sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/datastore/system/many_array.js

@@ -0,0 +1,157 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+
+/**
+  @class
+
+  A ManyArray is used to map an array of store ids back to their 
+  record objects which will be materialized from the owner store on demand.
+  
+  @extends SC.ManyArray
+  @since SproutCore 1.0
+*/
+
+SC.ManyArray = SC.Object.extend(SC.Enumerable, SC.Array,
+  /** @scope SC.ManyArray.prototype */ {
+
+  /**
+    The store that owns this record array.  All record arrays must have a 
+    store to function properly.
+
+    @property {SC.Store}
+  */
+  store: null,
+
+  /**
+    SC.Array object that will provide the store ids for the array.  The 
+    many array will register itself as an observer for this array.
+
+    @property {SC.Array}
+  */
+  storeIds: null,
+  
+  /**
+    recordType will tell what type to transform the record to when
+    materializing the record.
+
+    @type {String}
+  */
+  recordType: null,
+
+  // ..........................................................
+  // ARRAY PRIMITIVES
+  // 
+
+  /**
+    Returned length is a pass-through to the storeIds array.
+  */
+  length: function() {
+    var storeIds = this.get('storeIds');
+    return storeIds ? storeIds.get('length') : 0;
+  }.property('storeIds').cacheable(),
+
+  /**
+    Looks up the store id in the store ids array and materializes a
+    records.
+  */
+  objectAt: function(idx) {
+    var recs      = this._records, 
+        storeIds  = this.get('storeIds'),
+        store     = this.get('store'),
+        recordType = this.get('recordType'),
+        storeKey, ret, storeId ;
+        
+    if (!storeIds || !store) return undefined; // nothing to do
+    if (recs && (ret=recs[idx])) return ret ; // cached
+
+    // not in cache, materialize
+    if (!recs) this._records = recs = [] ; // create cache
+    storeId = storeIds.objectAt(idx);
+    if (storeId) {
+
+      // if record is not loaded already, then ask the data source to 
+      // retrieve it
+      storeKey = store.storeKeyFor(recordType, storeId);
+      
+      if (store.readStatus(storeKey) === SC.Record.EMPTY) {
+        store.retrieveRecord(recordType, null, storeKey);
+      }
+      
+      recs[idx] = ret = store.materializeRecord(storeKey);
+    }
+    return ret ;
+  },
+
+  /**
+    Pass through to the underlying array.  The passed in objects must be
+    records, which can be converted to storeIds.
+  */
+  replace: function(idx, amt, recs) {
+    var storeIds = this.get('storeIds'), 
+        len       = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
+        i, keys, ids;
+
+    if (!storeIds) throw "storeIds required";
+
+    // map to store keys
+    ids = [] ;
+    for(i=0;i<len;i++) ids[i] = recs.objectAt(i).get('id');
+
+    // pass along - if allowed, this should trigger the content observer 
+    storeIds.replace(idx, amt, ids);
+    
+    return this;
+  },
+  
+  // ..........................................................
+  // INTERNAL SUPPORT
+  // 
+
+  /** @private 
+    Invoked whenever the storeIds array changes.  Observes changes.
+  */
+  _storeIdsDidChange: function() {
+    var storeIds = this.get('storeIds');
+    var prev = this._prevStoreIds, f = this._storeIdsContentDidChange;
+
+    if (storeIds === prev) return this; // nothing to do
+
+    if (prev) {
+      prev.removeObserver('[]', this, f);
+    }
+
+    this._prevStoreIds = storeIds;
+
+    if (storeIds) {
+      storeIds.addObserver('[]', this, f);
+    }
+
+    var rev = (storeIds) ? storeIds.propertyRevision : -1 ;
+    this._storeIdsContentDidChange(storeIds, '[]', storeIds, rev);
+    
+  }.observes('storeIds'),
+
+  /** @private
+    Invoked whenever the content of the storeIds array changes.  This will
+    dump any cached record lookup and then notify that the enumerable content
+    has changed.
+  */
+  _storeIdsContentDidChange: function(target, key, value, rev) {
+    this._records = null ; // clear cache
+
+    this.beginPropertyChanges()
+      .notifyPropertyChange('length')
+      .enumerableContentDidChange()
+    .endPropertyChanges();
+  },
+
+  init: function() {
+    sc_super();
+    this._storeIdsDidChange();
+  }
+  
+}) ;

