epf-source 0.1.1 → 0.1.2

data/dist/epf.js

@@ -34,7 +34,7 @@
             var cwd = '/';
             return {
                 title: 'browser',
-                version: 'v0.11.2',
+                version: 'v0.10.13',
                 browser: true,
                 env: {},
                 argv: [],
@@ -55,7 +55,6 @@
         require('/lib/model/index.js', module);
         require('/lib/session/index.js', module);
         require('/lib/serializer/index.js', module);
-        require('/lib/session/index.js', module);
         require('/lib/local/index.js', module);
         require('/lib/rest/index.js', module);
     });
@@ -166,6 +165,22 @@
                     return null;
                 }
             },
+            extractRevision: function (type, hash) {
+                var revision = this._revision(type);
+                if (hash.hasOwnProperty(revision) && hash[revision] !== null) {
+                    return parseInt(hash[revision]);
+                } else {
+                    return undefined;
+                }
+            },
+            extractClientRevision: function (type, hash) {
+                var revision = this._clientRevision(type);
+                if (hash.hasOwnProperty(revision) && hash[revision] !== null) {
+                    return parseInt(hash[revision]);
+                } else {
+                    return undefined;
+                }
+            },
             extractHasMany: function (type, hash, key) {
                 return hash[key];
             },
@@ -442,6 +457,8 @@
             deserialize: mustImplement('deserialize'),
             extractId: mustImplement('extractId'),
             extractClientId: mustImplement('extractClientId'),
+            extractRevision: mustImplement('extractRevision'),
+            extractClientRevision: mustImplement('extractClientRevision'),
             extractAttribute: mustImplement('extractAttribute'),
             extractHasMany: mustImplement('extractHasMany'),
             extractBelongsTo: mustImplement('extractBelongsTo'),
@@ -449,6 +466,8 @@
                 var model = this.createModel(type);
                 set(model, 'id', this.extractId(type, hash));
                 set(model, 'clientId', this.extractClientId(type, hash));
+                set(model, 'rev', this.extractRevision(type, hash));
+                set(model, 'clientRev', this.extractClientRevision(type, hash));
                 this.deserializeAttributes(model, hash);
                 this.deserializeRelationships(model, hash);
                 return model;
