sproutcore 1.9.2 → 1.10.0.rc.1

data/lib/frameworks/sproutcore/frameworks/datastore/system/record_array.js

@@ -16,7 +16,7 @@ sc_require('models/record');
   your application can work with.
 
   Normally you do not create `RecordArray`s yourself.  Instead, a
-  `RecordArray` is returned when you call `SC.Store.findAll()`, already
+  `RecordArray` is returned when you call `SC.Store.find()`, already
   properly configured. You can usually just work with the `RecordArray`
   instance just like any other array.
 
@@ -43,7 +43,7 @@ sc_require('models/record');
   computationally heavy to match a large dataset to a query. To avoid the
   browser from ever showing a slow script timer in this scenario, the query
   matching is by default paced at 100ms. If query matching takes longer than
-  100ms, it will chunk the work with setTimeout to avoid too much computation
+  100ms, it will chunk the work with invokeNext to avoid too much computation
   to happen in one runloop.
 
 
@@ -212,7 +212,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
         len       = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
         i, keys;
 
-    if (!storeKeys) throw "Unable to edit an SC.RecordArray that does not have its storeKeys property set.";
+    if (!storeKeys) throw new Error("Unable to edit an SC.RecordArray that does not have its storeKeys property set.");
 
     if (!this.get('isEditable')) throw SC.RecordArray.NOT_EDITABLE;
 
@@ -575,18 +575,13 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
     // if we reach our threshold of pacing we need to schedule the rest of the
     // storeKeys to also be updated