data/frameworks/sproutcore/frameworks/datastore/system/nested_store.js

@@ -108,20 +108,36 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   reset: function() {
-    console.error('not implemented');
+    
+    // if we have a transient parent store, then we can just respawn from 
+    // its properties
+    var parentStore = this.get('parentStore');
+    if(parentStore) {
+      this.dataHashes = SC.beget(parentStore.dataHashes);
+      this.revisions  = SC.beget(parentStore.revisions);
+      this.statuses   = SC.beget(parentStore.statuses);
+    }
+    
+    // also, reset private temporary objects
+    this.chainedChanges = this.locks = this.editables = null;
+    this.changelog = null ;
+
+    this.set('hasChanges', NO);
   },
   
   /**
-    Propagate this store's changes to it's parent.  If the store does not 
+    Propagate this store's changes to its parent.  If the store does not 
     have a parent, this has no effect other than to clear the change set.
 
     @param {Boolean} force if YES, does not check for conflicts first
     @returns {SC.Store} receiver
   */
   commitChanges: function(force) {
-    var pstore = this.get('parentStore');
-    pstore.commitChangesFromNestedStore(this, this.chainedChanges, force);
-    this.reset(); // clear out custom changes 
+    if (this.get('hasChanges')) {
+      var pstore = this.get('parentStore');
+      pstore.commitChangesFromNestedStore(this, this.chainedChanges, force);
+      this.reset(); // clear out custom changes
+    }
     return this ;
   },
 
