sproutcore 1.6.0.beta.3-x86-mingw32 → 1.6.0.rc.1-x86-mingw32

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

@@ -14,8 +14,8 @@ sc_require('models/record');
 SC.ChildRecord = SC.Record.extend({});
 
 SC.ChildRecord.extend = function() {
-  //@ if (debug)
+  // @if (debug)
   console.log("SC.ChildRecord is deprecated. Please extend SC.Record instead.");
-  //@ endif
+  // @endif
   return SC.Record.extend.apply(this, arguments);
 };

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

@@ -572,6 +572,7 @@ if (SC.DateTime && !SC.RecordAttribute.transforms[SC.guidFor(SC.DateTime)]) {
     */
     to: function(str, attr) {
       if (SC.none(str) || SC.instanceOf(str, SC.DateTime)) return str;
+      if (SC.none(str) || SC.instanceOf(str, Date)) return SC.DateTime.create(str.getTime());
       var format = attr.get('format');
       return SC.DateTime.parse(str, format ? format : SC.DateTime.recordFormat);
     },

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

@@ -104,7 +104,6 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
       ret = hash[pname] = [];
     }
 
-    if (ret !== this._prevChildren) this.recordPropertyDidChange();
     return ret ;
   }.property(),
 
@@ -169,9 +168,11 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
         pname    = this.get('propertyName'),
         cr, recordType;
+    
     newRecs = this._processRecordsToHashes(recs);
     children.replace(idx, amt, newRecs);
     // notify that the record did change...
+    if (newRecs !== this._prevChildren) this.recordPropertyDidChange();
     record.recordDidChange(pname);
 
     return this;
@@ -245,7 +246,7 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
       newLen = children.get('length');
     }
 
-
+    
     this.arrayContentWillChange(0, oldLen, newLen);
     this._prevChildren = children;
     this._childrenContentDidChange(0, oldLen, newLen);

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

@@ -14,33 +14,33 @@ sc_require('models/record');
   object. When you access the items of a `RecordArray`, it will automatically
   convert the `storeKeys` into actual `SC.Record` objects that the rest of
   your application can work with.
-  
+
   Normally you do not create `RecordArray`s yourself.  Instead, a
   `RecordArray` is returned when you call `SC.Store.findAll()`, already
   properly configured. You can usually just work with the `RecordArray`
   instance just like any other array.
-  
+
   The information below about `RecordArray` internals is only intended for
   those who need to override this class for some reason to do something
   special.
-  
+
   Internal Notes
   ---
-  
+
   Normally the `RecordArray` behavior is very simple.  Any array-like
   operations will be translated into similar calls onto the underlying array
-  of `storeKeys`.  The underlying array can be a real array or it may be a 
+  of `storeKeys`.  The underlying array can be a real array or it may be a
   `SparseArray`, which is how you implement incremental loading.
-  
-  If the `RecordArray` is created with an `SC.Query` object as well (and it 
-  almost always will have a `Query` object), then the `RecordArray` will also 
-  consult the query for various delegate operations such as determining if 
+
+  If the `RecordArray` is created with an `SC.Query` object as well (and it
+  almost always will have a `Query` object), then the `RecordArray` will also
+  consult the query for various delegate operations such as determining if
   the record array should update automatically whenever records in the store
   changes. It will also ask the `Query` to refresh the `storeKeys` whenever
   records change in the store.
-  
-  If the `SC.Query` object has complex matching rules, it might be 
-  computationally heavy to match a large dataset to a query. To avoid the 
+
+  If the `SC.Query` object has complex matching rules, it might be
+  computationally heavy to match a large dataset to a query. To avoid the
   browser from ever showing a slow script timer in this scenario, the query
   matching is by default paced at 100ms. If query matching takes longer than
   100ms, it will chunk the work with setTimeout to avoid too much computation
