ember-rails 0.6.0 → 0.7.0

data/README.md

@@ -27,7 +27,7 @@ to use `rails g ember:bootstrap` to create the following directory structure und
     controllers/
     helpers/
     models/
-    states/
+    routes/
     templates/
     views/
 

data/lib/ember/handlebars/assets/ember-precompiler.js

@@ -18,6 +18,7 @@ var jQuery = window.jQuery = function() { return jQuery; };
 jQuery.ready = function() { return jQuery; };
 jQuery.inArray = function() { return jQuery; };
 jQuery.jquery = "1.7.2";
+jQuery.event = {fixHooks: {}};
 
 // Precompiler
 var EmberRails = {

data/lib/ember/rails/engine.rb

@@ -17,16 +17,6 @@ module Ember
         app.assets.register_engine '.handlebars', Ember::Handlebars::Template
         app.assets.register_engine '.hbs', Ember::Handlebars::Template
         app.assets.register_engine '.hjs', Ember::Handlebars::Template
-
-        # Add the gem's vendored ember to the end of the asset search path
-        variant = app.config.ember.variant
-
-        if variant.nil?
-          warn "[EMBER-RAILS] `ember.variant` was not found in your current environment"
-        end
-
-        ember_path = File.expand_path("../../../../vendor/ember/#{variant}", __FILE__)
-        app.config.assets.paths.unshift ember_path
       end
     end
   end

data/lib/ember/rails/version.rb

@@ -1,5 +1,5 @@
 module Ember
   module Rails
-    VERSION = '0.6.0'
+    VERSION = '0.7.0'
   end
 end

data/lib/ember_rails.rb

@@ -1,3 +1,4 @@
+require 'rails'
 require 'ember/rails/version'
 require 'ember/version'
 require 'ember/handlebars/version'
@@ -19,15 +20,28 @@ module Ember
       end
 
       initializer "ember_rails.setup_vendor", :after => "ember_rails.setup", :group => :all do |app|
-        # Add the gem's vendored ember to the end of the asset search path
-        variant = app.config.ember.variant
-        ember_path = app.root.join("vendor/assets/ember/#{variant}")
-        app.config.assets.paths.unshift(ember_path.to_s) if ember_path.exist?
+        if variant = app.config.ember.variant
+          # Add the gem's vendored ember to the end of the asset search path
+          ember_path = File.expand_path("../../vendor/ember/#{variant}", __FILE__)
+          app.config.assets.paths.push(ember_path.to_s)
+
+          # Allow a local variant override
+          ember_path = app.root.join("vendor/assets/ember/#{variant}")
+          app.config.assets.paths.unshift(ember_path.to_s) if ember_path.exist?
+        else
+          warn "No ember.js variant was specified in your config environment."
+          warn "You can set a specific variant in your application config in "
+          warn "order for sprockets to locate ember's assets:"
+          warn ""
+          warn "    config.ember.variant = :development"
+          warn ""
+          warn "Valid values are :development and :production"
+        end
       end
 
       initializer "ember_rails.find_ember", :after => "ember_rails.setup_vendor", :group => :all do |app|
-        config.ember.ember_location = location_for(app, "ember.js")
-        config.ember.handlebars_location = location_for(app, "handlebars.js")
+        config.ember.ember_location ||= location_for(app, "ember.js")
+        config.ember.handlebars_location ||= location_for(app, "handlebars.js")
       end
 
       def location_for(app, file)

data/lib/generators/ember/bootstrap_generator.rb

@@ -51,20 +51,6 @@ module Ember
       def create_app_stubs
         generate "ember:view", "application"
       end
-
-      def inject_proper_ember_version
-        environment <<-RUBY.strip_heredoc, :env => :development
-          config.ember.variant = :development
-        RUBY
-
-        environment <<-RUBY.strip_heredoc, :env => :test
-          config.ember.variant = :development
-        RUBY
-
-        environment <<-RUBY.strip_heredoc, :env => :production
-          config.ember.variant = :production
-        RUBY
-      end
     end
   end
 end

data/lib/generators/ember/controller_generator.rb

@@ -7,11 +7,14 @@ module Ember
 
       desc "Creates a new Ember.js controller"
       class_option :array, :type => :boolean, :default => false, :desc => "Create an Ember.ArrayController to represent multiple objects"
+      class_option :object, :type => :boolean, :default => false, :desc => "Create an Ember.ObjectController to represent a single object"
 
       def create_controller_files
         file_path = File.join('app/assets/javascripts/controllers', class_path, "#{file_name}_controller.js")
         if options.array?
           template 'array_controller.js', file_path
+        elsif options.object?
+          template 'object_controller.js', file_path
         else
           template 'controller.js', file_path
         end

data/lib/generators/ember/install_generator.rb

@@ -20,7 +20,7 @@ module Ember
             cmd command
           else
             Dir.chdir git_root do
-              command = "git fetch --force --quiet --tags && git reset origin/master --hard"
+              command = "git fetch origin && git reset origin/master --hard"
               say_status("updating", command, :green)
 
               cmd command
@@ -35,13 +35,49 @@ module Ember
             end
           end
 
-          self.class.source_root File.join(git_root, "dist")
+          source_paths << File.join(git_root, "dist")
 
           copy_file "ember.js", "vendor/assets/ember/development/ember.js"
           copy_file "ember.min.js", "vendor/assets/ember/production/ember.js"
         end
       end
 
+      def copy_ember_data
+        if options.head?
+
+          git_root = File.expand_path "~/.ember-data"
+          gem_file = File.join git_root, "Gemfile"
+
+          # If it doesn't exist yet
+          unless File.exist?(git_root)
+            command = %{git clone git://github.com/emberjs/data.git "#{git_root}"}
+            say_status("downloading", command, :green)
+
+            cmd command
+          else
+            Dir.chdir git_root do
+              command = "git fetch origin && git reset origin/master --hard"
+              say_status("updating", command, :green)
+
+              cmd command
+            end
+          end
+
+          Dir.chdir git_root do
+            say_status("building", "bundle && bundle exec rake", :green)
+            Bundler.with_clean_env do
+              cmd "bundle --gemfile #{gem_file}"
+              cmd %{BUNDLE_GEMFILE="#{gem_file}" bundle exec rake}
+            end
+          end
+
+          source_paths << File.join(git_root, "dist")
+
+          copy_file "ember-data.js", "vendor/assets/ember/development/ember-data.js"
+          copy_file "ember-data.min.js", "vendor/assets/ember/production/ember-data.js"
+        end
+      end
+
       private
 
       def cmd(command)

data/lib/generators/ember/resource_override.rb

@@ -14,7 +14,7 @@ module Rails
 
         say_status :invoke, "ember controller and view (singular)", :white
         with_padding do
-          invoke "ember:view"
+          invoke "ember:view", [singular_name], :object => true
         end
 
         @_invocations[Ember::Generators::ControllerGenerator].delete "create_controller_files"

data/lib/generators/ember/view_generator.rb

@@ -7,6 +7,7 @@ module Ember
 
       desc "Creates a new Ember.js view and associated Handlebars template"
       class_option :array, :type => :boolean, :default => false, :desc => "Create an Ember.ArrayController to represent multiple objects"
+      class_option :object, :type => :boolean, :default => false, :desc => "Create an Ember.ObjectController to represent a single object"
 
       def create_view_files
         template 'view.js', File.join('app/assets/javascripts/views', class_path, "#{file_name}_view.js")

data/lib/generators/templates/app.js

@@ -7,9 +7,4 @@
 //= require_tree ./routes
 //= require_self
 
-var router = <%= application_name.camelize %>.router = <%= application_name.camelize %>.Router.create({
-  location: 'hash'
-});
-
-<%= application_name.camelize %>.initialize(router);
-
+<%= application_name.camelize %>.initialize();

data/lib/generators/templates/array_controller.js

@@ -1,7 +1,3 @@
 <%= application_name.camelize %>.<%= class_name %>Controller = Ember.ArrayController.extend({
-  // Implement your controller here.
-  //
-  // An ArrayController has a `content` property, which you should
-  // set up in your router.
-});
 
+});

