sproutcore 1.4.5-java → 1.5.0-java

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 

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

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 

data/lib/frameworks/sproutcore/frameworks/runtime/ext/array.js

@@ -0,0 +1,92 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('mixins/array');
+
+SC.supplement(Array.prototype, SC.CoreArray);
+
+// Because Arrays are dealt with so much, we add specialized functions.
+
+SC.mixin(Array.prototype, {
+
+  // primitive for array support.
+  replace: function(idx, amt, objects) {
+    if (this.isFrozen) { throw SC.FROZEN_ERROR ; }
+
+    var args;
+    var len = objects ? (objects.get ? objects.get('length') : objects.length) : 0;
+
+    // Notify that array content is about to mutate.
+    this.arrayContentWillChange(idx, amt, len);
+
+    if (len === 0) {
+      this.splice(idx, amt) ;
+    } else {
+      args = [idx, amt].concat(objects) ;
+      this.splice.apply(this,args) ;
+    }
+
+    this.arrayContentDidChange(idx, amt, len);
+    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 ((value !== undefined) && ret === undefined) {
+      ret = this[key] = value;
+    }
+    return ret ;
+  }
+
+});
+
+if (Array.prototype.indexOf === SC.CoreArray.indexOf) {
+  /**
+    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
+  */
+  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;
+  } ;
+}
+
+if (Array.prototype.lastIndexOf === SC.CoreArray.lastIndexOf) {
+  /**
+    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
+  */
+  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;
+  };
+}

data/lib/frameworks/sproutcore/frameworks/runtime/ext/date.js

@@ -0,0 +1,15 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+if (!Date.now) {
+  /**
+    @ignore
+  */
+  Date.now = function() {
+    return new Date().getTime() ;
+  };
+}

data/lib/frameworks/sproutcore/frameworks/runtime/ext/function.js

