sproutcore 1.6.0.rc.2-x86-mingw32 → 1.6.0.1-x86-mingw32

data/lib/frameworks/sproutcore/frameworks/datastore/models/record_attribute.js

@@ -133,6 +133,27 @@ SC.RecordAttribute = SC.Object.extend(
     @default NO
   */
   aggregate: NO,
+
+
+  /**
+    Can only be used for toOne or toMany relationship attributes. If YES,
+    this flag will lazily create the related record that was pushed in
+    from the data source (via pushRetrieve) if the related record does
+    not exist yet.
+
+    Useful when you have a record used as a join table. Assumptions then
+    can be made that the record exists at all times (even if it doesn't).
+    For instance, if you have a contact that is a member of groups,
+    a group will be created automatically when a contact pushes a new
+    group.
+
+    Note that you will have to take care of destroying the created record
+    once all relationships are removed from it.
+
+    @property {Boolean}
+    @default NO
+   */
+  lazilyInstantiate: NO,
   
   // ..........................................................
   // HELPER PROPERTIES
@@ -149,7 +170,7 @@ SC.RecordAttribute = SC.Object.extend(
   */
   typeClass: function() {
     var ret = this.get('type');
-    if (SC.typeOf(ret) === SC.T_STRING) ret = SC.objectForPropertyPath(ret);
+    if (SC.typeOf(ret) === SC.T_STRING) ret = SC.requiredObjectForPropertyPath(ret);
     return ret ;
   }.property('type').cacheable(),
   

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

@@ -318,7 +318,7 @@ SC.NestedStore = SC.Store.extend(
       if (!editables) editables = this.editables = [];
       editables[storeKey] = 1 ; // mark as editable
       
-    } else this.dataHashes[storeKey] = this.dataHashes[storeKey];
+    } else this.dataHashes[storeKey] = pstore.dataHashes[storeKey];
     
     // also copy the status + revision
     this.statuses[storeKey] = this.statuses[storeKey];

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

@@ -11,14 +11,14 @@ sc_require('models/record');
   @class
 
 
-  The Store is where you can find all of your dataHashes. Stores can be 
-  chained for editing purposes and committed back one chain level at a time 
+  The Store is where you can find all of your dataHashes. Stores can be
+  chained for editing purposes and committed back one chain level at a time
   all the way back to a persistent data source.
-  
+
   Every application you create should generally have its own store objects.
   Once you create the store, you will rarely need to work with the store
-  directly except to retrieve records and collections.  
-  
+  directly except to retrieve records and collections.
+
   Internally, the store will keep track of changes to your json data hashes
   and manage syncing those changes with your data source.  A data source may
   be a server, local storage, or any other persistent code.
@@ -27,19 +27,19 @@ sc_require('models/record');
   @since SproutCore 1.0
 */
 SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
-  
+
   /**
     An (optional) name of the store, which can be useful during debugging,
     especially if you have multiple nested stores.
-    
+
     @type String
   */
   name: null,
 
   /**
-    An array of all the chained stores that current rely on the receiver 
+    An array of all the chained stores that current rely on the receiver
     store.
-    
+
     @type Array
   */
   nestedStores: null,
@@ -48,39 +48,39 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     The data source is the persistent storage that will provide data to the
     store and save changes.  You normally will set your data source when you
     first create your store in your application.
-    
+
     @type SC.DataSource
   */
   dataSource: null,
-  
+
   /**
     This type of store is not nested.
-    
+
 		@default NO
     @type Boolean
   */
   isNested: NO,
-  
+
   /**
     This type of store is not nested.
-    
+
 		@default NO
     @type Boolean
   */
   commitRecordsAutomatically: NO,
-  
+
   // ..........................................................
   // DATA SOURCE SUPPORT
-  // 
-  
+  //
+
   /**
     Convenience method.  Sets the current data source to the passed property.
     This will also set the store property on the dataSource to the receiver.
-    
+
     If you are using this from the `core.js` method of your app, you may need to
     just pass a string naming your data source class.  If this is the case,
     then your data source will be instantiated the first time it is requested.
-    
+
     @param {SC.DataSource|String} dataSource the data source
     @returns {SC.Store} receiver
   */
@@ -88,48 +88,48 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.set('dataSource', dataSource);
     return this ;
   },
-  
+
   // lazily convert data source to real object
   _getDataSource: function() {
     var ret = this.get('dataSource');
     if (typeof ret === SC.T_STRING) {
-      ret = SC.objectForPropertyPath(ret);
-      if (ret && ret.isClass) ret = ret.create();
-      if (ret) this.set('dataSource', ret);
+      ret = SC.requiredObjectForPropertyPath(ret);
+      if (ret.isClass) ret = ret.create();
+      this.set('dataSource', ret);
     }
     return ret;
   },
-  
+
   /**
-    Convenience method.  Creates a `CascadeDataSource` with the passed 
-    data source arguments and sets the `CascadeDataSource` as the data source 
+    Convenience method.  Creates a `CascadeDataSource` with the passed
+    data source arguments and sets the `CascadeDataSource` as the data source
     for the receiver.
-    
+
     @param {SC.DataSource...} dataSource one or more data source arguments
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   cascade: function(dataSource) {
     var dataSources = SC.A(arguments) ;
     dataSource = SC.CascadeDataSource.create({
-      dataSources: dataSources 
+      dataSources: dataSources
     });
     return this.from(dataSource);
   },
-  
+
   // ..........................................................
   // STORE CHAINING
-  // 
-  
-  /**  
+  //
+
+  /**
     Returns a new nested store instance that can be used to buffer changes
-    until you are ready to commit them.  When you are ready to commit your 
+    until you are ready to commit them.  When you are ready to commit your
     changes, call `commitChanges()` or `destroyChanges()` and then `destroy()`
     when you are finished with the chained store altogether.
-    
+
         store = MyApp.store.chain();
         .. edit edit edit
         store.commitChanges().destroy();
-    
+
     @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
@@ -137,7 +137,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   chain: function(attrs, newStoreClass) {
     if (!attrs) attrs = {};
     attrs.parentStore = this;
-    
+
     if (newStoreClass) {
       // Ensure the passed-in class is a type of nested store.
       if (SC.typeOf(newStoreClass) !== 'class') throw new Error("%@ is not a valid class".fmt(newStoreClass));
@@ -146,24 +146,24 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     else {
       newStoreClass = SC.NestedStore;
     }
-    
+
     // Replicate parent records references
     attrs.childRecords = this.childRecords ? SC.clone(this.childRecords) : {};
     attrs.parentRecords = this.parentRecords ? SC.clone(this.parentRecords) : {};
-    
+
     var ret    = newStoreClass.create(attrs),
         nested = this.nestedStores;
-        
+
     if (!nested) nested = this.nestedStores = [];
     nested.push(ret);
     return ret ;
   },
-  
+
   /** @private
-  
+
     Called by a nested store just before it is destroyed so that the parent
     can remove the store from its list of nested stores.
-    
+
     @returns {SC.Store} receiver
   */
   willDestroyNestedStore: function(nestedStore) {
@@ -176,7 +176,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     Used to determine if a nested store belongs directly or indirectly to the
     receiver.
-    
+
     @param {SC.Store} store store instance
     @returns {Boolean} YES if belongs
   */
@@ -186,110 +186,110 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   // ..........................................................
-  // SHARED DATA STRUCTURES 
-  // 
-  
+  // SHARED DATA STRUCTURES
+  //
+
   /** @private
-    JSON data hashes indexed by store key.  
-    
+    JSON data hashes indexed by store key.
+
     *IMPORTANT: Property is not observable*
 
     Shared by a store and its child stores until you make edits to it.
-    
+
     @type Hash
   */
   dataHashes: null,
 
   /** @private
     The current status of a data hash indexed by store key.
-    
+
     *IMPORTANT: Property is not observable*
 
     Shared by a store and its child stores until you make edits to it.
-    
+
     @type Hash
   */
   statuses: null,
-    
+
   /** @private
-    This array contains the revisions for the attributes indexed by the 
-    storeKey.  
-    
+    This array contains the revisions for the attributes indexed by the
+    storeKey.
+
     *IMPORTANT: Property is not observable*
-    
-    Revisions are used to keep track of when an attribute hash has been 
-    changed. A store shares the revisions data with its parent until it 
+
+    Revisions are used to keep track of when an attribute hash has been
+    changed. A store shares the revisions data with its parent until it
     starts to make changes to it.
-    
+
     @type Hash
   */
   revisions: null,
 
   /**
-    Array indicates whether a data hash is possibly in use by an external 
+    Array indicates whether a data hash is possibly in use by an external
     record for editing.  If a data hash is editable then it may be modified
-    at any time and therefore chained stores may need to clone the 
+    at any time and therefore chained stores may need to clone the
     attributes before keeping a copy of them.
-  
-    Note that this is kept as an array because it will be stored as a dense 
+
+    Note that this is kept as an array because it will be stored as a dense
     array on some browsers, making it faster.
-    
+
     @type Array
   */
   editables: null,
-    
+
   /**
     A set of storeKeys that need to be committed back to the data source. If
     you call `commitRecords()` without passing any other parameters, the keys
     in this set will be committed instead.
-  
+
     @type SC.Set
   */
   changelog: null,
-  
+
   /**
     An array of `SC.Error` objects associated with individual records in the
     store (indexed by store keys).
-    
+
     Errors passed form the data source in the call to dataSourceDidError() are
     stored here.
-    
+
     @type Array
   */
   recordErrors: null,
-  
+
   /**
     A hash of `SC.Error` objects associated with queries (indexed by the GUID
     of the query).
-    
+
     Errors passed from the data source in the call to
     `dataSourceDidErrorQuery()` are stored here.
-    
+
     @type Hash
   */
   queryErrors: null,
-  
+
   /**
     A hash of child Records and there immediate parents
   */
   childRecords: null,
-  
+
   /**
     A hash of parent records with registered children
   */
   parentRecords: null,
-  
+
   // ..........................................................
   // CORE ATTRIBUTE API
-  // 
+  //
   // The methods in this layer work on data hashes in the store.  They do not
-  // perform any changes that can impact records.  Usually you will not need 
+  // perform any changes that can impact records.  Usually you will not need
   // to use these methods.
-  
+
   /**
     Returns the current edit status of a storekey.  May be one of
     `EDITABLE` or `LOCKED`.  Used mostly for unit testing.
-    
+
     @param {Number} storeKey the store key
     @returns {Number} edit status
   */
@@ -297,27 +297,27 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     var editables = this.editables, locks = this.locks;
     return (editables && editables[storeKey]) ? SC.Store.EDITABLE : SC.Store.LOCKED ;
   },
