sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -0,0 +1,100 @@
+// ==========================================================================
+// 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 */
+
+sc_require('debug/test_suites/array/base');
+
+SC.ArraySuite.define(function(T) {
+  
+  var observer, obj ;
+  
+  module(T.desc("removeAt"), {
+    setup: function() {
+      obj = T.newObject();
+      observer = T.observer(obj);
+    }
+  });
+
+  test("[X].removeAt(0) => [] + notify", function() {
+
+    var before = T.expected(1);
+    obj.replace(0,0, before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeAt(0) ;
+    T.validateAfter(obj, [], observer, YES);
+  });
+  
+  test("[].removeAt(200) => OUT_OF_RANGE_EXCEPTION exception", function() {
+    var didThrow = NO ;
+    try {
+      obj.removeAt(200);
+    } catch (e) {
+      equals(e, SC.OUT_OF_RANGE_EXCEPTION, 'should throw SC.OUT_OF_RANGE_EXCEPTION');
+      didThrow = YES ;
+    }
+    ok(didThrow, 'should raise exception');
+  });
+
+  test("[A,B].removeAt(0) => [B] + notify", function() {
+    var before = T.expected(2), 
+        after   = [before[1]];
+    
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeAt(0);
+    T.validateAfter(obj, after, observer, YES);
+  });
+
+  test("[A,B].removeAt(1) => [A] + notify", function() {
+    var before = T.expected(2), 
+        after   = [before[0]];
+    
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeAt(1);
+    T.validateAfter(obj, after, observer, YES);
+  });
+
+  test("[A,B,C].removeAt(1) => [A,C] + notify", function() {
+    var before = T.expected(3), 
+        after   = [before[0], before[2]];
+    
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeAt(1);
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+  test("[A,B,C,D].removeAt(1,2) => [A,D] + notify", function() {
+    var before = T.expected(4), 
+        after   = [before[0], before[3]];
+    
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeAt(1,2);
+    T.validateAfter(obj, after, observer, YES);
+  });
+
+  test("[A,B,C,D].removeAt(IndexSet<0,2-3>) => [B] + notify", function() {
+    var before = T.expected(4), 
+        after   = [before[1]];
+    
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeAt(SC.IndexSet.create(0).add(2,2));
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+});
+

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

@@ -0,0 +1,49 @@
+// ==========================================================================
+// 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 */
+
+sc_require('debug/test_suites/array/base');
+
+SC.ArraySuite.define(function(T) {
+  
+  var observer, obj ;
+  
+  module(T.desc("removeObject"), {
+    setup: function() {
+      obj = T.newObject();
+      observer = T.observer(obj);
+    }
+  });
+
+  test("should return receiver", function() {
+    obj = T.newObject(3);
+    equals(obj.removeObject(obj.objectAt(0)), obj, 'should return receiver');
+  });
+  
+  test("[A,B,C].removeObject(B) => [A,C] + notify", function() {
+
+    var before = T.expected(3),
+        after  = [before[0], before[2]];
+    obj.replace(0,0, before);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeObject(before[1]) ;
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+  test("[A,B,C].removeObject(D) => [A,B,C]", function() {
+    var exp = T.expected(4),
+        extra = exp.pop();
+    obj.replace(0,0,exp);
+    observer.observe('[]', 'length') ;
+    
+    obj.removeObject(extra);
+    T.validateAfter(obj, exp, observer, NO, NO);
+  });
+  
+});

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

@@ -0,0 +1,94 @@
+// ==========================================================================
+// 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 */
+
+sc_require('debug/test_suites/array/base');
+
+SC.ArraySuite.define(function(T) {
+  
+  var observer, obj ;
+  
+  module(T.desc("replace"), {
+    setup: function() {
+      obj = T.newObject();
+      observer = T.observer(obj);
+    }
+  });
+  
+  test("[].replace(0,0,'X') => ['X'] + notify", function() {
+
+    var exp = T.expected(1);
+    
+    observer.observe('[]', 'length') ;
+    obj.replace(0,0,exp) ;
+
+    T.validateAfter(obj, exp, observer, YES);
+  });
+
+  test("[A,B,C,D].replace(1,2,X) => [A,X,D] + notify", function() {
+    
+    var exp = T.expected(5), 
+        before = exp.slice(0,4),
+        replace = exp.slice(4),
+        after = [before[0], replace[0], before[3]];
+        
+    obj.replace(0,0, before) ; // precond
+    observer.observe('[]', 'length') ;
+
+    obj.replace(1,2,replace) ;
+
+    T.validateAfter(obj, after, observer, YES);
+  });
+
+  test("[A,B,C,D].replace(1,2,[X,Y]) => [A,X,Y,D] + notify", function() {
+    
+    // setup the before, after, and replace arrays.  Use generated objects
+    var exp  = T.expected(6),
+        before  = exp.slice(0, 4),
+        replace = exp.slice(4),
+        after   = [before[0], replace[0], replace[1], before[3]]; 
+        
+    obj.replace(0,0, before) ;
+    observer.observe('[]', 'length') ;
+
+    obj.replace(1,2, replace) ;
+
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+  test("[A,B].replace(1,0,[X,Y]) => [A,X,Y,B] + notify", function() {
+
+    // setup the before, after, and replace arrays.  Use generated objects
+    var exp  = T.expected(4),
+        before  = exp.slice(0, 2),
+        replace = exp.slice(2),
+        after   = [before[0], replace[0], replace[1], before[1]] ;
+
+    obj.replace(0,0, before);
+    observer.observe('[]', 'length') ;
+  
+    obj.replace(1,0, replace) ;
+    
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+  test("[A,B,C,D].replace(2,2) => [A,B] + notify", function() {
+
+    // setup the before, after, and replace arrays.  Use generated objects
+    var before  = T.expected(4),
+        after   = [before[0], before[1]];
+
+    obj.replace(0,0, before);
+    observer.observe('[]', 'length') ;
+  
+    obj.replace(2,2) ;
+    
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+});

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

@@ -0,0 +1,50 @@
+// ==========================================================================
+// 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 */
+
+sc_require('debug/test_suites/array/base');
+
+SC.ArraySuite.define(function(T) {
+  
+  var observer, obj ;
+  
+  module(T.desc("shiftObject"), {
+    setup: function() {
+      obj = T.newObject();
+      observer = T.observer(obj);
+    }
+  });
+
+  test("[].shiftObject() => [] + returns undefined + NO notify", function() {
+    observer.observe('[]', 'length') ;
+    equals(obj.shiftObject(), undefined, 'should return undefined') ;
+    T.validateAfter(obj, [], observer, NO, NO);
+  });
+
+  test("[X].shiftObject() => [] + notify", function() {
+    var exp = T.expected(1)[0];
+    
+    obj.replace(0,0, [exp]);
+    observer.observe('[]', 'length') ;
+
+    equals(obj.shiftObject(), exp, 'should return shifted object') ;
+    T.validateAfter(obj, [], observer, YES, YES);
+  });
+
+  test("[A,B,C].shiftObject() => [B,C] + notify", function() {
+    var before  = T.expected(3),
+        value   = before[0],
+        after   = before.slice(1);
+        
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    equals(obj.shiftObject(), value, 'should return shifted object') ;
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+});

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

@@ -0,0 +1,47 @@
+// ==========================================================================
+// 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 */
+
+sc_require('debug/test_suites/array/base');
+
+SC.ArraySuite.define(function(T) {
+  
+  var observer, obj ;
+  
+  module(T.desc("unshiftObject"), {
+    setup: function() {
+      obj = T.newObject();
+      observer = T.observer(obj);
+    }
+  });
+
+  test("returns unshifted object", function() {
+    var exp = T.expected(1)[0];
+    equals(obj.pushObject(exp), exp, 'should return receiver');
+  });
+  
+
+  test("[].unshiftObject(X) => [X] + notify", function() {
+    var exp = T.expected(1);
+    observer.observe('[]', 'length') ;
+    obj.unshiftObject(exp[0]) ;
+    T.validateAfter(obj, exp, observer, YES);
+  });
+
+  test("[A,B,C].unshiftObject(X) => [X,A,B,C] + notify", function() {
+    var after  = T.expected(4),
+        before = after.slice(1),
+        value  = after[0];
+        
+    obj.replace(0,0,before);
+    observer.observe('[]', 'length') ;
+    obj.unshiftObject(value) ;
+    T.validateAfter(obj, after, observer, YES);
+  });
+  
+});

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

@@ -7,8 +7,8 @@
 
 // note: SC.Observable also enhances array.  make sure we are called after
 // SC.Observable so our version of unknownProperty wins.
-sc_require('mixins/observable') ;
-sc_require('mixins/enumerable') ;
+sc_require('mixins/observable');
+sc_require('mixins/enumerable');
 sc_require('system/range_observer');
 
 SC.OUT_OF_RANGE_EXCEPTION = "Index out of range" ;
@@ -33,60 +33,65 @@ SC.OUT_OF_RANGE_EXCEPTION = "Index out of range" ;
   
   You can use the methods defined in this module to access and modify array 
   contents in a KVO-friendly way.  You can also be notified whenever the 
-  membership if an array changes by observing the "[]" property.
-
+  membership if an array changes by changing the syntax of the property to
+  .observes('*myProperty.[]') .
+  
   To support SC.Array in your own class, you must override two
   primitives to use it: replace() and objectAt().  
-
+  
   Note that the SC.Array mixin also incorporates the SC.Enumerable mixin.  All
   SC.Array-like objects are also enumerable.
-
+  
   @extends SC.Enumerable
   @since SproutCore 0.9.0
 */
 SC.Array = {
-
-/**
-  @field {Number} length
   
-  Your array must support the length property.  your replace methods should
-  set this property whenever it changes.
-*/
-  // length: 0,
+  /**
+    Walk like a duck - use isSCArray to avoid conflicts
+  */
+  isSCArray: YES,
   
-/**
-  This is one of the primitves you must implement to support SC.Array.  You 
-  should replace amt objects started at idx with the objects in the passed 
-  array.  You should also call this.enumerableContentDidChange() ;
+  /**
+    @field {Number} length
+    
+    Your array must support the length property.  Your replace methods should
+    set this property whenever it changes.
+  */
+  // length: 0,
   
-  @param {Number} idx 
-    Starting index in the array to replace.  If idx >= length, then append to 
-    the end of the array.
-
-  @param {Number} amt 
-    Number of elements that should be removed from the array, starting at 
-    *idx*.
-
-  @param {Array} objects 
-    An array of zero or more objects that should be inserted into the array at 
-    *idx* 
-*/
+  /**
+    This is one of the primitves you must implement to support SC.Array.  You 
+    should replace amt objects started at idx with the objects in the passed 
+    array.  You should also call this.enumerableContentDidChange() ;
+    
+    @param {Number} idx 
+      Starting index in the array to replace.  If idx >= length, then append to 
+      the end of the array.
+      
+    @param {Number} amt 
+      Number of elements that should be removed from the array, starting at 
+      *idx*.
+      
+    @param {Array} objects 
+      An array of zero or more objects that should be inserted into the array at 
+      *idx* 
+  */
   replace: function(idx, amt, objects) {
     throw "replace() must be implemented to support SC.Array" ;
   },
-
-/**
-  This is one of the primitives you must implement to support SC.Array.  
-  Returns the object at the named index.  If your object supports retrieving 
-  the value of an array item using get() (i.e. myArray.get(0)), then you do
-  not need to implement this method yourself.
-  
-  @param {Number} idx
-    The index of the item to return.  If idx exceeds the current length, 
-    return null.
-*/
-  objectAt: function(idx)
-  {
+  
+  /**
+    This is one of the primitives you must implement to support SC.Array.  
+    Returns the object at the named index.  If your object supports retrieving 
+    the value of an array item using get() (i.e. myArray.get(0)), then you do
+    not need to implement this method yourself.
+    
+    @param {Number} idx
+      The index of the item to return.  If idx exceeds the current length, 
+      return null.
+  */
+  objectAt: function(idx) {
     if (idx < 0) return undefined ;
     if (idx >= this.get('length')) return undefined;
     return this.get(idx);
@@ -94,7 +99,7 @@ SC.Array = {
   
   /**
     @field []
-
+    
     This is the handler for the special array content property.  If you get
     this property, it will return this.  If you set this property it a new 
     array, it will replace the current content.
@@ -108,13 +113,13 @@ SC.Array = {
     return this ;
   }.property(),
   
-/**  
-  This will use the primitive replace() method to insert an object at the 
-  specified index.
-  
-  @param {Number} idx index of insert the object at.
-  @param {Object} object object to insert
-*/
+  /**
+    This will use the primitive replace() method to insert an object at the 
+    specified index.
+    
+    @param {Number} idx index of insert the object at.
+    @param {Object} object object to insert
+  */
   insertAt: function(idx, object) {
     if (idx > this.get('length')) throw SC.OUT_OF_RANGE_EXCEPTION ;
     this.replace(idx,0,[object]) ;
@@ -122,17 +127,48 @@ SC.Array = {
   },
   
   /**
-    Remove an object at the specified index using the replace() primitive method.
-  
-    @param {Number} idx index of object to remove
+    Remove an object at the specified index using the replace() primitive 
+    method.  You can pass either a single index, a start and a length or an
+    index set.
+    
+    If you pass a single index or a start and length that is beyond the 
+    length this method will throw an SC.OUT_OF_RANGE_EXCEPTION
+    
+    @param {Number|SC.IndexSet} start index, start of range, or index set
+    @param {Number} length length of passing range
+    @returns {Object} receiver
   */
-  removeAt: function(idx) {
-    if ((idx < 0) || (idx >= this.get('length'))) throw SC.OUT_OF_RANGE_EXCEPTION;
-    var ret = this.objectAt(idx) ;
-    this.replace(idx,1,[]);
-    return ret ;
+  removeAt: function(start, length) {
+    
+    var delta = 0, // used to shift range
+        empty = [];
+    
+    if (typeof start === SC.T_NUMBER) {
+      
+      if ((start < 0) || (start >= this.get('length'))) {
+        throw SC.OUT_OF_RANGE_EXCEPTION;
+      }
+      
+      // fast case
+      if (length === undefined) {
+        this.replace(start,1,empty);
+        return this ;
+      } else {
+        start = SC.IndexSet.create(start, length);
+      }
+    }
+    
+    this.beginPropertyChanges();
+    start.forEachRange(function(start, length) {
+      start -= delta ;
+      delta += length ;
+      this.replace(start, length, empty); // remove!
+    }, this);
+    this.endPropertyChanges();
+    
+    return this ;
   },
-  
+    
   /**
     Search the array of this object, removing any occurrences of it.
     @param {object} obj object to remove
@@ -146,6 +182,20 @@ SC.Array = {
     return this ;
   },
   
+  /**
+    Search the array for the passed set of objects and remove any occurrences
+    of the. 
+    
+    @param {SC.Enumerable} objects the objects to remove
+    @returns {SC.Array} receiver
+  */
+  removeObjects: function(objects) {
+    this.beginPropertyChanges();
+    objects.forEach(function(obj) { this.removeObject(obj); }, this);
+    this.endPropertyChanges();
+    return this;
+  },
+  
   /**
     Push the object onto the end of the array.  Works just like push() but it 
     is KVO-compliant.
@@ -155,6 +205,21 @@ SC.Array = {
     return obj ;
   },
   
+  
+  /**
+    Add the objects in the passed numerable to the end of the array.  Defers
+    notifying observers of the change until all objects are added.
+    
+    @param {SC.Enumerable} objects the objects to add
+    @returns {SC.Array} receiver
+  */
+  pushObjects: function(objects) {
+    this.beginPropertyChanges();
+    objects.forEach(function(obj) { this.pushObject(obj); }, this);
+    this.endPropertyChanges();
+    return this;
+  },
+
   /**
     Pop object from array or nil if none are left.  Works just like pop() but 
     it is KVO-compliant.
@@ -187,6 +252,21 @@ SC.Array = {
     this.insertAt(0, obj) ;
     return obj ;
   },
+
+  
+  /**
+    Adds the named objects to the beginning of the array.  Defers notifying
+    observers until all objects have been added.
+    
+    @param {SC.Enumerable} objects the objects to add
+    @returns {SC.Array} receiver
+  */
+  unshiftObjects: function(objects) {
+    this.beginPropertyChanges();
+    objects.forEach(function(obj) { this.unshiftObject(obj); }, this);
+    this.endPropertyChanges();
+    return this;
+  },
   
   /**  
     Compares each item in the array.  Returns true if they are equal.
@@ -227,7 +307,7 @@ SC.Array = {
     }) ;
     return ret ;
   },
-  
+
   /**
     Generates a new array with only unique values from the contents of the
     old array.
@@ -242,14 +322,6 @@ SC.Array = {
     return ret ;
   },
   
-  /**
-    SC.CollectionView compatibility. SC.Array does not calculate groups by 
-    default. Use SC.ArrayController and/or SC.ResultSet instead.
-    
-    @type SC.Array
-  */
-  groups: [],
-  
   rangeObserverClass: SC.RangeObserver,
   
   /**
@@ -261,48 +333,135 @@ SC.Array = {
     The callback for a range observer should have the signature:
     
     {{{
-      function rangePropertyDidChange(array, objects, key)
+      function rangePropertyDidChange(array, objects, key, indexes, conext)
     }}}
     
     If the passed key is '[]' it means that the object itself changed.
     
     The return value from this method is an opaque reference to the 
-    ranger observer object.  You can use this reference to destroy the 
+    range observer object.  You can use this reference to destroy the 
     range observer when you are done with it or to update its range.
+    
+    @param {SC.IndexSet} indexes indexes to observe
+    @param {Object} target object to invoke on change
+    @param {String|Function} method the method to invoke
+    @param {Object} context optional context
+    @returns {SC.RangeObserver} range observer
   */
-  createRangeObserver: function(start, length, target, method) {
+  addRangeObserver: function(indexes, target, method, context) {
     var rangeob = this._array_rangeObservers;
-    if (!rangeob) rangeob = this._array_rangeObservers = [] ;
-
+    if (!rangeob) rangeob = this._array_rangeObservers = SC.CoreSet.create() ;
+    
     var C = this.rangeObserverClass ;
-    var ret = C.create(this, start, length, target, method) ;
-    rangeob.push(ret);
+    var isDeep = NO; //disable this feature for now
+    var ret = C.create(this, indexes, target, method, context, isDeep) ;
+    rangeob.add(ret);
+    
+    // first time a range observer is added, begin observing the [] property
+    if (!this._array_isNotifyingRangeObservers) {
+      this._array_isNotifyingRangeObservers = YES ;
+      this.addObserver('[]', this, this._array_notifyRangeObservers);
+    }
+    
     return ret ;
   },
   
-  updateRangeObserver: function(rangeObserver, start, length) {
-    return rangeObserver.update(this, start, length);
+  /**
+    Moves a range observer so that it observes a new range of objects on the 
+    array.  You must have an existing range observer object from a call to
+    addRangeObserver().
+    
+    The return value should replace the old range observer object that you
+    pass in.
+    
+    @param {SC.RangeObserver} rangeObserver the range observer
+    @param {SC.IndexSet} indexes new indexes to observe
+    @returns {SC.RangeObserver} the range observer (or a new one)
+  */
+  updateRangeObserver: function(rangeObserver, indexes) {
+    return rangeObserver.update(this, indexes);
   },
-  
-  destroyRangeObserver: function(rangeObserver) {
+
+  /**
+    Removes a range observer from the receiver.  The range observer must
+    already be active on the array.
+    
+    The return value should replace the old range observer object.  It will
+    usually be null.
+    
+    @param {SC.RangeObserver} rangeObserver the range observer
+    @returns {SC.RangeObserver} updated range observer or null
+  */
+  removeRangeObserver: function(rangeObserver) {
     var ret = rangeObserver.destroy(this);
     var rangeob = this._array_rangeObservers;
-    if (rangeob) rangeob[rangeob.indexOf(rangeObserver)] = null ; // clear
+    if (rangeob) rangeob.remove(rangeObserver) ; // clear
     return ret ;
   },
   
-  enumerableContentDidChange: function(start, length) {
-    // notify range observers
-    var rangeob = this._array_rangeObservers, len, idx, cur;
-    if (rangeob && (len = rangeob.length)>0) {
-      for(idx=0;idx<len;idx++) { 
-        cur = rangeob[idx];
-        if ((length === undefined) || ((start < (cur.start + cur.length)) && ((start+length) > cur.start))) cur.rangeDidChange();
+  /**
+    Updates observers with content change.  To support range observers, 
+    you must pass three change parameters to this method.  Otherwise this
+    method will assume the entire range has changed.
+    
+    This also assumes you have already updated the length property.
+    @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
+    @returns {SC.Array} receiver
+  */
+  enumerableContentDidChange: function(start, amt, delta) {
+    var rangeob = this._array_rangeObservers, 
+        oldlen  = this._array_oldLength,
+        newlen, length, changes ;
+
+    this.beginPropertyChanges();    
+    this.notifyPropertyChange('length'); // flush caches
+
+    // schedule info for range observers
+    if (rangeob && rangeob.length>0) {
+
+      // if no oldLength has been cached, just assume 0
+      if (oldlen === undefined) oldlen = 0;    
+      this._array_oldLength = newlen = this.get('length');
+      
+      // normalize input parameters
+      // if delta was not passed, assume it is the different between the 
+      // new and old length.
+      if (start === undefined) start = 0;
+      if (delta === undefined) delta = newlen - oldlen ;
+      if (delta !== 0 || amt === undefined) {
+        length = newlen - start ;
+        if (delta<0) length -= delta; // cover removed range as well
+      } else {
+        length = amt ;
       }
+      
+      changes = this._array_rangeChanges;
+      if (!changes) changes = this._array_rangeChanges = SC.IndexSet.create();
+      changes.add(start, length);
     }
     
     this.notifyPropertyChange('[]') ;
+    this.endPropertyChanges();
+    
     return this ;
+  },
+  
+  /** 
+    Observer fires whenever the '[]' property changes.  If there are 
+    range observers, will notify observers of change.
+  */
+  _array_notifyRangeObservers: function() {
+    var rangeob = this._array_rangeObservers,
+        changes = this._array_rangeChanges,
+        len     = rangeob ? rangeob.length : 0, 
+        idx, cur;
+        
+    if (len > 0 && changes && changes.length > 0) {
+      for(idx=0;idx<len;idx++) rangeob[idx].rangeDidChange(changes);
+      changes.clear(); // reset for later notifications
+    }
   }
   
 } ;
@@ -335,19 +494,48 @@ SC.Array.slice = function(beginIndex, endIndex) {
   Returns the index for a particular object in the index.
   
   @param {Object} object the item to search for
+  @param {NUmber} startAt optional starting location to search, default 0
   @returns {Number} index of -1 if not found
 */
-SC.Array.indexOf = function(object) {
+SC.Array.indexOf = function(object, startAt) {
   var idx, len = this.get('length');
-  for(idx=0;idx<len;idx++) {
+  
+  if (startAt === undefined) startAt = 0;
+  else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt);
+  if (startAt < 0) startAt += len;
+  
+  for(idx=startAt;idx<len;idx++) {
     if (this.objectAt(idx) === object) return idx ;
   }
   return -1;
 };
 
 // Some browsers do not support indexOf natively.  Patch if needed
-if (!Array.prototype.indexOf) {
-  Array.prototype.indexOf = SC.Array.indexOf;
+if (!Array.prototype.indexOf) Array.prototype.indexOf = SC.Array.indexOf;
+
+/**
+  Returns the last index for a particular object in the index.
+  
+  @param {Object} object the item to search for
+  @param {NUmber} startAt optional starting location to search, default 0
+  @returns {Number} index of -1 if not found
+*/
+SC.Array.lastIndexOf = function(object, startAt) {
+  var idx, len = this.get('length');
+  
+  if (startAt === undefined) startAt = len-1;
+  else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt);
+  if (startAt < 0) startAt += len;
+  
+  for(idx=startAt;idx>=0;idx--) {
+    if (this.objectAt(idx) === object) return idx ;
+  }
+  return -1;
+};
+
+// Some browsers do not support lastIndexOf natively.  Patch if needed
+if (!Array.prototype.lastIndexOf) {
+  Array.prototype.lastIndexOf = SC.Array.lastIndexOf;
 }
 
 // ......................................................
@@ -357,47 +545,69 @@ if (!Array.prototype.indexOf) {
 // because working with arrays are so common.
 (function() {
   SC.mixin(Array.prototype, {
-
+    
     // primitive for array support.
     replace: function(idx, amt, objects) {
+      if (this.isFrozen) throw SC.FROZEN_ERROR ;
       if (!objects || objects.length === 0) {
         this.splice(idx, amt) ;
       } else {
         var args = [idx, amt].concat(objects) ;
         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;
-      if (amt !== len) amt = this.length - idx;
-      this.enumerableContentDidChange(idx, amt) ;
+      this.enumerableContentDidChange(idx, amt, len - amt) ;
       return this ;
     },
-  
+    
     // If you ask for an unknown property, then try to collect the value
     // from member items.
     unknownProperty: function(key, value) {
       var ret = this.reducedProperty(key, value) ;
-      if (ret === undefined) {
-        ret = (value === undefined) ? this.invoke('get', key) : null ;
+      if ((value !== undefined) && ret === undefined) {
+        ret = this[key] = value;
       }
       return ret ;
-    },
+    }
     
+  });
     
-    //indexOf is not implemente in IE for Array
-    indexOf: function(obj) {
-      var len=this.length;
-      for(var i=0; i<len; i++){
-        if(this[i]===obj){
-      	  return i;
-      	}
+  // If browser did not implement indexOf natively, then override with
+  // specialized version
+  var indexOf = Array.prototype.indexOf;
+  if (!indexOf || (indexOf === SC.Array.indexOf)) {
+    Array.prototype.indexOf = function(object, startAt) {
+      var idx, len = this.length;
+      
+      if (startAt === undefined) startAt = 0;
+      else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt);
+      if (startAt < 0) startAt += len;
+      
+      for(idx=startAt;idx<len;idx++) {
+        if (this[idx] === object) return idx ;
       }
       return -1;
-    }
-  }) ;
+    } ; 
+  }
   
-})() ;
-
+  var lastIndexOf = Array.prototype.lastIndexOf ;
+  if (!lastIndexOf || (lastIndexOf === SC.Array.lastIndexOf)) {
+    Array.prototype.lastIndexOf = function(object, startAt) {
+      var idx, len = this.length;
+      
+      if (startAt === undefined) startAt = len-1;
+      else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt);
+      if (startAt < 0) startAt += len;
+      
+      for(idx=startAt;idx>=0;idx--) {
+        if (this[idx] === object) return idx ;
+      }
+      return -1;
+    };
+  }
+  
+})();