data/lib/generators/templates/controller.js

@@ -1,4 +1,3 @@
-<%= application_name.camelize %>.<%= class_name %>Controller = Ember.ObjectController.extend({
-  // Implement your controller here.
-});
+<%= application_name.camelize %>.<%= class_name %>Controller = Ember.Controller.extend({
 
+});

data/lib/generators/templates/object_controller.js

@@ -0,0 +1,3 @@
+<%= application_name.camelize %>.<%= class_name %>Controller = Ember.ObjectController.extend({
+
+});

data/lib/generators/templates/router.js

@@ -1,6 +1,8 @@
 <%= application_name.camelize %>.Router = Ember.Router.extend({
-  root: Ember.State.extend({
-    index: Ember.State.extend({
+  location: 'hash',
+
+  root: Ember.Route.extend({
+    index: Ember.Route.extend({
       route: '/'
 
       // You'll likely want to connect a view here.

data/vendor/ember/development/ember-data.js

@@ -36,42 +36,14 @@ DS.RecordArray = Ember.ArrayProxy.extend({
   // The store that created this record array.
   store: null,
 
-  init: function() {
-    set(this, 'recordCache', Ember.A([]));
-    this._super();
-  },
-
-  arrayDidChange: function(array, index, removed, added) {
-    var recordCache = get(this, 'recordCache');
-    recordCache.replace(index, 0, new Array(added));
-
-    this._super(array, index, removed, added);
-  },
-
-  arrayWillChange: function(array, index, removed, added) {
-    this._super(array, index, removed, added);
-
-    var recordCache = get(this, 'recordCache');
-    recordCache.replace(index, removed);
-  },
-
   objectAtContent: function(index) {
-    var recordCache = get(this, 'recordCache');
-    var record = recordCache.objectAt(index);
-
-    if (!record) {
-      var store = get(this, 'store');
-      var content = get(this, 'content');
-
-      var contentObject = content.objectAt(index);
+    var content = get(this, 'content'),
+        clientId = content.objectAt(index),
+        store = get(this, 'store');
 
-      if (contentObject !== undefined) {
-        record = store.findByClientId(get(this, 'type'), contentObject);
-        recordCache.replace(index, 1, [record]);
-      }
+    if (clientId !== undefined) {
+      return store.findByClientId(get(this, 'type'), clientId);
     }
-
-    return record;
   }
 });
 
@@ -156,7 +128,7 @@ Set.prototype = {
 
     delete hash[guid];
     var list = this.list,
-        index = Ember.ArrayUtils.indexOf(this, item);
+        index = Ember.EnumerableUtils.indexOf(this, item);
 
     list.splice(index, 1);
   },
@@ -166,7 +138,7 @@ Set.prototype = {
   }
 };
 
-var ManyArrayState = Ember.State.extend({
+var LoadedState = Ember.State.extend({
   recordWasAdded: function(manager, record) {
     var dirty = manager.dirty, observer;
     dirty.add(record);
@@ -195,7 +167,21 @@ var ManyArrayState = Ember.State.extend({
 });
 
 var states = {
-  clean: ManyArrayState.create({
+  loading: Ember.State.create({
+    isLoaded: false,
+    isDirty: false,
+
+    loadedRecords: function(manager, count) {
+      manager.decrement(count);
+    },
+
+    becameLoaded: function(manager) {
+      manager.transitionTo('clean');
+    }
+  }),
+
+  clean: LoadedState.create({
+    isLoaded: true,
     isDirty: false,
 
     recordWasAdded: function(manager, record) {
@@ -209,7 +195,8 @@ var states = {
     }
   }),
 
-  dirty: ManyArrayState.create({
+  dirty: LoadedState.create({
+    isLoaded: true,
     isDirty: true,
 
     childWasSaved: function(manager, child) {
@@ -222,17 +209,37 @@ var states = {
     arrayBecameSaved: function(manager) {
       manager.goToState('clean');
     }
-  }) 
+  })
 };
 
 DS.ManyArrayStateManager = Ember.StateManager.extend({
   manyArray: null,
-  initialState: 'clean',
+  initialState: 'loading',
   states: states,
 
+  /**
+   This number is used to keep track of the number of outstanding
+   records that must be loaded before the array is considered
+   loaded. As results stream in, this number is decremented until
+   it becomes zero, at which case the `isLoaded` flag will be set
+   to true
+  */
+  counter: 0,
+
   init: function() {
     this._super();
     this.dirty = new Set();
+    this.counter = get(this, 'manyArray.length');
+  },
+
+  decrement: function(count) {
+    var counter = this.counter = this.counter - count;
+
+    Ember.assert("Somehow the ManyArray loaded counter went below 0. This is probably an ember-data bug. Please report it at https://github.com/emberjs/data/issues", counter >= 0);
+
+    if (counter === 0) {
+      this.send('becameLoaded');
+    }
   }
 });
 
@@ -241,7 +248,7 @@ DS.ManyArrayStateManager = Ember.StateManager.extend({
 
 
 (function() {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+var get = Ember.get, set = Ember.set;
 
 DS.ManyArray = DS.RecordArray.extend({
   init: function() {
@@ -253,23 +260,27 @@ DS.ManyArray = DS.RecordArray.extend({
   parentRecord: null,
 
   isDirty: Ember.computed(function() {
-    return getPath(this, 'stateManager.currentState.isDirty');
+    return get(this, 'stateManager.currentState.isDirty');
+  }).property('stateManager.currentState').cacheable(),
+
+  isLoaded: Ember.computed(function() {
+    return get(this, 'stateManager.currentState.isLoaded');
   }).property('stateManager.currentState').cacheable(),
 
+  send: function(event, context) {
+    this.get('stateManager').send(event, context);
+  },
+
   fetch: function() {
     var clientIds = get(this, 'content'),
         store = get(this, 'store'),
         type = get(this, 'type');
 
-    var ids = clientIds.map(function(clientId) {
-      return store.clientIdToId[clientId];
-    });
-
-    store.fetchMany(type, ids);
+    store.fetchUnloadedClientIds(type, clientIds);
   },
 
   // Overrides Ember.Array's replace method to implement
-  replace: function(index, removed, added) {
+  replaceContent: function(index, removed, added) {
     var parentRecord = get(this, 'parentRecord');
     var pendingParent = parentRecord && !get(parentRecord, 'id');
     var stateManager = get(this, 'stateManager');
@@ -286,7 +297,10 @@ DS.ManyArray = DS.RecordArray.extend({
         record.send('waitingOn', parentRecord);
       }
 
-      this.assignInverse(record, parentRecord);
+      var oldParent = this.assignInverse(record, parentRecord);
+
+      record.get('transaction')
+        .relationshipBecameDirty(record, oldParent, parentRecord);
 
       stateManager.send('recordWasAdded', record);
 
@@ -299,7 +313,10 @@ DS.ManyArray = DS.RecordArray.extend({
     for (var i = index; i < len; i++) {
       // TODO: null out inverse FK
       record = this.objectAt(i);
-      this.assignInverse(record, parentRecord, true);
+      var oldParent = this.assignInverse(record, parentRecord, true);
+
+      record.get('transaction')
+        .relationshipBecameDirty(record, parentRecord, null);
 
       // If we put the child record into a pending state because
       // we were waiting on the parent record to get an id, we
@@ -317,7 +334,7 @@ DS.ManyArray = DS.RecordArray.extend({
   assignInverse: function(record, parentRecord, remove) {
     var associationMap = get(record.constructor, 'associations'),
         possibleAssociations = associationMap.get(parentRecord.constructor),
-        possible, actual;
+        possible, actual, oldParent;
 
     if (!possibleAssociations) { return; }
 
@@ -331,7 +348,9 @@ DS.ManyArray = DS.RecordArray.extend({
     }
 
     if (actual) {
+      oldParent = get(record, actual.name);
       set(record, actual.name, remove ? null : parentRecord);
+      return oldParent;
     }
   },
 
@@ -362,7 +381,8 @@ DS.ManyArray = DS.RecordArray.extend({
 
 
 (function() {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
+var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt,
+    removeObject = Ember.EnumerableUtils.removeObject;
 
 /**
   A transaction allows you to collect multiple records into a unit of work
@@ -381,7 +401,7 @@ var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.Strin
   If you do not explicitly create a transaction, a record is assigned to
   an implicit transaction called the default transaction. In these cases,
   you can treat your application's instance of `DS.Store` as a transaction
-  and call the `commit()` and `rollback()` methods on the store itself. 
+  and call the `commit()` and `rollback()` methods on the store itself.
 
   Once a record has been successfully committed or rolled back, it will
   be moved back to the implicit transaction. Because it will now be in
@@ -457,6 +477,12 @@ DS.Transaction = Ember.Object.extend({
       deleted:  Ember.Map.create(),
       inflight: Ember.Map.create()
     });
+
+    this.dirtyRelationships = {
+      byChild: Ember.Map.create(),
+      byNewParent: Ember.Map.create(),
+      byOldParent: Ember.Map.create()
+    };
   },
 
   /**
@@ -487,7 +513,7 @@ DS.Transaction = Ember.Object.extend({
     Ember.assert("Once a record has changed, you cannot move it into a different transaction", !get(record, 'isDirty'));
 
     var recordTransaction = get(record, 'transaction'),
-        defaultTransaction = getPath(this, 'store.defaultTransaction');
+        defaultTransaction = get(this, 'store.defaultTransaction');
 
     Ember.assert("Models cannot belong to more than one transaction at a time.", recordTransaction === defaultTransaction);
 
@@ -599,7 +625,7 @@ DS.Transaction = Ember.Object.extend({
     @param {DS.Model} record
   */
   remove: function(record) {
-    var defaultTransaction = getPath(this, 'store.defaultTransaction');
+    var defaultTransaction = get(this, 'store.defaultTransaction');
     defaultTransaction.adoptRecord(record);
   },
 
@@ -696,6 +722,113 @@ DS.Transaction = Ember.Object.extend({
     records.remove(record);
   },
 
+  /**
+    @private
+
+    Called by a ManyArray when a new record is added to it. This
+    method will index a relationship description by the child
+    record, its old parent, and its new parent.
+
+    The store will provide this description to the adapter's
+    shouldCommit method, so it can determine whether any of
+    the records is pending another record. The store will also
+    provide a list of these descriptions to the adapter's commit
+    method.
+
+    @param {DS.Model} record the new child record
+    @param {DS.Model} oldParent the parent that the child is
+      moving from, or null
+    @param {DS.Model} newParent the parent that the child is
+      moving to, or null
+  */
+  relationshipBecameDirty: function(child, oldParent, newParent) {
+    var relationships = this.dirtyRelationships, relationship;
+
+    var relationshipsForChild = relationships.byChild.get(child),
+        possibleRelationship,
+        needsNewEntries = true;
+
+    // If the child has any existing dirty relationships in this
+    // transaction, we need to collapse the old relationship
+    // into the new one. For example, if we change the parent of
+    // a child record before saving, there is no need to save the
+    // record that was its parent temporarily.
+    if (relationshipsForChild) {
+
+      // Loop through all of the relationships we know about that
+      // contain the same child as the new relationship.
+      for (var i=0, l=relationshipsForChild.length; i<l; i++) {
+        relationship = relationshipsForChild[i];
+
+        // If the parent of the child record has changed, there is
+        // no need to update the old parent that had not yet been saved.
+        //
+        // This case is two changes in a record's parent:
+        //
+        //   A -> B
+        //   B -> C
+        //
+        // In this case, there is no need to remember the A->B
+        // change. We can collapse both changes into:
+        //
+        //   A -> C
+        //
+        // Another possible case is:
+        //
+        //   A -> B
+        //   B -> A
+        //
+        // In this case, we don't need to do anything. We can
+        // simply remove the original A->B change and call it
+        // a day.
+        if (relationship.newParent === oldParent) {
+          oldParent = relationship.oldParent;
+          this.removeRelationship(relationship);
+
+          // This is the case of A->B followed by B->A.
+          if (relationship.oldParent === newParent) {
+            needsNewEntries = false;
+          }
+        }
+      }
+    }
+
+    relationship = {
+      child: child,
+      oldParent: oldParent,
+      newParent: newParent
+    };
+
+    // If we didn't go A->B and then B->A, add new dirty relationship
+    // entries.
+    if (needsNewEntries) {
+      this.addRelationshipTo('byChild', child, relationship);
+      this.addRelationshipTo('byOldParent', oldParent, relationship);
+      this.addRelationshipTo('byNewParent', newParent, relationship);
+    }
+  },
+
+  removeRelationship: function(relationship) {
+    var relationships = this.dirtyRelationships;
+
+    removeObject(relationships.byOldParent.get(relationship.oldParent), relationship);
+    removeObject(relationships.byNewParent.get(relationship.newParent), relationship);
+    removeObject(relationships.byChild.get(relationship.child), relationship);
+  },
+
+  addRelationshipTo: function(type, record, description) {
+    var map = this.dirtyRelationships[type];
+
+    var relationships = map.get(record);
+
+    if (!relationships) {
+      relationships = [ description ];
+      map.set(record, relationships);
+    } else {
+      relationships.push(description);
+    }
+  },
+
   /**
     @private
 
@@ -746,7 +879,7 @@ DS.Transaction = Ember.Object.extend({
 
 (function() {
 /*globals Ember*/
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
+var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt;
 
 var DATA_PROXY = {
   get: function(name) {
@@ -824,6 +957,13 @@ DS.Store = Ember.Object.extend({
     this.clientIdToId = {};
     this.recordArraysByClientId = {};
 
+    // Internally, we maintain a map of all unloaded IDs requested by
+    // a ManyArray. As the adapter loads hashes into the store, the
+    // store notifies any interested ManyArrays. When the ManyArray's
+    // total number of loading records drops to zero, it becomes
+    // `isLoaded` and fires a `didLoad` event.
+    this.loadingRecordArrays = {};
+
     set(this, 'defaultTransaction', this.transaction());
 
     return this._super();
@@ -872,7 +1012,7 @@ DS.Store = Ember.Object.extend({
   _adapter: Ember.computed(function() {
     var adapter = get(this, 'adapter');
     if (typeof adapter === 'string') {
-      return getPath(this, adapter, false) || getPath(window, adapter);
+      return get(this, adapter, false) || get(window, adapter);
     }
     return adapter;
   }).property('adapter').cacheable(),
@@ -1048,8 +1188,7 @@ DS.Store = Ember.Object.extend({
 
   findByClientId: function(type, clientId, id) {
     var recordCache = get(this, 'recordCache'),
-        dataCache = this.typeMapFor(type).cidToHash,
-        record;
+        dataCache, record;
 
     // If there is already a clientId assigned for this
     // type/id combination, try to find an existing
@@ -1064,6 +1203,8 @@ DS.Store = Ember.Object.extend({
         // 'isLoading' state
         record = this.materializeRecord(type, clientId);
 
+        dataCache = this.typeMapFor(type).cidToHash;
+
         if (typeof dataCache[clientId] === 'object') {
           record.send('didChangeData');
         }
@@ -1087,78 +1228,123 @@ DS.Store = Ember.Object.extend({
   /**
     @private
 
-    Ask the adapter to fetch IDs that are not already loaded.
+    Given a type and array of `clientId`s, determines which of those
+    `clientId`s has not yet been loaded.
+
+    In preparation for loading, this method also marks any unloaded
+    `clientId`s as loading.
+  */
+  neededClientIds: function(type, clientIds) {
+    var neededClientIds = [],
+        typeMap = this.typeMapFor(type),
+        dataCache = typeMap.cidToHash,
+        clientId;
+
+    for (var i=0, l=clientIds.length; i<l; i++) {
+      clientId = clientIds[i];
+      if (dataCache[clientId] === UNLOADED) {
+        neededClientIds.push(clientId);
+        dataCache[clientId] = LOADING;
+      }
+    }
+
+    return neededClientIds;
+  },
 
-    This method will convert `id`s to `clientId`s, filter out
-    `clientId`s that already have a data hash present, and pass
-    the remaining `id`s to the adapter.
+  /**
+    @private
 
-    @param {Class} type A model class
-    @param {Array} ids An array of ids
-    @param {Object} query
+    This method is the entry point that associations use to update
+    themselves when their underlying data changes.
 
-    @returns {Array} An Array of all clientIds for the
-      specified ids.
+    First, it determines which of its `clientId`s are still unloaded,
+    then converts the needed `clientId`s to IDs and invokes `findMany`
+    on the adapter.
   */
-  fetchMany: function(type, ids, query) {
-    var typeMap = this.typeMapFor(type),
-        idToClientIdMap = typeMap.idToCid,
-        dataCache = typeMap.cidToHash,
-        data = typeMap.cidToHash,
-        needed;
+  fetchUnloadedClientIds: function(type, clientIds) {
+    var neededClientIds = this.neededClientIds(type, clientIds);
+    this.fetchMany(type, neededClientIds);
+  },
 
-    var clientIds = Ember.A([]);
+  /**
+    @private
 
-    if (ids) {
-      needed = [];
-
-      ids.forEach(function(id) {
-        // Get the clientId for the given id
-        var clientId = idToClientIdMap[id];
-
-        // If there is no `clientId` yet
-        if (clientId === undefined) {
-          // Create a new `clientId`, marking its data hash
-          // as loading. Once the adapter returns the data
-          // hash, it will be updated
-          clientId = this.pushHash(LOADING, id, type);
-          needed.push(id);
-
-        // If there is a clientId, but its data hash is
-        // marked as unloaded (this happens when a
-        // hasMany association creates clientIds for its
-        // referenced ids before they were loaded)
-        } else if (clientId && data[clientId] === UNLOADED) {
-          // change the data hash marker to loading
-          dataCache[clientId] = LOADING;
-          needed.push(id);
-        }
+    This method takes a type and list of `clientId`s, converts the
+    `clientId`s into IDs, and then invokes the adapter's `findMany`
+    method.
 
-        // this method is expected to return a list of
-        // all of the clientIds for the specified ids,
-        // unconditionally add it.
-        clientIds.push(clientId);
-      }, this);
-    } else {
-      needed = null;
-    }
+    It is used both by a brand new association (via the `findMany`
+    method) or when the data underlying an existing association
+    changes (via the `fetchUnloadedClientIds` method).
+  */
+  fetchMany: function(type, clientIds) {
+    var clientIdToId = this.clientIdToId;
 
-    // If there are any needed ids, ask the adapter to load them
-    if ((needed && get(needed, 'length') > 0) || query) {
-      var adapter = get(this, '_adapter');
-      if (adapter && adapter.findMany) { adapter.findMany(this, type, needed, query); }
-      else { throw fmt("Adapter is either null or does not implement `findMany` method", this); }
-    }
+    var neededIds = Ember.EnumerableUtils.map(clientIds, function(clientId) {
+      return clientIdToId[clientId];
+    });
+
+    if (!neededIds.length) { return; }
 
-    return clientIds;
+    var adapter = get(this, '_adapter');
+    if (adapter && adapter.findMany) { adapter.findMany(this, type, neededIds); }
+    else { throw fmt("Adapter is either null or does not implement `findMany` method", this); }
   },
 
-  /** @private
+  /**
+    @private
+
+    `findMany` is the entry point that associations use to generate a
+    new `ManyArray` for the list of IDs specified by the server for
+    the association.
+
+    Its responsibilities are:
+
+    * convert the IDs into clientIds
+    * determine which of the clientIds still need to be loaded
+    * create a new ManyArray whose content is *all* of the clientIds
+    * notify the ManyArray of the number of its elements that are
+      already loaded
+    * insert the unloaded clientIds into the `loadingRecordArrays`
+      bookkeeping structure, which will allow the `ManyArray` to know
+      when all of its loading elements are loaded from the server.
+    * ask the adapter to load the unloaded elements, by invoking
+      findMany with the still-unloaded IDs.
   */
-  findMany: function(type, ids, query) {
-    var clientIds = this.fetchMany(type, ids, query);
+  findMany: function(type, ids) {
+    // 1. Convert ids to client ids
+    // 2. Determine which of the client ids need to be loaded
+    // 3. Create a new ManyArray whose content is ALL of the clientIds
+    // 4. Decrement the ManyArray's counter by the number of loaded clientIds
+    // 5. Put the ManyArray into our bookkeeping data structure, keyed on
+    //    the needed clientIds
+    // 6. Ask the adapter to load the records for the unloaded clientIds (but
+    //    convert them back to ids)
+
+    var clientIds = this.clientIdsForIds(type, ids);
+
+    var neededClientIds = this.neededClientIds(type, clientIds),
+        manyArray = this.createManyArray(type, Ember.A(clientIds)),
+        loadedCount = clientIds.length - neededClientIds.length,
+        loadingRecordArrays = this.loadingRecordArrays,
+        clientId, i, l;
+
+    manyArray.send('loadedRecords', loadedCount);
+
+    if (neededClientIds.length) {
+      for (i=0, l=neededClientIds.length; i<l; i++) {
+        clientId = neededClientIds[i];
+        if (loadingRecordArrays[clientId]) {
+          loadingRecordArrays[clientId].push(manyArray);
+        } else {
+          this.loadingRecordArrays[clientId] = [ manyArray ];
+        }
+      }
+
+      this.fetchMany(type, neededClientIds);
+    }
 
-    return this.createManyArray(type, clientIds);
+    return manyArray;
   },
 
   findQuery: function(type, query) {
@@ -1201,6 +1387,10 @@ DS.Store = Ember.Object.extend({
     return array;
   },
 
+  recordIsLoaded: function(type, id) {
+    return !Ember.none(this.typeMapFor(type).idToCid[id]);
+  },
+
   // ............
   // . UPDATING .
   // ............
@@ -1361,21 +1551,28 @@ DS.Store = Ember.Object.extend({
         clientIds = typeMap.clientIds,
         clientId, hash, proxy;
 
-    var recordCache = get(this, 'recordCache'), record;
+    var recordCache = get(this, 'recordCache'),
+        foundRecord,
+        record;
 
     for (var i=0, l=clientIds.length; i<l; i++) {
       clientId = clientIds[i];
+      foundRecord = false;
 
       hash = dataCache[clientId];
       if (typeof hash === 'object') {
         if (record = recordCache[clientId]) {
-          proxy = get(record, 'data');
+          if (!get(record, 'isDeleted')) {
+            proxy = get(record, 'data');
+            foundRecord = true;
+          }
         } else {
           DATA_PROXY.savedData = hash;
           proxy = DATA_PROXY;
+          foundRecord = true;
         }
 
-        this.updateRecordArray(array, filter, type, clientId, proxy);
+        if (foundRecord) { this.updateRecordArray(array, filter, type, clientId, proxy); }
       }
     }
   },
@@ -1388,6 +1585,18 @@ DS.Store = Ember.Object.extend({
       filter = get(array, 'filterFunction');
       this.updateRecordArray(array, filter, type, clientId, dataProxy);
     }, this);
+
+    // loop through all manyArrays containing an unloaded copy of this
+    // clientId and notify them that the record was loaded.
+    var manyArrays = this.loadingRecordArrays[clientId], manyArray;
+
+    if (manyArrays) {
+      for (var i=0, l=manyArrays.length; i<l; i++) {
+        manyArrays[i].send('loadedRecords', 1);
+      }
+
+      this.loadingRecordArrays[clientId] = null;
+    }
   },
 
   updateRecordArray: function(array, filter, type, clientId, dataProxy) {
@@ -1473,6 +1682,24 @@ DS.Store = Ember.Object.extend({
     return this.pushHash(UNLOADED, id, type);
   },
 
+  /**
+    @private
+
+    This method works exactly like `clientIdForId`, but does not
+    require looking up the `typeMap` for every `clientId` and
+    invoking a method per `clientId`.
+  */
+  clientIdsForIds: function(type, ids) {
+    var typeMap = this.typeMapFor(type),
+        idToClientIdMap = typeMap.idToCid;
+
+    return Ember.EnumerableUtils.map(ids, function(id) {
+      var clientId = idToClientIdMap[id];
+      if (clientId) { return clientId; }
+      return this.pushHash(UNLOADED, id, type);
+    }, this);
+  },
+
   // ................
   // . LOADING DATA .
   // ................
@@ -1527,7 +1754,7 @@ DS.Store = Ember.Object.extend({
       ids = [];
       var primaryKey = type.proto().primaryKey;
 
-      ids = Ember.ArrayUtils.map(hashes, function(hash) {
+      ids = Ember.EnumerableUtils.map(hashes, function(hash) {
         return hash[primaryKey];
       });
     }
@@ -1607,7 +1834,7 @@ DS.Store = Ember.Object.extend({
 
 
 (function() {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath, guidFor = Ember.guidFor;
+var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor;
 
 /**
   This file encapsulates the various states that a record can transition
@@ -1636,7 +1863,7 @@ var get = Ember.get, set = Ember.set, getPath = Ember.getPath, guidFor = Ember.g
   string. You can determine a record's current state by getting its manager's
   current state path:
 
-        record.getPath('stateManager.currentState.path');
+        record.get('stateManager.currentState.path');
         //=> "created.uncommitted"
 
   The `DS.Model` states are themselves stateless. What we mean is that,
@@ -1722,7 +1949,7 @@ var get = Ember.get, set = Ember.set, getPath = Ember.getPath, guidFor = Ember.g
   state in a more user-friendly way than examining its state path. For example,
   instead of doing this:
 
-      var statePath = record.getPath('stateManager.currentState.path');
+      var statePath = record.get('stateManager.currentState.path');
       if (statePath === 'created.inFlight') {
         doSomething();
       }
@@ -1889,7 +2116,7 @@ var waitingOn = function(manager, object) {
 // super points to the class definition.
 var Uncommitted = Ember.Mixin.create({
   setProperty: setProperty,
-  setAssociation: setAssociation,
+  setAssociation: setAssociation
 });
 
 // These mixins are mixed into substates of the concrete
@@ -1983,7 +2210,7 @@ var DirtyState = DS.State.extend({
         t.recordBecameClean(dirtyType, record);
       });
 
-      manager.goToState('loaded');
+      manager.goToState('saved');
     }
   }, Uncommitted),
 
@@ -2013,7 +2240,7 @@ var DirtyState = DS.State.extend({
         t.recordBecameClean('inflight', record);
       });
 
-      manager.goToState('loaded');
+      manager.goToState('saved');
       manager.send('invokeLifecycleCallbacks', dirtyType);
     },
 
@@ -2164,7 +2391,7 @@ var DirtyState = DS.State.extend({
           errors = get(record, 'errors'),
           key = context.key;
 
-      delete errors[key];
+      set(errors, key, null);
 
       if (!hasDefinedProperties(errors)) {
         manager.send('becameValid');
@@ -2182,7 +2409,7 @@ var DirtyState = DS.State.extend({
 
     invokeLifecycleCallbacks: function(manager) {
       var record = get(manager, 'record');
-      record.fire('becameInvalid', record);
+      record.trigger('becameInvalid', record);
     }
   })
 });
@@ -2272,7 +2499,7 @@ var states = {
       // TRANSITIONS
       exit: function(manager) {
         var record = get(manager, 'record');
-        record.fire('didLoad');
+        record.trigger('didLoad');
       },
 
       // EVENTS
@@ -2326,9 +2553,9 @@ var states = {
         invokeLifecycleCallbacks: function(manager, dirtyType) {
           var record = get(manager, 'record');
           if (dirtyType === 'created') {
-            record.fire('didCreate', record);
+            record.trigger('didCreate', record);
           } else {
-            record.fire('didUpdate', record);
+            record.trigger('didUpdate', record);
           }
         }
       }),
@@ -2431,7 +2658,7 @@ var states = {
 
         invokeLifecycleCallbacks: function(manager) {
           var record = get(manager, 'record');
-          record.fire('didDelete', record);
+          record.trigger('didDelete', record);
         }
       })
     }),
@@ -2446,7 +2673,7 @@ var states = {
 
       invokeLifecycleCallbacks: function(manager) {
         var record = get(manager, 'record');
-        record.fire('becameError', record);
+        record.trigger('becameError', record);
       }
     })
   })
@@ -2609,10 +2836,10 @@ DataProxy.prototype = {
 
 
 (function() {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath, none = Ember.none;
+var get = Ember.get, set = Ember.set, none = Ember.none;
 
 var retrieveFromCurrentState = Ember.computed(function(key) {
-  return get(getPath(this, 'stateManager.currentState'), key);
+  return get(get(this, 'stateManager.currentState'), key);
 }).property('stateManager.currentState').cacheable();
 
 DS.Model = Ember.Object.extend(Ember.Evented, {
@@ -2903,12 +3130,18 @@ DS.Model = Ember.Object.extend(Ember.Evented, {
         cachedValue = this.cacheFor(name);
 
         if (cachedValue) {
-          var key = association.options.key || name,
+          var key = association.options.key || get(this, 'namingConvention').keyToJSONKey(name),
               ids = data.get(key) || [];
-          var clientIds = Ember.ArrayUtils.map(ids, function(id) {
-            return store.clientIdForId(association.type, id);
-          });
-
+          
+          var clientIds;   
+          if(association.options.embedded) {
+            clientIds = store.loadMany(association.type, ids).clientIds;
+          } else {
+            clientIds = Ember.EnumerableUtils.map(ids, function(id) {
+              return store.clientIdForId(association.type, id);
+            });
+          }
+          
           set(cachedValue, 'content', Ember.A(clientIds));
           cachedValue.fetch();
         }
@@ -2922,8 +3155,8 @@ DS.Model = Ember.Object.extend(Ember.Evented, {
     Override the default event firing from Ember.Evented to
     also call methods with the given name.
   */
-  fire: function(name) {
-    this[name].apply(this, [].slice.call(arguments, 1));
+  trigger: function(name) {
+    Ember.tryInvoke(this, name, [].slice.call(arguments, 1));
     this._super.apply(this, arguments);
   }
 });
@@ -2943,6 +3176,7 @@ var storeAlias = function(methodName) {
 };
 
 DS.Model.reopenClass({
+  isLoaded: storeAlias('recordIsLoaded'),
   find: storeAlias('find'),
   filter: storeAlias('filter'),
 
@@ -2960,7 +3194,7 @@ DS.Model.reopenClass({
 
 
 (function() {
-var get = Ember.get, getPath = Ember.getPath;
+var get = Ember.get;
 DS.Model.reopenClass({
   attributes: Ember.computed(function() {
     var map = Ember.Map.create();
@@ -2985,6 +3219,17 @@ DS.Model.reopenClass({
   }
 });
 
+function getAttr(record, options, key) {
+  var data = get(record, 'data');
+  var value = get(data, key);
+
+  if (value === undefined) {
+    value = options.defaultValue;
+  }
+
+  return value;
+}
+
 DS.attr = function(type, options) {
   var transform = DS.attr.transforms[type];
   Ember.assert("Could not find model attribute of type " + type, !!transform);
@@ -3014,14 +3259,12 @@ DS.attr = function(type, options) {
 
     if (arguments.length === 2) {
       value = transformTo(value);
-      this.setProperty(key, value);
-    } else {
-      data = get(this, 'data');
-      value = get(data, key);
 
-      if (value === undefined) {
-        value = options.defaultValue;
+      if (value !== getAttr(this, options, key)) {
+        this.setProperty(key, value);
       }
+    } else {
+      value = getAttr(this, options, key);
     }
 
     return transformFrom(value);
@@ -3122,7 +3365,7 @@ DS.attr.transforms = {
 
 
 (function() {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath,
+var get = Ember.get, set = Ember.set,
     none = Ember.none;
 
 var embeddedFindRecord = function(store, type, data, key, one) {
@@ -3147,12 +3390,12 @@ var hasAssociation = function(type, options, one) {
         store = get(this, 'store');
 
     if (typeof type === 'string') {
-      type = getPath(this, type, false) || getPath(window, type);
+      type = get(this, type, false) || get(window, type);
     }
 
     if (arguments.length === 2) {
       key = options.key || get(this, 'namingConvention').foreignKey(key);
-      this.send('setAssociation', { key: key, value: value === null ? null : get(value, 'clientId') });
+      this.send('setAssociation', { key: key, value: Ember.none(value) ? null : get(value, 'clientId') });
       //data.setAssociation(key, get(value, 'clientId'));
       // put the client id in `key` in the data hash
       return value;
@@ -3185,7 +3428,7 @@ DS.belongsTo = function(type, options) {
 
 
 (function() {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+var get = Ember.get, set = Ember.set;
 var embeddedFindRecord = function(store, type, data, key) {
   var association = get(data, key);
   return association ? store.loadMany(type, association).ids : [];
@@ -3209,12 +3452,12 @@ var hasAssociation = function(type, options) {
         ids, id, association;
 
     if (typeof type === 'string') {
-      type = getPath(this, type, false) || getPath(window, type);
+      type = get(this, type, false) || get(window, type);
     }
 
     key = options.key || get(this, 'namingConvention').keyToJSONKey(key);
     ids = findRecord(store, type, data, key);
-    association = store.findMany(type, ids);
+    association = store.findMany(type, ids || []);
     set(association, 'parentRecord', this);
 
     return association;
@@ -3231,7 +3474,7 @@ DS.hasMany = function(type, options) {
 
 
 (function() {
-var get = Ember.get, getPath = Ember.getPath;
+var get = Ember.get;
 
 DS.Model.reopenClass({
   typeForAssociation: function(name) {
@@ -3248,7 +3491,7 @@ DS.Model.reopenClass({
             typeList = map.get(type);
 
         if (typeof type === 'string') {
-          type = getPath(this, type, false) || getPath(window, type);
+          type = get(this, type, false) || get(window, type);
           meta.type = type;
         }
 
@@ -3273,7 +3516,7 @@ DS.Model.reopenClass({
         type = meta.type;
 
         if (typeof type === 'string') {
-          type = getPath(this, type, false) || getPath(window, type);
+          type = get(this, type, false) || get(window, type);
           meta.type = type;
         }
 
@@ -3430,9 +3673,28 @@ DS.Adapter = Ember.Object.extend({
 var set = Ember.set;
 
 Ember.onLoad('application', function(app) {
-  app.registerInjection(function(app, stateManager, property) {
-    if (property === 'Store') {
-      set(stateManager, 'store', app[property].create());
+  app.registerInjection({
+    name: "store",
+    before: "controllers",
+
+    injection: function(app, stateManager, property) {
+      if (property === 'Store') {
+        set(stateManager, 'store', app[property].create());
+      }
+    }
+  });
+
+  app.registerInjection({
+    name: "giveStoreToControllers",
+
+    injection: function(app, stateManager, property) {
+      if (property.match(/Controller$/)) {
+        var controllerName = property.charAt(0).toLowerCase() + property.substr(1);
+        var store = stateManager.get('store');
+        var controller = stateManager.get(controllerName);
+
+        controller.set('store', store);
+      }
     }
   });
 });
@@ -3442,34 +3704,138 @@ Ember.onLoad('application', function(app) {
 
 
 (function() {
-DS.fixtureAdapter = DS.Adapter.create({
+var get = Ember.get;
+
+DS.FixtureAdapter = DS.Adapter.extend({
+
+  simulateRemoteResponse: true,
+
+  latency: 50,
+
+  /*
+    Implement this method in order to provide data associated with a type
+  */
+  fixturesForType: function(type) {
+    return type.FIXTURES ? Ember.A(type.FIXTURES) : null;
+  },
+
+  /*
+    Implement this method in order to query fixtures data
+  */
+  queryFixtures: function(fixtures, query) {
+    return fixtures;
+  },
+
+  /*
+    Implement this method in order to provide provide json for CRUD methods
+  */
+  mockJSON: function(type, record) {
+    return record.toJSON({associations: true});
+  },
+
+  /*
+    Adapter methods
+  */
+  generateIdForRecord: function(store, record) {
+    return Ember.guidFor(record);
+  },
+
   find: function(store, type, id) {
-    var fixtures = type.FIXTURES;
+    var fixtures = this.fixturesForType(type);
 
     Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
-    if (fixtures.hasLoaded) { return; }
 
-    setTimeout(function() {
-      store.loadMany(type, fixtures);
-      fixtures.hasLoaded = true;
-    }, 300);
+    if (fixtures) {
+      fixtures = fixtures.findProperty('id', id);
+    }
+
+    if (fixtures) {
+      this.simulateRemoteCall(function() {
+        store.load(type, fixtures);
+      }, store, type);
+    }
   },
 
-  findMany: function() {
-    this.find.apply(this, arguments);
+  findMany: function(store, type, ids) {
+    var fixtures = this.fixturesForType(type);
+
+    Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
+
+    if (fixtures) {
+      fixtures = fixtures.filter(function(item) {
+        return ids.indexOf(item.id) !== -1;
+      });
+    }
+  
+    if (fixtures) {
+      this.simulateRemoteCall(function() {
+        store.loadMany(type, fixtures);
+      }, store, type);
+    }
   },
 
   findAll: function(store, type) {
-    var fixtures = type.FIXTURES;
+    var fixtures = this.fixturesForType(type);
 
     Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
 
-    var ids = fixtures.map(function(item, index, self){ return item.id; });
-    store.loadMany(type, ids, fixtures);
-  }
+    this.simulateRemoteCall(function() {
+      store.loadMany(type, fixtures);
+    }, store, type);
+  },
+
+  findQuery: function(store, type, query, array) {
+    var fixtures = this.fixturesForType(type);
+    
+    Ember.assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
+
+    fixtures = this.queryFixtures(fixtures, query);
 
+    if (fixtures) {
+      this.simulateRemoteCall(function() {
+        array.load(fixtures);
+      }, store, type);
+    }
+  },
+
+  createRecord: function(store, type, record) {
+    var fixture = this.mockJSON(type, record);
+
+    fixture.id = this.generateIdForRecord(store, record);
+
+    this.simulateRemoteCall(function() {
+      store.didCreateRecord(record, fixture);
+    }, store, type, record);
+  },
+
+  updateRecord: function(store, type, record) {
+    var fixture = this.mockJSON(type, record);
+
+    this.simulateRemoteCall(function() {
+      store.didUpdateRecord(record, fixture);
+    }, store, type, record);
+  },
+
+  deleteRecord: function(store, type, record) {
+    this.simulateRemoteCall(function() {
+      store.didDeleteRecord(record);
+    }, store, type, record);
+  },
+
+  /*
+    @private
+  */
+  simulateRemoteCall: function(callback, store, type, record) {
+    if (get(this, 'simulateRemoteResponse')) {
+      setTimeout(callback, get(this, 'latency'));
+    } else {
+      callback();
+    }
+  }
 });
 
+DS.fixtureAdapter = DS.FixtureAdapter.create();
+
 })();
 
 
@@ -3477,7 +3843,7 @@ DS.fixtureAdapter = DS.Adapter.create({
 (function() {
 /*global jQuery*/
 
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+var get = Ember.get, set = Ember.set;
 
 DS.RESTAdapter = DS.Adapter.extend({
   bulkCommit: false,
@@ -3490,13 +3856,20 @@ DS.RESTAdapter = DS.Adapter.extend({
 
     this.ajax(this.buildURL(root), "POST", {
       data: data,
+      context: this,
       success: function(json) {
-        this.sideload(store, type, json, root);
-        store.didCreateRecord(record, json[root]);
+        this.didCreateRecord(store, type, record, json);
       }
     });
   },
 
+  didCreateRecord: function(store, type, record, json) {
+    var root = this.rootForType(type);
+
+    this.sideload(store, type, json, root);
+    store.didCreateRecord(record, json[root]);
+  },
+
   createRecords: function(store, type, records) {
     if (get(this, 'bulkCommit') === false) {
       return this._super(store, type, records);
@@ -3512,14 +3885,20 @@ DS.RESTAdapter = DS.Adapter.extend({
 
     this.ajax(this.buildURL(root), "POST", {
       data: data,
-
+      context: this,
       success: function(json) {
-        this.sideload(store, type, json, plural);
-        store.didCreateRecords(type, records, json[plural]);
+        this.didCreateRecords(store, type, records, json);
       }
     });
   },
 
+  didCreateRecords: function(store, type, records, json) {
+    var root = this.pluralize(this.rootForType(type));
+
+    this.sideload(store, type, json, root);
+    store.didCreateRecords(type, records, json[root]);
+  },
+
   updateRecord: function(store, type, record) {
     var id = get(record, 'id');
     var root = this.rootForType(type);
@@ -3529,13 +3908,20 @@ DS.RESTAdapter = DS.Adapter.extend({
 
     this.ajax(this.buildURL(root, id), "PUT", {
       data: data,
+      context: this,
       success: function(json) {
-        this.sideload(store, type, json, root);
-        store.didUpdateRecord(record, json && json[root]);
+        this.didUpdateRecord(store, type, record, json);
       }
     });
   },
 
+  didUpdateRecord: function(store, type, record, json) {
+    var root = this.rootForType(type);
+
+    this.sideload(store, type, json, root);
+    store.didUpdateRecord(record, json && json[root]);
+  },
+
   updateRecords: function(store, type, records) {
     if (get(this, 'bulkCommit') === false) {
       return this._super(store, type, records);
@@ -3551,25 +3937,37 @@ DS.RESTAdapter = DS.Adapter.extend({
 
     this.ajax(this.buildURL(root, "bulk"), "PUT", {
       data: data,
+      context: this,
       success: function(json) {
-        this.sideload(store, type, json, plural);
-        store.didUpdateRecords(records, json[plural]);
+        this.didUpdateRecords(store, type, records, json);
       }
     });
   },
 
+  didUpdateRecords: function(store, type, records, json) {
+    var root = this.pluralize(this.rootForType(type));
+
+    this.sideload(store, type, json, root);
+    store.didUpdateRecords(records, json[root]);
+  },
+
   deleteRecord: function(store, type, record) {
     var id = get(record, 'id');
     var root = this.rootForType(type);
 
     this.ajax(this.buildURL(root, id), "DELETE", {
+      context: this,
       success: function(json) {
-        if (json) { this.sideload(store, type, json); }
-        store.didDeleteRecord(record);
+        this.didDeleteRecord(store, type, record, json);
       }
     });
   },
 
+  didDeleteRecord: function(store, type, record, json) {
+    if (json) { this.sideload(store, type, json); }
+    store.didDeleteRecord(record);
+  },
+
   deleteRecords: function(store, type, records) {
     if (get(this, 'bulkCommit') === false) {
       return this._super(store, type, records);
@@ -3585,20 +3983,25 @@ DS.RESTAdapter = DS.Adapter.extend({
 
     this.ajax(this.buildURL(root, 'bulk'), "DELETE", {
       data: data,
+      context: this,
       success: function(json) {
-        if (json) { this.sideload(store, type, json); }
-        store.didDeleteRecords(records);
+        this.didDeleteRecords(store, type, records, json);
       }
     });
   },
 
+  didDeleteRecords: function(store, type, records, json) {
+    if (json) { this.sideload(store, type, json); }
+    store.didDeleteRecords(records);
+  },
+
   find: function(store, type, id) {
     var root = this.rootForType(type);
 
     this.ajax(this.buildURL(root, id), "GET", {
       success: function(json) {
-        store.load(type, json[root]);
         this.sideload(store, type, json, root);
+        store.load(type, json[root]);
       }
     });
   },
@@ -3609,8 +4012,8 @@ DS.RESTAdapter = DS.Adapter.extend({
     this.ajax(this.buildURL(root), "GET", {
       data: { ids: ids },
       success: function(json) {
-        store.loadMany(type, json[plural]);
         this.sideload(store, type, json, plural);
+        store.loadMany(type, json[plural]);
       }
     });
   },
@@ -3620,8 +4023,8 @@ DS.RESTAdapter = DS.Adapter.extend({
 
     this.ajax(this.buildURL(root), "GET", {
       success: function(json) {
-        store.loadMany(type, json[plural]);
         this.sideload(store, type, json, plural);
+        store.loadMany(type, json[plural]);
       }
     });
   },
@@ -3632,8 +4035,8 @@ DS.RESTAdapter = DS.Adapter.extend({
     this.ajax(this.buildURL(root), "GET", {
       data: query,
       success: function(json) {
-        recordArray.load(json[plural]);
         this.sideload(store, type, json, plural);
+        recordArray.load(json[plural]);
       }
     });
   },
@@ -3672,7 +4075,9 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   sideload: function(store, type, json, root) {
-    var sideloadedType, mappings;
+    var sideloadedType, mappings, loaded = {};
+
+    loaded[root] = true;
 
     for (var prop in json) {
       if (!json.hasOwnProperty(prop)) { continue; }
@@ -3685,13 +4090,34 @@ DS.RESTAdapter = DS.Adapter.extend({
         Ember.assert("Your server returned a hash with the key " + prop + " but you have no mappings", !!mappings);
 
         sideloadedType = get(mappings, prop);
+
+        if (typeof sideloadedType === 'string') {
+          sideloadedType = get(window, sideloadedType);
+        }
+
         Ember.assert("Your server returned a hash with the key " + prop + " but you have no mapping for it", !!sideloadedType);
       }
 
-      this.loadValue(store, sideloadedType, json[prop]);
+      this.sideloadAssociations(store, sideloadedType, json, prop, loaded);
     }
   },
 
+  sideloadAssociations: function(store, type, json, prop, loaded) {
+    loaded[prop] = true;
+
+    get(type, 'associationsByName').forEach(function(key, meta) {
+      key = meta.key || key;
+      if (meta.kind === 'belongsTo') {
+        key = this.pluralize(key);
+      }
+      if (json[key] && !loaded[key]) {
+        this.sideloadAssociations(store, meta.type, json, key, loaded);
+      }
+    }, this);
+
+    this.loadValue(store, type, json[prop]);
+  },
+
   loadValue: function(store, type, value) {
     if (value instanceof Array) {
       store.loadMany(type, value);