sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/runtime/README

@@ -9,3 +9,4 @@ everything in between to easily manage the state of your page with less code.
 This library is a part of the SproutCore JavaScript Application Framework,
 which is a full-stack MVC framework for building desktop-like applications on
 the web.
+ 

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

@@ -27,7 +27,7 @@ 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 || {} ;
+  window.console = {} ;
   console.log = console.info = console.warn = console.error = function(){};
 }
 
@@ -208,34 +208,37 @@ SC.mixin(/** @scope SC */ {
   makeArray: function(obj) {
     return SC.isArray(obj) ? obj : SC.$A(obj);
   },
-
+  
   /**
     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.
-
+    
     @param object {Object} any enumerable or array-like object.
     @returns {Array} Array of items
   */
   A: function(obj) {
-
     // null or undefined -- fast path
     if (SC.none(obj)) return [] ;
-
+    
     // primitive -- fast path
-    if (obj.slice instanceof Function) return obj.slice() ; 
-
+    if (obj.slice instanceof Function) {
+      // do we have a string?
+      if (typeof(obj) === 'string') return [obj] ;
+      else return obj.slice() ;
+    }
+    
     // enumerable -- fast path
     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 ;
-  },  
+  },
   
   // ..........................................................
   // GUIDS & HASHES
@@ -267,7 +270,7 @@ SC.mixin(/** @scope SC */ {
     var guidKey = this.guidKey ;
     if (obj[guidKey]) return obj[guidKey] ;
 
-    switch(this.typeOf(obj)) {
+    switch(typeof obj) {
       case SC.T_NUMBER:
         return (this._numberGuids[obj] = this._numberGuids[obj] || ("nu" + obj));
       case SC.T_STRING:
@@ -325,7 +328,7 @@ SC.mixin(/** @scope SC */ {
     @returns {String} the hash code for this instance.
   */
   hashFor: function(obj) {
-    return (obj && obj.hash && SC.typeOf(obj.hash) === SC.T_FUNCTION) ? obj.hash() : this.guidFor(obj) ;
+    return (obj && obj.hash && (typeof obj.hash === SC.T_FUNCTION)) ? obj.hash() : this.guidFor(obj) ;
   },
     
   /**
@@ -347,6 +350,67 @@ SC.mixin(/** @scope SC */ {
     } else return this.hashFor(a) === this.hashFor(b) ;
   },
   
+  
+  /**
+   This will compare two javascript values of possibly different types.
+   It will tell you which one is greater than the other by returning
+   -1 if the first is smaller than the second,
+    0 if both are equal,
+    1 if the first is greater than the second.
+  
+   The order is calculated based on SC.ORDER_DEFINITION , if types are different.
+   In case they have the same type an appropriate comparison for this type is made.
+
+   @param v {Object} first value to compare
+   @param w {Object} the second value to compare
+   @returns {NUMBER} -1 if v < w, 0 if v = w and 1 if v > w.
+
+  */
+  compare: function (v, w) {
+    
+    var type1 = SC.typeOf(v);
+    var type2 = SC.typeOf(w);
+    var type1Index = SC.ORDER_DEFINITION.indexOf(type1);
+    var type2Index = SC.ORDER_DEFINITION.indexOf(type2);
+    
+    if (type1Index < type2Index) return -1;
+    if (type1Index > type2Index) return 1;
+    
+    // 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:
+        if (v.localeCompare(w)<0) return -1;
+        if (v.localeCompare(w)>0) return 1;
+        return 0;
+
+      case SC.T_ARRAY:
+        var l = Math.min(v.length,w.length);
+        var r = 0;
+        var i = 0;
+        while (r===0 && i < l) {
+          r = arguments.callee(v[i],w[i]);
+          if ( r !== 0 ) return r;
+          i++;
+        }
+        
+        // all elements are equal now
+        // shorter array should be ordered first
+        if (v.length < w.length) return -1;
+        if (v.length > w.length) return 1;
+        // arrays are equal now
+        return 0;
+
+      default:
+        return 0;
+    }
+  },
+  
   // ..........................................................
   // OBJECT MANAGEMENT
   // 
@@ -547,6 +611,20 @@ SC.typeOf = SC.typeOf ;
 /** @private Provided for compatibility with old HTML templates. */
 SC.didLoad = SC.K ;
 
+/** @private Used by SC.compare */
+SC.ORDER_DEFINITION = [ SC.T_ERROR,
+                        SC.T_UNDEFINED,
+                        SC.T_NULL,
+                        SC.T_BOOL,
+                        SC.T_NUMBER,
+                        SC.T_STRING,
+                        SC.T_ARRAY,
+                        SC.T_HASH,
+                        SC.T_OBJECT,
+                        SC.T_FUNCTION,
+                        SC.T_CLASS ];
+
+
 // ........................................
 // FUNCTION ENHANCEMENTS
 //
@@ -661,10 +739,12 @@ SC.mixin(Function.prototype,
     @returns {Function} the declared function instance
   */
   property: function() {
-    this.dependentKeys = SC.$A(arguments) ; 
-    this.cacheKey = "__cache__" + SC.guidFor(this) ;
-    this.lastSetValueKey = "__lastValue__" + SC.guidFor(this) ;
-    this.isProperty = true; return this; 
+    this.dependentKeys = SC.$A(arguments) ;
+    var guid = SC.guidFor(this) ;
+    this.cacheKey = "__cache__" + guid ;
+    this.lastSetValueKey = "__lastValue__" + guid ;
+    this.isProperty = YES ;
+    return this ;
   },
   
   /**
@@ -682,19 +762,19 @@ SC.mixin(Function.prototype,
     @returns {Function} reciever
   */
   cacheable: function(aFlag) {
-    this.isProperty = YES;  // also make a property just in case
+    this.isProperty = YES ;  // also make a property just in case
     if (!this.dependentKeys) this.dependentKeys = [] ;
     this.isCacheable = (aFlag === undefined) ? YES : aFlag ;
-    return this;
+    return this ;
   },
   
   /**
     Indicates that the computed property is volatile.  Normally SproutCore 
-    assumes that your computed property is indempotent.  That is, calling 
+    assumes that your computed property is idempotent.  That is, calling 
     set() on your property more than once with the same value has the same
     effect as calling it only once.  
     
-    All non-computed properties are indempotent and normally you should make
+    All non-computed properties are idempotent and normally you should make
     your computed properties behave the same way.  However, if you need to
     make your property change its return value everytime your method is
     called, you may chain this to your property to make it volatile.
@@ -705,39 +785,38 @@ SC.mixin(Function.prototype,
     @param {Boolean} aFlag optionally indicate state, default to YES
     @returns {Function} receiver
   */
-  indempotent: function(aFlag) {
+  idempotent: function(aFlag) {
     this.isProperty = YES;  // also make a property just in case
     if (!this.dependentKeys) this.dependentKeys = [] ;
-    this.isVolatile = !((aFlag === undefined) ? NO : aFlag) ;
-    return this;
+    this.isVolatile = (aFlag === undefined) ? YES : aFlag ;
+    return this ;
   },
   
-  /**  
+  /**
     Declare that a function should observe an object at the named path.  Note
     that the path is used only to construct the observation one time.
   */
   observes: function(propertyPaths) { 
-    
     // sort property paths into local paths (i.e just a property name) and
     // full paths (i.e. those with a . or * in them)
-    var loc = arguments.length, local = null, paths = null;
+    var loc = arguments.length, local = null, paths = null ;
     while(--loc >= 0) {
       var path = arguments[loc] ;
       // local
       if ((path.indexOf('.')<0) && (path.indexOf('*')<0)) {
-        if (!local) local = this.localPropertyPaths = [];
+        if (!local) local = this.localPropertyPaths = [] ;
         local.push(path);
         
       // regular
       } else {
-        if (!paths) paths = this.propertyPaths = [];
+        if (!paths) paths = this.propertyPaths = [] ;
         paths.push(path) ;
       }
     }
-    return this;
+    return this ;
   }
-    
-}) ;
+  
+});
 
 // ..........................................................
 // STRING ENHANCEMENT

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

@@ -0,0 +1,238 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/*globals module test ok equals same CoreTest */
+
+/**
+  Adds a new module of unit tests to verify that the passed object implements
+  the SC.Array interface.  To generate, call the ArrayTests array with a 
+  test descriptor.  Any properties you pass will be applied to the ArrayTests
+  descendent created by the create method.
+  
+  You should pass at least a newObject() method, which should return a new 
+  instance of the object you want to have tested.  You can also implement the
+  destroyObject() method, which should destroy a passed object.
+  
+  {{{
+    SC.ArrayTests.generate("Array", {
+      newObject:  function() { return []; }
+    });
+  }}}
+  
+  newObject must accept an optional array indicating the number of items
+  that should be in the array.  You should initialize the the item with 
+  that many items.  The actual objects you add are up to you.
+  
+  Unit tests themselves can be added by calling the define() method.  The
+  function you pass will be invoked whenever the ArrayTests are generated. The
+  parameter passed will be the instance of ArrayTests you should work with.
+  
+  {{{
+    SC.ArrayTests.define(function(T) {
+      T.module("length");
+      
+      test("verify length", function() {
+        var ary = T.newObject();
+        equals(ary.get('length'), 0, 'should have 0 initial length');
+      });
+    }
+  }}}
+  
+  
+*/
+SC.ArraySuite = CoreTest.Suite.create("Verify SC.Array compliance: %@#%@", {
+  
+  /** 
+    Override to return a set of simple values such as numbers or strings.
+    Return null if your set does not support primitives.
+  */
+  simple: function(amt) {
+    var ret = [];
+    if (amt === undefined) amt = 0;
+    while(--amt >= 0) ret[amt] = amt ;
+    return ret ;
+  },
+
+  /**  Override with the name of the key we should get/set on hashes */
+  hashValueKey: 'foo',
+  
+  /**
+    Override to return hashes of values if supported.  Or return null.
+  */
+  hashes: function(amt) {
+    var ret = [];  
+    if (amt === undefined) amt = 0;
+    while(--amt >= 0) {
+      ret[amt] = {};
+      ret[amt][this.hashValueKey] = amt ;
+    }
+    return ret ;
+  },
+  
+  /** Override with the name of the key we should get/set on objects */
+  objectValueKey: "foo",
+  
+  /**
+    Override to return observable objects if supported.  Or return null.
+  */
+  objects: function(amt) {
+    var ret = [];  
+    if (amt === undefined) amt = 0;
+    while(--amt >= 0) {
+      var o = {};
+      o[this.objectValueKey] = amt ;
+      ret[amt] = SC.Object.create(o);
+    }
+    return ret ;
+  },
+
+  /**
+    Returns an array of content items in your preferred format.  This will
+    be used whenever the test does not care about the specific object content.
+  */
+  expected: function(amt) {
+    return this.simple(amt);
+  },
+  
+  /**
+    Example of how to implement newObject
+  */
+  newObject: function(expected) {
+    if (!expected || SC.typeOf(expected) === SC.T_NUMBER) {
+      expected = this.expected(expected);
+    }
+    
+    return expected.slice();
+  },
+  
+  
+  /**
+    Creates an observer object for use when tracking object modifications.
+  */
+  observer: function(obj) {
+    return SC.Object.create({
+
+      // ..........................................................
+      // NORMAL OBSERVER TESTING
+      // 
+      
+      observer: function(target, key, value) {
+        this.notified[key] = true ;
+        this.notifiedValue[key] = value ;
+      },
+
+      resetObservers: function() {
+        this.notified = {} ;
+        this.notifiedValue = {} ;
+      },
+
+      observe: function() {
+        var keys = SC.$A(arguments) ;
+        var loc = keys.length ;
+        while(--loc >= 0) {
+          obj.addObserver(keys[loc], this, this.observer) ;
+        }
+        return this ;
+      },
+
+      didNotify: function(key) {
+        return !!this.notified[key] ;
+      },
+
+      init: function() {
+        sc_super() ;
+        this.resetObservers() ;
+      },
+      
+      // ..........................................................
+      // RANGE OBSERVER TESTING
+      // 
+      
+      callCount: 0,
+
+      // call afterward to verify
+      expectRangeChange: function(source, object, key, indexes, context) {
+        equals(this.callCount, 1, 'expects one callback');
+        
+        if (source !== undefined && source !== NO) {
+          ok(this.source, source, 'source should equal array');
+        }
+        
+        if (object !== undefined && object !== NO) {
+          equals(this.object, object, 'object');
+        }
+        
+        if (key !== undefined && key !== NO) {
+          equals(this.key, key, 'key');
+        }
+        
+        if (indexes !== undefined && indexes !== NO) {
+          if (indexes.isIndexSet) {
+            ok(this.indexes && this.indexes.isIndexSet, 'indexes should be index set');
+            ok(indexes.isEqual(this.indexes), 'indexes should match %@ (actual: %@)'.fmt(indexes, this.indexes));
+          } else equals(this.indexes, indexes, 'indexes');
+        }
+          
+        if (context !== undefined && context !== NO) {
+          equals(this.context, context, 'context should match');
+        }
+        
+      },
+      
+      rangeDidChange: function(source, object, key, indexes, context) {
+        this.callCount++ ;
+        this.source = source ;
+        this.object = object ;
+        this.key    = key ;
+        
+        // clone this because the index set may be reused after this callback
+        // runs.
+        this.indexes = (indexes && indexes.isIndexSet) ? indexes.clone() : indexes;
+        this.context = context ;          
+      }
+      
+    });  
+  },
+  
+  /**
+    Verifies that the passed object matches the passed array.
+  */
+  validateAfter: function(obj, after, observer, lengthDidChange, enumerableDidChange) {
+    var loc = after.length;
+    equals(obj.get('length'), loc, 'length should update (%@)'.fmt(obj)) ;
+    while(--loc >= 0) {
+      equals(obj.objectAt(loc), after[loc], 'objectAt(%@)'.fmt(loc)) ;
+    }
+
+    // note: we only test that the length notification happens when we expect
+    // it.  If we don't expect a length notification, it is OK for a class
+    // to trigger a change anyway so we don't check for this case.
+    if (enumerableDidChange !== NO) {
+      equals(observer.didNotify("[]"), YES, 'should notify []') ;
+    }
+    
+    if (lengthDidChange) {
+      equals(observer.didNotify('length'), YES, 'should notify length change');
+    }
+  }
+  
+});
+
+// Simple verfication of length
+SC.ArraySuite.define(function(T) {
+  T.module("length");
+  
+  test("should return 0 on empty array", function() {
+    equals(T.object.get('length'), 0, 'should have empty length');
+  });
+  
+  test("should return array length", function() {
+    var obj = T.newObject(3);
+    equals(obj.get('length'), 3, 'should return length');
+  });
+  
+});