-   
-  /** 
+
+  /**
     Returns the data hash for the given `storeKey`.  This will also 'lock'
-    the hash so that further edits to the parent store will no 
+    the hash so that further edits to the parent store will no
     longer be reflected in this store until you reset.
-    
+
     @param {Number} storeKey key to retrieve
     @returns {Hash} data hash or null
   */
   readDataHash: function(storeKey) {
     return this.dataHashes[storeKey];
   },
-  
-  /** 
+
+  /**
     Returns the data hash for the `storeKey`, cloned so that you can edit
     the contents of the attributes if you like.  This will do the extra work
-    to make sure that you only clone the attributes one time.  
-    
-    If you use this method to modify data hash, be sure to call 
+    to make sure that you only clone the attributes one time.
+
+    If you use this method to modify data hash, be sure to call
     `dataHashDidChange()` when you make edits to record the change.
-    
+
     @param {Number} storeKey the store key to retrieve
     @returns {Hash} the attributes hash
   */
@@ -335,48 +335,48 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
     return ret;
   },
-  
+
   /**
-    Reads a property from the hash - cloning it if needed so you can modify 
+    Reads a property from the hash - cloning it if needed so you can modify
     it independently of any parent store.  This method is really only well
-    tested for use with toMany relationships.  Although it is public you 
+    tested for use with toMany relationships.  Although it is public you
     generally should not call it directly.
-    
-    @param {Number} storeKey storeKey of data hash 
+
+    @param {Number} storeKey storeKey of data hash
     @param {String} propertyName property to read
     @returns {Object} editable property value
   */
   readEditableProperty: function(storeKey, propertyName) {
-    var hash      = this.readEditableDataHash(storeKey), 
+    var hash      = this.readEditableDataHash(storeKey),
         editables = this.editables[storeKey], // get editable info...
         ret       = hash[propertyName];
-        
+
     // editables must be made into a hash so that we can keep track of which
     // properties have already been made editable
     if (editables === 1) editables = this.editables[storeKey] = {};
-    
+
     // clone if needed
     if (!editables[propertyName]) {
       ret = hash[propertyName];
       if (ret && ret.isCopyable) ret = hash[propertyName] = ret.copy(YES);
       editables[propertyName] = YES ;
     }
-    
+
     return ret ;
   },
-  
+
   /**
     Replaces the data hash for the `storeKey`.  This will lock the data hash
     and mark them as cloned.  This will also call `dataHashDidChange()` for
     you.
-    
-    Note that the hash you set here must be a different object from the 
+
+    Note that the hash you set here must be a different object from the
     original data hash.  Once you make a change here, you must also call
     `dataHashDidChange()` to register the changes.
 
     If the data hash does not yet exist in the store, this method will add it.
     Pass the optional status to edit the status as well.
-    
+
     @param {Number} storeKey the store key to write
     @param {Hash} hash the new hash
     @param {String} status the new hash status
@@ -387,53 +387,53 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // update dataHashes and optionally status.
     if (hash) this.dataHashes[storeKey] = hash;
     if (status) this.statuses[storeKey] = status ;
-    
+
     // also note that this hash is now editable
     var editables = this.editables;
     if (!editables) editables = this.editables = [];
     editables[storeKey] = 1 ; // use number for dense array support
-    
+
     var that = this;
     this._propagateToChildren(storeKey, function(storeKey){
       that.writeDataHash(storeKey, null, status);
     });
-    
+
     return this ;
   },
 
   /**
     Removes the data hash from the store.  This does not imply a deletion of
-    the record.  You could be simply unloading the record.  Either way, 
-    removing the dataHash will be synced back to the parent store but not to 
+    the record.  You could be simply unloading the record.  Either way,
+    removing the dataHash will be synced back to the parent store but not to
     the server.
-    
+
     Note that you can optionally pass a new status to go along with this. If
     you do not pass a status, it will change the status to `SC.RECORD_EMPTY`
     (assuming you just unloaded the record).  If you are deleting the record
     you may set it to `SC.Record.DESTROYED_CLEAN`.
-    
+
     Be sure to also call `dataHashDidChange()` to register this change.
-    
+
     @param {Number} storeKey
     @param {String} status optional new status
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   removeDataHash: function(storeKey, status) {
      // don't use delete -- that will allow parent dataHash to come through
-    this.dataHashes[storeKey] = null;  
+    this.dataHashes[storeKey] = null;
     this.statuses[storeKey] = status || SC.Record.EMPTY;
-    
+
     // hash is gone and therefore no longer editable
     var editables = this.editables;
     if (editables) editables[storeKey] = 0 ;
-    
-    return this ;    
+
+    return this ;
   },
-  
+
   /**
-    Reads the current status for a storeKey.  This will also lock the data 
+    Reads the current status for a storeKey.  This will also lock the data
     hash.  If no status is found, returns `SC.RECORD_EMPTY`.
-    
+
     @param {Number} storeKey the store key
     @returns {Number} status
   */
@@ -443,41 +443,41 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.readDataHash(storeKey);
     return this.statuses[storeKey] || SC.Record.EMPTY;
   },
-  
+
   /**
-    Reads the current status for the storeKey without actually locking the 
+    Reads the current status for the storeKey without actually locking the
     record.  Usually you won't need to use this method.  It is mostly used
     internally.
-    
+
     @param {Number} storeKey the store key
     @returns {Number} status
   */
   peekStatus: function(storeKey) {
-    return this.statuses[storeKey] || SC.Record.EMPTY;  
+    return this.statuses[storeKey] || SC.Record.EMPTY;
   },
-  
+
   /**
-    Writes the current status for a storeKey.  If the new status is 
-    `SC.Record.ERROR`, you may also pass an optional error object.  Otherwise 
+    Writes the current status for a storeKey.  If the new status is
+    `SC.Record.ERROR`, you may also pass an optional error object.  Otherwise
     this param is ignored.
-    
+
     @param {Number} storeKey the store key
     @param {String} newStatus the new status
     @param {SC.Error} error optional error object
     @returns {SC.Store} receiver
   */
   writeStatus: function(storeKey, newStatus) {
-    // use writeDataHash for now to handle optimistic lock.  maximize code 
+    // use writeDataHash for now to handle optimistic lock.  maximize code
     // reuse.
     return this.writeDataHash(storeKey, null, newStatus);
   },
-  
+
   /**
     Call this method whenever you modify some editable data hash to register
     with the Store that the attribute values have actually changed.  This will
-    do the book-keeping necessary to track the change across stores including 
+    do the book-keeping necessary to track the change across stores including
     managing locks.
-    
+
     @param {Number|Array} storeKeys one or more store keys that changed
     @param {Number} rev optional new revision number. normally leave null
     @param {Boolean} statusOnly (optional) YES if only status changed
@@ -485,13 +485,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Store} receiver
   */
   dataHashDidChange: function(storeKeys, rev, statusOnly, key) {
-    
+
     // update the revision for storeKey.  Use generateStoreKey() because that
-    // gaurantees a universally (to this store hierarchy anyway) unique 
+    // gaurantees a universally (to this store hierarchy anyway) unique
     // key value.
     if (!rev) rev = SC.Store.generateStoreKey();
     var isArray, len, idx, storeKey;
-    
+
     isArray = SC.typeOf(storeKeys) === SC.T_ARRAY;
     if (isArray) {
       len = storeKeys.length;
@@ -499,39 +499,39 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       len = 1;
       storeKey = storeKeys;
     }
-    
+
     var that = this;
     for(idx=0;idx<len;idx++) {
       if (isArray) storeKey = storeKeys[idx];
       this.revisions[storeKey] = rev;
       this._notifyRecordPropertyChange(storeKey, statusOnly, key);
-      
+
       this._propagateToChildren(storeKey, function(storeKey){
         that.dataHashDidChange(storeKey, null, statusOnly, key);
       });
     }
-    
+
     return this ;
   },
 
-  /** @private 
+  /** @private
     Will push all changes to a the recordPropertyChanges property
     and execute `flush()` once at the end of the runloop.
   */
   _notifyRecordPropertyChange: function(storeKey, statusOnly, key) {
-    
-    var records      = this.records, 
+
+    var records      = this.records,
         nestedStores = this.get('nestedStores'),
         K            = SC.Store,
         rec, editState, len, idx, store, status, keys;
-    
+
     // pass along to nested stores
     len = nestedStores ? nestedStores.length : 0 ;
     for(idx=0;idx<len;idx++) {
       store = nestedStores[idx];
       status = store.peekStatus(storeKey); // important: peek avoids read-lock
       editState = store.storeKeyEditState(storeKey);
-      
+
       // when store needs to propagate out changes in the parent store
       // to nested stores
       if (editState === K.INHERITED) {
@@ -543,29 +543,29 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         store.reset();
       }
     }
-    
+
     // store info in changes hash and schedule notification if needed.
     var changes = this.recordPropertyChanges;
     if (!changes) {
-      changes = this.recordPropertyChanges = 
+      changes = this.recordPropertyChanges =
         { storeKeys:      SC.CoreSet.create(),
           records:        SC.CoreSet.create(),
           hasDataChanges: SC.CoreSet.create(),
           propertyForStoreKeys: {} };
     }
-    
+
     changes.storeKeys.add(storeKey);
 
     if (records && (rec=records[storeKey])) {
       changes.records.push(storeKey);
-      
+
       // If there are changes other than just the status we need to record
       // that information so we do the right thing during the next flush.
       // Note that if we're called multiple times before flush and one call
       // has `statusOnly=true` and another has `statusOnly=false`, the flush
       // will (correctly) operate in `statusOnly=false` mode.
       if (!statusOnly) changes.hasDataChanges.push(storeKey);
-      
+
       // If this is a key specific change, make sure that only those
       // properties/keys are notified.  However, if a previous invocation of
       // `_notifyRecordPropertyChange` specified that all keys have changed, we
@@ -574,7 +574,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         if (!(keys = changes.propertyForStoreKeys[storeKey])) {
           keys = changes.propertyForStoreKeys[storeKey] = SC.CoreSet.create();
         }
-        
+
         // If it's '*' instead of a set, then that means there was a previous
         // invocation that said all keys have changed.
         if (keys !== '*') {
@@ -586,22 +586,22 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         changes.propertyForStoreKeys[storeKey] = '*';
       }
     }
-    
+
     this.invokeOnce(this.flush);
     return this;
   },
 
   /**
-    Delivers any pending changes to materialized records.  Normally this 
+    Delivers any pending changes to materialized records.  Normally this
     happens once, automatically, at the end of the RunLoop.  If you have
-    updated some records and need to update records immediately, however, 
+    updated some records and need to update records immediately, however,
     you may call this manually.
 
     @returns {SC.Store} receiver
   */
   flush: function() {
     if (!this.recordPropertyChanges) return this;
-    
+
     var changes              = this.recordPropertyChanges,
         storeKeys            = changes.storeKeys,
         hasDataChanges       = changes.hasDataChanges,
@@ -609,26 +609,26 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         propertyForStoreKeys = changes.propertyForStoreKeys,
         recordTypes = SC.CoreSet.create(),
         rec, recordType, statusOnly, idx, len, storeKey, keys;
-    
+
     storeKeys.forEach(function(storeKey) {
       if (records.contains(storeKey)) {
         statusOnly = hasDataChanges.contains(storeKey) ? NO : YES;
         rec = this.records[storeKey];
         keys = propertyForStoreKeys ? propertyForStoreKeys[storeKey] : null;
-        
+
         // Are we invalidating all keys?  If so, don't pass any to
         // storeDidChangeProperties.
         if (keys === '*') keys = null;
-        
+
         // remove it so we don't trigger this twice
         records.remove(storeKey);
-        
+
         if (rec) rec.storeDidChangeProperties(statusOnly, keys);
       }
-      
+
       recordType = SC.Store.recordTypeFor(storeKey);
       recordTypes.add(recordType);
-      
+
     }, this);
 
     if (storeKeys.get('length') > 0) this._notifyRecordArrays(storeKeys, recordTypes);
@@ -638,19 +638,19 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     records.clear();
     // Provide full reference to overwrite
     this.recordPropertyChanges.propertyForStoreKeys = {};
-    
+
     return this;
   },
