sproutcore 0.9.14 → 0.9.15

data/frameworks/sproutcore/core.js

@@ -1,129 +1,218 @@
-//@license
 // ==========================================================================
-// SproutCore -- JavaScript Application Framework
-// copyright 2006-2008, Sprout Systems, Inc. and contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a 
-// copy of this software and associated documentation files (the "Software"), 
-// to deal in the Software without restriction, including without limitation 
-// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
-// and/or sell copies of the Software, and to permit persons to whom the 
-// Software is furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in 
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
-// DEALINGS IN THE SOFTWARE.
-//
-// For more information about SproutCore, visit http://www.sproutcore.com
-//
-//
-// ==========================================================================
-//@license
-
-// ==========================================================================
-// Utility Classes
+// SproutCore
 // Author: Charles Jolley
-// copyright 2006, Sprout Systems, Inc.
-//
-// This file contains a number of utility methods and classes used throughout
-// SproutCore. This should be loaded after your load Prototype but before you
-// load any other SproutCore objects.  In general, this is the only
-// dependency most SproutCore objects will have.
-//
+// copyright 2006-2008, Sprout Systems, Inc.
 // ==========================================================================
 
-if (!window.SC) {
-  /**
-    @namespace
-    
-    All objects live in the SproutCore namespace, which is also availabe in the
-    abbreviation SC.
-  */
-  SC = {};
-  SproutCore = SC ;
-}
-
-// this makes for some nicer to read code
-var YES = true ; var NO = false ;
-
 // this is used by the JavascriptCompile class on the server side.  You can
 // use this to automatically determine the order javascript files need to be
 // included in.  On the client side, this is a NOP.