@@ -131,7 +147,26 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   discardChanges: function() {
-    console.error('not implemented');
+    
+    // any locked records whose rev or lock rev differs from parent need to
+    // be notified.
+    var records, locks;
+    if ((records = this.records) && (locks = this.locks)) {
+      var pstore = this.get('parentStore'), psRevisions = pstore.revisions;
+      var revisions = this.revisions, storeKey, lock, rev;
+      for(storeKey in records) {
+        if (!records.hasOwnProperty(storeKey)) continue ;
+        if (!(lock = locks[storeKey])) continue; // not locked.
+
+        rev = psRevisions[storeKey];
+        if ((rev !== lock) || (revisions[storeKey] > rev)) {
+          this._notifyRecordPropertyChange(storeKey);
+        }
+      }
+    }
+    
+    this.reset();
+    return this ;
   },
   
   /**
@@ -141,7 +176,13 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   destroy: function() {
-    console.error('not implemented');
+    this.discardChanges();
+    
+    var parentStore = this.get('parentStore');
+    if (parentStore) parentStore.willDestroyNestedStore(this);
+    
+    sc_super();  
+    return this ;
   },
 
   /**
@@ -150,7 +191,23 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   reset: function() {
-    console.error('not implemented');
+
+    // requires a pstore to reset
+    var parentStore = this.get('parentStore');
+    if (!parentStore) throw SC.Store.NO_PARENT_STORE_ERROR;
+    
+    // inherit data store from parent store.
+    this.dataHashes = SC.beget(parentStore.dataHashes);
+    this.revisions  = SC.beget(parentStore.revisions);
+    this.statuses   = SC.beget(parentStore.statuses);
+    
+    // also, reset private temporary objects
+    this.chainedChanges = this.locks = this.editables = null;
+    this.changelog = null ;
+
+    // TODO: Notify record instances
+    
+    this.set('hasChanges', NO);
   },
   
   // ..........................................................
@@ -168,7 +225,8 @@ SC.NestedStore = SC.Store.extend(
     @returns {Number} edit status
   */
   storeKeyEditState: function(storeKey) {
-    console.error('not implemented');
+    var editables = this.editables, locks = this.locks;
+    return (editables && editables[storeKey]) ? SC.Store.EDITABLE : (locks && locks[storeKey]) ? SC.Store.LOCKED : SC.Store.INHERITED ;
   },
    
   /**  @private
@@ -176,17 +234,57 @@ SC.NestedStore = SC.Store.extend(
     store.
   */
   _lock: function(storeKey) {
-    console.error('not implemented');
+    var locks = this.locks, rev, editables;
+    
+    // already locked -- nothing to do
+    if (locks && locks[storeKey]) return this;
+
+    // create locks if needed
+    if (!locks) locks = this.locks = [];
+
+    // fixup editables
+    editables = this.editables;
+    if (editables) editables[storeKey] = 0;
+    
+    
+    // if the data hash in the parent store is editable, then clone the hash
+    // for our own use.  Otherwise, just copy a reference to the data hash
+    // in the parent store. -- find first non-inherited state
+    var pstore = this.get('parentStore'), editState;
+    while(pstore && (editState=pstore.storeKeyEditState(storeKey)) === SC.Store.INHERITED) {
+      pstore = pstore.get('parentStore');
+    }
+    
+    if (pstore && editState === SC.Store.EDITABLE) {
+      this.dataHashes[storeKey] = SC.clone(pstore.dataHashes[storeKey]);
+      if (!editables) editables = this.editables = [];
+      editables[storeKey] = 1 ; // mark as editable
+      
+    } else this.dataHashes[storeKey] = this.dataHashes[storeKey];
+    
+    // also copy the status + revision
+    this.statuses[storeKey] = this.statuses[storeKey];
+    rev = this.revisions[storeKey] = this.revisions[storeKey];
+    
+    // save a lock and make it not editable
+    locks[storeKey] = rev || 1;    
+    
+    return this ;
   },
   
   /** @private - adds chaining support */
   readDataHash: function(storeKey) {
-    console.error('not implemented');
+    if (this.get('lockOnRead')) this._lock(storeKey);
+    return this.dataHashes[storeKey];
   },
   
   /** @private - adds chaining support */
   readEditableDataHash: function(storeKey) {
-    console.error('not implemented');
+
+    // lock the data hash if needed
+    this._lock(storeKey);
+    
+    return sc_super();
   },
   
   /** @private - adds chaining support - 
@@ -194,17 +292,67 @@ SC.NestedStore = SC.Store.extend(
     much. 
   */
   writeDataHash: function(storeKey, hash, status) {
-    console.error('not implemented');
+    var locks = this.locks, rev ;
+    
+    // update dataHashes and optionally status.  Note that if status is not
+    // passed, we want to copy the reference to the status anyway to lock it
+    // in.
+    if (hash) this.dataHashes[storeKey] = hash;
+    this.statuses[storeKey] = status ? status : (this.statuses[storeKey] || SC.Record.READY_NEW);
+    rev = this.revisions[storeKey] = this.revisions[storeKey]; // copy ref
+    
+    // make sure we lock if needed.
+    if (!locks) locks = this.locks = [];
+    if (!locks[storeKey]) locks[storeKey] = rev || 1;
+    
+    // also note that this hash is now editable
+    var editables = this.editables;
+    if (!editables) editables = this.editables = [];
+    editables[storeKey] = 1 ; // use number for dense array support
+    
+    return this ;
   },
 
   /** @private - adds chaining support */
   removeDataHash: function(storeKey, status) {
-    console.error('not implemented');
+    
+    // record optimistic lock revision
+    var locks = this.locks;
+    if (!locks) locks = this.locks = [];
+    if (!locks[storeKey]) locks[storeKey] = this.revisions[storeKey] || 1;
+
+    return sc_super();
   },
   
   /** @private - book-keeping for a single data hash. */
   dataHashDidChange: function(storeKeys, rev) {
-    console.error('not implemented');
+    
+    // update the revision for storeKey.  Use generateStoreKey() because that
+    // gaurantees a universally (to this store hierarchy anyway) unique 
+    // key value.
+    if (!rev) rev = SC.Store.generateStoreKey();
+    var isArray, len, idx, storeKey;
+    
+    isArray = SC.typeOf(storeKeys) === SC.T_ARRAY;
+    if (isArray) {
+      len = storeKeys.length;
+    } else {
+      len = 1;
+      storeKey = storeKeys;
+    }
+
+    var changes = this.chainedChanges;
+    if (!changes) changes = this.chainedChanges = SC.Set.create();
+    
+    for(idx=0;idx<len;idx++) {
+      if (isArray) storeKey = storeKeys[idx];
+      this._lock(storeKey);
+      this.revisions[storeKey] = rev;
+      changes.add(storeKey);
+    }
+
+    this.setIfChanged('hasChanges', YES);
+    return this ;
   },
 
   // ..........................................................
