sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/runtime/mixins/freezable.js

@@ -0,0 +1,104 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+
+/**
+  Standard Error that should be raised when you try to modify a frozen object.
+*/
+SC.FROZEN_ERROR = new Error("Cannot modify a frozen object");
+
+/** 
+  @namespace
+  
+  The SC.Freezable mixin implements some basic methods for marking an object
+  as frozen.  Once an object is frozen it should be read only.  No changes 
+  may be made the internal state of the object.
+  
+  h2. Enforcement
+
+  To fully support freezing in your subclass, you must include this mixin and
+  override any method that might alter any property on the object to instead
+  raise an exception.  You can check the state of an object by checking the
+  isFrozen property.
+
+  Although future versions of JavaScript may support language-level freezing
+  object objects, that is not the case today.  Even if an object is freezable,
+  it is still technically possible to modify the object, even though it could
+  break other parts of your application that do not expect a frozen object to
+  change.  It is, therefore, very important that you always respect the 
+  isFrozen property on all freezable objects.
+  
+  h2. Example
+
+  The example below shows a simple object that implement the SC.Freezable 
+  protocol.  
+  
+  {{{
+    Contact = SC.Object.extend(SC.Freezable, {
+      
+      firstName: null,
+      
+      lastName: null,
+      
+      // swaps the names
+      swapNames: function() {
+        if (this.get('isFrozen')) throw SC.FROZEN_ERROR;
+        var tmp = this.get('firstName');
+        this.set('firstName', this.get('lastName'));
+        this.set('lastName', tmp);
+        return this;
+      }
+      
+    });
+    
+    c = Context.create({ firstName: "John", lastName: "Doe" });
+    c.swapNames();  => returns c
+    c.freeze();
+    c.swapNames();  => EXCEPTION
+    
+  }}}
+  
+  h2. Copying
+  
+  Usually the SC.Freezable protocol is implemented in cooperation with the
+  SC.Copyable protocol, which defines a frozenCopy() method that will return
+  a frozen object, if the object implements this method as well.
+  
+*/
+SC.Freezable = {
+  
+  /**
+    Walk like a duck.
+  */
+  isFreezable: YES,
+  
+  /**
+    Set to YES when the object is frozen.  Use this property to detect whether
+    your object is frozen or not.
+  */
+  isFrozen: NO,
+  
+  /**
+    Freezes the object.  Once this method has been called the object should
+    no longer allow any properties to be edited.
+    
+    @returns {Object} reciever
+  */
+  freeze: function() {
+    // NOTE: Once someone actually implements Object.freeze() in the browser,
+    // add a call to that here also.
+    
+    if (this.set) this.set('isFrozen', YES);
+    else this.isFrozen = YES;
+    return this;
+  }
+    
+};
+
+
+// Add to Array
+SC.mixin(Array.prototype, SC.Freezable);

data/frameworks/sproutcore/frameworks/runtime/mixins/observable.js

@@ -9,6 +9,8 @@ require('private/observer_set') ;
 
 /*globals logChange */
 