@@ -0,0 +1,189 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/function');
+
+SC.mixin(Function.prototype,
+/** @lends Function.prototype */ {
+
+  /**
+    Indicates that the function should be treated as a computed property.
+
+    Computed properties are methods that you want to treat as if they were
+    static properties.  When you use get() or set() on a computed property,
+    the object will call the property method and return its value instead of
+    returning the method itself.  This makes it easy to create "virtual
+    properties" that are computed dynamically from other properties.
+
+    Consider the following example:
+
+          contact = SC.Object.create({
+
+            firstName: "Charles",
+            lastName: "Jolley",
+
+            // This is a computed property!
+            fullName: function() {
+              return this.getEach('firstName','lastName').compact().join(' ') ;
+            }.property('firstName', 'lastName'),
+
+            // this is not
+            getFullName: function() {
+              return this.getEach('firstName','lastName').compact().join(' ') ;
+            }
+          });
+
+          contact.get('firstName') ;
+          --> "Charles"
+
+          contact.get('fullName') ;
+          --> "Charles Jolley"
+
+          contact.get('getFullName') ;
+          --> function()
+
+    Note that when you get the fullName property, SproutCore will call the
+    fullName() function and return its value whereas when you get() a property
+    that contains a regular method (such as getFullName above), then the
+    function itself will be returned instead.
+
+    Using Dependent Keys
+    ----
+
+    Computed properties are often computed dynamically from other member
+    properties.  Whenever those properties change, you need to notify any
+    object that is observing the computed property that the computed property
+    has changed also.  We call these properties the computed property is based
+    upon "dependent keys".
+
+    For example, in the contact object above, the fullName property depends on
+    the firstName and lastName property.  If either property value changes,
+    any observer watching the fullName property will need to be notified as
+    well.
+
+    You inform SproutCore of these dependent keys by passing the key names
+    as parameters to the property() function.  Whenever the value of any key
+    you name here changes, the computed property will be marked as changed
+    also.
+
+    You should always register dependent keys for computed properties to
+    ensure they update.
+
+    Sometimes you may need to depend on keys that are several objects deep. In
+    that case, you can provide a path to property():
+
+        capitalizedName: function() {
+          return this.getPath('person.fullName').toUpper();
+        }.property('person.firstName')
+
+    This will cause observers of +capitalizedName+ to be fired when either
+    +fullName+ _or_ +person+ changes.
+
+    Using Computed Properties as Setters
+    ---
+
+    Computed properties can be used to modify the state of an object as well
+    as to return a value.  Unlike many other key-value system, you use the
+    same method to both get and set values on a computed property.  To
+    write a setter, simply declare two extra parameters: key and value.
+
+    Whenever your property function is called as a setter, the value
+    parameter will be set.  Whenever your property is called as a getter the
+    value parameter will be undefined.
+
+    For example, the following object will split any full name that you set
+    into a first name and last name components and save them.
+
+          contact = SC.Object.create({
+
+            fullName: function(key, value) {
+              if (value !== undefined) {
+                var parts = value.split(' ') ;
+                this.beginPropertyChanges()
+                  .set('firstName', parts[0])
+                  .set('lastName', parts[1])
+                .endPropertyChanges() ;
+              }
+              return this.getEach('firstName', 'lastName').compact().join(' ');
+            }.property('firstName','lastName')
+
+          }) ;
+
+    Why Use The Same Method for Getters and Setters?
+    ---
+
+    Most property-based frameworks expect you to write two methods for each
+    property but SproutCore only uses one. We do this because most of the time
+    when you write a setter is is basically a getter plus some extra work.
+    There is little added benefit in writing both methods when you can
+    conditionally exclude part of it. This helps to keep your code more
+    compact and easier to maintain.
+
+    @param {String...} dependentKeys optional set of dependent keys
+    @returns {Function} the declared function instance
+  */
+  property: function() {
+    return SC.Function.property(this, arguments);
+  },
+
+  /**
+    You can call this method on a computed property to indicate that the
+    property is cacheable (or not cacheable).  By default all computed
+    properties are not cached.  Enabling this feature will allow SproutCore
+    to cache the return value of your computed property and to use that
+    value until one of your dependent properties changes or until you
+    invoke propertyDidChange() and name the computed property itself.
+
+    If you do not specify this option, computed properties are assumed to be
+    not cacheable.
+
+    @param {Boolean} aFlag optionally indicate cacheable or no, default YES
+    @returns {Function} reciever, useful for chaining calls.
+  */
+  cacheable: function(aFlag) {
+    return SC.Function.cacheable(this, aFlag);
+  },
+
+  /**
+    Indicates that the computed property is volatile.  Normally SproutCore
+    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 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.
+
+    If you do not specify this option, properties are assumed to be
+    non-volatile.
+
+    @param {Boolean} aFlag optionally indicate state, default to YES
+    @returns {Function} reciever, useful for chaining calls.
+  */
+  idempotent: function(aFlag) {
+    return SC.Function.idempotent(this, aFlag);
+  },
+
+  enhance: function() {
+    return SC.Function.enhance(this);
+  },
+
+  /**
+    Declare that a function should observe an object or property at the named 
+    path.  Note that the path is used only to construct the observation one time.
+
+    @param {String...} propertyPaths A list of strings which indicate the
+      properties being observed
+      
+    @returns {Function} reciever, useful for chaining calls.
+  */
+  observes: function(propertyPaths) {
+    return SC.Function.observes(this, arguments);
+  }
+
+});

data/lib/frameworks/sproutcore/frameworks/runtime/ext/string.js

@@ -0,0 +1,31 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('system/string');
+
+/** 
+  @namespace
+  Extends String by adding a few helpful methods.
+*/
+SC.mixin(String.prototype,
+/** @scope String.prototype */ {
+
+  /**
+    @see SC.String.fmt
+  */
+  fmt: function() {
+    return SC.String.fmt(this, arguments);
+  },
+
+  /**
+    @see SC.String.w
+  */
+  w: function() {
+    return SC.String.w(this);
+  }
+
+});

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

@@ -1,28 +1,29 @@
-/*! @license
-==========================================================================
-SproutCore Costello -- Property Observing Library
-Copyright ©2006-2011, Strobe Inc. and contributors.
-Portions copyright ©2008-2010 Apple Inc. All rights reserved.
-
-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 */
+/**
+ * @license
+ * ==========================================================================
+ * SproutCore Costello -- Property Observing Library
+ * Copyright ©2006-2011, Strobe Inc. and contributors.
+ * Portions copyright ©2008-2011 Apple Inc. All rights reserved.
+ * 
+ * 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
+ * 
+ * ==========================================================================
+ */

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

