sproutcore 1.4.5 → 1.5.0.pre.3

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

@@ -9,40 +9,40 @@
 /** @class
 
   A RangeObserver is used by Arrays to automatically observe all of the
-  objects in a particular range on the array.  Whenever any property on one 
+  objects in a particular range on the array.  Whenever any property on one
   of those objects changes, it will notify its delegate.  Likewise, whenever
   the contents of the array itself changes, it will notify its delegate and
   possibly update its own registration.
 
-  This implementation uses only SC.Array methods.  It can be used on any 
+  This implementation uses only SC.Array methods.  It can be used on any
   object that complies with SC.Array.  You may, however, choose to subclass
   this object in a way that is more optimized for your particular design.
-  
+
   @since SproutCore 1.0
 */
 SC.RangeObserver = {
 
-  /** 
+  /**
     Walk like a duck.
-    
+
     @property {Boolean}
   */
   isRangeObserver: YES,
-  
+
   /** @private */
-  toString: function() { 
+  toString: function() {
     var base = this.indexes ? this.indexes.toString() : "SC.IndexSet<..>";
     return base.replace('IndexSet', 'RangeObserver(%@)'.fmt(SC.guidFor(this)));
   },
-  
+
   /**
     Creates a new range observer owned by the source.  The indexSet you pass
     must identify the indexes you are interested in observing.  The passed
     target/method will be invoked whenever the observed range changes.
-    
+
     Note that changes to a range are buffered until the end of a run loop
     unless a property on the record itself changes.
-  
+
     @param {SC.Array} source the source array
     @param {SC.IndexSet} indexSet set of indexes to observer
     @param {Object} target the target
@@ -58,86 +58,87 @@ SC.RangeObserver = {
     ret.target = target;
     ret.method = method;
     ret.context = context ;
-    ret.isDeep  = isDeep || NO ;
+    ret.isDeep  = isDeep || false ;
     ret.beginObserving();
     return ret ;
   },
 
   /**
     Create subclasses for the RangeObserver.  Pass one or more attribute
-    hashes.  Use this to create customized RangeObservers if needed for your 
+    hashes.  Use this to create customized RangeObservers if needed for your
     classes.
-    
+
     @param {Hash} attrs one or more attribute hashes
     @returns {SC.RangeObserver} extended range observer class
   */
   extend: function(attrs) {
-    var ret = SC.beget(this), args = arguments, len = args.length, idx;
-    for(idx=0;idx<len;idx++) SC.mixin(ret, args[idx]);
+    var ret = SC.beget(this), args = arguments;
+    for(var i=0, l=args.length; i<l; i++) { SC.mixin(ret, args[i]); }
     return ret ;
   },
 
   /**
     Destroys an active ranger observer, cleaning up first.
-    
+
     @param {SC.Array} source the source array
     @returns {SC.RangeObserver} receiver
   */
-  destroy: function(source) { 
-    this.endObserving(); 
-    return this; 
+  destroy: function(source) {
+    this.endObserving();
+    return this;
   },
 
   /**
-    Updates the set of indexes the range observer applies to.  This will 
-    stop observing the old objects for changes and start observing the 
+    Updates the set of indexes the range observer applies to.  This will
+    stop observing the old objects for changes and start observing the
     new objects instead.
-    
+
     @param {SC.Array} source the source array
     @returns {SC.RangeObserver} receiver
   */
   update: function(source, indexSet) {
-    if (this.indexes && this.indexes.isEqual(indexSet)) return this ;
-    
+    if (this.indexes && this.indexes.isEqual(indexSet)) { return this ; }
+
     this.indexes = indexSet ? indexSet.frozenCopy() : null ;
     this.endObserving().beginObserving();
     return this;
   },
-  
+
   /**
     Configures observing for each item in the current range.  Should update
     the observing array with the list of observed objects so they can be
     torn down later
-    
+
     @returns {SC.RangeObserver} receiver
   */
   beginObserving: function() {
-    if (!this.isDeep) return this; // nothing to do
-    
-    var observing = this.observing;
-    if (!observing) observing = this.observing = SC.CoreSet.create();
-    
+    if ( !this.isDeep ) { return this; } // nothing to do
+
+    var observing = this.observing = this.observing || SC.CoreSet.create();
+
     // cache iterator function to keep things fast
-    var func = this._beginObservingForEach;
-    if (!func) {
+    var func = this._beginObservingForEach, source = this.source;
+
+    if( !func ) {
       func = this._beginObservingForEach = function(idx) {
-        var obj = this.source.objectAt(idx);
+        var obj = source.objectAt(idx);
         if (obj && obj.addObserver) {
           observing.push(obj);
-          obj._kvo_needsRangeObserver = YES ;
+          obj._kvo_needsRangeObserver = true ;
         }
       };
     }
-    this.indexes.forEach(func,this);
+
+    this.indexes.forEach(func);
 
     // add to pending range observers queue so that if any of these objects
     // change we will have a chance to setup observing on them.
-    this.isObserving = NO ;
+    this.isObserving = false ;
     SC.Observers.addPendingRangeObserver(this);
 
     return this;
   },
-  
+
   /** @private
     Called when an object that appears to need range observers has changed.
     Check to see if the range observer contains this object in its list.  If
@@ -147,60 +148,62 @@ SC.RangeObserver = {
   setupPending: function(object) {
     var observing = this.observing ;
 
-    if (this.isObserving || !observing || (observing.get('length')===0)) {
-      return YES ;
-    } 
-    
+    if ( this.isObserving || !observing || (observing.get('length')===0) ) {
+      return true ;
+    }
+
     if (observing.contains(object)) {
-      this.isObserving = YES ;
+      this.isObserving = true ;
 
       // cache iterator function to keep things fast
       var func = this._setupPendingForEach;
       if (!func) {
         var source = this.source,
-            method = this.objectPropertyDidChange;
+            method = this.objectPropertyDidChange,
+            self   = this;
 
         func = this._setupPendingForEach = function(idx) {
-          var obj = this.source.objectAt(idx),
+          var obj = source.objectAt(idx),
               guid = SC.guidFor(obj),
               key ;
-              
+
           if (obj && obj.addObserver) {
             observing.push(obj);
-            obj.addObserver('*', this, method);
-            
+            obj.addObserver('*', self, method);
+
             // also save idx of object on range observer itself.  If there is
             // more than one idx, convert to IndexSet.
-            key = this[guid];
-            if (key === undefined || key === null) {
-              this[guid] = idx ;
+            key = self[guid];
+            if ( key == null ) {
+              self[guid] = idx ;
             } else if (key.isIndexSet) {
               key.add(idx);
             } else {
-              key = this[guid] = SC.IndexSet.create(key).add(idx);
+              self[guid] = SC.IndexSet.create(key).add(idx);
             }
-            
+
           }
         };
       }
-      this.indexes.forEach(func,this);
-      return YES ;
-      
-    } else return NO ;
+      this.indexes.forEach(func);
+      return true ;
+    } else {
+      return false ;
+    }
   },
-  
+
   /**
-    Remove observers for any objects currently begin observed.  This is 
-    called whenever the observed range changes due to an array change or 
+    Remove observers for any objects currently begin observed.  This is
+    called whenever the observed range changes due to an array change or
     due to destroying the observer.
-    
+
     @returns {SC.RangeObserver} receiver
   */
   endObserving: function() {
-    if (!this.isDeep) return this; // nothing to do
-    
+    if ( !this.isDeep ) return this; // nothing to do
+
     var observing = this.observing;
-    
+
     if (this.isObserving) {
       var meth      = this.objectPropertyDidChange,
           source    = this.source,
@@ -214,28 +217,28 @@ SC.RangeObserver = {
           this[SC.guidFor(obj)] = null;
         }
         observing.length = 0 ; // reset
-      } 
-      
-      this.isObserving = NO ;
+      }
+
+      this.isObserving = false ;
     }
-    
-    if (observing) observing.clear(); // empty set.
+
+    if (observing) { observing.clear(); } // empty set.
     return this ;
   },
-  
+
   /**
     Whenever the actual objects in the range changes, notify the delegate
-    then begin observing again.  Usually this method will be passed an 
+    then begin observing again.  Usually this method will be passed an
     IndexSet with the changed indexes.  The range observer will only notify
     its delegate if the changed indexes include some of all of the indexes
     this range observer is monitoring.
-    
+
     @param {SC.IndexSet} changes optional set of changed indexes
     @returns {SC.RangeObserver} receiver
   */
   rangeDidChange: function(changes) {
     var indexes = this.indexes;
-    if (!changes || !indexes || indexes.intersects(changes)) {
+    if ( !changes || !indexes || indexes.intersects(changes) ) {
       this.endObserving(); // remove old observers
       this.method.call(this.target, this.source, null, '[]', changes, this.context);
       this.beginObserving(); // setup new ones
@@ -245,27 +248,23 @@ SC.RangeObserver = {
 
   /**
     Whenever an object changes, notify the delegate
-    
+
     @param {Object} the object that changed
     @param {String} key the property that changed
     @returns {SC.RangeObserver} receiver
   */
   objectPropertyDidChange: function(object, key, value, rev) {
     var context = this.context,
-        method  = this.method, 
+        method  = this.method,
         guid    = SC.guidFor(object),
         index   = this[guid];
-      
-    // lazily convert index to IndexSet.  
-    if (index && !index.isIndexSet) {
+
+    // lazily convert index to IndexSet.
+    if ( index && !index.isIndexSet ) {
       index = this[guid] = SC.IndexSet.create(index).freeze();
     }
-    
-    if (context) {
-      method.call(this.target, this.source, object, key, index, context, rev);
-    } else {
-      method.call(this.target, this.source, object, key, index, rev);
-    }
+
+    method.call(this.target, this.source, object, key, index, context || rev, rev);
   }
-  
+
 };

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

@@ -9,205 +9,215 @@ sc_require('private/observer_set');
 
 /**
   @class
-  
+
   The run loop provides a universal system for coordinating events within
-  your application.  The run loop processes timers as well as pending 
+  your application.  The run loop processes timers as well as pending
   observer notifications within your application.
-  
+
   To use a RunLoop within your application, you should make sure your event
   handlers always begin and end with SC.RunLoop.begin() and SC.RunLoop.end()
-  
-  The RunLoop is important because bindings do not fire until the end of 
+
+  The RunLoop is important because bindings do not fire until the end of
   your run loop is reached.  This improves the performance of your
   application.
-  
+
   h2. Example
-  
+
   This is how you could write your mouseup handler in jQuery:
-  
+
   {{{
     $('#okButton').on('click', function() {
       SC.RunLoop.begin();
-      
+
       // handle click event...
-      
+
       SC.RunLoop.end(); // allows bindings to trigger...
     });
   }}}
-  
+
   @extends SC.Object
   @since SproutCore 1.0
 */
 SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
-  
+
   /**
-    Call this method whenver you begin executing code.  
-    
-    This is typically invoked automatically for you from event handlers and 
-    the timeout handler.  If you call setTimeout() or setInterval() yourself, 
+    Call this method whenver you begin executing code.
+
+    This is typically invoked automatically for you from event handlers and
+    the timeout handler.  If you call setTimeout() or setInterval() yourself,
     you may need to invoke this yourself.
-    
+
     @returns {SC.RunLoop} receiver
   */
   beginRunLoop: function() {
     this._start = new Date().getTime() ; // can't use Date.now() in runtime
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
       console.log("-- SC.RunLoop.beginRunLoop at %@".fmt(this._start));
-    } 
+    }
     this._runLoopInProgress = YES;
-    return this ; 
+    return this ;
   },
-  
+
   /**
     YES when a run loop is in progress
-  
+
     @property {Boolean}
   */
   isRunLoopInProgress: function() {
     return this._runLoopInProgress;
   }.property(),
-  
+
   /**
     Call this method whenever you are done executing code.
-    
+
     This is typically invoked automatically for you from event handlers and
     the timeout handler.  If you call setTimeout() or setInterval() yourself
     you may need to invoke this yourself.
-    
+
     @returns {SC.RunLoop} receiver
   */
   endRunLoop: function() {
-    // at the end of a runloop, flush all the delayed actions we may have 
-    // stored up.  Note that if any of these queues actually run, we will 
+    // at the end of a runloop, flush all the delayed actions we may have
+    // stored up.  Note that if any of these queues actually run, we will
     // step through all of them again.  This way any changes get flushed
     // out completely.
-    var didChange ;
 
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
       console.log("-- SC.RunLoop.endRunLoop ~ flushing application queues");
     } 
     
-    do {
-      didChange = this.flushApplicationQueues() ;
-      if (!didChange) didChange = this._flushinvokeLastQueue() ; 
-    } while(didChange) ;
+    this.flushAllPending();
+    
     this._start = null ;
 
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
       console.log("-- SC.RunLoop.endRunLoop ~ End");
-    } 
-    
+    }
+
     SC.RunLoop.lastRunLoopEnd = Date.now();
     this._runLoopInProgress = NO;
+
+    return this ;
+  },
+
+  /**
+    Repeatedly flushes all bindings, observers, and other queued functions until all queues are empty.
+  */
+  flushAllPending: function() {
+    var didChange ;
     
-    return this ; 
+    do {
+      didChange = this.flushApplicationQueues() ;
+      if (!didChange) didChange = this._flushinvokeLastQueue() ; 
+    } while(didChange) ;
   },
   
+  
   /**
     Invokes the passed target/method pair once at the end of the runloop.
     You can call this method as many times as you like and the method will
-    only be invoked once.  
-    
-    Usually you will not call this method directly but use invokeOnce() 
+    only be invoked once.
+
+    Usually you will not call this method directly but use invokeOnce()
     defined on SC.Object.
-    
+
     Note that in development mode only, the object and method that call this
     method will be recorded, for help in debugging scheduled code.
-    
+
     @param {Object} target
     @param {Function} method
     @returns {SC.RunLoop} receiver
   */
   invokeOnce: function(target, method) {
     // normalize
-    if (method === undefined) { 
+    if (method === undefined) {
       method = target; target = this ;
     }
-    
+
     if (typeof method === "string") method = target[method];
     if (!this._invokeQueue) this._invokeQueue = SC.ObserverSet.create();
-    this._invokeQueue.add(target, method);
+    if ( method ) this._invokeQueue.add(target, method);
     return this ;
   },
-  
+
   /**
     Invokes the passed target/method pair at the very end of the run loop,
-    once all other delayed invoke queues have been flushed.  Use this to 
+    once all other delayed invoke queues have been flushed.  Use this to
     schedule cleanup methods at the end of the run loop once all other work
     (including rendering) has finished.
 
     If you call this with the same target/method pair multiple times it will
     only invoke the pair only once at the end of the runloop.
-    
-    Usually you will not call this method directly but use invokeLast() 
+
+    Usually you will not call this method directly but use invokeLast()
     defined on SC.Object.
-    
+
     Note that in development mode only, the object and method that call this
     method will be recorded, for help in debugging scheduled code.
-    
+
     @param {Object} target
     @param {Function} method
     @returns {SC.RunLoop} receiver
   */
   invokeLast: function(target, method) {
     // normalize
-    if (method === undefined) { 
+    if (method === undefined) {
       method = target; target = this ;
     }
-    
+
     if (typeof method === "string") method = target[method];
     if (!this._invokeLastQueue) this._invokeLastQueue = SC.ObserverSet.create();
     this._invokeLastQueue.add(target, method);
     return this ;
   },
-  
+
   /**
-    Executes any pending events at the end of the run loop.  This method is 
-    called automatically at the end of a run loop to flush any pending 
+    Executes any pending events at the end of the run loop.  This method is
+    called automatically at the end of a run loop to flush any pending
     queue changes.
-    
-    The default method will invoke any one time methods and then sync any 
-    bindings that might have changed.  You can override this method in a 
-    subclass if you like to handle additional cleanup. 
-    
+
+    The default method will invoke any one time methods and then sync any
+    bindings that might have changed.  You can override this method in a
+    subclass if you like to handle additional cleanup.
+
     This method must return YES if it found any items pending in its queues
     to take action on.  endRunLoop will invoke this method repeatedly until
     the method returns NO.  This way if any if your final executing code
     causes additional queues to trigger, then can be flushed again.
-    
+
     @returns {Boolean} YES if items were found in any queue, NO otherwise
   */
   flushApplicationQueues: function() {
     var hadContent = NO,
         // execute any methods in the invokeQueue.
         queue = this._invokeQueue;
-    if (queue && queue.targets > 0) {
+    if ( queue && queue.getMembers().length ) {
       this._invokeQueue = null; // reset so that a new queue will be created
       hadContent = YES ; // needs to execute again
       queue.invokeMethods();
     }
-    
-    // flush any pending changed bindings.  This could actually trigger a 
+
+    // flush any pending changed bindings.  This could actually trigger a
     // lot of code to execute.
     return SC.Binding.flushPendingChanges() || hadContent ;
   },
-  
+
   _flushinvokeLastQueue: function() {
     var queue = this._invokeLastQueue, hadContent = NO ;
-    if (queue && queue.targets > 0) {
+    if (queue && queue.getMembers().length ) {
       this._invokeLastQueue = null; // reset queue.
       hadContent = YES; // has targets!
       if (hadContent) queue.invokeMethods();
     }
     return hadContent ;
   }
-  
+
 });
 
-/** 
+/**
   The current run loop.  This is created automatically the first time you
-  call begin(). 
-  
+  call begin().
+
   @property {SC.RunLoop}
 */
 SC.RunLoop.currentRunLoop = null;
@@ -215,18 +225,18 @@ SC.RunLoop.currentRunLoop = null;
 /**
   The default RunLoop class.  If you choose to extend the RunLoop, you can
   set this property to make sure your class is used instead.
-  
+
   @property {Class}
 */
 SC.RunLoop.runLoopClass = SC.RunLoop;
 
-/** 
-  Begins a new run loop on the currentRunLoop.  If you are already in a 
+/**
+  Begins a new run loop on the currentRunLoop.  If you are already in a
   runloop, this method has no effect.
-  
+
   @returns {SC.RunLoop} receiver
 */
-SC.RunLoop.begin = function() {    
+SC.RunLoop.begin = function() {
   var runLoop = this.currentRunLoop;
   if (!runLoop) runLoop = this.currentRunLoop = this.runLoopClass.create();
   runLoop.beginRunLoop();
@@ -234,9 +244,9 @@ SC.RunLoop.begin = function() {
 };
 
 /**
-  Ends the run loop on the currentRunLoop.  This will deliver any final 
+  Ends the run loop on the currentRunLoop.  This will deliver any final
   pending notifications and schedule any additional necessary cleanup.
-  
+
   @returns {SC.RunLoop} receiver
 */
 SC.RunLoop.end = function() {
@@ -259,30 +269,29 @@ SC.RunLoop.isRunLoopInProgress = function() {
 };
 
 /**
-  Executes a passed function in the context of a run loop.
-
+  Executes a passed function in the context of a run loop. If called outside a 
+  runloop, starts and ends one. If called inside an existing runloop, is 
+  simply executes the function unless you force it to create a nested runloop.
+  
   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
+  @param {Boolean} if YES, starts/ends a new runloop even if one is already running
 */
-SC.run = function(callback, target, useExistingRunLoop) {
-  if(useExistingRunLoop) {
-    var alreadyRunning = SC.RunLoop.isRunLoopInProgress();
-    if(!alreadyRunning) SC.RunLoop.begin();
-    callback.call(target);
-    if(!alreadyRunning) SC.RunLoop.end();
-  } else {
+SC.run = function(callback, target, forceNested) {
+  var alreadyRunning = SC.RunLoop.isRunLoopInProgress();
+
+  // Only use a try/catch block if we have an ExceptionHandler
+  // since in some browsers try/catch causes a loss of the backtrace
+  if (SC.ExceptionHandler && SC.ExceptionHandler.enabled) {
     try {
-      SC.RunLoop.begin();
+      if(forceNested || !alreadyRunning) SC.RunLoop.begin();
       if (callback) callback.call(target);
-      SC.RunLoop.end();
+      if(forceNested || !alreadyRunning) SC.RunLoop.end();
     } catch (e) {
-      if (SC.ExceptionHandler) {
-        SC.ExceptionHandler.handleException(e);
-      }
+      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).
@@ -291,5 +300,9 @@ SC.run = function(callback, target, useExistingRunLoop) {
         throw e;
       }
     }
+  } else {
+    if(forceNested || !alreadyRunning) SC.RunLoop.begin();
+    if (callback) callback.call(target);
+    if(forceNested || !alreadyRunning) SC.RunLoop.end();
   }
 };