sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -9,30 +9,46 @@ sc_require('models/record');
 sc_require('models/record_attribute');
 
 /** @class
-
-  TODO: Describe
+  
+  ManyAttribute is a subclass of RecordAttribute and handles to-many 
+  relationships.
+  
+  When setting ( .set() ) the value of a toMany attribute, make sure
+  to pass in an array of SC.Record objects.
   
   @extends SC.RecordAttribute
   @since SproutCore 1.0
 */
 SC.ManyAttribute = SC.RecordAttribute.extend(
-  /** @scipe SC.ManyAttribute.prototype */ {
+  /** @scope SC.ManyAttribute.prototype */ {
   
   // ..........................................................
   // LOW-LEVEL METHODS
-  // 
+  //
   
   /**  @private - adapted for to many relationship */
   toType: function(record, key, value) {
-    // TODO: Implement ManyAttribute
-    return value ;
+    var transform = this.get('transform'),
+        type      = this.get('typeClass'),
+        store     = record.get('store');
+        
+    if (transform && transform.to) {
+      return SC.ManyArray.create({ store: store, storeIds: value, recordType: type });
+    }
   },
-
+  
   /** @private - adapted for to many relationship */
   fromType: function(record, key, value) {
-    // TODO: Implement ManyAttribute
-    return value;
+    var ret = [];
+    
+    if(!SC.isArray(value)) throw "Expects toMany attribute to be an array";
+    
+    var len = value.get('length');
+    for(var i=0;i<len;i++) {
+      ret[i] = value.objectAt(i).get('id');
+    }
+    
+    return ret;
   }
   
-}) ;
-
+});

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

@@ -17,7 +17,7 @@
   {{{
     $ sc-gen model MyApp.MyModel
   }}}
-
+  
   This will create MyApp.MyModel in clients/my_app/models/my_model.js.
   
   The core attributes hash is used to store the values of a record in a 