-function require(file) { return null ; }
-
-// implement window.console.log() for IE.
-if (!window.console) { 
- window.console = { 
-   _output: [],
-   log: function(str) { this._output.push(str) ; },
-   tail: function(lines) { 
-     if (!lines) lines = 1 ;
-     var loc = this._output.length - lines ;
-     if (loc < 0) loc = 0 ;
-     var ret = [] ;
-     while(loc < this._output.length) {
-       ret.push(this._output[loc]) ; loc++ ;
-     }
-     return ret.join("\n");
-   }  
- } ;
+var require = require || function require() { } ;
+require('license') ;
+
+// ........................................
+// GLOBAL CONSTANTS
+// 
+// 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 ;
+
+// prevent a console.log from blowing things up if we are on a browser that
+// does not support it
+if (typeof console === 'undefined') {
+  var console = console || window.console || {} ;
+  console.log = console.info = console.warn = console.error = function(){};
 }
-window.logCount = 0 ;
 
 // ........................................
-// GENERAL UTILITIES
+// BOOTSTRAP
 // 
+// The root namespace and some common utility methods are defined here. The
+// rest of the methods go into the mixin defined below.
 
-Object.extend(SC,{
+/**
+  @namespace
+  
+  The SproutCore namespace.  All SproutCore methods and functions are defined
+  inside of this namespace.  You generally should not add new properties to
+  this namespace as it may be overwritten by future versions of SproutCore.
+  
+  You can also use the shorthand "SC" instead of "SproutCore".
+  
+  SproutCore-Base is a framework that provides core functions for SproutCore
+  including cross-platform functions, support for property observing and
+  objects.  It's focus is on small size and performance.  You can use this 
+  in place of or along-side other cross-platform libraries such as jQuery or
+  Prototype.
+  
+  The core Base framework is based on the jQuery API with a number of 
+  performance optimizations.
+*/
+var SC = SC || {} ; 
+var SproutCore = SproutCore || SC ;
+
+/**
+  Adds properties to a target object.
+  
+  Takes the root object and adds the attributes for any additional 
+  arguments passed.  This can also perform a deep copy if the first param
+  is a bool that is YES.  This is generally not very safe though and not
+  advised.
+
+  @param deep {Boolean} optional parameter.  If true, triggers a deep copy.
+  @param target {Object} the target object to extend
+  @param properties {Object} one or more objects with properties to copy.
+  @returns {Object} the target object.
+  @static
+*/
+SC.mixin = function() {
+  // copy reference to target object
+  var target = arguments[0] || {};
+  var idx = 1;
+  var length = arguments.length ;
+  var deep = NO ;
+  var options ;
 
-  _downloadFrames: 0, // count of download frames inserted into document
+  // Handle case where we have only one item...extend SC
+  if (length === 1) {
+    target = this || {};
+    idx=0;
   
-	download: function(path) {
-    var tempDLIFrame=document.createElement('iframe');
-    var frameId = 'DownloadFrame_' + this._downloadFrames;
-    tempDLIFrame.setAttribute('id',frameId);
-    tempDLIFrame.style.border='10px';
-    tempDLIFrame.style.width='0px';
-    tempDLIFrame.style.height='0px';
-    tempDLIFrame.style.position='absolute';
-    tempDLIFrame.style.top='-10000px';
-    tempDLIFrame.style.left='-10000px';    
-    // Don't set the iFrame content yet if this is Safari
-    if (!(SC.isSafari())) {
-      tempDLIFrame.setAttribute('src',path);
+  // Handle a deep copy situation
+  } else if ((target===YES) || (target===NO)) {
+    deep = target;
+    target = arguments[1] || {};
+    idx = 2; // skip the boolean and the target
+  }
+
+  // Handle case when target is a string or something (possible in deep 
+  // copy)
+  if ( typeof target != "object" && typeof target != "function" ) {
+    target = {};
+  }
+
+  // extend SC itself if only one argument is passed
+  if ( length === idx ) {
+    target = this;
+    idx = idx-1;
+  }
+
+  for ( ; idx < length; idx++ ) {
+    if (!(options = arguments[idx])) continue ;
+    for(var key in options) {
+      if (!options.hasOwnProperty(key)) continue ;
+      
+      var src = target[key];
+      var copy = options[key] ;
+      if (target===copy) continue ; // prevent never-ending loop
+      
+      // Recurse if we're merging object values
+      if ( deep && copy && (typeof copy === "object") && !copy.nodeType ) {
+        copy = SC.extend(deep, 
+          src || (copy.length != null ? [ ] : { }), copy) ;
+      }
+      
+      if (copy !== undefined) target[key] = copy ;
     }
-    document.getElementsByTagName('body')[0].appendChild(tempDLIFrame);
-    if (SC.isSafari()) {
-      tempDLIFrame.setAttribute('src',path);    
+  }
+  
+  return target;
+} ;
+
+/** 
+  Alternative to mixin.  Provided for compatibility with jQuery.
+  @function 
+*/
+SC.extend = SC.mixin ;
+
+
+// Enough with the bootstrap code.  Let's define some core functions
+SC.mixin(/** @scope SC */ {
+  
+  // ........................................
+  // GLOBAL CONSTANTS
+  // 
+  T_ERROR:     'error',
+  T_OBJECT:    'object',
+  T_NULL:      'null',
+  T_CLASS:     'class',
+  T_HASH:      'hash',
+  T_FUNCTION:  'function',
+  T_UNDEFINED: 'undefined',
+  T_NUMBER:    'number',
+  T_BOOL:      'boolean',
+  T_ARRAY:     'array',
+  T_STRING:    'string',
+
+  // ........................................
+  // CORE HELPER METHODS
+  //   
+
+
+  /**
+    Creates a clone of the passed object.  This function can take just about
+    any type of object and create a clone of it, including primitive values
+    (which are not actually cloned because they are immutable).
+    
+    If the passed object implements the clone() method, then this function
+    will simply call that method and return the result.
+    
+    @param object {Object} the object to clone
+    @returns {Object} the cloned object
+  */
+  clone: function(object) {
+    var ret = object ;
+    switch (SC.typeOf(object)) {
+    case T_ARRAY:
+      if (object.clone && SC.typeOf(object.clone) === SC.T_FUNCTION) {
+        ret = object.clone() ;
+      } else ret = object.slice() ;
+      break ;
+    
+    case T_HASH:
+    case T_OBJECT:
+      if (object.clone && SC.typeOf(object.clone) === SC.T_FUNCTION) {
+        ret = object.clone() ;
+      } else {
+        ret = {} ;
+        for(var key in object) ret[key] = object[key] ;
+      }
     }
-    this._downloadFrames = this._downloadFrames + 1;
-    if (!(SC.isSafari())) {
-      var r = function() { 
-        document.body.removeChild(document.getElementById(frameId)); 
-				frameId = null;
-      } ;
-      var t = r.invokeLater(null, 2000);
+    
+    return ret ;
+  },
+  
+  /**  
+    Call this method during setup of your app to queue up methods to be 
+    called once the entire document has finished loading.  If you call this
+    method once the document has already loaded, then the function will be
+    called immediately.
+    
+    Any function you register with this method will be called just before
+    main.
+    
+    @param target {Object} optional target object.  Or just pass a method.
+    @param method {Function} the method to call.
+    @return {void}
+  */
+  callOnLoad: function(target, method) { 
+    
+    // normalize parameters
+    if (method === undefined) { method = target; target = null; }
+    if (typeof(method) === 'string') {
+      if (target) {
+        method = target[method] ;
+      } else {
+        throw "You must pass a function to callOnLoad() (got: "+method+")";
+      }
     }
-		//remove possible IE7 leak
-		tempDLIFrame = null;
-	},
-		
-  // Call this method during setup of your app to queue up methods to be 
-  // called once the entire document has finished loading.  If you call this
-  // method once the document has already loaded, then the function will be
-  // called immediately.
-  callOnLoad: function(func) { 
-    if (SC._onloadQueueFlushed) func.call(document);
-    var queue = SC._onloadQueue || [] ;
-    queue.push(func) ; SC._onloadQueue = queue ;
-	queue = null;
+
+    // invoke the method if the queue is flushed.
+    if (SC._onloadQueueFlushed) method.apply(target || window.document) ;
+    var queue = SC._onloadQueue = (SC._onloadQueue || []) ;
+    queue.push([target, method]) ;
   },
 
   // To flush the callOnLoad queue, you need to set window.onload=SC.didLoad
@@ -142,12 +231,17 @@ Object.extend(SC,{
       if (window.callOnLoad instanceof Array) {
         queue = window.callOnLoad ;
       } else if (window.callOnLoad instanceof Function) {
-        queue = [window.callOnLoad] ;
+        queue = [window, window.callOnLoad] ;
       }
     } else queue = [] ;
     queue = queue.concat(SC._onloadQueue) ;
     var func = null ;
-    while(func = queue.shift()) func.call(document) ;
+    while(func = queue.shift()) {
+      if (SC.typeOf(func) === T_FUNCTION) {
+        func.call(document) ;
+      } else func[1].call(func[0] || document) ;
+    }
+      
     SC._onloadQueueFlushed = true ;
         
     // start the app; call main.
@@ -161,29 +255,35 @@ Object.extend(SC,{
     }
     
     SC.runLoop.endRunLoop();
+    
 		//remove possible IE7 leak
 		b = null;
 		queue = null;
 		func = null;
   },
   
-  // this will take a URL of any type and convert it to a fully qualified URL.
-  normalizeURL: function(url) {
-    if (url.slice(0,1) == '/') {
-      url = window.location.protocol + '//' + window.location.host + url ;
-    } else if ((url.slice(0,5) == 'http:') || (url.slice(0,6) == 'https:')) {
-      // no change
-    } else {
-      url = window.location.href + '/' + url ;
-    }
-    return url ;
-  },
-  
-  // use this instead of typeOf() to get the type of item.  The return values
-  // are: 'string', 'number', 'function', 'class', 'object', 'hash', 'null', 
-  // 'undefined', 'boolean'.  
-  // 'object' will be returned for any items inheriting from SC.Object. 'hash' 
-  // is any other type of object.
+  /**
+    Returns a consistant type for the passed item.
+    
+    Use this instead of the built-in typeOf() to get the type of an item. 
+    It will return the same result across all browsers and includes a bit 
+    more detail.  Here is what will be returned:
+    
+    | Return Value Constant | Meaning |
+    | SC.T_STRING | String primitive |
+    | SC.T_NUMBER | Number primitive |
+    | SC.T_BOOLEAN | Boolean primitive |
+    | SC.T_NULL | Null value |
+    | SC.T_UNDEFINED | Undefined value |
+    | SC.T_FUNCTION | A function |
+    | SC.T_ARRAY | An instance of Array |
+    | SC.T_CLASS | A SproutCore class (created using SC.Object.extend()) |
+    | SC.T_OBJECT | A SproutCore object instance |
+    | SC.T_HASH | A JavaScript object not inheriting from SC.Object |
+    
+    @param item {Object} the item to check
+    @returns {String} the type
+  */  
   typeOf: function(item) {
     if (item === undefined) return T_UNDEFINED ;
     if (item === null) return T_NULL ; 
@@ -193,7 +293,12 @@ Object.extend(SC,{
         ret = T_ARRAY ;
       } else if (item instanceof Function) {
         ret = (item.isClass) ? T_CLASS : T_FUNCTION ;
-      } else if (item instanceof SC.Error) {
+        
+      // NB: typeOf() may be called before SC.Error has had a chance to load
+      // so this code checks for the presence of SC.Error first just to make
+      // sure.  No error instance can exist before the class loads anyway so
+      // this is safe.
+      } else if (SC.Error && (item instanceof SC.Error)) {
         ret = T_ERROR ;        
       } else if (item.isObject === true) {
         ret = T_OBJECT ;
@@ -202,35 +307,121 @@ Object.extend(SC,{
     return ret ;
   },
   
-  // this will compare two values to see if they are equal.  If you have two 
-  // values of unknown type, this is faster across all browsers than ===.
-  isEqual: function(a,b) {
-    if (a === null) {
-      return b === null ;
-    } else if (a === undefined) {
-      return b === undefined ;
-    } else if (typeof(a) == typeof(b)) {
-      return a == b ;
-    }
-  },
-  
+  /**
+    Returns YES if the passed object is an array or array-like.
+    
+    Unlike SC.$type this method returns true even if the passed object is 
+    not formally array but appears to be array-like (i.e. has a length 
+    property, responds to .objectAt, etc.)
+    
+    @param obj {Object} the object to test
+    @returns {Boolean} 
+  */
   isArray: function( obj )
   {
-    return ($type(obj) === T_ARRAY) || (obj && obj.objectAt);
+    return ($type(obj) === T_ARRAY) || (obj && ((obj.length!==undefined) || obj.objectAt));
   },
   
-  _nextGUID: 0,
-  
+  /**
+    Converts the passed object to an Array.  If the object appears to be 
+    array-like, a new array will be cloned from it.  Otherwise, a new array
+    will be created with the item itself as the only item in the array.
+    
+    This is an alias for Array.from() as well.
+    
+    @param object {Object} any enumerable or array-like object.
+    @returns {Array} Array of items
+  */
+  $A: function(obj) {
+    
+    // null or undefined
+    if (obj == null) return [] ;
+    
+    // primitive
+    if (obj.slice instanceof Function) return obj.slice() ; 
+    
+    // enumerable
+    if (obj.toArray) return obj.toArray() ;
+    
+    // not array-like
+    if (obj.length===undefined || $type(obj) === SC.T_FUNCTION) return [obj];
+
+    // when all else fails, do a manual convert...
+    var len = obj.length;
+    var ret = [] ;
+    for(var idx=0;idx<len;idx++) ret[idx] = obj[idx];
+    return ret ;
+  },
+
   /**
     Returns a unique GUID for the object.  If the object does not yet have
     a guid, one will be assigned to it.  You can call this on any object,
     SC.Object-based or not, but be aware that it will add a _guid property.
+    
+    @param obj {Object} any object, string, number or primitive
+    @returns {String} the unique guid for this instance.
   */
   guidFor: function(obj) {
-    if (obj == null) return 0 ;
-    return obj._guid ? obj._guid : (obj._guid = SC._nextGUID++);
+    if (obj === undefined) return "(undefined)" ;
+    if (obj === null) return '(null)' ;
+    if (obj._guid) return obj._guid ;
+    
+    switch($type(obj)) {
+      case T_NUMBER:
+        return this._numberGuids[obj] = this._numberGuids[obj] || ("#" + obj);
+        break ;
+      case T_STRING:
+        return this._stringGuids[obj] = this._stringGuids[obj] || ("$" + obj);
+        break ;
+      case T_BOOL:
+        return (obj) ? "(true)" : "(false)" ;
+        break;
+      default:
+        return obj._guid = SC.generateGuid();
+    }
   },
   
+  generateGuid: function() { return ("@" + (SC._nextGUID++)); },
+  _nextGUID: 0, _numberGuids: [], _stringGuids: {},
+
+  /**
+    Returns a unique hash code for the object.  If the object implements
+    a hash() method, the value of that method will be returned.  Otherwise,
+    this will return the same value as guidFor().  
+    
+    Unlike guidFor(), this method allows you to implement logic in your 
+    code to cause two separate instances of the same object to be treated as
+    if they were equal for comparisons and other functions.
+    
+    IMPORTANT:  If you implement a hash() method, it MUST NOT return a number
+    or a string that contains only a number.  Typically hash codes are strings
+    that begin with a "%".
+    
+    @param obj {Object} the object
+    @returns {String} the hash code for this instance.
+  */
+  hashFor: function(obj) {
+    return (obj && obj.hash && $type(obj.hash) === T_FUNCTION) ? obj.hash() : this.guidFor(obj) ;
+  },
+
+  /**
+    This will compare the two object values using their hash codes.
+    
+    @param a {Object} first value to compare
+    @param b {Object} the second value to compare
+    @returns {Boolean} YES if the two have equal hash code values.
+    
+  */
+  isEqual: function(a,b) {
+    // shortcut a few places.
+    if (a === null) {
+      return b === null ;
+    } else if (a === undefined) {
+      return b === undefined ;
+    
+    // finally, check their hash-codes
+    } else return SC.hashFor(a) === SC.hashFor(b) ;
+  },
 
   /**
     Convenience method to inspect an object by converting it to a hash.
@@ -332,6 +523,9 @@ Object.extend(SC,{
   
 });
 
+/** Alias for SC.typeOf() */
+SC.$type = SC.typeOf ;
+  
 /** @deprecated  Use guidFor() instead. */
 SC.getGUID = SC.guidFor ;
 
@@ -346,23 +540,31 @@ SC.Platform.Browser = function() {
   }
 }() ;
 
-T_ERROR = 'error' ;
-T_OBJECT = 'object' ;
-T_NULL = 'null';
-T_CLASS = 'class' ;
-T_HASH = 'hash' ;
-T_FUNCTION = 'function' ;
-T_UNDEFINED = 'undefined' ;
-T_NUMBER = 'number' ;
-T_BOOL = 'boolean' ;
-T_ARRAY = 'array' ;
-T_STRING = 'string' ;
+// Export the type variables into the global space.
+var T_ERROR = SC.T_ERROR ;
+var T_OBJECT = SC.T_OBJECT ;
+var T_NULL = SC.T_NULL ;
+var T_CLASS = SC.T_CLASS ;
+var T_HASH = SC.T_HASH ;
+var T_FUNCTION = SC.T_FUNCTION ;
+var T_UNDEFINED = SC.T_UNDEFINED ;
+var T_NUMBER = SC.T_NUMBER ;
+var T_BOOL = SC.T_BOOL ;
+var T_ARRAY = SC.T_ARRAY ;
+var T_STRING = SC.T_STRING ;
 
-$type = SC.typeOf ;
 
+// ........................................
+// GLOBAL EXPORTS
+//   
+// Global exports will be made optional in the future so you can avoid 
+// polluting the global namespace.
+
+$type = SC.typeOf ;
 $I = SC.inspect ;
 
-Object.extend(Object,{
+// Legacy.  Will retire.
+SC.mixin(Object,{
 
   // this will serialize a general JSON object into a URI.
   serialize: function(obj) {

data/frameworks/sproutcore/{foundation → debug}/unittest.js

@@ -344,7 +344,7 @@ Test.Unit.Assertions.prototype = {
   },
   assertEnumEqual: function(expected, actual) {
     var message = arguments[2] || "assertEnumEqual";
-    try { $A(expected).length == $A(actual).length && 
+    try { SC.$A(expected).length == SC.$A(actual).length && 
       expected.zip(actual).all(function(pair) { return pair[0] == pair[1]; }) ?
         this.pass() : this.fail(message + ': expected ' + Test.Unit.inspect(expected) + 
           ', actual ' + Test.Unit.inspect(actual)); }
@@ -456,7 +456,7 @@ Test.Unit.Assertions.prototype = {
     }
   },
   assertElementsMatch: function() {
-    var expressions = $A(arguments), elements = $A(expressions.shift());
+    var expressions = SC.$A(arguments), elements = SC.$A(expressions.shift());
     if (elements.length != expressions.length) {
       this.fail('assertElementsMatch: size mismatch: ' + elements.length + ' elements, ' + expressions.length + ' expressions');
       return false;
@@ -573,7 +573,7 @@ Test.setupBDDExtensionMethods = function(){
   Test.BDDMethods = {};   
   $H(METHODMAP).each(function(pair) { 
     Test.BDDMethods[pair.key] = function() { 
-       var args = $A(arguments); 
+       var args = SC.$A(arguments); 
        var scope = args.shift(); 
        makeAssertion.apply(scope, [pair.value, args, this]); }; 
   });

data/frameworks/sproutcore/english.lproj/detect-browser

@@ -5,7 +5,7 @@
 // the browser, language, and platform.  You can then call 
 // SC.setupBrowserClassNames() in a script tag after the body is defined to 
 // load the class names into the body.
-if (!SC) var SC = {} ;
+var SC = SC || {} ;
 SC.browser = (function() {
 
   var userAgent = navigator.userAgent.toLowerCase();

data/frameworks/sproutcore/english.lproj/theme.css

@@ -55,12 +55,12 @@ body.sc-theme {
 	border-top: 1px solid white;
 }
 
-.sc-theme .sc-collection-view .sel {
+.sc-theme .sc-collection-view .sc-collection-item.sel {
 	background-color: #ddd;
 	border-top: 1px solid #eee;
 }
 
-.sc-theme.focus .sc-collection-view.focus .sel {
+.sc-theme.focus .sc-collection-view.focus .sc-collection-item.sel {
 	background-color: #40007e;
 	color: white ;
 	border-top: 1px solid #84788f;

data/frameworks/sproutcore/foundation/application.js

@@ -105,7 +105,12 @@ SC.Application = SC.Responder.extend(
     if (!action || ($type(action) != T_STRING)) return null;
 
     // an explicit target was passed...
-    if (target) return target.respondsTo(action) ? target : null ;
+    if (target) {
+      if ($type(target) === T_STRING) {
+        target = SC.Object.objectForPropertyPath(target) ;
+      }
+      return target.respondsTo(action) ? target : null ;
+    }
 
     // ok, no target was passed... try to find one in the responder chain
     var keyPane   = this.get('keyPane');