embient 0.0.8 → 0.0.9

data/Gemfile.lock

@@ -1,38 +1,38 @@
 PATH
   remote: .
   specs:
-    embient (0.0.8)
+    embient (0.0.9)
       emberjs-rails
       rails (>= 3.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    actionmailer (3.2.1)
-      actionpack (= 3.2.1)
+    actionmailer (3.2.0)
+      actionpack (= 3.2.0)
       mail (~> 2.4.0)
-    actionpack (3.2.1)
-      activemodel (= 3.2.1)
-      activesupport (= 3.2.1)
+    actionpack (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
       builder (~> 3.0.0)
       erubis (~> 2.7.0)
-      journey (~> 1.0.1)
+      journey (~> 1.0.0)
       rack (~> 1.4.0)
       rack-cache (~> 1.1)
       rack-test (~> 0.6.1)
       sprockets (~> 2.1.2)
-    activemodel (3.2.1)
-      activesupport (= 3.2.1)
+    activemodel (3.2.0)
+      activesupport (= 3.2.0)
       builder (~> 3.0.0)
-    activerecord (3.2.1)
-      activemodel (= 3.2.1)
-      activesupport (= 3.2.1)
+    activerecord (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
       arel (~> 3.0.0)
       tzinfo (~> 0.3.29)
-    activeresource (3.2.1)
-      activemodel (= 3.2.1)
-      activesupport (= 3.2.1)
-    activesupport (3.2.1)
+    activeresource (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
+    activesupport (3.2.0)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     arel (3.0.2)
@@ -52,13 +52,13 @@ GEM
     hike (1.2.1)
     i18n (0.6.0)
     journey (1.0.3)
-    json (1.6.5)
+    json (1.6.6)
     mail (2.4.4)
       i18n (>= 0.4.0)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
     mime-types (1.18)
-    multi_json (1.1.0)
+    multi_json (1.2.0)
     polyglot (0.3.3)
     rack (1.4.1)
     rack-cache (1.2)
@@ -67,17 +67,17 @@ GEM
       rack
     rack-test (0.6.1)
       rack (>= 1.0)
-    rails (3.2.1)
-      actionmailer (= 3.2.1)
-      actionpack (= 3.2.1)
-      activerecord (= 3.2.1)
-      activeresource (= 3.2.1)
-      activesupport (= 3.2.1)
+    rails (3.2.0)
+      actionmailer (= 3.2.0)
+      actionpack (= 3.2.0)
+      activerecord (= 3.2.0)
+      activeresource (= 3.2.0)
+      activesupport (= 3.2.0)
       bundler (~> 1.0)
-      railties (= 3.2.1)
-    railties (3.2.1)
-      actionpack (= 3.2.1)
-      activesupport (= 3.2.1)
+      railties (= 3.2.0)
+    railties (3.2.0)
+      actionpack (= 3.2.0)
+      activesupport (= 3.2.0)
       rack-ssl (~> 1.3.2)
       rake (>= 0.8.7)
       rdoc (~> 3.4)
@@ -94,7 +94,7 @@ GEM
     treetop (1.4.10)
       polyglot
       polyglot (>= 0.3.1)
-    tzinfo (0.3.32)
+    tzinfo (0.3.33)
 
 PLATFORMS
   ruby

data/lib/embient/version.rb

@@ -1,3 +1,3 @@
 module Embient
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/vendor/assets/javascripts/embient/ember-data.js

@@ -1,510 +1,426 @@
-
-(function(exports) {
+(function() {
 window.DS = Ember.Namespace.create({
-  CURRENT_API_REVISION: 3
+  CURRENT_API_REVISION: 4
 });
 
-})({});
+})();
 
 
-(function(exports) {
-DS.Adapter = Ember.Object.extend({
-  commit: function(store, commitDetails) {
-    commitDetails.updated.eachType(function(type, array) {
-      this.updateRecords(store, type, array.slice());
-    }, this);
 
-    commitDetails.created.eachType(function(type, array) {
-      this.createRecords(store, type, array.slice());
-    }, this);
+(function() {
+var get = Ember.get, set = Ember.set;
 
-    commitDetails.deleted.eachType(function(type, array) {
-      this.deleteRecords(store, type, array.slice());
-    }, this);
-  },
+/**
+  A record array is an array that contains records of a certain type. The record
+  array materializes records as needed when they are retrieved for the first
+  time. You should not create record arrays yourself. Instead, an instance of
+  DS.RecordArray or its subclasses will be returned by your application's store
+  in response to queries.
+*/
 
-  createRecords: function(store, type, models) {
-    models.forEach(function(model) {
-      this.createRecord(store, type, model);
-    }, this);
-  },
+DS.RecordArray = Ember.ArrayProxy.extend({
 
-  updateRecords: function(store, type, models) {
-    models.forEach(function(model) {
-      this.updateRecord(store, type, model);
-    }, this);
-  },
+  /**
+    The model type contained by this record array.
 
-  deleteRecords: function(store, type, models) {
-    models.forEach(function(model) {
-      this.deleteRecord(store, type, model);
-    }, this);
-  },
+    @type DS.Model
+  */
+  type: null,
 
-  findMany: function(store, type, ids) {
-    ids.forEach(function(id) {
-      this.find(store, type, id);
-    }, this);
-  }
-});
-})({});
+  // The array of client ids backing the record array. When a
+  // record is requested from the record array, the record
+  // for the client id at the same index is materialized, if
+  // necessary, by the store.
+  content: null,
 
+  // The store that created this record array.
+  store: null,
 
-(function(exports) {
-DS.fixtureAdapter = DS.Adapter.create({
-  find: function(store, type, id) {
-    var fixtures = type.FIXTURES;
+  init: function() {
+    set(this, 'recordCache', Ember.A([]));
+    this._super();
+  },
 
-    ember_assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
-    if (fixtures.hasLoaded) { return; }
+  arrayDidChange: function(array, index, removed, added) {
+    var recordCache = get(this, 'recordCache');
+    recordCache.replace(index, 0, new Array(added));
 
-    setTimeout(function() {
-      store.loadMany(type, fixtures);
-      fixtures.hasLoaded = true;
-    }, 300);
+    this._super(array, index, removed, added);
   },
 
-  findMany: function() {
-    this.find.apply(this, arguments);
+  arrayWillChange: function(array, index, removed, added) {
+    this._super(array, index, removed, added);
+
+    var recordCache = get(this, 'recordCache');
+    recordCache.replace(index, removed);
   },
 
-  findAll: function(store, type) {
-    var fixtures = type.FIXTURES;
+  objectAtContent: function(index) {
+    var recordCache = get(this, 'recordCache');
+    var record = recordCache.objectAt(index);
 
-    ember_assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
+    if (!record) {
+      var store = get(this, 'store');
+      var content = get(this, 'content');
 
-    var ids = fixtures.map(function(item, index, self){ return item.id; });
-    store.loadMany(type, ids, fixtures);
-  }
+      var contentObject = content.objectAt(index);
+
+      if (contentObject !== undefined) {
+        record = store.findByClientId(get(this, 'type'), contentObject);
+        recordCache.replace(index, 1, [record]);
+      }
+    }
 
+    return record;
+  }
 });
 
-})({});
+})();
 
 
-(function(exports) {
-/*global jQuery*/
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
 
-DS.RESTAdapter = DS.Adapter.extend({
-  createRecord: function(store, type, model) {
-    var root = this.rootForType(type);
+(function() {
+var get = Ember.get;
 
-    var data = {};
-    data[root] = model.toJSON();
+DS.FilteredRecordArray = DS.RecordArray.extend({
+  filterFunction: null,
 
-    this.ajax(this.buildURL(root), "POST", {
-      data: data,
-      success: function(json) {
-        this.sideload(store, type, json, root);
-        store.didCreateRecord(model, json[root]);
-      }
-    });
+  replace: function() {
+    var type = get(this, 'type').toString();
+    throw new Error("The result of a client-side filter (on " + type + ") is immutable.");
   },
 
-  createRecords: function(store, type, models) {
-    if (get(this, 'bulkCommit') === false) {
-      return this._super(store, type, models);
-    }
-
-    var root = this.rootForType(type),
-        plural = this.pluralize(root);
+  updateFilter: Ember.observer(function() {
+    var store = get(this, 'store');
+    store.updateRecordArrayFilter(this, get(this, 'type'), get(this, 'filterFunction'));
+  }, 'filterFunction')
+});
 
-    var data = {};
-    data[plural] = models.map(function(model) {
-      return model.toJSON();
-    });
+})();
 
-    this.ajax(this.buildURL(root), "POST", {
-      data: data,
 
-      success: function(json) {
-        this.sideload(store, type, json, plural);
-        store.didCreateRecords(type, models, json[plural]);
-      }
-    });
-  },
 
-  updateRecord: function(store, type, model) {
-    var id = get(model, 'id');
-    var root = this.rootForType(type);
+(function() {
+var get = Ember.get, set = Ember.set;
 
-    var data = {};
-    data[root] = model.toJSON();
+DS.AdapterPopulatedRecordArray = DS.RecordArray.extend({
+  query: null,
+  isLoaded: false,
 
-    this.ajax(this.buildURL(root, id), "PUT", {
-      data: data,
-      success: function(json) {
-        this.sideload(store, type, json, root);
-        store.didUpdateRecord(model, json && json[root]);
-      }
-    });
+  replace: function() {
+    var type = get(this, 'type').toString();
+    throw new Error("The result of a server query (on " + type + ") is immutable.");
   },
 
-  updateRecords: function(store, type, models) {
-    if (get(this, 'bulkCommit') === false) {
-      return this._super(store, type, models);
-    }
+  load: function(array) {
+    var store = get(this, 'store'), type = get(this, 'type');
 
-    var root = this.rootForType(type),
-        plural = this.pluralize(root);
+    var clientIds = store.loadMany(type, array).clientIds;
 
-    var data = {};
-    data[plural] = models.map(function(model) {
-      return model.toJSON();
-    });
+    this.beginPropertyChanges();
+    set(this, 'content', Ember.A(clientIds));
+    set(this, 'isLoaded', true);
+    this.endPropertyChanges();
+  }
+});
 
-    this.ajax(this.buildURL(root, "bulk"), "PUT", {
-      data: data,
-      success: function(json) {
-        this.sideload(store, type, json, plural);
-        store.didUpdateRecords(models, json[plural]);
-      }
-    });
-  },
 
-  deleteRecord: function(store, type, model) {
-    var id = get(model, 'id');
-    var root = this.rootForType(type);
+})();
 
-    this.ajax(this.buildURL(root, id), "DELETE", {
-      success: function(json) {
-        if (json) { this.sideload(store, type, json); }
-        store.didDeleteRecord(model);
-      }
-    });
-  },
 
-  deleteRecords: function(store, type, models) {
-    if (get(this, 'bulkCommit') === false) {
-      return this._super(store, type, models);
-    }
 
-    var root = this.rootForType(type),
-        plural = this.pluralize(root);
+(function() {
+var get = Ember.get, set = Ember.set, guidFor = Ember.guidFor;
 
-    var data = {};
-    data[plural] = models.map(function(model) {
-      return get(model, 'id');
-    });
+var Set = function() {
+  this.hash = {};
+  this.list = [];
+};
 
-    this.ajax(this.buildURL(root, 'bulk'), "DELETE", {
-      data: data,
-      success: function(json) {
-        if (json) { this.sideload(store, type, json); }
-        store.didDeleteRecords(models);
-      }
-    });
-  },
+Set.prototype = {
+  add: function(item) {
+    var hash = this.hash,
+        guid = guidFor(item);
 
-  find: function(store, type, id) {
-    var root = this.rootForType(type);
+    if (hash.hasOwnProperty(guid)) { return; }
 
-    this.ajax(this.buildURL(root, id), "GET", {
-      success: function(json) {
-        store.load(type, json[root]);
-        this.sideload(store, type, json, root);
-      }
-    });
+    hash[guid] = true;
+    this.list.push(item);
   },
 
-  findMany: function(store, type, ids) {
-    var root = this.rootForType(type), plural = this.pluralize(root);
+  remove: function(item) {
+    var hash = this.hash,
+        guid = guidFor(item);
 
-    this.ajax(this.buildURL(root), "GET", {
-      data: { ids: ids },
-      success: function(json) {
-        store.loadMany(type, ids, json[plural]);
-        this.sideload(store, type, json, plural);
-      }
-    });
-  },
+    if (!hash.hasOwnProperty(guid)) { return; }
 
-  findAll: function(store, type) {
-    var root = this.rootForType(type), plural = this.pluralize(root);
+    delete hash[guid];
+    var list = this.list,
+        index = Ember.ArrayUtils.indexOf(this, item);
 
-    this.ajax(this.buildURL(root), "GET", {
-      success: function(json) {
-        store.loadMany(type, json[plural]);
-        this.sideload(store, type, json, plural);
-      }
-    });
+    list.splice(index, 1);
   },
 
-  findQuery: function(store, type, query, modelArray) {
-    var root = this.rootForType(type), plural = this.pluralize(root);
+  isEmpty: function() {
+    return this.list.length === 0;
+  }
+};
 
-    this.ajax(this.buildURL(root), "GET", {
-      data: query,
-      success: function(json) {
-        modelArray.load(json[plural]);
-        this.sideload(store, type, json, plural);
+var ManyArrayState = Ember.State.extend({
+  recordWasAdded: function(manager, record) {
+    var dirty = manager.dirty, observer;
+    dirty.add(record);
+
+    observer = function() {
+      if (!get(record, 'isDirty')) {
+        record.removeObserver('isDirty', observer);
+        manager.send('childWasSaved', record);
       }
-    });
-  },
+    };
 
-  // HELPERS
+    record.addObserver('isDirty', observer);
+  },
 
-  plurals: {},
+  recordWasRemoved: function(manager, record) {
+    var dirty = manager.dirty, observer;
+    dirty.add(record);
 
-  // define a plurals hash in your subclass to define
-  // special-case pluralization
-  pluralize: function(name) {
-    return this.plurals[name] || name + "s";
-  },
+    observer = function() {
+      record.removeObserver('isDirty', observer);
+      if (!get(record, 'isDirty')) { manager.send('childWasSaved', record); }
+    };
 
-  rootForType: function(type) {
-    if (type.url) { return type.url; }
+    record.addObserver('isDirty', observer);
+  }
+});
 
-    // use the last part of the name as the URL
-    var parts = type.toString().split(".");
-    var name = parts[parts.length - 1];
-    return name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
-  },
+var states = {
+  clean: ManyArrayState.create({
+    isDirty: false,
 
-  ajax: function(url, type, hash) {
-    hash.url = url;
-    hash.type = type;
-    hash.dataType = 'json';
-    hash.contentType = 'application/json';
-    hash.context = this;
+    recordWasAdded: function(manager, record) {
+      this._super(manager, record);
+      manager.goToState('dirty');
+    },
 
-    if (hash.data && type !== 'GET') {
-      hash.data = JSON.stringify(hash.data);
+    update: function(manager, clientIds) {
+      var manyArray = manager.manyArray;
+      set(manyArray, 'content', clientIds);
     }
+  }),
 
-    jQuery.ajax(hash);
-  },
+  dirty: ManyArrayState.create({
+    isDirty: true,
 
-  sideload: function(store, type, json, root) {
-    var sideloadedType, mappings;
+    childWasSaved: function(manager, child) {
+      var dirty = manager.dirty;
+      dirty.remove(child);
 
-    for (var prop in json) {
-      if (!json.hasOwnProperty(prop)) { continue; }
-      if (prop === root) { continue; }
+      if (dirty.isEmpty()) { manager.send('arrayBecameSaved'); }
+    },
 
-      sideloadedType = type.typeForAssociation(prop);
+    arrayBecameSaved: function(manager) {
+      manager.goToState('clean');
+    }
+  }) 
+};
 
-      if (!sideloadedType) {
-        mappings = get(this, 'mappings');
+DS.ManyArrayStateManager = Ember.StateManager.extend({
+  manyArray: null,
+  initialState: 'clean',
+  states: states,
 
-        ember_assert("Your server returned a hash with the key " + prop + " but you have no mappings", !!mappings);
+  init: function() {
+    this._super();
+    this.dirty = new Set();
+  }
+});
 
-        sideloadedType = get(get(this, 'mappings'), prop);
+})();
 
-        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]);
-    }
-  },
-
-  loadValue: function(store, type, value) {
-    if (value instanceof Array) {
-      store.loadMany(type, value);
-    } else {
-      store.load(type, value);
-    }
-  },
-
-  buildURL: function(model, suffix) {
-    var url = [""];
-
-    if (this.namespace !== undefined) {
-      url.push(this.namespace);
-    }
 
-    url.push(this.pluralize(model));
-    if (suffix !== undefined) {
-      url.push(suffix);
-    }
+(function() {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
 
-    return url.join("/");
-  }
-});
+DS.ManyArray = DS.RecordArray.extend({
+  init: function() {
+    set(this, 'stateManager', DS.ManyArrayStateManager.create({ manyArray: this }));
 
+    return this._super();
+  },
 
-})({});
+  parentRecord: null,
 
+  isDirty: Ember.computed(function() {
+    return getPath(this, 'stateManager.currentState.isDirty');
+  }).property('stateManager.currentState').cacheable(),
 
-(function(exports) {
-var get = Ember.get, set = Ember.set;
+  fetch: function() {
+    var clientIds = get(this, 'content'),
+        store = get(this, 'store'),
+        type = get(this, 'type');
 
-/**
-  A model array is an array that contains records of a certain type. The model
-  array materializes records as needed when they are retrieved for the first
-  time. You should not create model arrays yourself. Instead, an instance of
-  DS.ModelArray or its subclasses will be returned by your application's store
-  in response to queries.
-*/
+    var ids = clientIds.map(function(clientId) {
+      return store.clientIdToId[clientId];
+    });
 
-DS.ModelArray = Ember.ArrayProxy.extend({
+    store.fetchMany(type, ids);
+  },
 
-  /**
-    The model type contained by this model array.
+  // Overrides Ember.Array's replace method to implement
+  replace: function(index, removed, added) {
+    var parentRecord = get(this, 'parentRecord');
+    var pendingParent = parentRecord && !get(parentRecord, 'id');
+    var stateManager = get(this, 'stateManager');
 
-    @type DS.Model
-  */
-  type: null,
+    added = added.map(function(record) {
+      ember_assert("You can only add records of " + (get(this, 'type') && get(this, 'type').toString()) + " to this association.", !get(this, 'type') || (get(this, 'type') === record.constructor));
 
-  // The array of client ids backing the model array. When a
-  // record is requested from the model array, the record
-  // for the client id at the same index is materialized, if
-  // necessary, by the store.
-  content: null,
+      if (pendingParent) {
+        record.send('waitingOn', parentRecord);
+      }
 
-  // The store that created this model array.
-  store: null,
+      this.assignInverse(record, parentRecord);
 
-  init: function() {
-    set(this, 'modelCache', Ember.A([]));
-    this._super();
-  },
+      stateManager.send('recordWasAdded', record);
 
-  arrayDidChange: function(array, index, removed, added) {
-    var modelCache = get(this, 'modelCache');
-    modelCache.replace(index, 0, new Array(added));
+      return record.get('clientId');
+    }, this);
 
-    this._super(array, index, removed, added);
-  },
+    var store = this.store;
 
-  arrayWillChange: function(array, index, removed, added) {
-    this._super(array, index, removed, added);
+    var len = index+removed, record;
+    for (var i = index; i < len; i++) {
+      // TODO: null out inverse FK
+      record = this.objectAt(i);
+      this.assignInverse(record, parentRecord, true);
+      stateManager.send('recordWasAdded', record);
+    }
 
-    var modelCache = get(this, 'modelCache');
-    modelCache.replace(index, removed);
+    this._super(index, removed, added);
   },
 
-  objectAtContent: function(index) {
-    var modelCache = get(this, 'modelCache');
-    var model = modelCache.objectAt(index);
+  assignInverse: function(record, parentRecord, remove) {
+    var associationMap = get(record.constructor, 'associations'),
+        possibleAssociations = associationMap.get(parentRecord.constructor),
+        possible, actual;
 
-    if (!model) {
-      var store = get(this, 'store');
-      var content = get(this, 'content');
+    if (!possibleAssociations) { return; }
 
-      var contentObject = content.objectAt(index);
+    for (var i = 0, l = possibleAssociations.length; i < l; i++) {
+      possible = possibleAssociations[i];
 
-      if (contentObject !== undefined) {
-        model = store.findByClientId(get(this, 'type'), contentObject);
-        modelCache.replace(index, 1, [model]);
+      if (possible.kind === 'belongsTo') {
+        actual = possible;
+        break;
       }
     }
 
-    return model;
+    if (actual) {
+      set(record, actual.name, remove ? null : parentRecord);
+    }
   }
 });
 
-})({});
+})();
 
 
-(function(exports) {
-var get = Ember.get;
-
-DS.FilteredModelArray = DS.ModelArray.extend({
-  filterFunction: null,
-
-  replace: function() {
-    var type = get(this, 'type').toString();
-    throw new Error("The result of a client-side filter (on " + type + ") is immutable.");
-  },
 
-  updateFilter: Ember.observer(function() {
-    var store = get(this, 'store');
-    store.updateModelArrayFilter(this, get(this, 'type'), get(this, 'filterFunction'));
-  }, 'filterFunction')
-});
+(function() {
 
-})({});
+})();
 
 
-(function(exports) {
-var get = Ember.get, set = Ember.set;
-
-DS.AdapterPopulatedModelArray = DS.ModelArray.extend({
-  query: null,
-  isLoaded: false,
-
-  replace: function() {
-    var type = get(this, 'type').toString();
-    throw new Error("The result of a server query (on " + type + ") is immutable.");
-  },
 
-  load: function(array) {
-    var store = get(this, 'store'), type = get(this, 'type');
+(function() {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
 
-    var clientIds = store.loadMany(type, array).clientIds;
+/**
+  A transaction allows you to collect multiple records into a unit of work
+  that can be committed or rolled back as a group.
 
-    this.beginPropertyChanges();
-    set(this, 'content', Ember.A(clientIds));
-    set(this, 'isLoaded', true);
-    this.endPropertyChanges();
-  }
-});
+  For example, if a record has local modifications that have not yet
+  been saved, calling `commit()` on its transaction will cause those
+  modifications to be sent to the adapter to be saved. Calling
+  `rollback()` on its transaction would cause all of the modifications to
+  be discarded and the record to return to the last known state before
+  changes were made.
 
+  If a newly created record's transaction is rolled back, it will
+  immediately transition to the deleted state.
 
-})({});
+  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. 
 
+  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
+  a clean state, it can be moved to a new transaction if you wish.
 
-(function(exports) {
-var get = Ember.get, set = Ember.set;
+  ### Creating a Transaction
 
-DS.ManyArray = DS.ModelArray.extend({
-  parentRecord: null,
+  To create a new transaction, call the `transaction()` method of your
+  application's `DS.Store` instance:
 
-  // Overrides Ember.Array's replace method to implement
-  replace: function(index, removed, added) {
-    var parentRecord = get(this, 'parentRecord');
-    var pendingParent = parentRecord && !get(parentRecord, 'id');
+      var transaction = App.store.transaction();
 
-    added = added.map(function(record) {
-      ember_assert("You can only add records of " + (get(this, 'type') && get(this, 'type').toString()) + " to this association.", !get(this, 'type') || (get(this, 'type') === record.constructor));
+  This will return a new instance of `DS.Transaction` with no records
+  yet assigned to it.
 
-      if (pendingParent) {
-        record.send('waitingOn', parentRecord);
-      }
+  ### Adding Existing Records
 
-      this.assignInverse(record, parentRecord);
+  Add records to a transaction using the `add()` method:
 
-      return record.get('clientId');
-    }, this);
+      record = App.store.find(Person, 1);
+      transaction.add(record);
 
-    this._super(index, removed, added);
-  },
+  Note that only records whose `isDirty` flag is `false` may be added
+  to a transaction. Once modifications to a record have been made
+  (its `isDirty` flag is `true`), it is not longer able to be added to
+  a transaction.
 
-  assignInverse: function(record, parentRecord) {
-    var associationMap = get(record.constructor, 'associations'),
-        possibleAssociations = associationMap.get(record.constructor),
-        possible, actual;
+  ### Creating New Records
 
-    if (!possibleAssociations) { return; }
+  Because newly created records are dirty from the time they are created,
+  and because dirty records can not be added to a transaction, you must
+  use the `createRecord()` method to assign new records to a transaction.
 
-    for (var i = 0, l = possibleAssociations.length; i < l; i++) {
-      possible = possibleAssociations[i];
+  For example, instead of this:
 
-      if (possible.kind === 'belongsTo') {
-        actual = possible;
-        break;
-      }
-    }
+    var transaction = store.transaction();
+    var person = Person.createRecord({ name: "Steve" });
 
-    if (actual) {
-      set(record, actual.name, parentRecord);
-    }
-  }
-});
+    // won't work because person is dirty
+    transaction.add(person);
 
-})({});
+  Call `createRecord()` on the transaction directly:
 
+    var transaction = store.transaction();
+    transaction.createRecord(Person, { name: "Steve" });
 
-(function(exports) {
-})({});
+  ### Asynchronous Commits
 
+  Typically, all of the records in a transaction will be committed
+  together. However, new records that have a dependency on other new
+  records need to wait for their parent record to be saved and assigned an
+  ID. In that case, the child record will continue to live in the
+  transaction until its parent is saved, at which time the transaction will
+  attempt to commit again.
 
-(function(exports) {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
+  For this reason, you should not re-use transactions once you have committed
+  them. Always make a new transaction and move the desired records to it before
+  calling commit.
+*/
 
 DS.Transaction = Ember.Object.extend({
+  /**
+    @private
+
+    Creates the bucket data structure used to segregate records by
+    type.
+  */
   init: function() {
     set(this, 'buckets', {
       clean:   Ember.Map.create(),
@@ -514,30 +430,182 @@ DS.Transaction = Ember.Object.extend({
     });
   },
 
+  /**
+    Creates a new record of the given type and assigns it to the transaction
+    on which the method was called.
+
+    This is useful as only clean records can be added to a transaction and
+    new records created using other methods immediately become dirty.
+
+    @param {DS.Model} type the model type to create
+    @param {Object} hash the data hash to assign the new record
+  */
   createRecord: function(type, hash) {
     var store = get(this, 'store');
 
     return store.createRecord(type, hash, this);
   },
 
+  /**
+    Adds an existing record to this transaction. Only records without
+    modficiations (i.e., records whose `isDirty` property is `false`)
+    can be added to a transaction.
+
+    @param {DS.Model} record the record to add to the transaction
+  */
   add: function(record) {
     // we could probably make this work if someone has a valid use case. Do you?
     ember_assert("Once a record has changed, you cannot move it into a different transaction", !get(record, 'isDirty'));
 
-    var modelTransaction = get(record, 'transaction'),
+    var recordTransaction = get(record, 'transaction'),
         defaultTransaction = getPath(this, 'store.defaultTransaction');
 
-    ember_assert("Models cannot belong to more than one transaction at a time.", modelTransaction === defaultTransaction);
+    ember_assert("Models cannot belong to more than one transaction at a time.", recordTransaction === defaultTransaction);
 
     this.adoptRecord(record);
   },
 
+  /**
+    Commits the transaction, which causes all of the modified records that
+    belong to the transaction to be sent to the adapter to be saved.
+
+    Once you call `commit()` on a transaction, you should not re-use it.
+
+    When a record is saved, it will be removed from this transaction and
+    moved back to the store's default transaction.
+  */
+  commit: function() {
+    var self = this,
+        iterate;
+
+    iterate = function(bucketType, fn, binding) {
+      var dirty = self.bucketForType(bucketType);
+
+      dirty.forEach(function(type, records) {
+        if (records.isEmpty()) { return; }
+
+        var array = [];
+
+        records.forEach(function(record) {
+          record.send('willCommit');
+
+          if (get(record, 'isPending') === false) {
+            array.push(record);
+          }
+        });
+
+        fn.call(binding, type, array);
+      });
+    };
+
+    var commitDetails = {
+      updated: {
+        eachType: function(fn, binding) { iterate('updated', fn, binding); }
+      },
+
+      created: {
+        eachType: function(fn, binding) { iterate('created', fn, binding); }
+      },
+
+      deleted: {
+        eachType: function(fn, binding) { iterate('deleted', fn, binding); }
+      }
+    };
+
+    var store = get(this, 'store');
+    var adapter = get(store, '_adapter');
+
+    this.removeCleanRecords();
+
+    if (adapter && adapter.commit) { adapter.commit(store, commitDetails); }
+    else { throw fmt("Adapter is either null or do not implement `commit` method", this); }
+  },
+
+  /**
+    Rolling back a transaction resets the records that belong to
+    that transaction.
+
+    Updated records have their properties reset to the last known
+    value from the persistence layer. Deleted records are reverted
+    to a clean, non-deleted state. Newly created records immediately
+    become deleted, and are not sent to the adapter to be persisted.
+
+    After the transaction is rolled back, any records that belong
+    to it will return to the store's default transaction, and the
+    current transaction should not be used again.
+  */
+  rollback: function() {
+    var store = get(this, 'store'),
+        dirty;
+
+    // Loop through all of the records in each of the dirty states
+    // and initiate a rollback on them. As a side effect of telling
+    // the record to roll back, it should also move itself out of
+    // the dirty bucket and into the clean bucket.
+    ['created', 'updated', 'deleted'].forEach(function(bucketType) {
+      dirty = this.bucketForType(bucketType);
+
+      dirty.forEach(function(type, records) {
+        records.forEach(function(record) {
+          record.send('rollback');
+        });
+      });
+    }, this);
+
+    // Now that all records in the transaction are guaranteed to be
+    // clean, migrate them all to the store's default transaction.
+    this.removeCleanRecords();
+  },
+
+  /**
+    @private
+
+    Removes a record from this transaction and back to the store's
+    default transaction.
+
+    Note: This method is private for now, but should probably be exposed
+    in the future once we have stricter error checking (for example, in the
+    case of the record being dirty).
+
+    @param {DS.Model} record
+  */
   remove: function(record) {
     var defaultTransaction = getPath(this, 'store.defaultTransaction');
-
     defaultTransaction.adoptRecord(record);
   },
 
+  /**
+    @private
+
+    Removes all of the records in the transaction's clean bucket.
+  */
+  removeCleanRecords: function() {
+    var clean = this.bucketForType('clean'),
+        self = this;
+
+    clean.forEach(function(type, records) {
+      records.forEach(function(record) {
+        self.remove(record);
+      });
+    });
+  },
+
+  /**
+    @private
+
+    Returns the bucket for the given bucket type. For example, you might call
+    `this.bucketForType('updated')` to get the `Ember.Map` that contains all
+    of the records that have changes pending.
+
+    @param {String} bucketType the type of bucket
+    @returns Ember.Map
+  */
+  bucketForType: function(bucketType) {
+    var buckets = get(this, 'buckets');
+
+    return get(buckets, bucketType);
+  },
+
   /**
     @private
 
@@ -549,6 +617,8 @@ DS.Transaction = Ember.Object.extend({
     into a new transaction when the transaction is committed.
 
     This method must not be called unless the record is clean.
+
+    @param {DS.Model} record
   */
   adoptRecord: function(record) {
     var oldTransaction = get(record, 'transaction');
@@ -561,14 +631,15 @@ DS.Transaction = Ember.Object.extend({
     set(record, 'transaction', this);
   },
 
-  modelBecameDirty: function(kind, record) {
-    this.removeFromBucket('clean', record);
-    this.addToBucket(kind, record);
-  },
+  /**
+    @private
 
-  /** @private */
-  addToBucket: function(kind, record) {
-    var bucket = get(get(this, 'buckets'), kind),
+    Adds a record to the named bucket.
+
+    @param {String} bucketType one of `clean`, `created`, `updated`, or `deleted`
+  */
+  addToBucket: function(bucketType, record) {
+    var bucket = this.bucketForType(bucketType),
         type = record.constructor;
 
     var records = bucket.get(type);
@@ -581,80 +652,58 @@ DS.Transaction = Ember.Object.extend({
     records.add(record);
   },
 
-  /** @private */
-  removeFromBucket: function(kind, record) {
-    var bucket = get(get(this, 'buckets'), kind),
+  /**
+    @private
+
+    Removes a record from the named bucket.
+
+    @param {String} bucketType one of `clean`, `created`, `updated`, or `deleted`
+  */
+  removeFromBucket: function(bucketType, record) {
+    var bucket = this.bucketForType(bucketType),
         type = record.constructor;
 
     var records = bucket.get(type);
     records.remove(record);
   },
 
-  modelBecameClean: function(kind, record) {
-    this.removeFromBucket(kind, record);
+  /**
+    @private
 
-    var defaultTransaction = getPath(this, 'store.defaultTransaction');
-    defaultTransaction.adoptRecord(record);
-  },
+    Called by a record's state manager to indicate that the record has entered
+    a dirty state. The record will be moved from the `clean` bucket and into
+    the appropriate dirty bucket.
 
-  commit: function() {
-    var buckets = get(this, 'buckets');
-
-    var iterate = function(kind, fn, binding) {
-      var dirty = get(buckets, kind);
-
-      dirty.forEach(function(type, models) {
-        if (models.isEmpty()) { return; }
-
-        var array = [];
-
-        models.forEach(function(model) {
-          model.send('willCommit');
-
-          if (get(model, 'isPending') === false) {
-            array.push(model);
-          }
-        });
-
-        fn.call(binding, type, array);
-      });
-    };
-
-    var commitDetails = {
-      updated: {
-        eachType: function(fn, binding) { iterate('updated', fn, binding); }
-      },
-
-      created: {
-        eachType: function(fn, binding) { iterate('created', fn, binding); }
-      },
-
-      deleted: {
-        eachType: function(fn, binding) { iterate('deleted', fn, binding); }
-      }
-    };
+    @param {String} bucketType one of `created`, `updated`, or `deleted`
+  */
+  recordBecameDirty: function(bucketType, record) {
+    this.removeFromBucket('clean', record);
+    this.addToBucket(bucketType, record);
+  },
 
-    var store = get(this, 'store');
-    var adapter = get(store, '_adapter');
+  /**
+    @private
 
-    var clean = get(buckets, 'clean');
-    var defaultTransaction = get(store, 'defaultTransaction');
+    Called by a record's state manager to indicate that the record has entered
+    a clean state. The record will be moved from its current dirty bucket and into
+    the `clean` bucket.
 
-    clean.forEach(function(type, records) {
-      records.forEach(function(record) {
-        this.remove(record);
-      }, this);
-    }, this);
+    @param {String} bucketType one of `created`, `updated`, or `deleted`
+  */
+  recordBecameClean: function(kind, record) {
+    this.removeFromBucket(kind, record);
 
-    if (adapter && adapter.commit) { adapter.commit(store, commitDetails); }
-    else { throw fmt("Adapter is either null or do not implement `commit` method", this); }
+    var defaultTransaction = getPath(this, 'store.defaultTransaction');
+    defaultTransaction.adoptRecord(record);
   }
 });
 
-})({});
+})();
 
 
-(function(exports) {
+
+(function() {
+/*globals Ember*/
 var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
 
 var DATA_PROXY = {
@@ -663,6 +712,11 @@ var DATA_PROXY = {
   }
 };
 
+// These values are used in the data cache when clientIds are
+// needed but the underlying data has not yet been loaded by
+// the server.
+var UNLOADED = 'unloaded';
+var LOADING = 'loading';
 
 // Implementors Note:
 //
@@ -677,7 +731,7 @@ var DATA_PROXY = {
 //   * +type+ means a subclass of DS.Model.
 
 /**
-  The store contains all of the hashes for data models loaded from the server.
+  The store contains all of the hashes for records loaded from the server.
   It is also responsible for creating instances of DS.Model when you request one
   of these data hashes, so that they can be bound to in your Handlebars templates.
 
@@ -686,9 +740,9 @@ var DATA_PROXY = {
        MyApp.store = DS.Store.create();
 
   You can retrieve DS.Model instances from the store in several ways. To retrieve
-  a model for a specific id, use the `find()` method:
+  a record for a specific id, use the `find()` method:
 
-       var model = MyApp.store.find(MyApp.Contact, 123);
+       var record = MyApp.store.find(MyApp.Contact, 123);
 
    By default, the store will talk to your backend using a standard REST mechanism.
    You can customize how the store talks to your backend by specifying a custom adapter:
@@ -726,7 +780,7 @@ DS.Store = Ember.Object.extend({
     this.typeMaps = {};
     this.recordCache = [];
     this.clientIdToId = {};
-    this.modelArraysByClientId = {};
+    this.recordArraysByClientId = {};
 
     set(this, 'defaultTransaction', this.transaction());
 
@@ -746,7 +800,7 @@ DS.Store = Ember.Object.extend({
   /**
     @private
 
-    This is used only by the model's DataProxy. Do not use this directly.
+    This is used only by the record's DataProxy. Do not use this directly.
   */
   dataForRecord: function(record) {
     var type = record.constructor,
@@ -783,11 +837,11 @@ DS.Store = Ember.Object.extend({
 
   // A monotonically increasing number to be used to uniquely identify
   // data hashes and records.
-  clientIdCounter: -1,
+  clientIdCounter: 1,
 
-  // ....................
-  // . CREATE NEW MODEL .
-  // ....................
+  // .....................
+  // . CREATE NEW RECORD .
+  // .....................
 
   /**
     Create a new record in the current store. The properties passed
@@ -839,14 +893,14 @@ DS.Store = Ember.Object.extend({
     // Set the properties specified on the record.
     record.setProperties(properties);
 
-    this.updateModelArrays(type, clientId, get(record, 'data'));
+    this.updateRecordArrays(type, clientId, get(record, 'data'));
 
     return record;
   },
 
-  // ................
-  // . DELETE MODEL .
-  // ................
+  // .................
+  // . DELETE RECORD .
+  // .................
 
   /**
     For symmetry, a record can be deleted via the store.
@@ -857,9 +911,9 @@ DS.Store = Ember.Object.extend({
     record.send('deleteRecord');
   },
 
-  // ...............
-  // . FIND MODELS .
-  // ...............
+  // ................
+  // . FIND RECORDS .
+  // ................
 
   /**
     This is the main entry point into finding records. The first
@@ -879,7 +933,8 @@ DS.Store = Ember.Object.extend({
 
     If the record with that `id` had not previously been loaded,
     the store will return an empty record immediately and ask
-    the adapter to find the data by calling its `find` method.
+    the adapter to find the data by calling the adapter's `find`
+    method.
 
     The `find` method will always return the same object for a
     given type and `id`. To check whether the adapter has populated
@@ -893,11 +948,11 @@ DS.Store = Ember.Object.extend({
         store.find(App.Person);
         App.Person.find();
 
-    This will return a `ModelArray` representing all known records
+    This will return a `RecordArray` representing all known records
     for the given type and kick off a request to the adapter's
     `findAll` method to load any additional records for the type.
 
-    The `ModelArray` returned by `find()` is live. If any more
+    The `RecordArray` returned by `find()` is live. If any more
     records for the type are added at a later time through any
     mechanism, it will automatically update to reflect the change.
 
@@ -909,12 +964,12 @@ DS.Store = Ember.Object.extend({
         store.find(App.Person, { page: 1 });
         App.Person.find({ page: 1 });
 
-    This will return a `ModelArray` immediately, but it will always
-    be an empty `ModelArray` at first. It will call the adapter's
-    `findQuery` method, which will populate the `ModelArray` once
+    This will return a `RecordArray` immediately, but it will always
+    be an empty `RecordArray` at first. It will call the adapter's
+    `findQuery` method, which will populate the `RecordArray` once
     the server has returned results.
 
-    You can check whether a query results `ModelArray` has loaded
+    You can check whether a query results `RecordArray` has loaded
     by checking its `isLoaded` property.
   */
   find: function(type, id, query) {
@@ -932,7 +987,7 @@ DS.Store = Ember.Object.extend({
       return this.findMany(type, id);
     }
 
-    var clientId = this.clientIdForId(type, id);
+    var clientId = this.typeMapFor(type).idToCid[id];
 
     return this.findByClientId(type, clientId, id);
   },
@@ -940,31 +995,31 @@ DS.Store = Ember.Object.extend({
   findByClientId: function(type, clientId, id) {
     var recordCache = get(this, 'recordCache'),
         dataCache = this.typeMapFor(type).cidToHash,
-        model;
+        record;
 
     // If there is already a clientId assigned for this
     // type/id combination, try to find an existing
-    // model for that id and return. Otherwise,
-    // materialize a new model and set its data to the
+    // record for that id and return. Otherwise,
+    // materialize a new record and set its data to the
     // value we already have.
     if (clientId !== undefined) {
-      model = recordCache[clientId];
+      record = recordCache[clientId];
 
-      if (!model) {
-        // create a new instance of the model in the
+      if (!record) {
+        // create a new instance of the model type in the
         // 'isLoading' state
-        model = this.materializeRecord(type, clientId);
+        record = this.materializeRecord(type, clientId);
 
-        if (dataCache[clientId]) {
-          model.send('didChangeData');
+        if (typeof dataCache[clientId] === 'object') {
+          record.send('didChangeData');
         }
       }
     } else {
-      clientId = this.pushHash(null, id, type);
+      clientId = this.pushHash(LOADING, id, type);
 
-      // create a new instance of the model in the
+      // create a new instance of the model type in the
       // 'isLoading' state
-      model = this.materializeRecord(type, clientId);
+      record = this.materializeRecord(type, clientId);
 
       // let the adapter set the data, possibly async
       var adapter = get(this, '_adapter');
@@ -972,14 +1027,29 @@ DS.Store = Ember.Object.extend({
       else { throw fmt("Adapter is either null or does not implement `find` method", this); }
     }
 
-    return model;
+    return record;
   },
 
-  /** @private
+  /**
+    @private
+
+    Ask the adapter to fetch IDs that are not already loaded.
+
+    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.
+
+    @param {Class} type A model class
+    @param {Array} ids An array of ids
+    @param {Object} query
+
+    @returns {Array} An Array of all clientIds for the
+      specified ids.
   */
-  findMany: function(type, ids, query) {
+  fetchMany: function(type, ids, query) {
     var typeMap = this.typeMapFor(type),
         idToClientIdMap = typeMap.idToCid,
+        dataCache = typeMap.cidToHash,
         data = typeMap.cidToHash,
         needed;
 
@@ -989,29 +1059,56 @@ DS.Store = Ember.Object.extend({
       needed = [];
 
       ids.forEach(function(id) {
+        // Get the clientId for the given id
         var clientId = idToClientIdMap[id];
-        if (clientId === undefined || data[clientId] === undefined) {
-          clientId = this.pushHash(null, id, type);
+
+        // 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 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;
     }
 
+    // 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); }
     }
 
+    return clientIds;
+  },
+
+  /** @private
+  */
+  findMany: function(type, ids, query) {
+    var clientIds = this.fetchMany(type, ids, query);
+
     return this.createManyArray(type, clientIds);
   },
 
   findQuery: function(type, query) {
-    var array = DS.AdapterPopulatedModelArray.create({ type: type, content: Ember.A([]), store: this });
+    var array = DS.AdapterPopulatedRecordArray.create({ type: type, content: Ember.A([]), store: this });
     var adapter = get(this, '_adapter');
     if (adapter && adapter.findQuery) { adapter.findQuery(this, type, query, array); }
     else { throw fmt("Adapter is either null or does not implement `findQuery` method", this); }
@@ -1025,8 +1122,8 @@ DS.Store = Ember.Object.extend({
 
     if (findAllCache) { return findAllCache; }
 
-    var array = DS.ModelArray.create({ type: type, content: Ember.A([]), store: this });
-    this.registerModelArray(array, type);
+    var array = DS.RecordArray.create({ type: type, content: Ember.A([]), store: this });
+    this.registerRecordArray(array, type);
 
     var adapter = get(this, '_adapter');
     if (adapter && adapter.findAll) { adapter.findAll(this, type); }
@@ -1043,9 +1140,9 @@ DS.Store = Ember.Object.extend({
       filter = query;
     }
 
-    var array = DS.FilteredModelArray.create({ type: type, content: Ember.A([]), store: this, filterFunction: filter });
+    var array = DS.FilteredRecordArray.create({ type: type, content: Ember.A([]), store: this, filterFunction: filter });
 
-    this.registerModelArray(array, type, filter);
+    this.registerRecordArray(array, type, filter);
 
     return array;
   },
@@ -1055,7 +1152,17 @@ DS.Store = Ember.Object.extend({
   // ............
 
   hashWasUpdated: function(type, clientId, record) {
-    this.updateModelArrays(type, clientId, get(record, 'data'));
+    // Because hash updates are invoked at the end of the run loop,
+    // it is possible that a record might be deleted after its hash
+    // has been modified and this method was scheduled to be called.
+    //
+    // If that's the case, the record would have already been removed
+    // from all record arrays; calling updateRecordArrays would just
+    // add it back. If the record is deleted, just bail. It shouldn't
+    // give us any more trouble after this.
+
+    if (get(record, 'isDeleted')) { return; }
+    this.updateRecordArrays(type, clientId, get(record, 'data'));
   },
 
   // ..............
@@ -1071,37 +1178,37 @@ DS.Store = Ember.Object.extend({
 
   didUpdateRecords: function(array, hashes) {
     if (hashes) {
-      array.forEach(function(model, idx) {
-        this.didUpdateRecord(model, hashes[idx]);
+      array.forEach(function(record, idx) {
+        this.didUpdateRecord(record, hashes[idx]);
       }, this);
     } else {
-      array.forEach(function(model) {
-        this.didUpdateRecord(model);
+      array.forEach(function(record) {
+        this.didUpdateRecord(record);
       }, this);
     }
   },
 
-  didUpdateRecord: function(model, hash) {
+  didUpdateRecord: function(record, hash) {
     if (hash) {
-      var clientId = get(model, 'clientId'),
-          dataCache = this.typeMapFor(model.constructor).cidToHash;
+      var clientId = get(record, 'clientId'),
+          dataCache = this.typeMapFor(record.constructor).cidToHash;
 
       dataCache[clientId] = hash;
-      model.send('didChangeData');
-      model.hashWasUpdated();
+      record.send('didChangeData');
+      record.hashWasUpdated();
     }
 
-    model.send('didCommit');
+    record.send('didCommit');
   },
 
   didDeleteRecords: function(array) {
-    array.forEach(function(model) {
-      model.send('didCommit');
+    array.forEach(function(record) {
+      record.send('didCommit');
     });
   },
 
-  didDeleteRecord: function(model) {
-    model.send('didCommit');
+  didDeleteRecord: function(record) {
+    record.send('didCommit');
   },
 
   _didCreateRecord: function(record, hash, typeMap, clientId, primaryKey) {
@@ -1133,20 +1240,20 @@ DS.Store = Ember.Object.extend({
   didCreateRecords: function(type, array, hashes) {
     var primaryKey = type.proto().primaryKey,
         typeMap = this.typeMapFor(type),
-        id, clientId;
+        clientId;
 
     for (var i=0, l=get(array, 'length'); i<l; i++) {
-      var model = array[i], hash = hashes[i];
-      clientId = get(model, 'clientId');
+      var record = array[i], hash = hashes[i];
+      clientId = get(record, 'clientId');
 
-      this._didCreateRecord(model, hash, typeMap, clientId, primaryKey);
+      this._didCreateRecord(record, hash, typeMap, clientId, primaryKey);
     }
   },
 
-  didCreateRecord: function(model, hash) {
-    var type = model.constructor,
+  didCreateRecord: function(record, hash) {
+    var type = record.constructor,
         typeMap = this.typeMapFor(type),
-        id, clientId, primaryKey;
+        clientId, primaryKey;
 
     // The hash is optional, but if it is not provided, the client must have
     // provided a primary key.
@@ -1157,42 +1264,42 @@ DS.Store = Ember.Object.extend({
     if (hash) {
       ember_assert("The server must provide a primary key: " + primaryKey, get(hash, primaryKey));
     } else {
-      ember_assert("The server did not return data, and you did not create a primary key (" + primaryKey + ") on the client", get(get(model, 'data'), primaryKey));
+      ember_assert("The server did not return data, and you did not create a primary key (" + primaryKey + ") on the client", get(get(record, 'data'), primaryKey));
     }
 
-    clientId = get(model, 'clientId');
+    clientId = get(record, 'clientId');
 
-    this._didCreateRecord(model, hash, typeMap, clientId, primaryKey);
+    this._didCreateRecord(record, hash, typeMap, clientId, primaryKey);
   },
 
   recordWasInvalid: function(record, errors) {
     record.send('becameInvalid', errors);
   },
 
-  // ................
-  // . MODEL ARRAYS .
-  // ................
+  // .................
+  // . RECORD ARRAYS .
+  // .................
 
-  registerModelArray: function(array, type, filter) {
-    var modelArrays = this.typeMapFor(type).modelArrays;
+  registerRecordArray: function(array, type, filter) {
+    var recordArrays = this.typeMapFor(type).recordArrays;
 
-    modelArrays.push(array);
+    recordArrays.push(array);
 
-    this.updateModelArrayFilter(array, type, filter);
+    this.updateRecordArrayFilter(array, type, filter);
   },
 
   createManyArray: function(type, clientIds) {
     var array = DS.ManyArray.create({ type: type, content: clientIds, store: this });
 
     clientIds.forEach(function(clientId) {
-      var modelArrays = this.modelArraysForClientId(clientId);
-      modelArrays.add(array);
+      var recordArrays = this.recordArraysForClientId(clientId);
+      recordArrays.add(array);
     }, this);
 
     return array;
   },
 
-  updateModelArrayFilter: function(array, type, filter) {
+  updateRecordArrayFilter: function(array, type, filter) {
     var typeMap = this.typeMapFor(type),
         dataCache = typeMap.cidToHash,
         clientIds = typeMap.clientIds,
@@ -1203,7 +1310,8 @@ DS.Store = Ember.Object.extend({
     for (var i=0, l=clientIds.length; i<l; i++) {
       clientId = clientIds[i];
 
-      if (hash = dataCache[clientId]) {
+      hash = dataCache[clientId];
+      if (typeof hash === 'object') {
         if (record = recordCache[clientId]) {
           proxy = get(record, 'data');
         } else {
@@ -1211,22 +1319,22 @@ DS.Store = Ember.Object.extend({
           proxy = DATA_PROXY;
         }
 
-        this.updateModelArray(array, filter, type, clientId, proxy);
+        this.updateRecordArray(array, filter, type, clientId, proxy);
       }
     }
   },
 
-  updateModelArrays: function(type, clientId, dataProxy) {
-    var modelArrays = this.typeMapFor(type).modelArrays,
-        modelArrayType, filter;
+  updateRecordArrays: function(type, clientId, dataProxy) {
+    var recordArrays = this.typeMapFor(type).recordArrays,
+        filter;
 
-    modelArrays.forEach(function(array) {
+    recordArrays.forEach(function(array) {
       filter = get(array, 'filterFunction');
-      this.updateModelArray(array, filter, type, clientId, dataProxy);
+      this.updateRecordArray(array, filter, type, clientId, dataProxy);
     }, this);
   },
 
-  updateModelArray: function(array, filter, type, clientId, dataProxy) {
+  updateRecordArray: function(array, filter, type, clientId, dataProxy) {
     var shouldBeInArray;
 
     if (!filter) {
@@ -1238,22 +1346,22 @@ DS.Store = Ember.Object.extend({
     var content = get(array, 'content');
     var alreadyInArray = content.indexOf(clientId) !== -1;
 
-    var modelArrays = this.modelArraysForClientId(clientId);
+    var recordArrays = this.recordArraysForClientId(clientId);
 
     if (shouldBeInArray && !alreadyInArray) {
-      modelArrays.add(array);
+      recordArrays.add(array);
       content.pushObject(clientId);
     } else if (!shouldBeInArray && alreadyInArray) {
-      modelArrays.remove(array);
+      recordArrays.remove(array);
       content.removeObject(clientId);
     }
   },
 
-  removeFromModelArrays: function(model) {
-    var clientId = get(model, 'clientId');
-    var modelArrays = this.modelArraysForClientId(clientId);
+  removeFromRecordArrays: function(record) {
+    var clientId = get(record, 'clientId');
+    var recordArrays = this.recordArraysForClientId(clientId);
 
-    modelArrays.forEach(function(array) {
+    recordArrays.forEach(function(array) {
       var content = get(array, 'content');
       content.removeObject(clientId);
     });
@@ -1263,12 +1371,12 @@ DS.Store = Ember.Object.extend({
   // . INDEXING .
   // ............
 
-  modelArraysForClientId: function(clientId) {
-    var modelArrays = get(this, 'modelArraysByClientId');
-    var ret = modelArrays[clientId];
+  recordArraysForClientId: function(clientId) {
+    var recordArrays = get(this, 'recordArraysByClientId');
+    var ret = recordArrays[clientId];
 
     if (!ret) {
-      ret = modelArrays[clientId] = Ember.OrderedSet.create();
+      ret = recordArrays[clientId] = Ember.OrderedSet.create();
     }
 
     return ret;
@@ -1288,7 +1396,7 @@ DS.Store = Ember.Object.extend({
           idToCid: {},
           clientIds: [],
           cidToHash: {},
-          modelArrays: []
+          recordArrays: []
       });
     }
   },
@@ -1296,13 +1404,17 @@ DS.Store = Ember.Object.extend({
   /** @private
 
     For a given type and id combination, returns the client id used by the store.
-    If no client id has been assigned yet, `undefined` is returned.
+    If no client id has been assigned yet, one will be created and returned.
 
     @param {DS.Model} type
     @param {String|Number} id
   */
   clientIdForId: function(type, id) {
-    return this.typeMapFor(type).idToCid[id];
+    var clientId = this.typeMapFor(type).idToCid[id];
+
+    if (clientId !== undefined) { return clientId; }
+
+    return this.pushHash(UNLOADED, id, type);
   },
 
   // ................
@@ -1311,10 +1423,10 @@ DS.Store = Ember.Object.extend({
 
   /**
     Load a new data hash into the store for a given id and type combination.
-    If data for that model had been loaded previously, the new information
+    If data for that record had been loaded previously, the new information
     overwrites the old.
 
-    If the model you are loading data for has outstanding changes that have not
+    If the record you are loading data for has outstanding changes that have not
     yet been saved, an exception will be thrown.
 
     @param {DS.Model} type
@@ -1325,7 +1437,7 @@ DS.Store = Ember.Object.extend({
     if (hash === undefined) {
       hash = id;
       var primaryKey = type.proto().primaryKey;
-      ember_assert("A data hash was loaded for a model of type " + type.toString() + " but no primary key '" + primaryKey + "' was provided.", primaryKey in hash);
+      ember_assert("A data hash was loaded for a record of type " + type.toString() + " but no primary key '" + primaryKey + "' was provided.", primaryKey in hash);
       id = hash[primaryKey];
     }
 
@@ -1337,16 +1449,16 @@ DS.Store = Ember.Object.extend({
     if (clientId !== undefined) {
       dataCache[clientId] = hash;
 
-      var model = recordCache[clientId];
-      if (model) {
-        model.send('didChangeData');
+      var record = recordCache[clientId];
+      if (record) {
+        record.send('didChangeData');
       }
     } else {
       clientId = this.pushHash(hash, id, type);
     }
 
     DATA_PROXY.savedData = hash;
-    this.updateModelArrays(type, clientId, DATA_PROXY);
+    this.updateRecordArrays(type, clientId, DATA_PROXY);
 
     return { id: id, clientId: clientId };
   },
@@ -1406,22 +1518,22 @@ DS.Store = Ember.Object.extend({
     return clientId;
   },
 
-  // .........................
-  // . MODEL MATERIALIZATION .
-  // .........................
+  // ..........................
+  // . RECORD MATERIALIZATION .
+  // ..........................
 
   materializeRecord: function(type, clientId) {
-    var model;
+    var record;
 
-    get(this, 'recordCache')[clientId] = model = type._create({
+    get(this, 'recordCache')[clientId] = record = type._create({
       store: this,
       clientId: clientId
     });
 
-    get(this, 'defaultTransaction').adoptRecord(model);
+    get(this, 'defaultTransaction').adoptRecord(record);
 
-    model.send('loadingData');
-    return model;
+    record.send('loadingData');
+    return record;
   },
 
   destroy: function() {
@@ -1433,12 +1545,164 @@ DS.Store = Ember.Object.extend({
   }
 });
 
-})({});
+})();
 
 
-(function(exports) {
+
+(function() {
 var get = Ember.get, set = Ember.set, getPath = Ember.getPath, guidFor = Ember.guidFor;
 
+/**
+  This file encapsulates the various states that a record can transition
+  through during its lifecycle.
+
+  ### State Manager
+
+  A record's state manager explicitly tracks what state a record is in
+  at any given time. For instance, if a record is newly created and has
+  not yet been sent to the adapter to be saved, it would be in the
+  `created.uncommitted` state.  If a record has had local modifications
+  made to it that are in the process of being saved, the record would be
+  in the `updated.inFlight` state. (These state paths will be explained
+  in more detail below.)
+
+  Events are sent by the record or its store to the record's state manager.
+  How the state manager reacts to these events is dependent on which state
+  it is in. In some states, certain events will be invalid and will cause
+  an exception to be raised.
+
+  States are hierarchical. For example, a record can be in the
+  `deleted.start` state, then transition into the `deleted.inFlight` state.
+  If a child state does not implement an event handler, the state manager
+  will attempt to invoke the event on all parent states until the root state is
+  reached. The state hierarchy of a record is described in terms of a path
+  string. You can determine a record's current state by getting its manager's
+  current state path:
+
+        record.getPath('manager.currentState.path');
+        //=> "created.uncommitted"
+
+  The `DS.Model` states are themselves stateless. What we mean is that,
+  though each instance of a record also has a unique instance of a
+  `DS.StateManager`, the hierarchical states that each of *those* points
+  to is a shared data structure. For performance reasons, instead of each
+  record getting its own copy of the hierarchy of states, each state
+  manager points to this global, immutable shared instance. How does a
+  state know which record it should be acting on?  We pass a reference to
+  the current state manager as the first parameter to every method invoked
+  on a state.
+
+  The state manager passed as the first parameter is where you should stash
+  state about the record if needed; you should never store data on the state
+  object itself. If you need access to the record being acted on, you can
+  retrieve the state manager's `record` property. For example, if you had
+  an event handler `myEvent`:
+
+      myEvent: function(manager) {
+        var record = manager.get('record');
+        record.doSomething();
+      }
+
+  For more information about state managers in general, see the Ember.js
+  documentation on `Ember.StateManager`.
+
+  ### Events, Flags, and Transitions
+
+  A state may implement zero or more events, flags, or transitions.
+
+  #### Events
+
+  Events are named functions that are invoked when sent to a record. The
+  state manager will first look for a method with the given name on the
+  current state. If no method is found, it will search the current state's
+  parent, and then its grandparent, and so on until reaching the top of
+  the hierarchy. If the root is reached without an event handler being found,
+  an exception will be raised. This can be very helpful when debugging new
+  features.
+
+  Here's an example implementation of a state with a `myEvent` event handler:
+
+      aState: DS.State.create({
+        myEvent: function(manager, param) {
+          console.log("Received myEvent with "+param);
+        }
+      })
+
+  To trigger this event:
+
+      record.send('myEvent', 'foo');
+      //=> "Received myEvent with foo"
+
+  Note that an optional parameter can be sent to a record's `send()` method,
+  which will be passed as the second parameter to the event handler.
+
+  Events should transition to a different state if appropriate. This can be
+  done by calling the state manager's `goToState()` method with a path to the
+  desired state. The state manager will attempt to resolve the state path
+  relative to the current state. If no state is found at that path, it will
+  attempt to resolve it relative to the current state's parent, and then its
+  parent, and so on until the root is reached. For example, imagine a hierarchy
+  like this:
+
+      * created
+        * start <-- currentState
+        * inFlight
+      * updated
+        * inFlight
+
+  If we are currently in the `start` state, calling
+  `goToState('inFlight')` would transition to the `created.inFlight` state,
+  while calling `goToState('updated.inFlight')` would transition to
+  the `updated.inFlight` state.
+
+  Remember that *only events* should ever cause a state transition. You should
+  never call `goToState()` from outside a state's event handler. If you are
+  tempted to do so, create a new event and send that to the state manager.
+
+  #### Flags
+
+  Flags are Boolean values that can be used to introspect a record's current
+  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');
+      if (statePath === 'created.inFlight') {
+        doSomething();
+      }
+
+  You can say:
+
+      if (record.get('isNew') && record.get('isSaving')) {
+        doSomething();
+      }
+
+  If your state does not set a value for a given flag, the value will
+  be inherited from its parent (or the first place in the state hierarchy
+  where it is defined).
+
+  The current set of flags are defined below. If you want to add a new flag,
+  in addition to the area below, you will also need to declare it in the
+  `DS.Model` class.
+
+  #### Transitions
+
+  Transitions are like event handlers but are called automatically upon
+  entering or exiting a state. To implement a transition, just call a method
+  either `enter` or `exit`:
+
+      myState: DS.State.create({
+        // Gets called automatically when entering
+        // this state.
+        enter: function(manager) {
+          console.log("Entered myState");
+        }
+      })
+
+   Note that enter and exit events are called once per transition. If the
+   current state changes, but changes to another child state of the parent,
+   the transition event on the parent will not be triggered.
+*/
+
 var stateProperty = Ember.computed(function(key) {
   var parent = get(this, 'parentState');
   if (parent) {
@@ -1482,18 +1746,27 @@ DS.State = Ember.State.extend({
 var setProperty = function(manager, context) {
   var key = context.key, value = context.value;
 
-  var model = get(manager, 'model'),
-      data = get(model, 'data');
+  var record = get(manager, 'record'),
+      data = get(record, 'data');
 
   set(data, key, value);
 };
 
+var setAssociation = function(manager, context) {
+  var key = context.key, value = context.value;
+
+  var record = get(manager, 'record'),
+      data = get(record, 'data');
+
+  data.setAssociation(key, value);
+};
+
 var didChangeData = function(manager) {
-  var model = get(manager, 'model'),
-      data = get(model, 'data');
+  var record = get(manager, 'record'),
+      data = get(record, 'data');
 
   data._savedData = null;
-  model.notifyPropertyChange('data');
+  record.notifyPropertyChange('data');
 };
 
 // The waitingOn event shares common functionality
@@ -1503,8 +1776,8 @@ var didChangeData = function(manager) {
 // behavior, and then implement the behavior specific
 // to the state.
 var waitingOn = function(manager, object) {
-  var model = get(manager, 'model'),
-      pendingQueue = get(model, 'pendingQueue'),
+  var record = get(manager, 'record'),
+      pendingQueue = get(record, 'pendingQueue'),
       objectGuid = guidFor(object);
 
   var observer = function() {
@@ -1559,17 +1832,7 @@ var waitingOn = function(manager, object) {
 // super points to the class definition.
 var Uncommitted = Ember.Mixin.create({
   setProperty: setProperty,
-
-  deleteRecord: function(manager) {
-    this._super(manager);
-
-    var model = get(manager, 'model'),
-        dirtyType = get(this, 'dirtyType');
-
-    model.withTransaction(function(t) {
-      t.modelBecameClean(dirtyType, model);
-    });
-  }
+  setAssociation: setAssociation,
 });
 
 // These mixins are mixed into substates of the concrete
@@ -1577,8 +1840,12 @@ var Uncommitted = Ember.Mixin.create({
 
 var CreatedUncommitted = Ember.Mixin.create({
   deleteRecord: function(manager) {
+    var record = get(manager, 'record');
     this._super(manager);
 
+    record.withTransaction(function(t) {
+      t.recordBecameClean('created', record);
+    });
     manager.goToState('deleted.saved');
   }
 });
@@ -1587,10 +1854,10 @@ var UpdatedUncommitted = Ember.Mixin.create({
   deleteRecord: function(manager) {
     this._super(manager);
 
-    var model = get(manager, 'model');
+    var record = get(manager, 'record');
 
-    model.withTransaction(function(t) {
-      t.modelBecameClean('created', model);
+    record.withTransaction(function(t) {
+      t.recordBecameClean('updated', record);
     });
 
     manager.goToState('deleted');
@@ -1618,16 +1885,16 @@ var DirtyState = DS.State.extend({
     // TRANSITIONS
     enter: function(manager) {
       var dirtyType = get(this, 'dirtyType'),
-          model = get(manager, 'model');
+          record = get(manager, 'record');
 
-      model.withTransaction(function (t) {
-        t.modelBecameDirty(dirtyType, model);
+      record.withTransaction(function (t) {
+        t.recordBecameDirty(dirtyType, record);
       });
     },
 
     exit: function(manager) {
-      var model = get(manager, 'model');
-      manager.send('invokeLifecycleCallbacks', model);
+      var record = get(manager, 'record');
+      manager.send('invokeLifecycleCallbacks', record);
     },
 
     // EVENTS
@@ -1640,6 +1907,20 @@ var DirtyState = DS.State.extend({
 
     willCommit: function(manager) {
       manager.goToState('inFlight');
+    },
+
+    rollback: function(manager) {
+      var record = get(manager, 'record'),
+          dirtyType = get(this, 'dirtyType'),
+          data = get(record, 'data');
+
+      data.rollback();
+
+      record.withTransaction(function(t) {
+        t.recordBecameClean(dirtyType, record);
+      });
+
+      manager.goToState('loaded');
     }
   }, Uncommitted),
 
@@ -1653,10 +1934,10 @@ var DirtyState = DS.State.extend({
     // TRANSITIONS
     enter: function(manager) {
       var dirtyType = get(this, 'dirtyType'),
-          model = get(manager, 'model');
+          record = get(manager, 'record');
 
-      model.withTransaction(function (t) {
-        t.modelBecameClean(dirtyType, model);
+      record.withTransaction(function (t) {
+        t.recordBecameClean(dirtyType, record);
       });
     },
 
@@ -1666,9 +1947,9 @@ var DirtyState = DS.State.extend({
     },
 
     becameInvalid: function(manager, errors) {
-      var model = get(manager, 'model');
+      var record = get(manager, 'record');
 
-      set(model, 'errors', errors);
+      set(record, 'errors', errors);
       manager.goToState('invalid');
     },
 
@@ -1698,8 +1979,8 @@ var DirtyState = DS.State.extend({
     uncommitted: DS.State.extend({
       // EVENTS
       deleteRecord: function(manager) {
-        var model = get(manager, 'model'),
-            pendingQueue = get(model, 'pendingQueue'),
+        var record = get(manager, 'record'),
+            pendingQueue = get(record, 'pendingQueue'),
             tuple;
 
         // since we are leaving the pending state, remove any
@@ -1717,8 +1998,8 @@ var DirtyState = DS.State.extend({
       },
 
       doneWaitingOn: function(manager, object) {
-        var model = get(manager, 'model'),
-            pendingQueue = get(model, 'pendingQueue'),
+        var record = get(manager, 'record'),
+            pendingQueue = get(record, 'pendingQueue'),
             objectGuid = guidFor(object);
 
         delete pendingQueue[objectGuid];
@@ -1744,8 +2025,8 @@ var DirtyState = DS.State.extend({
 
       // EVENTS
       doneWaitingOn: function(manager, object) {
-        var model = get(manager, 'model'),
-            pendingQueue = get(model, 'pendingQueue'),
+        var record = get(manager, 'record'),
+            pendingQueue = get(record, 'pendingQueue'),
             objectGuid = guidFor(object);
 
         delete pendingQueue[objectGuid];
@@ -1756,10 +2037,10 @@ var DirtyState = DS.State.extend({
       },
 
       doneWaiting: function(manager) {
-        var model = get(manager, 'model'),
-            transaction = get(model, 'transaction');
+        var record = get(manager, 'record'),
+            transaction = get(record, 'transaction');
 
-        // Now that the model is no longer pending, schedule
+        // Now that the record is no longer pending, schedule
         // the transaction to commit.
         Ember.run.once(transaction, transaction.commit);
       },
@@ -1783,11 +2064,13 @@ var DirtyState = DS.State.extend({
       manager.goToState('deleted');
     },
 
+    setAssociation: setAssociation,
+
     setProperty: function(manager, context) {
       setProperty(manager, context);
 
-      var model = get(manager, 'model'),
-          errors = get(model, 'errors'),
+      var record = get(manager, 'record'),
+          errors = get(record, 'errors'),
           key = context.key;
 
       delete errors[key];
@@ -1814,8 +2097,8 @@ var createdState = DirtyState.create({
   isNew: true,
 
   // EVENTS
-  invokeLifecycleCallbacks: function(manager, model) {
-    model.didCreate();
+  invokeLifecycleCallbacks: function(manager, record) {
+    record.fire('didCreate');
   }
 });
 
@@ -1823,8 +2106,8 @@ var updatedState = DirtyState.create({
   dirtyType: 'updated',
 
   // EVENTS
-  invokeLifecycleCallbacks: function(manager, model) {
-    model.didUpdate();
+  invokeLifecycleCallbacks: function(manager, record) {
+    record.fire('didUpdate');
   }
 });
 
@@ -1833,6 +2116,15 @@ var updatedState = DirtyState.create({
 createdState.states.uncommitted.reopen(CreatedUncommitted);
 createdState.states.pending.states.uncommitted.reopen(CreatedUncommitted);
 
+// The created.uncommitted state needs to immediately transition to the
+// deleted state if it is rolled back.
+createdState.states.uncommitted.reopen({
+  rollback: function(manager) {
+    this._super(manager);
+    manager.goToState('deleted.saved');
+  }
+});
+
 // The updated.uncommitted state and updated.pending.uncommitted share
 // some logic defined in UpdatedUncommitted.
 updatedState.states.uncommitted.reopen(UpdatedUncommitted);
@@ -1879,8 +2171,8 @@ var states = {
     loading: DS.State.create({
       // TRANSITIONS
       exit: function(manager) {
-        var model = get(manager, 'model');
-        model.didLoad();
+        var record = get(manager, 'record');
+        record.fire('didLoad');
       },
 
       // EVENTS
@@ -1914,6 +2206,11 @@ var states = {
           manager.goToState('updated');
         },
 
+        setAssociation: function(manager, context) {
+          setAssociation(manager, context);
+          manager.goToState('updated');
+        },
+
         didChangeData: didChangeData,
 
         deleteRecord: function(manager) {
@@ -1944,6 +2241,14 @@ var states = {
       isLoaded: true,
       isDirty: true,
 
+      // TRANSITIONS
+      enter: function(manager) {
+        var record = get(manager, 'record'),
+            store = get(record, 'store');
+
+        store.removeFromRecordArrays(record);
+      },
+
       // SUBSTATES
 
       // When a record is deleted, it enters the `start`
@@ -1952,21 +2257,27 @@ var states = {
       start: DS.State.create({
         // TRANSITIONS
         enter: function(manager) {
-          var model = get(manager, 'model');
-          var store = get(model, 'store');
-
-          if (store) {
-            store.removeFromModelArrays(model);
-          }
+          var record = get(manager, 'record');
 
-          model.withTransaction(function(t) {
-            t.modelBecameDirty('deleted', model);
+          record.withTransaction(function(t) {
+            t.recordBecameDirty('deleted', record);
           });
         },
 
         // EVENTS
         willCommit: function(manager) {
           manager.goToState('inFlight');
+        },
+
+        rollback: function(manager) {
+          var record = get(manager, 'record'),
+              data = get(record, 'data');
+
+          data.rollback();
+          record.withTransaction(function(t) {
+            t.recordBecameClean('deleted', record);
+          });
+          manager.goToState('loaded');
         }
       }),
 
@@ -1980,10 +2291,10 @@ var states = {
 
         // TRANSITIONS
         exit: function(stateManager) {
-          var model = get(stateManager, 'model');
+          var record = get(stateManager, 'record');
 
-          model.withTransaction(function(t) {
-            t.modelBecameClean('deleted', model);
+          record.withTransaction(function(t) {
+            t.recordBecameClean('deleted', record);
           });
         },
 
@@ -2012,24 +2323,21 @@ var states = {
 };
 
 DS.StateManager = Ember.StateManager.extend({
-  model: null,
+  record: null,
   initialState: 'rootState',
   states: states
 });
 
-})({});
+})();
 
 
-(function(exports) {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath, none = Ember.none;
 
-var retrieveFromCurrentState = Ember.computed(function(key) {
-  return get(getPath(this, 'stateManager.currentState'), key);
-}).property('stateManager.currentState').cacheable();
+(function() {
+var get = Ember.get, set = Ember.set;
 
 // This object is a regular JS object for performance. It is only
 // used internally for bookkeeping purposes.
-var DataProxy = function(record) {
+var DataProxy = DS._DataProxy = function(record) {
   this.record = record;
   this.unsavedData = {};
   this.associations = {};
@@ -2111,6 +2419,8 @@ DataProxy.prototype = {
 
   rollback: function() {
     this.unsavedData = {};
+
+    this.record.notifyPropertyChange('data');
   },
 
   adapterDidUpdate: function(data) {
@@ -2118,7 +2428,18 @@ DataProxy.prototype = {
   }
 };
 
-DS.Model = Ember.Object.extend({
+})();
+
+
+
+(function() {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath, none = Ember.none;
+
+var retrieveFromCurrentState = Ember.computed(function(key) {
+  return get(getPath(this, 'stateManager.currentState'), key);
+}).property('stateManager.currentState').cacheable();
+
+DS.Model = Ember.Object.extend(Ember.Evented, {
   isLoaded: retrieveFromCurrentState,
   isDirty: retrieveFromCurrentState,
   isSaving: retrieveFromCurrentState,
@@ -2235,6 +2556,7 @@ DS.Model = Ember.Object.extend({
       }
     }
 
+    key = options.key || get(this, 'namingConvention').keyToJSONKey(key);
     json[key] = records;
   },
 
@@ -2300,7 +2622,7 @@ DS.Model = Ember.Object.extend({
   },
 
   data: Ember.computed(function() {
-    return new DataProxy(this);
+    return new DS._DataProxy(this);
   }).cacheable(),
 
   didLoad: Ember.K,
@@ -2309,7 +2631,7 @@ DS.Model = Ember.Object.extend({
 
   init: function() {
     var stateManager = DS.StateManager.create({
-      model: this
+      record: this
     });
 
     set(this, 'pendingQueue', {});
@@ -2357,7 +2679,7 @@ DS.Model = Ember.Object.extend({
     var data = get(this, 'data');
 
     if (data && key in data) {
-      ember_assert("You attempted to access the " + key + " property on a model without defining an attribute.", false);
+      ember_assert("You attempted to access the " + key + " property on a record without defining an attribute.", false);
     }
   },
 
@@ -2365,7 +2687,7 @@ DS.Model = Ember.Object.extend({
     var data = get(this, 'data');
 
     if (data && key in data) {
-      ember_assert("You attempted to set the " + key + " property on a model without defining an attribute.", false);
+      ember_assert("You attempted to set the " + key + " property on a record without defining an attribute.", false);
     } else {
       return this._super(key, value);
     }
@@ -2384,10 +2706,44 @@ DS.Model = Ember.Object.extend({
 
   /** @private */
   hashWasUpdated: function() {
-    // At the end of the run loop, notify model arrays that
+    // At the end of the run loop, notify record arrays that
     // this record has changed so they can re-evaluate its contents
     // to determine membership.
     Ember.run.once(this, this.notifyHashWasUpdated);
+  },
+
+  dataDidChange: Ember.observer(function() {
+    var associations = get(this.constructor, 'associationsByName'),
+        data = get(this, 'data'), store = get(this, 'store'),
+        idToClientId = store.idToClientId,
+        cachedValue;
+
+    associations.forEach(function(name, association) {
+      if (association.kind === 'hasMany') {
+        cachedValue = this.cacheFor(name);
+
+        if (cachedValue) {
+          var ids = data.get(name) || [];
+          var clientIds = Ember.ArrayUtils.map(ids, function(id) {
+            return store.clientIdForId(association.type, id);
+          });
+
+          set(cachedValue, 'content', Ember.A(clientIds));
+          cachedValue.fetch();
+        }
+      }
+    }, this);
+  }, 'data'),
+
+  /**
+    @private
+
+    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));
+    this._super.apply(this, arguments);
   }
 });
 
@@ -2418,10 +2774,11 @@ DS.Model.reopenClass({
   createRecord: storeAlias('createRecord')
 });
 
-})({});
+})();
+
 
 
-(function(exports) {
+(function() {
 var get = Ember.get, getPath = Ember.getPath;
 DS.Model.reopenClass({
   attributes: Ember.computed(function() {
@@ -2573,75 +2930,27 @@ DS.attr.transforms = {
 };
 
 
-})({});
-
-
-(function(exports) {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
-DS.Model.reopenClass({
-  typeForAssociation: function(name) {
-    var association = get(this, 'associationsByName').get(name);
-    return association && association.type;
-  },
-
-  associations: Ember.computed(function() {
-    var map = Ember.Map.create();
-
-    this.eachComputedProperty(function(name, meta) {
-      if (meta.isAssociation) {
-        var type = meta.type,
-            typeList = map.get(type);
-
-        if (typeof type === 'string') {
-          type = getPath(this, type, false) || getPath(window, type);
-          meta.type = type;
-        }
-
-        if (!typeList) {
-          typeList = [];
-          map.set(type, typeList);
-        }
-
-        typeList.push({ name: name, kind: meta.kind });
-      }
-    });
+})();
 
-    return map;
-  }).cacheable(),
 
-  associationsByName: Ember.computed(function() {
-    var map = Ember.Map.create(), type;
 
-    this.eachComputedProperty(function(name, meta) {
-      if (meta.isAssociation) {
-        meta.key = name;
-        type = meta.type;
+(function() {
 
-        if (typeof type === 'string') {
-          type = getPath(this, type, false) || getPath(window, type);
-          meta.type = type;
-        }
+})();
 
-        map.set(name, meta);
-      }
-    });
 
-    return map;
-  }).cacheable()
-});
 
+(function() {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath,
+    none = Ember.none;
 
 var embeddedFindRecord = function(store, type, data, key, one) {
-  var association = data ? get(data, key) : one ? null : [];
-  if (one) {
-    return association ? store.load(type, association).id : null;
-  } else {
-    return association ? store.loadMany(type, association).ids : [];
-  }
+  var association = get(data, key);
+  return none(association) ? undefined : store.load(type, association).id;
 };
 
 var referencedFindRecord = function(store, type, data, key, one) {
-  return data ? get(data, key) : one ? null : [];
+  return get(data, key);
 };
 
 var hasAssociation = function(type, options, one) {
@@ -2650,12 +2959,7 @@ var hasAssociation = function(type, options, one) {
   var embedded = options.embedded,
       findRecord = embedded ? embeddedFindRecord : referencedFindRecord;
 
-  var meta = { type: type, isAssociation: true, options: options };
-  if (one) {
-    meta.kind = 'belongsTo';
-  } else {
-    meta.kind = 'hasMany';
-  }
+  var meta = { type: type, isAssociation: true, options: options, kind: 'belongsTo' };
 
   return Ember.computed(function(key, value) {
     var data = get(this, 'data'), ids, id, association,
@@ -2665,57 +2969,477 @@ var hasAssociation = function(type, options, one) {
       type = getPath(this, type, false) || getPath(window, type);
     }
 
-    if (one) {
-      if (arguments.length === 2) {
-        key = options.key || get(this, 'namingConvention').foreignKey(key);
-        data.setAssociation(key, get(value, 'clientId'));
-        // put the client id in `key` in the data hash
-        return value;
-      } else {
-        // Embedded belongsTo associations should not look for
-        // a foreign key.
-        if (embedded) {
-          key = options.key || key;
+    if (arguments.length === 2) {
+      key = options.key || get(this, 'namingConvention').foreignKey(key);
+      this.send('setAssociation', { key: key, value: value === null ? null : get(value, 'clientId') });
+      //data.setAssociation(key, get(value, 'clientId'));
+      // put the client id in `key` in the data hash
+      return value;
+    } else {
+      // Embedded belongsTo associations should not look for
+      // a foreign key.
+      if (embedded) {
+        key = options.key || get(this, 'namingConvention').keyToJSONKey(key);
 
-        // Non-embedded associations should look for a foreign key.
-        // For example, instead of person, we might look for person_id
-        } else {
-          key = options.key || get(this, 'namingConvention').foreignKey(key);
-        }
-        id = findRecord(store, type, data, key, true);
-        association = id ? store.find(type, id) : null;
+      // Non-embedded associations should look for a foreign key.
+      // For example, instead of person, we might look for person_id
+      } else {
+        key = options.key || get(this, 'namingConvention').foreignKey(key);
       }
-    } else {
-      key = options.key || key;
-      ids = findRecord(store, type, data, key);
-      association = store.findMany(type, ids);
-      set(association, 'parentRecord', this);
+      id = findRecord(store, type, data, key, true);
+      association = id ? store.find(type, id) : null;
     }
 
     return association;
   }).property('data').cacheable().meta(meta);
 };
 
-DS.hasMany = function(type, options) {
-  ember_assert("The type passed to DS.hasMany must be defined", !!type);
+DS.belongsTo = function(type, options) {
+  ember_assert("The type passed to DS.belongsTo must be defined", !!type);
   return hasAssociation(type, options);
 };
 
-DS.hasOne = function(type, options) {
-  ember_assert("The type passed to DS.belongsTo must be defined", !!type);
-  return hasAssociation(type, options, true);
-};
+})();
 
-DS.belongsTo = DS.hasOne;
 
-})({});
 
+(function() {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+var embeddedFindRecord = function(store, type, data, key) {
+  var association = get(data, key);
+  return association ? store.loadMany(type, association).ids : [];
+};
 
-(function(exports) {
-})({});
+var referencedFindRecord = function(store, type, data, key, one) {
+  return get(data, key);
+};
+
+var hasAssociation = function(type, options) {
+  options = options || {};
+
+  var embedded = options.embedded,
+      findRecord = embedded ? embeddedFindRecord : referencedFindRecord;
+
+  var meta = { type: type, isAssociation: true, options: options, kind: 'hasMany' };
+
+  return Ember.computed(function(key, value) {
+    var data = get(this, 'data'),
+        store = get(this, 'store'),
+        ids, id, association;
+
+    if (typeof type === 'string') {
+      type = getPath(this, type, false) || getPath(window, type);
+    }
+
+    key = options.key || key;
+    ids = findRecord(store, type, data, key);
+    association = store.findMany(type, ids);
+    set(association, 'parentRecord', this);
+
+    return association;
+  }).property().cacheable().meta(meta);
+};
+
+DS.hasMany = function(type, options) {
+  ember_assert("The type passed to DS.hasMany must be defined", !!type);
+  return hasAssociation(type, options);
+};
+
+})();
 
 
-(function(exports) {
+
+(function() {
+var get = Ember.get, getPath = Ember.getPath;
+
+DS.Model.reopenClass({
+  typeForAssociation: function(name) {
+    var association = get(this, 'associationsByName').get(name);
+    return association && association.type;
+  },
+
+  associations: Ember.computed(function() {
+    var map = Ember.Map.create();
+
+    this.eachComputedProperty(function(name, meta) {
+      if (meta.isAssociation) {
+        var type = meta.type,
+            typeList = map.get(type);
+
+        if (typeof type === 'string') {
+          type = getPath(this, type, false) || getPath(window, type);
+          meta.type = type;
+        }
+
+        if (!typeList) {
+          typeList = [];
+          map.set(type, typeList);
+        }
+
+        typeList.push({ name: name, kind: meta.kind });
+      }
+    });
+
+    return map;
+  }).cacheable(),
+
+  associationsByName: Ember.computed(function() {
+    var map = Ember.Map.create(), type;
+
+    this.eachComputedProperty(function(name, meta) {
+      if (meta.isAssociation) {
+        meta.key = name;
+        type = meta.type;
+
+        if (typeof type === 'string') {
+          type = getPath(this, type, false) || getPath(window, type);
+          meta.type = type;
+        }
+
+        map.set(name, meta);
+      }
+    });
+
+    return map;
+  }).cacheable()
+});
+
+})();
+
+
+
+(function() {
+
+})();
+
+
+
+(function() {
+DS.Adapter = Ember.Object.extend({
+  commit: function(store, commitDetails) {
+    commitDetails.updated.eachType(function(type, array) {
+      this.updateRecords(store, type, array.slice());
+    }, this);
+
+    commitDetails.created.eachType(function(type, array) {
+      this.createRecords(store, type, array.slice());
+    }, this);
+
+    commitDetails.deleted.eachType(function(type, array) {
+      this.deleteRecords(store, type, array.slice());
+    }, this);
+  },
+
+  createRecords: function(store, type, records) {
+    records.forEach(function(record) {
+      this.createRecord(store, type, record);
+    }, this);
+  },
+
+  updateRecords: function(store, type, records) {
+    records.forEach(function(record) {
+      this.updateRecord(store, type, record);
+    }, this);
+  },
+
+  deleteRecords: function(store, type, records) {
+    records.forEach(function(record) {
+      this.deleteRecord(store, type, record);
+    }, this);
+  },
+
+  findMany: function(store, type, ids) {
+    ids.forEach(function(id) {
+      this.find(store, type, id);
+    }, this);
+  }
+});
+
+})();
+
+
+
+(function() {
+DS.fixtureAdapter = DS.Adapter.create({
+  find: function(store, type, id) {
+    var fixtures = type.FIXTURES;
+
+    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);
+  },
+
+  findMany: function() {
+    this.find.apply(this, arguments);
+  },
+
+  findAll: function(store, type) {
+    var fixtures = type.FIXTURES;
+
+    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);
+  }
+
+});
+
+})();
+
+
+
+(function() {
+/*global jQuery*/
+
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+
+DS.RESTAdapter = DS.Adapter.extend({
+  createRecord: function(store, type, record) {
+    var root = this.rootForType(type);
+
+    var data = {};
+    data[root] = record.toJSON();
+
+    this.ajax(this.buildURL(root), "POST", {
+      data: data,
+      success: function(json) {
+        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);
+    }
+
+    var root = this.rootForType(type),
+        plural = this.pluralize(root);
+
+    var data = {};
+    data[plural] = records.map(function(record) {
+      return record.toJSON();
+    });
+
+    this.ajax(this.buildURL(root), "POST", {
+      data: data,
+
+      success: function(json) {
+        this.sideload(store, type, json, plural);
+        store.didCreateRecords(type, records, json[plural]);
+      }
+    });
+  },
+
+  updateRecord: function(store, type, record) {
+    var id = get(record, 'id');
+    var root = this.rootForType(type);
+
+    var data = {};
+    data[root] = record.toJSON();
+
+    this.ajax(this.buildURL(root, id), "PUT", {
+      data: data,
+      success: function(json) {
+        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);
+    }
+
+    var root = this.rootForType(type),
+        plural = this.pluralize(root);
+
+    var data = {};
+    data[plural] = records.map(function(record) {
+      return record.toJSON();
+    });
+
+    this.ajax(this.buildURL(root, "bulk"), "PUT", {
+      data: data,
+      success: function(json) {
+        this.sideload(store, type, json, plural);
+        store.didUpdateRecords(records, json[plural]);
+      }
+    });
+  },
+
+  deleteRecord: function(store, type, record) {
+    var id = get(record, 'id');
+    var root = this.rootForType(type);
+
+    this.ajax(this.buildURL(root, id), "DELETE", {
+      success: function(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);
+    }
+
+    var root = this.rootForType(type),
+        plural = this.pluralize(root);
+
+    var data = {};
+    data[plural] = records.map(function(record) {
+      return get(record, 'id');
+    });
+
+    this.ajax(this.buildURL(root, 'bulk'), "DELETE", {
+      data: data,
+      success: function(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);
+      }
+    });
+  },
+
+  findMany: function(store, type, ids) {
+    var root = this.rootForType(type), plural = this.pluralize(root);
+
+    this.ajax(this.buildURL(root), "GET", {
+      data: { ids: ids },
+      success: function(json) {
+        store.loadMany(type, ids, json[plural]);
+        this.sideload(store, type, json, plural);
+      }
+    });
+  },
+
+  findAll: function(store, type) {
+    var root = this.rootForType(type), plural = this.pluralize(root);
+
+    this.ajax(this.buildURL(root), "GET", {
+      success: function(json) {
+        store.loadMany(type, json[plural]);
+        this.sideload(store, type, json, plural);
+      }
+    });
+  },
+
+  findQuery: function(store, type, query, recordArray) {
+    var root = this.rootForType(type), plural = this.pluralize(root);
+
+    this.ajax(this.buildURL(root), "GET", {
+      data: query,
+      success: function(json) {
+        recordArray.load(json[plural]);
+        this.sideload(store, type, json, plural);
+      }
+    });
+  },
+
+  // HELPERS
+
+  plurals: {},
+
+  // define a plurals hash in your subclass to define
+  // special-case pluralization
+  pluralize: function(name) {
+    return this.plurals[name] || name + "s";
+  },
+
+  rootForType: function(type) {
+    if (type.url) { return type.url; }
+
+    // use the last part of the name as the URL
+    var parts = type.toString().split(".");
+    var name = parts[parts.length - 1];
+    return name.replace(/([A-Z])/g, '_$1').toLowerCase().slice(1);
+  },
+
+  ajax: function(url, type, hash) {
+    hash.url = url;
+    hash.type = type;
+    hash.dataType = 'json';
+    hash.contentType = 'application/json';
+    hash.context = this;
+
+    if (hash.data && type !== 'GET') {
+      hash.data = JSON.stringify(hash.data);
+    }
+
+    jQuery.ajax(hash);
+  },
+
+  sideload: function(store, type, json, root) {
+    var sideloadedType, mappings;
+
+    for (var prop in json) {
+      if (!json.hasOwnProperty(prop)) { continue; }
+      if (prop === root) { continue; }
+
+      sideloadedType = type.typeForAssociation(prop);
+
+      if (!sideloadedType) {
+        mappings = get(this, 'mappings');
+
+        ember_assert("Your server returned a hash with the key " + prop + " but you have no mappings", !!mappings);
+
+        sideloadedType = get(get(this, 'mappings'), prop);
+
+        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]);
+    }
+  },
+
+  loadValue: function(store, type, value) {
+    if (value instanceof Array) {
+      store.loadMany(type, value);
+    } else {
+      store.load(type, value);
+    }
+  },
+
+  buildURL: function(record, suffix) {
+    var url = [""];
+
+    if (this.namespace !== undefined) {
+      url.push(this.namespace);
+    }
+
+    url.push(this.pluralize(record));
+    if (suffix !== undefined) {
+      url.push(suffix);
+    }
+
+    return url.join("/");
+  }
+});
+
+
+})();
+
+
+
+(function() {
 //Copyright (C) 2011 by Living Social, Inc.
 
 //Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -2735,4 +3459,6 @@ DS.belongsTo = DS.hasOne;
 //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //SOFTWARE.
-})({});
+
+})();
+