-  
+
   /**
     Resets the store content.  This will clear all internal data for all
     records, resetting them to an EMPTY state.  You generally do not want
     to call this method yourself, though you may override it.
-    
+
     @returns {SC.Store} receiver
   */
   reset: function() {
-    
+
     // create a new empty data store
     this.dataHashes = {} ;
     this.revisions  = {} ;
@@ -662,6 +662,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.recordErrors = null;
     this.queryErrors = null;
 
+    var dataSource = this.get('dataSource');
+    if (dataSource && dataSource.reset) { dataSource.reset(); }
+
     var records = this.records, storeKey;
     if (records) {
       for(storeKey in records) {
@@ -669,21 +672,21 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         this._notifyRecordPropertyChange(parseInt(storeKey, 10), NO);
       }
     }
-    
+
     this.set('hasChanges', NO);
   },
-  
+
   /** @private
     Called by a nested store on a parent store to commit any changes from the
-    store.  This will copy any changed dataHashes as well as any persistant 
+    store.  This will copy any changed dataHashes as well as any persistant
     change logs.
-    
+
     If the parentStore detects a conflict with the optimistic locking, it will
-    raise an exception before it makes any changes.  If you pass the 
+    raise an exception before it makes any changes.  If you pass the
     force flag then this detection phase will be skipped and the changes will
     be applied even if another resource has modified the store in the mean
     time.
-  
+
     @param {SC.Store} nestedStore the child store
     @param {SC.Set} changes the set of changed store keys
     @param {Boolean} force
@@ -692,20 +695,20 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   commitChangesFromNestedStore: function(nestedStore, changes, force) {
     // first, check for optimistic locking problems
     if (!force) this._verifyLockRevisions(changes, nestedStore.locks);
-    
-    // OK, no locking issues.  So let's just copy them changes. 
+
+    // OK, no locking issues.  So let's just copy them changes.
     // get local reference to values.
-    var len = changes.length, i, storeKey, myDataHashes, myStatuses, 
-      myEditables, myRevisions, myParentRecords, myChildRecords, 
+    var len = changes.length, i, storeKey, myDataHashes, myStatuses,
+      myEditables, myRevisions, myParentRecords, myChildRecords,
       chDataHashes, chStatuses, chRevisions, chParentRecords, chChildRecords;
-    
+
     myRevisions     = this.revisions ;
     myDataHashes    = this.dataHashes;
     myStatuses      = this.statuses;
     myEditables     = this.editables ;
     myParentRecords = this.parentRecords ? this.parentRecords : this.parentRecords ={} ;
     myChildRecords  = this.childRecords ? this.childRecords : this.childRecords = {} ;
-    
+
     // setup some arrays if needed
     if (!myEditables) myEditables = this.editables = [] ;
     chDataHashes    = nestedStore.dataHashes;
@@ -713,7 +716,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     chStatuses      = nestedStore.statuses;
     chParentRecords = nestedStore.parentRecords || {};
     chChildRecords  = nestedStore.childRecords || {};
-    
+
     for(i=0;i<len;i++) {
       storeKey = changes[i];
 
@@ -723,32 +726,32 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       myRevisions[storeKey]     = chRevisions[storeKey];
       myParentRecords[storeKey] = chParentRecords[storeKey];
       myChildRecords[storeKey]  = chChildRecords[storeKey];
-      
+
       myEditables[storeKey] = 0 ; // always make dataHash no longer editable
-      
+
       this._notifyRecordPropertyChange(storeKey, NO);
     }
-    
+
     // add any records to the changelog for commit handling
     var myChangelog = this.changelog, chChangelog = nestedStore.changelog;
     if (chChangelog) {
       if (!myChangelog) myChangelog = this.changelog = SC.CoreSet.create();
       myChangelog.addEach(chChangelog);
-    }  
+    }
     this.changelog = myChangelog;
-    
+
     // immediately flush changes to notify records - nested stores will flush
     // later on.
     if (!this.get('parentStore')) this.flush();
-    
+
     return this ;
   },
 
   /** @private
-    Verifies that the passed lock revisions match the current revisions 
-    in the receiver store.  If the lock revisions do not match, then the 
+    Verifies that the passed lock revisions match the current revisions
+    in the receiver store.  If the lock revisions do not match, then the
     store is in a conflict and an exception will be raised.
-    
+
     @param {Array}  changes set of changes we are trying to apply
     @param {SC.Set} locks the locks to verify
     @returns {SC.Store} receiver
@@ -763,85 +766,85 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
         // if the save revision for the item does not match the current rev
         // the someone has changed the data hash in this store and we have
-        // a conflict. 
+        // a conflict.
         if (lock < rev) throw SC.Store.CHAIN_CONFLICT_ERROR;
-      }   
+      }
     }
     return this ;
   },
-  
+
   // ..........................................................
   // HIGH-LEVEL RECORD API
-  // 
-  
+  //
+
   /**
     Finds a single record instance with the specified `recordType` and id or
     an  array of records matching some query conditions.
-    
+
     Finding a Single Record
     ---
-    
+
     If you pass a single `recordType` and id, this method will return an
     actual record instance.  If the record has not been loaded into the store
     yet, this method will ask the data source to retrieve it.  If no data
     source indicates that it can retrieve the record, then this method will
     return `null`.
-    
+
     Note that if the record needs to be retrieved from the server, then the
-    record instance returned from this method will not have any data yet. 
+    record instance returned from this method will not have any data yet.
     Instead it will have a status of `SC.Record.READY_LOADING`.  You can
     monitor the status property to be notified when the record data is
     available for you to use it.
-    
+
     Find a Collection of Records
     ---
-    
-    If you pass only a record type or a query object, you can instead find 
+
+    If you pass only a record type or a query object, you can instead find
     all records matching a specified set of conditions.  When you call
     `find()` in this way, it will create a query if needed and pass it to the
     data source to fetch the results.
-    
+
     If this is the first time you have fetched the query, then the store will
-    automatically ask the data source to fetch any records related to it as 
+    automatically ask the data source to fetch any records related to it as
     well.  Otherwise you can refresh the query results at anytime by calling
     `refresh()` on the returned `RecordArray`.
 
-    You can detect whether a RecordArray is fetching from the server by 
+    You can detect whether a RecordArray is fetching from the server by
     checking its status.
-    
+
     Examples
     ---
-    
+
     Finding a single record:
-    
+
         MyApp.store.find(MyApp.Contact, "23"); // returns MyApp.Contact
-    
+
     Finding all records of a particular type:
-    
+
         MyApp.store.find(MyApp.Contact); // returns SC.RecordArray of contacts
-    
-    
+
+
     Finding all contacts with first name John:
-    
+
         var query = SC.Query.local(MyApp.Contact, "firstName = %@", "John");
         MyApp.store.find(query); // returns SC.RecordArray of contacts
-    
+
     Finding all contacts using a remote query:
-    
+
         var query = SC.Query.remote(MyApp.Contact);
         MyApp.store.find(query); // returns SC.RecordArray filled by server
-    
+
     @param {SC.Record|String} recordType the expected record type
     @param {String} id the id to load
     @returns {SC.Record} record instance or null
   */
   find: function(recordType, id) {
-    
+
     // if recordType is passed as string, find object
     if (SC.typeOf(recordType)===SC.T_STRING) {
       recordType = SC.objectForPropertyPath(recordType);
     }
-    
+
     // handle passing a query...
     if ((arguments.length === 1) && !(recordType && recordType.get && recordType.get('isRecord'))) {
       if (!recordType) throw new Error("SC.Store#find() must pass recordType or query");
@@ -849,7 +852,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         recordType = SC.Query.local(recordType);
       }
       return this._findQuery(recordType, YES, YES);
-      
+
     // handle finding a single record
     } else {
       return this._findRecord(recordType, id);
@@ -858,36 +861,35 @@ 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 
+    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 
+    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) {
 
     // lookup the local RecordArray for this query.
-    var cache = this._scst_recordArraysByQuery, 
+    var cache = this._scst_recordArraysByQuery,
         key   = SC.guidFor(query),
         ret, ra ;
     if (!cache) cache = this._scst_recordArraysByQuery = {};
     ret = cache[key];
-    
+
     // if a RecordArray was not found, then create one and also add it to the
     // list of record arrays to update.
     if (!ret && createIfNeeded) {
@@ -899,51 +901,51 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
       if (refreshIfNew) this.refreshQuery(query);
     }
-    
+
     this.flush();
     return ret ;
   },
