sproutcore 1.4.5-java → 1.5.0-java

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

@@ -1,12 +1,10 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-require('system/object');
-
 // ........................................................................
 // CHAIN OBSERVER
 //
@@ -14,7 +12,7 @@ require('system/object');
 // This is a private class used by the observable mixin to support chained
 // properties.
 
-// ChainObservers are used to automatically monitor a property several 
+// ChainObservers are used to automatically monitor a property several
 // layers deep.
 // org.plan.name = SC._ChainObserver.create({
 //    target: this, property: 'org',
@@ -26,8 +24,9 @@ require('system/object');
 //    })
 //  })
 //
-SC._ChainObserver = function(property) {
+SC._ChainObserver = function(property, root) {
   this.property = property ;
+  this.root = root || this ;
 } ;
 
 // This is the primary entry point.  Configures the chain.
@@ -36,81 +35,122 @@ SC._ChainObserver.createChain = function(rootObject, path, target, method, conte
   // First we create the chain.
   var parts = path.split('.'),
       root  = new SC._ChainObserver(parts[0]),
-      tail  = root,
-      len   = parts.length;
+      tail  = root;
 
-  for(var idx=1;idx<len;idx++) {
-    tail = tail.next = new SC._ChainObserver(parts[idx]) ;
+  for(var i=1, l=parts.length; i<l; i++) {
+    tail = tail.next = new SC._ChainObserver(parts[i], root) ;
   }
-  
+
+  var tails = root.tails = [tail];
+
   // Now root has the first observer and tail has the last one.
   // Feed the rootObject into the front to setup the chain...
   // do this BEFORE we set the target/method so they will not be triggered.
   root.objectDidChange(rootObject);
-  
-  // Finally, set the target/method on the tail so that future changes will
-  // trigger.
-  tail.target = target; tail.method = method ; tail.context = context ;
-  
+
+  tails.forEach(function(tail) {
+    // Finally, set the target/method on the tail so that future changes will
+    // trigger.
+    tail.target = target; tail.method = method ; tail.context = context ;
+  });
+
+  // no need to hold onto references to the tails; if the underlying
+  // objects go away, let them get garbage collected
+  root.tails = null;
+
   // and return the root to save
   return root ;
 };
 
 SC._ChainObserver.prototype = {
   isChainObserver: true,
-  
+
   // the object this instance is observing
   object: null,
-  
+
   // the property on the object this link is observing.
   property: null,
-  
-  // if not null, this is the next link in the chain.  Whenever the 
+
+  // if not null, this is the next link in the chain.  Whenever the
   // current property changes, the next observer will be notified.
   next: null,
-  
+
+  root: null,
+
   // if not null, this is the final target observer.
   target: null,
-  
+
   // if not null, this is the final target method
   method: null,
-  
-  // invoked when the source object changes.  removes observer on old 
+
+  // an accessor method that traverses the list and finds the tail
+  tail: function() {
+    if(this._tail) { return this._tail; }
+
+    var tail = this;
+
+    while(tail.next) {
+      tail = tail.next;
+    }
+
+    this._tail = tail;
+    return tail;
+  },
+
+  // invoked when the source object changes.  removes observer on old
   // object, sets up new observer, if needed.
   objectDidChange: function(newObject) {
     if (newObject === this.object) return; // nothing to do.
-    
+
     // if an old object, remove observer on it.
-    if (this.object && this.object.removeObserver) {
-      this.object.removeObserver(this.property, this, this.propertyDidChange);
+    if (this.object) {
+      if (this.property === '@each' && this.object._removeContentObserver) {
+        this.object._removeContentObserver(this);
+      } else if (this.object.removeObserver) {
+        this.object.removeObserver(this.property, this, this.propertyDidChange);
+      }
     }
-    
+
     // if a new object, add observer on it...
     this.object = newObject ;
-    if (this.object && this.object.addObserver) {
-      this.object.addObserver(this.property, this, this.propertyDidChange); 
+
+    // when [].propName is used, we will want to set up observers on each item
+    // added to the Enumerable, and remove them when the item is removed from
+    // the Enumerable.
+    //
+    // In this case, we invoke addEnumerableObserver, which handles setting up
+    // and tearing down observers as items are added and removed from the
+    // Enumerable.
+    if (this.property === '@each' && this.next) {
+      if (this.object && this.object._addContentObserver) {
+        this.object._addContentObserver(this);
+      }
+    } else {
+      if (this.object && this.object.addObserver) {
+        this.object.addObserver(this.property, this, this.propertyDidChange);
+      }
+
+      // now, notify myself that my property value has probably changed.
+      this.propertyDidChange() ;
     }
-    
-    // now, notify myself that my property value has probably changed.
-    this.propertyDidChange() ;
   },
-  
+
   // the observer method invoked when the observed property changes.
   propertyDidChange: function() {
-    
     // get the new value
     var object = this.object ;
     var property = this.property ;
     var value = (object && object.get) ? object.get(property) : null ;
-    
-    // if we have a next object in the chain, notify it that its object 
+
+    // if we have a next object in the chain, notify it that its object
     // did change...
-    if (this.next) this.next.objectDidChange(value) ;
-    
+    if (this.next) { this.next.objectDidChange(value) ; }
+
     // if we have a target/method, call it.
     var target  = this.target,
         method  = this.method,
         context = this.context ;
+
     if (target && method) {
       var rev = object ? object.propertyRevision : null ;
       if (context) {
@@ -118,24 +158,24 @@ SC._ChainObserver.prototype = {
       } else {
         method.call(target, object, property, value, rev) ;
       }
-    } 
+    }
   },
-  
+
   // teardown the chain...
   destroyChain: function() {
-    
+
     // remove observer
     var obj = this.object ;
     if (obj && obj.removeObserver) {
       obj.removeObserver(this.property, this, this.propertyDidChange) ;
-    }  
-    
+    }
+
     // destroy next item in chain
     if (this.next) this.next.destroyChain() ;
-    
+
     // and clear left overs...
     this.next = this.target = this.method = this.object = this.context = null;
     return null ;
   }
-  
+
 } ;

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
@@ -12,27 +12,28 @@ sc_require('system/set');
 // OBSERVER QUEUE
 //
 // This queue is used to hold observers when the object you tried to observe
-// does not exist yet.  This queue is flushed just before any property 
+// does not exist yet.  This queue is flushed just before any property
 // notification is sent.
 
 /**
-  @namespace 
-  
-  The private ObserverQueue is used to maintain a set of pending observers. 
+  @namespace
+
+  The private ObserverQueue is used to maintain a set of pending observers.
   This allows you to setup an observer on an object before the object exists.
-  
-  Whenever the observer fires, the queue will be flushed to connect any 
+
+  Whenever the observer fires, the queue will be flushed to connect any
   pending observers.
-  
+
+  @private
   @since SproutCore 1.0
 */
 SC.Observers = {
 
   queue: [],
-  
+
   /**
-   @private 
-  
+   @private
+
    Attempt to add the named observer.  If the observer cannot be found, put
    it into a queue for later.
   */
@@ -43,32 +44,32 @@ SC.Observers = {
     if (typeof propertyPath === "string") {
       tuple = SC.tupleForPropertyPath(propertyPath, pathRoot) ;
     } else {
-      tuple = propertyPath; 
+      tuple = propertyPath;
     }
 
-    // if a tuple was found, add the observer immediately...
-    if (tuple) {
+    // if a tuple was found and is observable, add the observer immediately...
+    if (tuple && tuple[0].addObserver) {
       tuple[0].addObserver(tuple[1],target, method) ;
-      
+
     // otherwise, save this in the queue.
     } else {
       this.queue.push([propertyPath, target, method, pathRoot]) ;
     }
   },
 
-  /** 
-    @private 
-  
+  /**
+    @private
+
     Remove the observer.  If it is already in the queue, remove it.  Also
     if already found on the object, remove that.
   */
   removeObserver: function(propertyPath, target, method, pathRoot) {
     var idx, queue, tuple, item;
-    
+
     tuple = SC.tupleForPropertyPath(propertyPath, pathRoot) ;
     if (tuple) {
       tuple[0].removeObserver(tuple[1], target, method) ;
-    } 
+    }
 
     idx = this.queue.length; queue = this.queue ;
     while(--idx >= 0) {
@@ -76,11 +77,11 @@ SC.Observers = {
       if ((item[0] === propertyPath) && (item[1] === target) && (item[2] == method) && (item[3] === pathRoot)) queue[idx] = null ;
     }
   },
-  
+
   /**
-    @private 
-    
-    Range Observers register here to indicate that they may potentially 
+    @private
+
+    Range Observers register here to indicate that they may potentially
     need to start observing.
   */
   addPendingRangeObserver: function(observer) {
@@ -89,53 +90,58 @@ SC.Observers = {
     ro.add(observer);
     return this ;
   },
-  
+
   _TMP_OUT: [],
-  
-  /** 
+
+  /**
     Flush the queue.  Attempt to add any saved observers.
   */
-  flush: function(object) { 
-       
+  flush: function(object) {
+
     // flush any observers that we tried to setup but didn't have a path yet
-    var oldQueue = this.queue ;
-    if (oldQueue && oldQueue.length > 0) {
-      var newQueue = (this.queue = []) ; 
-      var idx = oldQueue.length ;
-      while(--idx >= 0) {
-        var item = oldQueue[idx] ;
-        if (!item) continue ;
-
-        var tuple = SC.tupleForPropertyPath(item[0], item[3]);
-        if (tuple) {
-          tuple[0].addObserver(tuple[1], item[1], item[2]) ;
-        } else newQueue.push(item) ;
+    var oldQueue = this.queue, i,
+        queueLen = oldQueue.length;
+    
+    if (oldQueue && queueLen > 0) {
+      var newQueue = (this.queue = []) ;
+
+      for (i=0; i<queueLen; i++ ) {
+        var item = oldQueue[i];
+        if ( !item ) continue;
+        
+        var tuple = SC.tupleForPropertyPath( item[0], item[3] );
+        // check if object is observable (yet) before adding an observer
+        if( tuple && tuple[0].addObserver ) {
+          tuple[0].addObserver( tuple[1], item[1], item[2] );
+        } else {
+          newQueue.push( item );
+        }
       }
     }
     
-    // if this object needsRangeObserver then see if any pending range 
+    // if this object needsRangeObserver then see if any pending range
     // observers need it.
-    if (object._kvo_needsRangeObserver) {
+    if ( object._kvo_needsRangeObserver ) {
       var set = this.rangeObservers,
           len = set ? set.get('length') : 0,
           out = this._TMP_OUT,
           ro;
-          
-      for(idx=0;idx<len;idx++) {
-        ro = set[idx]; // get the range observer
-        if (ro.setupPending(object)) {
+
+      for ( i=0; i<len; i++ ) {
+        ro = set[i]; // get the range observer
+        if ( ro.setupPending(object) ) {
           out.push(ro); // save to remove later
         }
       }
-      
+
       // remove any that have setup
-      if (out.length > 0) set.removeEach(out);
+      if ( out.length > 0 ) set.removeEach(out);
       out.length = 0; // reset
-      object._kvo_needsRangeObserver = NO ;
+      object._kvo_needsRangeObserver = false ;
     }
-    
+
   },
-  
+
   /** @private */
   isObservingSuspended: 0,
 
@@ -151,7 +157,7 @@ SC.Observers = {
   suspendPropertyObserving: function() {
     this.isObservingSuspended++ ;
   },
-  
+
   // resume change notifications.  This will call notifications to be
   // delivered for all pending objects.
   /** @private */
@@ -160,7 +166,7 @@ SC.Observers = {
     if(--this.isObservingSuspended <= 0) {
       pending = this._pending ;
       this._pending = SC.CoreSet.create() ;
-      
+
       var idx, len = pending.length;
       for(idx=0;idx<len;idx++) {
         pending[idx]._notifyPropertyObservers() ;
@@ -169,5 +175,5 @@ SC.Observers = {
       pending = null ;
     }
   }
-  
+
 } ;

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
@@ -16,17 +16,11 @@
   particular key.  Note that this object is not observable.  You create new
   instances by calling SC.beget(SC.ObserverSet) ;
 
+  @private
   @since SproutCore 1.0
 */
 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.
@@ -36,26 +30,17 @@ SC.ObserverSet = {
     being added.
   */
   add: function(target, method, context) {
-    var targetGuid = (target) ? SC.guidFor(target) : "__this__";
+    var targetGuid = SC.guidFor(target), methodGuid = SC.guidFor(method);
+    var targets = this._members, members = this.members;
 
     // get the set of methods
-    var methods = this[targetGuid] ;
-    if (!methods) {
-      methods = this[targetGuid] = SC.CoreSet.create() ;
-      methods.target = target ;
-      methods.isTargetSet = YES ; // used for getMembers().
-      this.targets++ ;
-    }
-    methods.add(method) ;
+    var indexes = targets[targetGuid];
+    if ( !indexes ) indexes = targets[targetGuid] = {};
 
-    // context is really useful sometimes but not used that often so this
-    // implementation is intentionally lazy.
-    if (context !== undefined) {
-      if (!methods.contexts) methods.contexts = {} ;
-      methods.contexts[SC.guidFor(method)] = context ;
-    }
+    if (indexes[methodGuid] === undefined) indexes[methodGuid] = members.length;
+    else return;
 
-    this._membersCacheIsValid = NO ;
+    members.push([target, method, context]);
   },
 
   /**
@@ -66,27 +51,23 @@ SC.ObserverSet = {
     returns YES if the items was removed, NO if it was not found.
   */
   remove: function(target, method) {
-    var targetGuid = (target) ? SC.guidFor(target) : "__this__";
+    var targetGuid = SC.guidFor(target), methodGuid = SC.guidFor(method);
+    var indexes = this._members[targetGuid], members = this.members;
 
-    // get the set of methods
-    var methods = this[targetGuid] ;
-    if (!methods) return NO ;
-
-    methods.remove(method) ;
-    if (methods.length <= 0) {
-      methods.target = null;
-      methods.isTargetSet = NO ;
-      methods.contexts = null ;
-      delete this[targetGuid] ;
-      this.targets-- ;
-
-    } else if (methods.contexts) {
-      delete methods.contexts[SC.guidFor(method)];
+    if( !indexes ) return false;
+
+    var index = indexes[methodGuid];
+    if ( index === undefined) return false;
+
+    if (index !== members.length - 1) {
+      var entry = (members[index] = members[members.length - 1]);
+      this._members[SC.guidFor(entry[0])][SC.guidFor(entry[1])] = index;
     }
 
-    this._membersCacheIsValid = NO;
+    members.pop();
+    delete this._members[targetGuid][methodGuid];
 
-    return YES ;
+    return true;
   },
 
   /**
@@ -94,87 +75,50 @@ SC.ObserverSet = {
     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 ;
-      value = this[key] ;
-      if (value && value.isTargetSet) {
-        idx = value.length;
-        target = value.target ;
-        while(--idx>=0) {
-          val = value[idx];
-          if(val) val.call(target);
-        }
-      }
-    }
-  },
+    var members = this.members, member;
 
-  /**
-    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 = [] ;
-    } else this._members.length = 0 ; // reset
-    var ret = this._members ;
-
-    // iterate through the set, look for sets.
-    for(var key in this) {
-      if (!this.hasOwnProperty(key)) continue ;
-      var value = this[key] ;
-      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) {
-          while(--idx>=0) {
-            var method = value[idx] ;
-            ret.push([target, method, contexts[SC.guidFor(method)]]) ;
-          }
-        } else {
-          while(--idx>=0) ret.push([target, value[idx]]);
-        }
-      }
-    }
+    for( var i=0, l=members.length; i<l; i++ ) {
+      member = members[i];
 
-    this._membersCacheIsValid = YES ;
-    return ret ;
+      // method.call(target);
+      member[1].call(member[0]);
+    }
   },
 
   /**
     Returns a new instance of the set with the contents cloned.
   */
   clone: function() {
-    var oldSet, newSet, key, ret = SC.ObserverSet.create() ;
-    for(key in this) {
-      if (!this.hasOwnProperty(key)) continue ;
-      oldSet = this[key];
-      if (oldSet && oldSet.isTargetSet) {
-        newSet = oldSet.clone();
-        newSet.target = oldSet.target ;
-        if (oldSet.contexts) newSet.contexts = SC.clone(oldSet.contexts);
-        ret[key] = newSet ;
-      }
+    var newSet = SC.ObserverSet.create(), memberArray = this.members;
+
+    newSet._members = SC.clone(this._members);
+    var newMembers = newSet.members;
+
+    for( var i=0, l=memberArray.length; i<l; i++ ) {
+      newMembers[i] = SC.clone(memberArray[i]);
+      newMembers[i].length = 3;
     }
-    ret.targets = this.targets ;
-    ret._membersCacheIsValid = NO ;
-    return ret ;
+
+    return newSet;
   },
 
   /**
     Creates a new instance of the observer set.
   */
-  create: function() { return SC.beget(this); }
+  create: function() {
+    return new SC.ObserverSet.constructor();
+  },
 
-} ;
+  getMembers: function() {
+    return this.members.slice(0);
+  },
 
-SC.ObserverSet.slice = SC.ObserverSet.clone ;
+  constructor: function() {
+    this._members = {};
+    this.members = [];
+  }
 
+} ;
+SC.ObserverSet.constructor.prototype = SC.ObserverSet;
+SC.ObserverSet.slice = SC.ObserverSet.clone ;