sproutcore 1.0.1046 → 1.0.1049.pre.1

data/frameworks/sproutcore/frameworks/datastore/models/children_attribute.js

@@ -0,0 +1,81 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2010 Evin Grano
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('models/record');
+sc_require('models/record_attribute');
+sc_require('models/child_attribute');
+
+/** @class
+  
+  ChildrenAttribute is a subclass of ChildAttribute and handles to-many 
+  relationships for child records
+  
+  When setting ( .set() ) the value of a toMany attribute, make sure
+  to pass in an array of SC.Record objects.
+  
+  There are many ways you can configure a ChildrenAttribute:
+  
+  {{{
+    contacts: SC.ChildrenAttribute.attr('SC.Child');
+  }}}
+  
+  @extends SC.RecordAttribute
+  @since SproutCore 1.0
+*/
+SC.ChildrenAttribute = SC.ChildAttribute.extend(
+  /** @scope SC.ChildrenAttribute.prototype */ {
+    
+  // ..........................................................
+  // LOW-LEVEL METHODS
+  //
+  
+  /**  @private - adapted for to many relationship */
+  toType: function(record, key, value) {
+    var attrKey   = this.get('key') || key,
+        arrayKey  = SC.keyFor('__kidsArray__', SC.guidFor(this)),
+        ret       = record[arrayKey],
+        recordType  = this.get('typeClass'), rel;
+
+    // lazily create a ManyArray one time.  after that always return the 
+    // same object.
+    if (!ret) {
+      ret = SC.ChildArray.create({ 
+        record:         record,
+        propertyName:   attrKey,
+        defaultRecordType: recordType
+      });
+
+      record[arrayKey] = this._cachedRef = ret ; // save on record
+      rel = record.get('relationships');
+      if (!rel) record.set('relationships', rel = []);
+      rel.push(ret); // make sure we get notified of changes...
+    }
+
+    return ret;
+  },
+      
+  orphan: function(parentRecord){
+    var cArray = this._cachedRef,
+        store, storeKey, attrs, key, 
+        len, param, cr;
+    
+    if (cArray) {
+      cArray.forEach( function(cr){
+        attrs = cr.get('readOnlyAttributes');
+        for(key in attrs) {
+          param = cr[key];
+          // Orphan all the child record and child records in a tree to clean up the store
+          if(param && param.isChildRecordTransform) param.orphan(parentRecord);
+        }
+        store = cr.get('store');
+        if(store) storeKey = cr.storeKey;
+        if(storeKey) store.unloadRecord(undefined, undefined, storeKey);
+      }, this);
+    }
+  }
+});
+
+

data/frameworks/sproutcore/frameworks/datastore/models/fetched_attribute.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('models/record');

data/frameworks/sproutcore/frameworks/datastore/models/many_attribute.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 sc_require('models/record');

data/frameworks/sproutcore/frameworks/datastore/models/record.js

@@ -2,7 +2,7 @@
 // Project:   SproutCore - JavaScript Application Framework
 // Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
 //            Portions ©2008-2009 Apple Inc. All rights reserved.
-// License:   Licened under MIT license (see license.js)
+// License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
 /**
@@ -182,7 +182,35 @@ SC.Record = SC.Object.extend(
         storeKey = this.storeKey;
     return store.readEditableDataHash(storeKey);
   }.property(),
+
+  /**
+    This will return the raw attributes that you cannot edit directly.  It is
+    useful if you want to efficiently look at multiple attributes in bulk.  If
+    you would like to edit the attributes, see the @attributes@ property
+    instead.
+  
+    @property {Hash}
+  **/
+  readOnlyAttributes: function() {
+    var store    = this.get('store'), 
+        storeKey = this.storeKey,
+        ret      = store.readDataHash(storeKey);
     
+    if (ret) ret = SC.clone(ret);
+
+    return ret;
+  }.property(),
+  
+  /**
+   * The child record cache.
+   */
+  childRecords: null,
+  
+  /**
+   * The namespace which to retrieve the childRecord Types from
+   */
+  childRecordNamespace: null,
+      
   // ...............................
   // CRUD OPERATIONS
   //
