sproutcore 0.9.14 → 0.9.15

data/frameworks/sproutcore/foundation/benchmark.js

@@ -81,7 +81,7 @@ SC.Benchmark = {
     @param key {String} The benchmark key you used when you called start()
     @param time {Integer} Only pass if you want to explicitly set the end time.  Otherwise start time is now.
   */
-  end: function(key, time) {
+  end: function(key, time, runs) {
     if (!this.enabled) return ;
     var stat = this._statFor(key) ;
     var start = stat._starts.pop() ;
@@ -94,7 +94,7 @@ SC.Benchmark = {
     if (start == 'ignore') return ; 
     
     stat.amt += (time || Date.now()) - start ;
-    stat.runs++ ;
+    stat.runs += (runs || 1) ;
     
     if (this.verbose) this.log(key) ;
   },
@@ -104,16 +104,17 @@ SC.Benchmark = {
     run with the name you provide the number of times you indicate.  Only the
     function is a required param.
   */  
-  bench: function(func, key, reps) {
+  bench: function(func, key, reps, context) {
     if (!key) key = "bench%@".fmt(this._benchCount++) ;
     if (!reps) reps = 1 ;
     var ret ;
     
+    var runs = reps; 
+    SC.Benchmark.start(key) ;
     while(--reps >= 0) {
-      SC.Benchmark.start(key) ;
-      ret = func();
-      SC.Benchmark.end(key) ; 
+      ret = func(context);
     }
+    SC.Benchmark.end(key, null, runs) ; 
     
     return ret ;
   },
@@ -129,7 +130,7 @@ SC.Benchmark = {
     
     // replace with this helper.
     object[method] = function() {
-      var key = '%@(%@)'.fmt(method, $A(arguments).join(', ')) ;
+      var key = '%@(%@)'.fmt(method, SC.$A(arguments).join(', ')) ;
       SC.Benchmark.start(key, topLevelOnly) ;
       var ret = __func.apply(this, arguments) ;
       SC.Benchmark.end(key) ;
@@ -156,9 +157,24 @@ SC.Benchmark = {
   report: function(key) {
     if (key) return this._genReport(key) ;
     var ret = [] ;
+    
+    // find the longest stat name...
+    var maxLen = 0 ;
+    for(var key in this.stats) {
+      if (!this.stats.hasOwnProperty(key)) continue ;
+      if (key.length > maxLen) maxLen = key.length;
+    }
+    
+    // now gen report...
+    var keys = [] ;
     for(var key in this.stats) {
       if (!this.stats.hasOwnProperty(key)) continue ;
-      ret.push(this._genReport(key)) ;
+      keys.push(key) ;
+    }
+    keys = keys.sort() ;
+    var max = keys.length ;
+    for(var idx=0;idx<max;idx++) {
+      ret.push(this._genReport(keys[idx], maxLen)) ;
     }
     return ret.join("\n") ;
   },
@@ -187,11 +203,21 @@ SC.Benchmark = {
   
   // PRIVATE METHODS
   
-  _genReport: function(key) {
+  _genReport: function(key, nameLength) {
     var stat = this._statFor(key) ;
-    var avg = (stat.runs > 0) ? (Math.floor(stat.amt * 1000 / stat.runs) / 1000) : 0 ;
+    var avg = (stat.runs > 0) ? (Math.floor(stat.amt * 100000 / stat.runs) / 100000) : 0 ;
      
-    return 'BENCH %@ msec: %@ (%@x)'.fmt(avg, (stat.name || key), stat.runs) ;  
+    // Generate the name, adding padding spaces if needed.
+    var name = (stat.name || key)  ;
+    nameLength = (nameLength) ? nameLength : 0; 
+    if (nameLength > name.length) {
+      var toJoin = [name] ;
+      nameLength -= name.length ;
+      while(--nameLength >= 0) toJoin.push(' ') ;
+      name = toJoin.join('') ;
+    }
+    
+    return 'BENCH | %@1 | avg: %@4 msec | total: %@2 msec | reps: %@3x '.fmt(name, stat.amt, stat.runs, avg) ;  
   },
   
   // @private

data/frameworks/sproutcore/foundation/date.js

@@ -290,7 +290,7 @@ Object.extend(Date,{
 Object.extend(Date.prototype, {
   
   // ------------------------------------------------------------------
-  // formatDate (date_object, format, naturalLanguage)
+  // formatDate (date_object, format)
   // Returns a date in the output format specified.
   // The format string uses the same abbreviations as in getDateFromFormat()
   // 

data/frameworks/sproutcore/foundation/enumerator.js

@@ -0,0 +1,105 @@
+// ==========================================================================
+// SproutCore -- JavaScript Application Framework
+// copyright 2006-2008, Sprout Systems, Inc. and contributors.
+// ==========================================================================
+
+/**
+  @class
+  
+  An object that iterates over all of the values in an object.  
+  
+  An instance of this object is returned everytime you call the 
+  enumerator() method on an object that implements the SC.Enumerable mixin.
+  
+  Once you create an enumerator instance, you can call nextObject() on it
+  until you can iterated through the entire collection.  Once you have
+  exhausted the enumerator, you can reuse it if you want by calling reset().
+  
+  @extends Object
+  @since SproutCore 1.0
+*/
+SC.Enumerator = function(enumerableObject) {
+  this.enumerable = enumerableObject ;
+  this.reset() ;
+  return this ;
+} ;
+
+SC.Enumerator.prototype = {
+  
+  /** 
+    Returns the next object in the enumeration or undefined when complete.
+    
+    @returns {Object} the next object or undefined
+  */
+  nextObject: function() {
+    var index = this._index ;
+    var len = this._length;
+    if (index >= len) return undefined ; // nothing to do
+    
+    // get the value
+    var ret = this.enumerable.nextObject(index, this._previousObject, this._context) ;
+    this._previousObject = ret ;
+    this._index = index + 1 ;
+    
+    if (index >= len) {
+      this._context = SC.Enumerator._pushContext(this._context); 
+    }
+    
+    return ret ;
+  },
+  
+  /**
+    Resets the enumerator to the beginning.  This is a nice way to reuse
+    an existing enumerator. 
+    
+    @returns {Object} this
+  */
+  reset: function() {
+    var e = this.enumerable ;
+    if (!e) throw $error("Enumerator has been destroyed");
+    
+    var len = this._length = (e.get) ? e.get('length') : e.length ;
+    this._index = 0;
+    this._previousObject = null ;
+    this._context = (len > 0) ? SC.Enumerator._popContext() : null;
+  },
+  
+  /**
+    Releases the enumerators enumerable object.  You cannot use this object
+    anymore.  This is not often needed but it is useful when you need to 
+    make sure memory gets cleared.
+    
+    @returns {Object} null 
+  */
+  destroy: function() {
+    this.enumerable = this._length = this._index = this._previousObject = this._context = null;
+  }
+  
+} ;
+
+/**
+  Use this method to manually create a new Enumerator object.  Usually you
+  will not access this method directly but instead call enumerator() on the
+  item you want to enumerate.
+
+  @param {SC.Enumerable}  The enumerable object.
+  @returns {SC.Enumerator} the enumerator
+*/
+SC.Enumerator.create = function(enumerableObject) {
+  return new SC.Enumerator(enumerableObject) ;
+};
+
+// Private context caching methods.  This avoids recreating lots of context
+// objects.
+
+SC.Enumerator._popContext = function() {
+  var ret = (this._contextCache) ? this._contextCache.pop() : null ;
+  return ret || {} ;
+} ;
+
+SC.Enumerator._pushContext = function(context) {
+  var cache = this._contextCache = this._contextCache || [] ;
+  cache.push(context);
+  return null ;
+}; 
+

data/frameworks/sproutcore/foundation/object.js

@@ -49,13 +49,12 @@ SC.BENCHMARK_OBJECTS = NO;
 
 */
 SC.Object = function(noinit) { 
-	if (noinit === SC.Object._noinit_) return ;
-	var ret = SC.Object._init.apply(this,$A(arguments)) ;
+	if (noinit === SC.Object._noinit_) return this ;
+	var ret = SC.Object._init.apply(this,SC.$A(arguments)) ;
   return ret ;
 };
 
-Object.extend(SC.Object, 
-/** @scope SC.Object */ {
+SC.mixin(SC.Object, /** @scope SC.Object */ {
 
 	_noinit_: '__noinit__',
 	
@@ -66,7 +65,7 @@ Object.extend(SC.Object,
     @returns {void}
   */
   mixin: function(props) {
-    var ext = $A(arguments) ;
+    var ext = SC.$A(arguments) ;
     for(var loc=0;loc<ext.length;loc++) {
       Object.extend(this,ext[loc]);
     }
@@ -86,8 +85,8 @@ Object.extend(SC.Object,
      
     // build function.  copy class methods on to it.
     var ret = function(noinit) { 
-      if (noinit && (typeof(noinit) == 'string') && (noinit == SC.Object._noinit_)) return ;
-      var ret = SC.Object._init.apply(this,$A(arguments)); 
+      if (noinit && (typeof(noinit) == 'string') && (noinit == SC.Object._noinit_)) return this ;
+      var ret = SC.Object._init.apply(this,SC.$A(arguments)); 
       return ret ;
     };
     for(var prop in this) { ret[prop] = this[prop]; }
@@ -96,16 +95,16 @@ Object.extend(SC.Object,
     var base = new this(SC.Object._noinit_) ;
 
 //    var base = SC.Object._extend({},this.prototype) ;
-    var extensions = $A(arguments) ;
+    var extensions = SC.$A(arguments) ;
     for(var loc=0;loc<extensions.length;loc++) {
       base = SC.Object._extend(base, extensions[loc]);
     }
     ret.prototype = base ;
     
     // return new extension
-    ret._guid = SC._nextGUID++ ; // each time we extend, get a new guid.
+    ret._guid = SC.generateGuid() ; // each time we extend we get a new guid
     ret._type = this ;
-    
+     
     if (SC.BENCHMARK_OBJECTS) SC.Benchmark.end('SC.Object.extend') ;
     
     return ret ;
@@ -129,7 +128,7 @@ Object.extend(SC.Object,
     @returns {SC.Object} new instance of the receiver class.
   */
   create: function(props) {
-    var ret = new this($A(arguments),this) ;
+    var ret = new this(SC.$A(arguments),this) ;
     return ret ;
   },
     
@@ -254,14 +253,14 @@ Object.extend(SC.Object,
   },
   
   objectForPropertyPath: function(path,root) {
-    var parts = (typeof(path) == "string") ? path.split('.') : path ;
+    var parts = ($type(path) === T_STRING) ? path.split('.') : path ;
     if (!root) root = window ;
-    var key = parts.shift() ;
-    while(key && root) { 
-      root = (root.get) ? root.get(key) : root[key]; 
-      key = parts.shift(); 
+    var loc = 0, max = parts.length, key = null;
+    while((loc < max) && (root)) {
+      key = parts[loc++];
+      if (key) root = (root.get) ? root.get(key) : root[key] ;
     }
-    return (parts.length > 0) ? undefined : root ;  
+    return (loc < max) ? undefined : root ;  
   },
   
   
@@ -274,7 +273,7 @@ Object.extend(SC.Object,
     for(var loc=0;loc<extensions.length;loc++) {
       ret = SC.Object._extend(ret,extensions[loc]) ;
     }
-    ret._guid = SC._nextGUID++ ;
+    ret._guid = SC.generateGuid() ;
     ret._type = type ;
     ret.init() ;
     
@@ -422,7 +421,7 @@ SC.Object.prototype = {
   {
     if ( !methodName ) return false;
     
-    var args = $A(arguments);
+    var args = SC.$A(arguments);
     var name = args.shift();
     if (this.respondsTo(name))
     {
@@ -734,7 +733,7 @@ SC.Object.prototype = {
     if (interval === undefined) interval = 1 ;
     var f = methodName ;
     if (arguments.length > 2) {
-      var args =$A(arguments).slice(2,arguments.length);
+      var args =SC.$A(arguments).slice(2,arguments.length);
       args.unshift(this);
       if ($type(f) === T_STRING) f = this[methodName] ;
       f = f.bind.apply(f, args) ;

data/frameworks/sproutcore/foundation/responder.js

@@ -168,7 +168,7 @@ SC.Responder = SC.Object.extend(
   doCommand: function(method)
   {
     var responder = this;
-    var args      = $A(arguments);
+    var args      = SC.$A(arguments);
     var method    = args.shift();
     var aliases   = this._commandAliases[method];
     var handled   = false;

data/frameworks/sproutcore/foundation/set.js

@@ -3,41 +3,116 @@
 // copyright 2006-2008, Sprout Systems, Inc. and contributors.
 // ==========================================================================
 
-require('mixins/array') ;
+require('mixins/enumerable') ;
+require('mixins/observable') ;
 
 /**
-  @class An unordered collection for keeping objects.
+  @class 
+  
+  An unordered collection of objects.
   
   A Set works a bit like an array except that its items are not ordered.  
-  You can create a set to efficiently test for membership for an object.
-
-  @extends SC.Object
+  You can create a set to efficiently test for membership for an object. You 
+  can also iterate through a set just like an array, even accessing objects
+  by index, however there is no gaurantee as to their order.
+  
+  Note that SC.Set is a primitive object, like an array.  It does implement
+  limited key-value observing support but it does not extend from SC.Object
+  so you should not subclass it.
+  
+  h1. Creating a Set
+  
+  You can create a set like you would most objects using SC.Set.create() or
+  new SC.Set().  Most new sets you create will be empty, but you can also
+  initialize the set with some content by passing an array or other enumerable
+  of objects to the constructor.
+  
+  Finally, you can pass in an existing set and the set will be copied.  You
+  can also create a copy of a set by calling SC.Set#clone().
+  
+  {{{
+    // creates a new empty set
+    var foundNames = SC.Set.create();
+    
+    // creates a set with four names in it.
+    var names = SC.Set.create(["Charles", "Peter", "Chris", "Erich"]) ;
 
-*/
-SC.Set = SC.Object.extend(SC.Array, 
-  /** @scope SC.Set.prototype */
-  {
+    // creates a copy of the names set.
+    var namesCopy = SC.Set.create(names);
+    
+    // same as above.
+    var anotherNamesCopy = names.clone();
+  }}}
   
-/**
+  h1. Adding/Removing Objects
+  
+  You generally add or removed objects from a set using add() or remove().
+  You can add any type of object including primitives such as numbers,
+  strings, and booleans.
+  
+  Note that objects can only exist one time in a set.  If you call add() on
+  a set with the same object multiple times, the object will only be added 
+  once.  Likewise, calling remove() with the same object multiple times will
+  remove the object the first time and have no effect on future calls until 
+  you add the object to the set again.
+  
+  Note that you cannot add/remove null or undefined to a set.  Any attempt to
+  do so will be ignored.  
+  
+  In addition to add/remove you can also call push()/pop().  Push behaves just
+  like add() but pop(), unlike remove() will pick an arbitrary object, remove
+  it and return it.  This is a good way to use a set as a job queue when you
+  don't care which order the jobs are executed in.
+  
+  h1. Testing for an Object
+  
+  To test for an object's presence in a set you simply call SC.Set#contains().
+  This method tests for the object's hash, which is generally the same as the
+  object's _guid but if you implement the hash() method on the object, it will
+  use the return value from that method instead.
+  
+  @extends Object
+  @extends SC.Enumerable 
+  @since SproutCore 0.9.15
+*/
+SC.Set = function(items) {
+  if (items && items.length > 0) {
+    var idx = (items.get) ? items.get('length') : items.length ;
+    if (items.objectAt) {
+      while(--idx >= 0) this.add(items.objectAt(idx)) ;
+    } else {
+      while(--idx >= 0) this.add(items[idx]) ;
+    }
+  }
+  return this ;
+} ;
+
+SC.Set.prototype = {
+    
+  /**
     This property will change as the number of objects in the set changes.
 
     @type number
-*/
+  */
   length: 0,
   
   /**
-    Changes each time an object is updated or removed. Observe this to be notified of changes to the set.
-  
-    @type number
+    Clears the set 
   */
-  revision: 0,
+  clear: function() { this.length = 0; },
   
   /**
     Call this method to test for membership.
   */
   contains: function(obj) {
-    if (obj === null) return false ;
-    return this[this._guidFor(obj)] === obj ;
+    
+    // because of the way a set is "reset", the guid for an object may 
+    // still be stored as a key, but points to an index that is beyond the
+    // length.  Therefore the found idx must both be defined and less than
+    // the current length.
+    if (obj === null) return NO ;
+    var idx = this[SC.hashFor(obj)] ;
+    return ((idx != null) && (idx < this.length)) ;
   },
   
   /**
@@ -46,70 +121,102 @@ SC.Set = SC.Object.extend(SC.Array,
     If the object is already in the set it will not be added again.
     
     @param obj {Object} the object to add
-    @returns {Boolean} YES if the object as added.
+    @returns {Object} this
   */
   add: function(obj) {
-    if (obj == null) return NO; // cannot add null to a set.
+    if (obj == null) return this; // cannot add null to a set.
     
-    var guid = this._guidFor(obj) ;
-    if (this[guid] == null) {
-      this[this._guidFor(obj)] = obj ;
-      this.incrementProperty('length') ;
-      this.incrementProperty('revision') ;
-      return YES ;
-    } else return NO ;
+    var guid = SC.hashFor(obj) ;
+    var idx = this[guid] ;
+    var len = this.length ;
+    if ((idx == null) || (idx >= len)) {
+      this[len] = obj ;
+      this[guid] = len ;
+      this.length = len+1;
+    }
+    return this ;
   },
   
+  /**
+    Add all the items in the passed array.
+  */
+  addEach: function(objects) {
+    var idx = objects.length ;
+    while(--idx >= 0) this.add(objects[idx]) ;
+  },  
+  
   /**
     Removes the object from the set if it is found.
     
     If the object is not in the set, nothing will be changed.
     
     @param obj {Object} the object to remove
-    @returns {Boolean} YES if the object was removed.
+    @returns {this} this
   */  
   remove: function(obj) {
-    if (obj == null) return NO ;
-    var guid = this._guidFor(obj);
-    if (this[guid] === obj) {
-      delete this[this._guidFor(obj)] ; 
-      this.decrementProperty('length') ;
-      this.incrementProperty('revision') ;
-      return YES ;
-    } else return NO;
+    
+    if (obj == null) return this ;
+    var guid = SC.hashFor(obj);
+    var idx = this[guid] ;
+    var len = this.length;
+    
+    if ((idx == null) || (idx >= len)) return this; // not in set.
+
+    // clear the guid key
+    delete this[guid] ;
+    
+    // to clear the index, we will swap the object stored in the last index.
+    // if this is the last object, just reduce the length.
+    if (idx < (len-1)) {
+      var obj = this[idx] = this[len-1];
+      this[SC.hashFor(obj)] = idx ;
+    }
+    
+    // reduce the length
+    this.length = len-1;
+    return this ;
+  },
+
+  /**
+    Removes an arbitrary object from the set and returns it.
+    
+    @returns {Object} an object from the set or null
+  */
+  pop: function() {
+    var obj = (this.length > 0) ? this[this.length-1] : null ;
+    if (obj) this.remove(obj) ;
+    return obj ;
   },
   
+  /**
+    Removes all the items in the passed array.
+  */
+  removeEach: function(objects) {
+    var idx = objects.length ;
+    while(--idx >= 0) this.remove(objects[idx]) ;
+  },  
+
   // .......................................
   // PRIVATE 
-  _guidFor: function(obj) {
-    return '@' + SC.guidFor(obj);
+  _each: function(iterator) {
+    var len = this.length ;
+    for(var idx=0;idx<len;idx++) iterator(this[idx]) ;
   },
   
-  _each: function(iterator) {
-    for (var key in this) {
-      if (!this.hasOwnProperty(key)) continue ;
-      if (key.match(/^@/)) iterator(this[key]) ;
-    }
+  toString: function() {
+    return "SC.Set<%@>".fmt(SC.SC.$A(this)) ;
   }
   
-}) ;
+} ;
+
+// Make this enumerable and observable
+SC.mixin(SC.Set.prototype, SC.Enumerable, SC.Observable) ;
 
-SC.Set.prototype.push = SC.Set.prototype.unshift = SC.Set.prototype.add;
-SC.Set.prototype.pop = SC.Set.prototype.shift = SC.Set.prototype.remove;
+SC.Set.prototype.push = SC.Set.prototype.unshift = SC.Set.prototype.add ;
+SC.Set.prototype.shift = SC.Set.prototype.pop ;
 
-SC.Set._create = SC.Set.create ;
 
 /**
   To create a set, pass an array of items instead of a hash.
 */
-SC.Set.create = function(items) {
-  if (!items) items = [] ;
-  var hash = {}, loc = items.length ;
-  while(--loc >= 0) {
-    var item = items[loc];
-    if (item == null) continue ;
-    hash[SC.Set.prototype._guidFor(item)] = item ;
-  }
-  hash.length = items.length ;
-  return SC.Set._create(hash) ;
-} ;
+SC.Set.create = function(items) { return new SC.Set(items); };