sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/frameworks/sproutcore/frameworks/runtime/system/sparse_array.js

@@ -0,0 +1,286 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+
+sc_require('mixins/enumerable') ;
+sc_require('mixins/array') ;
+sc_require('mixins/observable') ;
+sc_require('mixins/delegate_support') ;
+
+/**
+  @class
+
+  A dynamically filled array.  A SparseArray makes it easy for you to create 
+  very large arrays of data but then to defer actually populating that array
+  until it is actually needed.  This is often much faster than generating an
+  array up front and paying the cost to load your data then.
+  
+  Although technically all arrays in JavaScript are "sparse" (in the sense 
+  that you can read and write properties are arbitrary indexes), this array
+  keeps track of which elements in the array have been populated already 
+  and which ones have not.  If you try to get a value at an index that has 
+  not yet been populated, the SparseArray will notify a delegate object first
+  giving the delegate a chance to populate the component.
+  
+  Most of the time, you will use a SparseArray to incrementally load data 
+  from the server.  For example, if you have a contact list with 3,000
+  contacts in it, you may create a SparseArray with a length of 3,000 and set
+  that as the content for a ListView.  As the ListView tries to display the
+  visible contacts, it will request them from the SparseArray, which will in
+  turn notify your delegate, giving you a chance to load the contact data from
+  the server.
+  
+  @extends SC.Enumerable
+  @extends SC.Array
+  @extends SC.Observable
+  @extends SC.DelegateSupport
+  @since SproutCore 1.0
+*/
+
+SC.SparseArray = SC.Object.extend(SC.Observable, SC.Enumerable, SC.Array, 
+  SC.DelegateSupport, /** @scope SC.SparseArray.prototype */ {  
+
+  // ..........................................................
+  // LENGTH SUPPORT
+  // 
+  
+  /**
+    The length of the sparse array.  The delegate for the array should set 
+    this length.
+    
+    @property {Number}
+  */
+  length: function() {
+    var del = this.delegate ;
+    if (del && SC.none(this._length) && del.sparseArrayDidRequestLength) {      
+      del.sparseArrayDidRequestLength(this);
+    }
+    return this._length || 0 ;
+  }.property().cacheable(),
+
+  /**
+    Call this method from a delegate to provide a length for the sparse array.
+    If you pass null for this property, it will essentially "reset" the array
+    causing your delegate to be called again the next time another object 
+    requests the array length.
+  
+    @param {Number} length the length or null
+    @returns {SC.SparseArray} receiver
+  */
+  provideLength: function(length) {
+    if (SC.none(length)) this._sa_content = null ;
+    if (length !== this._length) {
+      this._length = length ;
+      this.enumerableContentDidChange() ;
+    }
+    return this ;
+  },
+  
+  // ..........................................................
+  // READING CONTENT 
+  // 
+
+  /** 
+    The minimum range of elements that should be requested from the delegate.
+    If this value is set to larger than 1, then the sparse array will always
+    fit a requested index into a range of this size and request it.
+    
+    @property {Number}
+  */
+  rangeWindowSize: 1,
+  
+  /** 
+    Returns the object at the specified index.  If the value for the index
+    is currently undefined, invokes the didRequestIndex() method to notify
+    the delegate.
+    
+    @param  {Number} idx the index to get
+    @return {Object} the object
+  */
+  objectAt: function(idx) {
+    var content = this._sa_content, ret ;
+    if (!content) content = this._sa_content = [] ;
+    if ((ret = content[idx]) === undefined) {
+      this.requestIndex(idx);
+      ret = content[idx]; // just in case the delegate provided immediately
+    }
+    return ret ;
+  },
+
+  _TMP_RANGE: {},
+  
+  /**
+    Called by objectAt() whenever you request an index that has not yet been
+    loaded.  This will possibly expand the index into a range and then invoke
+    an appropriate method on the delegate to request the data.
+    
+    @param {SC.SparseArray} receiver
+  */
+  requestIndex: function(idx) {
+    var del = this.delegate;
+    if (!del) return this; // nothing to do
+    
+    // adjust window
+    var len = this.get('rangeWindowSize'), start = idx;
+    if (len > 1) start = Math.floor(start / windowSize);
+    if (len < 1) len = 1 ;
+    
+    // invoke appropriate callback
+    if (del.sparseArrayDidRequestRange) {
+      var range = this._TMP_RANGE;
+      range.start = start;
+      range.length = len;
+      del.sparseArrayDidRequestRange(this, range);
+      
+    } else if (del.sparseArrayDidRequestIndex) {
+      while(--len >= 0) del.sparseArrayDidRequestIndex(start + len);
+    }
+    return this ;
+  },
+  
+  /**
+    This method sets the content for the specified to the objects in the 
+    passed array.  If you change the way SparseArray implements its internal
+    tracking of objects, you should override this method along with 
+    objectAt().
+    
+    @param {Range} range the range to apply to
+    @param {Array} array the array of objects to insert
+    @returns {SC.SparseArray} reciever
+  */
+  provideObjectsInRange: function(range, array) {
+    var content = this._sa_content ;
+    if (!content) content = this._sa_content = [] ;
+    var start = range.start, len = range.length;
+    while(--len >= 0) content[start+len] = array[len];
+    this.enumerableContentDidChange() ;
+    return this ;
+  },
+
+  _TMP_PROVIDE_ARRAY: [],
+  _TMP_PROVIDE_RANGE: { length: 1 },
+  
+  /**
+    Convenience method to provide a single object at a specified index.  Under
+    the covers this calls provideObjectsInRange() so you can override only 
+    that method and this one will still work.
+    
+    @param {Number} index the index to insert
+    @param {Object} the object to insert
+    @return {SC.SparseArray} receiver
+  */
+  provideObjectAtIndex: function(index, object) {
+    var array = this._TMP_PROVIDE_ARRAY, range = this._TMP_PROVIDE_RANGE;
+    array[0] = object;
+    range.start = index;
+    return this.provideObjectsInRange(range, array);
+  },
+
+  /**
+    Invalidates the array content in the specified range.  This is not the 
+    same as editing an array.  Rather it will cause the array to reload the
+    content from the delegate again when it is requested.
+    
+    @param {Range} the range
+    @returns {SC.SparseArray} receiver
+  */
+  objectsDidChangeInRange: function(range) {
+
+    // delete cached content
+    var content = this._sa_content ;
+    if (content) {
+      // if range covers entire length of cached content, just reset array
+      if (range.start === 0 && SC.maxRange(range)>=content.length) {
+        this._sa_content = null ;
+        
+      // otherwise, step through the changed parts and delete them.
+      } else {
+        var start = range.start, loc = Math.min(start + range.length, content.length);
+        while (--loc>=start) content[loc] = undefined;
+      }
+    }    
+    this.enumerableContentDidChange(range) ; // notify
+    return this ;
+  },
+  
+  /**
+    Optimized version of indexOf().  Asks the delegate to provide the index 
+    of the specified object.  If the delegate does not implement this method
+    then it will search the internal array directly.
+    
+    @param {Object} obj the object to search for
+    @returns {Number} the discovered index or -1 if not found
+  */
+  indexOf: function(obj) {
+    var del = this.delegate ;
+    if (del && del.sparseArrayDidRequestIndexOf) {
+      return del.del.sparseArrayDidRequestIndexOf(this, obj);
+    } else {
+      var content = this._sa_content ;
+      if (!content) content = this._sa_content = [] ;
+      return content.indexOf(obj) ;
+    }
+  },  
+  
+  // ..........................................................
+  // EDITING
+  // 
+
+  /**
+    Array primitive edits the objects at the specified index unless the 
+    delegate rejects the change.
+    
+    @param {Number} idx the index to begin to replace
+    @param {Number} amt the number of items to replace
+    @param {Array} objects the new objects to set instead
+    @returns {SC.SparseArray} receiver
+  */
+  replace: function(idx, amt, objects) {
+    objects = objects || [] ;
+
+    // if we have a delegate, get permission to make the replacement.
+    var del = this.delegate ;
+    if (del) {
+      if (!del.sparseArrayShouldReplace || 
+          !del.sparseArrayShouldReplace(this, idx, amt, objects)) {
+            return this;
+      }
+    }
+
+    // go ahead and apply to local content.
+    var content = this._sa_content ;
+    if (!content) content = this._sa_content = [] ;
+    content.replace(idx, amt, objects) ;
+    
+    // update length
+    var delta = objects.length - amt ;
+    if (delta!==0 && !SC.none(this._length)) {
+      this.propertyWillChange('length');
+      this._length += delta;
+      this.propertyDidChange('length');
+    } 
+
+    this.enumerableContentDidChange() ;
+    return this ;
+  },
+
+  /** 
+    Resets the SparseArray, causing it to reload its content from the 
+    delegate again.
+  */
+  reset: function() {
+    this._sa_content = null ;
+    this._length = null ;
+    this.enumerableContentDidChange() ;
+    this.invokeDelegateMethod(this.delegate, 'sparseArrayDidReset', this);
+    return this ;
+  }
+      
+}) ;
+
+SC.SparseArray.array = function(len) {
+  return this.create({ _length: len||0 });
+};

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

