sproutcore 1.10.3.1 → 1.11.0.rc1

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

@@ -141,6 +141,51 @@ SC.NestedStore = SC.Store.extend(
     return this ;
   },
 
+  /**
+    Propagate this store's successful changes to its parent (if exists). At the end, it clears the
+    local, private status of the committed records therefore the method can be called several times
+    until the full transaction is successful or editing is abandoned
+
+    @param {Boolean} force if YES, does not check for conflicts first
+    @returns {SC.Store} receiver
+  */
+  commitSuccessfulChanges: function(force) {
+    if (this.get('hasChanges') && this.chainedChanges) {
+      var chainedChanges = this.chainedChanges,
+          dataHashes = this.dataHashes,
+          revisions  = this.revisions,
+          statuses   = this.statuses,
+          editables  = this.editables,
+          locks      = this.locks;
+      var successfulChanges = chainedChanges.filter( function(storeKey) {
+        var state = this.readStatus(storeKey);
+
+        return state===SC.Record.READY_CLEAN || state===SC.Record.DESTROYED_CLEAN;
+      }, this );
+      var pstore = this.get('parentStore');
+
+      pstore.commitChangesFromNestedStore(this, successfulChanges, force);
+
+      // remove the local status so these records that have been successfully committed on the server
+      // are no longer retrieved from this nested store but from the parent
+      successfulChanges.forEach(function(storeKey)
+      {
+        if (dataHashes && dataHashes.hasOwnProperty(storeKey))
+          delete dataHashes[storeKey];
+        if (revisions && revisions.hasOwnProperty(storeKey))
+          delete revisions[storeKey];
+        if (editables) delete editables[storeKey];
+        if (locks) delete locks[storeKey];
+        if (statuses && statuses.hasOwnProperty(storeKey))
+          delete statuses[storeKey];
+        chainedChanges.remove( storeKey );
+      }, this );
+
+    }
+
+    return this;
+  },
+
   /**
     Discard the changes made to this store and reset the store.
 
@@ -250,6 +295,11 @@ SC.NestedStore = SC.Store.extend(
     return parentStore ? parentStore.readQueryError(query) : null;
   },
 
+  /** @private - adapt for nested store */
+  chainAutonomousStore: function(attrs, newStoreClass) {
+    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+  },
+
   // ..........................................................
   // CORE ATTRIBUTE API
   //
@@ -482,7 +532,7 @@ SC.NestedStore = SC.Store.extend(
     an error if the record is dirty.  We'll otherwise avoid setting our status
     because that can disconnect us from upper and/or lower stores.
   */
-  retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh) {
+  retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh, callbacks) {
     var pstore = this.get('parentStore'), idx, storeKey, newStatus,
       len = (!storeKeys) ? ids.length : storeKeys.length,
       K = SC.Record, status;
@@ -536,27 +586,39 @@ SC.NestedStore = SC.Store.extend(
       }
     }
 