@@ -57,12 +57,12 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /** @scope SC.RecordArray.prototype */ {
 
   /**
-    The store that owns this record array.  All record arrays must have a 
-    store to function properly. 
-    
+    The store that owns this record array.  All record arrays must have a
+    store to function properly.
+
     NOTE: You **MUST** set this property on the `RecordArray` when creating
     it or else it will fail.
-  
+
     @type SC.Store
   */
   store: null,
@@ -74,14 +74,14 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
     NOTE: You **MUST** set this property on the `RecordArray` when creating
     it or else it will fail.
-    
+
     @type SC.Query
   */
   query: null,
 
   /**
     The array of `storeKeys` as retrieved from the owner store.
-    
+
     @type SC.Array
   */
   storeKeys: null,
@@ -95,14 +95,15 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   status: SC.Record.EMPTY,
 
   /**
-    The current editabile state based on the query.
+    The current editable state based on the query. If this record array is not
+    backed by an SC.Query, it is assumed to be editable.
 
     @property
     @type Boolean
   */
   isEditable: function() {
     var query = this.get('query');
-    return query ? query.get('isEditable') : NO;
+    return query ? query.get('isEditable') : YES;
   }.property('query').cacheable(),
 
   // ..........................................................
@@ -119,6 +120,14 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     return storeKeys ? storeKeys.get('length') : 0;
   }.property('storeKeys').cacheable(),
 
+  /** @private
+    A cache of materialized records. The first time an instance of SC.Record is
+    created for a store key at a given index, it will be saved to this array.
+
+    Whenever the `storeKeys` property is reset, this cache is also reset.
+
+    @type Array
+  */
   _scra_records: null,
 
   /** @private
@@ -181,13 +190,19 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   },
 
   /** @private
-    Pass through to the underlying array.  The passed in objects must be
-    records, which can be converted to `storeKeys`.
-    
+    Replaces a range of records starting at a given index with the replacement
+    records provided. The objects to be inserted must be instances of SC.Record
+    and must have a store key assigned to them.
+
+    Note that most SC.RecordArrays are *not* editable via `replace()`, since they
+    are generated by a rule-based SC.Query. You can check the `isEditable` property
+    before attempting to modify a record array.
+
     @param {Number} idx start index
-    @param {Number} amt end index
-    @param {SC.RecordArray} recs to replace with records
-    @return {SC.RecordArray} 'this' after replace
+    @param {Number} amt count of records to remove
+    @param {SC.RecordArray} recs the records that should replace the removed records
+
+    @returns {SC.RecordArray} receiver, after mutation has occurred
   */
   replace: function(idx, amt, recs) {
 
@@ -197,13 +212,9 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
         len       = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
         i, keys;
 
-    if (!storeKeys) throw "storeKeys required";
+    if (!storeKeys) throw "Unable to edit an SC.RecordArray that does not have its storeKeys property set.";
 
-    var query = this.get('query');
-    if (query && !query.get('isEditable')) throw SC.RecordArray.NOT_EDITABLE;
-
-    // you can't modify an array whose store keys are autogenerated from a
-    // query.
+    if (!this.get('isEditable')) throw SC.RecordArray.NOT_EDITABLE;
 
     // map to store keys
     keys = [] ;
@@ -266,10 +277,10 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     return storeKeys ? storeKeys.lastIndexOf(storeKey, startAt) : -1;
   },
 
-  /** 
-    Adds the specified record to the record array if it is not already part 
+  /**
+    Adds the specified record to the record array if it is not already part
     of the array.  Provided for compatibilty with `SC.Set`.
-    
+
     @param {SC.Record} record
     @returns {SC.RecordArray} receiver
   */
@@ -282,7 +293,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /**
     Removes the specified record from the array if it is not already a part
     of the array.  Provided for compatibility with `SC.Set`.
-    
+
     @param {SC.Record} record
     @returns {SC.RecordArray} receiver
   */
