sproutcore 1.10.3.1 → 1.11.0.rc1

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

@@ -592,13 +592,13 @@ if (SC.DateTime && !SC.RecordAttribute.transforms[SC.guidFor(SC.DateTime)]) {
       Convert a String to a DateTime
     */
     to: function(str, attr) {
+      if (SC.none(str) || SC.instanceOf(str, SC.DateTime)) return str;
       if(attr.get('useUnixTime')) {
         if(SC.typeOf(str) === SC.T_STRING) { str = parseInt(str); }
         if(isNaN(str) || SC.typeOf(str) !== SC.T_NUMBER) { str = 0; }
         return SC.DateTime.create({ milliseconds: str*1000, timezone: 0 });
       }
-      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());
+      if (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

@@ -18,6 +18,20 @@
 SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /** @scope SC.ChildArray.prototype */ {
 
+  //@if(debug)
+  /* BEGIN DEBUG ONLY PROPERTIES AND METHODS */
+
+  /* @private */
+  toString: function () {
+    var propertyName = this.get('propertyName'),
+      length = this.get('length');
+
+    return "%@({  propertyName: '%@',  length: %@,  … })".fmt(sc_super(), propertyName, length);
+  },
+
+  /* END DEBUG ONLY PROPERTIES AND METHODS */
+  //@endif
+
   /**
     If set, it is the default record `recordType`
 
@@ -36,8 +50,8 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   record: null,
 
   /**
-    If set will be used by the many array to get an editable version of the
-    `storeId`s from the owner.
+    The name of the attribute in the parent record's datahash that represents
+    this child array's data.
 
     @default null
     @type String
@@ -45,38 +59,30 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   propertyName: null,
 
   /**
-    Actual references to the hashes
-
-    @default null
-    @type {SC.Array}
-  */
-  children: null,
-
-  /**
-    The store that owns this record array.  All record arrays must have a
-    store to function properly.
+    The store that owns this child array's parent record.
 
     @type SC.Store
-    @property
+    @readonly
   */
   store: function() {
     return this.getPath('record.store');
   }.property('record').cacheable(),
 
   /**
-    The storeKey for the parent record of this many array.  Editing this
-    array will place the parent record into a `READY_DIRTY state.
+    The storeKey for the parent record of this child array.
 
     @type Number
-    @property
+    @readonly
   */
   storeKey: function() {
     return this.getPath('record.storeKey');
   }.property('record').cacheable(),
 
   /**
-    Returns the storeIds in read only mode.  Avoids modifying the record
-    unnecessarily.
+    Returns the original child array of JavaScript Objects.
+
+    Note: Avoid modifying this array directly, because changes will not be
+    reflected by this SC.ChildArray.
 
     @type SC.Array
     @property
@@ -86,8 +92,9 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   }.property(),
 
   /**
-    Returns an editable array of child hashes.  Marks the owner records as
-    modified.
+    Returns an editable child array of JavaScript Objects.
+
+    Any changes to this array will not affect the parent record's datahash.
 
     @type {SC.Array}
     @property
@@ -127,18 +134,18 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     records.
 
     @param {Number} idx index of the object to retrieve.
-    @returns {SC.Record} The record if found or undefined.
+    @returns {SC.Record} The nested record if found or undefined if not.
   */
   objectAt: function(idx) {
     var recs      = this._records,
         children = this.get('readOnlyChildren'),
-        hash, ret, pname = this.get('propertyName'),
-        parent = this.get('record');
-    var len = children ? children.length : 0;
+      hash, ret,
+      pname = this.get('propertyName'),
+      parent = this.get('record'),
+      len = children ? children.length : 0;
 
     if (!children) return undefined; // nothing to do
     if (recs && (ret=recs[idx])) return ret ; // cached
-    if (!recs) this._records = recs = [] ; // create cache
 
     // If not a good index return undefined
     if (idx >= len) return undefined;
@@ -146,67 +153,146 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     if (!hash) return undefined;
 
     // not in cache, materialize
+    if (!recs) this._records = recs = []; // create cache
     recs[idx] = ret = parent.registerNestedRecord(hash, pname, pname+'.'+idx);
 
     return ret;
   },
 
   /**
-    Pass through to the underlying array.  The passed in objects must be
-    records, which can be converted to `storeId`s.
+    Pass through to the underlying array.  The passed in objects should be
+    nested SC.Records, which can be converted to JavaScript objects or
+    JavaScript objects themselves.
 
     @param {Number} idx index of the object to replace.
-    @param {Number} amt number of records to replace starting at idx.
-    @param {Number} recs array with records to replace.
-    @returns {SC.Record} The record if found or undefined.
-
+    @param {Number} amt number of objects to replace starting at idx.
+    @param {Number} recs array with records to replace. These may be JavaScript objects or nested SC.Record objects.
+    @returns {SC.ChildArray}
   */
   replace: function(idx, amt, recs) {
     var children = this.get('editableChildren'),
-        len      = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
-        record   = this.get('record'), newRecs,
+      recsLen = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
+      parent = this.get('record'),
+      pname    = this.get('propertyName'),
+      store = this.get('store'),
+      removeCount, addCount,
+      defaultRecordType, storeKeysById,
+      newObjects, rec,
+      i, len;
+
+    // Create the proxy cache, we will need it.
+    if (!this._records) this._records = [];
+
+    // Convert any SC.Record objects into JavaScript objects.
+    newObjects = this._processRecordsToHashes(recs);
+
+    // Unregister the records being replaced.
+    // for (i = idx, len = children.length; i < len; ++i) {
+    //  this.unregisterNestedRecord(i);
+    // }
+
+    // Ensure that all removed objects are pre-registered in case any instances are outstanding.
+    // These objects will improperly reflect being registered to this parent, but
+    // at least they won't conflict with the actual associated records once we
+    // disassociate them from the record type.
+    defaultRecordType = this.get('defaultRecordType');
+    storeKeysById = defaultRecordType.storeKeysById();
+
+    for (i = idx, len = idx + amt; i < len; i++) {
+      rec = this._records[i];
+
+      if (!rec) {
+        rec = parent.registerNestedRecord(children[i], pname, pname + '.' + i);
+      } else {
+        // Remove the cached record.
+        this._records[i] = null;
+      }
 
-        pname    = this.get('propertyName'),
-        cr, recordType;
-    
-    newRecs = this._processRecordsToHashes(recs);
-    // notify that the record did change...
-    if (newRecs !== this._prevChildren){
-      this._performRecordPropertyChange(null, false);
-    } 
-    children.replace(idx, amt, newRecs);
-    record.recordDidChange(pname);
+      // Now throw away the connection, so that the parent won't retrieve this
+      // same instance. This is a work-around due to the fact that nested records
+      // are proxied through their parent records.
+      storeKeysById[rec.get('id')] = null;
+    }
+
+    // All materialized nested records after idx + amt to end need to be removed
+    // because the paths will no longer be valid.
+    for (i = idx + amt, len = this._records.length; i < len; i++) {
+      rec = this._records[i];
+
+      if (rec) {
+        store.unregisterChildFromParent(rec.get('storeKey'));
+
+        this._records[i] = null;
+      }
+    }
+
+    // All objects from idx to the end must be removed to do an insert.
+    removeCount = children.length - idx;
+    addCount = children.length - idx - amt + recsLen;
+
+    this.arrayContentWillChange(idx, removeCount, addCount);
+
+    // Perform a raw array replace without any KVO checks.
+    if (newObjects.length === 0) {
+      children.splice(idx, amt);
+    } else {
+      var args = [idx, amt].concat(newObjects);
+      children.splice.apply(children, args);
+    }
+
+    // All current SC.Record instances must be updated to their new backing object.
+    // For example, when passing an SC.Record object in, that instance should
+    // update to reflect its new nested object path.
+    for (i = idx, len = children.length; i < len; i++) {
+      this._records[i] = parent.registerNestedRecord(children[i], pname, pname + '.' + i);
+    }
+
+    // Update the enumerable, [], property (including firstObject and lastObject)
+    this.arrayContentDidChange(idx, removeCount, addCount);
+
+    // Update our cache! So when the record property change comes back down we can ignore it.
+    this._sc_prevChildren = children;
+
+    // We must indicate to the parent that we have been modified, so they can
+    // update their status.
+    parent.recordDidChange(pname);
 
     return this;
   },
 
-  /** @private
+  /**
+    Unregisters a child record from its parent record.
 
-    Converts a records array into an array of hashes.
+    Since accessing a child (nested) record creates a new data hash for the
+    child and caches the child record and its relationship to the parent record,
+    it's important to clear those caches when the child record is overwritten
+    or removed.  This function tells the store to remove the child record from
+    the store's various child record caches.
 
-    @param {SC.Array} recs records to be converted to hashes.
-    @returns {SC.Array} array of hashes.
-  */
-  _processRecordsToHashes: function(recs){
-    var store, sk;
-    recs = recs || [];
-    recs.forEach( function(me, idx){
-      if (me.isNestedRecord){
-        store = me.get('store');
-        sk = me.storeKey;
-        recs[idx] = store.readDataHash(sk);
-      }
-    });
+    You should not need to call this function directly.  Simply setting the
+    child record property on the parent to a different value will cause the
+    previous child record to be unregistered.
 
-    return recs;
-  },
+    @param {Number} idx The index of the child record.
+  */
+  // unregisterNestedRecord: function(idx) {
+  //   var childArray, childRecord, csk, store,
+  //       record   = this.get('record'),
+  //       pname    = this.get('propertyName');
+  //
+  //   store = record.get('store');
+  //   childArray = record.getPath(pname);
+  //   childRecord = childArray.objectAt(idx);
+  //   csk = childRecord.get('storeKey');
+  //   store.unregisterChildFromParent(csk);
+  // },
 
   /**
     Calls normalize on each object in the array
   */
   normalize: function(){
-    this.forEach(function(child,id){
-      if(child.normalize) child.normalize();
+    this.forEach(function (rec) {
+      if (rec.normalize) rec.normalize();
     });
   },
 
@@ -214,83 +300,71 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   // INTERNAL SUPPORT
   //
 
-  /**
-    Invoked whenever the children array changes.  Observes changes.
+  /** @private Converts any SC.Records in the array into an array of hashes.
 
-    @param {SC.Array} keys optional
-    @returns {SC.ChildArray} itself.
-  */
-  recordPropertyDidChange: function(keys) {
-    this._performRecordPropertyChange(keys, true);
-    return this;
-  },
-  
-  /** @private
-    Invoked when the object is changed from the parent or an outside source
-    
-    will cause the entire array to reset
-    
-    @param {SC.Array} keys optional
-    @param {Boolean} doReset optional
-    @returns {SC.ChildArray} itself.
+    @param {SC.Array} recs records to be converted to hashes.
+    @returns {SC.Array} array of hashes.
   */
-  _performRecordPropertyChange: function(keys, doReset){
-    if (keys && !keys.contains(this.get('propertyName'))) return this;
-
-    var children = this.get('readOnlyChildren'), oldLen = 0, newLen = 0;
-    var prev = this._prevChildren, f = this._childrenContentDidChange;
-    doReset = SC.none(doReset) ? true : doReset;
-
-    if (children === prev) return this; // nothing to do
-
-    if (prev) {
-      prev.removeArrayObservers({
-        target: this,
-        willChange: this.arrayContentWillChange,
-        didChange: f
-      });
-
-      oldLen = prev.get('length');
-    }
-
-    if (children) {
-      children.addArrayObservers({
-        target: this,
-        willChange: this.arrayContentWillChange,
-        didChange: f
-      });
-
-      newLen = children.get('length');
-    }
-    this._prevChildren = children;
-    
-    if (doReset){
-      this.arrayContentWillChange(0, oldLen, newLen);
-      this._childrenContentDidChange(0, oldLen, newLen);      
-    }
+  _processRecordsToHashes: function (recs) {
+    var store, sk,
+      ret = [];
+
+    recs.forEach(function (rec, idx) {
+      if (rec.isNestedRecord) {
+        store = rec.get('store');
+        sk = rec.storeKey;
+        ret[idx] = store.readDataHash(sk);
+      } else {
+        ret[idx] = rec;
+      }
+    });
 
-    return this;
+    return ret;
   },
 
   /** @private
-    Invoked whenever the content of the children array changes.  This will
-    dump any cached record lookup and then notify that the enumerable content
-    has changed.
-
-    @param {Number} target
-    @param {Number} key
-    @param {Number} value
-    @param {Number} rev
+    This is called by the parent record whenever its properties change. It is
+    also called by the ChildrenAttribute transform when the attribute is set
+    to a new array.
   */
-  _childrenContentDidChange: function(start, removedCount, addedCount) {
-    this._records = null ; // clear cache
-    this.arrayContentDidChange(start, removedCount, addedCount);
-  },
-
-  /** @private */
-  init: function() {
-    sc_super();
-    this.recordPropertyDidChange();
+  recordPropertyDidChange: function (keys) {
+    var oldLength = this.get('length'),
+      children = this.get('readOnlyChildren'),
+      newLength = children ? children.length : 0,
+      // store = this.get('store'),
+      prevChildren = this._sc_prevChildren;
+
+    // Fast Path! No actual change to our backing array attribute so we should
+    // not notify any changes.
+    if (prevChildren === children) { return; }
+
+    // TODO: We can not use this, because removed instances will lose their
+    // connection to their data hashes in the store. There is an ugly hack in
+    // SC.Store#writeDataHash which can't handle this.
+    // All materialized nested records need to be removed. They are no longer valid!
+    // if (this._records) {
+    //   for (var i = 0, len = this._records.length; i < len; i++) {
+    //     var rec = this._records[i];
+
+    //     // Unregister the nested record.
+    //     if (rec) {
+    //       store.unregisterChildFromParent(rec.get('storeKey'));
+    //     }
+    //   }
+
+    //   // Throw away our cache.
+    //   this._records.length = 0;
+    // }
+
+    // Throw away our cache.
+    this._records = null;
+
+    // this.arrayContentWillChange(0, oldLength, newLength);
+    this.arrayContentDidChange(0, oldLength, newLength);
+
+    // Cache our backing array so we can avoid updates when we haven't actually
+    // changed. See fast path above.
+    this._sc_prevChildren = children;
   }
 
 }) ;