@@ -210,7 +238,12 @@ SC.Record = SC.Object.extend(
   */
   destroy: function() { 
     this.get('store').destroyRecord(null, null, this.get('storeKey'));
-    this.propertyDidChange('status');
+    this.notifyPropertyChange('status');
+
+    // If there are any aggregate records, we might need to propagate our new
+    // status to them.
+    this.propagateToAggregates();
+
     return this ;
   },
 
@@ -231,6 +264,11 @@ SC.Record = SC.Object.extend(
   recordDidChange: function(key) {
     this.get('store').recordDidChange(null, null, this.get('storeKey'), key);
     this.notifyPropertyChange('status');
+
+    // If there are any aggregate records, we might need to propagate our new
+    // status to them.
+    this.propagateToAggregates();
+
     return this ;
   },
   
@@ -304,8 +342,6 @@ SC.Record = SC.Object.extend(
     var store    = this.get('store'), 
         storeKey = this.storeKey,
         status   = store.peekStatus(storeKey),
-        recordAttr = this[key],
-        recordType = SC.Store.recordTypeFor(storeKey),
         attrs;
     
     attrs = store.readEditableDataHash(storeKey);
@@ -325,12 +361,6 @@ SC.Record = SC.Object.extend(
       
       if(!ignoreDidChange) this.endEditing(key);
     }
-    
-    // if any aggregates, propagate the state
-    if(!recordType.aggregates || recordType.aggregates.length>0) {
-      this.propagateToAggregates();
-    }
-    
     return this ;  
   },
   
@@ -352,7 +382,7 @@ SC.Record = SC.Object.extend(
     if (!aggregates) {
       var dataHash = this.get('store').readDataHash(storeKey);
       aggregates = [];
-      for(k in dataHash) {
+      for(var k in dataHash) {
         if(this[k] && this[k].get && this[k].get('aggregate')===YES) {
           aggregates.push(k);
         }
@@ -362,30 +392,40 @@ SC.Record = SC.Object.extend(
     
     // now loop through all aggregate properties and mark their related
     // record objects as dirty
-    var K = SC.Record;
+    var K          = SC.Record,
+        dirty      = K.DIRTY,
+        readyNew   = K.READY_NEW,
+        destroyed  = K.DESTROYED,
+        readyClean = K.READY_CLEAN,
+        iter;
+        
+    // If the child is dirty, then make sure the parent gets a dirty
+    // status.  (If the child is created or destroyed, there's no need,
+    // because the parent will dirty itself when it modifies that
+    // relationship.)
+    iter =  function(rec) {
+      var childStatus, parentStatus;
+      
+      if (rec) { 
+        childStatus = this.get('status');
+        if ((childStatus & dirty)  ||  
+            (childStatus & readyNew)  ||  (childStatus & destroyed)) {
+          parentStatus = rec.get('status');
+          if (parentStatus === readyClean) {
+            // Note:  storeDidChangeProperties() won't put it in the
+            //        changelog!
+            rec.get('store').recordDidChange(rec.constructor, null, rec.get('storeKey'), null, YES);
+          }
+        }
+      }
+    };
+        
     for(idx=0,len=aggregates.length;idx<len;++idx) {
       key = aggregates[idx];
       val = this.get(key);
       recs = SC.kindOf(val, SC.ManyArray) ? val : [val];
-      recs.forEach(function(rec) {
-        // If the child is dirty, then make sure the parent gets a dirty
-        // status.  (If the child is created or destroyed, there's no need,
-        // because the parent will dirty itself when it modifies that
-        // relationship.)
-        if (rec) { 
-          var childStatus = this.get('status');
-          if (childStatus & K.DIRTY) {
-            var parentStatus = rec.get('status');
-            if (parentStatus === K.READY_CLEAN) {
-              // Note:  storeDidChangeProperties() won't put it in the
-              //        changelog!
-              rec.get('store').recordDidChange(rec.constructor, null, rec.get('storeKey'), null, YES);
-            }
-          }
-        }
-      }, this);
+      recs.forEach(iter, this);
     }
-    
   },
   
   /**
@@ -398,6 +438,8 @@ SC.Record = SC.Object.extend(
     @returns {SC.Record} receiver
   */
   storeDidChangeProperties: function(statusOnly, keys) {
+    // TODO:  Should this function call propagateToAggregates() at the
+    //        appropriate times?
     if (statusOnly) this.notifyPropertyChange('status');
     else {      
       if (keys) {
@@ -405,7 +447,7 @@ SC.Record = SC.Object.extend(
         keys.forEach(function(k) { this.notifyPropertyChange(k); }, this);
         this.notifyPropertyChange('status'); 
         this.endPropertyChanges();
-        
+
       } else this.allPropertiesDidChange(); 
     
       // also notify manyArrays
@@ -435,56 +477,68 @@ SC.Record = SC.Object.extend(
     @returns {SC.Record} the normalized record
   */
   
-  normalize: function(includeNull) {
-    
+  normalize: function(includeNull) {    
     var primaryKey = this.primaryKey, 
-        dataHash   = {}, 
         recordId   = this.get('id'), 
         store      = this.get('store'), 
         storeKey   = this.get('storeKey'), 
-        recHash, attrValue, isRecord, defaultVal;
-    
+        key, valueForKey, typeClass, recHash, attrValue, normChild,  isRecord,
+        isChild, defaultVal, keyForDataHash;
+      
+    var dataHash = store.readEditableDataHash(storeKey) || {};
     dataHash[primaryKey] = recordId;
+    recHash = store.readDataHash(storeKey);
     
-    for(var key in this) {
+    for (key in this) {
       // make sure property is a record attribute.
-      if(this[key] && this[key]['typeClass']) {
-        
-        isRecord = SC.typeOf(this[key].typeClass())==='class';
+      valueForKey = this[key];
+      if (valueForKey) {
+        typeClass = valueForKey.typeClass;
+        if (typeClass) {
+          keyForDataHash = valueForKey.get('key') || key; // handle alt keys
+          isRecord = SC.typeOf(typeClass.call(valueForKey))===SC.T_CLASS;
+          isChild  = valueForKey.isChildRecordTransform;
+          if (!isRecord && !isChild) {
+            attrValue = this.get(key);
 
-        if (!isRecord) {
-          attrValue = this.get(key);
-          if(attrValue!==undefined || (attrValue===null && includeNull)) {
-            dataHash[key] = attrValue;
-          }
-        }
-        else if(isRecord) {
-          recHash = store.readDataHash(storeKey);
-
-          if(recHash[key]!==undefined) {
-            // write value already there
-            dataHash[key] = recHash[key];
-
-          // or write default
-          } else {
-            defaultVal = this[key].get('defaultValue');
-
-            // computed default value
-            if (SC.typeOf(defaultVal)===SC.T_FUNCTION) {
-              dataHash[key] = defaultVal(this, key, defaultVal);
-            
-            // plain value
+            if(attrValue!==undefined || (attrValue===null && includeNull)) {
+              dataHash[keyForDataHash] = attrValue;
+            }
+          
+          } else if (isChild) {
+            attrValue = this.get(key);
+
+            // Sometimes a child attribute property does not refer to a child record.
+            // Catch this and don't try to normalize.
+            if (attrValue && attrValue.normalize) {
+              attrValue.normalize();
+            }
+          } else if (isRecord) {
+            attrValue = recHash[key];
+            if (attrValue !== undefined) {
+              // write value already there
+              dataHash[keyForDataHash] = attrValue;
             } else {
-              dataHash[key] = defaultVal;
+              // or write default
+              defaultVal = valueForKey.get('defaultValue');
+
+              // computed default value
+              if (SC.typeOf(defaultVal)===SC.T_FUNCTION) {
+                dataHash[keyForDataHash] = defaultVal(this, key, defaultVal);
+              } else {
+                // plain value                
+                dataHash[keyForDataHash] = defaultVal;
+              }
             }
           }
         }
       }
     }
-    
-    store.writeDataHash(storeKey, dataHash);
-    return store.materializeRecord(storeKey);
+
+    return this;
   },
+
+  
   
   /**
     If you try to get/set a property not defined by the record, then this 
@@ -590,7 +644,9 @@ SC.Record = SC.Object.extend(
   */
   
   toString: function() {
-    var attrs = this.get('attributes');
+    // We won't use 'readOnlyAttributes' here because accessing them directly
+    // avoids a SC.clone() -- we'll be careful not to edit anything.
+    var attrs = this.get('store').readDataHash(this.get('storeKey'));
     return "%@(%@) %@".fmt(this.constructor.toString(), SC.inspect(attrs), this.statusString());
   },
   
@@ -610,8 +666,75 @@ SC.Record = SC.Object.extend(
     }
     
     return ret.join(" ");
-  }
-      
+  },
+  
+  /**
+   * Registers a child record with this parent record.
+   *
+   * If the parent already knows about the child record, return the cached instance.  If not,
+   * create the child record instance and add it to the child record cache.
+   *
+   * @param {CoreOrion.ChildRecord} recordType The type of the child record to register.
+   * @param {Hash} hash The hash of attributes to apply to the child record.
+   */
+  registerChildRecord: function(recordType, hash) {
+    var pm = recordType.primaryKey || 'childRecordKey';
+    var childKey = hash[pm];
+    var childRecord = null;
+    var crManager = this.get('childRecords');
+    if (childKey && crManager) {
+      childRecord = crManager[childKey];
+    }
+
+    if (SC.none(childRecord)) childRecord = this.createChildRecord(recordType, hash);
+ 
+    return childRecord;
+  },
+  
+  /**
+   * Creates a new child record instance.
+   *
+   * @param {CoreOrion.ChildRecord} recordType The type of the child record to create.
+   * @param {Hash} hash The hash of attributes to apply to the child record. (may be null)
+   */
+  createChildRecord: function(childRecordType, hash) {
+    SC.RunLoop.begin();
+    // Generate the key used by the parent's child record manager.
+    var key = SC.Record._generateChildKey();
+    hash = hash || {}; // init if needed
+    var pm = childRecordType.primaryKey || 'childRecordKey';
+    var childKey = hash[pm];
+    hash[pm] = key;
+    
+    var store = this.get('store');
+    if (SC.none(store)) throw 'Error: during the creation of a child record: NO STORE ON PARENT!';
+    
+    var cr = store.createRecord(childRecordType, hash);
+    cr._parentRecord = this;
+    
+    // ID processing if necessary
+    if(this.generateIdForChild) this.generateIdForChild(cr);
+    
+    // Add the child record to the hash.
+    var crManager = this.get('childRecords');
+    if (SC.none(crManager)) {
+      //console.log('Creating Child Record Manager for (%@)'.fmt(SC.guidFor(this)));
+      crManager = SC.Object.create();
+      this.set('childRecords', crManager);
+    }
+    
+    crManager[key] = cr;
+    SC.RunLoop.end();
+    
+    return cr;
+  },
+  
+  /**
+   * Override this function if you want to have a special way of creating 
+   * ids for your child records
+   */
+  generateIdForChild: function(childRecord){}
+     
 }) ;
 
 // Class Methods
@@ -856,6 +979,11 @@ SC.Record.mixin( /** @scope SC.Record */ {
   */
   GENERIC_ERROR:       SC.$error("Generic Error"),
   
+  /**
+   * The next child key to allocate.  A nextChildKey must always be greater than 0.
+   */
+  _nextChildKey: 0,
+  
   // ..........................................................
   // CLASS METHODS
   // 
@@ -908,35 +1036,63 @@ SC.Record.mixin( /** @scope SC.Record */ {
   },
   
   /**
-    Returns an SC.ManyAttribute that describes a record array backed by an 
-    array of guids stored in the underlying JSON.  You can edit the contents
-    of this relationship.
+    Returns:
     
-    If you set the inverse and isMaster: NO key, then editing this array will
-    modify the underlying data, but the inverse key on the matching record
-    will also be edited and that record will be marked as needing a change.
+    1: SC.ManyAttribute that describes a record array backed by an 
+    array of guids stored in the underlying JSON.  
+    2: SC.ChildrenAttribute that describes a record array backed by a
+    array of hashes.
+    
+    You can edit the contents of this relationship.
+    
+    For SC.ManyAttribute, If you set the inverse and isMaster: NO key, 
+    then editing this array will modify the underlying data, but the 
+    inverse key on the matching record will also be edited and that 
+    record will be marked as needing a change.
     
     @param {SC.Record|String} recordType The type of record to create
     @param {Hash} opts the options for the attribute
-    @returns {SC.ManyAttribute} created instance
+    @returns {SC.ManyAttribute|SC.ChildrenAttribute} created instance
   */
   toMany: function(recordType, opts) {
-    return SC.ManyAttribute.attr(recordType, opts);
+    opts = opts || {};
+    var isNested = opts.nested;
+    var attr;
+    if(isNested){
+      attr = SC.ChildrenAttribute.attr(recordType, opts);
+    }
+    else {
+      attr = SC.ManyAttribute.attr(recordType, opts);
+    }
+    return attr;
   },
   
   /**
-    Returns a SC.SingleAttribute that converts the underlying ID to a single
+    Returns:
+    1. SC.SingleAttribute that converts the underlying ID to a single
     record.  If you modify this property, it will rewrite the underyling ID. 
     It will also modify the inverse of the relationship, if you set it.
     
+    2. SC.ChildAttribute that you can edit the contents
+    of this relationship.
+    
     @param {SC.Record|String} recordType the type of the record to create
     @param {Hash} opts additional options
-    @returns {SC.SingleAttribute} created instance
+    @returns {SC.SingleAttribute|SC.ChildAttribute} created instance
   */
   toOne: function(recordType, opts) {
-    return SC.SingleAttribute.attr(recordType, opts);
+    opts = opts || {};
+    var isNested = opts.nested;
+    var attr;
+    if(isNested){
+      attr = SC.ChildAttribute.attr(recordType, opts);
+    }
+    else {
+      attr = SC.SingleAttribute.attr(recordType, opts);
+    }
+    return attr;
   },
-    
+  
   /**
     Returns all storeKeys mapped by Id for this record type.  This method is
     used mostly by the SC.Store and the Record to coordinate.  You will rarely
@@ -1007,6 +1163,15 @@ SC.Record.mixin( /** @scope SC.Record */ {
     var ret = SC.Object.extend.apply(this, arguments);
     SC.Query._scq_didDefineRecordType(ret);
     return ret ;
-  }
+  },
   
+  // ..........................................................
+  // PRIVATE METHODS
+  // 
+  
+  _generateChildKey: function() {
+    var newIdx = SC.Record._nextChildKey + 1;
+    SC.Record._nextChildKey = newIdx;
+    return newIdx; 
+  }
 }) ;