@@ -0,0 +1,56 @@
+// ========================================================================
+// SC.isEqual Tests
+// ========================================================================
+/*globals module test */
+
+module("String's - isEqual", {
+	
+	setup: function(){
+	StringA = "Hello";
+	StringB = "Hi";
+	StringC = "Hello";
+    }
+
+});
+
+test("strings should be equal ",function(){
+	equals(SC.isEqual(StringA,StringB),false);
+	equals(SC.isEqual(StringA,StringC),true);
+});
+
+module("Number's - isEqual",{
+ 
+     setup: function(){
+	 num1 = 24;
+	 num2 = 24;
+	 num3 = 21;
+     }
+
+});
+ 
+test("numericals should be equal ",function(){
+    equals(SC.isEqual(num1,num2),true);
+	equals(SC.isEqual(num1,num3),false);
+}); 
+
+var objectA,objectB; //global variables
+
+module("Array's - isEqual",{
+	
+	setup: function(){
+	objectA = [1,2];
+	objectB = [1,2];
+	objectC = [1];	
+	}
+	
+});
+	
+test("array should be equal  ",function(){
+	// NOTE: We don't test for array contents -- that would be too expensive.
+	equals(SC.isEqual(objectA,objectB),false, 'two array instances with the same values should not be equal');
+	equals(SC.isEqual(objectA,objectC),false, 'two array instances with different values should not be equal');
+});	
+
+
+
+	

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

