Gives Enyo the ability to generate functions that can only be executed ONE time, regardless of how many times it is called.

enyo.Once.js

(function(enyo, scope){
    
    /**
    * _enyo.Once_ returns a function that will only be executed one time no matter
    * how many times it was called.
    *
    * borrowed from underscore
    * 
    * @class  enyo.Once
    * @public
    */
    
    //shortcuts
    var ArrayProto = Array.prototype;
    var slice = ArrayProto.slice;
    
    /**
    * returns a function that will be executed before N times.
    *
    * @method
    * @type {Function}
    * @private
    */
    var before = function(times, func) {
        var memo;
        return function() {
          if (--times > 0) {
            memo = func.apply(this, arguments);
          }
          else func = null;
          return memo;
        };
    };
    
    /**
    * returns a partially applied function, without changing it's 'this' context
    *
    * @method
    * @type {Function}
    * @private
    */
    var partial = function(func) {
        var boundArgs = slice.call(arguments, 1);
        return function() {
          var position = 0;
          var args = boundArgs.slice();
          for (var i = 0, length = args.length; i < length; i++) {
            if (args[i] === enyo) args[i] = arguments[position++];
          }
          while (position < arguments.length) args.push(arguments[position++]);
          return func.apply(this, args);
        };
     };
    
    /**
    * Returns a function that will only be executed once reguardless of how many times it is called.
    *
    * @method
    * @type {Function}
    * @public
    */
    enyo.Once = enyo.Once || partial(before, 2);

}(enyo, this))