@@ -573,12 +592,18 @@
             },
             serialize: function (record, options) {
                 options = options || {};
-                var serialized = this.createSerializedForm(), id;
+                var serialized = this.createSerializedForm(), id, rev, clientRev;
                 if (options.includeId) {
                     if (id = get(record, 'id')) {
                         this._addId(serialized, record.constructor, id);
                     }
                     this._addClientId(serialized, record.constructor, get(record, 'clientId'));
+                    if (rev = get(record, 'rev')) {
+                        this._addRevision(serialized, record.constructor, get(record, 'rev'));
+                    }
+                    if (clientRev = get(record, 'clientRev')) {
+                        this._addClientRevision(serialized, record.constructor, get(record, 'clientRev'));
+                    }
                 }
                 if (options.includeType) {
                     this.addType(serialized, record.constructor);
@@ -601,6 +626,12 @@
             serializeClientId: function (clientId) {
                 return clientId;
             },
+            serializeRevision: function (rev) {
+                return rev;
+            },
+            serializeClientRevision: function (rev) {
+                return rev;
+            },
             addAttributes: function (data, record) {
                 record.eachAttribute(function (name, attribute) {
                     this._addAttribute(data, record, name, attribute.type);
@@ -632,6 +663,12 @@
             clientKey: function (type) {
                 return 'client_id';
             },
+            revision: function (type) {
+                return 'rev';
+            },
+            clientRevision: function (type) {
+                return 'client_rev';
+            },
             keyForBelongsTo: function (type, name) {
                 return this.keyForAttributeName(type, name);
             },
@@ -654,6 +691,22 @@
                     return this.clientKey(type);
                 }
             },
+            _revision: function (type) {
+                var config = this.configurationForType(type), revision = config && config.revision;
+                if (revision) {
+                    return revision;
+                } else {
+                    return this.revision(type);
+                }
+            },
+            _clientRevision: function (type) {
+                var config = this.configurationForType(type), clientRevision = config && config.clientRevision;
+                if (clientRevision) {
+                    return clientRevision;
+                } else {
+                    return this.clientRevision(type);
+                }
+            },
             _addAttribute: function (data, record, attributeName, attributeType) {
                 var key = this._keyForAttributeName(record.constructor, attributeName);
                 var value = get(record, attributeName);
@@ -667,6 +720,14 @@
                 var clientKey = this._clientKey(type);
                 this.addId(hash, clientKey, this.serializeClientId(id));
             },
+            _addRevision: function (hash, type, rev) {
+                var revision = this._revision(type);
+                this.addId(hash, revision, this.serializeRevision(rev));
+            },
+            _addClientRevision: function (hash, type, rev) {
+                var revision = this._clientRevision(type);
+                this.addId(hash, revision, this.serializeClientRevision(rev));
+            },
             _keyForAttributeName: function (type, name) {
                 return this._keyFromMappingOrHook('keyForAttributeName', type, name);
             },
@@ -1311,6 +1372,8 @@
         Ep.ModelMixin = Ember.Mixin.create({
             id: null,
             clientId: null,
+            rev: null,
+            clientRev: 0,
             session: null,
             errors: null,
             isEqual: function (model) {
@@ -1357,17 +1420,15 @@
         Ep.Model = Ember.Object.extend(Ember.Copyable, Ep.ModelMixin, {
             isPromise: false,
             isProxy: false,
+            isNew: true,
             isDeleted: false,
             isLoaded: true,
-            isNew: Ember.computed(function () {
-                return !get(this, 'id');
-            }).property('id'),
-            clientRevision: Ember.computed(function (key, value) {
-                if (arguments.length === 1) {
-                    return 0;
-                }
-                return value;
-            }),
+            isDirty: Ember.computed(function () {
+                var session = get(this, 'session');
+                if (!session)
+                    return false;
+                return get(session, 'dirtyModels').contains(this);
+            }).volatile(),
             diff: function (model) {
                 var diffs = [];
                 this.eachAttribute(function (name, meta) {
@@ -1456,7 +1517,10 @@
                 dest.beginPropertyChanges();
                 set(dest, 'id', get(this, 'id'));
                 set(dest, 'clientId', get(this, 'clientId'));
+                set(dest, 'rev', get(this, 'rev'));
+                set(dest, 'clientRev', get(this, 'clientRev'));
                 set(dest, 'errors', Ember.copy(get(this, 'errors')));
+                set(dest, 'isNew', get(this, 'isNew'));
                 set(dest, 'isDeleted', get(this, 'isDeleted'));
                 this.eachAttribute(function (name, meta) {
                     var left = get(this, name);
@@ -1800,7 +1864,10 @@
         Ep.ModelProxy = Ember.ObjectProxy.extend(Ember.Copyable, Ep.ModelMixin, {
             id: passThrough('id'),
             clientId: passThrough('clientId'),
+            rev: passThrough('rev'),
+            clientRev: passThrough('clientRev'),
             type: passThrough('type'),
+            isDirty: false,
             isPromise: false,
             isLoaded: passThrough('isLoaded', false),
             isLoading: false,
@@ -1966,7 +2033,7 @@
                 var data = {};
                 data[root] = get(this, 'serializer').serialize(model, { includeId: true });
                 return this.ajax(this.buildURL(root), 'POST', { data: data }).then(function (json) {
-                    return Ember.run(adapter, 'didReceiveDataForCreate', json, model);
+                    return Ember.run(adapter, 'didReceiveData', json, model);
                 }, function (xhr) {
                     throw Ember.run(adapter, 'didError', xhr, model);
                 });
@@ -2021,16 +2088,6 @@
                         result = model;
                     }
                 });
-                return result || targetModel;
-            },
-            didReceiveDataForCreate: function (data, targetModel) {
-                var result = null;
-                this.processData(data, function (model) {
-                    if (targetModel && model.isEqual(targetModel)) {
-                        result = model;
-                    }
-                });
-                set(targetModel, 'id', get(result, 'id'));
                 return result;
             },
             didReceiveDataForLoad: function (data, type, id) {
@@ -2199,6 +2256,7 @@
                             shadows.add(copy);
                         }
                     }
+                    this._embeddedManager.updateParents(model);
                 }, this);
             },
             dirtyEmbeddedTree: function (model, models, shadows, session) {
@@ -2311,48 +2369,23 @@
     require.define('/lib/rest/operation_graph.js', function (module, exports, __dirname, __filename) {
         require('/lib/rest/operation.js', module);
         var get = Ember.get, set = Ember.set;
-        var Node = function (model) {
-            this.op = null;
-            this.children = Ember.Set.create();
-            this.parents = Ember.Set.create();
-            this.dirty = false;
-            this.dirtyEmbeddedChildren = false;
-        };
-        Node.prototype = {
-            addChild: function (childNode) {
-                this.children.add(childNode);
-                childNode.parents.add(this);
-            },
-            isRoot: function () {
-                return this.parents.every(function (parent) {
-                    return !get(parent, 'dirty') && parent.isRoot();
-                });
-            },
-            toString: function (depth) {
-                if (!depth)
-                    depth = 0;
-                var prefix = '';
-                for (var i = 0; i < depth; i++) {
-                    prefix += '  ';
-                }
-                return prefix + this.op.toString() + this.children.map(function (child) {
-                    return '\n' + child.toString(depth + 1);
-                });
-            }
-        };
         Ep.OperationGraph = Ember.Object.extend({
             models: null,
             shadows: null,
-            rootNodes: null,
+            rootOps: null,
             adapter: null,
-            nodes: null,
             init: function () {
-                this.nodes = Ember.MapWithDefault.create({
+                var graph = this;
+                this.ops = Ember.MapWithDefault.create({
                     defaultValue: function (model) {
-                        return new Node(model);
+                        return Ep.Operation.create({
+                            model: model,
+                            graph: graph,
+                            adapter: get(graph, 'adapter')
+                        });
                     }
                 });
-                this.rootNodes = Ember.Set.create();
+                this.rootOps = Ember.Set.create();
                 this.build();
             },
             perform: function () {
@@ -2362,63 +2395,60 @@
                 var adapter = get(this, 'adapter');
                 var models = get(this, 'models');
                 var shadows = get(this, 'shadows');
-                var rootNodes = get(this, 'rootNodes');
-                var nodes = get(this, 'nodes');
+                var rootOps = get(this, 'rootOps');
+                var ops = get(this, 'ops');
                 models.forEach(function (model) {
                     if (!get(model, 'isLoaded')) {
                         return;
                     }
                     var shadow = shadows.getModel(model);
-                    var node = nodes.get(model);
-                    node.op = Ep.Operation.create({
-                        model: model,
-                        shadow: shadow,
-                        graph: this,
-                        adapter: adapter
-                    });
-                    node.dirty = node.dirty || !!get(node.op, 'dirtyType');
-                    if (node.dirty && adapter.isEmbedded(model) && !get(model, 'isNew')) {
-                        var root = adapter.findEmbeddedRoot(model, models);
-                        var rootNode = nodes.get(root);
-                        rootNode.dirty = true;
-                        rootNode.dirtyEmbeddedChildren = true;
-                    }
-                    var rels = get(node.op, 'dirtyRelationships');
+                    Ember.assert('Shadow does not exist for non-new model', shadow || get(model, 'isNew'));
+                    var op = ops.get(model);
+                    set(op, 'shadow', shadow);
+                    var isEmbedded = adapter.isEmbedded(model);
+                    if (get(op, 'isDirty') && isEmbedded) {
+                        var rootModel = adapter.findEmbeddedRoot(model, models);
+                        var rootOp = this.getOp(rootModel);
+                        set(rootOp, 'force', true);
+                        var parentModel = adapter._embeddedManager.findParent(model);
+                        var parentOp = this.getOp(parentModel);
+                        parentOp.addChild(op);
+                    }
+                    var rels = get(op, 'dirtyRelationships');
                     for (var i = 0; i < rels.length; i++) {
                         var d = rels[i];
                         var name = d.name;
                         var parentModel = model.get(name) || shadows.getModel(d.oldValue);
                         if (parentModel) {
-                            parentModel = models.getModel(parentModel);
-                            var parentNode = nodes.get(parentModel);
-                            parentNode.addChild(node);
+                            var parentOp = this.getOp(parentModel);
+                            parentOp.addChild(op);
                         }
                     }
                 }, this);
-                nodes.forEach(function (model, node) {
-                    if (node.dirty && node.isRoot()) {
-                        rootNodes.add(node);
+                ops.forEach(function (model, op) {
+                    if (get(op, 'isDirty') && get(op, 'isRoot')) {
+                        rootOps.add(op);
                     }
                 }, this);
             },
+            getOp: function (model) {
+                var models = get(this, 'models');
+                return this.ops.get(models.getModel(model));
+            },
             createPromise: function () {
-                var rootNodes = get(this, 'rootNodes'), adapter = get(this, 'adapter'), cumulative = [];
-                function createNestedPromise(node) {
-                    var promise = node.op.perform(node.dirtyEmbeddedChildren);
+                var rootOps = get(this, 'rootOps'), adapter = get(this, 'adapter'), cumulative = [];
+                function createNestedPromise(op) {
+                    var promise = op.perform();
                     promise = promise.then(function (model) {
-                        if (model === get(node.op, 'model')) {
-                            cumulative.push(model.lazyCopy());
-                        } else {
-                            cumulative.push(model);
-                        }
+                        cumulative.push(model);
                         return model;
                     }, function (model) {
                         cumulative.push(model);
                         throw model;
                     });
-                    if (node.children.length > 0) {
+                    if (op.children.length > 0) {
                         promise = promise.then(function (model) {
-                            var childPromises = node.children.map(createNestedPromise);
+                            var childPromises = op.children.map(createNestedPromise);
                             return Ember.RSVP.all(childPromises).then(function (models) {
                                 adapter.rebuildRelationships(models, model);
                                 return model;
@@ -2427,7 +2457,7 @@
                     }
                     return promise;
                 }
-                return Ember.RSVP.all(rootNodes.map(createNestedPromise)).then(function () {
+                return Ember.RSVP.all(rootOps.map(createNestedPromise)).then(function () {
                     return cumulative;
                 }, function (err) {
                     throw cumulative;
@@ -2435,9 +2465,9 @@
             },
             toStringExtension: function () {
                 var result = '';
-                var rootNodes = get(this, 'rootNodes');
-                rootNodes.forEach(function (node) {
-                    result += '\n' + node.toString(1);
+                var rootOps = get(this, 'rootOps');
+                rootOps.forEach(function (op) {
+                    result += '\n' + op.toString(1);
                 });
                 return result + '\n';
             }
@@ -2449,6 +2479,8 @@
             model: null,
             shadow: null,
             adapter: null,
+            _promise: null,
+            force: false,
             init: function () {
                 this.children = Ember.Set.create();
                 this.parents = Ember.Set.create();
@@ -2478,6 +2510,9 @@
                 return rels;
             }),
             isDirty: Ember.computed(function () {
+                return !!get(this, 'dirtyType');
+            }),
+            isDirtyFromUpdates: Ember.computed(function () {
                 var model = get(this, 'model'), shadow = get(this, 'shadow'), adapter = get(this, 'adapter');
                 var diff = model.diff(shadow);
                 var dirty = false;
@@ -2498,17 +2533,20 @@
                     return 'created';
                 } else if (get(model, 'isDeleted')) {
                     return 'deleted';
-                } else if (get(this, 'isDirty')) {
+                } else if (get(this, 'isDirtyFromUpdates') || get(this, 'force')) {
                     return 'updated';
                 }
             }),
-            perform: function (forceUpdate) {
+            perform: function () {
+                if (this._promise)
+                    return this._promise;
                 var adapter = get(this, 'adapter'), dirtyType = get(this, 'dirtyType'), model = get(this, 'model'), shadow = get(this, 'shadow'), promise;
-                if (!dirtyType && forceUpdate) {
-                    dirtyType = 'updated';
-                }
                 if (!dirtyType || !adapter.shouldSave(model)) {
-                    promise = Ember.RSVP.resolve(model);
+                    if (adapter.isEmbedded(model)) {
+                        promise = this._promiseFromEmbeddedParent();
+                    } else {
+                        promise = Ember.RSVP.resolve();
+                    }
                 } else if (dirtyType === 'created') {
                     promise = adapter.create(model);
                 } else if (dirtyType === 'updated') {
@@ -2516,17 +2554,61 @@
                 } else if (dirtyType === 'deleted') {
                     promise = adapter.deleteModel(model);
                 }
-                return promise.then(null, function (model) {
+                promise = promise.then(function (serverModel) {
+                    if (!get(model, 'id')) {
+                        set(model, 'id', get(serverModel, 'id'));
+                    }
+                    if (!serverModel) {
+                        serverModel = model;
+                    } else if (!get(serverModel, 'clientRev')) {
+                        set(serverModel, 'clientRev', get(model, 'clientRev'));
+                    }
+                    return serverModel;
+                }, function (serverModel) {
                     if (shadow) {
-                        shadow.set('errors', model.get('errors'));
+                        shadow.set('errors', serverModel.get('errors'));
                         throw shadow;
                     }
-                    throw model;
+                    throw serverModel;
+                });
+                return this._promise = promise;
+            },
+            _embeddedParent: Ember.computed(function () {
+                var model = get(this, 'model'), parentModel = get(this, 'adapter')._embeddedManager.findParent(model), graph = get(this, 'graph');
+                Ember.assert('Embedded parent does not exist!', parentModel);
+                return graph.getOp(parentModel);
+            }),
+            _promiseFromEmbeddedParent: function () {
+                var serializer = get(this, 'adapter.serializer');
+                var model = this.model;
+                function findInParent(parentModel) {
+                    var res = null;
+                    serializer.eachEmbeddedRecord(parentModel, function (child, embeddedType) {
+                        if (res)
+                            return;
+                        if (child.isEqual(model))
+                            res = child;
+                    });
+                    return res;
+                }
+                return get(this, '_embeddedParent').perform().then(function (parent) {
+                    return findInParent(parent);
+                }, function (parent) {
+                    throw findInParent(parent);
                 });
             },
             toStringExtension: function () {
                 return '( ' + get(this, 'dirtyType') + ' ' + get(this, 'model') + ' )';
-            }
+            },
+            addChild: function (child) {
+                this.children.add(child);
+                child.parents.add(this);
+            },
+            isRoot: Ember.computed(function () {
+                return this.parents.every(function (parent) {
+                    return !get(parent, 'isDirty') && get(parent, 'isRoot');
+                });
+            }).volatile()
         });
     });
     require.define('/lib/rest/embedded_manager.js', function (module, exports, __dirname, __filename) {
@@ -2878,34 +2960,70 @@
         var get = Ember.get, set = Ember.set;
         Ep.Session.reopen({
             merge: function (model, strategy) {
-                var shadows = get(this, 'shadows'), newModels = get(this, 'newModels');
                 this.reifyClientId(model);
-                if (!strategy)
-                    strategy = get(this, 'mergeStrategy').create({ session: this });
-                if (!get(model, 'hasErrors')) {
-                    var merged;
-                    this.suspendDirtyChecking(function () {
-                        merged = this.mergeModel(model, strategy);
-                    }, this);
-                    if (shadows.contains(model) && get(model, 'isLoaded')) {
-                        shadows.add(model);
+                if (get(model, 'hasErrors')) {
+                    return this._mergeError(model, strategy);
+                } else {
+                    return this._mergeSuccess(model, strategy);
+                }
+            },
+            _mergeSuccess: function (model, strategy) {
+                var models = get(this, 'models'), shadows = get(this, 'shadows'), newModels = get(this, 'newModels'), originals = get(this, 'originals'), merged, ancestor, existing = models.getModel(model);
+                if (existing && this._containsRev(existing, model)) {
+                    return existing;
+                }
+                var hasClientChanges = !existing || this._containsClientRev(model, existing);
+                if (hasClientChanges) {
+                    ancestor = shadows.getModel(model);
+                } else {
+                    ancestor = originals.getModel(model);
+                }
+                this.suspendDirtyChecking(function () {
+                    merged = this._mergeModel(existing, ancestor, model, strategy);
+                }, this);
+                if (hasClientChanges) {
+                    if (get(merged, 'isDeleted')) {
+                        this.remove(merged);
+                    } else {
+                        if (shadows.contains(model) && get(model, 'isLoaded')) {
+                            shadows.add(model);
+                        }
+                        originals.remove(model);
+                        if (!get(merged, 'isNew')) {
+                            newModels.remove(merged);
+                        }
                     }
-                    newModels.remove(model);
                 } else {
+                }
+                return merged;
+            },
+            _mergeError: function (model, strategy) {
+                var models = get(this, 'models'), shadows = get(this, 'shadows'), newModels = get(this, 'newModels'), originals = get(this, 'originals'), merged, ancestor, existing = models.getModel(model);
+                if (!existing) {
+                    Ember.assert('Errors returned for non-existant model: ' + model.toString(), model instanceof Ep.LoadError);
+                    return model;
+                }
+                ancestor = originals.getModel(model);
+                if (ancestor && !this._containsRev(existing, model)) {
                     this.suspendDirtyChecking(function () {
-                        merged = this.mergeErrors(model, strategy);
+                        merged = this._mergeModel(existing, ancestor, model, strategy);
                     }, this);
-                    shadows.add(model);
+                } else {
+                    merged = existing;
                 }
+                set(merged, 'errors', Ember.copy(get(model, 'errors')));
+                shadows.add(model);
+                originals.remove(model);
                 return merged;
             },
-            mergeModel: function (model, strategy) {
-                var dest = this.getModel(model);
+            _mergeModel: function (dest, ancestor, model, strategy) {
+                if (!strategy)
+                    strategy = get(this, 'mergeStrategy').create({ session: this });
                 if (model === dest) {
                     return model;
                 }
                 if (get(model, 'isPromise')) {
-                    return this.mergePromise(model, dest, strategy);
+                    return this._mergePromise(dest, ancestor, model, strategy);
                 }
                 var promise;
                 if (dest && get(dest, 'isPromise')) {
@@ -2918,18 +3036,24 @@
                         promise.resolve(dest);
                     }
                 }
+                if (!get(model, 'hasErrors')) {
+                    set(dest, 'isNew', false);
+                }
                 set(dest, 'id', get(model, 'id'));
                 set(dest, 'clientId', get(model, 'clientId'));
+                set(dest, 'rev', get(model, 'rev'));
                 set(dest, 'isDeleted', get(model, 'isDeleted'));
-                set(dest, 'errors', Ember.copy(get(model, 'errors')));
                 this.adopt(dest);
-                strategy.merge(model, dest);
+                if (!ancestor) {
+                    ancestor = dest;
+                }
+                strategy.merge(dest, ancestor, model);
                 return dest;
             },
-            mergePromise: function (promise, dest, strategy) {
+            _mergePromise: function (dest, ancestor, promise, strategy) {
                 var content = get(promise, 'content');
                 if (content) {
-                    return this.merge(content, strategy);
+                    return this.merge(dest, ancestor, content, strategy);
                 }
                 if (!dest) {
                     dest = promise.lazyCopy();
@@ -2937,14 +3061,15 @@
                 }
                 return dest;
             },
-            mergeErrors: function (model, strategy) {
-                var dest = this.getModel(model);
-                if (!dest) {
-                    Ember.assert('Errors returned for non-existant model: ' + model.toString(), model instanceof Ep.LoadError);
-                    return model;
-                }
-                set(dest, 'errors', Ember.copy(get(model, 'errors')));
-                return dest;
+            _containsRev: function (modelA, modelB) {
+                if (!get(modelA, 'rev'))
+                    return false;
+                if (!get(modelB, 'rev'))
+                    return false;
+                return get(modelA, 'rev') >= get(modelB, 'rev');
+            },
+            _containsClientRev: function (modelA, modelB) {
+                return get(modelA, 'clientRev') >= get(modelB, 'clientRev');
             }
         });
     });
@@ -2965,6 +3090,7 @@
                 this.collectionManager = Ep.CollectionManager.create();
                 this.belongsToManager = Ep.BelongsToManager.create();
                 this.shadows = Ep.ModelSet.create();
+                this.originals = Ep.ModelSet.create();
                 this.newModels = Ep.ModelSet.create();
             },
             create: function (type, hash) {
@@ -3042,6 +3168,11 @@
                 }, this);
                 return dest;
             },
+            remove: function (model) {
+                get(this, 'models').remove(model);
+                get(this, 'shadows').remove(model);
+                get(this, 'originals').remove(model);
+            },
             update: function (model) {
                 this.reifyClientId(model);
                 if (get(model, 'isProxy')) {
@@ -3135,7 +3266,10 @@
                 });
             },
             flush: function () {
-                var session = this, dirtyModels = get(this, 'dirtyModels'), shadows = get(this, 'shadows');
+                var session = this, dirtyModels = get(this, 'dirtyModels'), newModels = get(this, 'newModels'), shadows = get(this, 'shadows');
+                dirtyModels.forEach(function (model) {
+                    model.incrementProperty('clientRev');
+                }, this);
                 var promise = this.adapter.flush(this).then(function (models) {
                         var res = models.map(function (model) {
                                 return session.merge(model);
@@ -3148,8 +3282,14 @@
                         throw res;
                     });
                 dirtyModels.forEach(function (model) {
-                    this.shadows.add(model.copy());
+                    var original = this.originals.getModel(model);
+                    var shadow = this.shadows.getModel(model);
+                    if (shadow && (!original || original.get('rev') < shadow.get('rev'))) {
+                        this.originals.add(shadow);
+                    }
+                    this.shadows.remove(model);
                 }, this);
+                newModels.clear();
                 return promise;
             },
             getModel: function (model) {
@@ -3189,6 +3329,7 @@
                 this.collectionManager.destroy();
                 this.belongsToManager.destroy();
                 this.shadows.destroy();
+                this.originals.destroy();
                 this.newModels.destroy();
             },
             dirtyModels: Ember.computed(function () {
@@ -3243,23 +3384,21 @@
             init: function () {
                 this.cache = Ep.ModelSet.create();
             },
-            merge: function (theirs, ours) {
+            merge: function (ours, ancestor, theirs) {
                 if (this.cache.contains(ours))
                     return ours;
                 this.cache.addObject(theirs);
                 ours.beginPropertyChanges();
-                var session = get(this, 'session');
-                var original = session.getShadow(ours);
-                this.mergeAttributes(theirs, ours, original);
-                this.mergeRelationships(theirs, ours, original);
+                this.mergeAttributes(ours, ancestor, theirs);
+                this.mergeRelationships(ours, ancestor, theirs);
                 ours.endPropertyChanges();
                 return ours;
             },
-            mergeAttributes: function (theirs, ours, original) {
+            mergeAttributes: function (ours, ancestor, theirs) {
                 ours.eachAttribute(function (name, meta) {
                     var oursValue = get(ours, name);
                     var theirsValue = get(theirs, name);
-                    var originalValue = get(original, name);
+                    var originalValue = get(ancestor, name);
                     if (oursValue === theirsValue)
                         return;
                     if (oursValue === originalValue) {
@@ -3267,13 +3406,13 @@
                     }
                 });
             },
-            mergeRelationships: function (theirs, ours, original) {
+            mergeRelationships: function (ours, ancestor, theirs) {
                 var session = get(this, 'session');
                 ours.eachRelationship(function (name, relationship) {
                     if (relationship.kind === 'belongsTo') {
                         var oursValue = get(ours, name);
                         var theirsValue = get(theirs, name);
-                        var originalValue = get(original, name);
+                        var originalValue = get(ancestor, name);
                         var merged = mergeIfPresent(session, theirsValue, this);
                         if (isEqual(oursValue, originalValue)) {
                             set(ours, name, merged);
@@ -3281,7 +3420,7 @@
                     } else if (relationship.kind === 'hasMany') {
                         var theirChildren = get(theirs, name);
                         var ourChildren = get(ours, name);
-                        var originalChildren = get(original, name);
+                        var originalChildren = get(ancestor, name);
                         if (isEqual(ourChildren, originalChildren)) {
                             var existing = Ep.ModelSet.create();
                             existing.addObjects(ourChildren);
@@ -3310,7 +3449,7 @@
             init: function () {
                 this.cache = Ep.ModelSet.create();
             },
-            merge: function (model, dest) {
+            merge: function (dest, ancestor, model) {
                 if (this.cache.contains(model))
                     return dest;
                 this.cache.addObject(model);