+SC.LOG_OBSERVERS = NO ;
+
 /**
   @namespace 
   
@@ -135,6 +137,9 @@ require('private/observer_set') ;
 */
 SC.Observable = {
 
+  /** walk like that ol' duck */
+  isObservable: YES,
+  
   /**
     Determines whether observers should be automatically notified of changes
     to a key.
@@ -254,10 +259,31 @@ SC.Observable = {
     @returns {this}
   */
   set: function(key, value) {
-    var func = this[key], ret = value, dependents, cache, idx ;
-    
-    var notify = this.automaticallyNotifiesObserversFor(key) ;
-    
+    var func   = this[key], 
+        notify = this.automaticallyNotifiesObserversFor(key),
+        ret    = value, 
+        cachedep, cache, idx, dfunc ;
+
+    // if there are any dependent keys and they use caching, then clear the
+    // cache.
+    if (this._kvo_cacheable && (cache = this._kvo_cache)) {
+      // lookup the cached dependents for this key.  if undefined, compute.
+      // note that if cachdep is set to null is means we figure out it has no
+      // cached dependencies already.  this is different from undefined.
+      cachedep = this._kvo_cachedep;
+      if (!cachedep || (cachedep = cachedep[key])===undefined) {
+        cachedep = this._kvo_computeCachedDependentsFor(key);
+      }
+      
+      if (cachedep) {
+        idx = cachedep.length;
+        while(--idx>=0) {
+          dfunc = cachedep[idx];
+          cache[dfunc.cacheKey] = cache[dfunc.lastSetValueKey] = undefined;
+        }
+      }
+    }
+
     // set the value.
     if (func && func.isProperty) {
       cache = this._kvo_cache;
@@ -285,22 +311,7 @@ SC.Observable = {
         if (notify) this.propertyDidChange(key, ret) ;
       }
     }
-    
-    // if there are any dependent keys and they use caching, then clear the
-    // cache.
-    if (dependents = this._kvo_cachedDependents) {
-      dependents = this._kvo_cachedDependents[key] ;
-      if (dependents && dependents.length > 0) {
-        idx = dependents.length ;
-        if (cache = this._kvo_cache) {
-          while(--idx>=0) {
-            func = dependents[idx];
-            cache[func.cacheKey] = cache[func.lastSetValueKey] = undefined;
-          }
-        }
-      }
-    }
-    
+
     return this ;
   },
 
@@ -351,8 +362,8 @@ SC.Observable = {
   */
   endPropertyChanges: function() {
     this._kvo_changeLevel = (this._kvo_changeLevel || 1) - 1 ;
-    var level = this._kvo_changeLevel;
-    if ((level<=0) && this._kvo_changes && (this._kvo_changes.length>0)) {
+    var level = this._kvo_changeLevel, changes = this._kvo_changes;
+    if ((level<=0) && changes && (changes.length>0) && !SC.Observers.isObservingSuspended) {
       this._notifyPropertyObservers() ;
     } 
     return this ;
@@ -398,24 +409,47 @@ SC.Observable = {
   propertyDidChange: function(key,value, _keepCache) {
 
     this._kvo_revision = (this._kvo_revision || 0) + 1; 
-    var level = this._kvo_changeLevel || 0 ;
+    var level = this._kvo_changeLevel || 0,
+        cachedep, idx, dfunc, cache, func,
+        log = SC.LOG_OBSERVERS && !(this.LOG_OBSERVING===NO);
+
+    if (this._kvo_cacheable && (cache = this._kvo_cache)) {
+
+      // clear any cached value
+      if (!_keepCache) {
+        func = this[key] ;
+        if (func && (func instanceof Function)) {
+          cache[func.cacheKey] = cache[func.lastSetValueKey] = undefined ;
+        }
+      }
 
-    // clear any cached value
-    if (!_keepCache) {
-      var func = this[key], cache = this._kvo_cache ;
-      if (cache && func && (func instanceof Function) && func.isCacheable) {
-        cache[func.cacheKey] = cache[func.lastSetValueKey] = undefined ;
+      // if there are any dependent keys and they use caching, then clear the
+      // cache.  This is the same code as is in set.  It is inlined for perf.
+      cachedep = this._kvo_cachedep;
+      if (!cachedep || (cachedep = cachedep[key])===undefined) {
+        cachedep = this._kvo_computeCachedDependentsFor(key);
+      }
+
+      if (cachedep) {
+        idx = cachedep.length;
+        while(--idx>=0) {
+          dfunc = cachedep[idx];
+          cache[dfunc.cacheKey] = cache[dfunc.lastSetValueKey] = undefined;
+        }
       }
     }
-    
+
     // save in the change set if queuing changes
-    var suspended ;
-    if ((level > 0) || (suspended=SC.Observers.isObserveringSuspended)) {
+    var suspended = SC.Observers.isObservingSuspended;
+    if ((level > 0) || suspended) {
       var changes = this._kvo_changes ;
-      if (!changes) changes = this._kvo_changes = SC.Set.create() ;
+      if (!changes) changes = this._kvo_changes = SC.CoreSet.create() ;
       changes.add(key) ;
       
-      if (suspended) SC.Observers.objectHasPendingChanges(this) ;
+      if (suspended) {
+        if (log) console.log("%@%@: will not notify observers because observing is suspended".fmt(SC.KVO_SPACES,this));
+        SC.Observers.objectHasPendingChanges(this) ;
+      }
       
     // otherwise notify property observers immediately
     } else this._notifyPropertyObservers(key) ;
@@ -429,7 +463,9 @@ SC.Observable = {
 
   /**
     Use this to indicate that one key changes if other keys it depends on 
-    change.
+    change.  Pass the key that is dependent and additional keys it depends
+    upon.  You can either pass the additional keys inline as arguments or 
+    in a single array.
     
     You generally do not call this method, but instead pass dependent keys to
     your property() method when you declare a computed property.
@@ -437,68 +473,106 @@ SC.Observable = {
     You can call this method during your init to register the keys that should
     trigger a change notification for your computed properties.  
     
-    @param key {String} the dependent key followed by any keys the key depends on.
+    @param {String} key the dependent key
+    @param {Array|String} dependentKeys one or more dependent keys 
     @returns {Object} this
   */  
-  registerDependentKey: function(key) {
-    var idx = arguments.length ;
-    var dependents = this._kvo_dependents ;
+  registerDependentKey: function(key, dependentKeys) {
+    var dependents = this._kvo_dependents,
+        func       = this[key],
+        keys, idx, lim, dep, queue;
+
+    // normalize input.
+    if (SC.typeOf(dependentKeys) === SC.T_ARRAY) {
+      keys = dependentKeys;
+      lim  = 0;
+    } else {
+      keys = arguments;
+      lim  = 1;
+    }
+    idx  = keys.length;
+
+    // define dependents if not defined already.
     if (!dependents) this._kvo_dependents = dependents = {} ;
 
-    // the cached dependents hash contains computed properties that are 
-    // dependent and cached.  It is important not to define 
-    // _kvo_cachedDependents until this feature is actually used for perf
-    // reasons.
-    var cached = this._kvo_cachedDependents ;
-    var dep, func, array, arrayIdx, queue;
-    
-    // note that we store dependents as simple arrays instead of using set.
-    // we assume that in general you won't call registerDependentKey() more
-    // than once for a particular base key.  Even if you do, the added cost
-    // of having dups is minor.
-    
     // for each key, build array of dependents, add this key...
     // note that we ignore the first argument since it is the key...
-    while(--idx >= 1) {
-      dep = arguments[idx] ;
-      
-      // handle the case where the user passes arrays of keys...
-      if (SC.typeOf(dep) === SC.T_ARRAY) {
-        array = dep ;  arrayIdx = array.length;
-        while(--arrayIdx >= 0) {
-          dep = array[arrayIdx] ;
-          
-          // add to dependents
-          queue = dependents[dep] ;
-          if (!queue) queue = dependents[dep] = [] ;
-          queue.push(key) ;
-
-          // add function 
-          func = this[key];
-          if (func && (func instanceof Function) && func.isCacheable) {
-            if (!cached) this._kvo_cachedDependents = cached = {};
-            queue = cached[dep] ;
-            if (!queue) queue = cached[dep] = [] ;
-            queue.push(func) ;
-          }
-        }
+    while(--idx >= lim) {
+      dep = keys[idx] ;
+
+      // add dependent key to dependents array of key it depends on
+      queue = dependents[dep] ;
+      if (!queue) queue = dependents[dep] = [] ;
+      queue.push(key) ;
+    }
+  },
+
+  /** @private 
+  
+    Helper method used by computeCachedDependents.  Just loops over the 
+    array of dependent keys.  If the passed function is cacheable, it will
+    be added to the queue.  Also, recursively call on each keys dependent 
+    keys.
+  
+    @param {Array} queue the queue to add functions to
+    @param {Array} keys the array of dependent keys for this key
+    @param {Hash} dependents the _kvo_dependents cache
+    @param {SC.Set} seen already seen keys
+    @returns {void}
+  */
+  _kvo_addCachedDependents: function(queue, keys, dependents, seen) {
+    var idx = keys.length,
+        func, key, deps ;
         
-      // otherwise, just add the key.
-      } else {
-        queue = dependents[dep] ;
-        if (!queue) queue = dependents[dep] = [] ;
-        queue.push(key) ;
-          
-        // add to cached dependents if needed
-        func = this[key];
-        if (func && (func instanceof Function) && func.isCacheable) {
-          if (!cached) this._kvo_cachedDependents = cached = {};
-          queue = cached[dep] ;
-          if (!queue) queue = cached[dep] = [] ;
-          queue.push(func) ;
+    while(--idx >= 0) {
+      key  = keys[idx];
+      seen.add(key);
+      
+      // if the value for this key is a computed property, then add it to the
+      // set if it is cacheable, and process any of its dependent keys also.
+      func = this[key];
+      if (func && (func instanceof Function) && func.isProperty) {
+        if (func.isCacheable) queue.push(func); // handle this func
+        if ((deps = dependents[key]) && deps.length>0) { // and any dependents
+          this._kvo_addCachedDependents(queue, deps, dependents, seen);
         }
-      }
+      } 
     }
+        
+  },
+  
+  /** @private
+
+    Called by set() whenever it needs to determine which cached dependent
+    keys to clear.  Recursively searches dependent keys to determine all 
+    cached property direcly or indirectly affected.
+    
+    The return value is also saved for future reference
+    
+    @param {String} key the key to compute
+    @returns {Array}
+  */
+  _kvo_computeCachedDependentsFor: function(key) {
+    var cached     = this._kvo_cachedep,
+        dependents = this._kvo_dependents,
+        keys       = dependents ? dependents[key] : null,
+        queue, seen ;
+    if (!cached) cached = this._kvo_cachedep = {};
+
+    // if there are no dependent keys, then just set and return null to avoid
+    // this mess again.
+    if (!keys || keys.length===0) return cached[key] = null;
+
+    // there are dependent keys, so we need to do the work to find out if 
+    // any of them or their dependent keys are cached.
+    queue = cached[key] = [];
+    seen  = SC._TMP_SEEN_SET = (SC._TMP_SEEN_SET || SC.CoreSet.create());
+    seen.add(key);
+    this._kvo_addCachedDependents(queue, keys, dependents, seen);
+    seen.clear(); // reset
+    
+    if (queue.length === 0) queue = cached[key] = null ; // turns out nothing
+    return queue ;
   },
   
   // ..........................................
@@ -517,9 +591,9 @@ SC.Observable = {
       this._kvo_cloned[kvoKey] = YES ;
       
     // if item does exist but has not been cloned, then clone it.  Note
-    // that all types must implement slice().0
+    // that all types must implement copy().0
     } else if (!this._kvo_cloned[kvoKey]) {
-      ret = this[kvoKey] = ret.slice();
+      ret = this[kvoKey] = ret.copy();
       this._kvo_cloned[kvoKey] = YES; 
     }
     
@@ -536,12 +610,45 @@ SC.Observable = {
     value is set, regardless of whether it has actually changed.  Your
     observer should be prepared to handle that.
     
+    You can also pass an optional context parameter to this method.  The 
+    context will be passed to your observer method whenever it is triggered.
+    Note that if you add the same target/method pair on a key multiple times
+    with different context parameters, your observer will only be called once
+    with the last context you passed.
+    
+    h2. Observer Methods
+    
+    Observer methods you pass should generally have the following signature if
+    you do not pass a "context" parameter:
+    
+    {{{
+      fooDidChange: function(sender, key, value, rev);
+    }}}
+    
+    The sender is the object that changed.  The key is the property that
+    changes.  The value property is currently reserved and unused.  The rev
+    is the last property revision of the object when it changed, which you can
+    use to detect if the key value has really changed or not.
+    
+    If you pass a "context" parameter, the context will be passed before the
+    revision like so:
+    
+    {{{
+      fooDidChange: function(sender, key, value, context, rev);
+    }}}
+    
+    Usually you will not need the value, context or revision parameters at 
+    the end.  In this case, it is common to write observer methods that take
+    only a sender and key value as parameters or, if you aren't interested in
+    any of these values, to write an observer that has no parameters at all.
+    
     @param key {String} the key to observer
     @param target {Object} the target object to invoke
     @param method {String|Function} the method to invoke.
+    @param context {Object} optional context
     @returns {SC.Object} self
   */
-  addObserver: function(key,target,method) {
+  addObserver: function(key, target, method, context) {
     
     var kvoKey, chain, chains, observers;
     
@@ -559,8 +666,9 @@ SC.Observable = {
       
       // create the chain and save it for later so we can tear it down if 
       // needed.
-      chain = SC._ChainObserver.createChain(this, key, target, method);
-      chain.masterTarget = target;  chain.masterMethod = method ;
+      chain = SC._ChainObserver.createChain(this, key, target, method, context);
+      chain.masterTarget = target;  
+      chain.masterMethod = method ;
       
       // Save in set for chain observers.
       this._kvo_for(SC.keyFor('_kvo_chains', key)).push(chain);
@@ -577,13 +685,21 @@ SC.Observable = {
 
       if (target === this) target = null ; // use null for observers only.
       kvoKey = SC.keyFor('_kvo_observers', key);
-      this._kvo_for(kvoKey, SC._ObserverSet).add(target, method);
-      this._kvo_for('_kvo_observed_keys', SC.Set).add(key) ;
+      this._kvo_for(kvoKey, SC._ObserverSet).add(target, method, context);
+      this._kvo_for('_kvo_observed_keys', SC.CoreSet).add(key) ;
     }
-    
+
+    if (this.didAddObserver) this.didAddObserver(key, target, method);
     return this;
   },
 
+  /**
+    Remove an observer you have previously registered on this object.  Pass
+    the same key, target, and method you passed to addObserver() and your 
+    target will no longer receive notifications.
+    
+    @returns {SC.Observable} reciever
+  */
   removeObserver: function(key, target, method) {
     
     var kvoKey, chains, chain, observers, idx ;
@@ -626,14 +742,35 @@ SC.Observable = {
         observers = this._kvo_for(kvoKey) ;
         observers.remove(target, method) ;
         if (observers.targets <= 0) {
-          this._kvo_for('_kvo_observed_keys', SC.Set).remove(key);
+          this._kvo_for('_kvo_observed_keys', SC.CoreSet).remove(key);
         }
       }
     }
-    
+
+    if (this.didRemoveObserver) this.didRemoveObserver(key, target, method);
     return this;
   },
   
+  /**
+    Returns YES if the object currently has observers registered for a 
+    particular key.  You can use this method to potentially defer performing
+    an expensive action until someone begins observing a particular property
+    on the object.
+    
+    @param {String} key key to check
+    @returns {Boolean}
+  */
+  hasObserverFor: function(key) {
+    SC.Observers.flush(this) ; // hookup as many observers as possible.
+    
+    var observers = this[SC.keyFor('_kvo_observers', key)],
+        locals    = this[SC.keyFor('_kvo_local', key)],
+        members ;
+
+    if (locals && locals.length>0) return YES ;
+    if (observers && observers.getMembers().length>0) return YES ;
+    return NO ;
+  },
 
   /**
     This method will register any observers and computed properties saved on
@@ -716,11 +853,16 @@ SC.Observable = {
     // Add Properties
     if (keys = this._properties) {
       for(loc=0;loc<keys.length;loc++) {
-        key = keys[loc] ; value = this[key] ;
-        if (value && value.dependentKeys && (value.dependentKeys.length>0)) {
-          var args = value.dependentKeys.slice() ;
-          args.unshift(key) ;
-          this.registerDependentKey.apply(this,args) ;
+        key = keys[loc];
+        if (value = this[key]) {
+
+          // activate cacheable only if needed for perf reasons
+          if (value.isCacheable) this._kvo_cacheable = YES; 
+
+          // register dependent keys
+          if (value.dependentKeys && (value.dependentKeys.length>0)) {
+            this.registerDependentKey(key, value.dependentKeys) ;
+          }
         }
       }
     }
@@ -750,11 +892,18 @@ SC.Observable = {
 
     if (!this._observableInited) this.initObservable() ;
     
-    SC.Observers.flush() ; // hookup as many observers as possible.
+    SC.Observers.flush(this) ; // hookup as many observers as possible.
 
+    var log = SC.LOG_OBSERVERS && !(this.LOG_OBSERVING===NO) ;
     var observers, changes, dependents, starObservers, idx, keys, rev ;
     var members, membersLength, member, memberLoc, target, method, loc, func ;
+    var context, spaces, cache ;
 
+    if (log) {
+      spaces = SC.KVO_SPACES = (SC.KVO_SPACES || '') + '  ';
+      console.log('%@%@: notifying observers after change to key "%@"'.fmt(spaces, this, key));
+    }
+    
     // Get any starObservers -- they will be notified of all changes.
     starObservers =  this['_kvo_observers_*'] ;
     
@@ -765,20 +914,19 @@ SC.Observable = {
     while(((changes = this._kvo_changes) && (changes.length > 0)) || key) {
       
       // increment revision
-      rev = this.propertyRevision++;
+      rev = ++this.propertyRevision ;
       
       // save the current set of changes and swap out the kvo_changes so that
       // any set() calls by observers will be saved in a new set.
-      if (!changes) changes = SC.Set.create() ;
-      this._kvo_changes = this._kvo_altChanges ;
-      this._kvo_altChanges = null ; 
+      if (!changes) changes = SC.CoreSet.create() ;
+      this._kvo_changes = null ;
 
       // Add the passed key to the changes set.  If a '*' was passed, then
       // add all keys in the observers to the set...
       // once finished, clear the key so the loop will end.
       if (key === '*') {
         changes.add('*') ;
-        changes.addEach(this._kvo_for('_kvo_observed_keys', SC.Set));
+        changes.addEach(this._kvo_for('_kvo_observed_keys', SC.CoreSet));
 
       } else if (key) changes.add(key) ;
 
@@ -794,10 +942,16 @@ SC.Observable = {
           // for each dependent key, add to set of changes.  Also, if key
           // value is a cacheable property, clear the cached value...
           if (keys && (loc = keys.length)) {
+            if (log) {
+              console.log("%@...including dependent keys for %@: %@".fmt(spaces, key, keys));
+            }
+            cache = this._kvo_cache;
+            if (!cache) cache = this._kvo_cache = {};
             while(--loc >= 0) {
               changes.add(key = keys[loc]);
-              if ((func = this[key]) && func.isCacheable) {
+              if (func = this[key]) {
                 this[func.cacheKey] = undefined;
+                cache[func.cacheKey] = cache[func.lastSetValueKey] = undefined;
               } // if (func=)
             } // while (--loc)
           } // if (keys && 
@@ -815,9 +969,19 @@ SC.Observable = {
           membersLength = members.length ;
           for(memberLoc=0;memberLoc < membersLength; memberLoc++) {
             member = members[memberLoc] ;
-            if (member[2] === rev) continue ; // skip notified items.
-            target = member[0] || this; method = member[1] ; member[2] = rev;
-            method.call(target, this, key, null, rev) ;
+            if (member[3] === rev) continue ; // skip notified items.
+
+            target = member[0] || this; 
+            method = member[1] ; 
+            context = member[2];
+            member[3] = rev;
+            
+            if (log) console.log('%@...firing observer on %@ for key "%@"'.fmt(spaces, target, key));
+            if (context !== undefined) {
+              method.call(target, this, key, null, context, rev);
+            } else {
+              method.call(target, this, key, null, rev) ;
+            }
           }
         }
 
@@ -830,7 +994,10 @@ SC.Observable = {
           for(memberLoc=0;memberLoc<membersLength;memberLoc++) {
             member = members[memberLoc];
             method = this[member] ; // try to find observer function
-            if (method) method.call(this, this, key, null, rev);
+            if (method) {
+              if (log) console.log('%@...firing local observer %@.%@ for key "%@"'.fmt(spaces, this, member, key));
+              method.call(this, this, key, null, rev);
+            }
           }
         }
         
@@ -840,19 +1007,28 @@ SC.Observable = {
           membersLength = members.length ;
           for(memberLoc=0;memberLoc < membersLength; memberLoc++) {
             member = members[memberLoc] ;
-            target = member[0] || this; method = member[1] ;
-            method.call(target, this, key, null, rev) ;
+            target = member[0] || this; 
+            method = member[1] ;
+            context = member[2] ;
+            
+            if (log) console.log('%@...firing * observer on %@ for key "%@"'.fmt(spaces, target, key));
+            if (context !== undefined) {
+              method.call(target, this, key, null, context, rev);
+            } else {
+              method.call(target, this, key, null, rev) ;
+            }
           }
         }
 
         // if there is a default property observer, call that also
         if (this.propertyObserver) {
+          if (log) console.log('%@...firing %@.propertyObserver for key "%@"'.fmt(spaces, this, key));
           this.propertyObserver(this, key, null, rev);
         }
       } // while(changes.length>0)
 
-      // changes set should be empty. save this set so it can be reused later
-      this._kvo_altChanges = changes ;
+      // changes set should be empty. release it for reuse
+      if (changes) changes.destroy() ;
       
       // key is no longer needed; clear it to avoid infinite loops
       key = null ; 
@@ -861,6 +1037,9 @@ SC.Observable = {
     
     // done with loop, reduce change level so that future sets can resume
     this._kvo_changeLevel = (this._kvo_changeLevel || 1) - 1; 
+    
+    if (log) SC.KVO_SPACES = spaces.slice(0, -2);
+    
     return YES ; // finished successfully
   },
 
@@ -979,7 +1158,7 @@ SC.Observable = {
   setPath: function(path, value) {
     if (path.indexOf('.') >= 0) {
       var tuple = SC.tupleForPropertyPath(path, this) ;
-      if (!tuple[0]) return null ;
+      if (!tuple || !tuple[0]) return null ;
       tuple[0].set(tuple[1], value) ;
     } else this.set(path, value) ; // shortcut
     return this;
@@ -997,7 +1176,7 @@ SC.Observable = {
   setPathIfChanged: function(path, value) {
     if (path.indexOf('.') >= 0) {
       var tuple = SC.tupleForPropertyPath(path, this) ;
-      if (!tuple[0]) return null ;
+      if (!tuple || !tuple[0]) return null ;
       if (tuple[0].get(tuple[1]) !== value) {
         tuple[0].set(tuple[1], value) ;
       }
@@ -1061,29 +1240,6 @@ SC.Observable = {
     return this.get(key) ;
   },
 
-  /**  
-    Generic property observer called whenever a property on the receiver 
-    changes.
-    
-    If you need to observe a large number of properties on your object, it
-    is sometimes more efficient to implement this observer only and then to
-    handle requests yourself.  Although this observer will be triggered 
-    more often than an observer registered on a specific property, it also
-    does not need to be registered which can make it faster to setup your 
-    object instance.
-    
-    You will often implement this observer using a switch statement on the
-    key parameter, taking appropriate action. 
-    
-    @param observer {null} no longer used; usually null
-    @param target {Object} the target of the change.  usually this
-    @param key {String} the name of the property that changed
-    @param value {Object} the new value of the property.
-    @param revision {Number} a revision you can use to quickly detect changes.
-    @returns {void}
-  */
-  propertyObserver: function(observer,target,key,value, revision) {},
-
   /**
     Convenience method to call propertyWillChange/propertyDidChange.