sproutcore 1.6.0.beta.3-java → 1.6.0-java

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/manipulation.js

@@ -1,6 +1,8 @@
 sc_require("views/view");
 
-SC.View.reopen({
+SC.View.reopen(
+  /** @scope SC.View.prototype */{
+
   /**
     This code exists to make it possible to pool SC.Views. We are not going to pool SC.Views in Amber
     */
@@ -124,16 +126,22 @@ SC.View.reopen({
     if(view.parentViewDidChange) view.parentViewDidChange();
     if(view.layoutDidChange) view.layoutDidChange();
 
-    var pane = view.get('pane');
-    if(pane && pane.get('isPaneAttached')) {
-      view._notifyDidAppendToDocument();
-    }
+    view.endPropertyChanges();
 
-    // notify views
-    if (this.didAddChild) { this.didAddChild(view, beforeView) ; }
-    if (view.didAddToParent) { view.didAddToParent(this, beforeView) ; }
+    // Make sure all notifications are delayed since the appending
+    // doesn't complete until the end of the RunLoop
+    // There may be better ways to do this than with invokeLast,
+    // but it's the best I can do for now - PDW
+    this.invokeLast(function(){
+      var pane = view.get('pane');
+      if(pane && pane.get('isPaneAttached')) {
+        view._notifyDidAppendToDocument();
+      }
 
-    view.endPropertyChanges();
+      // notify views
+      if (this.didAddChild) { this.didAddChild(view, beforeView) ; }
+      if (view.didAddToParent) { view.didAddToParent(this, beforeView) ; }
+    });
 
     return this ;
   },

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/theming.js

@@ -116,23 +116,6 @@ SC.View.reopen(
     }
   }.property('baseThemeName', 'parentView').cacheable(),
 
-  /**
-   * Returns the named property if it is specified on the view, and
-   * otherwise returns the named constant from the view's theme.
-   *
-   * @param {String} property The property on the view.
-   * @param {String} constantName The name of the constant on the theme.
-  */
-  getThemedProperty: function(property, constantName){
-    var value = this.get(property);
-    if (value !== undefined) { return value; }
-
-    var theme = this.get('theme');
-    if (!theme) { return undefined; }
-
-    return theme[constantName];
-  },
-
   /**
     The object to which rendering and updating the HTML representation of this
     view should be delegated.
@@ -253,9 +236,16 @@ SC.View.reopen(
     original(context);
 
     var renderDelegate = this.get('renderDelegate');
+    if (renderDelegate && renderDelegate.className) {
+      context.addClass(renderDelegate.className);
+    }
+    
+    // @if(debug)
     if (renderDelegate && renderDelegate.name) {
-      context.addClass(renderDelegate.name);
+      SC.Logger.error("Render delegates now use 'className' instead of 'name'.");
+      SC.Logger.error("Name '%@' will be ignored.", renderDelegate.name);
     }
+    // @endif
   }.enhance()
 });
 

data/lib/frameworks/sproutcore/frameworks/core_tools/core.js

@@ -15,6 +15,12 @@
 CoreTools = SC.Object.create( /** @scope CoreTools.prototype */ {
 
   NAMESPACE: 'CoreTools',
-  VERSION: '1.0.0'
-  
+  VERSION: '1.0.0',
+
+  attachUrlPrefix: function(url) {
+    if(url && SC.urlPrefix) {
+      url = SC.urlPrefix + url;
+    }
+    return url;
+  }
 }) ;

data/lib/frameworks/sproutcore/frameworks/core_tools/data_source.js

@@ -41,7 +41,7 @@ CoreTools.DataSource = SC.DataSource.extend({
     
     if (!query.get('isRemote')) return NO ; 
     
-    SC.Request.getUrl('/sc/targets.json')
+    SC.Request.getUrl(CoreTools.attachUrlPrefix('/sc/targets.json'))
       .set('isJSON', YES)
       .notify(this, 'fetchTargetsDidComplete', { query: query, store: store })
       .send();

data/lib/frameworks/sproutcore/frameworks/core_tools/models/target.js

@@ -34,7 +34,7 @@ CoreTools.Target = SC.Record.extend(
     URL to use to load the app.  If no an app, returns null
   */
   appUrl: function() {
-    return (this.get('kind') === 'app') ? this.get('name') : null;
+    return (this.get('kind') === 'app') ? CoreTools.attachUrlPrefix(this.get('name')) : null;
   }.property('kind', 'name').cacheable(),
   
   /**

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

@@ -5,6 +5,12 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
+/**
+  Indicates a value has a mixed state of both on and off.
+
+  @property {String}
+*/
+SC.MIXED_STATE = '__MIXED__';
 
 /** @class
 
@@ -327,20 +333,22 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
     @returns {Boolean} YES if data source can handle keys
   */
   commitRecords: function(store, createStoreKeys, updateStoreKeys, destroyStoreKeys, params) {
-    var cret, uret, dret;
+    var uret, dret, ret;
     if (createStoreKeys.length>0) {
-      cret = this.createRecords.call(this, store, createStoreKeys, params);
+      ret = this.createRecords.call(this, store, createStoreKeys, params);
     }
 
     if (updateStoreKeys.length>0) {
       uret = this.updateRecords.call(this, store, updateStoreKeys, params);
+      ret = SC.none(ret) ? uret : (ret === uret) ? ret : SC.MIXED_STATE;
     }
 
     if (destroyStoreKeys.length>0) {
       dret = this.destroyRecords.call(this, store, destroyStoreKeys, params);
+      ret = SC.none(ret) ? dret : (ret === dret) ? ret : SC.MIXED_STATE;
     }
 
-    return ((cret === uret) && (cret === dret)) ? cret : SC.MIXED_STATE;
+    return ret || NO;
   },
 
   /**
@@ -441,13 +449,12 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
     invokes the named action for each store key.  returns proper value
   */
   _handleEach: function(store, storeKeys, action, ids, params) {
-    var len = storeKeys.length, idx, ret, cur, lastArg;
-    if(!ids) ids = [];
+    var len = storeKeys.length, idx, ret, cur, idOrParams;
 
     for(idx=0;idx<len;idx++) {
-      lastArg = ids[idx] ? ids[idx] : params;
+      idOrParams = ids ? ids[idx] : params;
 
-      cur = action.call(this, store, storeKeys[idx], lastArg, params);
+      cur = action.call(this, store, storeKeys[idx], idOrParams);
       if (ret === undefined) {
         ret = cur ;
       } else if (ret === YES) {
@@ -456,7 +463,7 @@ SC.DataSource = SC.Object.extend( /** @scope SC.DataSource.prototype */ {
         ret = (cur === NO) ? NO : SC.MIXED_STATE ;
       }
     }
-    return ret ? ret : null ;
+    return !SC.none(ret) ? ret : null ;
   },
 
 

data/lib/frameworks/sproutcore/frameworks/datastore/data_sources/fixtures.js

@@ -236,7 +236,7 @@ SC.FixturesDataSource = SC.DataSource.extend(
     @param {SC.Store} store the store to load into
     @param {SC.Record} recordType the record type to load
     @param {SC.Array} ret is passed, array to add loaded storeKeys to.
-    @returns {SC.Fixture} receiver
+    @returns {SC.FixturesDataSource} receiver
   */
   loadFixturesFor: function(store, recordType, ret) {
     var hashes   = [],
@@ -344,7 +344,17 @@ SC.FixturesDataSource = SC.DataSource.extend(
     var ret = [], fixtures = this._fixtures[SC.guidFor(recordType)];
     return fixtures ? YES: NO;
   },
-  
+
+  /**
+    Resets the fixtures to their original values.
+
+    @returns {SC.FixturesDataSource} receiver
+  */
+  reset: function(){
+    this._fixtures = null;
+    return this;
+  },
+
   /**
     Returns YES or SC.MIXED_STATE if one or more of the storeKeys can be 
     handled by the fixture data source.

data/lib/frameworks/sproutcore/frameworks/datastore/mixins/relationship_support.js

@@ -0,0 +1,296 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/** @class
+  Provides support for having relationships propagate by
+  data provided by the data source.
+
+  This means the following interaction is now valid:
+
+      App = { store: SC.Store.create(SC.RelationshipSupport) };
+
+      App.Person = SC.Record.extend({
+        primaryKey: 'name',
+
+        name: SC.Record.attr(String),
+
+        power: SC.Record.toOne('App.Power', {
+          isMaster: NO,
+          inverse: 'person'
+        })
+      });
+
+      App.Power = SC.Record.extend({
+        person: SC.Record.toOne('App.Person', {
+          isMaster: YES,
+          inverse: 'power'
+        })
+      });
+
+      var zan = App.store.createRecord(App.Person, { name: 'Zan' }),
+          jayna = App.store.createRecord(App.Person, { name: 'Janya' });
+
+      // Wondertwins activate!
+      var glacier = App.store.loadRecords(App.Power, [{
+        guid: 'petunia',  // Shape of...
+        person: 'Jayna'
+      }, {
+        guid: 'drizzle',  // Form of...
+        person: 'Zan'
+      }]);
+
+
+  Leveraging this mixin requires your records to be unambiguously
+  defined. Note that this mixin does not take into account record
+  relationship created / destroyed on `dataSourceDidComplete`,
+  `writeAttribute`, etc. The only support here is for `pushRetrieve`,
+  `pushDestroy`, and `loadRecords` (under the hood, `loadRecord(s)` uses
+  `pushRetrieve`).
+
+  This mixin also supports lazily creating records when a related
+  record is pushed in from the store (but it doesn't exist).
+
+  This means that the previous example could have been simplified
+  to this:
+
+      App.Power = SC.Record.extend({
+        person: SC.Record.toOne('App.Person', {
+          isMaster: YES,
+          lazilyInstantiate: YES,
+          inverse: 'power'
+        })
+      });
+
+      // Wondertwins activate!
+      var glacier = App.store.loadRecords(App.Power, [{
+        guid: 'petunia',  // Shape of...
+        person: 'Jayna'
+      }, {
+        guid: 'drizzle',  // Form of...
+        person: 'Zan'
+      }]);
+
+
+  When the `loadRecords` call is done, there will be four unmaterialized
+  records in the store, giving the exact same result as the former
+  example.
+
+  As a side note, this mixin was developed primarily for use
+  in a real-time backend that provides data to SproutCore
+  as soon as it gets it (no transactions). This means streaming
+  APIs / protocols like the Twitter streaming API or XMPP (an IM
+  protocol) can be codified easier.
+
+  @since SproutCore 1.6
+ */
+SC.RelationshipSupport = {
+
+  /** @private
+    Relinquish many records.
+
+    This happens when a master record (`isMaster` = `YES`) removes a reference
+    to related records, either through `pushRetrieve` or `pushDestroy`.
+   */
+  _srs_inverseDidRelinquishRelationships: function (recordType, ids, attr, inverseId) {
+    ids.forEach(function (id) {
+      this._srs_inverseDidRelinquishRelationship(recordType, id, attr, inverseId);
+    },this);
+  },
+
+  /** @private
+    Relinquish the record, removing the reference of the record being
+    destroyed on any related records.
+   */
+  _srs_inverseDidRelinquishRelationship: function (recordType, id, toAttr, relativeID) {
+    var storeKey = recordType.storeKeyFor(id),
+      dataHash = this.readDataHash(storeKey),
+      key = toAttr.inverse,
+      proto = recordType.prototype;
+
+    if (!dataHash || !key) return;
+
+    if (SC.instanceOf(proto[key], SC.SingleAttribute)) {
+      delete dataHash[key];
+    } else if (SC.instanceOf(proto[key], SC.ManyAttribute)
+               && SC.typeOf(dataHash[key]) === SC.T_ARRAY) {
+      dataHash[key].removeObject(relativeID);
+    }
+
+    this.pushRetrieve(recordType, id, dataHash, undefined, true);
+  },
+
+  /** @private
+    Add a relationship to many inverse records.
+
+    This happens when a master record (`isMaster` = `YES`) adds a reference
+    to another record on a `pushRetrieve`.
+   */
+  _srs_inverseDidAddRelationships: function (recordType, ids, attr, inverseId) {
+    ids.forEach(function (id) {
+      this._srs_inverseDidAddRelationship(recordType, id, attr, inverseId);
+    },this);
+  },
+
+
+  /** @private
+    Add a relationship to an inverse record.
+
+    If the flag lazilyInstantiate is set to YES, then the inverse record will be
+    created lazily.
+
+    @param {SC.Record} recordType The inverse record type.
+    @param {String} id The id of the recordType to add.
+    @param {SC.RecordAttribute} toAttr The record attribute that represents
+      the relationship being created.
+    @param {String} relativeID The ID of the model that needs to have it's
+      relationship updated.
+   */
+  _srs_inverseDidAddRelationship: function (recordType, id, toAttr, relativeID) {
+    var storeKey = recordType.storeKeyFor(id),
+        dataHash = this.readDataHash(storeKey),
+        status = this.peekStatus(storeKey),
+        proto = recordType.prototype,
+        key = toAttr.inverse,
+        hashKey = proto[key],
+        primaryAttr = proto[proto.primaryKey],
+        shouldRecurse = false;
+
+    // in case the SC.RecordAttribute defines a `key` field, we need to use that
+    hashKey = (hashKey && hashKey.get && hashKey.get('key') || hashKey.key) || key;
+
+    if ((status === SC.Record.EMPTY) &&
+        (SC.typeOf(toAttr.lazilyInstantiate) === SC.T_FUNCTION && toAttr.lazilyInstantiate() ||
+         SC.typeOf(toAttr.lazilyInstantiate) !== SC.T_FUNCTION && toAttr.lazilyInstantiate)) {
+
+      if (!SC.none(primaryAttr) && primaryAttr.typeClass &&
+          SC.typeOf(primaryAttr.typeClass()) === SC.T_CLASS) {
+
+        // Recurse to create the record that this primaryKey points to iff it
+        // also should be created if the record is empty.
+        // Identifies chained relationships where the object up the chain
+        // doesn't exist yet.
+
+        // TODO: this can lead to an infinite recursion if the relationship
+        // graph is cyclic
+        shouldRecurse = true;
+      }
+      dataHash = {};
+      dataHash[proto.primaryKey] = id;
+    }
+
+    if (!dataHash || !key) return;
+
+    if (SC.instanceOf(proto[key], SC.SingleAttribute)) {
+      dataHash[hashKey] = relativeID;
+    } else if (SC.instanceOf(proto[key], SC.ManyAttribute)) {
+      dataHash[hashKey] = dataHash[hashKey] || [];
+
+      if (dataHash[key].indexOf(relativeID) < 0) {
+        dataHash[hashKey].push(relativeID);
+      }
+    }
+
+    this.pushRetrieve(recordType, id, dataHash, undefined, !shouldRecurse);
+  },
+
+  // ..........................................................
+  // ASYNCHRONOUS RECORD RELATIONSHIPS
+  //
+
+  /** @private
+    Iterates over keys on the recordType prototype, looking for RecordAttributes
+    that have relationships (toOne or toMany).
+
+    @param {SC.Record} recordType The record type to do introspection on to see
+      if it has any RecordAttributes that have relationships to other records.
+    @param {String} id The id of the record being pushed in.
+    @param {Number} storeKey The storeKey
+   */
+  _srs_pushIterator: function (recordType, id, storeKey, lambda) {
+    var proto = recordType.prototype,
+        attr, currentHash, key, inverseType;
+
+    if (typeof storeKey === "undefined") {
+      storeKey = recordType.storeKeyFor(id);
+    }
+
+    currentHash = this.readDataHash(storeKey) || {};
+
+    for (key in proto) {
+      attr = proto[key];
+      if (attr && attr.typeClass && attr.inverse && attr.isMaster) {
+        inverseType = attr.typeClass();
+
+        if (SC.typeOf(inverseType) !== SC.T_CLASS) continue;
+
+        lambda.apply(this, [inverseType, currentHash, attr,
+                            attr.get && attr.get('key') || key]);
+      }
+    }
+  },
+
+
+  /**
+    Disassociate records that are related to the one being destroyed iff this
+    record has `isMaster` set to `YES`.
+   */
+  pushDestroy: function (original, recordType, id, storeKey) {
+    var existingIDs;
+
+    this._srs_pushIterator(recordType, id, storeKey,
+      function (inverseType, currentHash, toAttr, keyValue) {
+        // update old relationships
+        existingIDs = [currentHash[keyValue] || null].flatten().compact().uniq();
+        this._srs_inverseDidRelinquishRelationships(inverseType, existingIDs, toAttr, id);
+    });
+
+    return original(recordType, id, storeKey);
+  }.enhance(),
+
+  /**
+    Associate records that are added via a pushRetrieve, and update subsequent
+    relationships to ensure that the master-slave relationship is kept intact.
+
+    For use cases, see the test for pushRelationships.
+
+    The `ignore` argument is only set to true when adding the inverse
+    relationship (to prevent recursion).
+   */
+  pushRetrieve: function (original, recordType, id, dataHash, storeKey, ignore) {
+    // avoid infinite recursions when additional changes are propogated
+    // from `_srs_inverseDidAddRelationship`
+    if (!ignore) {
+      var existingIDs, inverseIDs;
+
+      this._srs_pushIterator(recordType, id, storeKey,
+        /** @ignore
+          @param {SC.Record} inverseType - in a Master-Slave
+          relationship when pushing master, Slave is the inverse type
+          @param {Object} currentHash - the hash in the data store (data to be replaced by `dataHash`)
+          @param {SC.RecordAttribute} toAttr - key in `recordType.prototype` that names isMaster and has an inverse
+          @param {String} keyValue - the property name in the datahash that defines this foreign key relationship
+         */
+        function (inverseType, currentHash, toAttr, keyValue) {
+          // update old relationships
+          existingIDs = [currentHash[keyValue] || null].flatten().compact().uniq();
+
+          // update new relationships
+          inverseIDs = [dataHash[keyValue] || null].flatten().compact().uniq();
+
+          this._srs_inverseDidRelinquishRelationships(inverseType, existingIDs.filter(
+            function (el) {
+              return inverseIDs.indexOf(el) === -1;
+            }), toAttr, id);
+
+          this._srs_inverseDidAddRelationships(inverseType, inverseIDs, toAttr, id);
+        });
+    }
+
+    storeKey = storeKey || recordType.storeKeyFor(id);
+    return original(recordType, id, dataHash, storeKey);
+  }.enhance()
+};