-  
+
   _findRecord: function(recordType, id) {
 
-    var storeKey ; 
-    
-    // if a record instance is passed, simply use the storeKey.  This allows 
+    var storeKey ;
+
+    // if a record instance is passed, simply use the storeKey.  This allows
     // you to pass a record from a chained store to get the same record in the
     // current store.
     if (recordType && recordType.get && recordType.get('isRecord')) {
       storeKey = recordType.get('storeKey');
-      
-    // otherwise, lookup the storeKey for the passed id.  look in subclasses 
+
+    // otherwise, lookup the storeKey for the passed id.  look in subclasses
     // as well.
     } else storeKey = id ? recordType.storeKeyFor(id) : null;
-    
+
     if (storeKey && (this.readStatus(storeKey) === SC.Record.EMPTY)) {
       storeKey = this.retrieveRecord(recordType, id);
     }
-    
+
     // now we have the storeKey, materialize the record and return it.
     return storeKey ? this.materializeRecord(storeKey) : null ;
   },
 
   // ..........................................................
   // RECORD ARRAY OPERATIONS
-  // 
+  //
 
   /**
-    Called by the record array just before it is destroyed.  This will 
+    Called by the record array just before it is destroyed.  This will
     de-register it from receiving future notifications.
 
     You should never call this method yourself.  Instead call `destroy()` on
     the `RecordArray` directly.
-    
+
     @param {SC.RecordArray} recordArray the record array
     @returns {SC.Store} receiver
   */
   recordArrayWillDestroy: function(recordArray) {
     var cache = this._scst_recordArraysByQuery,
         set   = this.get('recordArrays');
-        
+
     if (cache) delete cache[SC.guidFor(recordArray.get('query'))];
     if (set) set.remove(recordArray);
     return this ;
@@ -956,7 +958,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     You should never call this method yourself.  Instead call `refresh()` on
     the `RecordArray` directly.
-    
+
     @param {SC.Query} query the record array query to refresh
     @returns {SC.Store} receiver
   */
@@ -964,21 +966,21 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if (!query) throw new Error("refreshQuery() requires a query");
 
     var cache    = this._scst_recordArraysByQuery,
-        recArray = cache ? cache[SC.guidFor(query)] : null, 
+        recArray = cache ? cache[SC.guidFor(query)] : null,
         source   = this._getDataSource();
-        
+
     if (source && source.fetch) {
       if (recArray) recArray.storeWillFetchQuery(query);
       source.fetch.call(source, this, query);
     }
-    
-    return this ;      
+
+    return this ;
   },
-  
-  /** @private 
+
+  /** @private
     Will ask all record arrays that have been returned from `findAll`
     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
@@ -990,29 +992,29 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     recordArrays.forEach(function(recArray) {
       if (recArray) recArray.storeDidChangeStoreKeys(storeKeys, recordTypes);
     }, this);
-    
+
     return this ;
   },
-  
-  
+
+
   // ..........................................................
   // LOW-LEVEL HELPERS
-  // 
-  
+  //
+
   /**
     Array of all records currently in the store with the specified
     type.  This method only reflects the actual records loaded into memory and
     therefore is not usually needed at runtime.  However you will often use
     this method for testing.
-    
+
     @param {SC.Record} recordType the record type
     @returns {SC.Array} array instance - usually SC.RecordArray
   */
   recordsFor: function(recordType) {
-    var storeKeys     = [], 
+    var storeKeys     = [],
         storeKeysById = recordType.storeKeysById(),
         id, storeKey, ret;
-    
+
     // collect all non-empty store keys
     for(id in storeKeysById) {
       storeKey = storeKeysById[id]; // get the storeKey
@@ -1020,23 +1022,23 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         storeKeys.push(storeKey);
       }
     }
-    
+
     if (storeKeys.length>0) {
       ret = SC.RecordArray.create({ store: this, storeKeys: storeKeys });
     } else ret = storeKeys; // empty array
     return ret ;
   },
-  
+
   _TMP_REC_ATTRS: {},
-  
-  /** 
+
+  /**
     Given a `storeKey`, return a materialized record.  You will not usually
     call this method yourself.  Instead it will used by other methods when
     you find records by id or perform other searches.
 
     If a `recordType` has been mapped to the storeKey, then a record instance
     will be returned even if the data hash has not been requested yet.
-    
+
     Each Store instance returns unique record instances for each storeKey.
 
     @param {Number} storeKey The storeKey for the dataHash.
@@ -1044,33 +1046,33 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   materializeRecord: function(storeKey) {
     var records = this.records, ret, recordType, attrs;
-    
+
     // look up in cached records
     if (!records) records = this.records = {}; // load cached records
     ret = records[storeKey];
     if (ret) return ret;
-    
+
     // not found -- OK, create one then.
     recordType = SC.Store.recordTypeFor(storeKey);
     if (!recordType) return null; // not recordType registered, nothing to do
-    
+
     attrs = this._TMP_REC_ATTRS ;
     attrs.storeKey = storeKey ;
     attrs.store    = this ;
     ret = records[storeKey] = recordType.create(attrs);
-    
+
     return ret ;
   },
 
   // ..........................................................
   // CORE RECORDS API
-  // 
-  // The methods in this section can be used to manipulate records without 
+  //
+  // The methods in this section can be used to manipulate records without
   // actually creating record instances.
-  
+
   /**
     Creates a new record instance with the passed `recordType` and `dataHash`.
-    You can also optionally specify an id or else it will be pulled from the 
+    You can also optionally specify an id or else it will be pulled from the
     data hash.
 
     Note that the record will not yet be saved back to the server.  To save
@@ -1085,8 +1087,8 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   createRecord: function(recordType, dataHash, id) {
     var primaryKey, storeKey, status, K = SC.Record, changelog, defaultVal,
         ret;
-    
-    // First, try to get an id.  If no id is passed, look it up in the 
+
+    // First, try to get an id.  If no id is passed, look it up in the
     // dataHash.
     if (!id && (primaryKey = recordType.prototype.primaryKey)) {
       id = dataHash[primaryKey];
@@ -1097,57 +1099,57 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         id = dataHash[primaryKey] = defaultVal();
       }
     }
-    
+
     // Next get the storeKey - base on id if available
     storeKey = id ? recordType.storeKeyFor(id) : SC.Store.generateStoreKey();
-    
+
     // now, check the state and do the right thing.
     status = this.readStatus(storeKey);
-    
+
     // check state
     // any busy or ready state or destroyed dirty state is not allowed
-    if ((status & K.BUSY)  || 
-        (status & K.READY) || 
-        (status === K.DESTROYED_DIRTY)) { 
+    if ((status & K.BUSY)  ||
+        (status & K.READY) ||
+        (status === K.DESTROYED_DIRTY)) {
       throw id ? K.RECORD_EXISTS_ERROR : K.BAD_STATE_ERROR;
-      
+
     // allow error or destroyed state only with id
     } else if (!id && (status===SC.DESTROYED_CLEAN || status===SC.ERROR)) {
       throw K.BAD_STATE_ERROR;
     }
-    
+
     // add dataHash and setup initial status -- also save recordType
     this.writeDataHash(storeKey, (dataHash ? dataHash : {}), K.READY_NEW);
-    
+
     SC.Store.replaceRecordTypeFor(storeKey, recordType);
     this.dataHashDidChange(storeKey);
-    
+
     // Record is now in a committable state -- add storeKey to changelog
     changelog = this.changelog;
     if (!changelog) changelog = SC.Set.create();
     changelog.add(storeKey);
     this.changelog = changelog;
-    
+
     // if commit records is enabled
     if(this.get('commitRecordsAutomatically')){
       this.invokeLast(this.commitRecords);
     }
-    
+
     // Finally return materialized record, after we propagate the status to
     // any aggregrate records.
     ret = this.materializeRecord(storeKey);
     if (ret) ret.propagateToAggregates();
     return ret;
-  },  
-  
+  },
+
   /**
-    Creates an array of new records.  You must pass an array of `dataHash`es 
+    Creates an array of new records.  You must pass an array of `dataHash`es
     plus a `recordType` and, optionally, an array of ids.  This will create an
     array of record instances with the same record type.
-    
+
     If you need to instead create a bunch of records with different data types
     you can instead pass an array of `recordType`s, one for each data hash.
-    
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} dataHashes array of data hashes
     @param {Array} ids (optional) ids to assign to records
@@ -1164,14 +1166,14 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
     return ret ;
   },
-  
-  
+
+
   /**
-    Unloads a record, removing the data hash from the store.  If you try to 
-    unload a record that is already destroyed then this method will have no effect.  
-    If you unload a record that does not exist or an error then an exception 
+    Unloads a record, removing the data hash from the store.  If you try to
+    unload a record that is already destroyed then this method will have no effect.
+    If you unload a record that does not exist or an error then an exception
     will be raised.
-    
+
     @param {SC.Record} recordType the recordType
     @param {String} id the record id
     @param {Number} storeKey (optional) if passed, ignores recordType and id
@@ -1184,35 +1186,35 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // handle status - ignore if destroying or destroyed
     if ((status === K.BUSY_DESTROYING) || (status & K.DESTROYED)) {
       return this; // nothing to do
-      
+
     // error out if empty
     } else if (status & K.BUSY) {
       throw K.BUSY_ERROR ;
-           
+
     // otherwise, destroy in dirty state
     } else status = newStatus ;
-    
+
     // remove the data hash, set new status
     this.removeDataHash(storeKey, status);
     this.dataHashDidChange(storeKey);
-    
+
     // Handle all the child Records
     var that = this;
     this._propagateToChildren(storeKey, function(storeKey){
       that.unloadRecord(null, null, storeKey, newStatus);
     });
-      
+
     return this ;
   },
-  
+
   /**
     Unloads a group of records.  If you have a set of record ids, unloading
-    them this way can be faster than retrieving each record and unloading 
+    them this way can be faster than retrieving each record and unloading
     it individually.
 
     You can pass either a single `recordType` or an array of `recordType`s. If
     you pass a single `recordType`, then the record type will be used for each
-    record.  If you pass an array, then each id must have a matching record 
+    record.  If you pass an array, then each id must have a matching record
     type in the array.
 
     You can optionally pass an array of `storeKey`s instead of the `recordType`
@@ -1259,10 +1261,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
   /**
     Destroys a record, removing the data hash from the store and adding the
-    record to the destroyed changelog.  If you try to destroy a record that is 
-    already destroyed then this method will have no effect.  If you destroy a 
+    record to the destroyed changelog.  If you try to destroy a record that is
+    already destroyed then this method will have no effect.  If you destroy a
     record that does not exist or an error then an exception will be raised.
-    
+
     @param {SC.Record} recordType the recordType
     @param {String} id the record id
     @param {Number} storeKey (optional) if passed, ignores recordType and id
@@ -1275,22 +1277,22 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // handle status - ignore if destroying or destroyed
     if ((status === K.BUSY_DESTROYING) || (status & K.DESTROYED)) {
       return this; // nothing to do
-      
+
     // error out if empty
     } else if (status === K.EMPTY) {
       throw K.NOT_FOUND_ERROR ;
-      
+
     // error out if busy
     } else if (status & K.BUSY) {
       throw K.BUSY_ERROR ;
-      
+
     // if new status, destroy but leave in clean state
     } else if (status === K.READY_NEW) {
       status = K.DESTROYED_CLEAN ;
-      
+
     // otherwise, destroy in dirty state
     } else status = K.DESTROYED_DIRTY ;
-    
+
     // remove the data hash, set new status
     this.writeStatus(storeKey, status);
     this.dataHashDidChange(storeKey);
@@ -1306,30 +1308,30 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if(this.get('commitRecordsAutomatically')){
       this.invokeLast(this.commitRecords);
     }
-    
+
     var that = this;
     this._propagateToChildren(storeKey, function(storeKey){
       that.destroyRecord(null, null, storeKey);
     });
-        
+
     return this ;
   },
-  
+
   /**
     Destroys a group of records.  If you have a set of record ids, destroying
-    them this way can be faster than retrieving each record and destroying 
+    them this way can be faster than retrieving each record and destroying
     it individually.
-    
+
     You can pass either a single `recordType` or an array of `recordType`s. If
     you pass a single `recordType`, then the record type will be used for each
-    record.  If you pass an array, then each id must have a matching record 
+    record.  If you pass an array, then each id must have a matching record
     type in the array.
 
     You can optionally pass an array of `storeKey`s instead of the `recordType`
     and ids.  In this case the first two parameters will be ignored.  This
     is usually only used by low-level internal methods.  You will not usually
     destroy records this way.
-    
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} ids ids to destroy
     @param {Array} storeKeys (optional) store keys to destroy
@@ -1355,7 +1357,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
     return this ;
   },
-  
+
   /**
     register a Child Record to the parent
   */