@@ -199,22 +199,28 @@ SC.Record = SC.Object.extend(
   
     @param {String} key the attribute you want to read
     @param {Object} value the attribute you want to read
+    @param {Boolean} ignoreDidChange only set if you do NOT want to flag 
+      record as dirty
     @returns {SC.Record} receiver
   **/
-  writeAttribute: function(key, value) {
-    this.beginEditing();
+  writeAttribute: function(key, value, ignoreDidChange) {
+    if(!ignoreDidChange) this.beginEditing();
     var store = this.get('store'), storeKey = this.storeKey;
     var attrs = store.readEditableDataHash(storeKey);
     if (!attrs) throw SC.Record.BAD_STATE_ERROR;
     attrs[key] = value;
-    this.endEditing();
+    // if value is primaryKey of record, write it to idsByStoreKey
+    if(key===this.get('primaryKey')) {
+      SC.Store.idsByStoreKey[storeKey] = attrs[key] ;
+    }
+    if(!ignoreDidChange) this.endEditing();
     return this ;  
   },
   
   /**
     This will return the raw attributes that you can edit directly.  If you 
     make changes to this hash, be sure to call beginEditing() before you get
-    the attributes and endEditing() aftwards.
+    the attributes and endEditing() afterwards.
   
     @returns {Object} the current attributes of the receiver
   **/
@@ -238,6 +244,76 @@ SC.Record = SC.Object.extend(
     }
   },
   
+  /**
+    Normalizing a record will ensure that the underlying hash conforms
+    to the record attributes such as their types (transforms) and default 
+    values. 
+    
+    This method will write the conforming hash to the store and return
+    the materialized record.
+    
+    By normalizing the record, you can use .attributes() and be
+    assured that it will conform to the defined model. For example, this
+    can be useful in the case where you need to send a JSON representation
+    to some server after you have used .createRecord(), since this method
+    will enforce the 'rules' in the model such as their types and default
+    values. You can also include null values in the hash with the 
+    includeNull argument.
+    
+    @param {Boolean} includeNull will write empty (null) attributes
+    @returns {SC.Record} the normalized record
+  */
+  
+  normalize: function(includeNull) {
+    
+    var primaryKey = this.primaryKey, dataHash = {}, recordId = this.get('id'), 
+      recHash, store = this.get('store'), storeKey = this.get('storeKey'), 
+      attrValue, isRecord, defaultVal;
+    
+    dataHash[primaryKey] = recordId;
+    
+    for(var key in this) {
+      // make sure property is a record attribute.
+      if(this[key] && this[key]['typeClass']) {
+        
+        isRecord = SC.typeOf(this[key].typeClass())==='class';
+
+        if (!isRecord) {
+          attrValue = this.get(key);
+          if(attrValue || includeNull) dataHash[key] = attrValue;
+        }
+        else if(isRecord) {
+          recHash = store.readDataHash(storeKey);
+
+          if(recHash[key]) {
+            // write value already there
+            dataHash[key] = recHash[key];
+          }
+          else {
+            // or write default
+            defaultVal = this[key].get('defaultValue');
+            if(SC.typeOf(defaultVal)===SC.T_FUNCTION) {
+              // computed default value
+              dataHash[key] = defaultVal();
+            }
+            else {
+              // plain value
+              dataHash[key] = defaultVal;
+            }
+          }
+        }
+        
+        if(includeNull && dataHash[key]===undefined) {
+          dataHash[key] = null;
+        }
+        
+      }
+    }
+    
+    store.writeDataHash(storeKey, dataHash);
+    return store.materializeRecord(storeKey);
+  },
+  
   /**
     If you try to get/set a property not defined by the record, then this 
     method will be called. It will try to get the value from the set of 
@@ -269,9 +345,33 @@ SC.Record = SC.Object.extend(
   // PRIVATE
   //
   
+  /** @private
+    Creates string representation of record, with status.
+    
+    @returns {String}
+  */
+  
   toString: function() {
     var attrs = this.get('attributes');
-    return "%@(%@)".fmt(this.constructor.toString(), SC.inspect(attrs));
+    return "%@(%@) %@".fmt(this.constructor.toString(), SC.inspect(attrs), this.statusString());
+  },
+  
+  /** @private
+    Creates string representation of record, with status.
+    
+    @returns {String}
+  */
+  
+  statusString: function() {
+    var ret = [], status = this.get('status');
+    
+    for(prop in SC.Record) {
+      if(prop.match(/[A-Z_]$/) && SC.Record[prop]===status) {
+        ret.push(prop);
+      }
+    }
+    
+    return ret.join(" ");
   }
       
 }) ;