@@ -1,94 +1,111 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 // note: SC.Observable also enhances array.  make sure we are called after
 // SC.Observable so our version of unknownProperty wins.
+sc_require('ext/function');
 sc_require('mixins/observable');
 sc_require('mixins/enumerable');
 sc_require('system/range_observer');
 
-SC.OUT_OF_RANGE_EXCEPTION = "Index out of range" ;
+SC.OUT_OF_RANGE_EXCEPTION = "Index out of range";
+
+SC.CoreArray = /** @lends SC.Array.prototype */ {
 
-/**
-  @namespace
-  
-  This module implements Observer-friendly Array-like behavior.  This mixin is 
-  picked up by the Array class as well as other controllers, etc. that want to  
-  appear to be arrays.
-  
-  Unlike SC.Enumerable, this mixin defines methods specifically for 
-  collections that provide index-ordered access to their contents.  When you
-  are designing code that needs to accept any kind of Array-like object, you
-  should use these methods instead of Array primitives because these will 
-  properly notify observers of changes to the array. 
-  
-  Although these methods are efficient, they do add a layer of indirection to
-  your application so it is a good idea to use them only when you need the 
-  flexibility of using both true JavaScript arrays and "virtual" arrays such
-  as controllers and collections.
-  
-  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 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 = {
-  
   /**
     Walk like a duck - use isSCArray to avoid conflicts
+    @type Boolean
   */
   isSCArray: YES,
-  
+
   /**
     @field {Number} length
-    
+
     Your array must support the length property.  Your replace methods should
     set this property whenever it changes.
   */
   // length: 0,
-  
-  /**
-    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 
+
+  /**
+    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.
+
+    Before mutating the underlying data structure, you must call
+    this.arrayContentWillChange(). After the mutation is complete, you must
+    call arrayContentDidChange() and enumerableContentDidChange().
+
+    NOTE: JavaScript arrays already implement SC.Array and automatically call
+    the correct callbacks.
+
+    @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 
+
+    @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* 
+
+    @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" ;
   },
-  
+
+  /**
+    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
+  */
+  indexOf: function(object, startAt) {
+    var idx, len = this.get('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.objectAt(idx, YES) === object) return idx ;
+    }
+    return -1;
+  },
+
+  /**
+    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
+  */
+  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;
+  },
+
   /**
-    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 
+    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, 
+      The index of the item to return.  If idx exceeds the current length,
       return null.
   */
   objectAt: function(idx) {
@@ -96,27 +113,27 @@ SC.Array = {
     if (idx >= this.get('length')) return undefined;
     return this.get(idx);
   },
-  
+
   /**
     @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 
+    this property, it will return this.  If you set this property it a new
     array, it will replace the current content.
-    
+
     This property overrides the default property defined in SC.Enumerable.
   */
   '[]': function(key, value) {
     if (value !== undefined) {
       this.replace(0, this.get('length'), value) ;
-    }  
+    }
     return this ;
   }.property(),
-  
+
   /**
-    This will use the primitive replace() method to insert an object at the 
+    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
   */
@@ -125,30 +142,30 @@ SC.Array = {
     this.replace(idx,0,[object]) ;
     return this ;
   },
-  
+
   /**
-    Remove an object at the specified index using the replace() primitive 
+    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 
+
+    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(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);
@@ -157,7 +174,7 @@ SC.Array = {
         start = SC.IndexSet.create(start, length);
       }
     }
-    
+
     this.beginPropertyChanges();
     start.forEachRange(function(start, length) {
       start -= delta ;
@@ -165,10 +182,10 @@ SC.Array = {
       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
@@ -181,11 +198,11 @@ SC.Array = {
     }
     return this ;
   },
-  
+
   /**
     Search the array for the passed set of objects and remove any occurrences
-    of the. 
-    
+    of the.
+
     @param {SC.Enumerable} objects the objects to remove
     @returns {SC.Array} receiver
   */
@@ -195,21 +212,46 @@ SC.Array = {
     this.endPropertyChanges();
     return this;
   },