@@ -0,0 +1,23 @@
+// ========================================================================
+// SC.guidFor Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var objectA, objectB ; // global variables
+
+module("Beget function Module", {
+setup: function() {
+    objectA = {} ;
+    objectB = {} ;
+	arrayA  = [1,3];
+	stringA ="stringA";
+}
+});
+
+test("should return a new object with same prototype as that of passed object", function() {
+  	equals(YES, SC.beget(objectA) !== objectA, "Beget for an object") ;
+	equals(YES, SC.beget(stringA) !== stringA, "Beget for a string") ;
+	equals(YES, SC.beget(SC.hashFor(objectB))!==SC.hashFor(objectB), "Beget for a hash") ;
+	equals(YES, SC.beget(arrayA) !== arrayA, "Beget for an array") ;
+});
+

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

@@ -0,0 +1,66 @@
+// ==========================================================================
+// 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 isObj equals expects object isSet */
+
+var object ;
+
+module("Cloned Objects", {
+  setup: function() {
+    
+	object = SC.Object.create({
+	
+	  name:'Cloned Object',
+	  value:'value1',
+	 
+	  clone: function(object) {
+	    var ret = object ;
+	    switch (SC.typeOf(object)) {
+	  
+	  	 case SC.T_ARRAY:
+	        ret = object.slice() ;
+	    	break ;
+
+	     case SC.T_OBJECT:
+	        ret = {} ;
+	        for(var key in object) ret[key] = object[key] ;
+	    }
+
+	    return ret ;
+	  }
+	});
+  }
+});
+
+
+test("should return a cloned object", function() {
+	var objectA = [1,2,3,4,5] ;
+	var objectB = "SproutCore" ;
+	var objectC = SC.hashFor(objectA);	
+	var objectE = 100;
+	var a = SC.clone(objectA);
+	var b = SC.clone(objectA);
+	
+  	equals(SC.clone(objectB), SC.clone(objectB)) ;
+	equals(SC.clone(objectC), SC.clone(objectC)) ;
+	equals(SC.clone(objectE), SC.clone(objectE)) ;
+	isSet(a, b);
+});
+
+test("should return cloned object when the object is null", function() {
+	var objectD = null;
+  	equals(SC.clone(objectD), SC.clone(objectD)) ;
+});
+
+test("should return a cloned array ", function() {
+	var arrayA  = ['value1','value2'] ;
+	var resultArray = object.clone(arrayA);
+    equals(resultArray[0], arrayA[0], 'check first array item');
+    equals(resultArray[1], arrayA[1], 'check first array item');
+		
+});
+

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