@@ -1380,7 +1382,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.childRecords = crs;
     this.parentRecords = prs;
   },
-  
+
   /**
     materialize the parent when passing in a store key for the child
   */
@@ -1390,10 +1392,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     crs = this.childRecords;
     pk = crs ? this.childRecords[childStoreKey] : null ;
     if (SC.none(pk)) return null;
-    
+
     return this.materializeRecord(pk);
   },
-  
+
   /**
     function for retrieving a parent record key
 
@@ -1404,7 +1406,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     var crs = this.childRecords || {};
     return crs[storeKey];
   },
-  
+
   /**
     function that propagates a function call to all children
   */
@@ -1417,12 +1419,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       if (children.hasOwnProperty(key)) func(key);
     }
   },
-  
+
   /**
     Notes that the data for the given record id has changed.  The record will
     be committed to the server the next time you commit the root store.  Only
     call this method on a record in a READY state of some type.
-    
+
     @param {SC.Record} recordType the recordType
     @param {String} id the record id
     @param {Number} storeKey (optional) if passed, ignores recordType and id
@@ -1433,55 +1435,55 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   recordDidChange: function(recordType, id, storeKey, key, statusOnly) {
     if (storeKey === undefined) storeKey = recordType.storeKeyFor(id);
     var status = this.readStatus(storeKey), changelog, K = SC.Record;
-    
+
     // BUSY_LOADING, BUSY_CREATING, BUSY_COMMITTING, BUSY_REFRESH_CLEAN
     // BUSY_REFRESH_DIRTY, BUSY_DESTROYING
     if (status & K.BUSY) {
       throw K.BUSY_ERROR ;
-      
+
     // if record is not in ready state, then it is not found.
     // ERROR, EMPTY, DESTROYED_CLEAN, DESTROYED_DIRTY
     } else if (!(status & K.READY)) {
       throw K.NOT_FOUND_ERROR ;
-      
+
     // 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);
     }
-    
+
     // record data hash change
     this.dataHashDidChange(storeKey, null, statusOnly, key);
-    
+
     // record in changelog
     changelog = this.changelog ;
     if (!changelog) changelog = this.changelog = SC.Set.create() ;
     changelog.add(storeKey);
     this.changelog = changelog;
-    
+
     // if commit records is enabled
     if(this.get('commitRecordsAutomatically')){
       this.invokeLast(this.commitRecords);
     }
-    
+
     return this ;
   },
 
   /**
     Mark a group of records as dirty.  The records will be committed to the
-    server the next time you commit changes on the root store.  If you have a 
-    set of record ids, marking them dirty this way can be faster than 
+    server the next time you commit changes on the root store.  If you have a
+    set of record ids, marking them dirty this way can be faster than
     retrieving each record and destroying it individually.
-    
+
     You can pass either a single `recordType` or an array of `recordType`s. If
     you pass a single `recordType`, then the record type will be used for each
-    record.  If you pass an array, then each id must have a matching record 
+    record.  If you pass an array, then each id must have a matching record
     type in the array.
 
     You can optionally pass an array of `storeKey`s instead of the `recordType`
     and ids.  In this case the first two parameters will be ignored.  This
-    is usually only used by low-level internal methods.  
-    
+    is usually only used by low-level internal methods.
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} ids ids to destroy
     @param {Array} storeKeys (optional) store keys to destroy
@@ -1506,20 +1508,20 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
           this.recordDidChange(undefined, undefined, storeKey);
         }
       }
-      return this ;  
+      return this ;
   },
 
   /**
-    Retrieves a set of records from the server.  If the records has 
-    already been loaded in the store, then this method will simply return.  
-    Otherwise if your store has a `dataSource`, this will call the 
-    `dataSource` to retrieve the record.  Generally you will not need to 
+    Retrieves a set of records from the server.  If the records has
+    already been loaded in the store, then this method will simply return.
+    Otherwise if your store has a `dataSource`, this will call the
+    `dataSource` to retrieve the record.  Generally you will not need to
     call this method yourself. Instead you can just use `find()`.
-    
-    This will not actually create a record instance but it will initiate a 
-    load of the record from the server.  You can subsequently get a record 
+
+    This will not actually create a record instance but it will initiate a
+    load of the record from the server.  You can subsequently get a record
     instance itself using `materializeRecord()`.
-    
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} ids ids to retrieve
     @param {Array} storeKeys (optional) store keys to retrieve
@@ -1528,7 +1530,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {Array} storeKeys to be retrieved
   */
   retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh, callbacks) {
-    
+
     var source  = this._getDataSource(),
         isArray = SC.typeOf(recordTypes) === SC.T_ARRAY,
         hasCallbackArray = SC.typeOf(callbacks) === SC.T_ARRAY,
@@ -1537,12 +1539,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         rev     = SC.Store.generateStoreKey(),
         K       = SC.Record,
         recordType, idx, storeKey, status, ok, callback;
-        
+
     if (!isArray) recordType = recordTypes;
-    
+
     // if no storeKeys were passed, map recordTypes + ids
     for(idx=0;idx<len;idx++) {
-      
+
       // collect store key
       if (storeKeys) {
         storeKey = storeKeys[idx];
@@ -1552,10 +1554,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
       //collect the callback
       callback = hasCallbackArray ? callbacks[idx] : callbacks;
-      
+
       // collect status and process
       status = this.readStatus(storeKey);
-      
+
       // K.EMPTY, K.ERROR, K.DESTROYED_CLEAN - initial retrieval
       if ((status == K.EMPTY) || (status == K.ERROR) || (status == K.DESTROYED_CLEAN)) {
         this.writeStatus(storeKey, K.BUSY_LOADING);
@@ -1577,19 +1579,19 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         // K.DESTROY_DIRTY, bad state...
         } else if (status == K.DESTROYED_DIRTY) {
           throw K.BAD_STATE_ERROR ;
-          
+
         // ignore K.BUSY_LOADING, K.BUSY_REFRESH_CLEAN, K.BUSY_REFRESH_DIRTY
         }
       }
     }
-    
+
     // 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);
 
     // if the data source could not retrieve or if there is no source, then
-    // simulate the data source calling dataSourceDidError on those we are 
+    // simulate the data source calling dataSourceDidError on those we are
     // loading for the first time or dataSourceDidComplete on refreshes.
     if (!ok) {
       len = ret.length;
@@ -1600,7 +1602,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         if (status === K.BUSY_LOADING) {
           this.writeStatus(storeKey, K.ERROR);
           this.dataHashDidChange(storeKey, rev, YES);
-          
+
         } else if (status & K.BUSY_REFRESH) {
           this.writeStatus(storeKey, K.READY | (status & 0x03));
           this.dataHashDidChange(storeKey, rev, YES);
@@ -1610,11 +1612,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
     return ret ;
   },
-  
+
   _TMP_RETRIEVE_ARRAY: [],
-  
+
   _callback_queue: {},
-  
+
   /**
     @private
     stores the callbacks for the storeKeys that are inflight
@@ -1651,14 +1653,14 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
             delete queue[key];
           });
         }
-        
+
       }
     }
   },
-  
+
   /*
     @private
-    
+
   */
   _cancelCallback: function(storeKey){
     var queue = this._callback_queue;
@@ -1666,17 +1668,17 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       delete queue[storeKey];
     }
   },
-  
-  
+
+
   /**
     Retrieves a record from the server.  If the record has already been loaded
-    in the store, then this method will simply return.  Otherwise if your 
-    store has a `dataSource`, this will call the `dataSource` to retrieve the 
-    record.  Generally you will not need to call this method yourself.  
+    in the store, then this method will simply return.  Otherwise if your
+    store has a `dataSource`, this will call the `dataSource` to retrieve the
+    record.  Generally you will not need to call this method yourself.
     Instead you can just use `find()`.
-    
-    This will not actually create a record instance but it will initiate a 
-    load of the record from the server.  You can subsequently get a record 
+
+    This will not actually create a record instance but it will initiate a
+    load of the record from the server.  You can subsequently get a record
     instance itself using `materializeRecord()`.
 
     @param {SC.Record} recordType class
@@ -1684,12 +1686,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Number} storeKey (optional) store key
     @param {Boolean} isRefresh
     @param {Function} callback (optional)
-    @returns {Number} storeKey that was retrieved 
+    @returns {Number} storeKey that was retrieved
   */
   retrieveRecord: function(recordType, id, storeKey, isRefresh, callback) {
     var array = this._TMP_RETRIEVE_ARRAY,
         ret;
-    
+
     if (storeKey) {
       array[0] = storeKey;
       storeKey = array;
@@ -1698,7 +1700,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       array[0] = id;
       id = array;
     }
-    
+
     ret = this.retrieveRecords(recordType, id, storeKey, isRefresh, callback);
     array.length = 0 ;
     return ret[0];
@@ -1708,7 +1710,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     Refreshes a record from the server.  If the record has already been loaded
     in the store, then this method will request a refresh from the
     `dataSource`. Otherwise it will attempt to retrieve the record.
-    
+
     @param {String} id to id of the record to load
     @param {SC.Record} recordType the expected record type
     @param {Number} storeKey (optional) optional store key
@@ -1723,7 +1725,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     Refreshes a set of records from the server.  If the records has already been loaded
     in the store, then this method will request a refresh from the
     `dataSource`. Otherwise it will attempt to retrieve them.
-    
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} ids ids to destroy
     @param {Array} storeKeys (optional) store keys to destroy
@@ -1734,29 +1736,29 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     var ret = this.retrieveRecords(recordTypes, ids, storeKeys, YES, callback);
     return ret && ret.length>0;
   },