-    return pstore.retrieveRecords(recordTypes, ids, storeKeys, isRefresh);
+    return pstore.retrieveRecords(recordTypes, ids, storeKeys, isRefresh, callbacks);
   },
 
   /** @private - adapt for nested store */
   commitRecords: function(recordTypes, ids, storeKeys) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   commitRecord: function(recordType, id, storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   cancelRecords: function(recordTypes, ids, storeKeys) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   cancelRecord: function(recordType, id, storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   // ..........................................................
@@ -566,22 +628,34 @@ SC.NestedStore = SC.Store.extend(
 
   /** @private - adapt for nested store */
   dataSourceDidCancel: function(storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   dataSourceDidComplete: function(storeKey, dataHash, newId) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   dataSourceDidDestroy: function(storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   dataSourceDidError: function(storeKey, error) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   // ..........................................................
@@ -590,17 +664,26 @@ SC.NestedStore = SC.Store.extend(
 
   /** @private - adapt for nested store */
   pushRetrieve: function(recordType, id, dataHash, storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   pushDestroy: function(recordType, id, storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   },
 
   /** @private - adapt for nested store */
   pushError: function(recordType, id, error, storeKey) {
-    throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
+    if( this.get( "dataSource" ) )
+      return sc_super();
+    else
+      throw SC.Store.NESTED_STORE_UNSUPPORTED_ERROR;
   }
 
 }) ;

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

@@ -1186,10 +1186,20 @@ SC.Query = SC.Object.extend(SC.Copyable, SC.Freezable,
     if (l.length == 1) l = l[0];
     else error.push('string did not resolve to a single tree');
 
-    // error?
-    if (error.length > 0) return {error: error.join(',\n'), tree: l};
-    // everything fine - token list is now a tree and can be returned
-    else return l;
+    // If we have errors, return an error object.
+    if (error.length > 0) {
+      return {
+        error: error.join(',\n'),
+        tree: l,
+        // Conform to SC.Error.
+        isError: YES,
+        errorVal: function() { return this.error }
+      };
+    }
+    // Otherwise the token list is now a tree and can be returned.
+    else {
+      return l;
+    }
 
   },
 

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

@@ -10,42 +10,53 @@ sc_require('models/record');
 /**
   @class
 
-  A `RecordArray` wraps an array of `storeKeys` and, optionally, a `Query`
-  object. When you access the items of a `RecordArray`, it will automatically
-  convert the `storeKeys` into actual `SC.Record` objects that the rest of
-  your application can work with.
+  A `RecordArray` is a managed list of records (instances of your `SC.Record`
+  model classes).
 
-  Normally you do not create `RecordArray`s yourself.  Instead, a
-  `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.
+  Using RecordArrays
+  ---
+
+  Most often, RecordArrays contain the results of a `SC.Query`. You will generally not
+  create or modify record arrays yourselves, instead using the ones returned from calls
+  to `SC.Store#find` with either a record type or a query.
+
+  The membership of these query-backed record arrays is managed by the store, which
+  searches already-loaded records for local queries, and defers to your data source
+  for remote ones (see `SC.Query` documentation for more details). Since membership
+  in these record arrays is managed by the store, you will not generally add, remove
+  or rearrange them here (see `isEditable` below).
 
-  The information below about `RecordArray` internals is only intended for
-  those who need to override this class for some reason to do something
-  special.
+  Query-backed record arrays have a status property which reflects the store's progress
+  in fulfilling the query. See notes on `status` below.
+
+  (Note that instances of `SC.Query` are dumb descriptor objects which do not have a
+  status or results of their own. References to a query's status or results should be
+  understood to refer to those of its record array.)
 
   Internal Notes
   ---
 
-  Normally the `RecordArray` behavior is very simple.  Any array-like
-  operations will be translated into similar calls onto the underlying array
-  of `storeKeys`.  The underlying array can be a real array or it may be a
-  `SparseArray`, which is how you implement incremental loading.
+  This section is about `RecordArray` internals, and is only intended for those
+  who need to extend this class to do something special.
 
-  If the `RecordArray` is created with an `SC.Query` object as well (and it
-  almost always will have a `Query` object), then the `RecordArray` will also
-  consult the query for various delegate operations such as determining if
-  the record array should update automatically whenever records in the store
-  changes. It will also ask the `Query` to refresh the `storeKeys` whenever
-  records change in the store.
+  A `RecordArray` wraps an array of store keys, listed on its `storeKeys`
+  property. If you request a record from the array, e.g. via `objectAt`,
+  the `RecordArray` will convert the requested store key to a record
+  suitable for public use.
 
-  If the `SC.Query` object has complex matching rules, it might be
-  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 invokeNext to avoid too much computation
-  to happen in one runloop.
+  The list of store keys is usually managed by the store. If you are using
+  your `RecordArray` with a query, you should manage the results via the
+  store, and not try to directly manipulate the results via the array. If you
+  are managing the array's store keys yourself, then any array-like operation
+  will be translated into similar calls on the underlying `storeKeys` array.
+  This underlying array can be a real array, or, if you wish to implement
+  incremental loading, it may be a `SparseArray`.
 
+  If the record array is created with an `SC.Query` object (as is almost always the
+  case), then the record array will also consult the query for various delegate
+  operations such as determining if the record array should update automatically
+  whenever records in the store changes. It will also ask the query to refresh the
+  `storeKeys` list whenever records change in the store.
 
   @extends SC.Object
   @extends SC.Enumerable
@@ -66,7 +77,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
       query = this.get('query'),
       length = this.get('length');
 
-    return "%@({\n    query: %@,\n    storeKeys: [%@],\n    length: %@,\n    … }) %@".fmt(this.constructor.toString(), query, storeKeys, length, statusString);
+    return "%@({\n    query: %@,\n    storeKeys: [%@],\n    length: %@,\n    … }) %@".fmt(sc_super(), query, storeKeys, length, statusString);
   },
 
   /** @private */
@@ -97,7 +108,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   store: null,
 
   /**
-    The `Query` object this record array is based upon.  All record arrays
+    The `SC.Query` object this record array is based upon.  All record arrays
     **MUST** have an associated query in order to function correctly.  You
     cannot change this property once it has been set.
 
@@ -115,17 +126,35 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   */
   storeKeys: null,
 
+  /** @private The cache of previous store keys so that we can avoid unnecessary updates. */
+  _prevStoreKeys: null,
+
   /**
-    The current status for the record array.  Read from the underlying
-    store.
+    Reflects the store's current status in fulfilling the record array's query. Note
+    that this status is not directly related to the status of the array's records:
+
+    - The store returns local queries immediately, regardless of any first-time loading
+      they may trigger. (Note that by default, local queries are limited to 100ms
+      processing time per run loop, so very complex queries may take several run loops
+      to return to `READY` status. You can edit `SC.RecordArray.QUERY_MATCHING_THRESHOLD`
+      to change this duration.)
+    - The store fulfills remote queries by passing them to your data source's `fetch`
+      method. While fetching, it sets your array's status to `BUSY_LOADING` or
+      `BUSY_REFRESHING`. Once your data source has finished fetching (successfully or
+      otherwise), it will call the appropriate store methods (e.g. `dataSourceDidFetchQuery`
+      or `dataSourceDidErrorQuery`), which will update the query's array's status.
+
+    Thus, a record array may have a `READY` status while records are still loading (if
+    a local query triggers a call to `SC.DataSource#fetch`), and will not reflect the
+    `DIRTY` status of any of its records.
 
     @type Number
   */
   status: SC.Record.EMPTY,
 
   /**
-    The current editable state based on the query. If this record array is not
-    backed by an SC.Query, it is assumed to be editable.
+    The current editable state of the query. If this record array is not backed by a
+    query, it is assumed to be editable.
 
     @property
     @type Boolean
@@ -255,7 +284,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   },
 
   /**
-    Returns YES if the passed can be found in the record array.  This is
+    Returns YES if the passed record can be found in the record array.  This is
     provided for compatibility with SC.Set.
 
     @param {SC.Record} record
@@ -274,7 +303,10 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   */
   indexOf: function(record, startAt) {
     if (!SC.kindOf(record, SC.Record)) {
-      SC.Logger.warn("Using indexOf on %@ with an object that is not an SC.Record".fmt(record));
+      //@if(debug)
+      SC.Logger.warn("Developer Warning: Used SC.RecordArray's `indexOf` on %@, which is not an SC.Record. SC.RecordArray only works with records.".fmt(record));
+      SC.Logger.trace();
+      //@endif
       return -1; // only takes records
     }
 
@@ -295,7 +327,10 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   */
   lastIndexOf: function(record, startAt) {
     if (!SC.kindOf(record, SC.Record)) {
-      SC.Logger.warn("Using lastIndexOf on %@ with an object that is not an SC.Record".fmt(record));
+      //@if(debug)
+      SC.Logger.warn("Developer Warning: Using SC.RecordArray's `lastIndexOf` on %@, which is not an SC.Record. SC.RecordArray only works with records.".fmt(record));
+      SC.Logger.trace();
+      //@endif
       return -1; // only takes records
     }
 
@@ -363,11 +398,12 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   },
 
   /**
-    Will recompute the results based on the `SC.Query` attached to the record
-    array. Useful if your query is based on computed properties that might
-    have changed. Use `refresh()` instead of you want to trigger a fetch on
-    your data source since this will purely look at records already loaded
-    into the store.
+    Will recompute the results of the attached `SC.Query`. Useful if your query
+    is based on computed properties that might have changed.
+
+    This method is for local use only, operating only on records that have already
+    been loaded into your store. If you wish to re-fetch a remote query via your
+    data source, use `refresh()` instead.
 
     @returns {SC.RecordArray} receiver
   */
@@ -616,6 +652,11 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     // clear set of changed store keys
     if (changed) changed.clear();
 
+    // Clear the flushing flag.
+    // NOTE: Do this now, because any observers of storeKeys could trigger a call
+    // to flush (ex. by calling get('length') on the RecordArray).
+    this._insideFlush = NO;
+
     // only resort and update if we did change
     if (didChange) {
 
@@ -630,7 +671,6 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
       }
     }
 
-    this._insideFlush = NO;
     return this;
   },
 

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

@@ -56,7 +56,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     This type of store is not nested.
 
-		@default NO
+    @default NO
     @type Boolean
   */
   isNested: NO,
@@ -64,7 +64,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     This type of store is not nested.
 
-		@default NO
+    @default NO
     @type Boolean
   */
   commitRecordsAutomatically: NO,
@@ -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;
 
@@ -159,6 +159,51 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return ret ;
   },
 
+  /**
+    Creates an autonomous nested store that is connected to the data source.
+    Use this kind of nested store to ensure that all records that are committed into main store are first of all committed on the server.
+
+    ns = store.chainAutonomousStore();
+    ... perform changes into the nested store
+    ns.commitRecords( ...,callback );
+    or...
+    newRecord.commitRecord( ..., callback );
+
+    into the callback method:
+      A. If using a transaction model: "all or nothing" where all rows are handled into a single transaction
+
+         if the transaction is successful, commit the successful changes into the main store and destroy:
+           ns.commitSuccessfulChanges();
+           ns.destroy();
+
+        if not successful, handle the error, allow corrections if needed, etc.
+
+      B. If using a transaction model: "independent rows" where the edited rows are independent and committed separately into the backend database
+         When only some of them have been accepted by the server, the overall transaction is only partially
+         successful therefore the nested store will contain rows with different statuses.
+         In such case, into the callback method only the accepted rows should be pushed to the main store using commitSuccessfulChanges()
+
+           ns.commitSuccessfulChanges();
+           ...
+         if some of the rows were not accepted by the backend, allow corrections, attempt another commit, etc.:
+           ns.commitRecords( ...,callback );
+           ... the callback will be invoked again
+
+         Important note: In the case of such configuration, in order to preserve the consistency of the main store with
+         the backend database, it is recommended to systematically call commitSuccessfulChanges() when receiving the answer from the server.
+
+    @param {Hash} attrs optional attributes to set on new store
+    @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
+  */
+  chainAutonomousStore: function(attrs, newStoreClass) {
+    var newAttrs = attrs ? SC.clone( attrs ) : {};
+    var source  = this._getDataSource();
+
+    newAttrs.dataSource = source;
+    return this.chain( newAttrs, newStoreClass );
+  },
+
   /** @private
 
     Called by a nested store just before it is destroyed so that the parent
@@ -166,7 +211,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 +225,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 ;
   },
@@ -287,14 +332,14 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   // to use these methods.
 
   /**
-    Returns the current edit status of a storekey.  May be one of
+    Returns the current edit status of a store key.  May be one of
     `EDITABLE` or `LOCKED`.  Used mostly for unit testing.
 
     @param {Number} storeKey the store key
     @returns {Number} edit status
   */
-  storeKeyEditState: function (storeKey) {
-    var editables = this.editables, locks = this.locks;
+  storeKeyEditState: function(storeKey) {
+    var editables = this.editables;
     return (editables && editables[storeKey]) ? SC.Store.EDITABLE : SC.Store.LOCKED ;
   },
 
@@ -306,7 +351,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 +366,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 +391,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 +427,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;
@@ -393,15 +438,14 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if (!editables) editables = this.editables = [];
     editables[storeKey] = 1 ; // use number for dense array support
 
+    var processedPaths={};
     // Update the child record hashes in place.
     if (!SC.none(this.parentRecords) ) {
       var children = this.parentRecords[storeKey] || {},
         childHash;
 
       for (var key in children) {
-
         if (children.hasOwnProperty(key)) {
-
           if (hash) {
             var childPath = children[key];
             childPath = childPath.split('.');
@@ -411,7 +455,24 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
               childHash = hash[childPath[0]];
             }
 
-            this.writeDataHash(key, childHash, status);
+            if (!processedPaths[hash[childPath[0]]]){
+                // update data hash: required to push changes beyond the first nesting level
+                this.writeDataHash(key, childHash, status);
+            }
+
+            if (childPath.length > 1 && ! processedPaths[hash[childPath[0]]]) {
+              // save it so that we don't processed it over and over
+              processedPaths[hash[childPath[0]]]=true;
+
+              // force fetching of all children records by invoking the children_attribute wrapper code
+              // and then interating the list in an empty loop
+              // Ugly, but there's basically no other way to do it at the moment, other than
+              // leaving this broken as it was before
+              var that = this;
+              this.invokeLast(function() {
+                that.records[storeKey].get(childPath[0]).forEach(function (it) {});
+              });
+            }
           } else {
             this.writeDataHash(key, null, status);
           }
@@ -419,7 +480,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
     }
 
-    return this;
+    return this ;
   },
 
   /**
@@ -439,7 +500,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;
@@ -458,7 +519,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);
@@ -473,7 +534,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;
   },
 
@@ -487,10 +548,16 @@ 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) {
+    var that = this,
+        ret;
     // use writeDataHash for now to handle optimistic lock.  maximize code
     // reuse.
-    return this.writeDataHash(storeKey, null, newStatus);
+    ret = this.writeDataHash(storeKey, null, newStatus);
+    this._propagateToChildren(storeKey, function(storeKey) {
+      that.writeStatus(storeKey, newStatus);
+    });
+    return ret;
   },
 
   /**
@@ -505,8 +572,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
     // key value.
@@ -527,7 +593,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);
       });
     }
@@ -539,7 +605,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'),
@@ -620,7 +686,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,
@@ -629,9 +695,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         records              = changes.records,
         propertyForStoreKeys = changes.propertyForStoreKeys,
         recordTypes = SC.CoreSet.create(),
-        rec, recordType, statusOnly, idx, len, storeKey, keys;
+        rec, recordType, statusOnly, keys;
 
-    storeKeys.forEach(function (storeKey) {
+    storeKeys.forEach(function(storeKey) {
       if (records.contains(storeKey)) {
         statusOnly = hasDataChanges.contains(storeKey) ? NO : YES;
         rec = this.records[storeKey];
@@ -670,12 +736,15 @@ 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 = {} ;
     this.revisions  = {} ;
     this.statuses   = {} ;
+    this.records = {};
+    this.childRecords = {};
+    this.parentRecords = {};
 
     // also reset temporary objects and errors
     this.chainedChanges = this.locks = this.editables = null;
@@ -697,7 +766,7 @@ 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()) {
+      while ((ra = raList.pop())) {
         ra.destroy();
       }
       raList.clear();
@@ -723,7 +792,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);
 
@@ -787,7 +856,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++) {
@@ -869,7 +938,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) {
@@ -891,7 +960,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   /** @private */
-  _findQuery: function (query, createIfNeeded, refreshIfNew) {
+  _findQuery: function(query, createIfNeeded, refreshIfNew) {
 
     // lookup the local RecordArray for this query.
     var cache = this._scst_recordArraysByQuery,
@@ -917,7 +986,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   /** @private */
-  _findRecord: function (recordType, id) {
+  _findRecord: function(recordType, id) {
 
     var storeKey ;
 
@@ -931,7 +1000,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // as well.
     } else storeKey = id ? recordType.storeKeyFor(id) : null;
 
-    if (storeKey && (this.readStatus(storeKey) === SC.Record.EMPTY)) {
+    if (storeKey && (this.peekStatus(storeKey) === SC.Record.EMPTY)) {
       storeKey = this.retrieveRecord(recordType, id);
     }
 
@@ -953,7 +1022,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');
 
@@ -973,7 +1042,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,
@@ -996,11 +1065,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @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);
 
@@ -1021,7 +1090,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;
@@ -1041,7 +1110,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   /** @private */
-  _TMP_REC_ATTRS: {},
+  _CACHED_REC_ATTRS: {},
+
+  /** @private */
+  _CACHED_REC_INIT: function() {},
 
   /**
     Given a `storeKey`, return a materialized record.  You will not usually
@@ -1056,11 +1128,8 @@ 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,
-      //@if(debug)
-      updatingRecords = this.updatingRecords,
-      //@endif
       ret, recordType, attrs;
 
     // look up in cached records
@@ -1072,28 +1141,26 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     recordType = SC.Store.recordTypeFor(storeKey);
     if (!recordType) return null; // not recordType registered, nothing to do
 
-    attrs = this._TMP_REC_ATTRS ;
+    // Populate the attributes.
+    attrs = this._CACHED_REC_ATTRS ;
     attrs.storeKey = storeKey ;
     attrs.store    = this ;
 
-    //@if(debug)
-    // Add some developer support to prevent a tough to diagnose bug that if
-    // materializeRecord is called during the creation of a record, the store
-    // will inadvertently create a duplicate record instance not because the
-    // actual instance won't have been cached to this.records yet.
-    if (!this.updatingRecords) { updatingRecords = this.updatingRecords = {}; }
-    if (updatingRecords[storeKey]) {
-      throw new Error("Developer Error: The record of type, %@, with storeKey, %@, was materialized a second time before the first call had finished. This will result in two separate instances of the same object being created and should be fixed. A likely cause is using `.observes` code in the record class, which can cause the record to be retrieved somehow while it is still being created.".fmt(recordType, storeKey));
-    }
-
-    updatingRecords[storeKey] = storeKey;
-    //@endif
-
-    ret = records[storeKey] = recordType.create(attrs);
-
-    //@if(debug)
-    updatingRecords[storeKey] = null;
-    //@endif
+    // We do a little gymnastics here to prevent record initialization before we've
+    // received and cached a copy of the object. This is because if initialization
+    // triggers downstream effects which call materializeRecord for the same record,
+    // we won't have a copy of it cached yet, causing another copy to be created
+    // and resulting in a stack overflow at best and a really hard-to-diagnose bug
+    // involving two instances of the same record floating around at worst.
+
+    // Override _object_init to prevent premature initialization.
+    var _object_init = recordType.prototype._object_init;
+    recordType.prototype._object_init = this._CACHED_REC_INIT;
+    // Create the record (but don't init it).
+    ret = records[storeKey] = recordType.create();
+    // Repopulate the _object_init method and run initialization.
+    recordType.prototype._object_init = ret._object_init = _object_init;
+    ret._object_init([attrs]);
 
     return ret ;
   },
@@ -1141,7 +1208,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
@@ -1249,7 +1316,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;
@@ -1273,7 +1340,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;
@@ -1288,16 +1355,23 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // otherwise, destroy in dirty state
     } else status = newStatus ;
 
-    // remove the data hash, set new status
+    // remove the data hash, set the new status and remove the cached record.
     this.removeDataHash(storeKey, status);
     this.dataHashDidChange(storeKey);
+    delete this.records[storeKey];
 
-    // Handle all the child Records
+    // If this record is a parent record, unregister all of its child records.
     var that = this;
     this._propagateToChildren(storeKey, function (storeKey) {
-      that.unloadRecord(null, null, storeKey, newStatus);
+      that.unregisterChildFromParent(storeKey);
     });
 
+    // If this record is a parent record, its child records have been cleared so also clear the
+    // cached reference as well.
+    if (this.parentRecords) {
+      delete this.parentRecords[storeKey];
+    }
+
     return this ;
   },
 
@@ -1321,7 +1395,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) {
@@ -1364,7 +1438,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;
 
@@ -1396,7 +1470,8 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     changelog = this.changelog;
     if (!changelog) changelog = this.changelog = SC.Set.create();
 
-    ((status & K.DIRTY) ? changelog.add(storeKey) : changelog.remove(storeKey));
+    if (status & K.DIRTY) { changelog.add(storeKey); }
+    else { changelog.remove(storeKey); }
     this.changelog=changelog;
 
     // if commit records is enabled
@@ -1405,7 +1480,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);
     });
 
@@ -1432,7 +1507,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;
@@ -1456,7 +1531,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     register a Child Record to the parent
   */
-  registerChildToParent: function (parentStoreKey, childStoreKey, path) {
+  registerChildToParent: function(parentStoreKey, childStoreKey, path){
     var parentRecords, childRecords, oldPk, oldChildren, pkRef;
 
     // Check the child to see if it has a parent
@@ -1465,7 +1540,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     // first rid of the old parent
     oldPk = childRecords[childStoreKey];
-    if (oldPk) {
+    if (oldPk){
       oldChildren = parentRecords[oldPk];
       delete oldChildren[childStoreKey];
       // this.recordDidChange(null, null, oldPk, key);
@@ -1484,35 +1559,55 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     Unregister the Child Record from its Parent.  This will cause the Child
     Record to be removed from the store.
+
+    @param {Number} childStoreKey storeKey to unregister
   */
-  unregisterChildFromParent: function (childStoreKey) {
-    var childRecords, oldPk;
+  unregisterChildFromParent: function(childStoreKey) {
+    var childRecords, oldPk, storeKeys,
+        recordType = this.recordTypeFor(childStoreKey),
+        id = this.idFor(childStoreKey),
+        that = this;
 
     // Check the child to see if it has a parent
     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 = childRecords[childStoreKey];
-    if (oldPk) {
-      delete this.parentRecords[oldPk][childStoreKey];
-    }
-
     // Remove the child.
     // 1. from the cache of data hashes
     // 2. from the cache of record objects
     // 3. from the cache of child record store keys
     this.removeDataHash(childStoreKey);
-    delete this.records[childStoreKey];
-    delete childRecords[childStoreKey];
+    if (this.records) {
+      delete this.records[childStoreKey];
+    }
+
+    if (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 = childRecords[childStoreKey];
+      if (oldPk) {
+        delete this.parentRecords[oldPk][childStoreKey];
+      }
+
+      delete childRecords[childStoreKey];
+    }
+
+    // 4. from the cache of ids
+    // 5. from the cache of store keys
+    delete SC.Store.idsByStoreKey[childStoreKey];
+    storeKeys = recordType.storeKeysById();
+    delete storeKeys[id];
+
+    this._propagateToChildren(childStoreKey, function(storeKey) {
+      that.unregisterChildFromParent(storeKey);
+    });
   },
 
   /**
     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;
@@ -1525,9 +1620,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     function for retrieving a parent record key
 
-		@param {Number} storeKey The store key of the parent
+    @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];
@@ -1536,7 +1631,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] || {};
@@ -1560,7 +1655,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;
 
@@ -1577,7 +1672,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // otherwise, make new status READY_DIRTY unless new.
     // K.READY_CLEAN, K.READY_DIRTY, ignore K.READY_NEW
     } else {
-      if (status != K.READY_NEW) this.writeStatus(storeKey, K.READY_DIRTY);
+      if (status !== K.READY_NEW) this.writeStatus(storeKey, K.READY_DIRTY);
     }
 
     // record data hash change
@@ -1617,7 +1712,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;
@@ -1657,7 +1752,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,
@@ -1687,7 +1782,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       status = this.readStatus(storeKey);
 
       // K.EMPTY, K.ERROR, K.DESTROYED_CLEAN - initial retrieval
-      if ((status == K.EMPTY) || (status == K.ERROR) || (status == K.DESTROYED_CLEAN)) {
+      if ((status === K.EMPTY) || (status === K.ERROR) || (status === K.DESTROYED_CLEAN)) {
         this.writeStatus(storeKey, K.BUSY_LOADING);
         this.dataHashDidChange(storeKey, rev, YES);
         ret.push(storeKey);
@@ -1701,11 +1796,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
           ret.push(storeKey);
           this._setCallbackForStoreKey(storeKey, callback, hasCallbackArray, storeKeys);
         // K.BUSY_DESTROYING, K.BUSY_COMMITTING, K.BUSY_CREATING
-        } else if ((status == K.BUSY_DESTROYING) || (status == K.BUSY_CREATING) || (status == K.BUSY_COMMITTING)) {
+        } else if ((status === K.BUSY_DESTROYING) || (status === K.BUSY_CREATING) || (status === K.BUSY_COMMITTING)) {
           throw K.BUSY_ERROR ;
 
         // K.DESTROY_DIRTY, bad state...
-        } else if (status == K.DESTROYED_DIRTY) {
+        } else if (status === K.DESTROYED_DIRTY) {
           throw K.BAD_STATE_ERROR ;
 
         // ignore K.BUSY_LOADING, K.BUSY_REFRESH_CLEAN, K.BUSY_REFRESH_DIRTY
@@ -1713,7 +1808,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
     }
 
-    // now retrieve storekeys from dataSource.  if there is no dataSource,
+    // now retrieve storeKeys from dataSource.  if there is no dataSource,
     // then act as if we couldn't retrieve.
     ok = NO;
     if (source) ok = source.retrieveRecords.call(source, this, ret, ids);
@@ -1749,17 +1844,18 @@ 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;
   },
+
   /**
     @private
-    retreives and calls callback for `storkey` if exists
-    also handles if a single callback is need for one key
+    Retrieves and calls callback for `storeKey` if exists, also handles if a single callback is
+    needed for one key..
   **/
-  _retreiveCallbackForStoreKey: function (storeKey){
+  _retrieveCallbackForStoreKey: function(storeKey){
     var queue = this._callback_queue,
         callback = queue[storeKey],
         allFinished, keys;
@@ -1768,16 +1864,16 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         callback.call(); //args?
         delete queue[storeKey]; //cleanup
       }
-      else if(SC.typeOf(callback) == SC.T_HASH){
+      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];
           });
         }
@@ -1790,7 +1886,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];
@@ -1816,7 +1912,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;
 
@@ -1845,7 +1941,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);
   },
 
@@ -1860,7 +1956,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;
   },
@@ -1882,14 +1978,14 @@ 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,
         retCreate= [], retUpdate= [], retDestroy = [],
         rev       = SC.Store.generateStoreKey(),
         K         = SC.Record,
-        recordType, idx, storeKey, status, key, ret, len, callback;
+        recordType, idx, storeKey, status, ret, len, callback;
 
     // If no params are passed, look up storeKeys in the changelog property.
     // Remove any committed records from changelog property.
@@ -1917,26 +2013,26 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       // collect status and process
       status = this.readStatus(storeKey);
 
-      if (status == K.ERROR) {
+      if (status === K.ERROR) {
         throw K.NOT_FOUND_ERROR ;
       }
       else {
-        if(status==K.READY_NEW) {
+        if(status === K.READY_NEW) {
           this.writeStatus(storeKey, K.BUSY_CREATING);
           this.dataHashDidChange(storeKey, rev, YES);
           retCreate.push(storeKey);
           this._setCallbackForStoreKey(storeKey, callback, hasCallbackArray, storeKeys);
-        } else if (status==K.READY_DIRTY) {
+        } else if (status === K.READY_DIRTY) {
           this.writeStatus(storeKey, K.BUSY_COMMITTING);
           this.dataHashDidChange(storeKey, rev, YES);
           retUpdate.push(storeKey);
           this._setCallbackForStoreKey(storeKey, callback, hasCallbackArray, storeKeys);
-        } else if (status==K.DESTROYED_DIRTY) {
+        } else if (status === K.DESTROYED_DIRTY) {
           this.writeStatus(storeKey, K.BUSY_DESTROYING);
           this.dataHashDidChange(storeKey, rev, YES);
           retDestroy.push(storeKey);
           this._setCallbackForStoreKey(storeKey, callback, hasCallbackArray, storeKeys);
-        } else if (status==K.DESTROYED_CLEAN) {
+        } else if (status === K.DESTROYED_CLEAN) {
           this.dataHashDidChange(storeKey, rev, YES);
         }
         // ignore K.EMPTY, K.READY_CLEAN, K.BUSY_LOADING, K.BUSY_CREATING, K.BUSY_COMMITTING,
@@ -1944,7 +2040,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
     }
 
-    // now commit storekeys to dataSource
+    // now commit storeKeys to dataSource
     if (source && (len>0 || params)) {
       ret = source.commitRecords.call(source, this, retCreate, retUpdate, retDestroy, params);
     }
@@ -1977,7 +2073,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;
@@ -2005,7 +2101,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,
@@ -2027,7 +2123,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       if(storeKey) {
         status = this.readStatus(storeKey);
 
-        if ((status == K.EMPTY) || (status == K.ERROR)) {
+        if ((status === K.EMPTY) || (status === K.ERROR)) {
           throw K.NOT_FOUND_ERROR ;
         }
         ret.push(storeKey);
@@ -2050,7 +2146,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 ;
 
@@ -2093,7 +2189,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;
 
@@ -2139,12 +2235,11 @@ 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     = [],
-        K       = SC.Record,
-        recordType, id, primaryKey, idx, dataHash, storeKey;
+        recordType, id, primaryKey, idx, dataHash;
 
     // save lookup info
     if (!isArray) {
@@ -2175,7 +2270,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 ;
   },
@@ -2187,7 +2282,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 ;
   },
@@ -2204,7 +2299,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;
 
@@ -2260,7 +2355,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,
@@ -2270,7 +2365,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
 
     // otherwise, determine proper state transition
-    if(status===K.BUSY_DESTROYING) {
+    if(status === K.BUSY_DESTROYING) {
       throw K.BAD_STATE_ERROR ;
     } else status = K.READY_CLEAN ;
 
@@ -2283,11 +2378,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     // Force record to refresh its cached properties based on store key
     var record = this.materializeRecord(storeKey);
-    if (record != null) {
+    if (record !== null) {
       record.notifyPropertyChange('status');
     }
     //update callbacks
-    this._retreiveCallbackForStoreKey(storeKey);
+    this._retrieveCallbackForStoreKey(storeKey);
 
     return this ;
   },
@@ -2299,7 +2394,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,
@@ -2316,11 +2411,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     // Force record to refresh its cached properties based on store key
     var record = this.materializeRecord(storeKey);
-    if (record != null) {
+    if (record !== null) {
       record.notifyPropertyChange('status');
     }
 
-    this._retreiveCallbackForStoreKey(storeKey);
+    this._retrieveCallbackForStoreKey(storeKey);
 
     return this ;
   },
@@ -2332,7 +2427,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,
@@ -2353,11 +2448,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     // Force record to refresh its cached properties based on store key
     var record = this.materializeRecord(storeKey);
-    if (record != null) {
+    if (record) {
       record.notifyPropertyChange('status');
     }
 
-    this._retreiveCallbackForStoreKey(storeKey);
+    this._retrieveCallbackForStoreKey(storeKey);
     return this ;
   },
 
@@ -2375,15 +2470,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);
@@ -2404,14 +2499,14 @@ 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){
       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.DESTROYED_CLEAN;
       this.removeDataHash(storeKey, status) ;
       this.dataHashDidChange(storeKey);
@@ -2431,13 +2526,13 @@ 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);
     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.ERROR;
 
       // Add the error to the array of record errors (for lookup later on if necessary).
@@ -2469,7 +2564,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @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("Developer Error: You should not call loadQueryResults with a local query.  You need to use dataSourceDidFetchQuery instead.");
@@ -2545,11 +2640,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if (recArray) recArray.storeDidFetchQuery(query);
 
     // notify nested stores
-    while (--loc >= 0) {
+    while(--loc >= 0) {
       nestedStores[loc]._scstore_dataSourceDidFetchQuery(query);
     }
 
-    return this;
+    return this ;
   },
 
   /**
@@ -2560,11 +2655,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;
@@ -2589,7 +2684,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).
@@ -2601,7 +2696,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;
@@ -2622,13 +2717,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) {
@@ -2651,7 +2746,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);
   },
 
@@ -2661,7 +2756,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) ;
   },
 
@@ -2673,7 +2768,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);
   },
 
@@ -2686,7 +2781,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);
   },
 
@@ -2697,7 +2792,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 ;
@@ -2722,13 +2817,13 @@ 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;
 
     for(storeKey in this.statuses) {
       // if status is not empty
-      if(this.statuses[storeKey] != SC.Record.EMPTY) {
+      if(this.statuses[storeKey] !== SC.Record.EMPTY) {
         ret.push(parseInt(storeKey, 10));
       }
     }
@@ -2742,7 +2837,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();
   }
@@ -2840,7 +2935,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.
@@ -2849,7 +2944,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] ;
   },
 
@@ -2860,7 +2955,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];
   },
 
@@ -2874,7 +2969,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];
   },
 
@@ -2887,7 +2982,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;
 
@@ -2920,7 +3015,7 @@ 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 ;
   }