@@ -0,0 +1,147 @@
+// ========================================================================
+// SC.guidFor Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var objectA, objectB ; // global variables
+
+module("Object", {
+  
+  setup: function() {
+    objectA = {} ;
+    objectB = {} ;
+  }
+  
+});
+
+test("should return same guid for same instance every time", function() {
+  equals(SC.guidFor(objectA), SC.guidFor(objectA)) ;
+});
+
+test("should return different guid for different instances", function() {
+  ok(SC.guidFor(objectA) !==  SC.guidFor(objectB)) ;
+});
+
+test("guid should not parse to a number", function() {
+  equals(YES, isNaN(parseInt(SC.guidFor(objectA), 0))) ;
+});
+
+var stringA, stringACopy, stringB ; // global variables
+
+module("String", {
+  
+  setup: function() {
+    stringA = "string A" ;
+    stringACopy = "string A" ;
+    stringB = "string B" ;
+  }
+  
+});
+
+test("same string instance should have same guide every time", function() {
+  equals(SC.guidFor(stringA), SC.guidFor(stringA)) ;  
+});
+
+test("two string instances with same value should have same guid", function() {
+  equals(SC.guidFor(stringA), SC.guidFor(stringACopy)) ;  
+});
+
+test("two instances with different value should have different guid", function() {
+  ok(SC.guidFor(stringA) !==  SC.guidFor(stringB)) ;
+});
+
+test("guid should not parse to a number", function() {
+  equals(YES, isNaN(parseInt(SC.guidFor(stringA), 0))) ;
+});
+
+var numberA, numberACopy, numberB ; // global variables
+
+module("Number", {
+  
+  setup: function() {
+    numberA = 23 ;
+    numberACopy = 23 ;
+    numberB = 34 ;
+  }
+  
+});
+
+test("same number instance should have same guide every time", function() {
+  equals(SC.guidFor(numberA), SC.guidFor(numberA)) ;  
+});
+
+test("two number instances with same value should have same guid", function() {
+  equals(SC.guidFor(numberA), SC.guidFor(numberACopy)) ;  
+});
+
+test("two instances with different value should have different guid", function() {
+  ok(SC.guidFor(numberA) !==  SC.guidFor(numberB)) ;
+});
+
+test("guid should not parse to a number", function() {
+  equals(YES, isNaN(parseInt(SC.guidFor(numberA), 0))) ;
+});
+
+module("Boolean") ;
+
+test("should always have same guid", function() {
+  equals(SC.guidFor(true), SC.guidFor(true)) ;
+  equals(SC.guidFor(false), SC.guidFor(false)) ;
+});
+
+test("true should have different guid than false", function() {
+  ok(SC.guidFor(true) !==  SC.guidFor(false)) ;
+});
+
+test("guid should not parse to a number", function() {
+  equals(YES, isNaN(parseInt(SC.guidFor(true), 0)), 'guid for boolean-true') ;
+  equals(YES, isNaN(parseInt(SC.guidFor(false), 0)), 'guid for boolean-false') ;
+});
+
+module("Null and Undefined") ;
+
+test("should always have same guid", function() {
+  equals(SC.guidFor(null), SC.guidFor(null)) ;
+  equals(SC.guidFor(undefined), SC.guidFor(undefined)) ;
+});
+
+test("null should have different guid than undefined", function() {
+  ok(SC.guidFor(null) !==  SC.guidFor(undefined)) ;
+});
+
+test("guid should not parse to a number", function() {
+  equals(YES, isNaN(parseInt(SC.guidFor(null), 0))) ;
+  equals(YES, isNaN(parseInt(SC.guidFor(undefined), 0))) ;
+});
+
+module("Arrays", {
+	
+	setup: function() {
+	    array1 = ['a','b','c'] ;
+	    array1copy = array1 ;
+		array2 = ['1','2','3'];
+	    array2copy = ['1','2','3'] ;
+	}
+}) ;
+
+test("same array instance should have same guide every time", function(){
+	equals(SC.guidFor(array1), SC.guidFor(array1));
+	equals(SC.guidFor(array2), SC.guidFor(array2));
+});
+
+test("two array instances with same value, by assigning one to the other.", function() {
+	equals(SC.guidFor(array1), SC.guidFor(array1copy)) ;
+});
+
+test("two array instances with same value, by assigning the same value", function() {
+	ok(SC.guidFor(array2) !== SC.guidFor(array2copy)) ;
+});
+
+test("two instances with different value should have different guid", function() {
+  ok(SC.guidFor(array1) !==  SC.guidFor(array2)) ;
+  ok(SC.guidFor(array1copy) !==  SC.guidFor(array2copy)) ;
+});
+
+test("guid should not parse to a number", function() {
+  equals(YES, isNaN(parseInt(SC.guidFor(array1), 0))) ;
+});

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