@@ -213,7 +361,27 @@ SC.NestedStore = SC.Store.extend(
   
   /** @private - adapt for nested store */
   commitChangesFromNestedStore: function(nestedStore, changes, force) {
-    console.error('not implemented');
+
+    sc_super();
+    
+    // save a lock for each store key if it does not have one already
+    // also add each storeKey to my own changes set.
+    var pstore = this.get('parentStore'), psRevisions = pstore.revisions, i;
+    var myLocks = this.locks, myChanges = this.chainedChanges,len,storeKey;
+    if (!myLocks) myLocks = this.locks = [];
+    if (!myChanges) myChanges = this.chainedChanges = SC.Set.create();
+
+    len = changes.length ;
+    for(i=0;i<len;i++) {
+      storeKey = changes[i];
+      if (!myLocks[storeKey]) myLocks[storeKey] = psRevisions[storeKey]||1;
+      myChanges.add(storeKey);
+    }
+    
+    // Finally, mark store as dirty if we have changes
+    this.setIfChanged('hasChanges', myChanges.get('length')>0);
+    
+    return this ;
   },
 
   // ..........................................................
@@ -223,7 +391,8 @@ SC.NestedStore = SC.Store.extend(
   
   /** @private - adapt for nested store */
   findAll: function(queryKey, params, _store) { 
-    console.error('not implemented');
+    if (!_store) store = this;
+    return this.get('parentStore').findAll(queryKey, params, _store);
   },
 
   // ..........................................................
@@ -233,8 +402,22 @@ SC.NestedStore = SC.Store.extend(
   // actually creating record instances.
   
   /** @private - adapt for nested store */
-  retrieveRecords: function(recordTypes, ids, storeKeys, _isRefresh) {
-    console.error('not implemented');
+  retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh) {
+    var pstore = this.get('parentStore'), idx, storeKey, newStatus,
+      len = (!storeKeys) ? ids.length : storeKeys.length,
+      K = SC.Record, status;
+    
+    // turn status to BUSY_REFRESH_CLEAN/DIRTY if isRefresh is true
+    // for correct transition before handing to parent store
+    if(isRefresh) {
+      for(idx=0;idx<len;idx++) {
+        storeKey = !storeKeys ? pstore.storeKeyFor(recordTypes, ids[idx]) : storeKeys[idx];
+        newStatus = status===K.READY_DIRTY ? K.BUSY_REFRESH_DIRTY : K.BUSY_REFRESH_CLEAN;
+        this.writeStatus(storeKey, newStatus);
+      }
+    }
+    
+    return pstore.retrieveRecords(recordTypes, ids, storeKeys, isRefresh);
   },
 
   /** @private - adapt for nested store */