rightnow_oms 0.1.2 → 0.1.3

data/app/assets/javascripts/rightnow_oms/vendor/ember-data.js

@@ -71,7 +71,7 @@ DS.fixtureAdapter = DS.Adapter.create({
 
     ember_assert("Unable to find fixtures for model type "+type.toString(), !!fixtures);
 
-    var ids = fixtures.map(function(item, index, self){ return item.id });
+    var ids = fixtures.map(function(item, index, self){ return item.id; });
     store.loadMany(type, ids, fixtures);
   }
 
@@ -81,6 +81,7 @@ DS.fixtureAdapter = DS.Adapter.create({
 
 
 (function(exports) {
+/*global jQuery*/
 var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
 
 DS.RESTAdapter = DS.Adapter.extend({
@@ -120,8 +121,7 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   updateRecord: function(store, type, model) {
-    var primaryKey = getPath(type, 'proto.primaryKey'),
-        id = get(model, primaryKey);
+    var id = get(model, 'id');
     var root = this.rootForType(type);
 
     var data = {};
@@ -159,8 +159,7 @@ DS.RESTAdapter = DS.Adapter.extend({
   },
 
   deleteRecord: function(store, type, model) {
-    var primaryKey = getPath(type, 'proto.primaryKey'),
-        id = get(model, primaryKey);
+    var id = get(model, 'id');
     var root = this.rootForType(type);
 
     var url = ["", this.pluralize(root), id].join("/");
@@ -178,12 +177,11 @@ DS.RESTAdapter = DS.Adapter.extend({
     }
 
     var root = this.rootForType(type),
-        plural = this.pluralize(root),
-        primaryKey = getPath(type, 'proto.primaryKey');
+        plural = this.pluralize(root);
 
     var data = {};
     data[plural] = models.map(function(model) {
-      return get(model, primaryKey);
+      return get(model, 'id');
     });
 
     this.ajax("/" + this.pluralize(root) + "/delete", "POST", {
@@ -215,7 +213,6 @@ DS.RESTAdapter = DS.Adapter.extend({
         store.loadMany(type, ids, json[plural]);
       }
     });
-    var url = "/" + plural;
   },
 
   findAll: function(store, type) {
@@ -274,19 +271,58 @@ DS.RESTAdapter = DS.Adapter.extend({
 (function(exports) {
 var get = Ember.get, set = Ember.set;
 
+/**
+  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.
+*/
+
 DS.ModelArray = Ember.ArrayProxy.extend({
+
+  /**
+    The model type contained by this model array.
+
+    @type DS.Model
+  */
   type: null,
+
+  // 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,
+
+  // The store that created this model array.
   store: null,
 
+  // for associations, the model that this association belongs to.
+  parentModel: null,
+
   init: function() {
     set(this, 'modelCache', Ember.A([]));
     this._super();
   },
 
+  // Overrides Ember.Array's replace method to implement
+  replace: function(index, removed, added) {
+    var parentRecord = get(this, 'parentRecord');
+    var pendingParent = parentRecord && !get(parentRecord, 'id');
+
+    added = added.map(function(item) {
+      ember_assert("You can only add items of " + (get(this, 'type') && get(this, 'type').toString()) + " to this association.", !get(this, 'type') || (get(this, 'type') === item.constructor));
+
+      if (pendingParent) { item.send('waitingOn', parentRecord); }
+      return item.get('clientId');
+    });
+
+    this._super(index, removed, added);
+  },
+
   arrayDidChange: function(array, index, removed, added) {
     var modelCache = get(this, 'modelCache');
-    modelCache.replace(index, 0, Array(added));
+    modelCache.replace(index, 0, new Array(added));
 
     this._super(array, index, removed, added);
   },
@@ -318,6 +354,12 @@ DS.ModelArray = Ember.ArrayProxy.extend({
   }
 });
 
+})({});
+
+
+(function(exports) {
+var get = Ember.get;
+
 DS.FilteredModelArray = DS.ModelArray.extend({
   filterFunction: null,
 
@@ -327,6 +369,12 @@ DS.FilteredModelArray = DS.ModelArray.extend({
   }, 'filterFunction')
 });
 
+})({});
+
+
+(function(exports) {
+var get = Ember.get, set = Ember.set;
+
 DS.AdapterPopulatedModelArray = DS.ModelArray.extend({
   query: null,
   isLoaded: false,
@@ -343,6 +391,11 @@ DS.AdapterPopulatedModelArray = DS.ModelArray.extend({
   }
 });
 
+
+})({});
+
+
+(function(exports) {
 })({});
 
 
@@ -384,7 +437,8 @@ var OrderedSet = Ember.Object.extend({
   },
 
   forEach: function(fn, self) {
-    get(this, 'list').forEach(function(item) {
+    // allow mutation during iteration
+    get(this, 'list').slice().forEach(function(item) {
       fn.call(self, item);
     });
   },
@@ -447,7 +501,8 @@ var Hash = Ember.Object.extend({
   },
 
   forEach: function(fn, binding) {
-    var keys = get(this, 'keys'), values = get(this, 'values');
+    var keys = get(this, 'keys'),
+        values = get(this, 'values');
 
     keys.forEach(function(key) {
       var guid = Ember.guidFor(key);
@@ -507,8 +562,17 @@ DS.Transaction = Ember.Object.extend({
       dirty.forEach(function(type, models) {
         if (models.isEmpty()) { return; }
 
-        models.forEach(function(model) { model.willCommit(); });
-        fn.call(binding, type, models.toArray());
+        var array = [];
+
+        models.forEach(function(model) {
+          model.send('willCommit');
+
+          if (get(model, 'isPending') === false) {
+            array.push(model);
+          }
+        });
+
+        fn.call(binding, type, array);
       });
     };
 
@@ -680,28 +744,27 @@ DS.Store = Ember.Object.extend({
   // . CREATE NEW MODEL .
   // ....................
 
-  createRecord: function(type, hash, transaction) {
-    hash = hash || {};
+  createRecord: function(type, properties, transaction) {
+    properties = properties || {};
 
-    var id = hash[getPath(type, 'proto.primaryKey')] || null;
+    var id = properties[getPath(type, 'proto.primaryKey')] || null;
 
-    var model = type.create({
-      data: hash || {},
+    var model = type._create({
       store: this,
       transaction: transaction
     });
 
-    model.adapterDidCreate();
+    var hash = {}, clientId;
 
-    var data = this.clientIdToHashMap(type);
-    var models = get(this, 'models');
+    clientId = this.pushHash(hash, id, type);
+    model.send('setData', hash);
 
-    var clientId = this.pushHash(hash, id, type);
+    var models = get(this, 'models');
 
     set(model, 'clientId', clientId);
-
     models[clientId] = model;
 
+    model.setProperties(properties);
     this.updateModelArrays(type, clientId, hash);
 
     return model;
@@ -712,7 +775,7 @@ DS.Store = Ember.Object.extend({
   // ................
 
   deleteRecord: function(model) {
-    model.deleteRecord();
+    model.send('deleteRecord');
   },
 
   // ...............
@@ -739,7 +802,7 @@ DS.Store = Ember.Object.extend({
   */
   find: function(type, id, query) {
     if (id === undefined) {
-      return this.findMany(type, null, null);
+      return this.findAll(type);
     }
 
     if (query !== undefined) {
@@ -774,17 +837,17 @@ DS.Store = Ember.Object.extend({
       if (!model) {
         // create a new instance of the model in the
         // 'isLoading' state
-        model = this.createModel(type, clientId);
+        model = this.materializeRecord(type, clientId);
 
         // immediately set its data
-        model.setData(data[clientId] || null);
+        model.send('setData', data[clientId] || null);
       }
     } else {
       clientId = this.pushHash(null, id, type);
 
       // create a new instance of the model in the
       // 'isLoading' state
-      model = this.createModel(type, clientId);
+      model = this.materializeRecord(type, clientId);
 
       // let the adapter set the data, possibly async
       var adapter = get(this, '_adapter');
@@ -898,20 +961,20 @@ DS.Store = Ember.Object.extend({
       var data = this.clientIdToHashMap(model.constructor);
 
       data[clientId] = hash;
-      model.set('data', hash);
+      model.send('setData', hash);
     }
 
-    model.adapterDidUpdate();
+    model.send('didCommit');
   },
 
   didDeleteRecords: function(array) {
     array.forEach(function(model) {
-      model.adapterDidDelete();
+      model.send('didCommit');
     });
   },
 
   didDeleteRecord: function(model) {
-    model.adapterDidDelete();
+    model.send('didCommit');
   },
 
   didCreateRecords: function(type, array, hashes) {
@@ -927,38 +990,55 @@ DS.Store = Ember.Object.extend({
       clientId = get(model, 'clientId');
 
       data[clientId] = hash;
-      set(model, 'data', hash);
+      model.send('setData', hash);
 
       idToClientIdMap[id] = clientId;
       idList.push(id);
 
-      model.adapterDidUpdate();
+      model.send('didCommit');
     }
   },
 
   didCreateRecord: function(model, hash) {
     var type = model.constructor;
 
-    var id, clientId, primaryKey = getPath(type, 'proto.primaryKey');
+    var id, clientId, primaryKey;
 
     var idToClientIdMap = this.idToClientIdMap(type);
     var data = this.clientIdToHashMap(type);
     var idList = this.idList(type);
 
-    id = hash[primaryKey];
+    // The hash is optional, but if it is not provided, the client must have
+    // provided a primary key.
+
+    primaryKey = getPath(type, 'proto.primaryKey');
+
+    // TODO: Make ember_assert more flexible and convert this into an ember_assert
+    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));
+    }
+
+    // If a hash was provided, index it under the model's client ID
+    // and update the model.
+    if (arguments.length === 2) {
+      id = hash[primaryKey];
+
+      data[clientId] = hash;
+      set(model, 'data', hash);
+    }
 
     clientId = get(model, 'clientId');
-    data[clientId] = hash;
-    set(model, 'data', hash);
 
     idToClientIdMap[id] = clientId;
     idList.push(id);
 
-    model.adapterDidUpdate();
+    model.send('didCommit');
   },
 
   recordWasInvalid: function(record, errors) {
-    record.wasInvalid(errors);
+    record.send('becameInvalid', errors);
   },
 
   // ................
@@ -967,7 +1047,6 @@ DS.Store = Ember.Object.extend({
 
   registerModelArray: function(array, type, filter) {
     var modelArrays = get(this, 'modelArrays');
-    var idToClientIdMap = this.idToClientIdMap(type);
 
     modelArrays.push(array);
 
@@ -987,7 +1066,7 @@ DS.Store = Ember.Object.extend({
 
   updateModelArrayFilter: function(array, type, filter) {
     var data = this.clientIdToHashMap(type);
-    var allClientIds = this.clientIdList(type);
+    var allClientIds = this.clientIdList(type), clientId, hash;
 
     for (var i=0, l=allClientIds.length; i<l; i++) {
       clientId = allClientIds[i];
@@ -1001,11 +1080,12 @@ DS.Store = Ember.Object.extend({
   },
 
   updateModelArrays: function(type, clientId, hash) {
-    var modelArrays = get(this, 'modelArrays');
+    var modelArrays = get(this, 'modelArrays'),
+        modelArrayType, filter;
 
     modelArrays.forEach(function(array) {
-          modelArrayType = get(array, 'type');
-          filter = get(array, 'filterFunction');
+      modelArrayType = get(array, 'type');
+      filter = get(array, 'filterFunction');
 
       if (type !== modelArrayType) { return; }
 
@@ -1138,8 +1218,7 @@ DS.Store = Ember.Object.extend({
 
       var model = models[clientId];
       if (model) {
-        model.willLoadData();
-        model.setData(hash);
+        model.send('setData', hash);
       }
     } else {
       clientId = this.pushHash(hash, id, type);
@@ -1208,13 +1287,21 @@ DS.Store = Ember.Object.extend({
   // . MODEL MATERIALIZATION .
   // .........................
 
-  createModel: function(type, clientId) {
+  materializeRecord: function(type, clientId) {
     var model;
 
-    get(this, 'models')[clientId] = model = type.create({ store: this, clientId: clientId });
+    get(this, 'models')[clientId] = model = type._create({ store: this, clientId: clientId });
     set(model, 'clientId', clientId);
-    model.loadingData();
+    model.send('loadingData');
     return model;
+  },
+
+  destroy: function() {
+    if (get(DS, 'defaultStore') === this) {
+      set(DS, 'defaultStore', null);
+    }
+
+    return this._super();
   }
 });
 
@@ -1223,7 +1310,7 @@ DS.Store = Ember.Object.extend({
 
 
 (function(exports) {
-var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath, guidFor = Ember.guidFor;
 
 var stateProperty = Ember.computed(function(key) {
   var parent = get(this, 'parentState');
@@ -1232,6 +1319,14 @@ var stateProperty = Ember.computed(function(key) {
   }
 }).property();
 
+var isEmptyObject = function(object) {
+  for (var name in object) {
+    if (object.hasOwnProperty(name)) { return false; }
+  }
+
+  return true;
+};
+
 DS.State = Ember.State.extend({
   isLoaded: stateProperty,
   isDirty: stateProperty,
@@ -1239,14 +1334,16 @@ DS.State = Ember.State.extend({
   isDeleted: stateProperty,
   isError: stateProperty,
   isNew: stateProperty,
-  isValid: stateProperty
+  isValid: stateProperty,
+  isPending: stateProperty,
+
+  // For states that are substates of a
+  // DirtyState (updated or created), it is
+  // useful to be able to determine which
+  // type of dirty state it is.
+  dirtyType: stateProperty
 });
 
-var cantLoadData = function() {
-  // TODO: get the current state name
-  throw "You cannot load data into the store when its associated model is in its current state";
-};
-
 var isEmptyObject = function(obj) {
   for (var prop in obj) {
     if (!obj.hasOwnProperty(prop)) { continue; }
@@ -1259,89 +1356,287 @@ var isEmptyObject = function(obj) {
 var setProperty = function(manager, context) {
   var key = context.key, value = context.value;
 
-  var model = get(manager, 'model'), type = model.constructor;
-  var store = get(model, 'store');
-  var data = get(model, 'data');
+  var model = get(manager, 'model'),
+      data = get(model, 'data');
 
   data[key] = value;
 
-  if (store) { store.hashWasUpdated(type, get(model, 'clientId')); }
+  // At the end of the run loop, notify model arrays that
+  // this record has changed so they can re-evaluate its contents
+  // to determine membership.
+  Ember.run.once(model, model.notifyHashWasUpdated);
 };
 
-// several states share extremely common functionality, so we are factoring
-// them out into a common class.
+// The waitingOn event shares common functionality
+// between the different dirty states, but each is
+// treated slightly differently. This method is exposed
+// so that each implementation can invoke the common
+// behavior, and then implement the behavior specific
+// to the state.
+var waitingOn = function(manager, object) {
+  var model = get(manager, 'model'),
+      pendingQueue = get(model, 'pendingQueue'),
+      objectGuid = guidFor(object);
+
+  var observer = function() {
+    if (get(object, 'id')) {
+      manager.send('doneWaitingOn', object);
+      Ember.removeObserver(object, 'id', observer);
+    }
+  };
+
+  pendingQueue[objectGuid] = [object, observer];
+  Ember.addObserver(object, 'id', observer);
+};
+
+// Implementation notes:
+//
+// Each state has a boolean value for all of the following flags:
+//
+// * isLoaded: The record has a populated `data` property. When a
+//   record is loaded via `store.find`, `isLoaded` is false
+//   until the adapter sets it. When a record is created locally,
+//   its `isLoaded` property is always true.
+// * isDirty: The record has local changes that have not yet been
+//   saved by the adapter. This includes records that have been
+//   created (but not yet saved) or deleted.
+// * isSaving: The record's transaction has been committed, but
+//   the adapter has not yet acknowledged that the changes have
+//   been persisted to the backend.
+// * isDeleted: The record was marked for deletion. When `isDeleted`
+//   is true and `isDirty` is true, the record is deleted locally
+//   but the deletion was not yet persisted. When `isSaving` is
+//   true, the change is in-flight. When both `isDirty` and
+//   `isSaving` are false, the change has persisted.
+// * isError: The adapter reported that it was unable to save
+//   local changes to the backend. This may also result in the
+//   record having its `isValid` property become false if the
+//   adapter reported that server-side validations failed.
+// * isNew: The record was created on the client and the adapter
+//   did not yet report that it was successfully saved.
+// * isValid: No client-side validations have failed and the
+//   adapter did not report any server-side validation failures.
+// * isPending: A record `isPending` when it belongs to an
+//   association on another record and that record has not been
+//   saved. A record in this state cannot be saved because it
+//   lacks a "foreign key" that will be supplied by its parent
+//   association when the parent record has been created. When
+//   the adapter reports that the parent has saved, the
+//   `isPending` property on all children will become `false`
+//   and the transaction will try to commit the records.
+
+
+// The dirty state is a abstract state whose functionality is
+// shared between the `created` and `updated` states.
+//
+// The deleted state shares the `isDirty` flag with the
+// subclasses of `DirtyState`, but with a very different
+// implementation.
 var DirtyState = DS.State.extend({
-  // these states are virtually identical except that
-  // they (thrice) use their states name explicitly.
-  //
-  // child classes implement stateName.
-  stateName: null,
+  initialState: 'uncommitted',
+
+  // FLAGS
   isDirty: true,
-  willLoadData: cantLoadData,
 
-  enter: function(manager) {
-    var stateName = get(this, 'stateName'),
-        model = get(manager, 'model');
+  // SUBSTATES
 
-    model.withTransaction(function (t) {
-      t.modelBecameDirty(stateName, model);
-    });
-  },
+  // When a record first becomes dirty, it is `uncommitted`.
+  // This means that there are local pending changes,
+  // but they have not yet begun to be saved.
+  uncommitted: DS.State.extend({
+    // TRANSITIONS
+    enter: function(manager) {
+      var dirtyType = get(this, 'dirtyType'),
+          model = get(manager, 'model');
 
-  exit: function(manager) {
-    var stateName = get(this, 'stateName'),
-        model = get(manager, 'model');
+      model.withTransaction(function (t) {
+        t.modelBecameDirty(dirtyType, model);
+      });
+    },
 
-    this.notifyModel(model);
+    exit: function(manager) {
+      var model = get(manager, 'model');
+      manager.send('invokeLifecycleCallbacks', model);
+    },
 
-    model.withTransaction(function (t) {
-      t.modelBecameClean(stateName, model);
-    });
-  },
+    // EVENTS
+    setProperty: setProperty,
 
-  setProperty: setProperty,
+    deleteRecord: function(manager) {
+      manager.goToState('deleted');
+    },
 
-  willCommit: function(manager) {
-    manager.goToState('saving');
-  },
+    waitingOn: function(manager, object) {
+      waitingOn(manager, object);
+      manager.goToState('pending');
+    },
 
-  saving: DS.State.extend({
+    willCommit: function(manager) {
+      manager.goToState('inFlight');
+    }
+  }),
+
+  // Once a record has been handed off to the adapter to be
+  // saved, it is in the 'in flight' state. Changes to the
+  // record cannot be made during this window.
+  inFlight: DS.State.extend({
+    // FLAGS
     isSaving: true,
 
-    didUpdate: function(manager) {
+    // TRANSITIONS
+    enter: function(manager) {
+      var dirtyType = get(this, 'dirtyType'),
+          model = get(manager, 'model');
+
+      model.withTransaction(function (t) {
+        t.modelBecameClean(dirtyType, model);
+      });
+    },
+
+    // EVENTS
+    didCommit: function(manager) {
       manager.goToState('loaded');
     },
 
-    wasInvalid: function(manager, errors) {
+    becameInvalid: function(manager, errors) {
       var model = get(manager, 'model');
 
       set(model, 'errors', errors);
       manager.goToState('invalid');
+    },
+
+    setData: function(manager, hash) {
+      var model = get(manager, 'model');
+      set(model, 'data', hash);
     }
   }),
 
+  // If a record becomes associated with a newly created
+  // parent record, it will be `pending` until the parent
+  // record has successfully persisted. Once this happens,
+  // this record can use the parent's primary key as its
+  // foreign key.
+  //
+  // If the record's transaction had already started to
+  // commit, the record will transition to the `inFlight`
+  // state. If it had not, the record will transition to
+  // the `uncommitted` state.
+  pending: DS.State.extend({
+    initialState: 'uncommitted',
+
+    // FLAGS
+    isPending: true,
+
+    // SUBSTATES
+
+    // A pending record whose transaction has not yet
+    // started to commit is in this state.
+    uncommitted: DS.State.extend({
+      // EVENTS
+      setProperty: setProperty,
+
+      deleteRecord: function(manager) {
+        var model = get(manager, 'model'),
+            pendingQueue = get(model, 'pendingQueue'),
+            tuple;
+
+        // since we are leaving the pending state, remove any
+        // observers we have registered on other records.
+        for (var prop in pendingQueue) {
+          if (!pendingQueue.hasOwnProperty(prop)) { continue; }
+
+          tuple = pendingQueue[prop];
+          Ember.removeObserver(tuple[0], 'id', tuple[1]);
+        }
+
+        manager.goToState('deleted');
+      },
+
+      willCommit: function(manager) {
+        manager.goToState('committing');
+      },
+
+      doneWaitingOn: function(manager, object) {
+        var model = get(manager, 'model'),
+            pendingQueue = get(model, 'pendingQueue'),
+            objectGuid = guidFor(object);
+
+        delete pendingQueue[objectGuid];
+
+        if (isEmptyObject(pendingQueue)) {
+          manager.send('doneWaiting');
+        }
+      },
+
+      doneWaiting: function(manager) {
+        var dirtyType = get(this, 'dirtyType');
+        manager.goToState(dirtyType + '.uncommitted');
+      }
+    }),
+
+    // A pending record whose transaction has started
+    // to commit is in this state. Since it has not yet
+    // been sent to the adapter, it is not `inFlight`
+    // until all of its dependencies have been committed.
+    committing: DS.State.extend({
+      // FLAGS
+      isSaving: true,
+
+      // EVENTS
+      doneWaitingOn: function(manager, object) {
+        var model = get(manager, 'model'),
+            pendingQueue = get(model, 'pendingQueue'),
+            objectGuid = guidFor(object);
+
+        delete pendingQueue[objectGuid];
+
+        if (isEmptyObject(pendingQueue)) {
+          manager.send('doneWaiting');
+        }
+      },
+
+      doneWaiting: function(manager) {
+        var dirtyType = get(this, 'dirtyType');
+        manager.goToState(dirtyType + '.inFlight');
+      }
+    })
+  }),
+
+  // A record is in the `invalid` state when its client-side
+  // invalidations have failed, or if the adapter has indicated
+  // the the record failed server-side invalidations.
   invalid: DS.State.extend({
+    // FLAGS
     isValid: false,
 
+    // EVENTS
+    deleteRecord: function(manager) {
+      manager.goToState('deleted');
+    },
+
     setProperty: function(manager, context) {
       setProperty(manager, context);
 
-      var stateName = getPath(this, 'parentState.stateName'),
-          model = get(manager, 'model'),
+      var model = get(manager, 'model'),
           errors = get(model, 'errors'),
           key = context.key;
 
       delete errors[key];
 
       if (isEmptyObject(errors)) {
-        manager.goToState(stateName);
+        manager.send('becameValid');
       }
+    },
+
+    becameValid: function(manager) {
+      manager.goToState('uncommitted');
     }
   })
 });
 
 var states = {
   rootState: Ember.State.create({
+    // FLAGS
     isLoaded: false,
     isDirty: false,
     isSaving: false,
@@ -1349,80 +1644,126 @@ var states = {
     isError: false,
     isNew: false,
     isValid: true,
+    isPending: false,
 
-    willLoadData: cantLoadData,
-
-    didCreate: function(manager) {
-      manager.goToState('loaded.created');
-    },
+    // SUBSTATES
 
+    // A record begins its lifecycle in the `empty` state.
+    // If its data will come from the adapter, it will
+    // transition into the `loading` state. Otherwise, if
+    // the record is being created on the client, it will
+    // transition into the `created` state.
     empty: DS.State.create({
+      // EVENTS
       loadingData: function(manager) {
         manager.goToState('loading');
+      },
+
+      setData: function(manager, hash) {
+        var model = get(manager, 'model');
+        set(model, 'data', hash);
+        manager.goToState('loaded.created');
       }
     }),
 
+    // A record enters this state when the store askes
+    // the adapter for its data. It remains in this state
+    // until the adapter provides the requested data.
+    //
+    // Usually, this process is asynchronous, using an
+    // XHR to retrieve the data.
     loading: DS.State.create({
-      willLoadData: Ember.K,
-
+      // TRANSITIONS
       exit: function(manager) {
         var model = get(manager, 'model');
         model.didLoad();
       },
 
+      // EVENTS
       setData: function(manager, data) {
         var model = get(manager, 'model');
 
         model.beginPropertyChanges();
-        model.set('data', data);
+        set(model, 'data', data);
 
         if (data !== null) {
-          manager.goToState('loaded');
+          manager.send('loadedData');
         }
 
         model.endPropertyChanges();
+      },
+
+      loadedData: function(manager) {
+        manager.goToState('loaded');
       }
     }),
 
+    // A record enters this state when its data is populated.
+    // Most of a record's lifecycle is spent inside substates
+    // of the `loaded` state.
     loaded: DS.State.create({
+      initialState: 'saved',
+
+      // FLAGS
       isLoaded: true,
 
-      willLoadData: Ember.K,
+      // SUBSTATES
 
-      setProperty: function(manager, context) {
-        setProperty(manager, context);
-        manager.goToState('updated');
-      },
+      // If there are no local changes to a record, it remains
+      // in the `saved` state.
+      saved: DS.State.create({
+        // EVENTS
+        setProperty: function(manager, context) {
+          setProperty(manager, context);
+          manager.goToState('updated');
+        },
 
-      'delete': function(manager) {
-        manager.goToState('deleted');
-      },
+        deleteRecord: function(manager) {
+          manager.goToState('deleted');
+        },
 
+        waitingOn: function(manager, object) {
+          waitingOn(manager, object);
+          manager.goToState('updated.pending');
+        }
+      }),
+
+      // A record is in this state after it has been locally
+      // created but before the adapter has indicated that
+      // it has been saved.
       created: DirtyState.create({
-        stateName: 'created',
+        dirtyType: 'created',
+
+        // FLAGS
         isNew: true,
 
-        notifyModel: function(model) {
+        // EVENTS
+        invokeLifecycleCallbacks: function(manager, model) {
           model.didCreate();
         }
       }),
 
+      // A record is in this state if it has already been
+      // saved to the server, but there are new local changes
+      // that have not yet been saved.
       updated: DirtyState.create({
-        stateName: 'updated',
+        dirtyType: 'updated',
 
-        notifyModel: function(model) {
+        // EVENTS
+        invokeLifecycleCallbacks: function(manager, model) {
           model.didUpdate();
         }
       })
     }),
 
+    // A record is in this state if it was deleted from the store.
     deleted: DS.State.create({
+      // FLAGS
       isDeleted: true,
       isLoaded: true,
       isDirty: true,
 
-      willLoadData: cantLoadData,
-
+      // TRANSITIONS
       enter: function(manager) {
         var model = get(manager, 'model');
         var store = get(model, 'store');
@@ -1436,31 +1777,51 @@ var states = {
         });
       },
 
-      willCommit: function(manager) {
-        manager.goToState('saving');
-      },
+      // SUBSTATES
 
-      saving: DS.State.create({
-        isSaving: true,
+      // When a record is deleted, it enters the `start`
+      // state. It will exit this state when the record's
+      // transaction starts to commit.
+      start: DS.State.create({
+        willCommit: function(manager) {
+          manager.goToState('inFlight');
+        }
+      }),
 
-        didDelete: function(manager) {
-          manager.goToState('saved');
-        },
+      // After a record's transaction is committing, but
+      // before the adapter indicates that the deletion
+      // has saved to the server, a record is in the
+      // `inFlight` substate of `deleted`.
+      inFlight: DS.State.create({
+        // FLAGS
+        isSaving: true,
 
+        // TRANSITIONS
         exit: function(stateManager) {
           var model = get(stateManager, 'model');
 
           model.withTransaction(function(t) {
             t.modelBecameClean('deleted', model);
           });
+        },
+
+        // EVENTS
+        didCommit: function(manager) {
+          manager.goToState('saved');
         }
       }),
 
+      // Once the adapter indicates that the deletion has
+      // been saved, the record enters the `saved` substate
+      // of `deleted`.
       saved: DS.State.create({
         isDirty: false
       })
     }),
 
+    // If the adapter indicates that there was an unknown
+    // error saving a record, the record enters the `error`
+    // state.
     error: DS.State.create({
       isError: true
     })
@@ -1473,6 +1834,12 @@ DS.StateManager = Ember.StateManager.extend({
   states: states
 });
 
+})({});
+
+
+(function(exports) {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+
 var retrieveFromCurrentState = Ember.computed(function(key) {
   return get(getPath(this, 'stateManager.currentState'), key);
 }).property('stateManager.currentState').cacheable();
@@ -1484,6 +1851,7 @@ DS.Model = Ember.Object.extend({
   isDeleted: retrieveFromCurrentState,
   isError: retrieveFromCurrentState,
   isNew: retrieveFromCurrentState,
+  isPending: retrieveFromCurrentState,
   isValid: retrieveFromCurrentState,
 
   clientId: null,
@@ -1491,8 +1859,22 @@ DS.Model = Ember.Object.extend({
   // because unknownProperty is used, any internal property
   // must be initialized here.
   primaryKey: 'id',
+  id: Ember.computed(function(key, value) {
+    var primaryKey = get(this, 'primaryKey'),
+        data = get(this, 'data');
+
+    if (arguments.length === 2) {
+      set(data, primaryKey, value);
+      return value;
+    }
+
+    return data && get(data, primaryKey);
+  }).property('primaryKey', 'data'),
+
   data: null,
+  pendingQueue: null,
   transaction: null,
+  errors: null,
 
   didLoad: Ember.K,
   didUpdate: Ember.K,
@@ -1503,100 +1885,101 @@ DS.Model = Ember.Object.extend({
       model: this
     });
 
+    set(this, 'pendingQueue', {});
     set(this, 'stateManager', stateManager);
     stateManager.goToState('empty');
   },
 
-  withTransaction: function(fn) {
-    var transaction = get(this, 'transaction') || getPath(this, 'store.defaultTransaction');
-
-    if (transaction) { fn(transaction); }
-  },
-
-  setData: function(data) {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('setData', data);
-  },
-
-  setProperty: function(key, value) {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('setProperty', { key: key, value: value });
-  },
-
-  deleteRecord: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('delete');
-  },
-
   destroy: function() {
-    this.deleteRecord();
+    if (!get(this, 'isDeleted')) {
+      this.deleteRecord();
+    }
     this._super();
   },
 
-  loadingData: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('loadingData');
+  send: function(name, context) {
+    return get(this, 'stateManager').send(name, context);
   },
 
-  willLoadData: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('willLoadData');
-  },
-
-  willCommit: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('willCommit');
+  withTransaction: function(fn) {
+    var transaction = get(this, 'transaction') || getPath(this, 'store.defaultTransaction');
+    if (transaction) { fn(transaction); }
   },
 
-  adapterDidUpdate: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('didUpdate');
+  setProperty: function(key, value) {
+    this.send('setProperty', { key: key, value: value });
   },
 
-  adapterDidCreate: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('didCreate');
+  deleteRecord: function() {
+    this.send('deleteRecord');
   },
 
-  adapterDidDelete: function() {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('didDelete');
+  waitingOn: function(record) {
+    this.send('waitingOn', record);
   },
 
-  wasInvalid: function(errors) {
-    var stateManager = get(this, 'stateManager');
-    stateManager.send('wasInvalid', errors);
+  notifyHashWasUpdated: function() {
+    var store = get(this, 'store');
+    if (store) {
+      store.hashWasUpdated(this.constructor, get(this, 'clientId'));
+    }
   },
 
   unknownProperty: function(key) {
     var data = get(this, 'data');
 
-    if (data) {
-      return get(data, key);
+    if (data && key in data) {
+      ember_assert("You attempted to access the " + key + " property on a model without defining an attribute.", false);
     }
   },
 
   setUnknownProperty: function(key, value) {
     var data = get(this, 'data');
-    ember_assert("You cannot set a model attribute before its data is loaded.", !!data);
 
-    this.setProperty(key, value);
-    return value;
+    if (data && key in data) {
+      ember_assert("You attempted to set the " + key + " property on a model without defining an attribute.", false);
+    } else {
+      return this._super(key, value);
+    }
   }
 });
 
+// Helper function to generate store aliases.
+// This returns a function that invokes the named alias
+// on the default store, but injects the class as the
+// first parameter.
+var storeAlias = function(methodName) {
+  return function() {
+    var store = get(DS, 'defaultStore'),
+        args = [].slice.call(arguments);
+
+    args.unshift(this);
+    return store[methodName].apply(store, args);
+  };
+};
+
 DS.Model.reopenClass({
-  typeForAssociation: function(association) {
-    var type = this.metaForProperty(association).type;
-    if (typeof type === 'string') {
-      type = getPath(this, type, false) || getPath(window, type);
-    }
-    return type;
-  }
+  find: storeAlias('find'),
+  filter: storeAlias('filter'),
+
+  _create: DS.Model.create,
+
+  create: function() {
+    throw new Ember.Error("You should not call `create` on a model. Instead, call `createRecord` with the attributes you would like to set.");
+  },
+
+  createRecord: storeAlias('createRecord')
 });
 
+})({});
+
+
+(function(exports) {
+var get = Ember.get, getPath = Ember.getPath;
 DS.attr = function(type, options) {
   var transform = DS.attr.transforms[type];
+  ember_assert("Could not find model attribute of type " + type, !!transform);
+
   var transformFrom = transform.from;
   var transformTo = transform.to;
 
@@ -1618,73 +2001,24 @@ DS.attr = function(type, options) {
     }
   }).property('data');
 };
-
-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 referencedFindRecord = function(store, type, data, key, one) {
-  return data ? get(data, key) : one ? null : [];
-};
-
-var hasAssociation = function(type, options, one) {
-  var embedded = options && options.embedded,
-    findRecord = embedded ? embeddedFindRecord : referencedFindRecord;
-
-  return Ember.computed(function(key) {
-    var data = get(this, 'data'), ids, id, association,
-      store = get(this, 'store');
-
-    if (typeof type === 'string') {
-      type = getPath(this, type, false) || getPath(window, type);
-    }
-
-    key = (options && options.key) ? options.key : key;
-    if (one) {
-      id = findRecord(store, type, data, key, true);
-      association = id ? store.find(type, id) : null;
-    } else {
-      ids = findRecord(store, type, data, key);
-      association = store.findMany(type, ids);
-    }
-
-    return association;
-  }).property('data').cacheable().meta({ type: type });
-};
-
-DS.hasMany = function(type, options) {
-  ember_assert("The type passed to DS.hasMany must be defined", !!type);
-  return hasAssociation(type, options);
-};
-
-DS.hasOne = function(type, options) {
-  ember_assert("The type passed to DS.hasOne must be defined", !!type);
-  return hasAssociation(type, options, true);
-};
-
 DS.attr.transforms = {
   string: {
     from: function(serialized) {
-      return Em.none(serialized) ? null : String(serialized);
+      return Ember.none(serialized) ? null : String(serialized);
     },
 
     to: function(deserialized) {
-      return Em.none(deserialized) ? null : String(deserialized);
+      return Ember.none(deserialized) ? null : String(deserialized);
     }
   },
 
   integer: {
     from: function(serialized) {
-      return Em.none(serialized) ? null : Number(serialized);
+      return Ember.none(serialized) ? null : Number(serialized);
     },
 
     to: function(deserialized) {
-      return Em.none(deserialized) ? null : Number(deserialized);
+      return Ember.none(deserialized) ? null : Number(deserialized);
     }
   },
 
@@ -1746,6 +2080,76 @@ DS.attr.transforms = {
   }
 };
 
+
+})({});
+
+
+(function(exports) {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath;
+DS.Model.reopenClass({
+  typeForAssociation: function(association) {
+    var type = this.metaForProperty(association).type;
+    if (typeof type === 'string') {
+      type = getPath(this, type, false) || getPath(window, type);
+    }
+    return type;
+  }
+});
+
+
+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 referencedFindRecord = function(store, type, data, key, one) {
+  return data ? get(data, key) : one ? null : [];
+};
+
+var hasAssociation = function(type, options, one) {
+  var embedded = options && options.embedded,
+    findRecord = embedded ? embeddedFindRecord : referencedFindRecord;
+
+  return Ember.computed(function(key) {
+    var data = get(this, 'data'), ids, id, association,
+      store = get(this, 'store');
+
+    if (typeof type === 'string') {
+      type = getPath(this, type, false) || getPath(window, type);
+    }
+
+    key = (options && options.key) ? options.key : key;
+    if (one) {
+      id = findRecord(store, type, data, key, true);
+      association = id ? store.find(type, id) : null;
+    } else {
+      ids = findRecord(store, type, data, key);
+      association = store.findMany(type, ids);
+      set(association, 'parentRecord', this);
+    }
+
+    return association;
+  }).property('data').cacheable().meta({ type: type });
+};
+
+DS.hasMany = function(type, options) {
+  ember_assert("The type passed to DS.hasMany must be defined", !!type);
+  return hasAssociation(type, options);
+};
+
+DS.hasOne = function(type, options) {
+  ember_assert("The type passed to DS.hasOne must be defined", !!type);
+  return hasAssociation(type, options, true);
+};
+
+})({});
+
+
+(function(exports) {
 })({});