sproutcore 1.5.0.pre.3 → 1.5.0.pre.4

data/lib/frameworks/sproutcore/frameworks/runtime/core.js

@@ -8,9 +8,9 @@
 /*global NodeList */
 // These commands are used by the build tools to control load order.  On the
 // client side these are a no-op.
-var require = require || function require() { } ;
-var sc_require = sc_require || require;
-var sc_resource = sc_resource || function sc_resource() {};
+if (!window.require) { window.require = function require(){}; }
+if (!window.sc_require) { window.sc_require = require };
+if (!window.sc_resource) {window.sc_resource = function sc_resource(){}; }
 sc_require('license') ;
 
 // ........................................
@@ -19,8 +19,8 @@ sc_require('license') ;
 // Most global constants should be defined inside of the SC namespace.
 // However the following two are useful enough and generally benign enough
 // to put into the global object.
-var YES = true ;
-var NO = false ;
+window.YES = true ;
+window.NO = false ;
 
 // prevent a console.log from blowing things up if we are on a browser that
 // does not support it
@@ -36,7 +36,7 @@ if (typeof console === 'undefined') {
 // rest of the methods go into the mixin defined below.
 
 /**
-  @version 1.5.0.pre.3
+  @version 1.5.0.pre.4
   @namespace
 
   The SproutCore namespace.  All SproutCore methods and functions are defined
@@ -54,10 +54,10 @@ if (typeof console === 'undefined') {
   The core Base framework is based on the jQuery API with a number of
   performance optimizations.
 */
-var SC = SC || {} ;
-var SproutCore = SproutCore || SC ;
+window.SC = window.SC || {} ;
+window.SproutCore = window.SproutCore || SC ;
 
-SC.VERSION = '1.5.0.pre.3';
+SC.VERSION = '1.5.0.pre.4';
 
 /**
   @private
@@ -198,7 +198,7 @@ SC.mixin(/** @scope SC */ {
     var nativeType = jQuery.type(item);
 
     if (nativeType === "function") {
-      return item.isClass ? SC.T_CLASS : SC.T_FUNCTION
+      return item.isClass ? SC.T_CLASS : SC.T_FUNCTION;
     } else if (nativeType === "object") {
       if (item.isError) {
         return SC.T_ERROR ;
@@ -255,8 +255,8 @@ SC.mixin(/** @scope SC */ {
       return false;
     } else if ( obj.objectAt ) {
       return true ;
-    } else if ( obj.length && jQuery.type(obj) === "object" ) {
-      return true
+    } else if ( obj.length !== undefined && jQuery.type(obj) === "object" ) {
+      return true;
     }
 
     return false;
@@ -309,7 +309,7 @@ SC.mixin(/** @scope SC */ {
   // GUIDS & HASHES
   //
 
-  guidKey: jQuery.expando,
+  guidKey: jQuery.expando || ("SproutCore" + ( SC.VERSION + Math.random() ).replace( /\D/g, "" )),
 
   // Used for guid generation...
   _guidPrefixes: {"number": "nu", "string": "st"},
@@ -327,13 +327,13 @@ SC.mixin(/** @scope SC */ {
     @returns {String} the unique guid for this instance.
   */
   guidFor: function(obj) {
+    var cache, ret,
+        type = typeof obj;
 
     // special cases where we don't want to add a key to object
     if (obj === undefined) return "(undefined)";
     if (obj === null) return "(null)";
 
-    var type = typeof obj;
-
     // Don't allow prototype changes to String etc. to change the guidFor
     if (type === SC.T_NUMBER || type === SC.T_STRING) {
       cache = this._guidCaches[type];
@@ -344,7 +344,7 @@ SC.mixin(/** @scope SC */ {
       }
       return ret;
     } else if (type === SC.T_BOOL) {
-      return (obj) ? "(true)" : "(false)"
+      return (obj) ? "(true)" : "(false)";
     }
 
     var guidKey = this.guidKey;
@@ -355,9 +355,6 @@ SC.mixin(/** @scope SC */ {
     if (obj === Object) return '(Object)';
     if (obj === Array) return '(Array)';
 
-    var cache, ret;
-    var type = typeof obj;
-
     return SC.generateGuid(obj, "sc");
   },
 
@@ -615,8 +612,8 @@ SC.mixin(/** @scope SC */ {
       if ( deep ) {
         idx = ret.length;
         while ( idx-- ) { ret[idx] = SC.copy( ret[idx], true ); }
-        break ;
       }
+      break ;
 
     case "object":
       ret = {} ;
@@ -815,6 +812,11 @@ SC.Function = {
     return fn ;
   },
 
+  enhance: function(fn) {
+    fn.isEnhancement = true;
+    return fn ;
+  },
+
   observes: function(fn, propertyPaths) {
     // sort property paths into local paths (i.e just a property name) and
     // full paths (i.e. those with a . or * in them)
@@ -835,7 +837,7 @@ SC.Function = {
     return fn ;
   }
 
-}
+};
 
 SC.mixin(Function.prototype,
 /** @lends Function.prototype */ {
@@ -949,7 +951,7 @@ SC.mixin(Function.prototype,
     @returns {Function} the declared function instance
   */
   property: function() {
-    return SC.Function.property(this, arguments)
+    return SC.Function.property(this, arguments);
   },
 
   /**
@@ -988,7 +990,11 @@ SC.mixin(Function.prototype,
     @returns {Function} receiver
   */
   idempotent: function(aFlag) {
-    return SC.Function.idempotent(this, aFlag)
+    return SC.Function.idempotent(this, aFlag);
+  },
+
+  enhance: function() {
+    return SC.Function.enhance(this);
   },
 
   /**
@@ -1014,8 +1020,8 @@ SC.CoreString = {
     }) ;
   },
   loc: function(str, formats) {
-    var str = SC.STRINGS[str] || str;
-    return SC.String.fmt(str, arguments) ;
+    str = SC.STRINGS[str] || str;
+    return SC.CoreString.fmt(str, arguments) ;
   },
   w: function(str) {
     var ary = [], ary2 = str.split(' '), len = ary2.length, string, idx=0;
@@ -1025,7 +1031,7 @@ SC.CoreString = {
     }
     return ary ;
   }
-}
+};
 
 SC.mixin(String.prototype,
 /** @lends Function.prototype */ {

data/lib/frameworks/sproutcore/frameworks/runtime/debug/test_suites/array/base.js

@@ -5,7 +5,7 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-/*globals module test ok equals same CoreTest */
+/*globals module test ok equals same SC */
 
 /**
   Adds a new module of unit tests to verify that the passed object implements
@@ -41,10 +41,169 @@
       });
     }
   }}}
+*/
+
+SC.TestSuite = /** @scope SC.TestSuite.prototype */ {
+
+  /**
+    Call this method to define a new test suite.  Pass one or more hashes of
+    properties you want added to the new suite.  
+    
+    @param {Hash} attrs one or more attribute hashes
+    @returns {SC.TestSuite} subclass of suite.
+  */
+  create: function(desc, attrs) {
+    var len = arguments.length,
+        ret = SC.beget(this),
+        idx;
+        
+    // copy any attributes
+    for(idx=1;idx<len;idx++) SC.mixin(ret, arguments[idx]);
+    
+    if (desc) ret.basedesc = desc;
+    
+    // clone so that new definitions will be kept separate
+    ret.definitions = ret.definitions.slice();
+    
+    return ret ;
+  },
+
+  /**
+    Generate a new test suite instance, adding the suite definitions to the 
+    current test plan.  Pass a description of the test suite as well as one or
+    more attribute hashes to apply to the test plan.
+    
+    The description you add will be prefixed in front of the 'desc' property
+    on the test plan itself.
+    
+    @param {String} desc suite description
+    @param {Hash} attrs one or more attribute hashes
+    @returns {SC.TestSuite} suite instance
+  */
+  generate: function(desc, attrs) {
+    var len = arguments.length,
+        ret = SC.beget(this),
+        idx, defs;
+        
+    // apply attributes - skip first argument b/c it is a string
+    for(idx=1;idx<len;idx++) SC.mixin(ret, arguments[idx]);    
+    ret.subdesc = desc ;
+    
+    // invoke definitions
+    defs = ret.definitions ;
+    len = defs.length;
+    for(idx=0;idx<len;idx++) defs[idx].call(ret, ret);
+    
+    return ret ;
+  },
+  
+  /**
+    Adds the passed function to the array of definitions that will be invoked
+    when the suite is generated.
+    
+    The passed function should expect to have the TestSuite instance passed
+    as the first and only parameter.  The function should actually define 
+    a module and tests, which will be added to the test suite.
+    
+    @param {Function} func definition function
+    @returns {SC.TestSuite} receiver
+  */
+  define: function(func) {
+    this.definitions.push(func);
+    return this ;
+  },
   
+  /** 
+    Definition functions.  These are invoked in order when  you generate a 
+    suite to add unit tests and modules to the test plan.
+  */
+  definitions: [],
   
-*/
-SC.ArraySuite = CoreTest.Suite.create("Verify SC.Array compliance: %@#%@", {
+  /**
+    Generates a module description by merging the based description, sub 
+    description and the passed description.  This is usually used inside of 
+    a suite definition function.
+    
+    @param {String} str detailed description for this module
+    @returns {String} generated description
+  */
+  desc: function(str) {
+    return this.basedesc.fmt(this.subdesc, str);
+  },
+  
+  /**
+    The base description string.  This should accept two formatting options,
+    a sub description and a detailed description.  This is the description
+    set when you call extend()
+  */
+  basedesc: "%@ > %@",
+  
+  /**
+    Default setup method for use with modules.  This method will call the
+    newObject() method and set its return value on the object property of 
+    the receiver.
+  */
+  setup: function() {
+    this.object = this.newObject();
+  },
+  
+  /**
+    Default teardown method for use with modules.  This method will call the
+    destroyObejct() method, passing the current object property on the 
+    receiver.  It will also clear the object property.
+  */
+  teardown: function() {
+    if (this.object) this.destroyObject(this.object);
+    this.object = null;
+  },
+  
+  /**
+    Default method to create a new object instance.  You will probably want
+    to override this method when you generate() a suite with a function that
+    can generate the type of object you want to test.
+    
+    @returns {Object} generated object
+  */
+  newObject: function() { return null; },
+  
+  /**
+    Default method to destroy a generated object instance after a test has 
+    completed.  If you override newObject() you can also overried this method
+    to cleanup the object you just created.
+    
+    Default method does nothing.
+  */
+  destroyObject: function(obj) { 
+    // do nothing.
+  },
+  
+  /**
+    Generates a default module with the description you provide.  This is 
+    a convenience function for use inside of a definition function.  You could
+    do the same thing by calling:
+    
+    {{{
+      var T = this ;
+      module(T.desc(description), {
+        setup: function() { T.setup(); },
+        teardown: function() { T.teardown(); }
+      }
+    }}}
+    
+    @param {String} desc detailed descrition
+    @returns {SC.TestSuite} receiver
+  */
+  module: function(desc) {
+    var T = this ;
+    module(T.desc(desc), {
+      setup: function() { T.setup(); },
+      teardown: function() { T.teardown(); }
+    });
+  }
+  
+};
+
+SC.ArraySuite = SC.TestSuite.create("Verify SC.Array compliance: %@#%@", {
   
   /** 
     Override to return a set of simple values such as numbers or strings.

data/lib/frameworks/sproutcore/frameworks/runtime/mixins/array.js

@@ -367,7 +367,7 @@ SC.Array = {
     The callback for a range observer should have the signature:
 
     {{{
-      function rangePropertyDidChange(array, objects, key, indexes, conext)
+      function rangePropertyDidChange(array, objects, key, indexes, context)
     }}}
 
     If the passed key is '[]' it means that the object itself changed.
@@ -448,9 +448,11 @@ SC.Array = {
     @param {Number} start the starting index of the change
     @param {Number} amt the final range of objects changed
     @param {Number} delta if you added or removed objects, the delta change
+    @param {Array} addedObjects the objects that were added
+    @param {Array} removedObjects the objects that were removed
     @returns {SC.Array} receiver
   */
-  enumerableContentDidChange: function(start, amt, delta) {
+  enumerableContentDidChange: function(start, amt, delta, addedObjects, removedObjects) {
     var rangeob = this._array_rangeObservers,
         oldlen  = this._array_oldLength,
         newlen, length, changes ;
@@ -482,6 +484,7 @@ SC.Array = {
       changes.add(start, length);
     }
 
+    this._setupEnumerableObservers(addedObjects, removedObjects);
     this.notifyPropertyChange('[]') ;
     this.endPropertyChanges();
 
@@ -588,19 +591,21 @@ if (!Array.prototype.lastIndexOf) {
 
     // primitive for array support.
     replace: function(idx, amt, objects) {
+      var removedObjects;
+
       if (this.isFrozen) throw SC.FROZEN_ERROR ;
       if (!objects || objects.length === 0) {
-        this.splice(idx, amt) ;
+        removedObjects = this.splice(idx, amt) ;
       } else {
         var args = [idx, amt].concat(objects) ;
-        this.splice.apply(this,args) ;
+        removedObjects = this.splice.apply(this,args) ;
       }
 
       // if we replaced exactly the same number of items, then pass only the
       // replaced range.  Otherwise, pass the full remaining array length
       // since everything has shifted
       var len = objects ? (objects.get ? objects.get('length') : objects.length) : 0;
-      this.enumerableContentDidChange(idx, amt, len - amt) ;
+      this.enumerableContentDidChange(idx, amt, len - amt, objects, removedObjects) ;
       return this ;
     },
 

data/lib/frameworks/sproutcore/frameworks/runtime/mixins/enumerable.js

@@ -5,8 +5,8 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-require('core') ;
-require('system/enumerator');
+sc_require('core') ;
+sc_require('system/enumerator');
 
 /*globals Prototype */
 
@@ -815,13 +815,133 @@ SC.Reducers = /** @lends SC.Enumerable */ {
 
     @param {Number} start optional start offset for the content change
     @param {Number} length optional length of change
+    @param {Number} delta if you added or removed objects, the delta change
+    @param {Array} addedObjects the objects that were added
+    @param {Array} removedObjects the objects that were removed
     @returns {Object} receiver
   */
-  enumerableContentDidChange: function(start, length) {
+  enumerableContentDidChange: function(start, length, delta, addedObjects, removedObjects) {
+    this._setupEnumerableObservers(addedObjects, removedObjects);
     this.notifyPropertyChange('[]') ;
+
     return this ;
   },
 
+  /**
+    @private
+
+    Clones a segment of an observer chain and applies it
+    to an element of this Enumerable.
+
+    @param {SC._ChainObserver} chainObserver the chain segment to begin from
+  */
+  _resumeChainObservingForItemWithChainObserver: function(item, chainObserver) {
+    var observer = SC.clone(chainObserver.next);
+    var key = observer.property;
+
+    // The chain observer should create new observers on the child object
+    observer.object = item;
+    item.addObserver(key, observer, observer.propertyDidChange);
+
+    // if we're in the initial chained observer setup phase, add the tail
+    // of the current observer segment to the list of tracked tails.
+    if(chainObserver.root.tails) {
+      chainObserver.root.tails.pushObject(observer.tail());
+    }
+
+    observer.propertyDidChange();
+
+    // Maintain a list of observers on the item so we can remove them
+    // if it is removed from the enumerable.
+    item._kvo_for(SC.keyFor('_kvo_enumerable_observers', key)).push(observer);
+  },
+
+  /**
+    @private
+
+    When enumerable content has changed, remove enumerable observers from
+    items that are no longer in the enumerable, and add observers to newly
+    added items.
+
+    @param {Array} addedObjects the array of objects that have been added
+    @param {Array} removedObjects the array of objects that have been removed
+  */
+  _setupEnumerableObservers: function(addedObjects, removedObjects) {
+    if (!addedObjects) { addedObjects = this; }
+    if (!removedObjects) { removedObjects = []; }
+
+    var observedKeys = this._kvo_for('_kvo_enumerable_observed_keys', SC.CoreSet);
+    var kvoKey;
+
+    // Only setup and teardown enumerable observers if we have keys to observe
+    if (observedKeys.get('length') > 0) {
+      // Loop through removed objects and remove any enumerable observers that
+      // belong to them.
+      removedObjects.forEach(function(item) {
+        item._kvo_for('_kvo_enumerable_observers').forEach(function(observer) {
+          // Remove the observer if it is pointing at this enumerable.
+          // If the observer belongs to another enumerable, just ignore it.
+          if (observer.object === this) {
+            item.removeObserver(observer.key, observer, observer.propertyDidChange);
+          }
+        });
+      });
+
+      // added and resume the chain observer.
+      observedKeys.forEach(function(key) {
+        kvoKey = SC.keyFor('_kvo_enumerable_observers', key);
+
+        var lastObserver;
+
+        // Get all original ChainObservers associated with the key
+        this._kvo_for(kvoKey).forEach(function(observer) {
+          // if there are no added objects or removed objects, this
+          // object is a proxy (like ArrayController), which does
+          // not currently receive the added or removed objects.
+          // As a result, walk down to the last element of the
+          // chain and trigger its propertyDidChange, which will
+          // invalidate anything listening.
+          if(!addedObjects.get('length') && !removedObjects.get('length')) {
+            lastObserver = observer;
+            while(lastObserver.next) { lastObserver = lastObserver.next; }
+            lastObserver.propertyDidChange();
+          } else {
+            addedObjects.forEach(function(item) {
+              this._resumeChainObservingForItemWithChainObserver(item, observer);
+            }, this);
+          }
+        }, this);
+      }, this);
+    }
+  },
+
+  /**
+    @private
+
+    Adds an enumerable observer. Enumerable observers are able to
+    propagate chain observers to each member item in the enumerable,
+    so that the observer is fired whenever a single item changes.
+
+    You should never call this method directly. Instead, you should
+    call addObserver() with the special '[]' property in the path.
+
+    For example, if you wanted to observe changes to each item's isDone
+    property, you could call:
+
+        arrayController.addObserver('[].isDone');
+  */
+  addEnumerableObserver: function(key, target, action) {
+    // Add the key to a set so we know what we are observing
+    this._kvo_for('_kvo_enumerable_observed_keys', SC.CoreSet).push(key);
+
+    // Add the passed ChainObserver to an ObserverSet for that key
+    var kvoKey = SC.keyFor('_kvo_enumerable_observers', key);
+    this._kvo_for(kvoKey).push(target);
+
+    // set up chained observers on the initial content
+    this._setupEnumerableObservers(this);
+  },
+
   /**
     Call this method from your unknownProperty() handler to implement
     automatic reduced properties.  A reduced property is a property that

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

@@ -5,7 +5,8 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-require('private/observer_set') ;
+sc_require('private/observer_set');
+sc_require('private/chain_observer');
 
 /*globals logChange */
 
@@ -523,10 +524,16 @@ SC.Observable = {
     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) ;
+      if (dep.indexOf('.') >= 0) {
+        this.addObserver(dep, this, function() {
+          this.propertyDidChange(key);
+        });
+      } else {
+        // add dependent key to dependents array of key it depends on
+        queue = dependents[dep] ;
+        if (!queue) { queue = dependents[dep] = [] ; }
+        queue.push(key) ;
+      }
     }
   },