sproutcore 1.9.2 → 1.10.0.rc.1

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

@@ -25,7 +25,7 @@ SC.RangeObserver = /** @scope SC.RangeObserver.prototype */{
   /**
     Walk like a duck.
 
-    @property {Boolean}
+    @type Boolean
   */
   isRangeObserver: YES,
 

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

@@ -26,7 +26,7 @@ sc_require('private/observer_set');
 
   This is how you could write your mouseup handler in jQuery:
 
-        $('#okButton').on('click', function() {
+        $('#okButton').on('click', function () {
           SC.RunLoop.begin();
 
           // handle click event...
@@ -43,7 +43,7 @@ sc_require('private/observer_set');
 // setting SC.LOG_DEFERRED_CALLS.  We'll declare the variable explicitly to make
 // life easier for people who want to enter it inside consoles that auto-
 // complete.
-//@if(debug)
+//@if (debug)
 if (!SC.LOG_DEFERRED_CALLS) SC.LOG_DEFERRED_CALLS = false;
 //@endif
 
@@ -58,14 +58,14 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
     @returns {SC.RunLoop} receiver
   */
-  beginRunLoop: function() {
-    this._start = new Date().getTime() ; // can't use Date.now() in runtime
+  beginRunLoop: function () {
+    this._start = new Date().getTime(); // can't use Date.now() in runtime
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
       SC.Logger.log("-- SC.RunLoop.beginRunLoop at %@".fmt(this._start));
     }
     this._runLoopInProgress = YES;
     this._flushinvokeNextQueue();
-    return this ;
+    return this;
   },
 
   /**
@@ -74,7 +74,7 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     @property
     @type Boolean
   */
-  isRunLoopInProgress: function() {
+  isRunLoopInProgress: function () {
     return this._runLoopInProgress;
   }.property(),
 
@@ -87,7 +87,7 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
     @returns {SC.RunLoop} receiver
   */
-  endRunLoop: function() {
+  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
     // step through all of them again.  This way any changes get flushed
@@ -99,7 +99,7 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
     this.flushAllPending();
 
-    this._start = null ;
+    this._start = null;
 
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
       SC.Logger.log("-- SC.RunLoop.endRunLoop ~ End");
@@ -108,19 +108,26 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     SC.RunLoop.lastRunLoopEnd = Date.now();
     this._runLoopInProgress = NO;
 
-    return this ;
+    // If there are members in the invokeNextQueue, be sure to schedule another
+    // run of the run loop.
+    var queue = this._invokeNextQueue;
+    if (queue && queue.getMembers().length) {
+      this._invokeNextTimeout = this.scheduleRunLoop(SC.RunLoop.lastRunLoopEnd);
+    }
+
+    return this;
   },
 
   /**
     Repeatedly flushes all bindings, observers, and other queued functions until all queues are empty.
   */
-  flushAllPending: function() {
-    var didChange ;
+  flushAllPending: function () {
+    var didChange;
 
     do {
-      didChange = this.flushApplicationQueues() ;
-      if (!didChange) didChange = this._flushinvokeLastQueue() ;
-    } while(didChange) ;
+      didChange = this.flushApplicationQueues();
+      if (!didChange) didChange = this._flushinvokeLastQueue();
+    } while (didChange);
   },
 
 
@@ -139,15 +146,27 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     @param {Function} method
     @returns {SC.RunLoop} receiver
   */
-  invokeOnce: function(target, method) {
+  invokeOnce: function (target, method) {
+    //@if(debug)
+    // Calling invokeOnce outside of a run loop causes problems when coupled
+    // with time dependent methods invokeNext and invokeLater, because the
+    // time dependent methods execute at the start of the next run of the run
+    // loop and may fire before the invokeOnce code in this case.
+    var isRunLoopInProgress = this.get('isRunLoopInProgress');
+    if (!isRunLoopInProgress) {
+      SC.warn("Developer Warning: invokeOnce called outside of the run loop.  This can cause problems in production code if not addressed.  You likely need to wrap some event handling code within SC.run(...).");
+      console.trace();
+    }
+    //@endif
     // normalize
     if (method === undefined) {
-      method = target; target = this ;
+      method = target;
+      target = this;
     }
 
     var deferredCallLoggingInfo;      // Used only in debug mode
 
-    //@if(debug)
+    //@if (debug)
     // When in debug mode, SC.Object#invokeOnce() will pass in the originating
     // method, target, and stack.  That way, we'll record the interesting parts
     // rather than having most of these calls seemingly coming from
@@ -176,8 +195,8 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
     if (typeof method === "string") method = target[method];
     if (!this._invokeQueue) this._invokeQueue = SC.ObserverSet.create();
-    if ( method ) this._invokeQueue.add(target, method, undefined, deferredCallLoggingInfo);
-    return this ;
+    if (method) this._invokeQueue.add(target, method, undefined, deferredCallLoggingInfo);
+    return this;
   },
 
   /**
@@ -199,15 +218,28 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     @param {Function} method
     @returns {SC.RunLoop} receiver
   */
-  invokeLast: function(target, method) {
+  invokeLast: function (target, method) {
+    //@if(debug)
+    // Calling invokeLast outside of a run loop causes problems when coupled
+    // with time dependent methods invokeNext and invokeLater, because the
+    // time dependent methods execute at the start of the next run of the run
+    // loop and may fire before the invokeLast code in this case.
+    var isRunLoopInProgress = this.get('isRunLoopInProgress');
+    if (!isRunLoopInProgress) {
+      SC.warn("Developer Warning: invokeLast called outside of the run loop.  This can cause problems in production code if not addressed.  You likely need to wrap some event handling code within SC.run(...).");
+      console.trace();
+    }
+    //@endif
+
     // normalize
     if (method === undefined) {
-      method = target; target = this ;
+      method = target;
+      target = this;
     }
 
     var deferredCallLoggingInfo;      // Used only in debug mode
 
-    //@if(debug)
+    //@if (debug)
     // When in debug mode, SC.Object#invokeOnce() will pass in the originating
     // method, target, and stack.  That way, we'll record the interesting parts
     // rather than having most of these calls seemingly coming from
@@ -238,13 +270,13 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     if (typeof method === "string") method = target[method];
     if (!this._invokeLastQueue) this._invokeLastQueue = SC.ObserverSet.create();
     this._invokeLastQueue.add(target, method, undefined, deferredCallLoggingInfo);
-    return this ;
+    return this;
   },
 
   /**
     Invokes the passed target/method pair once at the beginning of the next
-    runloop, before any other methods (including events) are processed.
-    Use this to defer painting to make views more responsive.
+    run of the run loop, before any other methods (including events) are
+    processed.  Use this to defer painting to make views more responsive.
 
     If you call this with the same target/method pair multiple times it will
     only invoke the pair only once at the beginning of the next runloop.
@@ -252,23 +284,21 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
     Usually you will not call this method directly but use invokeNext()
     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
   */
-  invokeNext: function(target, method) {
+  invokeNext: function (target, method) {
     // normalize
     if (method === undefined) {
-      method = target; target = this ;
+      method = target;
+      target = this;
     }
 
     if (typeof method === "string") method = target[method];
     if (!this._invokeNextQueue) this._invokeNextQueue = SC.ObserverSet.create();
     this._invokeNextQueue.add(target, method);
-    return this ;
+    return this;
   },
 
   /**
@@ -287,39 +317,83 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
     @returns {Boolean} YES if items were found in any queue, NO otherwise
   */
-  flushApplicationQueues: function() {
+  flushApplicationQueues: function () {
     var hadContent = NO,
         // execute any methods in the invokeQueue.
         queue = this._invokeQueue;
-    if ( queue && queue.getMembers().length ) {
+    if (queue && queue.getMembers().length) {
       this._invokeQueue = null; // reset so that a new queue will be created
-      hadContent = YES ; // needs to execute again
+      hadContent = YES; // needs to execute again
       queue.invokeMethods();
     }
 
     // flush any pending changed bindings.  This could actually trigger a
     // lot of code to execute.
-    return SC.Binding.flushPendingChanges() || hadContent ;
+    return SC.Binding.flushPendingChanges() || hadContent;
   },
 
-  _flushinvokeLastQueue: function() {
-    var queue = this._invokeLastQueue, hadContent = NO ;
-    if (queue && queue.getMembers().length ) {
+  _flushinvokeLastQueue: function () {
+    var queue = this._invokeLastQueue, hadContent = NO;
+    if (queue && queue.getMembers().length) {
       this._invokeLastQueue = null; // reset queue.
       hadContent = YES; // has targets!
       if (hadContent) queue.invokeMethods();
     }
-    return hadContent ;
+    return hadContent;
   },
 
-  _flushinvokeNextQueue: function() {
-    var queue = this._invokeNextQueue, hadContent = NO ;
-    if (queue && queue.getMembers().length ) {
+  _flushinvokeNextQueue: function () {
+    var queue = this._invokeNextQueue, hadContent = NO;
+    if (queue && queue.getMembers().length) {
       this._invokeNextQueue = null; // reset queue.
       hadContent = YES; // has targets!
       if (hadContent) queue.invokeMethods();
     }
-    return hadContent ;
+    return hadContent;
+  },
+
+  /** @private
+    Schedules the run loop to run at the given time.  If the run loop is
+    already scheduled to run earlier nothing will change, but if the run loop
+    is not scheduled or it is scheduled later, then it will be rescheduled
+    to the value of nextTimeoutAt.
+
+    @returns timeoutID {Number} The ID of the timeout to start the next run of the run loop
+  */
+  scheduleRunLoop: function (nextTimeoutAt) {
+    /*jshint eqnull:true*/
+    // If there is no run loop scheduled or if the scheduled run loop is later, reschedule.
+    if (this._timeoutAt == null || this._timeoutAt > nextTimeoutAt) {
+      // clear existing...
+      if (this._timeout) { clearTimeout(this._timeout); }
+
+      // reschedule
+      var delay = Math.max(0, nextTimeoutAt - Date.now());
+      this._timeout = setTimeout(this._timeoutDidFire, delay);
+      this._timeoutAt = nextTimeoutAt;
+    }
+
+    return this._timeout;
+  },
+
+  /** @private
+    Invoked when a timeout actually fires.  Simply cleanup, then begin and end
+    a runloop. Note that this function will be called with 'this' set to the
+    global context, hence the need to lookup the current run loop.
+  */
+  _timeoutDidFire: function () {
+    var rl = SC.RunLoop.currentRunLoop;
+    rl._timeout = rl._timeoutAt = rl._invokeNextTimeout = null; // cleanup
+    SC.run();  // begin/end runloop to trigger timers.
+  },
+
+  /** @private Unschedule the run loop that is scheduled for the given timeoutID */
+  unscheduleRunLoop: function () {
+    // Don't unschedule if the timeout is shared with an invokeNext timeout.
+    if (!this._invokeNextTimeout) {
+      clearTimeout(this._timeout);
+      this._timeout = this._timeoutAt = null; // cleanup
+    }
   }
 
 });
@@ -334,7 +408,7 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
   @returns {Hash}
 */
-SC._getRecentStack = function() {
+SC._getRecentStack = function () {
   var currentFunction = arguments.callee.caller,
       i               = 0,
       stack           = {},
@@ -345,8 +419,7 @@ SC._getRecentStack = function() {
     // Skip ourselves!
     if (first) {
       first = NO;
-    }
-    else {
+    } else {
       functionName = currentFunction.displayName || currentFunction.toString().substring(0, 40);
       stack[i++]   = functionName;
     }
@@ -381,11 +454,11 @@ SC.RunLoop.runLoopClass = SC.RunLoop;
 
   @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();
-  return this ;
+  return this;
 };
 
 /**
@@ -394,14 +467,14 @@ SC.RunLoop.begin = function() {
 
   @returns {SC.RunLoop} receiver
 */
-SC.RunLoop.end = function() {
+SC.RunLoop.end = function () {
   var runLoop = this.currentRunLoop;
   if (!runLoop) {
-    throw "SC.RunLoop.end() called outside of a runloop!";
+    throw new Error("SC.RunLoop.end() called outside of a runloop!");
   }
   runLoop.endRunLoop();
-  return this ;
-} ;
+  return this;
+};
 
 
 /**
@@ -412,7 +485,7 @@ SC.RunLoop.end = function() {
   for the error catcher, but you don't want the app itself to continue
   running.
 */
-SC.RunLoop.kill = function() {
+SC.RunLoop.kill = function () {
   this.currentRunLoop = this.runLoopClass.create();
   return this;
 };
@@ -422,8 +495,8 @@ SC.RunLoop.kill = function() {
 
   @return {Boolean}
 */
-SC.RunLoop.isRunLoopInProgress = function() {
-  if(this.currentRunLoop) return this.currentRunLoop.get('isRunLoopInProgress');
+SC.RunLoop.isRunLoopInProgress = function () {
+  if (this.currentRunLoop) return this.currentRunLoop.get('isRunLoopInProgress');
   return NO;
 };
 
@@ -439,16 +512,16 @@ SC.RunLoop.isRunLoopInProgress = function() {
   @param {Object} target context for callback
   @param {Boolean} if YES, starts/ends a new runloop even if one is already running
 */
-SC.run = function(callback, target, forceNested) {
+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 {
-      if(forceNested || !alreadyRunning) SC.RunLoop.begin();
+      if (forceNested || !alreadyRunning) SC.RunLoop.begin();
       if (callback) callback.call(target);
-      if(forceNested || !alreadyRunning) SC.RunLoop.end();
+      if (forceNested || !alreadyRunning) SC.RunLoop.end();
     } catch (e) {
       var handled = SC.ExceptionHandler.handleException(e);
 
@@ -460,9 +533,9 @@ SC.run = function(callback, target, forceNested) {
       }
     }
   } else {
-    if(forceNested || !alreadyRunning) SC.RunLoop.begin();
+    if (forceNested || !alreadyRunning) SC.RunLoop.begin();
     if (callback) callback.call(target);
-    if(forceNested || !alreadyRunning) SC.RunLoop.end();
+    if (forceNested || !alreadyRunning) SC.RunLoop.end();
   }
 };
 
@@ -470,12 +543,12 @@ SC.run = function(callback, target, forceNested) {
   Wraps the passed function in code that ensures a run loop will
   surround it when run.
 */
-SC.RunLoop.wrapFunction = function(func) {
-  var ret = function() {
+SC.RunLoop.wrapFunction = function (func) {
+  var ret = function () {
     var alreadyRunning = SC.RunLoop.isRunLoopInProgress();
-    if(!alreadyRunning) SC.RunLoop.begin();
-    var ret = arguments.callee.wrapped.apply(this,arguments);
-    if(!alreadyRunning) SC.RunLoop.end();
+    if (!alreadyRunning) SC.RunLoop.begin();
+    var ret = arguments.callee.wrapped.apply(this, arguments);
+    if (!alreadyRunning) SC.RunLoop.end();
     return ret;
   };
   ret.wrapped = func;

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

@@ -53,7 +53,7 @@ sc_require('mixins/copyable');
         var foundNames = SC.Set.create();
 
         // creates a set with four names in it.
-        var names = SC.Set.create(["Charles", "Tom", "Juan", "Alex"]) ; // :P
+        var names = SC.Set.create(["Charles", "Tom", "Juan", "Alex"]);
 
         // creates a copy of the names set.
         var namesCopy = SC.Set.create(names);
@@ -122,8 +122,8 @@ sc_require('mixins/copyable');
   @since SproutCore 1.0
 */
 SC.Set = SC.mixin({},
-  SC.Enumerable,
   SC.Observable,
+  SC.Enumerable,
   SC.Freezable,
 /** @scope SC.Set.prototype */ {
 
@@ -169,21 +169,21 @@ SC.Set = SC.mixin({},
   /**
     Walk like a duck
 
-    @property {Boolean}
+    @type Boolean
   */
   isSet: YES,
 
   /**
     This property will change as the number of objects in the set changes.
 
-    @property {Number}
+    @type Number
   */
   length: 0,
 
   /**
     Returns the first object in the set or null if the set is empty
 
-    @property {Object}
+    @type Object
   */
   firstObject: function() {
     return (this.length > 0) ? this[0] : undefined ;
@@ -262,8 +262,7 @@ SC.Set = SC.mixin({},
     // 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.
+    // remove the set observer. Pretty simple, if you think about it.
     this.setObservers.remove(setObserver);
   },
 
@@ -309,7 +308,7 @@ SC.Set = SC.mixin({},
   addEach: function(objects) {
     if (this.isFrozen) throw SC.FROZEN_ERROR;
     if (!objects || !objects.isEnumerable) {
-      throw "%@.addEach must pass enumerable".fmt(this);
+      throw new Error("%@.addEach must pass enumerable".fmt(this));
     }
 
     var idx, isObservable = this.isObservable ;
@@ -367,8 +366,10 @@ SC.Set = SC.mixin({},
       this[guid] = idx;
     }
 
-    // reduce the length
+    // Throw away the last object (it has been moved or is the object we are removing).
+    delete this[len-1];
     this.length = len-1;
+
     if (this.isObservable) this.enumerableContentDidChange();
     if (this.setObservers) this.didRemoveItem(obj);
     return this ;
@@ -395,7 +396,7 @@ SC.Set = SC.mixin({},
   removeEach: function(objects) {
     if (this.isFrozen) throw SC.FROZEN_ERROR;
     if (!objects || !objects.isEnumerable) {
-      throw "%@.addEach must pass enumerable".fmt(this);
+      throw new Error("%@.addEach must pass enumerable".fmt(this));
     }
 
     var idx, isObservable = this.isObservable ;