-  
+
   /**
-    Push the object onto the end of the array.  Works just like push() but it 
+    Returns a new array that is a slice of the receiver.  This implementation
+    uses the observable array methods to retrieve the objects for the new
+    slice.
+
+    If you don't pass in beginIndex and endIndex, it will act as a copy of the
+    array.
+
+    @param beginIndex {Integer} (Optional) index to begin slicing from.
+    @param endIndex {Integer} (Optional) index to end the slice at.
+    @returns {Array} New array with specified slice
+  */
+  slice: function(beginIndex, endIndex) {
+    var ret = [];
+    var length = this.get('length') ;
+    if (SC.none(beginIndex)) beginIndex = 0 ;
+    if (SC.none(endIndex) || (endIndex > length)) endIndex = length ;
+    while(beginIndex < endIndex) ret[ret.length] = this.objectAt(beginIndex++) ;
+    return ret ;
+  },
+
+  /**
+    Push the object onto the end of the array.  Works just like push() but it
     is KVO-compliant.
+
+    @param {Object} object the objects to push
+
+    @return {Object} The passed object
   */
   pushObject: function(obj) {
     this.insertAt(this.get('length'), obj) ;
     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
   */
@@ -221,21 +263,25 @@ SC.Array = {
   },
 
   /**
-    Pop object from array or nil if none are left.  Works just like pop() but 
+    Pop object from array or nil if none are left.  Works just like pop() but
     it is KVO-compliant.
+
+    @return {Object} The popped object
   */
   popObject: function() {
     var len = this.get('length') ;
     if (len === 0) return null ;
-    
+
     var ret = this.objectAt(len-1) ;
     this.removeAt(len-1) ;
     return ret ;
   },
-  
+
   /**
-    Shift an object from start of array or nil if none are left.  Works just 
+    Shift an object from start of array or nil if none are left.  Works just
     like shift() but it is KVO-compliant.
+
+    @return {Object} The shifted object
   */
   shiftObject: function() {
     if (this.get('length') === 0) return null ;
@@ -243,21 +289,23 @@ SC.Array = {
     this.removeAt(0) ;
     return ret ;
   },
-  
+
   /**
-    Unshift an object to start of array.  Works just like unshift() but it is 
+    Unshift an object to start of array.  Works just like unshift() but it is
     KVO-compliant.
+
+    @param {Object} obj the object to add
+    @return {Object} The passed object
   */
   unshiftObject: function(obj) {
     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
   */
@@ -267,14 +315,17 @@ SC.Array = {
     this.endPropertyChanges();
     return this;
   },
-  
-  /**  
-    Compares each item in the array.  Returns true if they are equal.
+
+  /**
+    Compares each item in the passed array to this one.
+
+    @param {Array} ary The array you want to compare to
+    @returns {Boolean} true if they are equal.
   */
   isEqual: function(ary) {
     if (!ary) return false ;
     if (ary == this) return true;
-    
+
     var loc = ary.get('length') ;
     if (loc != this.get('length')) return false ;
 
@@ -283,27 +334,27 @@ SC.Array = {
     }
     return true ;
   },
-  
+
   /**
     Generates a new array with the contents of the old array, sans any null
     values.
-    
-    @returns {Array}
+
+    @returns {Array} The new, compact array
   */
   compact: function() { return this.without(null); },
-  
+
   /**
     Generates a new array with the contents of the old array, sans the passed
     value.
-    
-    @param {Object} value
-    @returns {Array}
+
+    @param {Object} value The value you want to be removed
+    @returns {Array} The new, filtered array
   */
   without: function(value) {
     if (this.indexOf(value)<0) return this; // value not present.
     var ret = [] ;
-    this.forEach(function(k) { 
-      if (k !== value) ret[ret.length] = k; 
+    this.forEach(function(k) {
+      if (k !== value) ret[ret.length] = k;
     }) ;
     return ret ;
   },
@@ -311,8 +362,8 @@ SC.Array = {
   /**
     Generates a new array with only unique values from the contents of the
     old array.
-    
-    @returns {Array}
+
+    @returns {Array} The new, de-duped array
   */
   uniq: function() {
     var ret = [] ;
@@ -321,51 +372,59 @@ SC.Array = {
     });
     return ret ;
   },
-  
+
   /**
     Returns the largest Number in an array of Numbers. Make sure the array
     only contains values of type Number to get expected result.
-    
+
     Note: This only works for dense arrays.
-    
+
     @returns {Number}
   */
   max: function() {
     return Math.max.apply(Math, this);
   },
-  
+
   /**
     Returns the smallest Number in an array of Numbers. Make sure the array
     only contains values of type Number to get expected result.
-    
+
     Note: This only works for dense arrays.
-    
+
     @returns {Number}
   */
   min: function() {
     return Math.min.apply(Math, this);
   },
-  
+
   rangeObserverClass: SC.RangeObserver,
-  
+
+  /**
+    Returns YES if object is in the array
+
+    @param {Object} object to look for
+    @returns {Boolean}
+  */
+  contains: function(obj){
+    return this.indexOf(obj) >= 0;
+  },
+
   /**
     Creates a new range observer on the receiver.  The target/method callback
-    you provide will be invoked anytime any property on the objects in the 
+    you provide will be invoked anytime any property on the objects in the
     specified range changes.  It will also be invoked if the objects in the
     range itself changes also.
-    
+
     The callback for a range observer should have the signature:
-    
-    {{{
-      function rangePropertyDidChange(array, objects, key, indexes, conext)
-    }}}
-    
+
+          function rangePropertyDidChange(array, objects, key, indexes, context)
+
     If the passed key is '[]' it means that the object itself changed.
-    
-    The return value from this method is an opaque reference to the 
-    range observer object.  You can use this reference to destroy the 
+
+    The return value from this method is an opaque reference to 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
@@ -381,29 +440,29 @@ SC.Array = {
     if (this._array_oldLength===undefined) {
       this._array_oldLength = this.get('length') ;
     }
-    
+
     var C = this.rangeObserverClass ;
     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 ;
   },
-  
+
   /**
-    Moves a range observer so that it observes a new range of objects on the 
+    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)
@@ -415,10 +474,10 @@ SC.Array = {
   /**
     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
   */
@@ -428,216 +487,417 @@ SC.Array = {
     if (rangeob) rangeob.remove(rangeObserver) ; // clear
     return ret ;
   },
-  
-  /**
-    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,
+
+  addArrayObservers: function(options) {
+    this._modifyObserverSet('add', options);
+  },
+
+  removeArrayObservers: function(options) {
+    this._modifyObserverSet('remove', options);
+  },
+
+  _modifyObserverSet: function(method, options) {
+    var willChangeObservers, didChangeObservers;
+
+    var target     = options.target || this;
+    var willChange = options.willChange || 'arrayWillChange';
+    var didChange  = options.didChange || 'arrayDidChange';
+    var context    = options.context;
+
+    if (typeof willChange === "string") {
+      willChange = target[willChange];
+    }
+
+    if (typeof didChange === "string") {
+      didChange = target[didChange];
+    }
+
+    willChangeObservers = this._kvo_for('_kvo_array_will_change', SC.ObserverSet);
+    didChangeObservers  = this._kvo_for('_kvo_array_did_change', SC.ObserverSet);
+
+    willChangeObservers[method](target, willChange, context);
+    didChangeObservers[method](target, didChange, context);
+  },
+
+  arrayContentWillChange: function(start, removedCount, addedCount) {
+    this._teardownContentObservers(start, removedCount);
+
+    var member, members, membersLen, idx;
+    var target, action;
+    var willChangeObservers = this._kvo_array_will_change;
+    if (willChangeObservers) {
+      members = willChangeObservers.members;
+      membersLen = members.length;
+
+      for (idx = 0; idx < membersLen; idx++) {
+        member = members[idx];
+        target = member[0];
+        action = member[1];
+        action.call(target, start, removedCount, addedCount, this);
+      }
+    }
+  },
+
+  arrayContentDidChange: function(start, removedCount, addedCount) {
+    var rangeob = this._array_rangeObservers,
         newlen, length, changes ;
 
-    this.beginPropertyChanges();    
+    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
+      changes = this._array_rangeChanges;
+      if (!changes) { changes = this._array_rangeChanges = SC.IndexSet.create(); }
+      if (removedCount === addedCount) {
+        length = removedCount;
       } else {
-        length = amt ;
+        length = this.get('length') - start;
+
+        if (removedCount > addedCount) {
+          length += (removedCount - addedCount);
+        }
       }
-      
-      changes = this._array_rangeChanges;
-      if (!changes) changes = this._array_rangeChanges = SC.IndexSet.create();
       changes.add(start, length);
     }
-    
+
+    this._setupContentObservers(start, addedCount);
+
+    var member, members, membersLen, idx;
+    var target, action;
+    var didChangeObservers = this._kvo_array_did_change;
+    if (didChangeObservers) {
+      members = didChangeObservers.members;
+      membersLen = members.length;
+
+      for (idx = 0; idx < membersLen; idx++) {
+        member = members[idx];
+        target = member[0];
+        action = member[1];
+        action.call(target, start, removedCount, addedCount, this);
+      }
+    }
+
     this.notifyPropertyChange('[]') ;
     this.endPropertyChanges();
-    
+
+    return this ;
+  },
+
+  /**
+    @private
+
+    When enumerable content has changed, remove enumerable observers from
+    items that are no longer in the enumerable, and add observers to newly
+    added items.
+
+    @param {Array} addedObjects the array of objects that have been added
+    @param {Array} removedObjects the array of objects that have been removed
+  */
+  _setupContentObservers: function(start, addedCount) {
+    var observedKeys = this._kvo_for('_kvo_content_observed_keys', SC.CoreSet);
+    var addedObjects;
+    var kvoKey;
+
+    // Only setup and teardown enumerable observers if we have keys to observe
+    if (observedKeys.get('length') > 0) {
+      addedObjects = this.slice(start, start+addedCount);
+
+      var self = this;
+      // added and resume the chain observer.
+      observedKeys.forEach(function(key) {
+        kvoKey = SC.keyFor('_kvo_content_observers', key);
+
+        // Get all original ChainObservers associated with the key
+        self._kvo_for(kvoKey).forEach(function(observer) {
+          addedObjects.forEach(function(item) {
+            self._resumeChainObservingForItemWithChainObserver(item, observer);
+          });
+        });
+      });
+    }
+  },
+
+  _teardownContentObservers: function(start, removedCount) {
+    var observedKeys = this._kvo_for('_kvo_content_observed_keys', SC.CoreSet);
+    var removedObjects;
+    var kvoKey;
+
+    // Only setup and teardown enumerable observers if we have keys to observe
+    if (observedKeys.get('length') > 0) {
+      removedObjects = this.slice(start, start+removedCount);
+
+      // added and resume the chain observer.
+      observedKeys.forEach(function(key) {
+        kvoKey = SC.keyFor('_kvo_content_observers', key);
+
+        // Loop through removed objects and remove any enumerable observers that
+        // belong to them.
+        removedObjects.forEach(function(item) {
+          item._kvo_for(kvoKey).forEach(function(observer) {
+            observer.destroyChain();
+          });
+        });
+      });
+    }
+  },
+
+  teardownEnumerablePropertyChains: function(removedObjects) {
+    var chains = this._kvo_enumerable_property_chains;
+
+    if (chains) {
+      chains.forEach(function(chain) {
+        var idx, len = removedObjects.get('length'),
+            chainGuid = SC.guidFor(chain),
+            clonedChain, item, kvoChainList = '_kvo_enumerable_property_clones';
+
+        chain.notifyPropertyDidChange();
+
+        for (idx = 0; idx < len; idx++) {
+          item = removedObjects[idx];
+          clonedChain = item[kvoChainList][chainGuid];
+          clonedChain.deactivate();
+          delete item[kvoChainList][chainGuid];
+        }
+      }, this);
+    }
+    return this ;
+  },
+
+  /**
+    For all registered property chains on this object, removed them from objects
+    being removed from the enumerable, and clone them onto newly added objects.
+
+    @param {Object[]} addedObjects the objects being added to the enumerable
+    @param {Object[]} removedObjects the objected being removed from the enumerable
+    @returns {Object} receiver
+  */
+  setupEnumerablePropertyChains: function(addedObjects) {
+    var chains = this._kvo_enumerable_property_chains;
+
+    if (chains) {
+      chains.forEach(function(chain) {
+        var idx, len = addedObjects.get('length');
+
+        chain.notifyPropertyDidChange();
+
+        len = addedObjects.get('length');
+        for (idx = 0; idx < len; idx++) {
+          this._clonePropertyChainToItem(chain, addedObjects[idx]);
+        }
+      }, this);
+    }
     return this ;
   },
-  
+
+  /**
+    Register a property chain to propagate to enumerable content.
+
+    This will clone the property chain to each item in the enumerable,
+    then save it so that it is automatically set up and torn down when
+    the enumerable content changes.
+
+    @param {String} property the property being listened for on this object
+    @param {SC._PropertyChain} chain the chain to clone to items
+  */
+  registerDependentKeyWithChain: function(property, chain) {
+    // Get the set of all existing property chains that should
+    // be propagated to enumerable contents. If that set doesn't
+    // exist yet, _kvo_for() will create it.
+    var kvoChainList = '_kvo_enumerable_property_chains',
+        chains, item, clone, cloneList;
+
+    chains = this._kvo_for(kvoChainList, SC.CoreSet);
+
+    // Save a reference to the chain on this object. If new objects
+    // are added to the enumerable, we will clone this chain and add
+    // it to the new object.
+    chains.add(chain);
+
+    this.forEach(function(item) {
+      this._clonePropertyChainToItem(chain, item);
+    }, this);
+  },
+
+  /**
+    Clones an SC._PropertyChain to a content item.
+
+    @param {SC._PropertyChain} chain
+    @param {Object} item
+  */
+  _clonePropertyChainToItem: function(chain, item) {
+    var clone        = SC.clone(chain),
+        kvoCloneList = '_kvo_enumerable_property_clones',
+        cloneList;
+
+    clone.object = item;
+
+    cloneList = item[kvoCloneList] = item[kvoCloneList] || {};
+    cloneList[SC.guidFor(chain)] = clone;
+
+    clone.activate(item);
+  },
+
+  /**
+    Removes a dependent key from the enumerable, and tears it down on
+    all content objects.
+
+    @param {String} property
+    @param {SC._PropertyChain} chain
+  */
+  removeDependentKeyWithChain: function(property, chain) {
+    var kvoChainList = '_kvo_enumerable_property_chains',
+        kvoCloneList = '_kvo_enumerable_property_clones',
+        chains, item, clone, cloneList;
+
+    this.forEach(function(item) {
+      item.removeDependentKeyWithChain(property, chain);
+
+      cloneList = item[kvoCloneList];
+      clone = cloneList[SC.guidFor(chain)];
+
+      clone.deactivate(item);
+    }, this);
+  },
+
+  /**
+    @private
+
+    Clones a segment of an observer chain and applies it
+    to an element of this Enumerable.
+
+    @param {Object} item The element
+    @param {SC._ChainObserver} chainObserver the chain segment to begin from
+  */
+  _resumeChainObservingForItemWithChainObserver: function(item, chainObserver) {
+    var observer = SC.clone(chainObserver.next);
+    var key = observer.property;
+
+    // The chain observer should create new observers on the child object
+    observer.object = item;
+    item.addObserver(key, observer, observer.propertyDidChange);
+
+    // if we're in the initial chained observer setup phase, add the tail
+    // of the current observer segment to the list of tracked tails.
+    if(chainObserver.root.tails) {
+      chainObserver.root.tails.pushObject(observer.tail());
+    }
+
+    observer.propertyDidChange();
+
+    // Maintain a list of observers on the item so we can remove them
+    // if it is removed from the enumerable.
+    item._kvo_for(SC.keyFor('_kvo_content_observers', key)).push(observer);
+  },
+
+  /**
+    @private
+
+    Adds a content observer. Content observers are able to
+    propagate chain observers to each member item in the enumerable,
+    so that the observer is fired whenever a single item changes.
+
+    You should never call this method directly. Instead, you should
+    call addObserver() with the special '@each' property in the path.
+
+    For example, if you wanted to observe changes to each item's isDone
+    property, you could call:
+
+        arrayController.addObserver('@each.isDone');
+
+    @param {SC._ChainObserver} chainObserver the chain observer to propagate
+  */
+  _addContentObserver: function(chainObserver) {
+    var key = chainObserver.next.property;
+
+    // Add the key to a set so we know what we are observing
+    this._kvo_for('_kvo_content_observed_keys', SC.CoreSet).push(key);
+
+    // Add the passed ChainObserver to an ObserverSet for that key
+    var kvoKey = SC.keyFor('_kvo_content_observers', key);
+    this._kvo_for(kvoKey).push(chainObserver);
+
+    // set up chained observers on the initial content
+    this._setupContentObservers(0, chainObserver.object.get('length'));
+  },
+
+  /**
+    @private
+
+    Removes a content observer. Pass the same chain observer
+    that was used to add the content observer.
+
+    @param {SC._ChainObserver} chainObserver the chain observer to propagate
+  */
+
+  _removeContentObserver: function(chainObserver) {
+    var observers, kvoKey;
+    var observedKeys = this._kvo_content_observed_keys;
+    var key = chainObserver.next.property;
+
+    if (observedKeys.contains(key)) {
+
+      kvoKey = SC.keyFor('_kvo_content_observers', key);
+      observers = this._kvo_for(kvoKey);
+
+      observers.removeObject(chainObserver);
+
+      this._teardownContentObservers(0, chainObserver.object.get('length'));
+
+      if (observers.length === 0) {
+        this._kvo_for('_kvo_content_observed_keys').remove(key);
+      }
+    }
+  },
+
   /**  @private
-    Observer fires whenever the '[]' property changes.  If there are 
+    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, 
+        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
     }
   }
-  
-} ;
 
-// Add SC.Array to the built-in array before we add SC.Enumerable to SC.Array
-// since built-in Array's are already enumerable.
-SC.mixin(Array.prototype, SC.Array) ; 
-SC.Array = SC.mixin({}, SC.Enumerable, SC.Array) ;
+} ;
 
-// Add any extra methods to SC.Array that are native to the built-in Array.
 /**
-  Returns a new array that is a slice of the receiver.  This implementation
-  uses the observable array methods to retrieve the objects for the new 
-  slice.
-  
-  @param beginIndex {Integer} (Optional) index to begin slicing from.     
-  @param endIndex {Integer} (Optional) index to end the slice at.
-  @returns {Array} New array with specified slice
-*/
-SC.Array.slice = function(beginIndex, endIndex) {
-  var ret = []; 
-  var length = this.get('length') ;
-  if (SC.none(beginIndex)) beginIndex = 0 ;
-  if (SC.none(endIndex) || (endIndex > length)) endIndex = length ;
-  while(beginIndex < endIndex) ret[ret.length] = this.objectAt(beginIndex++) ;
-  return ret ;
-}  ;
+  @namespace
 
-/**
-  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, startAt) {
-  var idx, len = this.get('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.objectAt(idx) === object) return idx ;
-  }
-  return -1;
-};
+  This module implements Observer-friendly Array-like behavior.  This mixin is
+  picked up by the Array class as well as other controllers, etc. that want to
+  appear to be arrays.
 
-// Some browsers do not support indexOf natively.  Patch if needed
-if (!Array.prototype.indexOf) Array.prototype.indexOf = SC.Array.indexOf;
+  Unlike SC.Enumerable, this mixin defines methods specifically for
+  collections that provide index-ordered access to their contents.  When you
+  are designing code that needs to accept any kind of Array-like object, you
+  should use these methods instead of Array primitives because these will
+  properly notify observers of changes to the array.
 
-/**
-  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
+  Although these methods are efficient, they do add a layer of indirection to
+  your application so it is a good idea to use them only when you need the
+  flexibility of using both true JavaScript arrays and "virtual" arrays such
+  as controllers and collections.
+
+  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 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.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;
-}
-
-// ......................................................
-// ARRAY SUPPORT
-//
-// Implement the same enhancements on Array.  We use specialized methods
-// 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;
-      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 ((value !== undefined) && ret === undefined) {
-        ret = this[key] = value;
-      }
-      return ret ;
-    }
-    
-  });
-    
-  // 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;
-    };
-  }
-  
-})();
+SC.Array = SC.mixin({}, SC.Enumerable, SC.CoreArray);