@@ -280,29 +380,29 @@ SC.Record = SC.Object.extend(
 SC.Record.mixin( /** @scope SC.Record */ {
 
   // Record States
-  CLEAN:            0x0001,
-  DIRTY:            0x0002,
-
-  EMPTY:            0x0100,
-  ERROR:            0x1000,
-
-  READY:            0x0200,
-  READY_CLEAN:      0x0201,
-  READY_DIRTY:      0x0202,
-  READY_NEW:        0x0203,
-
-  DESTROYED:        0x0400,
-  DESTROYED_CLEAN:  0x0401,
-  DESTROYED_DIRTY:  0x0402,
-
-  BUSY:             0x0800,
-  BUSY_LOADING:     0x0804,
-  BUSY_CREATING:    0x0808,
-  BUSY_COMMITTING:  0x0810,
-  BUSY_REFRESH:     0x0820,
-  BUSY_REFRESH_CLEAN:  0x0821,
-  BUSY_REFRESH_DIRTY:  0x0822,
-  BUSY_DESTROYING:  0x0840,
+  CLEAN:            0x0001, // 1
+  DIRTY:            0x0002, // 2
+  
+  EMPTY:            0x0100, // 256
+  ERROR:            0x1000, // 4096
+  
+  READY:            0x0200, // 512
+  READY_CLEAN:      0x0201, // 513
+  READY_DIRTY:      0x0202, // 514
+  READY_NEW:        0x0203, // 515
+  
+  DESTROYED:        0x0400, // 1024
+  DESTROYED_CLEAN:  0x0401, // 1025
+  DESTROYED_DIRTY:  0x0402, // 1026
+  
+  BUSY:             0x0800, // 2048
+  BUSY_LOADING:     0x0804, // 2052
+  BUSY_CREATING:    0x0808, // 2056
+  BUSY_COMMITTING:  0x0810, // 2064
+  BUSY_REFRESH:     0x0820, // 2080
+  BUSY_REFRESH_CLEAN:  0x0821, // 2081
+  BUSY_REFRESH_DIRTY:  0x0822, // 2082
+  BUSY_DESTROYING:  0x0840, // 2112
 
   // exceptions that can be raised when processing records
   BAD_STATE_ERROR:     new Error("Internal Inconsistency"),
@@ -374,6 +474,20 @@ SC.Record.mixin( /** @scope SC.Record */ {
     return SC.ManyAttribute.attr(recordType, opts);
   },
   
+  /**
+    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
+    need to call this method yourself.
+    
+    @returns {Hash}
+  */
+  storeKeysById: function() {
+    var key = SC.keyFor('storeKey', SC.guidFor(this)),
+        ret = this[key];
+    if (!ret) ret = this[key] = {};
+    return ret;
+  },
+  
   /**
     Given a primaryKey value for the record, returns the associated
     storeKey.  If the primaryKey has not been assigned a storeKey yet, it 
@@ -386,15 +500,31 @@ SC.Record.mixin( /** @scope SC.Record */ {
     @returns {Number} a storeKey.
   */
   storeKeyFor: function(id) {
-    var storeKeys = this.prototype.storeKeysById;
-    if (!storeKeys) storeKeys = this.prototype.storeKeysById = {};
-    var ret = storeKeys[id];
+    var storeKeys = this.storeKeysById(),
+        ret       = storeKeys[id];
+    
     if (!ret) {
       ret = SC.Store.generateStoreKey();
       SC.Store.idsByStoreKey[ret] = id ;
       SC.Store.recordTypesByStoreKey[ret] = this ;
       storeKeys[id] = ret ;
     }
+    
+    return ret ;
+  },
+  
+  /**
+    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 {String} id a record id
+    @returns {Number} a storeKey.
+  */
+  storeKeyExists: function(id) {
+    var storeKeys = this.storeKeysById(),
+        ret       = storeKeys[id];
+    
     return ret ;
   },
 
@@ -428,3 +558,4 @@ SC.Record.mixin( /** @scope SC.Record */ {
   relationships can sometimes make your code more understandable.
 */
 SC.Record.toOne = SC.Record.attr ;
+

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

@@ -13,6 +13,22 @@ sc_require('models/record');
   generate computed properties on records that can automatically convert data
   types and verify data.
   
+  In addition to having predefined transform types, there is also a way to 
+  set a computed relationship on an attribute. A typical example of this would
+  be if you have record with a parentGuid attribute, but are not able to 
+  determine which record type to map to before looking at the guid (or any
+  other attributes). To set up such a computed property, you can attach a 
+  function in the attribute definition of the SC.Record subclass:
+  
+  {{{
+    relatedToComputed: SC.Record.toOne(function() {
+      return (this.readAttribute('relatedToComputed').indexOf("foo")==0) ? MyApp.Foo : MyApp.Bar;
+    })
+  }}}
+  
+  Notice that we are not using .get() to avoid another transform which would 
+  trigger an infinite loop.
+  
   You usually will not work with RecordAttribute objects directly, though you
   may extend the class in any way that you like to create a custom attribute.
 
@@ -102,10 +118,13 @@ SC.RecordAttribute = SC.Object.extend(
     var klass      = this.get('typeClass') || String,
         transforms = SC.RecordAttribute.transforms,
         ret ;
-    
+        
     // walk up class hierarchy looking for a transform handler
     while(klass && !(ret = transforms[SC.guidFor(klass)])) {
-      klass = klass.superclass ;
+      // check if super has create property to detect SC.Object's
+      if(klass.superclass.hasOwnProperty('create')) klass = klass.superclass ;
+      // otherwise return the function transform handler
+      else klass = SC.T_FUNCTION ;
     }
     
     return ret ;
@@ -129,10 +148,11 @@ SC.RecordAttribute = SC.Object.extend(
   toType: function(record, key, value) {
     var transform = this.get('transform'),
         type      = this.get('typeClass');
+    
     if (transform && transform.to) {
       value = transform.to(value, this, type, record, key) ;
     }
-    return value ;        
+    return value ;
   },
 
   /** 
@@ -149,6 +169,7 @@ SC.RecordAttribute = SC.Object.extend(
   fromType: function(record, key, value) {
     var transform = this.get('transform'),
         type      = this.get('typeClass');
+    
     if (transform && transform.from) {
       value = transform.from(value, this, type, record, key);
     }
@@ -174,9 +195,12 @@ SC.RecordAttribute = SC.Object.extend(
       if (SC.none(value) && (value = this.get('defaultValue'))) {
         if (typeof value === SC.T_FUNCTION) {
           value = this.defaultValue(record, key, this);
+          // write default value so it doesn't have to be executed again
+          if(record.attributes()) record.writeAttribute(attrKey, value, true);
         }
       } else value = this.toType(record, key, value);
     }
+    
     return value ;
   },
 
@@ -241,7 +265,7 @@ SC.RecordAttribute.transforms = {};
   @returns {SC.RecordAttribute} receiver
 */
 SC.RecordAttribute.registerTransform = function(klass, transform) {
-  SC.RecordAttribute.transforms[SC.guidFor(klass)] = transform;  
+  SC.RecordAttribute.transforms[SC.guidFor(klass)] = transform;
 };
 
 // ..........................................................
@@ -280,11 +304,49 @@ SC.RecordAttribute.registerTransform(String, {
   }
 });
 
+/** @private - generic converter for Array */
+SC.RecordAttribute.registerTransform(Array, {
+  /** @private - check if obj is an array
+  */
+  to: function(obj) {
+    if (!SC.isArray(obj) && !SC.none(obj)) {
+      obj = [];
+    }
+    return obj;
+  }
+});
+
+/** @private - generic converter for Object */
+SC.RecordAttribute.registerTransform(Object, {
+  /** @private - check if obj is an object */
+  to: function(obj) {
+    if (!(typeof obj === 'object') && !SC.none(obj)) {
+      obj = {};
+    }
+    return obj;
+  }
+});
+
 /** @private - generic converter for SC.Record-type records */
 SC.RecordAttribute.registerTransform(SC.Record, {
 
   /** @private - convert a record id to a record instance */
   to: function(id, attr, recordType, parentRecord) {
+    var store = parentRecord.get('store');
+    if (SC.none(id) || (id==="")) return null;
+    else return store.find(recordType, id);
+  },
+  
+  /** @private - convert a record instance to a record id */
+  from: function(record) { return record ? record.get('id') : null; }
+});
+
+/** @private - generic converter for transforming computed record attributes */
+SC.RecordAttribute.registerTransform(SC.T_FUNCTION, {
+
+  /** @private - convert a record id to a record instance */
+  to: function(id, attr, recordType, parentRecord) {
+    recordType = recordType.apply(parentRecord);
     var store = parentRecord.get('store');
     return store.find(recordType, id);
   },
@@ -325,7 +387,7 @@ SC.RecordAttribute.registerTransform(Date, {
       
       ret = new Date();
       ret.setTime(Number(time));
-    } else ret = Date.parse(str);
+    } else ret = new Date(Date.parse(str));
     return ret ;
   },