@@ -0,0 +1,27 @@
+// ========================================================================
+// SC.inspect Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var obj1,obj2,obj3; //global variables
+
+module("Inspect module",{
+  
+      setup: function(){	
+        obj1 = [1,3,4,9];
+        obj2 = 24;     
+        obj3 = {};
+     }
+});
+
+
+test("SC.inspect module should give a string type",function(){
+    var object1 = SC.inspect(obj1); 	
+	equals(YES,SC.T_STRING === SC.typeOf(object1) ,'description of the array');
+	
+	var object2 = SC.inspect(obj2);
+	equals(YES,SC.T_STRING === SC.typeOf(object2),'description of the numbers');
+	
+	var object3 = SC.inspect(obj3);
+	equals(YES,SC.T_STRING === SC.typeOf(object3),'description of the object');
+});

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

@@ -0,0 +1,25 @@
+// ========================================================================
+// SC.isArray Tests
+// ========================================================================
+/*globals module test */
+
+var objectA,objectB,objectC; //global variables
+
+module("Array Check" , {
+	
+	setup: function(){
+		objectA = [1,2,3];
+		objectB = 23;
+		objectC = ["Hello","Hi"];
+		objectD = "Hello";
+		objectE	= {};
+	}
+});
+
+test("should check if a given object is an array or not " ,function(){
+	equals(SC.isArray(objectA),true);
+	equals(SC.isArray(objectB),false);
+	equals(SC.isArray(objectC),true);
+	equals(SC.isArray(objectD),false);
+	equals(SC.isArray(objectE),false);
+});

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

@@ -0,0 +1,38 @@
+module("item type", {
+  setup: function() {
+     object = SC.Object.create({
+	
+	    method:function(){
+		
+	    }
+     });
+	
+  }   
+  
+});
+
+test("should return the type for the passed item", function() {
+	  a = null;
+	  var arr = [1,2,3];
+	  var obj = {};
+	  
+      equals(SC.T_NULL,SC.typeOf(a),"item of type null ");
+	  equals(SC.T_ARRAY,SC.typeOf(arr),"item of type array ");		  
+	  equals(SC.T_HASH,SC.typeOf(obj),"item of type hash");
+	  equals(SC.T_OBJECT,SC.typeOf(object),"item of type object");
+	  equals(SC.T_FUNCTION,SC.typeOf(object.method),"item of type function") ;
+	  equals(SC.T_CLASS,SC.typeOf(SC.Object),"item of type class");
+});
+
+var a,b;
+module("none or undefined object type",{
+	setup: function() {
+		a = null;
+		b = undefined; 
+  }
+});
+
+test("should return true for null and undefined ",function(){
+	equals(YES,SC.none(a),"for a null parameter passed  ");
+	equals(YES,SC.none(b),"for a undefined parameter passed ");
+});

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

@@ -0,0 +1,20 @@
+// ========================================================================
+// SC.keys Tests
+// ========================================================================
+/*globals module test */
+
+module("Fetch Keys ");
+
+test("should get a key array for a specified object ",function(){
+	var object1 = {};
+
+	object1.names = "Rahul";
+	object1.age = "23";
+	object1.place = "Mangalore";
+
+	var object2 = [];
+	object2 = SC.keys(object1);
+	equals(object2,'names,age,place');
+});
+
+