sproutcore 1.11.0.rc2 → 1.11.0.rc3

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

@@ -444,6 +444,19 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if (!editables) editables = this.editables = [];
     editables[storeKey] = 1 ; // use number for dense array support
 
+    // propagate the data to the child records
+    this._updateChildRecordHashes(storeKey, hash, status);
+
+    return this ;
+  },
+
+  /** @private
+
+    Called by writeDataHash to update the child record hashes starting from the new (parent) data hash.
+
+    @returns {SC.Store} receiver
+  */
+  _updateChildRecordHashes: function(storeKey, hash, status) {
     var processedPaths={};
     // Update the child record hashes in place.
     if (!SC.none(this.parentRecords) ) {
@@ -485,8 +498,6 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
         }
       }
     }
-
-    return this ;
   },
 
   /**
@@ -798,9 +809,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Boolean} force
     @returns {SC.Store} receiver
   */
-  commitChangesFromNestedStore: function(nestedStore, changes, force) {
+  commitChangesFromNestedStore: function (nestedStore, changes, force) {
     // first, check for optimistic locking problems
-    if (!force) this._verifyLockRevisions(changes, nestedStore.locks);
+    if (!force && nestedStore.get('conflictedStoreKeys')) {
+      throw SC.Store.CHAIN_CONFLICT_ERROR;
+    }
 
     // OK, no locking issues.  So let's just copy them changes.
     // get local reference to values.
@@ -853,32 +866,6 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     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
-    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
-  */
-  _verifyLockRevisions: function(changes, locks) {
-    var len = changes.length, revs = this.revisions, i, storeKey, lock, rev ;
-    if (locks && revs) {
-      for(i=0;i<len;i++) {
-        storeKey = changes[i];
-        lock = locks[storeKey] || 1;
-        rev  = revs[storeKey] || 1;
-
-        // 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.
-        if (lock < rev) throw SC.Store.CHAIN_CONFLICT_ERROR;
-      }
-    }
-    return this ;
-  },
-
   // ..........................................................
   // HIGH-LEVEL RECORD API
   //
@@ -2373,11 +2360,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // otherwise, determine proper state transition
     if(status === K.BUSY_DESTROYING) {
       throw K.BAD_STATE_ERROR ;
-    } else status = K.READY_CLEAN ;
+    } else status = K.READY_CLEAN;
 
-    this.writeStatus(storeKey, status) ;
-    if (dataHash) this.writeDataHash(storeKey, dataHash, status) ;
-    if (newId) SC.Store.replaceIdFor(storeKey, newId);
+    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);
@@ -2385,6 +2372,8 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // Force record to refresh its cached properties based on store key
     var record = this.materializeRecord(storeKey);
     if (record !== null) {
+      // If the record's id property has been computed, ensure that it re-computes.
+      if (newId) { record.propertyDidChange('id'); }
       record.notifyPropertyChange('status');
     }
     //update callbacks
@@ -2487,7 +2476,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       if(dataHash === undefined) this.writeStatus(storeKey, status) ;
       else this.writeDataHash(storeKey, dataHash, status) ;
 
-      if (id && this.idFor(storeKey) !== id) SC.Store.replaceIdFor(storeKey, id);
+      if (id && this.idFor(storeKey) !== id) {
+        SC.Store.replaceIdFor(storeKey, id);
+
+        // If the record's id property has been computed, ensure that it re-computes.
+        var record = this.materializeRecord(storeKey);
+        record.propertyDidChange('id');
+      }
       this.dataHashDidChange(storeKey);
 
       return storeKey;

data/lib/frameworks/sproutcore/frameworks/datastore/tests/models/record/writeAttribute.js

@@ -3,7 +3,7 @@
 // Copyright: ©2006-2011 Apple Inc. and contributors.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-/*globals module ok equals same test MyApp */