-    
+
   /**
     Commits the passed store keys or ids. If no `storeKey`s are given,
-    it will commit any records in the changelog. 
-    
-    Based on the current state of the record, this will ask the data 
+    it will commit any records in the changelog.
+
+    Based on the current state of the record, this will ask the data
     source to perform the appropriate actions
     on the store keys.
-    
+
     @param {Array} recordTypes the expected record types (SC.Record)
     @param {Array} ids to commit
     @param {SC.Set} storeKeys to commit
     @param {Hash} params optional additional parameters to pass along to the
       data source
     @param {Function|Array} callback function or array of callbacks
-    
+
     @returns {Boolean} if the action was succesful.
   */
   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 = [], 
+        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;
@@ -1769,9 +1771,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
 
     len = storeKeys ? storeKeys.get('length') : (ids ? ids.get('length') : 0);
-    
+
     for(idx=0;idx<len;idx++) {
-      
+
       // collect store key
       if (storeKeys) {
         storeKey = storeKeys[idx];
@@ -1780,16 +1782,16 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         else recordType = recordTypes;
         storeKey = recordType.storeKeyFor(ids[idx]);
       }
-      
+
       //collect the callback
       callback = hasCallbackArray ? callbacks[idx] : callbacks;
-      
+
       // collect status and process
       status = this.readStatus(storeKey);
-      
+
       if ((status == K.EMPTY) || (status == K.ERROR)) {
         throw K.NOT_FOUND_ERROR ;
-      } 
+      }
       else {
         if(status==K.READY_NEW) {
           this.writeStatus(storeKey, K.BUSY_CREATING);
@@ -1809,16 +1811,16 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         } else if (status==K.DESTROYED_CLEAN) {
           this.dataHashDidChange(storeKey, rev, YES);
         }
-        // ignore K.READY_CLEAN, K.BUSY_LOADING, K.BUSY_CREATING, K.BUSY_COMMITTING, 
+        // ignore K.READY_CLEAN, K.BUSY_LOADING, K.BUSY_CREATING, K.BUSY_COMMITTING,
         // K.BUSY_REFRESH_CLEAN, K_BUSY_REFRESH_DIRTY, KBUSY_DESTROYING
       }
     }
-    
+
     // now commit storekeys to dataSource
     if (source && (len>0 || params)) {
       ret = source.commitRecords.call(source, this, retCreate, retUpdate, retDestroy, params);
     }
