sproutcore 1.6.0.rc.2-x86-mingw32 → 1.6.0.1-x86-mingw32

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/mixins/template_helpers/text_field_support.js

@@ -38,6 +38,10 @@
     equals(textFieldView.$('input').val(), "afterlife", "sets value of DOM to value property");
   });
 
+  // Not really sure how to test this without doing something like adding a selection then checking 
+  // to see if it's still there after setting value
+  test("only update DOM if value changed");
+
   test("value binding works properly for inputs that haven't been created", function() {
     var view = SC.TemplateView.create(SC.TextFieldSupport, {
       template: SC.Handlebars.compile('<input type="text">'),
@@ -74,7 +78,7 @@
     equals(focusCalled, 1, "focus called after field receives focus");
 
     textFieldView.$('input').blur();
-    equals(blurCalled, 1, "blur alled after field blurs");
+    equals(blurCalled, 1, "blur called after field blurs");
   });
 
   test("calls correct method for key events", function() {
@@ -130,6 +134,10 @@
     equals(textFieldView.$('input').val(), "afterlife", "sets value of DOM to value property");
   });
 
+  // Not really sure how to test this without doing something like adding a selection then checking 
+  // to see if it's still there after setting value
+  test("only update DOM if value changed");
+
   test("value binding works properly for inputs that haven't been created", function() {
     var view = SC.TextField.create({
       valueBinding: 'TestObject.value'
@@ -165,7 +173,7 @@
     equals(focusCalled, 1, "focus called after field receives focus");
 
     textFieldView.$('input').blur();
-    equals(blurCalled, 1, "blur alled after field blurs");
+    equals(blurCalled, 1, "blur called after field blurs");
   });
 
   test("calls correct method for key events", function() {

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/panes/template.js

@@ -9,7 +9,6 @@ module("Template Panes");
 test("Template panes append a main pane to the document body", function() {
   var pane = SC.TemplatePane.append({
     layerId: 'template-panes-are-so-cool',
-
     template: SC.Handlebars.compile('<h1>foo bar baz</h1>')
   });
 
@@ -18,3 +17,19 @@ test("Template panes append a main pane to the document body", function() {
 
   pane.remove();
 });
+
+test("Template panes should be awoken", function(){
+  var didAwake = false;
+
+  var originalAwake = SC.MainPane.prototype.awake; // null for now, but just in case
+  SC.MainPane.prototype.awake = function(){ didAwake = true; }
+
+  var pane = SC.TemplatePane.append({
+    layerId: 'template-panes-are-so-cool',
+    template: SC.Handlebars.compile('<h1>foo bar baz</h1>')
+  });
+
+  SC.MainPane.prototype.awake = originalAwake;
+
+  ok(didAwake, "should have awoken the pane");
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/template/handlebars.js

@@ -898,7 +898,7 @@ test("should be able to bind class attribute with {{bindAttr}}", function() {
 });
 
 test("should be able to bind boolean element attributes using {{bindAttr}}", function() {
-  var template = SC.Handlebars.compile('<input type="check" {{bindAttr disabled="content.isDisabled" checked="content.isChecked"}} />');
+  var template = SC.Handlebars.compile('<input type="checkbox" {{bindAttr disabled="content.isDisabled" checked="content.isChecked"}} />');
   var content = SC.Object.create({
     isDisabled: false,
     isChecked: true

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/clippingFrame.js

@@ -115,3 +115,14 @@ test("notifies receiver and each child if parent clipping frame changes", functi
   // number.
   equals(callCount, 2, 'should invoke observer on child and nested child');
 });
+
+test("returns 0, 0, W, H if parentView has no clippingFrame", function(){
+  a.clippingFrame = null;
+
+  var targetFrame = aa.get('clippingFrame');
+
+  equals(targetFrame.x, 0, "x should be 0");
+  equals(targetFrame.y, 0, "y should be 0");
+  equals(targetFrame.width, 40, "width should be 40");
+  equals(targetFrame.height, 40, "height should be 40");
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/didAppendToDocument.js

@@ -21,6 +21,7 @@ module("SC.View#didAppendToDocument", {
             context.push('new string');
           },
           didAppendToDocument: function(){
+            ok(document.getElementById(this.get('layerId')), "view layer should exist");
             counter++;
           }
         })
@@ -30,6 +31,7 @@ module("SC.View#didAppendToDocument", {
 
     additionalView = SC.View.create({
       didAppendToDocument: function(){
+        ok(document.getElementById(this.get('layerId')), "additionalView layer should exist");
         counter++;
       }
     });
@@ -59,11 +61,12 @@ test("Check that didAppendToDocument gets called at the right moment", function(
   equals(counter, 3, "");
 });
 
+
 // Test for bug: when a childView has a non-fixed layout and we request its frame before the parentView has
 // a layer and the parentView uses static layout, then the frame returned will be {x: 0, y:0, width: 0, height: 0}
 // and any further requests for the childView's frame will not return a new value unless the parentViewDidChange
 // or parentViewDidResize.  A weird case, but we prevent it from failing anyhow.
-test("Check that childView is updated if we have static layout and they don't have a fixed layout", function() {
+test("Check that childView is updated if the pane has a static layout and view doesn't have a fixed layout", function() {
   var childFrame,
       wrongFrame = {x:0, y:0, width: 0, height: 0},
       correctFrame;
@@ -80,4 +83,17 @@ test("Check that childView is updated if we have static layout and they don't ha
   correctFrame = pane.get('frame');
 
   same(childFrame, correctFrame, 'getting frame after layer exists on non-fixed layout childView should return actual frame');
-});
+});
+
+
+test("Check that childView is updated if it has a static layout", function() {
+  var childFrame,
+      wrongFrame = {x:0, y:0, width: 0, height: 0},
+      correctFrame;
+
+  view.set('useStaticLayout', YES);
+
+  equals(counter, 0, "precond - has not been called yet");
+  pane.append(); // make sure there is a layer...
+  equals(counter, 1, "didAppendToDocument was called once");
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/insertBefore.js

@@ -80,7 +80,7 @@ test("invokes willAddChild() on receiver if defined before adding child" ,functi
 
 	  
   parent.insertBefore(child, otherChild);
-  ok(callCount, 1, 'invoked');
+  equals(callCount, 1, 'invoked');
 });
 
 test("invokes willAddToParent() on child view if defined before adding child" ,function() {
@@ -102,7 +102,7 @@ test("invokes willAddToParent() on child view if defined before adding child" ,f
 
 	  
   parent.insertBefore(child, otherChild);
-  ok(callCount, 1, 'invoked');
+  equals(callCount, 1, 'invoked');
 });
 
 test("invokes didAddChild() on receiver if defined after adding child" ,function() {
@@ -122,9 +122,11 @@ test("invokes didAddChild() on receiver if defined after adding child" ,function
   	callCount++;
   };
 
-	  
+  SC.RunLoop.begin();
   parent.insertBefore(child, otherChild);
-  ok(callCount, 1, 'invoked');
+  SC.RunLoop.end();
+
+  equals(callCount, 1, 'invoked');
 });
 
 test("invokes didAddToParent() on child view if defined after adding child" ,function() {
@@ -144,9 +146,11 @@ test("invokes didAddToParent() on child view if defined after adding child" ,fun
   	callCount++;
   };
 
-	  
+  SC.RunLoop.begin();
   parent.insertBefore(child, otherChild);
-  ok(callCount, 1, 'invoked');
+  SC.RunLoop.end();
+
+  equals(callCount, 1, 'invoked');
 });
 
 test("invokes parentViewDidChange() on child view.  this is used by the view internals to update layer loc", function() {

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/keyboard.js

@@ -4,7 +4,18 @@
 //            ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
-module("SC.View - Keyboard support");
+
+var originalTabbing;
+
+module("SC.View - Keyboard support with Tabbing Only Inside Document", {
+  setup: function(){
+    originalTabbing = SC.TABBING_ONLY_INSIDE_DOCUMENT;
+    SC.TABBING_ONLY_INSIDE_DOCUMENT = YES;
+  },
+  teardown: function(){
+    SC.TABBING_ONLY_INSIDE_DOCUMENT = originalTabbing;
+  }
+});
 
 test("Views only attempt to call performKeyEquivalent on child views that support it", function() {
   var performKeyEquivalentCalled = 0;
@@ -422,3 +433,9 @@ test("previousValidKeyView prioritizes parent's firstKeyView even if previousKey
   equals(pane.view2.view6.get('previousValidKeyView'), pane.view1.view4, "firstKeyView was respected; views before firstKeyView were skipped");
 });
 
+
+module("SC.View - Keyboard support with Tabbing Outside of Document");
+
+test("forward tab with no next responder moves out of document");
+
+test("backwards tab with no previous responder moves out of document");

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/template_collection.js

@@ -9,7 +9,15 @@ sc_require('views/template');
 */
 SC.TemplateCollectionView = SC.TemplateView.extend(
   /** @scope SC.TemplateCollectionView.prototype */{
+  /**
+    Name of the tag that is used for the collection
+
+    If the tag is a list ('ul' or 'ol') each item will be wrapped into a 'li' tag.
+    If the tag is a table ('table', 'thead', 'tbody') each item will be wrapped into a 'tr' tag.
 
+    @property {String}
+    @default ul
+  */
   tagName: 'ul',
   content: null,
   template: SC.Handlebars.compile(''),
@@ -297,7 +305,7 @@ SC.TemplateCollectionView = SC.TemplateView.extend(
       case 'thead':
       case 'tbody':
       case 'tfoot':
-        return 'tr'
+        return 'tr';
     }
   }.property('tagName'),
 

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

@@ -24,7 +24,7 @@ SC.CONTEXT_MENU_ENABLED = YES;
   Default property to disable or enable if the focus can jump to the address
   bar or not.
 */
-SC.TABBING_ONLY_INSIDE_DOCUMENT = YES;
+SC.TABBING_ONLY_INSIDE_DOCUMENT = NO;
 
 /**
   Tells the property (when fetched with themed()) to get its value from the renderer (if any).
@@ -674,7 +674,12 @@ SC.CoreView.reopen(
 
     if (this.get('isTextSelectable')) { context.addClass('allow-select'); }
     if (!this.get('isVisible')) { context.addClass('sc-hidden'); }
-    if (this.get('isFirstResponder')) { context.addClass('focus'); }
+    if (this.get('isFirstResponder')) { 
+      context.addClass('focus');
+      context.attr('tabindex', '0'); 
+    }else{
+      context.attr('tabindex', '-1');
+    }
 
     context.id(this.get('layerId'));
     context.attr('role', this.get('ariaRole'));
@@ -999,7 +1004,7 @@ SC.CoreView.reopen(
     pv = this.get('parentView');
     if (pv) {
       cf = pv.get('clippingFrame');
-      if (!cf) return f;
+      if (!cf) return { x: 0, y: 0, width: f.width, height: f.height};
       ret = SC.intersectRects(cf, f);
     }
     ret.x -= f.x;
@@ -1236,7 +1241,7 @@ SC.CoreView.reopen(
 
 });
 
-SC.CoreView.mixin(/** @scope SC.View.prototype */ {
+SC.CoreView.mixin(/** @scope SC.CoreView.prototype */ {
 
   /** @private walk like a duck -- used by SC.Page */
   isViewClass: YES,

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

@@ -39,13 +39,20 @@ SC.View.reopen(
 
   /**
     Invokved just after the responder loses key responder status.
+    @param {SC.Responder} responder
   */
   didLoseKeyResponderTo: function(responder) {},
 
   /**
     Invoked just after the responder gains key responder status.
+    By default, it calls focus on the view root element. For accessibility 
+    purposes.
+  
+    @param {SC.Responder} responder
   */
-  didBecomeKeyResponderFrom: function(responder) {},
+  didBecomeKeyResponderFrom: function(responder) {
+    this.$().focus();
+  },
 
   /**
     This method will process a key input event, attempting to convert it to
@@ -276,7 +283,10 @@ SC.View.reopen(
       }
 
       // if no parents have a next sibling, start over from the beginning
-      if(!next) next = this.get('pane');
+      if(!next) {
+        if(!SC.TABBING_ONLY_INSIDE_DOCUMENT) break;
+        else next = this.get('pane');
+      }
 
       // if it's a valid firstResponder, we're done!
       if(next.get('isVisibleInWindow') && next.get('acceptsFirstResponder')) return next;
@@ -287,7 +297,6 @@ SC.View.reopen(
 
     // this will only happen if no views are visible and accept first responder
     return null;
-
   }.property('nextKeyView'),
 
   /**
@@ -355,6 +364,9 @@ SC.View.reopen(
       // normally, just try to get previous view's last child
       if(cur.get('parentView')) prev = cur._getPreviousKeyView();
 
+      // if we are the pane and address bar tabbing is enabled, trigger it now
+      else if(!SC.TABBING_ONLY_INSIDE_DOCUMENT) break;
+
       // if we are the pane, get our own last child
       else prev = cur;
 

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

@@ -126,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/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()
+};