sproutcore 1.7.1.beta → 1.8.0

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

@@ -70,8 +70,8 @@ SC._object_extend = function _object_extend(base, ext, proto) {
   base._kvo_cloned = null;
 
   // get some common vars
-  var key, idx, len, cur, cprops = base.concatenatedProperties, K = SC.K ;
-  var p1,p2;
+  var key, idx, len, cur, cprops = base.concatenatedProperties, K = SC.K,
+      p1,p2;
 
   // first, save any concat props.  use old or new array or concat
   idx = (cprops) ? cprops.length : 0 ;
@@ -91,10 +91,10 @@ SC._object_extend = function _object_extend(base, ext, proto) {
   // setup arrays for bindings, observers, and properties.  Normally, just
   // save the arrays from the base.  If these need to be changed during
   // processing, then they will be cloned first.
-  var bindings = base._bindings, clonedBindings = NO;
-  var observers = base._observers, clonedObservers = NO;
-  var properties = base._properties, clonedProperties = NO;
-  var paths, pathLoc, local ;
+  var bindings = base._bindings, clonedBindings = NO,
+      observers = base._observers, clonedObservers = NO,
+      properties = base._properties, clonedProperties = NO,
+      paths, pathLoc, local, value;
 
   // outlets are treated a little differently because you can manually
   // name outlets in the passed in hash. If this is the case, then clone
@@ -114,7 +114,7 @@ SC._object_extend = function _object_extend(base, ext, proto) {
     if (!ext.hasOwnProperty(key)) continue ;
 
     // get the value.  use concats if defined
-    var value = (concats.hasOwnProperty(key) ? concats[key] : null) || ext[key];
+    value = (concats.hasOwnProperty(key) ? concats[key] : null) || ext[key];
 
     // Possibly add to a bindings.
     if (key.length > 7 && key.slice(-7) === "Binding") {
@@ -210,8 +210,8 @@ SC._object_extend = function _object_extend(base, ext, proto) {
 
 SC._enhance = function(originalFunction, enhancement) {
   return function() {
-    var args = Array.prototype.slice.call(arguments, 0);
-    var self = this;
+    var args = Array.prototype.slice.call(arguments, 0),
+        self = this;
 
     args.unshift(function() { return originalFunction.apply(self, arguments); });
     return enhancement.apply(this, args);
@@ -234,7 +234,7 @@ SC._enhance = function(originalFunction, enhancement) {
   ===
 
   JavaScript is not a class-based language.  Instead it uses a type of
-  inheritence inspired by self called "prototypical" inheritance.
+  inheritance inspired by self called "prototypical" inheritance.
   ...
 
   Using SproutCore objects with other JavaScript object.
@@ -324,9 +324,12 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
     this.subclasses.add(ret); // now we can walk a class hierarchy
 
     // setup new prototype and add properties to it
-    var base = (ret.prototype = SC.beget(this.prototype));
-    var idx, len = arguments.length;
-    for(idx=0;idx<len;idx++) { SC._object_extend(base, arguments[idx], ret.__sc_super__) ; }
+    var base = (ret.prototype = SC.beget(this.prototype)),
+        idx, len = arguments.length;
+    
+    for(idx=0;idx<len;idx++) { 
+      SC._object_extend(base, arguments[idx], ret.__sc_super__) ; 
+    }
     base.constructor = ret; // save constructor
 
     if (bench) SC.Benchmark.end('SC.Object.extend') ;
@@ -532,12 +535,12 @@ SC.Object.prototype = {
     @returns {Object} receiver
   */
   mixin: function() {
-    var idx, len = arguments.length;
+    var idx, len = arguments.length, init;
     for(idx=0;idx<len;idx++) SC.mixin(this, arguments[idx]) ;
 
     // call initMixin
     for(idx=0;idx<len;idx++) {
-      var init = arguments[idx].initMixin ;
+      init = arguments[idx].initMixin ;
       if (init) init.call(this) ;
     }
     return this ;
@@ -614,7 +617,7 @@ SC.Object.prototype = {
   },
 
   /**
-    Attemps to invoke the named method, passing the included two arguments.
+    Attempts to invoke the named method, passing the included two arguments.
     Returns NO if the method is either not implemented or if the handler
     returns NO (indicating that it did not handle the event).  This method
     is invoked to deliver actions from menu items and to deliver events.
@@ -716,8 +719,8 @@ SC.Object.prototype = {
   toString: function() {
     if (!this._object_toString) {
       // only cache the string if the klass name is available
-      var klassName = SC._object_className(this.constructor) ;
-      var string = "%@:%@".fmt(klassName, SC.guidFor(this));
+      var klassName = SC._object_className(this.constructor),
+          string = klassName + ":" + SC.guidFor(this);
       if (klassName) this._object_toString = string ;
       else return string ;
     }
@@ -754,8 +757,20 @@ SC.Object.prototype = {
     @returns {SC.Object} receiver
   */
   invokeOnce: function(method) {
-    SC.RunLoop.currentRunLoop.invokeOnce(this, method) ;
-    return this ;
+    //@if(debug)
+    // If we're logging deferred calls, send along the information that needs to
+    // be recorded.
+    var originatingTarget, originatingMethod, originatingStack;
+    if (SC.LOG_DEFERRED_CALLS) {
+      originatingTarget = this;
+      originatingStack  = SC._getRecentStack();
+      originatingMethod = originatingStack[0];
+    }
+    SC.RunLoop.currentRunLoop.invokeOnce(this, method, originatingTarget, originatingMethod, originatingStack);
+    return this;
+    //@endif
+    SC.RunLoop.currentRunLoop.invokeOnce(this, method);
+    return this;
   },
 
   /**
@@ -778,14 +793,11 @@ SC.Object.prototype = {
             var obj = MyRecord.newRecord() ;
 
             // update the collection controller's selection
-            MyApp.myRecordCollectionController.invokeLast( function() {
+            MyApp.myRecordCollectionController.invokeNext( function() {
               this.set('selection', [obj]) ;
             });
           }
 
-    You can call invokeLast as many times as you like and the method will
-    only be invoked once.
-
     Note that in development mode only, the object and method that call this
     method will be recorded, for help in debugging scheduled code.
 
@@ -793,8 +805,20 @@ SC.Object.prototype = {
     @returns {SC.Object} receiver
   */
   invokeLast: function(method) {
-    SC.RunLoop.currentRunLoop.invokeLast(this, method) ;
-    return this ;
+    //@if(debug)
+    // If we're logging deferred calls, send along the information that needs to
+    // be recorded.
+    var originatingTarget, originatingMethod, originatingStack;
+    if (SC.LOG_DEFERRED_CALLS) {
+      originatingTarget = this ;
+      originatingStack  = SC._getRecentStack();
+      originatingMethod = originatingStack[0];
+    }
+    SC.RunLoop.currentRunLoop.invokeLast(this, method, originatingTarget, originatingMethod, originatingStack);
+    return this;
+    //@endif
+    SC.RunLoop.currentRunLoop.invokeLast(this, method);
+    return this;
   },
 
   /**
@@ -832,9 +856,11 @@ function findClassNames() {
   if (SC._object_foundObjectClassNames) return ;
   SC._object_foundObjectClassNames = true ;
 
-  var seen = [] ;
-  var detectedSC = false;
+  var seen = [],
+      detectedSC = false;
   var searchObject = function(root, object, levels) {
+    
+    var path, value, type;
     levels-- ;
 
     // not the fastest, but safe
@@ -851,11 +877,11 @@ function findClassNames() {
         detectedSC = true;
       }
 
-      var path = (root) ? [root,key].join('.') : key ;
-      var value = object[key] ;
+      path = (root) ? [root,key].join('.') : key ;
+      value = object[key] ;
 
       try {
-        var type = SC.typeOf(value);
+        type = SC.typeOf(value);
       } catch (e) {
         // Firefox gives security errors when trying to run typeOf on certain objects
         break;

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

@@ -37,6 +37,16 @@ sc_require('private/observer_set');
   @extends SC.Object
   @since SproutCore 1.0
 */
+
+
+// When in debug mode, users can log deferred calls (such as .invokeOnce()) by
+// 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 (!SC.LOG_DEFERRED_CALLS) SC.LOG_DEFERRED_CALLS = false;
+//@endif
+
 SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
   /**
@@ -54,6 +64,7 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
       SC.Logger.log("-- SC.RunLoop.beginRunLoop at %@".fmt(this._start));
     }
     this._runLoopInProgress = YES;
+    this._flushinvokeNextQueue();
     return this ;
   },
 
@@ -84,10 +95,10 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
 
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
       SC.Logger.log("-- SC.RunLoop.endRunLoop ~ flushing application queues");
-    } 
-    
+    }
+
     this.flushAllPending();
-    
+
     this._start = null ;
 
     if (SC.LOG_BINDINGS || SC.LOG_OBSERVERS) {
@@ -105,14 +116,14 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
   */
   flushAllPending: function() {
     var didChange ;
-    
+
     do {
       didChange = this.flushApplicationQueues() ;
-      if (!didChange) didChange = this._flushinvokeLastQueue() ; 
+      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
@@ -134,9 +145,38 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
       method = target; target = this ;
     }
 
+    var deferredCallLoggingInfo;      // Used only in debug mode
+
+    //@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
+    // SC.Object#invokeOnce().
+    //
+    // If it was not specified, we'll record the originating function ourselves.
+    var shouldLog = SC.LOG_DEFERRED_CALLS;
+    if (shouldLog) {
+      var originatingTarget = arguments[2],
+          originatingMethod = arguments[3],
+          originatingStack  = arguments[4];
+
+      if (!originatingTarget) originatingTarget = null;   // More obvious when debugging
+      if (!originatingMethod) {
+        originatingStack  = SC._getRecentStack();
+        originatingMethod = originatingStack[0];
+      }
+
+      deferredCallLoggingInfo = {
+        originatingTarget: originatingTarget,
+        originatingMethod: originatingMethod,
+        originatingStack:  originatingStack
+      };
+    }
+    //@endif
+
     if (typeof method === "string") method = target[method];
     if (!this._invokeQueue) this._invokeQueue = SC.ObserverSet.create();
-    if ( method ) this._invokeQueue.add(target, method);
+    if ( method ) this._invokeQueue.add(target, method, undefined, deferredCallLoggingInfo);
     return this ;
   },
 
@@ -165,9 +205,69 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
       method = target; target = this ;
     }
 
+    var deferredCallLoggingInfo;      // Used only in debug mode
+
+    //@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
+    // SC.Object#invokeOnce().
+    //
+    // If it was not specified, we'll record the originating function ourselves.
+    var shouldLog = SC.LOG_DEFERRED_CALLS;
+    if (shouldLog) {
+      var originatingTarget = arguments[2],
+          originatingMethod = arguments[3],
+          originatingStack  = arguments[4];
+
+      if (!originatingTarget) originatingTarget = null;   // More obvious when debugging
+      if (!originatingMethod) {
+        originatingStack  = SC._getRecentStack();
+        originatingMethod = originatingStack[0];
+      }
+
+      deferredCallLoggingInfo = {
+        originatingTarget: originatingTarget,
+        originatingMethod: originatingMethod,
+        originatingStack:  originatingStack
+      };
+    }
+    //@endif
+
+
     if (typeof method === "string") method = target[method];
     if (!this._invokeLastQueue) this._invokeLastQueue = SC.ObserverSet.create();
-    this._invokeLastQueue.add(target, method);
+    this._invokeLastQueue.add(target, method, undefined, deferredCallLoggingInfo);
+    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.
+
+    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.
+
+    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) {
+    // normalize
+    if (method === undefined) {
+      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 ;
   },
 
@@ -210,10 +310,55 @@ SC.RunLoop = SC.Object.extend(/** @scope SC.RunLoop.prototype */ {
       if (hadContent) queue.invokeMethods();
     }
     return hadContent ;
+  },
+
+  _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 ;
   }
 
 });
 
+
+//@if(debug)
+ /**
+  Will return the recent stack as a hash with numerical keys, for nice output
+  in some browsers’ debuggers.  The “recent” stack is capped at 6 entries.
+
+  This is used by, amongst other places, SC.LOG_DEFERRED_CALLS.
+
+  @returns {Hash}
+*/
+SC._getRecentStack = function() {
+  var currentFunction = arguments.callee.caller,
+      i               = 0,
+      stack           = {},
+      first           = YES,
+      functionName;
+
+  while (currentFunction  &&  i < 10) {
+    // Skip ourselves!
+    if (first) {
+      first = NO;
+    }
+    else {
+      functionName = currentFunction.displayName || currentFunction.toString().substring(0, 40);
+      stack[i++]   = functionName;
+    }
+    currentFunction = currentFunction.caller;
+  }
+
+  return stack;
+};
+//@endif
+
+
+
 /**
   The current run loop.  This is created automatically the first time you
   call begin().
@@ -258,6 +403,20 @@ SC.RunLoop.end = function() {
   return this ;
 } ;
 
+
+/**
+  Call this to kill the current run loop--stopping all propagation of bindings
+  and observers and clearing all timers.
+
+  This is useful if you are popping up an error catcher: you need a run loop
+  for the error catcher, but you don't want the app itself to continue
+  running.
+*/
+SC.RunLoop.kill = function() {
+  this.currentRunLoop = this.runLoopClass.create();
+  return this;
+};
+
 /**
   Returns YES when a run loop is in progress
 
@@ -269,13 +428,13 @@ SC.RunLoop.isRunLoopInProgress = function() {
 };
 
 /**
-  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 
+  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, starts/ends a new runloop even if one is already running
@@ -296,7 +455,7 @@ SC.run = function(callback, target, forceNested) {
       // If the exception was not handled, 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 (!handled && !SC.browser.msie) {
+      if (!handled && !SC.browser.isIE) {
         throw e;
       }
     }
@@ -306,3 +465,19 @@ SC.run = function(callback, target, forceNested) {
     if(forceNested || !alreadyRunning) SC.RunLoop.end();
   }
 };
+
+/**
+  Wraps the passed function in code that ensures a run loop will
+  surround it when run.
+*/
+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();
+    return ret;
+  };
+  ret.wrapped = func;
+  return ret;
+};