-    
+
     //remove all commited changes from changelog
     if (ret && !recordTypes && !ids) {
       if (storeKeys === this.changelog) {
@@ -1832,13 +1834,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   /**
-    Commits the passed store key or id.  Based on the current state of the 
+    Commits the passed store key or id.  Based on the current state of the
     record, this will ask the data source to perform the appropriate action
     on the store key.
-    
-    You have to pass either the id or the storeKey otherwise it will return 
+
+    You have to pass either the id or the storeKey otherwise it will return
     NO.
-    
+
     @param {SC.Record} recordType the expected record type
     @param {String} id the id of the record to commit
     @param {Number} storeKey the storeKey of the record to commit
@@ -1859,17 +1861,17 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       array[0] = id;
       id = array;
     }
-    
+
     ret = this.commitRecords(recordType, id, storeKey, params, callback);
     array.length = 0 ;
     return ret;
   },
-  
+
   /**
-    Cancels an inflight request for the passed records.  Depending on the 
-    server implementation, this could cancel an entire request, causing 
+    Cancels an inflight request for the passed records.  Depending on the
+    server implementation, this could cancel an entire request, causing
     other records to also transition their current state.
-    
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} ids ids to destroy
     @param {Array} storeKeys (optional) store keys to destroy
@@ -1881,22 +1883,22 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         K       = SC.Record,
         ret     = [],
         status, len, idx, id, recordType, storeKey;
-        
+
     len = (storeKeys === undefined) ? ids.length : storeKeys.length;
     for(idx=0;idx<len;idx++) {
       if (isArray) recordType = recordTypes[idx] || SC.Record;
       else recordType = recordTypes || SC.Record;
-      
+
       id = ids ? ids[idx] : undefined ;
-      
+
       if(storeKeys===undefined){
         storeKey = recordType.storeKeyFor(id);
       }else{
-        storeKey = storeKeys ? storeKeys[idx] : undefined ;        
+        storeKey = storeKeys ? storeKeys[idx] : undefined ;
       }
       if(storeKey) {
         status = this.readStatus(storeKey);
-        
+
         if ((status == K.EMPTY) || (status == K.ERROR)) {
           throw K.NOT_FOUND_ERROR ;
         }
@@ -1904,17 +1906,17 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         this._cancelCallback(storeKey);
       }
     }
-    
+
     if (source) source.cancel.call(source, this, ret);
-    
+
     return this ;
   },
 
   /**
-    Cancels an inflight request for the passed record.  Depending on the 
-    server implementation, this could cancel an entire request, causing 
+    Cancels an inflight request for the passed record.  Depending on the
+    server implementation, this could cancel an entire request, causing
     other records to also transition their current state.
-  
+
     @param {SC.Record|Array} recordTypes class or array of classes
     @param {Array} ids ids to destroy
     @param {Array} storeKeys (optional) store keys to destroy
@@ -1923,7 +1925,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   cancelRecord: function(recordType, id, storeKey) {
     var array = this._TMP_RETRIEVE_ARRAY,
         ret ;
-        
+
     if (storeKey !== undefined) {
       array[0] = storeKey;
       storeKey = array;
@@ -1932,32 +1934,32 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       array[0] = id;
       id = array;
     }
-    
+
     ret = this.cancelRecords(recordType, id, storeKey);
     array.length = 0 ;
     return this;
   },
 
-  /** 
-    Convenience method can be called by the store or other parts of your 
+  /**
+    Convenience method can be called by the store or other parts of your
     application to load a record into the store.  This method will take a
-    recordType and a data hashes and either add or update the 
-    record in the store. 
-    
+    recordType and a data hashes and either add or update the
+    record in the store.
+
     The loaded records will be in an `SC.Record.READY_CLEAN` state, indicating
-    they were loaded from the data source and do not need to be committed 
+    they were loaded from the data source and do not need to be committed
     back before changing.
-    
-    This method will check the state of the storeKey and call either 
-    `pushRetrieve()` or `dataSourceDidComplete()`.  The standard state constraints 
+
+    This method will check the state of the storeKey and call either
+    `pushRetrieve()` or `dataSourceDidComplete()`.  The standard state constraints
     for these methods apply here.
-    
+
     The return value will be the `storeKey` used for the push.  This is often
     convenient to pass into `loadQuery()`, if you are fetching a remote query.
-    
-    If you are upgrading from a pre SproutCore 1.0 application, this method 
+
+    If you are upgrading from a pre SproutCore 1.0 application, this method
     is the closest to the old `updateRecord()`.
-    
+
     @param {SC.Record} recordType the record type
     @param {Array} dataHash to update
     @param {Array} id optional.  if not passed lookup on the hash
@@ -1966,44 +1968,44 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   loadRecord: function(recordType, dataHash, id) {
     var K       = SC.Record,
         ret, primaryKey, storeKey;
-        
+
     // save lookup info
     recordType = recordType || SC.Record;
     primaryKey = recordType.prototype.primaryKey;
-    
-    
+
+
     // push each record
     id = id || dataHash[primaryKey];
     ret = storeKey = recordType.storeKeyFor(id); // needed to cache
-      
+
     if (this.readStatus(storeKey) & K.BUSY) {
       this.dataSourceDidComplete(storeKey, dataHash, id);
     } else this.pushRetrieve(recordType, id, dataHash, storeKey);
-    
+
     // return storeKey
     return ret ;
   },
-  
-  /** 
-    Convenience method can be called by the store or other parts of your 
+
+  /**
+    Convenience method can be called by the store or other parts of your
     application to load records into the store.  This method will take a
-    recordType and an array of data hashes and either add or update the 
-    record in the store. 
-    
+    recordType and an array of data hashes and either add or update the
+    record in the store.
+
     The loaded records will be in an `SC.Record.READY_CLEAN` state, indicating
-    they were loaded from the data source and do not need to be committed 
+    they were loaded from the data source and do not need to be committed
     back before changing.
-    
-    This method will check the state of each storeKey and call either 
-    `pushRetrieve()` or `dataSourceDidComplete()`.  The standard state 
+
+    This method will check the state of each storeKey and call either
+    `pushRetrieve()` or `dataSourceDidComplete()`.  The standard state
     constraints for these methods apply here.
-    
+
     The return value will be the storeKeys used for each push.  This is often
     convenient to pass into `loadQuery()`, if you are fetching a remote query.
-    
-    If you are upgrading from a pre SproutCore 1.0 application, this method 
+
+    If you are upgrading from a pre SproutCore 1.0 application, this method
     is the closest to the old `updateRecords()`.
-    
+
     @param {SC.Record} recordTypes the record type or array of record types
     @param {Array} dataHashes array of data hashes to update
     @param {Array} ids optional array of ids.  if not passed lookup on hashes
@@ -2015,13 +2017,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         ret     = [],
         K       = SC.Record,
         recordType, id, primaryKey, idx, dataHash, storeKey;
-        
+
     // save lookup info
     if (!isArray) {
       recordType = recordTypes || SC.Record;
       primaryKey = recordType.prototype.primaryKey ;
     }
-    
+
     // push each record
     for(idx=0;idx<len;idx++) {
       dataHash = dataHashes.objectAt(idx);
@@ -2031,9 +2033,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
       id = (ids) ? ids.objectAt(idx) : dataHash[primaryKey];
       ret[idx] = this.loadRecord(recordType, dataHash, id);
-      
+
     }
-    
+
     // return storeKeys
     return ret ;
   },
@@ -2042,7 +2044,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     Returns the `SC.Error` object associated with a specific record.
 
     @param {Number} storeKey The store key of the record.
- 
+
     @returns {SC.Error} SC.Error or undefined if no error associated with the record.
   */
   readError: function(storeKey) {
@@ -2054,91 +2056,91 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     Returns the `SC.Error` object associated with a specific query.
 
     @param {SC.Query} query The SC.Query with which the error is associated.
- 
+
     @returns {SC.Error} SC.Error or undefined if no error associated with the query.
   */
   readQueryError: function(query) {
     var errors = this.queryErrors ;
     return errors ? errors[SC.guidFor(query)] : undefined ;
   },
-  
+
   // ..........................................................
   // DATA SOURCE CALLBACKS
-  // 
+  //
   // Mathods called by the data source on the store
 
   /**
-    Called by a `dataSource` when it cancels an inflight operation on a 
+    Called by a `dataSource` when it cancels an inflight operation on a
     record.  This will transition the record back to it non-inflight state.
-    
+
     @param {Number} storeKey record store key to cancel
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   dataSourceDidCancel: function(storeKey) {
-    var status = this.readStatus(storeKey), 
+    var status = this.readStatus(storeKey),
         K      = SC.Record;
-    
+
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
     // DESTROYED_DIRTY
     if (!(status & K.BUSY)) {
       throw K.BAD_STATE_ERROR; // should never be called in this state
     }
-    
+
     // otherwise, determine proper state transition
     switch(status) {
       case K.BUSY_LOADING:
         status = K.EMPTY;
         break ;
-      
+
       case K.BUSY_CREATING:
         status = K.READY_NEW;
         break;
-        
+
       case K.BUSY_COMMITTING:
         status = K.READY_DIRTY ;
         break;
-        
+
       case K.BUSY_REFRESH_CLEAN:
         status = K.READY_CLEAN;
         break;
-        
+
       case K.BUSY_REFRESH_DIRTY:
         status = K.READY_DIRTY ;
         break ;
-        
+
       case K.BUSY_DESTROYING:
         status = K.DESTROYED_DIRTY ;
         break;
-        
+
       default:
         throw K.BAD_STATE_ERROR ;
-    } 
+    }
     this.writeStatus(storeKey, status) ;
     this.dataHashDidChange(storeKey, null, YES);
     this._cancelCallback(storeKey);
-    
+
     return this ;
   },
-  
+
   /**
     Called by a data source when it creates or commits a record.  Passing an
-    optional id will remap the `storeKey` to the new record id.  This is 
+    optional id will remap the `storeKey` to the new record id.  This is
     required when you commit a record that does not have an id yet.
-    
+
     @param {Number} storeKey record store key to change to READY_CLEAN state
     @param {Hash} dataHash optional data hash to replace current hash
     @param {Object} newId optional new id to replace the old one
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   dataSourceDidComplete: function(storeKey, dataHash, newId) {
     var status = this.readStatus(storeKey), K = SC.Record, statusOnly;
-    
+
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
     // DESTROYED_DIRTY
     if (!(status & K.BUSY)) {
       throw K.BAD_STATE_ERROR; // should never be called in this state
     }
-    
+
     // otherwise, determine proper state transition
     if(status===K.BUSY_DESTROYING) {
       throw K.BAD_STATE_ERROR ;
@@ -2147,7 +2149,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.writeStatus(storeKey, status) ;
     if (dataHash) this.writeDataHash(storeKey, dataHash, status) ;
     if (newId) SC.Store.replaceIdFor(storeKey, newId);
-    
+
     statusOnly = dataHash || newId ? NO : YES;
     this.dataHashDidChange(storeKey, null, statusOnly);
 
@@ -2158,16 +2160,16 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
     //update callbacks
     this._retreiveCallbackForStoreKey(storeKey);
-    
+
     return this ;
   },
-  
+
   /**
     Called by a data source when it has destroyed a record.  This will
     transition the record to the proper state.
-    
+
     @param {Number} storeKey record store key to cancel
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   dataSourceDidDestroy: function(storeKey) {
     var status = this.readStatus(storeKey), K = SC.Record;
@@ -2180,7 +2182,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // otherwise, determine proper state transition
     else{
       status = K.DESTROYED_CLEAN ;
-    } 
+    }
     this.removeDataHash(storeKey, status) ;
     this.dataHashDidChange(storeKey);
 
@@ -2197,10 +2199,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
   /**
     Converts the passed record into an error object.
-    
+
     @param {Number} storeKey record store key to error
     @param {SC.Error} error [optional] an SC.Error instance to associate with storeKey
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   dataSourceDidError: function(storeKey, error) {
     var status = this.readStatus(storeKey), errors = this.recordErrors, K = SC.Record;
@@ -2233,44 +2235,44 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
   // ..........................................................
   // PUSH CHANGES FROM DATA SOURCE
-  // 
-  
+  //
+
   /**
-    Call by the data source whenever you want to push new data out of band 
+    Call by the data source whenever you want to push new data out of band
     into the store.
-    
+
     @param {Class} recordType the SC.Record subclass
     @param {Object} id the record id or null
     @param {Hash} dataHash data hash to load
-    @param {Number} storeKey optional store key.  
+    @param {Number} storeKey optional store key.
     @returns {Number|Boolean} storeKey if push was allowed, NO if not
   */
   pushRetrieve: function(recordType, id, dataHash, 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) {
-      
+
       status = K.READY_CLEAN;
       if(dataHash===undefined) this.writeStatus(storeKey, status) ;
       else this.writeDataHash(storeKey, dataHash, status) ;
 
       this.dataHashDidChange(storeKey);
-      
+
       return storeKey;
     }
     //conflicted (ready)
     return NO;
   },
-  
+
   /**
-    Call by the data source whenever you want to push a deletion into the 
+    Call by the data source whenever you want to push a deletion into the
     store.
-    
+
     @param {Class} recordType the SC.Record subclass
     @param {Object} id the record id or null
-    @param {Number} storeKey optional store key.  
+    @param {Number} storeKey optional store key.
     @returns {Number|Boolean} storeKey if push was allowed, NO if not
   */
   pushDestroy: function(recordType, id, storeKey) {
@@ -2291,9 +2293,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   /**
-    Call by the data source whenever you want to push an error into the 
+    Call by the data source whenever you want to push an error into the
     store.
-    
+
     @param {Class} recordType the SC.Record subclass
     @param {Object} id the record id or null
     @param {SC.Error} error [optional] an SC.Error instance to associate with id or storeKey
@@ -2308,13 +2310,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     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).
       if (error && error.isError) {
         if (!errors) errors = this.recordErrors = [];
         errors[storeKey] = error;
       }
-      
+
       this.writeStatus(storeKey, status) ;
       this.dataHashDidChange(storeKey, null, YES);
       return storeKey;
@@ -2322,29 +2324,29 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     //conflicted (error)
     return NO;
   },
-  
+
   // ..........................................................
   // FETCH CALLBACKS
-  // 
-  
+  //
+
   // **NOTE**: although these method works on RecordArray instances right now.
   // They could be optimized to actually share query results between nested
-  // stores.  This is why these methods are implemented here instead of 
+  // 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 
+    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.
-    
+
     @param {SC.Query} query the query you are loading.  must be remote.
     @param {SC.Array} storeKeys array of store keys
     @returns {SC.Store} receiver
@@ -2357,75 +2359,75 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     var recArray = this._findQuery(query, YES, NO);
     if (recArray) recArray.set('storeKeys', storeKeys);
     this.dataSourceDidFetchQuery(query);
-    
+
     return this ;
   },
-  
+
   /**
-    Called by your data source whenever you finish fetching the results of a 
+    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.
-    
-    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 
+
+    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.
-    
+
     @param {SC.Query} query the query you fetched
     @returns {SC.Store} receiver
   */
   dataSourceDidFetchQuery: function(query) {
     return this._scstore_dataSourceDidFetchQuery(query, YES);
   },
-  
+
   _scstore_dataSourceDidFetchQuery: function(query, createIfNeeded) {
     var recArray     = this._findQuery(query, createIfNeeded, NO),
         nestedStores = this.get('nestedStores'),
         loc          = nestedStores ? nestedStores.get('length') : 0;
-    
+
     // fix query if needed
     if (recArray) recArray.storeDidFetchQuery(query);
-    
+
     // notify nested stores
     while(--loc >= 0) {
       nestedStores[loc]._scstore_dataSourceDidFetchQuery(query, NO);
     }
-    
+
     return this ;
   },
-  
+
   /**
     Called by your data source if it cancels fetching the results of a query.
     This will put any RecordArray's back into its original state (READY or
     EMPTY).
-    
+
     @param {SC.Query} query the query you cancelled
     @returns {SC.Store} receiver
   */
   dataSourceDidCancelQuery: function(query) {
     return this._scstore_dataSourceDidCancelQuery(query, YES);
   },
-  
+
   _scstore_dataSourceDidCancelQuery: function(query, createIfNeeded) {
     var recArray     = this._findQuery(query, createIfNeeded, NO),
         nestedStores = this.get('nestedStores'),
         loc          = nestedStores ? nestedStores.get('length') : 0;
-    
+
     // fix query if needed
     if (recArray) recArray.storeDidCancelQuery(query);
-    
+
     // notify nested stores
     while(--loc >= 0) {
       nestedStores[loc]._scstore_dataSourceDidCancelQuery(query, NO);
     }
-    
+
     return this ;
   },
-  
+
   /**
     Called by your data source if it encountered an error loading the query.
     This will put the query into an error state until you try to refresh it
     again.
-    
+
     @param {SC.Query} query the query with the error
     @param {SC.Error} error [optional] an SC.Error instance to associate with query
     @returns {SC.Store} receiver
@@ -2457,18 +2459,18 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     return this ;
   },
-    
+
   // ..........................................................
   // INTERNAL SUPPORT
-  // 
-  
+  //
+
   /** @private */
   init: function() {
     sc_super();
     this.reset();
   },
-  
-  
+
+
   toString: function() {
     // Include the name if the client has specified one.
     var name = this.get('name');
@@ -2484,32 +2486,32 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
   // ..........................................................
   // PRIMARY KEY CONVENIENCE METHODS
-  // 
+  //
 
-  /** 
+  /**
     Given a `storeKey`, return the `primaryKey`.
-  
+
     @param {Number} storeKey the store key
     @returns {String} primaryKey value
   */
   idFor: function(storeKey) {
     return SC.Store.idFor(storeKey);
   },
-  
+
   /**
     Given a storeKey, return the recordType.
-    
+
     @param {Number} storeKey the store key
     @returns {SC.Record} record instance
   */
   recordTypeFor: function(storeKey) {
     return SC.Store.recordTypeFor(storeKey) ;
   },
-  
+
   /**
     Given a `recordType` and `primaryKey`, find the `storeKey`. If the
     `primaryKey` has not been assigned a `storeKey` yet, it will be added.
-    
+
     @param {SC.Record} recordType the record type
     @param {String} primaryKey the primary key
     @returns {Number} storeKey
@@ -2517,12 +2519,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   storeKeyFor: function(recordType, primaryKey) {
     return recordType.storeKeyFor(primaryKey);
   },
-  
+
   /**
     Given a `primaryKey` value for the record, returns the associated
     `storeKey`.  As opposed to `storeKeyFor()` however, this method
     will **NOT** generate a new `storeKey` but returned `undefined`.
-    
+
     @param {SC.Record} recordType the record type
     @param {String} primaryKey the primary key
     @returns {Number} a storeKey.
@@ -2530,56 +2532,56 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   storeKeyExists: function(recordType, primaryKey) {
     return recordType.storeKeyExists(primaryKey);
   },
-  
+
   /**
     Finds all `storeKey`s of a certain record type in this store
     and returns an array.
-    
+
     @param {SC.Record} recordType
     @returns {Array} set of storeKeys
   */
   storeKeysFor: function(recordType) {
-    var ret = [], 
+    var ret = [],
         isEnum = recordType && recordType.isEnumerable,
         recType, storeKey, isMatch ;
-    
+
     if (!this.statuses) return ret;
     for(storeKey in SC.Store.recordTypesByStoreKey) {
       recType = SC.Store.recordTypesByStoreKey[storeKey];
-      
+
       // if same record type and this store has it
       if (isEnum) isMatch = recordType.contains(recType);
       else isMatch = recType === recordType;
-      
+
       if(isMatch && this.statuses[storeKey]) ret.push(parseInt(storeKey, 10));
     }
-    
+
     return ret;
   },
-  
+
   /**
     Finds all `storeKey`s in this store
     and returns an array.
-    
+
     @returns {Array} set of storeKeys
   */
   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) {
         ret.push(parseInt(storeKey, 10));
       }
     }
-    
+
     return ret;
   },
-  
+
   /**
     Returns string representation of a `storeKey`, with status.
-    
+
     @param {Number} storeKey
     @returns {String}
   */
@@ -2587,54 +2589,54 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     var rec = this.materializeRecord(storeKey);
     return rec.statusString();
   }