@@ -324,11 +335,11 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
   /**
     Will recompute the results based on the `SC.Query` attached to the record
-    array. Useful if your query is based on computed properties that might 
+    array. Useful if your query is based on computed properties that might
     have changed. Use `refresh()` instead of you want to trigger a fetch on
     your data source since this will purely look at records already loaded
     into the store.
-    
+
     @returns {SC.RecordArray} receiver
   */
   reload: function() {
@@ -352,14 +363,14 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
   // ..........................................................
   // STORE CALLBACKS
-  // 
-  
+  //
+
   // **NOTE**: `storeWillFetchQuery()`, `storeDidFetchQuery()`,
   // `storeDidCancelQuery()`, and `storeDidErrorQuery()` are tested implicitly
   // through the related methods in `SC.Store`.  We're doing it this way
   // because eventually this particular implementation is likely to change;
   // moving some or all of this code directly into the store. -CAJ
-  
+
   /** @private
     Called whenever the store initiates a refresh of the query.  Sets the
     status of the record array to the appropriate status.
@@ -416,10 +427,13 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   },
 
   /** @private
-    Called by the store whenever it changes the state of certain store keys.
-    If the receiver cares about these changes, it will mark itself as dirty.
-    The next time you try to access the record array it will update any
-    pending changes.
+    Called by the store whenever it changes the state of certain store keys. If
+    the receiver cares about these changes, it will mark itself as dirty and add
+    the changed store keys to the _scq_changedStoreKeys index set.
+
+    The next time you try to access the record array, it will call `flush()` and
+    add the changed keys to the underlying `storeKeys` array if the new records
+    match the conditions of the record array's query.
 
     @param {SC.Array} storeKeys the effected store keys
     @param {SC.Set} recordTypes the record types for the storeKeys.
@@ -437,11 +451,8 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     changed.addEach(storeKeys);
 
     this.set('needsFlush', YES);
-
     if (this.get('storeKeys')) {
       this.flush();
-    } else {
-      this.arrayContentDidChange();
     }
 
     return this;
@@ -453,8 +464,8 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     you access the RecordArray to make sure it is up to date, but you can
     call it yourself as well if you need to force the record array to fully
     update immediately.
-    
-    Currently this method only has an effect if the query location is 
+
+    Currently this method only has an effect if the query location is
     `SC.Query.LOCAL`.  You can call this method on any `RecordArray` however,
     without an error.
 
@@ -604,7 +615,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   },
 
   /**
-    Set to `YES` when the query is dirty and needs to update its storeKeys 
+    Set to `YES` when the query is dirty and needs to update its storeKeys
     before returning any results.  `RecordArray`s always start dirty and become
     clean the first time you try to access their contents.
 
@@ -619,7 +630,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /**
     Returns `YES` whenever the status is `SC.Record.ERROR`.  This will allow
     you to put the UI into an error state.
-    
+
 		@property
     @type Boolean
   */
@@ -630,7 +641,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /**
     Returns the receiver if the record array is in an error state.  Returns
     `null` otherwise.
-    
+
 		@property
     @type SC.Record
   */
@@ -642,7 +653,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     Returns the current error object only if the record array is in an error
     state. If no explicit error object has been set, returns
     `SC.Record.GENERIC_ERROR.`
-    
+
 		@property
     @type SC.Error
   */
@@ -655,7 +666,7 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
 
   // ..........................................................
   // INTERNAL SUPPORT
-  // 
+  //
 
   propertyWillChange: function(key) {
     if (key === 'storeKeys') {

data/lib/frameworks/sproutcore/frameworks/datastore/tests/data_sources/data_source.js

@@ -0,0 +1,190 @@
+// ==========================================================================
+// Project:   SC.DataSource Unit Test
+// Copyright: ©2011 Junction Networks and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals JN module test ok equals same stop start */
+
+var MyApp, wasCalled;
+module("SC.DataSource", {
+  setup: function () {
+    MyApp = window.MyApp = {};
+    MyApp.store = SC.Store.create();
+    MyApp.Foo = SC.Record.extend();
+
+    MyApp.DataSource = SC.DataSource.extend({
+      fetch: function (store, query) {
+        wasCalled = true;
+        equals(arguments.length, 2);
+        return YES;
+      },
+
+      createRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      updateRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      retrieveRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      destroyRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      }
+    });
+    SC.RunLoop.begin();
+  },
+
+  teardown: function () {
+    SC.RunLoop.end();
+  }
+});
+
+test("The dataSource will forward calls to the appropriate methods", function () {
+  var ds = MyApp.DataSource.create();
+  MyApp.store.set('dataSource', ds);
+  ok(MyApp.store.find(SC.Query.remote(MyApp.Foo)),
+     "the fetch should return a record array");
+  ok(wasCalled, "`fetch` should have been called");
+  wasCalled = NO;
+
+  ok(MyApp.store.find(MyApp.Foo, "testing retrieve"),
+     "retrieve should return a new record (because the dataSource handled the request YES)");
+  ok(wasCalled, "`retrieve` should have been called");
+  wasCalled = NO;
+
+  var rec = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecord(MyApp.Foo, 'foo', rec.get('storeKey')), YES,
+         "commiting a new record should return YES");
+  ok(wasCalled, "`createRecord` should have been called");
+  wasCalled = NO;
+
+  MyApp.store.writeStatus(rec.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec.set('zero', 0);
+  equals(MyApp.store.commitRecord(MyApp.Foo, 'foo', rec.get('storeKey')), YES,
+         "updating a record should return YES");
+  ok(wasCalled, "`updateRecord` should have been called");
+  wasCalled = NO;
+
+  MyApp.store.writeStatus(rec.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec.destroy();
+  // broken in SC.Store
+  equals(MyApp.store.commitRecord(MyApp.Foo, 'foo', rec.get('storeKey')), YES,
+     "destroying the record should return YES");
+  ok(wasCalled, "`destroyRecord` should have been called");
+});
+
+test("The dataSource will return YES when all records committed return YES", function () {
+  var ds = MyApp.DataSource.create({
+    createRecord: function () { return YES; },
+    updateRecord: function () { return YES; },
+    destroyRecord: function () { return YES; }
+  });
+
+  MyApp.store.set('dataSource', ds);
+
+  var rec1 = MyApp.store.createRecord(MyApp.Foo, {}),
+      rec2, rec3;
+
+  equals(MyApp.store.commitRecords(), YES,
+         "commiting a single new record should return YES");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.set('zero', 0);
+  rec2 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), YES,
+         "commiting records for an 'update' and 'create' should return YES");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+  MyApp.store.writeStatus(rec2.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.destroy();
+  rec2.set('one', 1);
+  rec3 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), YES,
+         "commiting records for an 'update', 'create', and 'destroy' should return YES");
+});
+
+test("The dataSource will return SC.MIXED_STATE when all records committed return YES and NO", function () {
+  var ds = MyApp.DataSource.create({
+    createRecord: function () { return NO; },
+    updateRecord: function () { return YES; },
+    destroyRecord: function () { return NO; }
+  });
+
+  MyApp.store.set('dataSource', ds);
+
+  var rec1 = MyApp.store.createRecord(MyApp.Foo, {}),
+      rec2, rec3;
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting a single new record should return NO");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.set('zero', 0);
+  rec2 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), SC.MIXED_STATE,
+         "commiting records for an 'update' and 'create' should return %@".fmt(SC.MIXED_STATE));
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+  MyApp.store.writeStatus(rec2.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.destroy();
+  rec2.set('one', 1);
+  rec3 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), SC.MIXED_STATE,
+         "commiting records for an 'update', 'create', and 'destroy' should return %@".fmt(SC.MIXED_STATE));
+});
+
+test("The dataSource will return NO when all records committed return NO", function () {
+  var ds = MyApp.DataSource.create({
+    createRecord: function () { return NO; },
+    updateRecord: function () { return NO; },
+    destroyRecord: function () { return NO; }
+  });
+  MyApp.store.set('dataSource', ds);
+
+  var rec1 = MyApp.store.createRecord(MyApp.Foo, {}),
+      rec2, rec3;
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting a single new record should return NO");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.set('zero', 0);
+  rec2 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting records for an 'update' and 'create' should return NO");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+  MyApp.store.writeStatus(rec2.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.destroy();
+  rec2.set('one', 1);
+  rec3 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting records for an 'update', 'create', and 'destroy' should return NO");
+});