sproutcore 1.9.2 → 1.10.0.rc.1

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

@@ -4,14 +4,14 @@
 //            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
+/*global jQuery, require, console */
 
-/*global NodeList */
 // These commands are used by the build tools to control load order.  On the
 // client side these are a no-op.
-if (!window.require) { window.require = function require(){}; }
+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') ;
+if (!window.sc_resource) { window.sc_resource = function sc_resource() {}; }
+sc_require('license');
 
 // ........................................
 // GLOBAL CONSTANTS
@@ -19,18 +19,18 @@ 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.
-window.YES = true ;
-window.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
 if (typeof console === 'undefined') {
-  window.console = {} ;
-  console.log = console.info = console.warn = console.error = function(){};
+  window.console = {};
+  console.log = console.info = console.warn = console.error = function () {};
 }
 
-window.SC = window.SC || {} ;
-window.SproutCore = window.SproutCore || SC ;
+window.SC = window.SC || {};
+window.SproutCore = window.SproutCore || SC;
 
 // ........................................
 // BOOTSTRAP
@@ -39,7 +39,7 @@ window.SproutCore = window.SproutCore || SC ;
 // rest of the methods go into the mixin defined below.
 
 /**
-  @version 1.9.2
+  @version Edge
   @namespace
 
   All SproutCore methods and functions are defined
@@ -59,7 +59,7 @@ window.SproutCore = window.SproutCore || SC ;
 */
 SC = window.SC; // This is dumb but necessary for jsdoc to get it right
 