+/*globals module, ok, equals, same, test */
 
 var store, Foo, json, foo ;
 module("SC.Record#writeAttribute", {
@@ -108,10 +108,11 @@ test("Writing a new guid", function(){
 });
 
 test("Writing primaryKey of 'id'", function(){
-  PrimaryKeyId = SC.Record.extend({ primaryKey: 'id' });
+  var PrimaryKeyId = SC.Record.extend({ primaryKey: 'id' });
   var foo2 = store.createRecord(PrimaryKeyId, { id: 1 });
 
   equals(foo2.get('id'), 1, 'foo2.id should be 1');
   foo2.set('id', 2);
   equals(foo2.get('id'), 2, 'foo2.id should be 2');
+  equals(store.idFor(foo2.get('storeKey')), 2, 'foo2.id should be 2 in the store');
 });

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

@@ -12,18 +12,18 @@ var parent, store, child, storeKey, json;
 module("SC.NestedStore#writeDataHash", {
   setup: function() {
     parent = SC.Store.create();
-    
+
     json = {
       string: "string",
       number: 23,
       bool:   YES
     };
-    
+
     storeKey = SC.Store.generateStoreKey();
 
     parent.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
     parent.editables = null; // manually patch to setup test state
-    
+
     store = parent.chain(); // create nested store
     child = store.chain();  // test multiple levels deep
   }
@@ -31,20 +31,20 @@ module("SC.NestedStore#writeDataHash", {
 
 // ..........................................................
 // BASIC STATE TRANSITIONS
-// 
+//
 
 // The transition from each base state performs the same operation, so just
 // run the same test on each state.
 function testWriteDataHash() {
   var oldrev = store.revisions[storeKey];
-  
+
   // perform test
   var json2 = { foo: "bar" };
   equals(store.writeDataHash(storeKey, json2, SC.Record.READY_NEW), store, 'should return receiver');
-  
+
   // verify
   equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'new edit state should be editable');
-  
+
   equals(store.readDataHash(storeKey), json2, 'should have new json data hash');
   equals(store.readStatus(storeKey), SC.Record.READY_NEW, 'should have new status');
 
@@ -56,45 +56,45 @@ function testWriteDataHash() {
 
 
 test("edit state=INHERITED", function() {
-  
+
   // test preconditions
   equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - edit state should be inherited');
-  
+
   testWriteDataHash();
 });
 
 test("edit state=LOCKED", function() {
-  
+
   // test preconditions
   store.readDataHash(storeKey);
   equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - edit state should be locked');
-  
+
   testWriteDataHash();
 
 });
 
 test("edit state=EDITABLE", function() {
-  
+
   // test preconditions
   store.readEditableDataHash(storeKey);
   equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - edit state should be editable');
-  
+
   testWriteDataHash();
 
 });
 
 // ..........................................................
 // WRITING NEW VS EXISTING
-// 
+//
 
 test("writing a new hash", function() {
   storeKey = SC.Store.generateStoreKey(); // new store key!
   equals(parent.readDataHash(storeKey), null, 'precond - parent should not have a data hash for store key yet');
   equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - edit status should be inherited');
-  
+
   // perform write
   equals(store.writeDataHash(storeKey, json, SC.Record.READY_NEW), store, 'should return receiver');
-  
+
   // verify change
   equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'new status should be editable');
   equals(store.readDataHash(storeKey), json, 'should match new json');
@@ -103,7 +103,7 @@ test("writing a new hash", function() {
 
 // ..........................................................
 // PROPOGATING TO NESTED STORES
-// 
+//
 
 test("change should propogate to child if child edit state = INHERITED", function() {
 
@@ -113,11 +113,11 @@ test("change should propogate to child if child edit state = INHERITED", functio
   // perform change
   var json2 = { version: 2 };
   store.writeDataHash(storeKey, json2, SC.Record.READY_NEW);
-  
+
   // verify
   same(child.readDataHash(storeKey), json2, 'child should pick up change');
   equals(parent.readDataHash(storeKey), json, 'parent should still have old json');
-  
+
   equals(child.readStatus(storeKey), SC.Record.READY_NEW, 'child should pick up new status');
   equals(parent.readStatus(storeKey), SC.Record.READY_CLEAN, 'parent should still have old status');
 
@@ -128,11 +128,11 @@ function testLockedOrEditableChild() {
   // perform change
   var json2 = { version: 2 };
   store.writeDataHash(storeKey, json2, SC.Record.READY_NEW);
-  
+
   // verify
   same(child.readDataHash(storeKey), json, 'child should NOT pick up change');
   equals(parent.readDataHash(storeKey), json, 'parent should still have old json');
-  
+
   equals(child.readStatus(storeKey), SC.Record.READY_CLEAN, 'child should pick up new status');
   equals(parent.readStatus(storeKey), SC.Record.READY_CLEAN, 'parent should still have old status');
 }
@@ -156,11 +156,55 @@ test("change should not propogate to child if child edit state = EDITABLE", func
   testLockedOrEditableChild();
 });
 
-
-
-
-
-
-
-
-
+test("writeDataHash on parent records should be propagated to nested children and eventually to the parent store", function() {
+  var model = SC.Record.extend( {
+                v: SC.Record.attr( String ),
+                c: SC.Record.toMany( SC.Record.extend( {
+                                       v: SC.Record.attr( String ),
+                                     } ),
+                                     {
+                                       nested: YES
+                                     } )
+              } );
+  var json1 = { guid: "p1", v: "p1-1", c: [ { guid: "c1", v: "c1-1" }, { id: "c2", v: "c2-1" } ] };
+  var json12 = { guid: "p1", v: "p1-2", c: [ { guid: "c1", v: "c1-2" }, { id: "c2", v: "c2-1" } ] };
+
+  SC.RunLoop.begin();
+
+  // load the data into the main store
+  var storeKey1 = parent.loadRecord( model, json1 );
+  var rec1 = parent.find( model, "p1" );
+
+  equals( rec1.get( "v" ), "p1-1", "the data loaded into the record should be correct" );
+  equals( rec1.get( "c" ).objectAt( 0 ).get( "v" ), "c1-1", "the data loaded into the 1st child record should be correct" );
+  equals( rec1.get( "c" ).objectAt( 1 ).get( "v" ), "c2-1", "the data loaded into the 2nd child record should be correct" );
+
+  // start an "editing" session into the nested store store
+  var rec12 = store.find( rec1 );
+
+  equals( rec12.get( "c" ).objectAt( 0 ).get( "v" ), "c1-1", "the data loaded into the 1st child record should be correct" );
+  equals( rec12.get( "c" ).objectAt( 1 ).get( "v" ), "c2-1", "the data loaded into the 2nd child record should be correct" );
+
+  // replace the content and notify the changes
+  store.writeDataHash( storeKey1, json12, SC.Record.READY_CLEAN );
+  store.dataHashDidChange( storeKey1 );
+
+  SC.RunLoop.end();
+
+  SC.RunLoop.begin();
+  // check if the values from the hash are properly propagated to the record + children
+  equals( rec12.get( "v" ), "p1-2", "after writeDataHash the data loaded into the record should be updated" );
+  equals( rec12.get( "c" ).objectAt( 0 ).get( "v" ), "c1-2", "after writeDataHash the data loaded into the 1st child record should be updated" );
+  equals( rec12.get( "c" ).objectAt( 1 ).get( "v" ), "c2-1", "after writeDataHash the data loaded into the 2nd child record should not be updated" );
+
+  // push the changes to the parent store
+  store.commitChanges(YES);
+  SC.RunLoop.end();
+
+  SC.RunLoop.begin();
+  // check if the values updated into the nested store are properly propagated to the record + children
+  equals( rec1.get( "v" ), "p1-2", "after commitChanges the data loaded into the record should be updated" );
+  equals( rec1.get( "c" ).objectAt( 0 ).get( "v" ), "c1-2", "after commitChanges the data loaded into the 1st child record should be updated" );
+  equals( rec1.get( "c" ).objectAt( 1 ).get( "v" ), "c2-1", "the data loaded into the 2nd child record should be correct" );
+  SC.RunLoop.end();
+});

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

@@ -0,0 +1,156 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module, ok, equals, same, test */
+
+var store, child, json;
+
+module("SC.NestedStore.prototype.conflictedStoreKeys", {
+  setup: function () {
+    SC.run(function () {
+      store = SC.Store.create();
+
+      json = {
+        string: "string",
+        number: 23,
+        bool: true
+      };
+
+      child = store.chain();  // test multiple levels deep
+    });
+  },
+
+  teardown: function () {
+    child.destroy();
+    store.destroy();
+
+    store = child = json = null;
+  }
+});
+
+test("should return empty array when no conflict is present", function() {
+  SC.run(function () {
+    var storeKey = SC.Store.generateStoreKey();
+
+    // write basic status
+    child.writeDataHash(storeKey, json, SC.Record.READY_DIRTY);
+    child.dataHashDidChange(storeKey);
+    child.changelog = SC.Set.create();
+    child.changelog.add(storeKey);
+
+    same(child.get('conflictedStoreKeys'), null, "There should be no conflicted store keys");
+  });
+});
+
+test("should return an array with one or more storekeys when one or more conflicts exist", function() {
+  SC.run(function () {
+    var json2 = { kind: "json2" };
+    var json3 = { kind: "json3" };
+
+    // create a lock conflict.  use a new storeKey since the old one has been
+    // setup in a way that won't work for this.
+    var storeKey = SC.Store.generateStoreKey();
+
+    // step 1: add data to root store
+    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    store.dataHashDidChange(storeKey);
+
+    // step 2: read data in chained store.  this will create lock
+    child.readDataHash(storeKey);
+    ok(child.locks[storeKey], 'child store should now have lock');
+
+    // step 3: modify root store again
+    store.writeDataHash(storeKey, json2, SC.Record.READY_CLEAN);
+    store.dataHashDidChange(storeKey);
+
+    // step 4: modify data in chained store so we have something to commit.
+    child.writeDataHash(storeKey, json3, SC.Record.READY_DIRTY);
+    child.dataHashDidChange(storeKey);
+
+    // just to make sure verify that the lock and revision in parent do not match
+    ok(child.locks[storeKey] !== store.revisions[storeKey], 'child.lock (%@) should !== store.revision (%@)'.fmt(child.locks[storeKey], store.revisions[storeKey]));
+
+    // step 5: now try to retrieve conflicts
+    same(child.get('conflictedStoreKeys') , [storeKey], "There should be conflicted store key as");
+
+  });
+});
+
+
+test("should be able to bind and observe conflictedStoreKeys", function () {
+  var observerExpected = null,
+      observerObject = SC.Object.create({
+        conflictedStoreKeysDC: function () {
+          same(child.get('conflictedStoreKeys'), observerExpected, "There should be conflicted store keys observed as");
+        }
+      });
+
+  child.addObserver('conflictedStoreKeys', observerObject, 'conflictedStoreKeysDC');
+
+  SC.run(function () {
+    var json2 = { kind: "json2" };
+    var json3 = { kind: "json3" };
+    var json4 = { kind: "json4" };
+
+    // create a lock conflict.  use a new storeKey since the old one has been
+    // setup in a way that won't work for this.
+    var storeKey = SC.Store.generateStoreKey();
+
+    // step 1: add data to root store
+    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    store.dataHashDidChange(storeKey);
+
+    // step 2: read data in chained store.  this will create lock
+    child.readDataHash(storeKey);
+
+    // Run observer manually once.
+    observerObject.conflictedStoreKeysDC();
+
+    // step 3: modify root store again
+    store.writeDataHash(storeKey, json2, SC.Record.READY_CLEAN);
+    store.dataHashDidChange(storeKey);
+
+    // Observer should fire on its own.
+    observerExpected = [storeKey];
+
+    // step 4: modify data in chained store so we have something to commit.
+    child.writeDataHash(storeKey, json3, SC.Record.READY_DIRTY);
+    child.dataHashDidChange(storeKey);
+
+    // step 5: modify data again (shouldn't fire update b/c it's the same record)
+    child.writeDataHash(storeKey, json4, SC.Record.READY_DIRTY);
+    child.dataHashDidChange(storeKey);
+
+    var storeKey2 = SC.Store.generateStoreKey();
+
+    // step 6: add data to root store
+    store.writeDataHash(storeKey2, SC.copy(json), SC.Record.READY_CLEAN);
+    store.dataHashDidChange(storeKey2);
+
+    // step 7: read data in chained store.  this will create lock
+    child.readDataHash(storeKey2);
+
+    // Run observer manually once.
+    observerObject.conflictedStoreKeysDC();
+
+    // step 8: modify root store again
+    store.writeDataHash(storeKey2, SC.copy(json2), SC.Record.READY_CLEAN);
+    store.dataHashDidChange(storeKey2);
+
+    // Observer should fire on its own.
+    observerExpected = [storeKey, storeKey2];
+
+    // step 4: modify data in chained store so we have something to commit.
+    child.writeDataHash(storeKey2, SC.copy(json3), SC.Record.READY_DIRTY);
+    child.dataHashDidChange(storeKey2);
+
+    // Observer should fire on its own.
+    observerExpected = null;
+
+    // step 6: throw away the changes, conflicted store keys should go to null.
+    child.discardChanges();
+  });
+});
+