-    if(storeKeysToPace.length>0) {
-      var self = this;
-      // use setTimeout here to guarantee that we hit the next runloop,
-      // and not the same runloop which the invoke* methods do not guarantee
-      window.setTimeout(function() {
-        SC.run(function() {
-          if(!self || self.get('isDestroyed')) return;
-          self.set('needsFlush', YES);
-          self._scq_changedStoreKeys = SC.IndexSet.create().addEach(storeKeysToPace);
-          self.flush();
-        });
-      }, 1);
+    if (storeKeysToPace.length > 0) {
+      this.invokeNext(function () {
+        if (!this || this.get('isDestroyed')) return;
+        this.set('needsFlush', YES);
+        this._scq_changedStoreKeys = SC.IndexSet.create().addEach(storeKeysToPace);
+        this.flush();
+      });
     }
 
     // clear set of changed store keys
@@ -757,7 +752,7 @@ SC.RecordArray.mixin(/** @scope SC.RecordArray.prototype */{
   /**
     Number of milliseconds to allow a query matching to run for. If this number
     is exceeded, the query matching will be paced so as to not lock up the
-    browser (by essentially splitting the work with a setTimeout)
+    browser (by essentially splitting the work with an invokeNext)
 
     @type Number
   */

data/lib/frameworks/sproutcore/frameworks/datastore/system/store.js

@@ -84,13 +84,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.DataSource|String} dataSource the data source
     @returns {SC.Store} receiver
   */
-  from: function(dataSource) {
+  from: function (dataSource) {
     this.set('dataSource', dataSource);
     return this ;
   },
 
   // lazily convert data source to real object
-  _getDataSource: function() {
+  _getDataSource: function () {
     var ret = this.get('dataSource');
     if (typeof ret === SC.T_STRING) {
       ret = SC.requiredObjectForPropertyPath(ret);
@@ -108,7 +108,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.DataSource...} dataSource one or more data source arguments
     @returns {SC.Store} receiver
   */
-  cascade: function(dataSource) {
+  cascade: function (dataSource) {
     var dataSources = SC.A(arguments) ;
     dataSource = SC.CascadeDataSource.create({
       dataSources: dataSources
@@ -134,7 +134,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Class} newStoreClass optional the class of the newly-created nested store (defaults to SC.NestedStore)
     @returns {SC.NestedStore} new nested store chained to receiver
   */
-  chain: function(attrs, newStoreClass) {
+  chain: function (attrs, newStoreClass) {
     if (!attrs) attrs = {};
     attrs.parentStore = this;
 
@@ -166,7 +166,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {SC.Store} receiver
   */
-  willDestroyNestedStore: function(nestedStore) {
+  willDestroyNestedStore: function (nestedStore) {
     if (this.nestedStores) {
       this.nestedStores.removeObject(nestedStore);
     }
@@ -180,7 +180,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Store} store store instance
     @returns {Boolean} YES if belongs
   */
-  hasNestedStore: function(store) {
+  hasNestedStore: function (store) {
     while(store && (store !== this)) store = store.get('parentStore');
     return store === this ;
   },
@@ -293,7 +293,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey the store key
     @returns {Number} edit status
   */
-  storeKeyEditState: function(storeKey) {
+  storeKeyEditState: function (storeKey) {
     var editables = this.editables, locks = this.locks;
     return (editables && editables[storeKey]) ? SC.Store.EDITABLE : SC.Store.LOCKED ;
   },
@@ -306,7 +306,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey key to retrieve
     @returns {Hash} data hash or null
   */
-  readDataHash: function(storeKey) {
+  readDataHash: function (storeKey) {
     return this.dataHashes[storeKey];
   },
 
@@ -321,7 +321,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey the store key to retrieve
     @returns {Hash} the attributes hash
   */
-  readEditableDataHash: function(storeKey) {
+  readEditableDataHash: function (storeKey) {
     // read the value - if there is no hash just return; nothing to do
     var ret = this.dataHashes[storeKey];
     if (!ret) return ret ; // nothing to do.
@@ -346,7 +346,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} propertyName property to read
     @returns {Object} editable property value
   */
-  readEditableProperty: function(storeKey, propertyName) {
+  readEditableProperty: function (storeKey, propertyName) {
     var hash      = this.readEditableDataHash(storeKey),
         editables = this.editables[storeKey], // get editable info...
         ret       = hash[propertyName];
@@ -382,7 +382,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} status the new hash status
     @returns {SC.Store} receiver
   */
-  writeDataHash: function(storeKey, hash, status) {
+  writeDataHash: function (storeKey, hash, status) {
 
     // update dataHashes and optionally status.
     if (hash) this.dataHashes[storeKey] = hash;
@@ -418,7 +418,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} status optional new status
     @returns {SC.Store} receiver
   */
-  removeDataHash: function(storeKey, status) {
+  removeDataHash: function (storeKey, status) {
      // don't use delete -- that will allow parent dataHash to come through
     this.dataHashes[storeKey] = null;
     this.statuses[storeKey] = status || SC.Record.EMPTY;
@@ -437,7 +437,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey the store key
     @returns {Number} status
   */
-  readStatus: function(storeKey) {
+  readStatus: function (storeKey) {
     // use readDataHash to handle optimistic locking.  this could be inlined
     // but for now this minimized copy-and-paste code.
     this.readDataHash(storeKey);
@@ -452,7 +452,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey the store key
     @returns {Number} status
   */
-  peekStatus: function(storeKey) {
+  peekStatus: function (storeKey) {
     return this.statuses[storeKey] || SC.Record.EMPTY;
   },
 
@@ -466,7 +466,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Error} error optional error object
     @returns {SC.Store} receiver
   */
-  writeStatus: function(storeKey, newStatus) {
+  writeStatus: function (storeKey, newStatus) {
     // use writeDataHash for now to handle optimistic lock.  maximize code
     // reuse.
     return this.writeDataHash(storeKey, null, newStatus);
@@ -484,7 +484,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} key that changed (optional)
     @returns {SC.Store} receiver
   */
-  dataHashDidChange: function(storeKeys, rev, statusOnly, key) {
+  dataHashDidChange: function (storeKeys, rev, statusOnly, key) {
 
     // update the revision for storeKey.  Use generateStoreKey() because that
     // guarantees a universally (to this store hierarchy anyway) unique
@@ -506,7 +506,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       this.revisions[storeKey] = rev;
       this._notifyRecordPropertyChange(storeKey, statusOnly, key);
 
-      this._propagateToChildren(storeKey, function(storeKey){
+      this._propagateToChildren(storeKey, function (storeKey) {
         that.dataHashDidChange(storeKey, null, statusOnly, key);
       });
     }
@@ -518,7 +518,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     Will push all changes to a the recordPropertyChanges property
     and execute `flush()` once at the end of the runloop.
   */
-  _notifyRecordPropertyChange: function(storeKey, statusOnly, key) {
+  _notifyRecordPropertyChange: function (storeKey, statusOnly, key) {
 
     var records      = this.records,
         nestedStores = this.get('nestedStores'),
@@ -599,7 +599,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {SC.Store} receiver
   */
-  flush: function() {
+  flush: function () {
     if (!this.recordPropertyChanges) return this;
 
     var changes              = this.recordPropertyChanges,
@@ -610,7 +610,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         recordTypes = SC.CoreSet.create(),
         rec, recordType, statusOnly, idx, len, storeKey, keys;
 
-    storeKeys.forEach(function(storeKey) {
+    storeKeys.forEach(function (storeKey) {
       if (records.contains(storeKey)) {
         statusOnly = hasDataChanges.contains(storeKey) ? NO : YES;
         rec = this.records[storeKey];
@@ -649,7 +649,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {SC.Store} receiver
   */
-  reset: function() {
+  reset: function () {
 
     // create a new empty data store
     this.dataHashes = {} ;
@@ -673,6 +673,16 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
     }
 
+    // Also reset all pre-created recordArrays.
+    var ra, raList = this.get('recordArrays');
+    if (raList) {
+      while (ra = raList.pop()) {
+        ra.destroy();
+      }
+      raList.clear();
+      this.set('recordArrays', null);
+    }
+
     this.set('hasChanges', NO);
   },
 
@@ -692,7 +702,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Boolean} force
     @returns {SC.Store} receiver
   */
-  commitChangesFromNestedStore: function(nestedStore, changes, force) {
+  commitChangesFromNestedStore: function (nestedStore, changes, force) {
     // first, check for optimistic locking problems
     if (!force) this._verifyLockRevisions(changes, nestedStore.locks);
 
@@ -756,7 +766,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Set} locks the locks to verify
     @returns {SC.Store} receiver
   */
-  _verifyLockRevisions: function(changes, locks) {
+  _verifyLockRevisions: function (changes, locks) {
     var len = changes.length, revs = this.revisions, i, storeKey, lock, rev ;
     if (locks && revs) {
       for(i=0;i<len;i++) {
@@ -838,7 +848,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} id the id to load
     @returns {SC.Record} record instance or null
   */
-  find: function(recordType, id) {
+  find: function (recordType, id) {
 
     // if recordType is passed as string, find object
     if (SC.typeOf(recordType)===SC.T_STRING) {
@@ -859,29 +869,8 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
   },
 
-  /** @private
-    DEPRECATED used find() instead.
-
-    This method will accept a record type or query and return a record array
-    matching the results.  This method was commonly used prior to SproutCore
-    1.0.  It has been deprecated in favor of a single `find()` method instead.
-
-    For compatibility, this method will continue to work in SproutCore 1.0 but
-    it will raise a warning.  It will be removed in a future version of
-    SproutCore.
-  */
-  findAll: function(recordType, conditions, params) {
-    SC.Logger.warn("SC.Store#findAll() will be removed in a future version of SproutCore.  Use SC.Store#find() instead");
-
-    if (!recordType || !recordType.isQuery) {
-      recordType = SC.Query.local(recordType, conditions, params);
-    }
-
-    return this._findQuery(recordType, YES, YES);
-  },
-
-
-  _findQuery: function(query, createIfNeeded, refreshIfNew) {
+  /** @private */
+  _findQuery: function (query, createIfNeeded, refreshIfNew) {
 
     // lookup the local RecordArray for this query.
     var cache = this._scst_recordArraysByQuery,
@@ -906,7 +895,8 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return ret ;
   },
 
-  _findRecord: function(recordType, id) {
+  /** @private */
+  _findRecord: function (recordType, id) {
 
     var storeKey ;
 
@@ -942,7 +932,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.RecordArray} recordArray the record array
     @returns {SC.Store} receiver
   */
-  recordArrayWillDestroy: function(recordArray) {
+  recordArrayWillDestroy: function (recordArray) {
     var cache = this._scst_recordArraysByQuery,
         set   = this.get('recordArrays');
 
@@ -962,7 +952,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Query} query the record array query to refresh
     @returns {SC.Store} receiver
   */
-  refreshQuery: function(query) {
+  refreshQuery: function (query) {
     if (!query) throw new Error("refreshQuery() requires a query");
 
     var cache    = this._scst_recordArraysByQuery,
@@ -978,18 +968,18 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   /** @private
-    Will ask all record arrays that have been returned from `findAll`
+    Will ask all record arrays that have been returned from `find`
     with an `SC.Query` to check their arrays with the new `storeKey`s
 
     @param {SC.IndexSet} storeKeys set of storeKeys that changed
     @param {SC.Set} recordTypes
     @returns {SC.Store} receiver
   */
-  _notifyRecordArrays: function(storeKeys, recordTypes) {
+  _notifyRecordArrays: function (storeKeys, recordTypes) {
     var recordArrays = this.get('recordArrays');
     if (!recordArrays) return this;
 
-    recordArrays.forEach(function(recArray) {
+    recordArrays.forEach(function (recArray) {
       if (recArray) recArray.storeDidChangeStoreKeys(storeKeys, recordTypes);
     }, this);
 
@@ -1010,7 +1000,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Record} recordType the record type
     @returns {SC.Array} array instance - usually SC.RecordArray
   */
-  recordsFor: function(recordType) {
+  recordsFor: function (recordType) {
     var storeKeys     = [],
         storeKeysById = recordType.storeKeysById(),
         id, storeKey, ret;
@@ -1029,6 +1019,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return ret ;
   },
 
+  /** @private */
   _TMP_REC_ATTRS: {},
 
   /**
@@ -1044,7 +1035,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey The storeKey for the dataHash.
     @returns {SC.Record} Returns a record instance.
   */
-  materializeRecord: function(storeKey) {
+  materializeRecord: function (storeKey) {
     var records = this.records, ret, recordType, attrs;
 
     // look up in cached records
@@ -1107,7 +1098,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {SC.Record} Returns the created record
   */
-  createRecord: function(recordType, dataHash, id) {
+  createRecord: function (recordType, dataHash, id) {
     var primaryKey, prototype, storeKey, status, K = SC.Record, changelog, defaultVal, ret;
 
     //initialize dataHash if necessary
@@ -1215,7 +1206,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} ids (optional) ids to assign to records
     @returns {Array} array of materialized record instances.
   */
-  createRecords: function(recordTypes, dataHashes, ids) {
+  createRecords: function (recordTypes, dataHashes, ids) {
     var ret = [], recordType, id, isArray, len = dataHashes.length, idx ;
     isArray = SC.typeOf(recordTypes) === SC.T_ARRAY;
     if (!isArray) recordType = recordTypes;
@@ -1239,7 +1230,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey (optional) if passed, ignores recordType and id
     @returns {SC.Store} receiver
   */
-  unloadRecord: function(recordType, id, storeKey, newStatus) {
+  unloadRecord: function (recordType, id, storeKey, newStatus) {
     if (storeKey === undefined) storeKey = recordType.storeKeyFor(id);
     var status = this.readStatus(storeKey), K = SC.Record;
     newStatus = newStatus || K.EMPTY;
@@ -1260,7 +1251,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     // Handle all the child Records
     var that = this;
-    this._propagateToChildren(storeKey, function(storeKey){
+    this._propagateToChildren(storeKey, function (storeKey) {
       that.unloadRecord(null, null, storeKey, newStatus);
     });
 
@@ -1287,7 +1278,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} storeKeys (optional) store keys to unload
     @returns {SC.Store} receiver
   */
-  unloadRecords: function(recordTypes, ids, storeKeys, newStatus) {
+  unloadRecords: function (recordTypes, ids, storeKeys, newStatus) {
     var len, isArray, idx, id, recordType, storeKey;
 
     if (storeKeys === undefined) {
@@ -1330,7 +1321,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey (optional) if passed, ignores recordType and id
     @returns {SC.Store} receiver
   */
-  destroyRecord: function(recordType, id, storeKey) {
+  destroyRecord: function (recordType, id, storeKey) {
     if (storeKey === undefined) storeKey = recordType.storeKeyFor(id);
     var status = this.readStatus(storeKey), changelog, K = SC.Record;
 
@@ -1346,9 +1337,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     } else if (status & K.BUSY) {
       throw K.BUSY_ERROR ;
 
-    // if new status, destroy but leave in clean state
+    // if new status, destroy in clean state
     } else if (status === K.READY_NEW) {
       status = K.DESTROYED_CLEAN ;
+      this.removeDataHash(storeKey, status) ;
 
     // otherwise, destroy in dirty state
     } else status = K.DESTROYED_DIRTY ;
@@ -1370,7 +1362,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
 
     var that = this;
-    this._propagateToChildren(storeKey, function(storeKey){
+    this._propagateToChildren(storeKey, function (storeKey){
       that.destroyRecord(null, null, storeKey);
     });
 
@@ -1397,7 +1389,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} storeKeys (optional) store keys to destroy
     @returns {SC.Store} receiver
   */
-  destroyRecords: function(recordTypes, ids, storeKeys) {
+  destroyRecords: function (recordTypes, ids, storeKeys) {
     var len, isArray, idx, id, recordType, storeKey;
     if(storeKeys===undefined){
       len = ids.length;
@@ -1421,43 +1413,46 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     register a Child Record to the parent
   */
-  registerChildToParent: function(parentStoreKey, childStoreKey, path){
-    var prs, crs, oldPk, oldChildren, pkRef;
+  registerChildToParent: function (parentStoreKey, childStoreKey, path) {
+    var parentRecords, childRecords, oldPk, oldChildren, pkRef;
+
     // Check the child to see if it has a parent
-    crs = this.childRecords || {};
-    prs = this.parentRecords || {};
+    childRecords = this.childRecords || {};
+    parentRecords = this.parentRecords || {};
+
     // first rid of the old parent
-    oldPk = crs[childStoreKey];
-    if (oldPk){
-      oldChildren = prs[oldPk];
+    oldPk = childRecords[childStoreKey];
+    if (oldPk) {
+      oldChildren = parentRecords[oldPk];
       delete oldChildren[childStoreKey];
       // this.recordDidChange(null, null, oldPk, key);
     }
-    pkRef = prs[parentStoreKey] || {};
+    pkRef = parentRecords[parentStoreKey] || {};
     pkRef[childStoreKey] = path || YES;
-    prs[parentStoreKey] = pkRef;
-    crs[childStoreKey] = parentStoreKey;
+    parentRecords[parentStoreKey] = pkRef;
+    childRecords[childStoreKey] = parentStoreKey;
+
     // sync the status of the child
     this.writeStatus(childStoreKey, this.statuses[parentStoreKey]);
-    this.childRecords = crs;
-    this.parentRecords = prs;
+    this.childRecords = childRecords;
+    this.parentRecords = parentRecords;
   },
 
   /**
     Unregister the Child Record from its Parent.  This will cause the Child
     Record to be removed from the store.
   */
-  unregisterChildFromParent: function(childStoreKey) {
-    var crs, oldPk;
+  unregisterChildFromParent: function (childStoreKey) {
+    var childRecords, oldPk;
 
     // Check the child to see if it has a parent
-    crs = this.childRecords;
+    childRecords = this.childRecords;
 
     // Remove the parent's connection to the child.  This doesn't remove the
     // parent store key from the cache of parent store keys if the parent
     // no longer has any other registered children, because the amount of effort
     // to determine that would not be worth the miniscule memory savings.
-    oldPk = crs[childStoreKey];
+    oldPk = childRecords[childStoreKey];
     if (oldPk) {
       delete this.parentRecords[oldPk][childStoreKey];
     }
@@ -1468,13 +1463,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // 3. from the cache of child record store keys
     this.removeDataHash(childStoreKey);
     delete this.records[childStoreKey];
-    delete crs[childStoreKey];
+    delete childRecords[childStoreKey];
   },
 
   /**
     materialize the parent when passing in a store key for the child
   */
-  materializeParentRecord: function(childStoreKey){
+  materializeParentRecord: function (childStoreKey){
     var pk, crs;
     if (SC.none(childStoreKey)) return null;
     crs = this.childRecords;
@@ -1489,7 +1484,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
 		@param {Number} storeKey The store key of the parent
   */
-  parentStoreKeyExists: function(storeKey){
+  parentStoreKeyExists: function (storeKey){
     if (SC.none(storeKey)) return ;
     var crs = this.childRecords || {};
     return crs[storeKey];
@@ -1498,7 +1493,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     function that propagates a function call to all children
   */
-  _propagateToChildren: function(storeKey, func){
+  _propagateToChildren: function (storeKey, func) {
     // Handle all the child Records
     if ( SC.none(this.parentRecords) ) return;
     var children = this.parentRecords[storeKey] || {};
@@ -1522,7 +1517,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Boolean} if the change is to statusOnly (optional)
     @returns {SC.Store} receiver
   */
-  recordDidChange: function(recordType, id, storeKey, key, statusOnly) {
+  recordDidChange: function (recordType, id, storeKey, key, statusOnly) {
     if (storeKey === undefined) storeKey = recordType.storeKeyFor(id);
     var status = this.readStatus(storeKey), changelog, K = SC.Record;
 
@@ -1579,7 +1574,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} storeKeys (optional) store keys to destroy
     @returns {SC.Store} receiver
   */
-  recordsDidChange: function(recordTypes, ids, storeKeys) {
+  recordsDidChange: function (recordTypes, ids, storeKeys) {
      var len, isArray, idx, id, recordType, storeKey;
       if(storeKeys===undefined){
         len = ids.length;
@@ -1619,7 +1614,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Function|Array} callback function or array of functions
     @returns {Array} storeKeys to be retrieved
   */
-  retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh, callbacks) {
+  retrieveRecords: function (recordTypes, ids, storeKeys, isRefresh, callbacks) {
 
     var source  = this._getDataSource(),
         isArray = SC.typeOf(recordTypes) === SC.T_ARRAY,
@@ -1711,7 +1706,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @private
     stores the callbacks for the storeKeys that are inflight
   **/
-  _setCallbackForStoreKey: function(storeKey, callback, hasCallbackArray, storeKeys){
+  _setCallbackForStoreKey: function (storeKey, callback, hasCallbackArray, storeKeys){
     var queue = this._callback_queue;
     if(hasCallbackArray) queue[storeKey] = {callback: callback, otherKeys: storeKeys};
     else queue[storeKey] = callback;
@@ -1721,7 +1716,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     retreives and calls callback for `storkey` if exists
     also handles if a single callback is need for one key
   **/
-  _retreiveCallbackForStoreKey: function(storeKey){
+  _retreiveCallbackForStoreKey: function (storeKey){
     var queue = this._callback_queue,
         callback = queue[storeKey],
         allFinished, keys;
@@ -1733,13 +1728,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       else if(SC.typeOf(callback) == SC.T_HASH){
         callback.completed = YES;
         keys = callback.storeKeys;
-        keys.forEach(function(key){
+        keys.forEach(function (key){
           if(!queue[key].completed) allFinished = YES;
         });
         if(allFinished){
           callback.callback.call(); // args?
           //cleanup
-          keys.forEach(function(key){
+          keys.forEach(function (key){
             delete queue[key];
           });
         }
@@ -1752,7 +1747,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @private
 
   */
-  _cancelCallback: function(storeKey){
+  _cancelCallback: function (storeKey){
     var queue = this._callback_queue;
     if(queue[storeKey]){
       delete queue[storeKey];
@@ -1778,7 +1773,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Function} callback (optional)
     @returns {Number} storeKey that was retrieved
   */
-  retrieveRecord: function(recordType, id, storeKey, isRefresh, callback) {
+  retrieveRecord: function (recordType, id, storeKey, isRefresh, callback) {
     var array = this._TMP_RETRIEVE_ARRAY,
         ret;
 
@@ -1807,7 +1802,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Function} callback (optional) when refresh completes
     @returns {Boolean} YES if the retrieval was a success.
   */
-  refreshRecord: function(recordType, id, storeKey, callback) {
+  refreshRecord: function (recordType, id, storeKey, callback) {
     return !!this.retrieveRecord(recordType, id, storeKey, YES, callback);
   },
 
@@ -1822,7 +1817,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Function} callback (optional) when refresh completes
     @returns {Boolean} YES if the retrieval was a success.
   */
-  refreshRecords: function(recordTypes, ids, storeKeys, callback) {
+  refreshRecords: function (recordTypes, ids, storeKeys, callback) {
     var ret = this.retrieveRecords(recordTypes, ids, storeKeys, YES, callback);
     return ret && ret.length>0;
   },
@@ -1844,7 +1839,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {Boolean} if the action was succesful.
   */
-  commitRecords: function(recordTypes, ids, storeKeys, params, callbacks) {
+  commitRecords: function (recordTypes, ids, storeKeys, params, callbacks) {
     var source    = this._getDataSource(),
         isArray   = SC.typeOf(recordTypes) === SC.T_ARRAY,
         hasCallbackArray = SC.typeOf(callbacks) === SC.T_ARRAY,
@@ -1939,7 +1934,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Function|Array} callback function or array of functions
     @returns {Boolean} if the action was successful.
   */
-  commitRecord: function(recordType, id, storeKey, params, callback) {
+  commitRecord: function (recordType, id, storeKey, params, callback) {
     var array = this._TMP_RETRIEVE_ARRAY,
         ret ;
     if (id === undefined && storeKey === undefined ) return NO;
@@ -1967,7 +1962,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} storeKeys (optional) store keys to destroy
     @returns {SC.Store} the store.
   */
-  cancelRecords: function(recordTypes, ids, storeKeys) {
+  cancelRecords: function (recordTypes, ids, storeKeys) {
     var source  = this._getDataSource(),
         isArray = SC.typeOf(recordTypes) === SC.T_ARRAY,
         K       = SC.Record,
@@ -2012,7 +2007,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} storeKeys (optional) store keys to destroy
     @returns {SC.Store} the store.
   */
-  cancelRecord: function(recordType, id, storeKey) {
+  cancelRecord: function (recordType, id, storeKey) {
     var array = this._TMP_RETRIEVE_ARRAY,
         ret ;
 
@@ -2055,7 +2050,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} id optional.  if not passed lookup on the hash
     @returns {String} store keys assigned to these id
   */
-  loadRecord: function(recordType, dataHash, id) {
+  loadRecord: function (recordType, dataHash, id) {
     var K       = SC.Record,
         ret, primaryKey, storeKey;
 
@@ -2101,7 +2096,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Array} ids optional array of ids.  if not passed lookup on hashes
     @returns {Array} store keys assigned to these ids
   */
-  loadRecords: function(recordTypes, dataHashes, ids) {
+  loadRecords: function (recordTypes, dataHashes, ids) {
     var isArray = SC.typeOf(recordTypes) === SC.T_ARRAY,
         len     = dataHashes.get('length'),
         ret     = [],
@@ -2137,7 +2132,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {SC.Error} SC.Error or undefined if no error associated with the record.
   */
-  readError: function(storeKey) {
+  readError: function (storeKey) {
     var errors = this.recordErrors ;
     return errors ? errors[storeKey] : undefined ;
   },
@@ -2149,7 +2144,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {SC.Error} SC.Error or undefined if no error associated with the query.
   */
-  readQueryError: function(query) {
+  readQueryError: function (query) {
     var errors = this.queryErrors ;
     return errors ? errors[SC.guidFor(query)] : undefined ;
   },
@@ -2166,7 +2161,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey record store key to cancel
     @returns {SC.Store} receiver
   */
-  dataSourceDidCancel: function(storeKey) {
+  dataSourceDidCancel: function (storeKey) {
     var status = this.readStatus(storeKey),
         K      = SC.Record;
 
@@ -2222,7 +2217,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Object} newId optional new id to replace the old one
     @returns {SC.Store} receiver
   */
-  dataSourceDidComplete: function(storeKey, dataHash, newId) {
+  dataSourceDidComplete: function (storeKey, dataHash, newId) {
     var status = this.readStatus(storeKey), K = SC.Record, statusOnly;
 
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
@@ -2261,7 +2256,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey record store key to cancel
     @returns {SC.Store} receiver
   */
-  dataSourceDidDestroy: function(storeKey) {
+  dataSourceDidDestroy: function (storeKey) {
     var status = this.readStatus(storeKey), K = SC.Record;
 
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
@@ -2294,7 +2289,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Error} error [optional] an SC.Error instance to associate with storeKey
     @returns {SC.Store} receiver
   */
-  dataSourceDidError: function(storeKey, error) {
+  dataSourceDidError: function (storeKey, error) {
     var status = this.readStatus(storeKey), errors = this.recordErrors, K = SC.Record;
 
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
@@ -2337,15 +2332,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey optional store key.
     @returns {Number|Boolean} storeKey if push was allowed, NO if not
   */
-  pushRetrieve: function(recordType, id, dataHash, storeKey) {
+  pushRetrieve: function (recordType, id, dataHash, storeKey) {
     var K = SC.Record, status;
 
-    if(storeKey===undefined) storeKey = recordType.storeKeyFor(id);
+    if (storeKey === undefined) storeKey = recordType.storeKeyFor(id);
     status = this.readStatus(storeKey);
-    if(status==K.EMPTY || status==K.ERROR || status==K.READY_CLEAN || status==K.DESTROYED_CLEAN) {
+    if (status == K.EMPTY || status == K.ERROR || status == K.READY_CLEAN || status == K.DESTROYED_CLEAN) {
 
       status = K.READY_CLEAN;
-      if(dataHash===undefined) this.writeStatus(storeKey, status) ;
+      if (dataHash === undefined) this.writeStatus(storeKey, status) ;
       else this.writeDataHash(storeKey, dataHash, status) ;
 
       if (id && this.idFor(storeKey) !== id) SC.Store.replaceIdFor(storeKey, id);
@@ -2366,7 +2361,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey optional store key.
     @returns {Number|Boolean} storeKey if push was allowed, NO if not
   */
-  pushDestroy: function(recordType, id, storeKey) {
+  pushDestroy: function (recordType, id, storeKey) {
     var K = SC.Record, status;
 
     if(storeKey===undefined){
@@ -2393,7 +2388,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey optional store key.
     @returns {Number|Boolean} storeKey if push was allowed, NO if not
   */
-  pushError: function(recordType, id, error, storeKey) {
+  pushError: function (recordType, id, error, storeKey) {
     var K = SC.Record, status, errors = this.recordErrors;
 
     if(storeKey===undefined) storeKey = recordType.storeKeyFor(id);
@@ -2425,53 +2420,81 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   // stores.  This is why these methods are implemented here instead of
   // directly on `Query` or `RecordArray` objects.
 
-  /**
-    Sets the passed array of storeKeys as the new data for the query.  You
-    can call this at any time for a remote query to update its content.  If
-    you want to use incremental loading, then pass a `SparseArray` object.
-
-    If the query you pass is not a REMOTE query, then this method will raise
-    an exception.  This will also implicitly transition the query state to
-    `SC.Record.READY`.
-
-    If you called `loadRecords()` before to load the actual content, you can
-    call this method with the return value of that method to actually set the
-    storeKeys on the result.
+  /** @deprecated
 
     @param {SC.Query} query the query you are loading.  must be remote.
     @param {SC.Array} storeKeys array of store keys
     @returns {SC.Store} receiver
   */
-  loadQueryResults: function(query, storeKeys) {
+  loadQueryResults: function (query, storeKeys) {
+    //@if(debug)
     if (query.get('location') === SC.Query.LOCAL) {
-      throw new Error("Cannot load query results for a local query");
+      throw new Error("Developer Error: You should not call loadQueryResults with a local query.  You need to use dataSourceDidFetchQuery instead.");
+    } else {
+      SC.warn("Developer Warning: loadQueryResults has been deprecated in favor of using dataSourceDidFetchQuery for both local and remote queries.  With remote queries, include the store keys when calling dataSourceDidFetchQuery.");
     }
+    //@endif
 
-    var recArray = this._findQuery(query, YES, NO);
-    if (recArray) recArray.set('storeKeys', storeKeys);
-    this.dataSourceDidFetchQuery(query);
-
-    return this ;
+    return this.dataSourceDidFetchQuery(query, storeKeys);
   },
 
   /**
     Called by your data source whenever you finish fetching the results of a
-    query.  This will put the query into a READY state if it was loading.
+    query.  This will put the record array for the query into a READY_CLEAN
+    state if it was previously loading or refreshing.
+
+    # Handling REMOTE queries
+
+    Note that if the query is REMOTE, then you must first load the results
+    into the store using `loadRecords()` and pass the ordered array of store
+    keys returned by `loadRecords()` into this method.
+
+    For example,
+
+        storeKeys = store.loadRecords(body.contacts);
+        store.dataSourceDidFetchQuery(query, storeKeys);
+
+    # Automatic updates
+
+    When you call this method the record array for the query will notify that
+    its contents have changed.  If the query is LOCAL then the contents will
+    update automatically to include any new records you added to the store.
+    If the query is REMOTE the contents will update to be the ordered records
+    for the passed in store keys.
 
-    Note that if the query is a REMOTE query, then you must separately load
-    the results into the query using `loadQueryResults()`.  If the query is
-    LOCAL, then the query will update automatically with any new records you
-    added to the store.
+    # Incremental loading for REMOTE queries
 
-    @param {SC.Query} query the query you fetched
+    If you want to support incremental loading, then pass an SC.SparseArray
+    object to hold the store keys.  This will allow you to load results
+    incrementally and provide more store keys as you do.
+
+    See the SC.SparseArray documentation for more information.
+
+    @param {SC.Query} query The query you fetched
+    @param {Array} [storeKeys] Ordered array of store keys as returned by a remote query.  NOTE: Required for remote queries.
     @returns {SC.Store} receiver
   */
-  dataSourceDidFetchQuery: function(query) {
-    return this._scstore_dataSourceDidFetchQuery(query, YES);
+  dataSourceDidFetchQuery: function (query, storeKeys) {
+    var recArray = this._findQuery(query, YES, NO);
+
+    // Set the ordered array of store keys for remote queries.
+    if (recArray && query.get('isRemote')) {
+      //@if(debug)
+      // Prevent confusion between local and remote requests.
+      if (SC.none(storeKeys)) {
+        throw new Error("Developer Error: The storeKeys argument in dataSourceDidFetchQuery is not optional for remote queries.  For a remote query you must include the ordered array of store keys for the loaded records (even if it's an empty array).");
+      }
+      //@endif
+
+      recArray.set('storeKeys', storeKeys);
+    }
+
+    return this._scstore_dataSourceDidFetchQuery(query);
   },
 
-  _scstore_dataSourceDidFetchQuery: function(query, createIfNeeded) {
-    var recArray     = this._findQuery(query, createIfNeeded, NO),
+  /** @private */
+  _scstore_dataSourceDidFetchQuery: function (query) {
+    var recArray     = this._findQuery(query, NO, NO),
         nestedStores = this.get('nestedStores'),
         loc          = nestedStores ? nestedStores.get('length') : 0;
 
@@ -2479,11 +2502,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if (recArray) recArray.storeDidFetchQuery(query);
 
     // notify nested stores
-    while(--loc >= 0) {
-      nestedStores[loc]._scstore_dataSourceDidFetchQuery(query, NO);
+    while (--loc >= 0) {
+      nestedStores[loc]._scstore_dataSourceDidFetchQuery(query);
     }
 
-    return this ;
+    return this;
   },
 
   /**
@@ -2494,11 +2517,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Query} query the query you cancelled
     @returns {SC.Store} receiver
   */
-  dataSourceDidCancelQuery: function(query) {
+  dataSourceDidCancelQuery: function (query) {
     return this._scstore_dataSourceDidCancelQuery(query, YES);
   },
 
-  _scstore_dataSourceDidCancelQuery: function(query, createIfNeeded) {
+  _scstore_dataSourceDidCancelQuery: function (query, createIfNeeded) {
     var recArray     = this._findQuery(query, createIfNeeded, NO),
         nestedStores = this.get('nestedStores'),
         loc          = nestedStores ? nestedStores.get('length') : 0;
@@ -2523,7 +2546,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Error} error [optional] an SC.Error instance to associate with query
     @returns {SC.Store} receiver
   */
-  dataSourceDidErrorQuery: function(query, error) {
+  dataSourceDidErrorQuery: function (query, error) {
     var errors = this.queryErrors;
 
     // Add the error to the array of query errors (for lookup later on if necessary).
@@ -2535,7 +2558,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return this._scstore_dataSourceDidErrorQuery(query, YES);
   },
 
-  _scstore_dataSourceDidErrorQuery: function(query, createIfNeeded) {
+  _scstore_dataSourceDidErrorQuery: function (query, createIfNeeded) {
     var recArray     = this._findQuery(query, createIfNeeded, NO),
         nestedStores = this.get('nestedStores'),
         loc          = nestedStores ? nestedStores.get('length') : 0;
@@ -2556,13 +2579,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   //
 
   /** @private */
-  init: function() {
+  init: function () {
     sc_super();
     this.reset();
   },
 
 
-  toString: function() {
+  toString: function () {
     // Include the name if the client has specified one.
     var name = this.get('name');
     if (!name) {
@@ -2585,7 +2608,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey the store key
     @returns {String} primaryKey value
   */
-  idFor: function(storeKey) {
+  idFor: function (storeKey) {
     return SC.Store.idFor(storeKey);
   },
 
@@ -2595,7 +2618,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey the store key
     @returns {SC.Record} record instance
   */
-  recordTypeFor: function(storeKey) {
+  recordTypeFor: function (storeKey) {
     return SC.Store.recordTypeFor(storeKey) ;
   },
 
@@ -2607,7 +2630,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} primaryKey the primary key
     @returns {Number} storeKey
   */
-  storeKeyFor: function(recordType, primaryKey) {
+  storeKeyFor: function (recordType, primaryKey) {
     return recordType.storeKeyFor(primaryKey);
   },
 
@@ -2620,7 +2643,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {String} primaryKey the primary key
     @returns {Number} a storeKey.
   */
-  storeKeyExists: function(recordType, primaryKey) {
+  storeKeyExists: function (recordType, primaryKey) {
     return recordType.storeKeyExists(primaryKey);
   },
 
@@ -2631,7 +2654,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Record} recordType
     @returns {Array} set of storeKeys
   */
-  storeKeysFor: function(recordType) {
+  storeKeysFor: function (recordType) {
     var ret = [],
         isEnum = recordType && recordType.isEnumerable,
         recType, storeKey, isMatch ;
@@ -2656,7 +2679,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     @returns {Array} set of storeKeys
   */
-  storeKeys: function() {
+  storeKeys: function () {
     var ret = [], storeKey;
     if(!this.statuses) return ret;
 
@@ -2676,7 +2699,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey
     @returns {String}
   */
-  statusString: function(storeKey) {
+  statusString: function (storeKey) {
     var rec = this.materializeRecord(storeKey);
     return rec.statusString();
   }
@@ -2774,7 +2797,7 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
 
     @type Number
   */
-  generateStoreKey: function() { return this.nextStoreKey++; },
+  generateStoreKey: function () { return this.nextStoreKey++; },
 
   /**
     Given a `storeKey` returns the `primaryKey` associated with the key.
@@ -2783,7 +2806,7 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
     @param {Number} storeKey the store key
     @returns {String} the primary key or null
   */
-  idFor: function(storeKey) {
+  idFor: function (storeKey) {
     return this.idsByStoreKey[storeKey] ;
   },
 
@@ -2794,7 +2817,7 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
     @param {Number} storeKey the store key
     @returns {SC.Query} query query object
   */
-  queryFor: function(storeKey) {
+  queryFor: function (storeKey) {
     return this.queriesByStoreKey[storeKey];
   },
 
@@ -2808,7 +2831,7 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
     @param {Number} storeKey the store key
     @returns {SC.Record} the record type
   */
-  recordTypeFor: function(storeKey) {
+  recordTypeFor: function (storeKey) {
     return this.recordTypesByStoreKey[storeKey];
   },
 
@@ -2821,7 +2844,7 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
     @param {String} newPrimaryKey the new primary key
     @returns {SC.Store} receiver
   */
-  replaceIdFor: function(storeKey, newId) {
+  replaceIdFor: function (storeKey, newId) {
     var oldId = this.idsByStoreKey[storeKey],
         recordType, storeKeys;
 
@@ -2854,98 +2877,9 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
     @param {SC.Record} recordType a record class
     @returns {SC.Store} receiver
   */
-  replaceRecordTypeFor: function(storeKey, recordType) {
+  replaceRecordTypeFor: function (storeKey, recordType) {
     this.recordTypesByStoreKey[storeKey] = recordType;
     return this ;
   }
 
 });
-
-
-/** @private */
-SC.Store.prototype.nextStoreIndex = 1;
-
-// ..........................................................
-// COMPATIBILITY
-//
-
-/** @private
-  global store is used only for deprecated compatibility methods.  Don't use
-  this in real code.
-*/
-SC.Store._getDefaultStore = function() {
-  var store = this._store;
-  if(!store) this._store = store = SC.Store.create();
-  return store;
-};
-
-/** @private
-
-  DEPRECATED
-
-  Included for compatibility, loads data hashes with the named `recordType`.
-  If no `recordType` is passed, expects to find a `recordType` property in the
-  data hashes.  `dataSource` and `isLoaded` params are ignored.
-
-  Calls `SC.Store#loadRecords()` on the default store. Do not use this method in
-  new code.
-
-  @param {Array} dataHashes data hashes to import
-  @param {Object} dataSource ignored
-  @param {SC.Record} recordType default record type
-  @param {Boolean} isLoaded ignored
-  @returns {Array} SC.Record instances for loaded data hashes
-*/
-SC.Store.updateRecords = function(dataHashes, dataSource, recordType, isLoaded) {
-  SC.Logger.warn("SC.Store.updateRecords() is deprecated.  Use loadRecords() instead");
-  var store = this._getDefaultStore(),
-      len   = dataHashes.length,
-      idx, ret;
-
-  // if no recordType was passed, build an array of recordTypes from hashes
-  if (!recordType) {
-    recordType = [];
-    for(idx=0;idx<len;idx++) recordType[idx] = dataHashes[idx].recordType;
-  }
-
-  // call new API.  Returns storeKeys
-  ret = store.loadRecords(recordType, dataHashes);
-
-  // map to SC.Record instances
-  len = ret.length;
-  for(idx=0;idx<len;idx++) ret[idx] = store.materializeRecord(ret[idx]);
-
-  return ret ;
-};
-
-/** @private
-
-  DEPRECATED
-
-  Finds a record with the passed guid on the default store.  This is included
-  only for compatibility.  You should use the newer `find()` method defined on
-  `SC.Store` instead.
-
-  @param {String} guid the guid
-  @param {SC.Record} recordType expected record type
-  @returns {SC.Record} found record
-*/
-SC.Store.find = function(guid, recordType) {
-  return this._getDefaultStore().find(recordType, guid);
-};
-
-/** @private
-
-  DEPRECATED
-
-  Passes through to `findAll` on default store.  This is included only for
-  compatibility.  You should use the newer `findAll()` defined on `SC.Store`
-  instead.
-
-  @param {Hash} filter search parameters
-  @param {SC.Record} recordType type of record to find
-  @returns {SC.RecordArray} result set
-*/
-SC.Store.findAll = function(filter, recordType) {
-  return this._getDefaultStore().findAll(filter, recordType);
-};