-  
+
 }) ;
 
 SC.Store.mixin(/** @scope SC.Store.prototype */{
-  
+
   /**
     Standard error raised if you try to commit changes from a nested store
     and there is a conflict.
-    
+
     @type Error
   */
   CHAIN_CONFLICT_ERROR: new Error("Nested Store Conflict"),
-  
+
   /**
-    Standard error if you try to perform an operation on a nested store 
+    Standard error if you try to perform an operation on a nested store
     without a parent.
-  
+
     @type Error
   */
   NO_PARENT_STORE_ERROR: new Error("Parent Store Required"),
-  
+
   /**
     Standard error if you try to perform an operation on a nested store that
     is only supported in root stores.
-    
+
     @type Error
   */
   NESTED_STORE_UNSUPPORTED_ERROR: new Error("Unsupported In Nested Store"),
-  
+
   /**
     Standard error if you try to retrieve a record in a nested store that is
     dirty.  (This is allowed on the main store, but not in nested stores.)
-    
+
     @type Error
   */
   NESTED_STORE_RETRIEVE_DIRTY_ERROR: new Error("Cannot Retrieve Dirty Record in Nested Store"),
 
   /**
     Data hash state indicates the data hash is currently editable
-    
+
     @type String
   */
   EDITABLE:  'editable',
-  
+
   /**
-    Data hash state indicates the hash no longer tracks changes from a 
+    Data hash state indicates the hash no longer tracks changes from a
     parent store, but it is not editable.
-    
+
     @type String
   */
   LOCKED:    'locked',
@@ -2642,88 +2644,88 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
   /**
     Data hash state indicates the hash is tracking changes from the parent
     store and is not editable.
-    
+
     @type String
   */
   INHERITED: 'inherited',
-  
+
   /** @private
     This array maps all storeKeys to primary keys.  You will not normally
-    access this method directly.  Instead use the `idFor()` and 
+    access this method directly.  Instead use the `idFor()` and
     `storeKeyFor()` methods on `SC.Record`.
   */
   idsByStoreKey: [],
-  
+
   /** @private
     Maps all `storeKey`s to a `recordType`.  Once a `storeKey` is associated
     with a `primaryKey` and `recordType` that remains constant throughout the
     lifetime of the application.
   */
   recordTypesByStoreKey: {},
-  
+
   /** @private
     Maps some `storeKeys` to query instance.  Once a `storeKey` is associated
-    with a query instance, that remains constant through the lifetime of the 
-    application.  If a `Query` is destroyed, it will remove itself from this 
+    with a query instance, that remains constant through the lifetime of the
+    application.  If a `Query` is destroyed, it will remove itself from this
     list.
-    
+
     Don't access this directly.  Use queryFor().
   */
   queriesByStoreKey: [],
-  
+
   /** @private
     The next store key to allocate.  A storeKey must always be greater than 0
   */
   nextStoreKey: 1,
-  
+
   /**
     Generates a new store key for use.
-    
+
     @type Number
   */
   generateStoreKey: function() { return this.nextStoreKey++; },
-  
-  /** 
+
+  /**
     Given a `storeKey` returns the `primaryKey` associated with the key.
     If no `primaryKey` is associated with the `storeKey`, returns `null`.
-    
+
     @param {Number} storeKey the store key
     @returns {String} the primary key or null
   */
   idFor: function(storeKey) {
     return this.idsByStoreKey[storeKey] ;
   },
-  
+
   /**
     Given a `storeKey`, returns the query object associated with the key.  If
     no query is associated with the `storeKey`, returns `null`.
-    
+
     @param {Number} storeKey the store key
     @returns {SC.Query} query query object
   */
   queryFor: function(storeKey) {
-    return this.queriesByStoreKey[storeKey];  
+    return this.queriesByStoreKey[storeKey];
   },
-  
+
   /**
     Given a `storeKey` returns the `SC.Record` class associated with the key.
     If no record type is associated with the store key, returns `null`.
-    
+
     The SC.Record class will only be found if you have already called
     storeKeyFor() on the record.
-    
+
     @param {Number} storeKey the store key
     @returns {SC.Record} the record type
   */
   recordTypeFor: function(storeKey) {
     return this.recordTypesByStoreKey[storeKey];
   },
-  
+
   /**
-    Swaps the `primaryKey` mapped to the given storeKey with the new 
+    Swaps the `primaryKey` mapped to the given storeKey with the new
     `primaryKey`.  If the `storeKey` is not currently associated with a record
     this will raise an exception.
-    
+
     @param {Number} storeKey the existing store key
     @param {String} newPrimaryKey the new primary key
     @returns {SC.Store} receiver
@@ -2731,7 +2733,7 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
   replaceIdFor: function(storeKey, newId) {
     var oldId = this.idsByStoreKey[storeKey],
         recordType, storeKeys;
-        
+
     if (oldId !== newId) { // skip if id isn't changing
 
       recordType = this.recordTypeFor(storeKey);
@@ -2740,32 +2742,32 @@ SC.Store.mixin(/** @scope SC.Store.prototype */{
       }
 
       // map one direction...
-      this.idsByStoreKey[storeKey] = newId; 
+      this.idsByStoreKey[storeKey] = newId;
 
       // then the other...
       storeKeys = recordType.storeKeysById() ;
       delete storeKeys[oldId];
-      storeKeys[newId] = storeKey;     
+      storeKeys[newId] = storeKey;
     }
-    
+
     return this ;
   },
-  
+
   /**
     Swaps the `recordType` recorded for a given `storeKey`.  Normally you
     should not call this method directly as it can damage the store behavior.
-    This method is used by other store methods to set the `recordType` for a 
+    This method is used by other store methods to set the `recordType` for a
     `storeKey`.
-    
+
     @param {Integer} storeKey the store key
     @param {SC.Record} recordType a record class
-    @returns {SC.Store} reciever
+    @returns {SC.Store} receiver
   */
   replaceRecordTypeFor: function(storeKey, recordType) {
     this.recordTypesByStoreKey[storeKey] = recordType;
     return this ;
   }
-  
+
 });
 
 
@@ -2774,7 +2776,7 @@ SC.Store.prototype.nextStoreIndex = 1;
 
 // ..........................................................
 // COMPATIBILITY
-// 
+//
 
 /** @private
   global store is used only for deprecated compatibility methods.  Don't use
@@ -2789,14 +2791,14 @@ SC.Store._getDefaultStore = function() {
 /** @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 
+
+  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.  
-  
+
+  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
@@ -2804,37 +2806,35 @@ SC.Store._getDefaultStore = function() {
   @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 
+  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
@@ -2845,12 +2845,12 @@ SC.Store.find = function(guid, recordType) {
 
 /** @private
 
-  DEPRECATED 
+  DEPRECATED
 
-  Passes through to `findAll` on default store.  This is included only for 
+  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