-SC.VERSION = '1.9.2';
+SC.VERSION = '1.10.0';
 
 /**
   @private
@@ -78,26 +78,26 @@ SC.VERSION = '1.9.2';
   @static
 */
 SC._baseMixin = function (override) {
-  var args = Array.prototype.slice.call(arguments, 1), src,
+  var args = Array.prototype.slice.call(arguments, 1),
   // copy reference to target object
       target = args[0] || {},
       idx = 1,
-      length = args.length ,
-      options, copy , key;
+      length = args.length,
+      options, copy, key;
 
   // Handle case where we have only one item...extend SC
   if (length === 1) {
     target = this || {};
-    idx=0;
+    idx = 0;
   }
 
-  for ( ; idx < length; idx++ ) {
-    if (!(options = args[idx])) continue ;
-    for(key in options) {
-      if (!options.hasOwnProperty(key)) continue ;
-      copy = options[key] ;
-      if (target===copy) continue ; // prevent never-ending loop
-      if (copy !== undefined && ( override || (target[key] === undefined) )) target[key] = copy ;
+  for (; idx < length; idx++) {
+    if (!(options = args[idx])) continue;
+    for (key in options) {
+      if (!options.hasOwnProperty(key)) continue;
+      copy = options[key];
+      if (target === copy) continue; // prevent never-ending loop
+      if (copy !== undefined && (override || (target[key] === undefined))) target[key] = copy;
     }
     // Manually copy toString() because some JS engines do not enumerate it
     // (such as IE8)
@@ -105,7 +105,7 @@ SC._baseMixin = function (override) {
   }
 
   return target;
-} ;
+};
 
 /**
   Adds properties to a target object.
@@ -118,11 +118,11 @@ SC._baseMixin = function (override) {
   @returns {Object} the target object.
   @static
 */
-SC.mixin = function() {
+SC.mixin = function () {
   var args = Array.prototype.slice.call(arguments);
   args.unshift(true);
   return SC._baseMixin.apply(this, args);
-} ;
+};
 
 /**
   Adds properties to a target object.  Unlike SC.mixin, however, if the target
@@ -136,17 +136,17 @@ SC.mixin = function() {
   @returns {Object} the target object.
   @static
 */
-SC.supplement = function() {
+SC.supplement = function () {
   var args = Array.prototype.slice.call(arguments);
   args.unshift(false);
   return SC._baseMixin.apply(this, args);
-} ;
+};
 
 /**
   Alternative to mixin.  Provided for compatibility with jQuery.
   @function
 */
-SC.extend = SC.mixin ;
+SC.extend = SC.mixin;
 
 // ..........................................................
 // CORE FUNCTIONS
@@ -199,9 +199,9 @@ SC.mixin(/** @scope window.SC.prototype */ {
             SC.T_HASH: A JavaScript object not inheriting from SC.Object, <br>
             SC.T_ERROR: A SproutCore SC.Error object <br>
   */
-  typeOf: function(item) {
-    if (item === undefined) return SC.T_UNDEFINED ;
-    if (item === null) return SC.T_NULL ;
+  typeOf: function (item) {
+    if (item === undefined) return SC.T_UNDEFINED;
+    if (item === null) return SC.T_NULL;
 
     var nativeType = jQuery.type(item);
 
@@ -233,7 +233,8 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj value to test
     @returns {Boolean}
   */
-  none: function(obj) {
+  none: function (obj) {
+    /*jshint eqnull:true */
     return obj == null;
   },
 
@@ -244,7 +245,7 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj value to test
     @returns {Boolean}
   */
-  empty: function(obj) {
+  empty: function (obj) {
     return obj === null || obj === undefined || obj === '';
   },
 
@@ -263,7 +264,7 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj the object to test
     @returns {Boolean}
   */
-  isArray: function(obj) {
+  isArray: function (obj) {
     if (!obj || obj.setInterval) { return false; }
     if (Array.isArray && Array.isArray(obj)) { return true; }
     if (obj.objectAt) { return true; }
@@ -280,7 +281,7 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj object to convert
     @returns {Array} Actual array
   */
-  makeArray: function(obj) {
+  makeArray: function (obj) {
     return SC.isArray(obj) ? obj : SC.A(obj);
   },
 
@@ -292,27 +293,27 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} object any enumerable or array-like object.
     @returns {Array} Array of items
   */
-  A: function(obj) {
+  A: function (obj) {
     // null or undefined -- fast path
-    if ( obj === null || obj === undefined ) return [] ;
+    if (obj === null || obj === undefined) return [];
 
     // primitive -- fast path
-    if ( obj.slice instanceof Function ) {
+    if (obj.slice instanceof Function) {
       // do we have a string?
-      if ( typeof(obj) === 'string' ) return [obj] ;
-      else return obj.slice() ;
+      if (typeof(obj) === 'string') return [obj];
+      else return obj.slice();
     }
 
     // enumerable -- fast path
-    if (obj.toArray) return obj.toArray() ;
+    if (obj.toArray) return obj.toArray();
 
     // if not array-like, then just wrap in array.
     if (!SC.isArray(obj)) return [obj];
 
     // when all else fails, do a manual convert...
     var ret = [], len = obj.length;
-    while(--len >= 0) ret[len] = obj[len];
-    return ret ;
+    while (--len >= 0) ret[len] = obj[len];
+    return ret;
   },
 
   //
@@ -320,12 +321,14 @@ SC.mixin(/** @scope window.SC.prototype */ {
   //
 
   // Like jQuery.expando but without any risk of conflict
-  guidKey: "SproutCore" + ( SC.VERSION + Math.random() ).replace( /\D/g, "" ),
+  guidKey: "SproutCore" + (SC.VERSION + Math.random()).replace(/\D/g, ""),
 
   // Used for guid generation...
   _guidPrefixes: {"number": "nu", "string": "st"},
   _guidCaches:   {"number": {},   "string": {}},
-  _numberGuids: [], _stringGuids: {}, _keyCache: {},
+  _numberGuids: [],
+  _stringGuids: {},
+  _keyCache: {},
 
   /**"
     Returns a unique GUID for the object.  If the object does not yet have
@@ -337,7 +340,7 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj any object, string, number, Element, or primitive
     @returns {String} the unique guid for this instance.
   */
-  guidFor: function(obj) {
+  guidFor: function (obj) {
     var cache, ret,
         type = typeof obj;
 
@@ -349,7 +352,7 @@ SC.mixin(/** @scope window.SC.prototype */ {
     if (type === SC.T_NUMBER || type === SC.T_STRING) {
       cache = this._guidCaches[type];
       ret   = cache[obj];
-      if(!ret) {
+      if (!ret) {
         ret        = "st" + (jQuery.uuid++);
         cache[obj] = ret;
       }
@@ -378,12 +381,12 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {String} key The key
     @returns {String} result
   */
-  keyFor: function(prefix, key) {
+  keyFor: function (prefix, key) {
     var ret, pcache = this._keyCache[prefix];
     if (!pcache) pcache = this._keyCache[prefix] = {}; // get cache for prefix
     ret = pcache[key];
-    if (!ret) ret = pcache[key] = prefix + '_' + key ;
-    return ret ;
+    if (!ret) ret = pcache[key] = prefix + '_' + key;
+    return ret;
   },
 
   /**
@@ -395,10 +398,10 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {String} prefix prefixes the generated guid
     @returns {String} the guid
   */
-  generateGuid: function(obj, prefix) {
+  generateGuid: function (obj, prefix) {
     var ret = (prefix + (jQuery.uuid++));
-    if (obj) obj[this.guidKey] = ret ;
-    return ret ;
+    if (obj) obj[this.guidKey] = ret;
+    return ret;
   },
 
   /**
@@ -420,12 +423,12 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object...} objects the object(s)
     @returns {String} the hash code for this instance.
   */
-  hashFor: function() {
+  hashFor: function () {
     var l = arguments.length,
-        h = '',
-        obj, f, i;
+      h = '',
+      obj, f, i;
 
-    for (i=0 ; i<l; ++i) {
+    for (i = 0; i < l; ++i) {
       obj = arguments[i];
       h += (obj && (f = obj.hash) && (typeof f === SC.T_FUNCTION)) ? f.call(obj) : this.guidFor(obj);
     }
@@ -441,10 +444,10 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @returns {Boolean} YES if the two have equal hash code values.
 
   */
-  isEqual: function(a,b) {
+  isEqual: function (a, b) {
     // QUESTION: is there a compelling performance reason to special-case
     // undefined here?
-    return this.hashFor(a) === this.hashFor(b) ;
+    return this.hashFor(a) === this.hashFor(b);
   },
 
   /**
@@ -493,44 +496,44 @@ SC.mixin(/** @scope window.SC.prototype */ {
 
     // ok - types are equal - so we have to check values now
     switch (type1) {
-      case SC.T_BOOL:
-      case SC.T_NUMBER:
-        if (v<w) return -1;
-        if (v>w) return 1;
-        return 0;
-
-      case SC.T_STRING:
-        var comp = v.localeCompare(w);
-        if (comp<0) return -1;
-        if (comp>0) return 1;
-        return 0;
-
-      case SC.T_ARRAY:
-        var vLen = v.length;
-        var wLen = w.length;
-        var l = Math.min(vLen, wLen);
-        var r = 0;
-        var i = 0;
-        var thisFunc = arguments.callee;
-        while (r===0 && i < l) {
-          r = thisFunc(v[i],w[i]);
-          i++;
-        }
-        if (r !== 0) return r;
-
-        // all elements are equal now
-        // shorter array should be ordered first
-        if (vLen < wLen) return -1;
-        if (vLen > wLen) return 1;
-        // arrays are equal now
-        return 0;
-
-      case SC.T_OBJECT:
-        if (v.constructor.isComparable === YES) return v.constructor.compare(v, w);
-        return 0;
-
-      default:
-        return 0;
+    case SC.T_BOOL:
+    case SC.T_NUMBER:
+      if (v < w) return -1;
+      if (v > w) return 1;
+      return 0;
+
+    case SC.T_STRING:
+      var comp = v.localeCompare(w);
+      if (comp < 0) return -1;
+      if (comp > 0) return 1;
+      return 0;
+
+    case SC.T_ARRAY:
+      var vLen = v.length;
+      var wLen = w.length;
+      var l = Math.min(vLen, wLen);
+      var r = 0;
+      var i = 0;
+      var thisFunc = arguments.callee;
+      while (r === 0 && i < l) {
+        r = thisFunc(v[i], w[i]);
+        i++;
+      }
+      if (r !== 0) return r;
+
+      // all elements are equal now
+      // shorter array should be ordered first
+      if (vLen < wLen) return -1;
+      if (vLen > wLen) return 1;
+      // arrays are equal now
+      return 0;
+
+    case SC.T_OBJECT:
+      if (v.constructor.isComparable === YES) return v.constructor.compare(v, w);
+      return 0;
+
+    default:
+      return 0;
     }
   },
 
@@ -543,7 +546,7 @@ SC.mixin(/** @scope window.SC.prototype */ {
 
     @returns {Object}
   */
-  K: function() { return this; },
+  K: function () { return this; },
 
   /**
     Empty array.  Useful for some optimizations.
@@ -587,13 +590,14 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj the object to beget
     @returns {Object} the new object.
   */
-  beget: function(obj) {
-    if (obj === null || obj === undefined) return null ;
-    var K = SC.K; K.prototype = obj ;
+  beget: function (obj) {
+    if (obj === null || obj === undefined) return null;
+    var K = SC.K;
+    K.prototype = obj;
     var ret = new K();
-    K.prototype = null ; // avoid leaks
+    K.prototype = null; // avoid leaks
     if (typeof obj.didBeget === "function") ret = obj.didBeget(ret);
-    return ret ;
+    return ret;
   },
 
   /**
@@ -608,31 +612,31 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Boolean} deep if true, a deep copy of the object is made
     @returns {Object} the cloned object
   */
-  copy: function(object, deep) {
-    var ret = object, idx ;
+  copy: function (object, deep) {
+    var ret = object, idx;
 
     // fast paths
-    if ( object ) {
-      if ( object.isCopyable ) return object.copy( deep );
-      if ( object.clone )      return object.clone();
+    if (object) {
+      if (object.isCopyable) return object.copy(deep);
+      if (object.clone)      return object.clone();
     }
 
-    switch ( jQuery.type(object) ) {
+    switch (jQuery.type(object)) {
     case "array":
       ret = object.slice();
 
-      if ( deep ) {
+      if (deep) {
         idx = ret.length;
-        while ( idx-- ) { ret[idx] = SC.copy( ret[idx], true ); }
+        while (idx--) { ret[idx] = SC.copy(ret[idx], true); }
       }
-      break ;
+      break;
 
     case "object":
-      ret = {} ;
-      for(var key in object) { ret[key] = deep ? SC.copy(object[key], true) : object[key] ; }
+      ret = {};
+      for (var key in object) { ret[key] = deep ? SC.copy(object[key], true) : object[key]; }
     }
 
-    return ret ;
+    return ret;
   },
 
   /**
@@ -641,10 +645,10 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object...} object one or more objects
     @returns {Object} new Object
   */
-  merge: function() {
+  merge: function () {
     var ret = {}, len = arguments.length, idx;
-    for(idx=0; idx<len; idx++) SC.mixin(ret, arguments[idx]);
-    return ret ;
+    for (idx = 0; idx < len; idx++) SC.mixin(ret, arguments[idx]);
+    return ret;
   },
 
   /**
@@ -654,9 +658,9 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} obj The Object
     @returns {Array} array of keys
   */
-  keys: function(obj) {
+  keys: function (obj) {
     var ret = [];
-    for(var key in obj) ret.push(key);
+    for (var key in obj) ret.push(key);
     return ret;
   },
 
@@ -668,15 +672,15 @@ SC.mixin(/** @scope window.SC.prototype */ {
 
     @returns {String} A description of the object
   */
-  inspect: function(obj) {
-    var v, ret = [] ;
-    for(var key in obj) {
-      v = obj[key] ;
-      if (v === 'toString') continue ; // ignore useless items
-      if (SC.typeOf(v) === SC.T_FUNCTION) v = "function() { ... }" ;
-      ret.push(key + ": " + v) ;
+  inspect: function (obj) {
+    var v, ret = [];
+    for (var key in obj) {
+      v = obj[key];
+      if (v === 'toString') continue; // ignore useless items
+      if (SC.typeOf(v) === SC.T_FUNCTION) v = "function () { ... }";
+      ret.push(key + ": " + v);
     }
-    return "{" + ret.join(" , ") + "}" ;
+    return "{" + ret.join(" , ") + "}";
   },
 
   /**
@@ -691,20 +695,22 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Object} root optional parameter specifying the place to start
     @returns {Array} array with [object, property] if found or null
   */
-  tupleForPropertyPath: function(path, root) {
+  tupleForPropertyPath: function (path, root) {
+    // if passed nothing, return nothing.
+    if (path == null) return null;
 
     // if the passed path is itself a tuple, return it
-    if (typeof path === "object" && (path instanceof Array)) return path ;
+    if (typeof path === "object" && (path instanceof Array)) return path;
 
     // find the key.  It is the last . or first *
-    var key ;
-    var stopAt = path.indexOf('*') ;
-    if (stopAt < 0) stopAt = path.lastIndexOf('.') ;
-    key = (stopAt >= 0) ? path.slice(stopAt+1) : path ;
+    var key;
+    var stopAt = path.indexOf('*');
+    if (stopAt < 0) stopAt = path.lastIndexOf('.');
+    key = (stopAt >= 0) ? path.slice(stopAt + 1) : path;
 
     // convert path to object.
-    var obj = this.objectForPropertyPath(path, root, stopAt) ;
-    return (obj && key) ? [obj,key] : null ;
+    var obj = this.objectForPropertyPath(path, root, stopAt);
+    return (obj && key) ? [obj, key] : null;
   },
 
   /**
@@ -716,37 +722,39 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Integer} stopAt optional point to stop searching the path.
     @returns {Object} the found object or undefined.
   */
-  objectForPropertyPath: function(path, root, stopAt) {
+  objectForPropertyPath: function (path, root, stopAt) {
 
-    var loc, nextDotAt, key, max ;
+    var loc, nextDotAt, key, max;
 
-    if (!root) root = window ;
+    if (!root) root = window;
 
     // faster method for strings
-    if (SC.typeOf(path) === SC.T_STRING) {
-      if (stopAt === undefined) stopAt = path.length ;
-      loc = 0 ;
-      while((root) && (loc < stopAt)) {
-        nextDotAt = path.indexOf('.', loc) ;
+    if (typeof path === "string") {
+      if (stopAt === undefined) stopAt = path.length;
+      loc = 0;
+      while ((root) && (loc < stopAt)) {
+        nextDotAt = path.indexOf('.', loc);
         if ((nextDotAt < 0) || (nextDotAt > stopAt)) nextDotAt = stopAt;
         key = path.slice(loc, nextDotAt);
-        root = root.get ? root.get(key) : root[key] ;
-        loc = nextDotAt+1;
+        root = root.get ? root.get(key) : root[key];
+        loc = nextDotAt + 1;
       }
       if (loc < stopAt) root = undefined; // hit a dead end. :(
 
     // older method using an array
     } else {
+      loc = 0;
+      max = path.length;
+      key = null;
 
-      loc = 0; max = path.length; key = null;
-      while((loc < max) && root) {
+      while ((loc < max) && root) {
         key = path[loc++];
-        if (key) root = (root.get) ? root.get(key) : root[key] ;
+        if (key) root = (root.get) ? root.get(key) : root[key];
       }
-      if (loc < max) root = undefined ;
+      if (loc < max) root = undefined;
     }
 
-    return root ;
+    return root;
   },
 
   /**
@@ -758,9 +766,9 @@ SC.mixin(/** @scope window.SC.prototype */ {
     @param {Integer} stopAt optional point to stop searching the path.
     @returns {Object} the found object or throws an error.
   */
-  requiredObjectForPropertyPath: function(path, root, stopAt) {
+  requiredObjectForPropertyPath: function (path, root, stopAt) {
     var o = SC.objectForPropertyPath(path, root, stopAt);
-    if(!o) {
+    if (!o) {
       throw path + " could not be found";
     }
     return o;
@@ -769,13 +777,13 @@ SC.mixin(/** @scope window.SC.prototype */ {
 }); // end mixin
 
 /** @private Alias for SC.clone() */
-SC.clone = SC.copy ;
+SC.clone = SC.copy;
 
 /** @private Alias for SC.A() */
 SC.$A = SC.A;
 
 /** @private Provided for compatibility with old HTML templates. */
-SC.didLoad = SC.K ;
+SC.didLoad = SC.K;
 
 /** @private Used by SC.compare */
 SC.ORDER_DEFINITION = [ SC.T_ERROR,