sproutcore 1.0.1049.pre.2 → 1.4.0.rc

data/lib/frameworks/sproutcore/frameworks/runtime/private/observer_queue.js

@@ -40,7 +40,7 @@ SC.Observers = {
     var tuple ;
 
     // try to get the tuple for this.
-    if (SC.typeOf(propertyPath) === SC.T_STRING) {
+    if (typeof propertyPath === "string") {
       tuple = SC.tupleForPropertyPath(propertyPath, pathRoot) ;
     } else {
       tuple = propertyPath; 

data/lib/frameworks/sproutcore/frameworks/runtime/private/observer_set.js

@@ -12,7 +12,7 @@
 /**
   @namespace
 
-  This private class is used to store information about obversers on a 
+  This private class is used to store information about obversers on a
   particular key.  Note that this object is not observable.  You create new
   instances by calling SC.beget(SC.ObserverSet) ;
 
@@ -24,20 +24,20 @@ SC.ObserverSet = {
     the number of targets in the set.
   */
   targets: 0,
-  
+
   _membersCacheIsValid: NO,
-  
+
   /**
     Adds the named target/method observer to the set.  The method must be
     a function, not a string.
-    
+
     Note that in debugging mode only, this method is overridden to also record
     the name of the object and function that resulted in the target/method
     being added.
   */
   add: function(target, method, context) {
     var targetGuid = (target) ? SC.guidFor(target) : "__this__";
-    
+
     // get the set of methods
     var methods = this[targetGuid] ;
     if (!methods) {
@@ -47,32 +47,31 @@ SC.ObserverSet = {
       this.targets++ ;
     }
     methods.add(method) ;
-    
+
     // context is really useful sometimes but not used that often so this
     // implementation is intentionally lazy.
     if (context !== undefined) {
-      var contexts = methods.contexts ;
-      if (!contexts) contexts = methods.contexts = {} ;
-      contexts[SC.guidFor(method)] = context ;
+      if (!methods.contexts) context = methods.contexts = {} ;
+      methods.contexts[SC.guidFor(method)] = context ;
     }
-    
+
     this._membersCacheIsValid = NO ;
   },
-  
+
   /**
     removes the named target/method observer from the set.  If this is the
     last method for the named target, then the number of targets will also
     be reduced.
-  
+
     returns YES if the items was removed, NO if it was not found.
   */
   remove: function(target, method) {
     var targetGuid = (target) ? SC.guidFor(target) : "__this__";
-    
+
     // get the set of methods
-    var methods = this[targetGuid] ;    
+    var methods = this[targetGuid] ;
     if (!methods) return NO ;
-    
+
     methods.remove(method) ;
     if (methods.length <= 0) {
       methods.target = null;
@@ -80,23 +79,23 @@ SC.ObserverSet = {
       methods.contexts = null ;
       delete this[targetGuid] ;
       this.targets-- ;
-      
+
     } else if (methods.contexts) {
       delete methods.contexts[SC.guidFor(method)];
     }
 
     this._membersCacheIsValid = NO;
-    
+
     return YES ;
   },
-  
+
   /**
     Invokes the target/method pairs in the receiver.  Used by SC.RunLoop
     Note: does not support context
   */
   invokeMethods: function() {
     var key, value, idx, target, val;
-    
+
     // iterate through the set, look for sets.
     for(key in this) {
       if (!this.hasOwnProperty(key)) continue ;
@@ -111,13 +110,13 @@ SC.ObserverSet = {
       }
     }
   },
-  
+
   /**
     Returns an array of target/method pairs.  This is cached.
   */
   getMembers: function() {
     if (this._membersCacheIsValid) return this._members ;
-    
+
     // need to recache, reset the array...
     if (!this._members) {
       this._members = [] ;
@@ -131,7 +130,7 @@ SC.ObserverSet = {
       if (value && value.isTargetSet) {
         var idx = value.length;
         var target = value.target ;
-        
+
         // slightly slower - only do if we have contexts
         var contexts = value.contexts ;
         if (contexts) {
@@ -148,7 +147,7 @@ SC.ObserverSet = {
     this._membersCacheIsValid = YES ;
     return ret ;
   },
-  
+
   /**
     Returns a new instance of the set with the contents cloned.
   */
@@ -168,12 +167,12 @@ SC.ObserverSet = {
     ret._membersCacheIsValid = NO ;
     return ret ;
   },
-  
+
   /**
     Creates a new instance of the observer set.
   */
   create: function() { return SC.beget(this); }
-  
+
 } ;
 
 SC.ObserverSet.slice = SC.ObserverSet.clone ;

data/lib/frameworks/sproutcore/frameworks/runtime/system/binding.js

@@ -389,7 +389,8 @@ SC.Binding = {
     // contentBinding: "*owner.value"
     //
     path = this._fromPropertyPath; root = this._fromRoot ;
-    if (SC.typeOf(path) === SC.T_STRING) {
+    
+    if (typeof path === "string") {
       
       // if the first character is a '.', this is a static path.  make the 
       // toRoot the default root.
@@ -404,12 +405,14 @@ SC.Binding = {
         root = null ;
       }
     }
-    SC.Observers.addObserver(path, this, this.fromPropertyDidChange, root) ;
+    this._fromObserverData = [path, this, this.fromPropertyDidChange, root];
+    SC.Observers.addObserver.apply(SC.Observers, this._fromObserverData);
     
     // try to connect the to side
     if (!this._oneWay) {
       path = this._toPropertyPath; root = this._toRoot ;
-      SC.Observers.addObserver(path, this, this.toPropertyDidChange, root) ;  
+      this._toObserverData = [path, this, this.toPropertyDidChange, root];
+      SC.Observers.addObserver.apply(SC.Observers, this._toObserverData);
     }
 
     if (bench) SC.Benchmark.end("SC.Binding.connect()");
@@ -438,9 +441,9 @@ SC.Binding = {
       
     // connection is completed, disconnect.
     } else {
-      SC.Observers.removeObserver(this._fromPropertyPath, this, this.fromPropertyDidChange, (this._fromRoot || this._toRoot)) ;
+      SC.Observers.removeObserver.apply(SC.Observers, this._fromObserverData);
       if (!this._oneWay) {
-        SC.Observers.removeObserver(this._toPropertyPath, this, this.toPropertyDidChange, this._toRoot) ;
+        SC.Observers.removeObserver.apply(SC.Observers, this._toObserverData);
       }
     }
     
@@ -672,7 +675,7 @@ SC.Binding = {
       // toRoot as the root object.  Similar code exists in connect() so if 
       // you make a change to one be sure to update the other.
       path = this._fromPropertyPath; root = this._fromRoot ;
-      if (SC.typeOf(path) === SC.T_STRING) {
+      if (typeof path === "string") {
         
         // static path beginning with the toRoot
         if (path.indexOf('.') === 0) {

data/lib/frameworks/sproutcore/frameworks/runtime/system/object.js

@@ -7,6 +7,7 @@
 
 sc_require('core') ;
 sc_require('mixins/observable') ;
+sc_require('private/observer_queue');
 sc_require('mixins/array') ;
 sc_require('system/set');
 
@@ -89,7 +90,7 @@ SC._object_extend = function _object_extend(base, ext) {
     var value = (concats.hasOwnProperty(key) ? concats[key] : null) || ext[key] ;
 
     // Possibly add to a bindings.
-    if (key.slice(-7) === "Binding") {
+    if (key.length > 7 && key.slice(-7) === "Binding") {
       if (!clonedBindings) {
         bindings = (bindings || SC.EMPTY_ARRAY).slice() ;
         clonedBindings = YES ;
@@ -116,16 +117,20 @@ SC._object_extend = function _object_extend(base, ext) {
         observers[observers.length] = key ;
 
       // handle local properties
-      } else if (paths = value.localPropertyPaths) {
+      }
+      
+      if (paths = value.localPropertyPaths) {
         pathLoc = paths.length;
         while(--pathLoc >= 0) {
-          local = base._kvo_for(SC.keyFor('_kvo_local', paths[pathLoc]), SC.Set);
+          local = base._kvo_for(SC.keyFor('_kvo_local', paths[pathLoc]), SC.CoreSet);
           local.add(key);
           base._kvo_for('_kvo_observed_keys', SC.CoreSet).add(paths[pathLoc]);
         }
 
       // handle computed properties
-      } else if (value.dependentKeys) {
+      }
+      
+      if (value.dependentKeys) {
         if (!clonedProperties) {
           properties = (properties || SC.EMPTY_ARRAY).slice() ;
           clonedProperties = YES ;
@@ -133,7 +138,9 @@ SC._object_extend = function _object_extend(base, ext) {
         properties[properties.length] = key ;
 
       // handle outlets
-      } else if (value.autoconfiguredOutlet) {
+      }
+      
+      if (value.autoconfiguredOutlet) {
         if (!clonedOutlets) {
           outlets = (outlets || SC.EMPTY_ARRAY).slice();
           clonedOutlets = YES ;
@@ -544,7 +551,7 @@ SC.Object.prototype = {
     @returns {Boolean}
   */
   respondsTo: function( methodName ) {
-    return !!(SC.typeOf(this[methodName]) === SC.T_FUNCTION);
+    return !!(this[methodName] instanceof Function);
   },
   
   /**

data/lib/frameworks/sproutcore/frameworks/runtime/system/run_loop.js

@@ -123,7 +123,8 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     if (method === undefined) { 
       method = target; target = this ;
     }
-    if (SC.typeOf(method) === SC.T_STRING) method = target[method];
+    
+    if (typeof method === "string") method = target[method];
     if (!this._invokeQueue) this._invokeQueue = SC.ObserverSet.create();
     this._invokeQueue.add(target, method);
     return this ;
@@ -153,7 +154,8 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     if (method === undefined) { 
       method = target; target = this ;
     }
-    if (SC.typeOf(method) === SC.T_STRING) method = target[method];
+    
+    if (typeof method === "string") method = target[method];
     if (!this._invokeLastQueue) this._invokeLastQueue = SC.ObserverSet.create();
     this._invokeLastQueue.add(target, method);
     return this ;
@@ -257,13 +259,14 @@ SC.RunLoop.isRunLoopInProgress = function() {
 };
 
 /**
-  Helper method executes the passed function inside of a runloop.  Normally
-  not needed but useful for testing.
-  
+  Executes a passed function in the context of a run loop.
+
+  If an exception is thrown during execution, we give an error catcher the
+  opportunity to handle it before allowing the exception to bubble again.
+
   @param {Function} callback callback to execute
   @param {Object} target context for callback
   @param {Boolean} if YES, does not start/end a new runloop if one is already running
-  @returns {SC} receiver
 */
 SC.run = function(callback, target, useExistingRunLoop) {
   if(useExistingRunLoop) {
@@ -272,9 +275,21 @@ SC.run = function(callback, target, useExistingRunLoop) {
     callback.call(target);
     if(!alreadyRunning) SC.RunLoop.end();
   } else {
-    SC.RunLoop.begin();
-    callback.call(target);
-    SC.RunLoop.end();
-  }
-};
+    try {
+      SC.RunLoop.begin();
+      if (callback) callback.call(target);
+      SC.RunLoop.end();
+    } catch (e) {
+      if (SC.ExceptionHandler) {
+        SC.ExceptionHandler.handleException(e);
+      }
 
+      // Now that we've handled the exception, throw it again so the browser
+      // can deal with it (and potentially use it for debugging).
+      // (We don't throw it in IE because the user will see two errors)
+      if (!SC.browser.msie) {
+        throw e;
+      }
+    }
+  }
+};

data/lib/frameworks/sproutcore/frameworks/runtime/system/set.js

@@ -29,13 +29,18 @@ sc_require('mixins/copyable');
   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.
+  
+  Whether or not property observing is enabled, sets offer very powerful
+  notifications of items being added and removed, through the 
+  `#js:addSetObserver` and `#js:removeSetObserver` methods; this can be
+  very useful, for instance, for filtering or mapping sets.
 
   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
+  limited key-value observing support, but it does not extend from SC.Object
   so you should not subclass it.
 
-  h1. Creating a Set
-
+  Creating a Set
+  --------------
   You can create a set like you would most objects using SC.Set.create().  
   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 
@@ -44,23 +49,22 @@ sc_require('mixins/copyable');
   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"]) ;
+      #js
+      // creates a new empty set
+      var foundNames = SC.Set.create();
 
-    // creates a copy of the names set.
-    var namesCopy = SC.Set.create(names);
+      // creates a set with four names in it.
+      var names = SC.Set.create(["Charles", "Tom", "Juan", "Alex"]) ; // :P
 
-    // same as above.
-    var anotherNamesCopy = names.clone();
-  }}}
+      // creates a copy of the names set.
+      var namesCopy = SC.Set.create(names);
 
-  h1. Adding/Removing Objects
+      // same as above.
+      var anotherNamesCopy = names.clone();
 
-  You generally add or removed objects from a set using add() or remove().
+  Adding/Removing Objects
+  -----------------------
+  You generally add or remove objects from a set using add() or remove().
   You can add any type of object including primitives such as numbers,
   strings, and booleans.
 
@@ -78,12 +82,38 @@ sc_require('mixins/copyable');
   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
-
+  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
+  object's guid; however, if you implement the hash() method on the object, it will
   use the return value from that method instead.
+  
+  Observing changes
+  -----------------
+  When using `#js:SC.Set` (rather than `#js:SC.CoreSet`), you can observe the
+  `#js:"[]"` property to be alerted whenever the content changes.
+  
+  This is often unhelpful. If you are filtering sets of objects, for instance,
+  it is very inefficient to re-filter all of the items each time the set changes.
+  It would be better if you could just adjust the filtered set based on what
+  was changed on the original set. The same issue applies to merging sets,
+  as well.
+  
+  `#js:SC.Set` and `#js:SC.CoreSet` both offer another method of being observed:
+  `#js:addSetObserver` and `#js:removeSetObserver`. These take a single parameter:
+  an object which implements `#js:didAddItem(set, item)` and 
+  `#js:didRemoveItem(set, item)`.
+  
+  Whenever an item is added or removed from the set, all objects in the set
+  (a SC.CoreSet, actually) of observing objects will be alerted appropriately.
+  
+  BIG WARNING
+  ===========
+  SetObservers are not intended to be used "_creatively_"; for instance, do 
+  not expect to be alerted immediately to any changes. **While the notifications
+  are currently sent out immediately, if we find a fast way to send them at end
+  of run loop, we most likely will do so.**
 
   @extends SC.Enumerable 
   @extends SC.Observable
@@ -204,6 +234,36 @@ SC.Set = SC.mixin({},
     
     return YES;
   },
+  
+  /**
+    Adds a set observers. Set observers must implement two methods:
+    
+    - didAddItem(set, item)
+    - didRemoveItem(set, item)
+    
+    Set observers are, in fact, stored in another set (a CoreSet).
+  */
+  addSetObserver: function(setObserver) {
+    // create set observer set if needed
+    if (!this.setObservers) {
+      this.setObservers = SC.CoreSet.create();
+    }
+    
+    // add
+    this.setObservers.add(setObserver);
+  },
+  
+  /**
+    Removes a set observer.
+  */
+  removeSetObserver: function(setObserver) {
+    // if there is no set, there can be no currently observing set observers
+    if (!this.setObservers) return;
+    
+    // remove the set observer. Pretty simple, if you think about it. I mean,
+    // honestly.
+    this.setObservers.remove(setObserver);
+  },
 
   /**
     Call this method to add an object. performs a basic add.
@@ -219,13 +279,18 @@ SC.Set = SC.mixin({},
     // cannot add null to a set.
     if (obj===null || obj===undefined) return this; 
 
-    var guid = SC.hashFor(obj) ;
-    var idx = this[guid] ;
-    var len = this.length ;
-    if ((idx===null || idx===undefined) || (idx >= len) || (this[idx]!==obj)){
-      this[len] = obj ;
-      this[guid] = len ;
+    // Implementation note:  SC.hashFor() is inlined because sets are
+    // fundamental in SproutCore, and the inlined code is ~ 25% faster than
+    // calling SC.hashFor() in IE8.
+    var hashFunc,
+        guid = (obj && (hashFunc = obj.hash) && (typeof hashFunc === SC.T_FUNCTION)) ? hashFunc.call(obj) : SC.guidFor(obj),
+        idx  = this[guid],
+        len  = this.length;
+    if ((idx===null || idx===undefined) || (idx >= len) || (this[idx]!==obj)) {
+      this[len] = obj;
+      this[guid] = len;
       this.length = len+1;
+      if (this.setObservers) this.didAddItem(obj);
     }
     
     if (this.isObservable) this.enumerableContentDidChange();
@@ -271,27 +336,37 @@ SC.Set = SC.mixin({},
   remove: function(obj) {
     if (this.isFrozen) throw SC.FROZEN_ERROR;
 
-    if (SC.none(obj)) return this ;
-    var guid = SC.hashFor(obj);
-    var idx = this[guid] ;
-    var len = this.length;
+    // Implementation note:  SC.none() and SC.hashFor() are inlined because
+    // sets are fundamental in SproutCore, and the inlined code is ~ 25%
+    // faster than calling them "normally" in IE8.
+    if (obj === null || obj === undefined) return this ;
+
+    var hashFunc,
+        guid = (obj && (hashFunc = obj.hash) && (typeof hashFunc === SC.T_FUNCTION)) ? hashFunc.call(obj) : SC.guidFor(obj),
+        idx  = this[guid],
+        len  = this.length;
 
     // not in set.
-    if (SC.none(idx) || (idx >= len) || (this[idx] !== obj)) return this; 
+    // (SC.none is inlined for the reasons given above)
+    if ((idx === null || idx === undefined) || (idx >= len) || (this[idx] !== obj)) return this; 
 
     // clear the guid key
-    delete this[guid] ;
+    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)) {
-      obj = this[idx] = this[len-1];
-      this[SC.hashFor(obj)] = idx ;
+      // we need to keep a reference to "obj" so we can alert others below;
+      // so, no changing it. Instead, create a temporary variable.
+      tmp = this[idx] = this[len-1];
+      guid = (tmp && (hashFunc = tmp.hash) && (typeof hashFunc === SC.T_FUNCTION)) ? hashFunc.call(tmp) : SC.guidFor(tmp);
+      this[guid] = idx;
     }
 
     // reduce the length
     this.length = len-1;
     if (this.isObservable) this.enumerableContentDidChange();
+    if (this.setObservers) this.didRemoveItem(obj);
     return this ;
   },
 
@@ -372,6 +447,38 @@ SC.Set = SC.mixin({},
     return "SC.Set<%@>".fmt(ary.join(',')) ;
   },
   
+  /**
+    @private
+    Alerts set observers that an item has been added.
+  */
+  didAddItem: function(item) {
+    // get the set observers
+    var o = this.setObservers;
+    
+    // return if there aren't any
+    if (!o) return;
+    
+    // loop through and call didAddItem.
+    var len = o.length, idx;
+    for (idx = 0; idx < len; idx++) o[idx].didAddItem(this, item);
+  },
+  
+  /**
+    @private
+    Alerts set observers that an item has been removed.
+  */
+  didRemoveItem: function(item) {
+    // get the set observers
+    var o = this.setObservers;
+    
+    // return if there aren't any
+    if (!o) return;
+    
+    // loop through and call didAddItem.
+    var len = o.length, idx;
+    for (idx = 0; idx < len; idx++) o[idx].didRemoveItem(this, item);
+  },
+  
   // the pool used for non-observable sets
   _pool: [],