From c7a36e5b41574fa8466aa983607436e375fae76e Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Sun, 1 Jun 2014 16:01:18 +0200
Subject: [PATCH 01/10] parse / toJSON applied inconsistent #111

---
 .idea/codeStyleSettings.xml  |  21 +
 SpecRunner.html              |   1 +
 backbone.dualstorage.coffee  |  21 +-
 backbone.dualstorage.js      |  20 +-
 spec/backbone.dualstorage.js | 784 ++++++++++++++++++-----------------
 spec/localsync_spec.coffee   |   2 +-
 spec/localsync_spec.js       |   2 +-
 spec/parse_specs.coffee      | 135 ++++++
 8 files changed, 579 insertions(+), 407 deletions(-)
 create mode 100644 .idea/codeStyleSettings.xml
 create mode 100644 spec/parse_specs.coffee

diff --git a/.idea/codeStyleSettings.xml b/.idea/codeStyleSettings.xml
new file mode 100644
index 0000000..d698db9
--- /dev/null
+++ b/.idea/codeStyleSettings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectCodeStyleSettingsManager">
+    <option name="PER_PROJECT_SETTINGS">
+      <value>
+        <XML>
+          <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true" />
+        </XML>
+        <codeStyleSettings language="JavaScript">
+          <indentOptions>
+            <option name="INDENT_SIZE" value="2" />
+            <option name="CONTINUATION_INDENT_SIZE" value="2" />
+            <option name="TAB_SIZE" value="2" />
+          </indentOptions>
+        </codeStyleSettings>
+      </value>
+    </option>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </component>
+</project>
+
diff --git a/SpecRunner.html b/SpecRunner.html
index 1b59341..cca54e1 100644
--- a/SpecRunner.html
+++ b/SpecRunner.html
@@ -23,6 +23,7 @@
   <script type="text/javascript" src="spec/backbone_extensions_spec.js"></script>
   <script type="text/javascript" src="spec/integration_spec.js"></script>
   <script type="text/javascript" src="spec/bugs_spec.js"></script>
+  <script type="text/javascript" src="spec/parse_specs.js"></script>
 
   <script type="text/javascript">
     (function() {
diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index 1c43b8a..d65533d 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -212,7 +212,9 @@ localsync = (method, model, options) ->
           store.clean(model, 'dirty')
         else
           store.clean(model, 'destroyed')
-  response = response.attributes if response?.attributes
+
+  # Returne the serialized form of the model, this form is passed to parse
+  response = response.toJSON() if response?.attributes
 
   unless options.ignoreCallbacks
     if response
@@ -225,11 +227,13 @@ localsync = (method, model, options) ->
 # Helper function to run parseBeforeLocalSave() in order to
 # parse a remote JSON response before caching locally
 parseRemoteResponse = (object, response) ->
-  if not (object and object.parseBeforeLocalSave) then return response
-  if _.isFunction(object.parseBeforeLocalSave) then object.parseBeforeLocalSave(response)
+  if _.isFunction(object.parseBeforeLocalSave)
+    object.parseBeforeLocalSave response
+  else
+    response
 
 modelUpdatedWithResponse = (model, response) ->
-  modelClone = new Backbone.Model
+  modelClone = new model.constructor
   modelClone.idAttribute = model.idAttribute
   modelClone.set model.attributes
   modelClone.set model.parse response
@@ -278,18 +282,23 @@ dualsync = (method, model, options) ->
         success localsync(method, model, options)
       else
         options.success = (resp, status, xhr) ->
+          # for backwards compatiblity, should not be needed anymore
           resp = parseRemoteResponse(model, resp)
 
           if model instanceof Backbone.Collection
             collection = model
+
+            # parse the model using the parse method of the collection
+            # can be used to adjust the schema of collection elements (not for a single element)
+            workingRespone = collection.parse(resp)
             idAttribute = collection.model.prototype.idAttribute
             localsync('clear', collection, options) unless options.add
-            for modelAttributes in resp
+            for modelAttributes in workingRespone
               model = collection.get(modelAttributes[idAttribute])
               if model
                 responseModel = modelUpdatedWithResponse(model, modelAttributes)
               else
-                responseModel = new collection.model(modelAttributes)
+                responseModel = new collection.model(modelAttributes, { parse: true })
               localsync('update', responseModel, options)
           else
             responseModel = modelUpdatedWithResponse(model, resp)
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 58313ca..5bfb47f 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -286,7 +286,7 @@ as that.
       }
     })();
     if (response != null ? response.attributes : void 0) {
-      response = response.attributes;
+      response = response.toJSON();
     }
     if (!options.ignoreCallbacks) {
       if (response) {
@@ -299,17 +299,16 @@ as that.
   };
 
   parseRemoteResponse = function(object, response) {
-    if (!(object && object.parseBeforeLocalSave)) {
-      return response;
-    }
     if (_.isFunction(object.parseBeforeLocalSave)) {
       return object.parseBeforeLocalSave(response);
+    } else {
+      return response;
     }
   };
 
   modelUpdatedWithResponse = function(model, response) {
     var modelClone;
-    modelClone = new Backbone.Model;
+    modelClone = new model.constructor;
     modelClone.idAttribute = model.idAttribute;
     modelClone.set(model.attributes);
     modelClone.set(model.parse(response));
@@ -362,21 +361,24 @@ as that.
           return success(localsync(method, model, options));
         } else {
           options.success = function(resp, status, xhr) {
-            var collection, idAttribute, modelAttributes, responseModel, _i, _len;
+            var collection, idAttribute, modelAttributes, responseModel, workingRespone, _i, _len;
             resp = parseRemoteResponse(model, resp);
             if (model instanceof Backbone.Collection) {
               collection = model;
+              workingRespone = collection.parse(resp);
               idAttribute = collection.model.prototype.idAttribute;
               if (!options.add) {
                 localsync('clear', collection, options);
               }
-              for (_i = 0, _len = resp.length; _i < _len; _i++) {
-                modelAttributes = resp[_i];
+              for (_i = 0, _len = workingRespone.length; _i < _len; _i++) {
+                modelAttributes = workingRespone[_i];
                 model = collection.get(modelAttributes[idAttribute]);
                 if (model) {
                   responseModel = modelUpdatedWithResponse(model, modelAttributes);
                 } else {
-                  responseModel = new collection.model(modelAttributes);
+                  responseModel = new collection.model(modelAttributes, {
+                    parse: true
+                  });
                 }
                 localsync('update', responseModel, options);
               }
diff --git a/spec/backbone.dualstorage.js b/spec/backbone.dualstorage.js
index d6b0be7..3d64eed 100644
--- a/spec/backbone.dualstorage.js
+++ b/spec/backbone.dualstorage.js
@@ -7,424 +7,393 @@ A simple module to replace `Backbone.sync` with *localStorage*-based
 persistence. Models are given GUIDS, and saved into a JSON object. Simple
 as that.
  */
-var S4, backboneSync, callbackTranslator, dualsync, getStoreName, localsync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse,
-  __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
-
-Backbone.DualStorage = {
-  offlineStatusCodes: [408, 502]
-};
-
-Backbone.Model.prototype.hasTempId = function() {
-  return _.isString(this.id) && this.id.length === 36;
-};
-
-getStoreName = function(collection, model) {
-  model || (model = collection.model.prototype);
-  return _.result(collection, 'storeName') || _.result(model, 'storeName') || _.result(collection, 'url') || _.result(model, 'urlRoot') || _.result(model, 'url');
-};
-
-Backbone.Collection.prototype.syncDirty = function() {
-  var id, ids, store, _i, _len, _ref, _results;
-  store = localStorage.getItem("" + (getStoreName(this)) + "_dirty");
-  ids = (store && store.split(',')) || [];
-  _results = [];
-  for (_i = 0, _len = ids.length; _i < _len; _i++) {
-    id = ids[_i];
-    _results.push((_ref = this.get(id)) != null ? _ref.save() : void 0);
-  }
-  return _results;
-};
-
-Backbone.Collection.prototype.dirtyModels = function() {
-  var id, ids, models, store;
-  store = localStorage.getItem("" + (getStoreName(this)) + "_dirty");
-  ids = (store && store.split(',')) || [];
-  models = (function() {
-    var _i, _len, _results;
-    _results = [];
-    for (_i = 0, _len = ids.length; _i < _len; _i++) {
-      id = ids[_i];
-      _results.push(this.get(id));
-    }
-    return _results;
-  }).call(this);
-  return _.compact(models);
-};
-
-Backbone.Collection.prototype.syncDestroyed = function() {
-  var id, ids, model, store, _i, _len, _results;
-  store = localStorage.getItem("" + (getStoreName(this)) + "_destroyed");
-  ids = (store && store.split(',')) || [];
-  _results = [];
-  for (_i = 0, _len = ids.length; _i < _len; _i++) {
-    id = ids[_i];
-    model = new this.model;
-    model.set(model.idAttribute, id);
-    model.collection = this;
-    _results.push(model.destroy());
-  }
-  return _results;
-};
-
-Backbone.Collection.prototype.destroyedModelIds = function() {
-  var ids, store;
-  store = localStorage.getItem("" + (getStoreName(this)) + "_destroyed");
-  return ids = (store && store.split(',')) || [];
-};
-
-Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
-  this.syncDirty();
-  return this.syncDestroyed();
-};
-
-S4 = function() {
-  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
-};
-
-window.Store = (function() {
-  Store.prototype.sep = '';
-
-  function Store(name) {
-    this.name = name;
-    this.records = this.recordsOn(this.name);
-  }
-
-  Store.prototype.generateId = function() {
-    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
-  };
 
-  Store.prototype.save = function() {
-    return localStorage.setItem(this.name, this.records.join(','));
-  };
+  var S4, backboneSync, callbackTranslator, dualsync, getStoreName, localsync, modelUpdatedWithResponse, onlineSync, parseRemoteResponse,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
 
-  Store.prototype.recordsOn = function(key) {
-    var store;
-    store = localStorage.getItem(key);
-    return (store && store.split(',')) || [];
+  Backbone.DualStorage = {
+    offlineStatusCodes: [408, 502]
   };
 
-  Store.prototype.dirty = function(model) {
-    var dirtyRecords;
-    dirtyRecords = this.recordsOn(this.name + '_dirty');
-    if (!_.include(dirtyRecords, model.id.toString())) {
-      dirtyRecords.push(model.id);
-      localStorage.setItem(this.name + '_dirty', dirtyRecords.join(','));
-    }
-    return model;
+  Backbone.Model.prototype.hasTempId = function() {
+    return _.isString(this.id) && this.id.length === 36;
   };
 
-  Store.prototype.clean = function(model, from) {
-    var dirtyRecords, store;
-    store = "" + this.name + "_" + from;
-    dirtyRecords = this.recordsOn(store);
-    if (_.include(dirtyRecords, model.id.toString())) {
-      localStorage.setItem(store, _.without(dirtyRecords, model.id.toString()).join(','));
-    }
-    return model;
+  getStoreName = function(collection, model) {
+    model || (model = collection.model.prototype);
+    return _.result(collection, 'storeName') || _.result(model, 'storeName') || _.result(collection, 'url') || _.result(model, 'urlRoot') || _.result(model, 'url');
   };
 
-  Store.prototype.destroyed = function(model) {
-    var destroyedRecords;
-    destroyedRecords = this.recordsOn(this.name + '_destroyed');
-    if (!_.include(destroyedRecords, model.id.toString())) {
-      destroyedRecords.push(model.id);
-      localStorage.setItem(this.name + '_destroyed', destroyedRecords.join(','));
+  Backbone.Collection.prototype.syncDirty = function() {
+    var id, ids, store, _i, _len, _ref, _results;
+    store = localStorage.getItem("" + (getStoreName(this)) + "_dirty");
+    ids = (store && store.split(',')) || [];
+    _results = [];
+    for (_i = 0, _len = ids.length; _i < _len; _i++) {
+      id = ids[_i];
+      _results.push((_ref = this.get(id)) != null ? _ref.save() : void 0);
     }
-    return model;
+    return _results;
   };
 
-  Store.prototype.create = function(model) {
-    if (!_.isObject(model)) {
-      return model;
-    }
-    if (!model.id) {
-      model.set(model.idAttribute, this.generateId());
-    }
-    localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-    this.records.push(model.id.toString());
-    this.save();
-    return model;
+  Backbone.Collection.prototype.dirtyModels = function() {
+    var id, ids, models, store;
+    store = localStorage.getItem("" + (getStoreName(this)) + "_dirty");
+    ids = (store && store.split(',')) || [];
+    models = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = ids.length; _i < _len; _i++) {
+        id = ids[_i];
+        _results.push(this.get(id));
+      }
+      return _results;
+    }).call(this);
+    return _.compact(models);
   };
 
-  Store.prototype.update = function(model) {
-    localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
-    if (!_.include(this.records, model.id.toString())) {
-      this.records.push(model.id.toString());
+  Backbone.Collection.prototype.syncDestroyed = function() {
+    var id, ids, model, store, _i, _len, _results;
+    store = localStorage.getItem("" + (getStoreName(this)) + "_destroyed");
+    ids = (store && store.split(',')) || [];
+    _results = [];
+    for (_i = 0, _len = ids.length; _i < _len; _i++) {
+      id = ids[_i];
+      model = new this.model;
+      model.set(model.idAttribute, id);
+      model.collection = this;
+      _results.push(model.destroy());
     }
-    this.save();
-    return model;
+    return _results;
   };
 
-  Store.prototype.clear = function() {
-    var id, _i, _len, _ref;
-    _ref = this.records;
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      id = _ref[_i];
-      localStorage.removeItem(this.name + this.sep + id);
-    }
-    this.records = [];
-    return this.save();
+  Backbone.Collection.prototype.destroyedModelIds = function() {
+    var ids, store;
+    store = localStorage.getItem("" + (getStoreName(this)) + "_destroyed");
+    return ids = (store && store.split(',')) || [];
   };
 
-  Store.prototype.hasDirtyOrDestroyed = function() {
-    return !_.isEmpty(localStorage.getItem(this.name + '_dirty')) || !_.isEmpty(localStorage.getItem(this.name + '_destroyed'));
+  Backbone.Collection.prototype.syncDirtyAndDestroyed = function() {
+    this.syncDirty();
+    return this.syncDestroyed();
   };
 
-  Store.prototype.find = function(model) {
-    var modelAsJson;
-    modelAsJson = localStorage.getItem(this.name + this.sep + model.id);
-    if (modelAsJson === null) {
-      return null;
-    }
-    return JSON.parse(modelAsJson);
+  S4 = function() {
+    return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
   };
 
-  Store.prototype.findAll = function() {
-    var id, _i, _len, _ref, _results;
-    _ref = this.records;
-    _results = [];
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      id = _ref[_i];
-      _results.push(JSON.parse(localStorage.getItem(this.name + this.sep + id)));
+  window.Store = (function() {
+    Store.prototype.sep = '';
+
+    function Store(name) {
+      this.name = name;
+      this.records = this.recordsOn(this.name);
     }
-    return _results;
-  };
 
-  Store.prototype.destroy = function(model) {
-    localStorage.removeItem(this.name + this.sep + model.id);
-    this.records = _.reject(this.records, function(record_id) {
-      return record_id === model.id.toString();
-    });
-    this.save();
-    return model;
-  };
+    Store.prototype.generateId = function() {
+      return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+    };
+
+    Store.prototype.save = function() {
+      return localStorage.setItem(this.name, this.records.join(','));
+    };
+
+    Store.prototype.recordsOn = function(key) {
+      var store;
+      store = localStorage.getItem(key);
+      return (store && store.split(',')) || [];
+    };
+
+    Store.prototype.dirty = function(model) {
+      var dirtyRecords;
+      dirtyRecords = this.recordsOn(this.name + '_dirty');
+      if (!_.include(dirtyRecords, model.id.toString())) {
+        dirtyRecords.push(model.id);
+        localStorage.setItem(this.name + '_dirty', dirtyRecords.join(','));
+      }
+      return model;
+    };
+
+    Store.prototype.clean = function(model, from) {
+      var dirtyRecords, store;
+      store = "" + this.name + "_" + from;
+      dirtyRecords = this.recordsOn(store);
+      if (_.include(dirtyRecords, model.id.toString())) {
+        localStorage.setItem(store, _.without(dirtyRecords, model.id.toString()).join(','));
+      }
+      return model;
+    };
+
+    Store.prototype.destroyed = function(model) {
+      var destroyedRecords;
+      destroyedRecords = this.recordsOn(this.name + '_destroyed');
+      if (!_.include(destroyedRecords, model.id.toString())) {
+        destroyedRecords.push(model.id);
+        localStorage.setItem(this.name + '_destroyed', destroyedRecords.join(','));
+      }
+      return model;
+    };
+
+    Store.prototype.create = function(model) {
+      if (!_.isObject(model)) {
+        return model;
+      }
+      if (!model.id) {
+        model.set(model.idAttribute, this.generateId());
+      }
+      localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
+      this.records.push(model.id.toString());
+      this.save();
+      return model;
+    };
 
-  return Store;
+    Store.prototype.update = function(model) {
+      localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
+      if (!_.include(this.records, model.id.toString())) {
+        this.records.push(model.id.toString());
+      }
+      this.save();
+      return model;
+    };
+
+    Store.prototype.clear = function() {
+      var id, _i, _len, _ref;
+      _ref = this.records;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        id = _ref[_i];
+        localStorage.removeItem(this.name + this.sep + id);
+      }
+      this.records = [];
+      return this.save();
+    };
+
+    Store.prototype.hasDirtyOrDestroyed = function() {
+      return !_.isEmpty(localStorage.getItem(this.name + '_dirty')) || !_.isEmpty(localStorage.getItem(this.name + '_destroyed'));
+    };
+
+    Store.prototype.find = function(model) {
+      var modelAsJson;
+      modelAsJson = localStorage.getItem(this.name + this.sep + model.id);
+      if (modelAsJson === null) {
+        return null;
+      }
+      return JSON.parse(modelAsJson);
+    };
+
+    Store.prototype.findAll = function() {
+      var id, _i, _len, _ref, _results;
+      _ref = this.records;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        id = _ref[_i];
+        _results.push(JSON.parse(localStorage.getItem(this.name + this.sep + id)));
+      }
+      return _results;
+    };
+
+    Store.prototype.destroy = function(model) {
+      localStorage.removeItem(this.name + this.sep + model.id);
+      this.records = _.reject(this.records, function(record_id) {
+        return record_id === model.id.toString();
+      });
+      this.save();
+      return model;
+    };
 
-})();
+    return Store;
 
-window.Store.exists = function(storeName) {
-  return localStorage.getItem(storeName) !== null;
-};
+  })();
 
-callbackTranslator = {
-  needsTranslation: Backbone.VERSION === '0.9.10',
-  forBackboneCaller: function(callback) {
-    if (this.needsTranslation) {
-      return function(model, resp, options) {
-        return callback.call(null, resp);
-      };
-    } else {
-      return callback;
+  window.Store.exists = function(storeName) {
+    return localStorage.getItem(storeName) !== null;
+  };
+
+  callbackTranslator = {
+    needsTranslation: Backbone.VERSION === '0.9.10',
+    forBackboneCaller: function(callback) {
+      if (this.needsTranslation) {
+        return function(model, resp, options) {
+          return callback.call(null, resp);
+        };
+      } else {
+        return callback;
+      }
+    },
+    forDualstorageCaller: function(callback, model, options) {
+      if (this.needsTranslation) {
+        return function(resp) {
+          return callback.call(null, model, resp, options);
+        };
+      } else {
+        return callback;
+      }
     }
-  },
-  forDualstorageCaller: function(callback, model, options) {
-    if (this.needsTranslation) {
-      return function(resp) {
-        return callback.call(null, model, resp, options);
-      };
-    } else {
-      return callback;
+  };
+
+  localsync = function(method, model, options) {
+    var isValidModel, preExisting, response, store;
+    isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
+    isValidModel || (isValidModel = model instanceof Backbone.Model);
+    isValidModel || (isValidModel = model instanceof Backbone.Collection);
+    if (!isValidModel) {
+      throw new Error('model parameter is required to be a backbone model or collection.');
     }
-  }
-};
-
-localsync = function(method, model, options) {
-  var isValidModel, preExisting, response, store;
-  isValidModel = (method === 'clear') || (method === 'hasDirtyOrDestroyed');
-  isValidModel || (isValidModel = model instanceof Backbone.Model);
-  isValidModel || (isValidModel = model instanceof Backbone.Collection);
-  if (!isValidModel) {
-    throw new Error('model parameter is required to be a backbone model or collection.');
-  }
-  store = new Store(options.storeName);
-  response = (function() {
-    switch (method) {
-      case 'read':
-        if (model instanceof Backbone.Model) {
-          return store.find(model);
-        } else {
-          return store.findAll();
-        }
-        break;
-      case 'hasDirtyOrDestroyed':
-        return store.hasDirtyOrDestroyed();
-      case 'clear':
-        return store.clear();
-      case 'create':
-        if (options.add && !options.merge && (preExisting = store.find(model))) {
-          return preExisting;
-        } else {
-          model = store.create(model);
-          if (options.dirty) {
-            store.dirty(model);
+    store = new Store(options.storeName);
+    response = (function() {
+      switch (method) {
+        case 'read':
+          if (model instanceof Backbone.Model) {
+            return store.find(model);
+          } else {
+            return store.findAll();
           }
-          return model;
-        }
-        break;
-      case 'update':
-        store.update(model);
-        if (options.dirty) {
-          return store.dirty(model);
-        } else {
-          return store.clean(model, 'dirty');
-        }
-        break;
-      case 'delete':
-        store.destroy(model);
-        if (options.dirty) {
-          return store.destroyed(model);
-        } else {
-          if (model.id.toString().length === 36) {
+          break;
+        case 'hasDirtyOrDestroyed':
+          return store.hasDirtyOrDestroyed();
+        case 'clear':
+          return store.clear();
+        case 'create':
+          if (options.add && !options.merge && (preExisting = store.find(model))) {
+            return preExisting;
+          } else {
+            model = store.create(model);
+            if (options.dirty) {
+              store.dirty(model);
+            }
+            return model;
+          }
+          break;
+        case 'update':
+          store.update(model);
+          if (options.dirty) {
+            return store.dirty(model);
+          } else {
             return store.clean(model, 'dirty');
+          }
+          break;
+        case 'delete':
+          store.destroy(model);
+          if (options.dirty) {
+            return store.destroyed(model);
           } else {
-            return store.clean(model, 'destroyed');
+            if (model.id.toString().length === 36) {
+              return store.clean(model, 'dirty');
+            } else {
+              return store.clean(model, 'destroyed');
+            }
           }
-        }
+      }
+    })();
+    if (response != null ? response.attributes : void 0) {
+      response = response.toJSON();
     }
-  })();
-  if (response != null ? response.attributes : void 0) {
-    response = response.attributes;
-  }
-  if (!options.ignoreCallbacks) {
-    if (response) {
-      options.success(response);
-    } else {
-      options.error('Record not found');
+    if (!options.ignoreCallbacks) {
+      if (response) {
+        options.success(response);
+      } else {
+        options.error('Record not found');
+      }
     }
-  }
-  return response;
-};
-
-parseRemoteResponse = function(object, response) {
-  if (!(object && object.parseBeforeLocalSave)) {
     return response;
-  }
-  if (_.isFunction(object.parseBeforeLocalSave)) {
-    return object.parseBeforeLocalSave(response);
-  }
-};
-
-modelUpdatedWithResponse = function(model, response) {
-  var modelClone;
-  modelClone = new Backbone.Model;
-  modelClone.idAttribute = model.idAttribute;
-  modelClone.set(model.attributes);
-  modelClone.set(model.parse(response));
-  return modelClone;
-};
-
-backboneSync = Backbone.sync;
-
-onlineSync = function(method, model, options) {
-  options.success = callbackTranslator.forBackboneCaller(options.success);
-  options.error = callbackTranslator.forBackboneCaller(options.error);
-  return backboneSync(method, model, options);
-};
-
-dualsync = function(method, model, options) {
-  var error, local, relayErrorCallback, success, temporaryId;
-  options.storeName = getStoreName(model.collection, model);
-  options.storeExists = Store.exists(options.storeName);
-  options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
-  options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
-  if (_.result(model, 'remote') || _.result(model.collection, 'remote')) {
-    return onlineSync(method, model, options);
-  }
-  local = _.result(model, 'local') || _.result(model.collection, 'local');
-  options.dirty = options.remote === false && !local;
-  if (options.remote === false || local) {
-    return localsync(method, model, options);
-  }
-  options.ignoreCallbacks = true;
-  success = options.success;
-  error = options.error;
-  relayErrorCallback = function(response) {
-    var offline, offlineStatusCodes, _ref;
-    offlineStatusCodes = Backbone.DualStorage.offlineStatusCodes;
-    if (_.isFunction(offlineStatusCodes)) {
-      offlineStatusCodes = offlineStatusCodes(response);
-    }
-    offline = response.status === 0 || (_ref = response.status, __indexOf.call(offlineStatusCodes, _ref) >= 0);
-    if (offline && options.storeExists) {
-      options.dirty = true;
-      return success(localsync(method, model, options));
+  };
+
+  parseRemoteResponse = function(object, response) {
+    if (_.isFunction(object.parseBeforeLocalSave)) {
+      return object.parseBeforeLocalSave(response);
     } else {
-      return error(response);
+      return response;
     }
   };
-  switch (method) {
-    case 'read':
-      if (localsync('hasDirtyOrDestroyed', model, options)) {
+
+  modelUpdatedWithResponse = function(model, response) {
+    var modelClone;
+    modelClone = new model.constructor;
+    modelClone.idAttribute = model.idAttribute;
+    modelClone.set(model.attributes);
+    modelClone.set(model.parse(response));
+    return modelClone;
+  };
+
+  backboneSync = Backbone.sync;
+
+  onlineSync = function(method, model, options) {
+    options.success = callbackTranslator.forBackboneCaller(options.success);
+    options.error = callbackTranslator.forBackboneCaller(options.error);
+    return backboneSync(method, model, options);
+  };
+
+  dualsync = function(method, model, options) {
+    var error, local, relayErrorCallback, success, temporaryId;
+    options.storeName = getStoreName(model.collection, model);
+    options.storeExists = Store.exists(options.storeName);
+    options.success = callbackTranslator.forDualstorageCaller(options.success, model, options);
+    options.error = callbackTranslator.forDualstorageCaller(options.error, model, options);
+    if (_.result(model, 'remote') || _.result(model.collection, 'remote')) {
+      return onlineSync(method, model, options);
+    }
+    local = _.result(model, 'local') || _.result(model.collection, 'local');
+    options.dirty = options.remote === false && !local;
+    if (options.remote === false || local) {
+      return localsync(method, model, options);
+    }
+    options.ignoreCallbacks = true;
+    success = options.success;
+    error = options.error;
+    relayErrorCallback = function(response) {
+      var offline, offlineStatusCodes, _ref;
+      offlineStatusCodes = Backbone.DualStorage.offlineStatusCodes;
+      if (_.isFunction(offlineStatusCodes)) {
+        offlineStatusCodes = offlineStatusCodes(response);
+      }
+      offline = response.status === 0 || (_ref = response.status, __indexOf.call(offlineStatusCodes, _ref) >= 0);
+      if (offline && options.storeExists) {
         options.dirty = true;
         return success(localsync(method, model, options));
       } else {
-        options.success = function(resp, status, xhr) {
-          var collection, idAttribute, modelAttributes, responseModel, _i, _len;
-          resp = parseRemoteResponse(model, resp);
-          if (model instanceof Backbone.Collection) {
-            collection = model;
-            idAttribute = collection.model.prototype.idAttribute;
-            if (!options.add) {
-              localsync('clear', collection, options);
-            }
-            for (_i = 0, _len = resp.length; _i < _len; _i++) {
-              modelAttributes = resp[_i];
-              model = collection.get(modelAttributes[idAttribute]);
-              if (model) {
-                responseModel = modelUpdatedWithResponse(model, modelAttributes);
-              } else {
-                responseModel = new collection.model(modelAttributes);
+        return error(response);
+      }
+    };
+    switch (method) {
+      case 'read':
+        if (localsync('hasDirtyOrDestroyed', model, options)) {
+          options.dirty = true;
+          return success(localsync(method, model, options));
+        } else {
+          options.success = function(resp, status, xhr) {
+            var collection, idAttribute, modelAttributes, responseModel, workingRespone, _i, _len;
+            resp = parseRemoteResponse(model, resp);
+            if (model instanceof Backbone.Collection) {
+              collection = model;
+              workingRespone = collection.parse(resp);
+              idAttribute = collection.model.prototype.idAttribute;
+              if (!options.add) {
+                localsync('clear', collection, options);
               }
+              for (_i = 0, _len = workingRespone.length; _i < _len; _i++) {
+                modelAttributes = workingRespone[_i];
+                model = collection.get(modelAttributes[idAttribute]);
+                if (model) {
+                  responseModel = modelUpdatedWithResponse(model, modelAttributes);
+                } else {
+                  responseModel = new collection.model(modelAttributes, {
+                    parse: true
+                  });
+                }
+                localsync('update', responseModel, options);
+              }
+            } else {
+              responseModel = modelUpdatedWithResponse(model, resp);
               localsync('update', responseModel, options);
             }
-          } else {
-            responseModel = modelUpdatedWithResponse(model, resp);
-            localsync('update', responseModel, options);
-          }
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          return relayErrorCallback(resp);
-        };
-        return onlineSync(method, model, options);
-      }
-      break;
-    case 'create':
-      options.success = function(resp, status, xhr) {
-        var updatedModel;
-        updatedModel = modelUpdatedWithResponse(model, resp);
-        localsync(method, updatedModel, options);
-        return success(resp, status, xhr);
-      };
-      options.error = function(resp) {
-        return relayErrorCallback(resp);
-      };
-      return onlineSync(method, model, options);
-    case 'update':
-      if (model.hasTempId()) {
-        temporaryId = model.id;
-        options.success = function(resp, status, xhr) {
-          var updatedModel;
-          updatedModel = modelUpdatedWithResponse(model, resp);
-          model.set(model.idAttribute, temporaryId, {
-            silent: true
-          });
-          localsync('delete', model, options);
-          localsync('create', updatedModel, options);
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          model.set(model.idAttribute, temporaryId, {
-            silent: true
-          });
-          return relayErrorCallback(resp);
-        };
-        model.set(model.idAttribute, null, {
-          silent: true
-        });
-        return onlineSync('create', model, options);
-      } else {
+            return success(resp, status, xhr);
+          };
+          options.error = function(resp) {
+            return relayErrorCallback(resp);
+          };
+          return onlineSync(method, model, options);
+        }
+        break;
+      case 'create':
         options.success = function(resp, status, xhr) {
           var updatedModel;
           updatedModel = modelUpdatedWithResponse(model, resp);
@@ -435,24 +404,59 @@ dualsync = function(method, model, options) {
           return relayErrorCallback(resp);
         };
         return onlineSync(method, model, options);
-      }
-      break;
-    case 'delete':
-      if (model.hasTempId()) {
-        return localsync(method, model, options);
-      } else {
-        options.success = function(resp, status, xhr) {
-          localsync(method, model, options);
-          return success(resp, status, xhr);
-        };
-        options.error = function(resp) {
-          return relayErrorCallback(resp);
-        };
-        return onlineSync(method, model, options);
-      }
-  }
-};
+      case 'update':
+        if (model.hasTempId()) {
+          temporaryId = model.id;
+          options.success = function(resp, status, xhr) {
+            var updatedModel;
+            updatedModel = modelUpdatedWithResponse(model, resp);
+            model.set(model.idAttribute, temporaryId, {
+              silent: true
+            });
+            localsync('delete', model, options);
+            localsync('create', updatedModel, options);
+            return success(resp, status, xhr);
+          };
+          options.error = function(resp) {
+            model.set(model.idAttribute, temporaryId, {
+              silent: true
+            });
+            return relayErrorCallback(resp);
+          };
+          model.set(model.idAttribute, null, {
+            silent: true
+          });
+          return onlineSync('create', model, options);
+        } else {
+          options.success = function(resp, status, xhr) {
+            var updatedModel;
+            updatedModel = modelUpdatedWithResponse(model, resp);
+            localsync(method, updatedModel, options);
+            return success(resp, status, xhr);
+          };
+          options.error = function(resp) {
+            return relayErrorCallback(resp);
+          };
+          return onlineSync(method, model, options);
+        }
+        break;
+      case 'delete':
+        if (model.hasTempId()) {
+          return localsync(method, model, options);
+        } else {
+          options.success = function(resp, status, xhr) {
+            localsync(method, model, options);
+            return success(resp, status, xhr);
+          };
+          options.error = function(resp) {
+            return relayErrorCallback(resp);
+          };
+          return onlineSync(method, model, options);
+        }
+    }
+  };
+
+  Backbone.sync = dualsync;
 
-Backbone.sync = dualsync;
 
 //# sourceMappingURL=backbone.dualstorage.map
diff --git a/spec/localsync_spec.coffee b/spec/localsync_spec.coffee
index aaad3bf..2bca557 100644
--- a/spec/localsync_spec.coffee
+++ b/spec/localsync_spec.coffee
@@ -128,7 +128,7 @@ describe 'localsync', ->
         localsync 'create', model, {success: ((resp) -> response = resp)}
       waitsFor (-> response), "A callback should have been called with a response", 100
       runs ->
-        expect(response).toBe model.attributes
+        expect(response).toEqual model.attributes
 
     it 'ignores callbacks when the ignoreCallbacks option is set', ->
       {start, callback} = {start: new Date().getTime()}
diff --git a/spec/localsync_spec.js b/spec/localsync_spec.js
index 8f047b0..5fb994c 100644
--- a/spec/localsync_spec.js
+++ b/spec/localsync_spec.js
@@ -316,7 +316,7 @@
           return response;
         }), "A callback should have been called with a response", 100);
         return runs(function() {
-          return expect(response).toBe(model.attributes);
+          return expect(response).toEqual(model.attributes);
         });
       });
       return it('ignores callbacks when the ignoreCallbacks option is set', function() {
diff --git a/spec/parse_specs.coffee b/spec/parse_specs.coffee
new file mode 100644
index 0000000..8265484
--- /dev/null
+++ b/spec/parse_specs.coffee
@@ -0,0 +1,135 @@
+describe "Ensures that parse is invoked concistently", ->
+  Model = Backbone.Model.extend {
+    url: "tests",
+    defaults: ->
+      { name: undefined, subCollection: new Backbone.Collection }
+
+    toJSON: ->
+      attributes = Backbone.Model.prototype.toJSON.apply this
+      attributes.subCollection = this.get("subCollection").toJSON()
+      attributes
+
+    parse: (response) ->
+      parsed = _.clone(response)
+      parsed.subCollection = new Backbone.Collection(response.subCollection || [])
+      parsed
+  }
+
+  Collection = Backbone.Collection.extend {
+    model: Model,
+    url: "tests"
+  }
+
+  beforeEach ->
+    localStorage.clear
+
+  describe "Fetching a single model", ->
+    it "parses the server response with the models parse method before storing it in the localStorage", ->
+      model = new Model { id: 1 };
+
+      serverResponse = { Model: { id: 1, name: "test" } }
+      localResponse = { id: 1, name: "Test" }
+
+      parseSpy = spyOn(model, "parse").andReturn(localResponse);
+      model.fetch({ serverResponse: serverResponse });
+
+      expect(model.get("name")).toBe("Test");
+      expect(parseSpy).toHaveBeenCalledWith(serverResponse);
+
+  describe "Fetching a collection", ->
+    it "first pases the server response to the parse method of the collection", ->
+      collection = new Collection();
+      model = new Model { id: 1, name: "OldName" }
+      collection.add(model);
+
+      serverResponse = {
+        Models: [
+          Model: {
+            id: 1,
+            name: "Test"
+          },
+          Model: {
+            id: 2,
+            name: "Other"
+          }
+        ]
+      }
+      localResponse = [ { id: 1, name: "Test" }, { id: 2, name: "Other"}]
+
+      parseSpy = spyOn(collection, "parse").andReturn(localResponse)
+      modelParseSpy = spyOn(Model.prototype, "parse").andCallThrough()
+      collection.fetch({ serverResponse: serverResponse })
+
+      expect(parseSpy).toHaveBeenCalledWith(serverResponse, jasmine.any(Object))
+
+      # First calls for updating the model in local storage
+      expect(modelParseSpy.argsForCall[0][0]).toEqual({ id: 1, name: "Test" })
+      expect(modelParseSpy.argsForCall[1][0]).toEqual({ id: 2, name: "Other" })
+
+      # call from thorax to update the real instance
+      expect(modelParseSpy.argsForCall[2][0]).toEqual({ id: 1, name: "Test" })
+      expect(modelParseSpy.argsForCall[3][0]).toEqual({ id: 2, name: "Other" })
+
+      expect(collection.length).toBe(2)
+      expect(collection.get(1).get("name")).toBe("Test")
+      expect(collection.get(2).get("name")).toBe("Other")
+
+  describe "Creating a model instance", ->
+    it "the server response should be parsed with parse", ->
+      model = new Model { name: "Old name" }
+
+      serverResponse = { Model: { id: 1, name: "test" } }
+      localResponse = { id: 1, name: "Test" }
+
+      parseSpy = spyOn(model, "parse").andReturn(localResponse);
+
+      model.save({}, { serverResponse: serverResponse });
+
+      expect(parseSpy).toHaveBeenCalledWith(serverResponse)
+      expect(model.get("name")).toBe("Test")
+
+  describe "Updating a model instance", ->
+    it "the updated result from the server should be parsed using model.parse to adopt the format", ->
+      model = new Model { id: 1, name: "Old name" }
+
+      serverResponse = { Model: { id: 1, name: "test" } }
+      localResponse = { id: 1, name: "Test" }
+
+      parseSpy = spyOn(model, "parse").andReturn(localResponse);
+
+      model.save({}, { serverResponse: serverResponse });
+
+      expect(parseSpy).toHaveBeenCalledWith(serverResponse)
+      expect(model.get("name")).toBe("Test")
+
+  describe "Updating a model instance with a temporary id", ->
+    it "should parse the result from the server", ->
+      model = new Model { name: "Old name" }
+      model.save({}, { remote: false }) # get temp id
+
+      serverResponse = { Model: { id: 1, name: "test" } }
+      localResponse = { id: 1, name: "Test" }
+
+      parseSpy = spyOn(model, "parse").andReturn(localResponse);
+
+      model.save({}, { serverResponse: serverResponse });
+
+      expect(parseSpy).toHaveBeenCalledWith(serverResponse)
+      expect(model.get("name")).toBe("Test")
+
+
+  describe "Parse local fetched entities", ->
+    describe "Create new entry", ->
+      it "should pass the model as json instead of it's attributes to parse", ->
+        model = new Model { name: "Old name" }
+
+        parseSpy = spyOn(model, "parse").andCallThrough()
+        model.save({}, { remote: false })
+
+        expect(parseSpy.argsForCall[0][0]).not.toBeUndefined()
+        expect(parseSpy.argsForCall[0][0].subCollection).not.toBeUndefined()
+        #We expect an array (json serialized collection) and not the defaults collection
+        expect(parseSpy.argsForCall[0][0].subCollection).toEqual([])
+        expect(model.id).not.toBeUndefined()
+        expect(model.get("name")).toBe("Old name")
+

From 6cbbe2da70e0eb4d06ca5f4eaf9a084bc26d81bb Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Sun, 1 Jun 2014 16:05:50 +0200
Subject: [PATCH 02/10] parse / toJSON applied inconsistent #111

---
 spec/parse_specs.js | 215 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 215 insertions(+)
 create mode 100644 spec/parse_specs.js

diff --git a/spec/parse_specs.js b/spec/parse_specs.js
new file mode 100644
index 0000000..09788cb
--- /dev/null
+++ b/spec/parse_specs.js
@@ -0,0 +1,215 @@
+// Generated by CoffeeScript 1.7.1
+(function() {
+  describe("Ensures that parse is invoked concistently", function() {
+    var Collection, Model;
+    Model = Backbone.Model.extend({
+      url: "tests",
+      defaults: function() {
+        return {
+          name: void 0,
+          subCollection: new Backbone.Collection
+        };
+      },
+      toJSON: function() {
+        var attributes;
+        attributes = Backbone.Model.prototype.toJSON.apply(this);
+        attributes.subCollection = this.get("subCollection").toJSON();
+        return attributes;
+      },
+      parse: function(response) {
+        var parsed;
+        parsed = _.clone(response);
+        parsed.subCollection = new Backbone.Collection(response.subCollection || []);
+        return parsed;
+      }
+    });
+    Collection = Backbone.Collection.extend({
+      model: Model,
+      url: "tests"
+    });
+    beforeEach(function() {
+      return localStorage.clear;
+    });
+    describe("Fetching a single model", function() {
+      return it("parses the server response with the models parse method before storing it in the localStorage", function() {
+        var localResponse, model, parseSpy, serverResponse;
+        model = new Model({
+          id: 1
+        });
+        serverResponse = {
+          Model: {
+            id: 1,
+            name: "test"
+          }
+        };
+        localResponse = {
+          id: 1,
+          name: "Test"
+        };
+        parseSpy = spyOn(model, "parse").andReturn(localResponse);
+        model.fetch({
+          serverResponse: serverResponse
+        });
+        expect(model.get("name")).toBe("Test");
+        return expect(parseSpy).toHaveBeenCalledWith(serverResponse);
+      });
+    });
+    describe("Fetching a collection", function() {
+      return it("first pases the server response to the parse method of the collection", function() {
+        var collection, localResponse, model, modelParseSpy, parseSpy, serverResponse;
+        collection = new Collection();
+        model = new Model({
+          id: 1,
+          name: "OldName"
+        });
+        collection.add(model);
+        serverResponse = {
+          Models: [
+            {
+              Model: {
+                id: 1,
+                name: "Test"
+              },
+              Model: {
+                id: 2,
+                name: "Other"
+              }
+            }
+          ]
+        };
+        localResponse = [
+          {
+            id: 1,
+            name: "Test"
+          }, {
+            id: 2,
+            name: "Other"
+          }
+        ];
+        parseSpy = spyOn(collection, "parse").andReturn(localResponse);
+        modelParseSpy = spyOn(Model.prototype, "parse").andCallThrough();
+        collection.fetch({
+          serverResponse: serverResponse
+        });
+        expect(parseSpy).toHaveBeenCalledWith(serverResponse, jasmine.any(Object));
+        expect(modelParseSpy.argsForCall[0][0]).toEqual({
+          id: 1,
+          name: "Test"
+        });
+        expect(modelParseSpy.argsForCall[1][0]).toEqual({
+          id: 2,
+          name: "Other"
+        });
+        expect(modelParseSpy.argsForCall[2][0]).toEqual({
+          id: 1,
+          name: "Test"
+        });
+        expect(modelParseSpy.argsForCall[3][0]).toEqual({
+          id: 2,
+          name: "Other"
+        });
+        expect(collection.length).toBe(2);
+        expect(collection.get(1).get("name")).toBe("Test");
+        return expect(collection.get(2).get("name")).toBe("Other");
+      });
+    });
+    describe("Creating a model instance", function() {
+      return it("the server response should be parsed with parse", function() {
+        var localResponse, model, parseSpy, serverResponse;
+        model = new Model({
+          name: "Old name"
+        });
+        serverResponse = {
+          Model: {
+            id: 1,
+            name: "test"
+          }
+        };
+        localResponse = {
+          id: 1,
+          name: "Test"
+        };
+        parseSpy = spyOn(model, "parse").andReturn(localResponse);
+        model.save({}, {
+          serverResponse: serverResponse
+        });
+        expect(parseSpy).toHaveBeenCalledWith(serverResponse);
+        return expect(model.get("name")).toBe("Test");
+      });
+    });
+    describe("Updating a model instance", function() {
+      return it("the updated result from the server should be parsed using model.parse to adopt the format", function() {
+        var localResponse, model, parseSpy, serverResponse;
+        model = new Model({
+          id: 1,
+          name: "Old name"
+        });
+        serverResponse = {
+          Model: {
+            id: 1,
+            name: "test"
+          }
+        };
+        localResponse = {
+          id: 1,
+          name: "Test"
+        };
+        parseSpy = spyOn(model, "parse").andReturn(localResponse);
+        model.save({}, {
+          serverResponse: serverResponse
+        });
+        expect(parseSpy).toHaveBeenCalledWith(serverResponse);
+        return expect(model.get("name")).toBe("Test");
+      });
+    });
+    describe("Updating a model instance with a temporary id", function() {
+      return it("should parse the result from the server", function() {
+        var localResponse, model, parseSpy, serverResponse;
+        model = new Model({
+          name: "Old name"
+        });
+        model.save({}, {
+          remote: false
+        });
+        serverResponse = {
+          Model: {
+            id: 1,
+            name: "test"
+          }
+        };
+        localResponse = {
+          id: 1,
+          name: "Test"
+        };
+        parseSpy = spyOn(model, "parse").andReturn(localResponse);
+        model.save({}, {
+          serverResponse: serverResponse
+        });
+        expect(parseSpy).toHaveBeenCalledWith(serverResponse);
+        return expect(model.get("name")).toBe("Test");
+      });
+    });
+    return describe("Parse local fetched entities", function() {
+      return describe("Create new entry", function() {
+        return it("should pass the model as json instead of it's attributes to parse", function() {
+          var model, parseSpy;
+          model = new Model({
+            name: "Old name"
+          });
+          parseSpy = spyOn(model, "parse").andCallThrough();
+          model.save({}, {
+            remote: false
+          });
+          expect(parseSpy.argsForCall[0][0]).not.toBeUndefined();
+          expect(parseSpy.argsForCall[0][0].subCollection).not.toBeUndefined();
+          expect(parseSpy.argsForCall[0][0].subCollection).toEqual([]);
+          expect(model.id).not.toBeUndefined();
+          return expect(model.get("name")).toBe("Old name");
+        });
+      });
+    });
+  });
+
+}).call(this);
+
+//# sourceMappingURL=parse_specs.map

From 5fbc1ba5a7441b6aa42322b1a4fafc3f72ab07d1 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Sun, 1 Jun 2014 16:06:50 +0200
Subject: [PATCH 03/10] Removed idea code style settings

---
 .idea/codeStyleSettings.xml | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 .idea/codeStyleSettings.xml

diff --git a/.idea/codeStyleSettings.xml b/.idea/codeStyleSettings.xml
deleted file mode 100644
index d698db9..0000000
--- a/.idea/codeStyleSettings.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectCodeStyleSettingsManager">
-    <option name="PER_PROJECT_SETTINGS">
-      <value>
-        <XML>
-          <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true" />
-        </XML>
-        <codeStyleSettings language="JavaScript">
-          <indentOptions>
-            <option name="INDENT_SIZE" value="2" />
-            <option name="CONTINUATION_INDENT_SIZE" value="2" />
-            <option name="TAB_SIZE" value="2" />
-          </indentOptions>
-        </codeStyleSettings>
-      </value>
-    </option>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-  </component>
-</project>
-

From b983cc2fcb64a32a867b83eadfa5972aa208fe81 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Mon, 2 Jun 2014 07:17:17 +0200
Subject: [PATCH 04/10] parse / toJSON applied inconsistent #111 #113

Using Backbone.Model instead of the model type, for compatibility with
Backbone-relational
---
 backbone.dualstorage.coffee  | 7 +++++--
 backbone.dualstorage.js      | 6 ++++--
 spec/backbone.dualstorage.js | 6 ++++--
 3 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index d65533d..bdab211 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -233,10 +233,13 @@ parseRemoteResponse = (object, response) ->
     response
 
 modelUpdatedWithResponse = (model, response) ->
-  modelClone = new model.constructor
+  modelClone = new Backbone.Model
+  # Use the methods from the model to support "inheritance"
+  modelClone.toJSON = _.bind(model.toJSON, model);
+  modelClone.parse = _.bind(model.parse, model);
   modelClone.idAttribute = model.idAttribute
   modelClone.set model.attributes
-  modelClone.set model.parse response
+  modelClone.set modelClone.parse response
   modelClone
 
 backboneSync = Backbone.sync
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 5bfb47f..9ca53e3 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -308,10 +308,12 @@ as that.
 
   modelUpdatedWithResponse = function(model, response) {
     var modelClone;
-    modelClone = new model.constructor;
+    modelClone = new Backbone.Model;
+    modelClone.toJSON = _.bind(model.toJSON, model);
+    modelClone.parse = _.bind(model.parse, model);
     modelClone.idAttribute = model.idAttribute;
     modelClone.set(model.attributes);
-    modelClone.set(model.parse(response));
+    modelClone.set(modelClone.parse(response));
     return modelClone;
   };
 
diff --git a/spec/backbone.dualstorage.js b/spec/backbone.dualstorage.js
index 3d64eed..0c64f72 100644
--- a/spec/backbone.dualstorage.js
+++ b/spec/backbone.dualstorage.js
@@ -307,10 +307,12 @@ as that.
 
   modelUpdatedWithResponse = function(model, response) {
     var modelClone;
-    modelClone = new model.constructor;
+    modelClone = new Backbone.Model;
+    modelClone.toJSON = _.bind(model.toJSON, model);
+    modelClone.parse = _.bind(model.parse, model);
     modelClone.idAttribute = model.idAttribute;
     modelClone.set(model.attributes);
-    modelClone.set(model.parse(response));
+    modelClone.set(modelClone.parse(response));
     return modelClone;
   };
 

From 974b60a66c3026489851ea9bb9fbbff242e7d23d Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Tue, 3 Jun 2014 11:07:07 +0200
Subject: [PATCH 05/10] Fix typo

---
 backbone.dualstorage.coffee | 4 ++--
 backbone.dualstorage.js     | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index bdab211..f0eec81 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -293,10 +293,10 @@ dualsync = (method, model, options) ->
 
             # parse the model using the parse method of the collection
             # can be used to adjust the schema of collection elements (not for a single element)
-            workingRespone = collection.parse(resp)
+            workingResponse = collection.parse(resp)
             idAttribute = collection.model.prototype.idAttribute
             localsync('clear', collection, options) unless options.add
-            for modelAttributes in workingRespone
+            for modelAttributes in workingResponse
               model = collection.get(modelAttributes[idAttribute])
               if model
                 responseModel = modelUpdatedWithResponse(model, modelAttributes)
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 9ca53e3..0dfed95 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -363,17 +363,17 @@ as that.
           return success(localsync(method, model, options));
         } else {
           options.success = function(resp, status, xhr) {
-            var collection, idAttribute, modelAttributes, responseModel, workingRespone, _i, _len;
+            var collection, idAttribute, modelAttributes, responseModel, workingResponse, _i, _len;
             resp = parseRemoteResponse(model, resp);
             if (model instanceof Backbone.Collection) {
               collection = model;
-              workingRespone = collection.parse(resp);
+              workingResponse = collection.parse(resp);
               idAttribute = collection.model.prototype.idAttribute;
               if (!options.add) {
                 localsync('clear', collection, options);
               }
-              for (_i = 0, _len = workingRespone.length; _i < _len; _i++) {
-                modelAttributes = workingRespone[_i];
+              for (_i = 0, _len = workingResponse.length; _i < _len; _i++) {
+                modelAttributes = workingResponse[_i];
                 model = collection.get(modelAttributes[idAttribute]);
                 if (model) {
                   responseModel = modelUpdatedWithResponse(model, modelAttributes);

From 733241d1d17ddef3ef8d9cb4093c69c17a431271 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Mon, 9 Jun 2014 13:56:06 +0200
Subject: [PATCH 06/10] Set the id silently when a model is created

---
 backbone.dualstorage.coffee  |  2 +-
 backbone.dualstorage.js      |  4 +++-
 spec/backbone.dualstorage.js | 12 +++++++-----
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index f0eec81..3369d35 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -107,7 +107,7 @@ class window.Store
   create: (model) ->
     if not _.isObject(model) then return model
     if not model.id
-      model.set model.idAttribute, @generateId()
+      model.set model.idAttribute, @generateId(), { silent: true }
     localStorage.setItem @name + @sep + model.id, JSON.stringify(model)
     @records.push model.id.toString()
     @save()
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 0dfed95..3d0662c 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -140,7 +140,9 @@ as that.
         return model;
       }
       if (!model.id) {
-        model.set(model.idAttribute, this.generateId());
+        model.set(model.idAttribute, this.generateId(), {
+          silent: true
+        });
       }
       localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
       this.records.push(model.id.toString());
diff --git a/spec/backbone.dualstorage.js b/spec/backbone.dualstorage.js
index 0c64f72..821681f 100644
--- a/spec/backbone.dualstorage.js
+++ b/spec/backbone.dualstorage.js
@@ -139,7 +139,9 @@ as that.
         return model;
       }
       if (!model.id) {
-        model.set(model.idAttribute, this.generateId());
+        model.set(model.idAttribute, this.generateId(), {
+          silent: true
+        });
       }
       localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
       this.records.push(model.id.toString());
@@ -362,17 +364,17 @@ as that.
           return success(localsync(method, model, options));
         } else {
           options.success = function(resp, status, xhr) {
-            var collection, idAttribute, modelAttributes, responseModel, workingRespone, _i, _len;
+            var collection, idAttribute, modelAttributes, responseModel, workingResponse, _i, _len;
             resp = parseRemoteResponse(model, resp);
             if (model instanceof Backbone.Collection) {
               collection = model;
-              workingRespone = collection.parse(resp);
+              workingResponse = collection.parse(resp);
               idAttribute = collection.model.prototype.idAttribute;
               if (!options.add) {
                 localsync('clear', collection, options);
               }
-              for (_i = 0, _len = workingRespone.length; _i < _len; _i++) {
-                modelAttributes = workingRespone[_i];
+              for (_i = 0, _len = workingResponse.length; _i < _len; _i++) {
+                modelAttributes = workingResponse[_i];
                 model = collection.get(modelAttributes[idAttribute]);
                 if (model) {
                   responseModel = modelUpdatedWithResponse(model, modelAttributes);

From 64468dcbbc13dc79299c60a1daf808b67ec46a2b Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Mon, 9 Jun 2014 14:11:55 +0200
Subject: [PATCH 07/10] Revert "Set the id silently when a model is created"

This reverts commit 733241d1d17ddef3ef8d9cb4093c69c17a431271.
---
 backbone.dualstorage.coffee  |  2 +-
 backbone.dualstorage.js      |  4 +---
 spec/backbone.dualstorage.js | 12 +++++-------
 3 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index 3369d35..f0eec81 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -107,7 +107,7 @@ class window.Store
   create: (model) ->
     if not _.isObject(model) then return model
     if not model.id
-      model.set model.idAttribute, @generateId(), { silent: true }
+      model.set model.idAttribute, @generateId()
     localStorage.setItem @name + @sep + model.id, JSON.stringify(model)
     @records.push model.id.toString()
     @save()
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 3d0662c..0dfed95 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -140,9 +140,7 @@ as that.
         return model;
       }
       if (!model.id) {
-        model.set(model.idAttribute, this.generateId(), {
-          silent: true
-        });
+        model.set(model.idAttribute, this.generateId());
       }
       localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
       this.records.push(model.id.toString());
diff --git a/spec/backbone.dualstorage.js b/spec/backbone.dualstorage.js
index 821681f..0c64f72 100644
--- a/spec/backbone.dualstorage.js
+++ b/spec/backbone.dualstorage.js
@@ -139,9 +139,7 @@ as that.
         return model;
       }
       if (!model.id) {
-        model.set(model.idAttribute, this.generateId(), {
-          silent: true
-        });
+        model.set(model.idAttribute, this.generateId());
       }
       localStorage.setItem(this.name + this.sep + model.id, JSON.stringify(model));
       this.records.push(model.id.toString());
@@ -364,17 +362,17 @@ as that.
           return success(localsync(method, model, options));
         } else {
           options.success = function(resp, status, xhr) {
-            var collection, idAttribute, modelAttributes, responseModel, workingResponse, _i, _len;
+            var collection, idAttribute, modelAttributes, responseModel, workingRespone, _i, _len;
             resp = parseRemoteResponse(model, resp);
             if (model instanceof Backbone.Collection) {
               collection = model;
-              workingResponse = collection.parse(resp);
+              workingRespone = collection.parse(resp);
               idAttribute = collection.model.prototype.idAttribute;
               if (!options.add) {
                 localsync('clear', collection, options);
               }
-              for (_i = 0, _len = workingResponse.length; _i < _len; _i++) {
-                modelAttributes = workingResponse[_i];
+              for (_i = 0, _len = workingRespone.length; _i < _len; _i++) {
+                modelAttributes = workingRespone[_i];
                 model = collection.get(modelAttributes[idAttribute]);
                 if (model) {
                   responseModel = modelUpdatedWithResponse(model, modelAttributes);

From 74e475329093ecede5a47d6973e1082df20141f0 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Sun, 22 Jun 2014 12:27:33 +0200
Subject: [PATCH 08/10] Fix for success callbacks that have not been invoked

---
 .gitignore                          |  1 +
 .idea/jsLinters/jshint.xml          | 66 +++++++++++++++++++++++++++++
 .idea/libraries/Generated_files.xml | 13 ++++++
 .idea/watcherTasks.xml              | 26 ++++++++++++
 backbone.dualstorage.coffee         |  1 +
 backbone.dualstorage.js             |  1 +
 spec/backbone.dualstorage.js        | 10 ++---
 spec/dualsync_spec.coffee           | 13 ++++++
 spec/dualsync_spec.js               | 14 ++++++
 9 files changed, 140 insertions(+), 5 deletions(-)
 create mode 100644 .idea/jsLinters/jshint.xml
 create mode 100644 .idea/libraries/Generated_files.xml
 create mode 100644 .idea/watcherTasks.xml

diff --git a/.gitignore b/.gitignore
index 537c277..dc87201 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .floo
 *map
+.idea*
\ No newline at end of file
diff --git a/.idea/jsLinters/jshint.xml b/.idea/jsLinters/jshint.xml
new file mode 100644
index 0000000..0273db3
--- /dev/null
+++ b/.idea/jsLinters/jshint.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JSHintConfiguration" version="2.4.4" use-config-file="true">
+    <option bitwise="true" />
+    <option camelcase="false" />
+    <option curly="true" />
+    <option eqeqeq="true" />
+    <option forin="true" />
+    <option immed="false" />
+    <option latedef="false" />
+    <option newcap="false" />
+    <option noarg="true" />
+    <option noempty="true" />
+    <option nonew="true" />
+    <option plusplus="false" />
+    <option regexp="false" />
+    <option undef="true" />
+    <option unused="false" />
+    <option strict="true" />
+    <option trailing="false" />
+    <option asi="false" />
+    <option boss="false" />
+    <option debug="false" />
+    <option eqnull="false" />
+    <option es5="false" />
+    <option esnext="false" />
+    <option evil="false" />
+    <option expr="false" />
+    <option funcscope="false" />
+    <option globalstrict="false" />
+    <option iterator="false" />
+    <option lastsemic="false" />
+    <option laxbreak="false" />
+    <option laxcomma="false" />
+    <option loopfunc="false" />
+    <option multistr="false" />
+    <option proto="false" />
+    <option onecase="false" />
+    <option regexdash="false" />
+    <option scripturl="false" />
+    <option smarttabs="false" />
+    <option shadow="false" />
+    <option sub="false" />
+    <option supernew="false" />
+    <option validthis="false" />
+    <option browser="true" />
+    <option couch="false" />
+    <option devel="false" />
+    <option dojo="false" />
+    <option jquery="false" />
+    <option mootools="false" />
+    <option node="false" />
+    <option nonstandard="false" />
+    <option prototypejs="false" />
+    <option rhino="false" />
+    <option worker="false" />
+    <option wsh="false" />
+    <option yui="false" />
+    <option nomen="false" />
+    <option onevar="false" />
+    <option passfail="false" />
+    <option white="false" />
+    <option maxerr="50" />
+  </component>
+</project>
+
diff --git a/.idea/libraries/Generated_files.xml b/.idea/libraries/Generated_files.xml
new file mode 100644
index 0000000..af6ac59
--- /dev/null
+++ b/.idea/libraries/Generated_files.xml
@@ -0,0 +1,13 @@
+<component name="libraryTable">
+  <library name="Generated files" type="javaScript">
+    <properties>
+      <sourceFilesUrls>
+        <item url="file://$PROJECT_DIR$/spec/dualsync_spec.js" />
+      </sourceFilesUrls>
+    </properties>
+    <CLASSES>
+      <root url="file://$PROJECT_DIR$/spec/dualsync_spec.js" />
+    </CLASSES>
+    <SOURCES />
+  </library>
+</component>
\ No newline at end of file
diff --git a/.idea/watcherTasks.xml b/.idea/watcherTasks.xml
new file mode 100644
index 0000000..db232d9
--- /dev/null
+++ b/.idea/watcherTasks.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectTasksOptions">
+    <TaskOptions isEnabled="true">
+      <option name="arguments" value="--map --compile $FileName$" />
+      <option name="checkSyntaxErrors" value="true" />
+      <option name="description" value="Compiles .coffee files into .js files" />
+      <option name="exitCodeBehavior" value="ERROR" />
+      <option name="fileExtension" value="coffee" />
+      <option name="immediateSync" value="true" />
+      <option name="name" value="CoffeeScript" />
+      <option name="output" value="$FileNameWithoutExtension$.js:$FileNameWithoutExtension$.map" />
+      <option name="outputFilters">
+        <array />
+      </option>
+      <option name="outputFromStdout" value="false" />
+      <option name="passParentEnvs" value="true" />
+      <option name="program" value="C:\Users\rem\AppData\Roaming\npm\coffee.cmd" />
+      <option name="scopeName" value="Project Files" />
+      <option name="trackOnlyRoot" value="true" />
+      <option name="workingDir" value="$FileDir$" />
+      <envs />
+    </TaskOptions>
+  </component>
+</project>
+
diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index f0eec81..4984859 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -352,6 +352,7 @@ dualsync = (method, model, options) ->
 
     when 'delete'
       if model.hasTempId()
+        options.ignoreCallbacks = false
         localsync(method, model, options)
       else
         options.success = (resp, status, xhr) ->
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index 0dfed95..c8538d1 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -445,6 +445,7 @@ as that.
         break;
       case 'delete':
         if (model.hasTempId()) {
+          options.ignoreCallbacks = false;
           return localsync(method, model, options);
         } else {
           options.success = function(resp, status, xhr) {
diff --git a/spec/backbone.dualstorage.js b/spec/backbone.dualstorage.js
index 0c64f72..bda166c 100644
--- a/spec/backbone.dualstorage.js
+++ b/spec/backbone.dualstorage.js
@@ -362,17 +362,17 @@ as that.
           return success(localsync(method, model, options));
         } else {
           options.success = function(resp, status, xhr) {
-            var collection, idAttribute, modelAttributes, responseModel, workingRespone, _i, _len;
+            var collection, idAttribute, modelAttributes, responseModel, workingResponse, _i, _len;
             resp = parseRemoteResponse(model, resp);
             if (model instanceof Backbone.Collection) {
               collection = model;
-              workingRespone = collection.parse(resp);
+              workingResponse = collection.parse(resp);
               idAttribute = collection.model.prototype.idAttribute;
               if (!options.add) {
                 localsync('clear', collection, options);
               }
-              for (_i = 0, _len = workingRespone.length; _i < _len; _i++) {
-                modelAttributes = workingRespone[_i];
+              for (_i = 0, _len = workingResponse.length; _i < _len; _i++) {
+                modelAttributes = workingResponse[_i];
                 model = collection.get(modelAttributes[idAttribute]);
                 if (model) {
                   responseModel = modelUpdatedWithResponse(model, modelAttributes);
@@ -444,6 +444,7 @@ as that.
         break;
       case 'delete':
         if (model.hasTempId()) {
+          options.ignoreCallbacks = false;
           return localsync(method, model, options);
         } else {
           options.success = function(resp, status, xhr) {
@@ -460,5 +461,4 @@ as that.
 
   Backbone.sync = dualsync;
 
-
 //# sourceMappingURL=backbone.dualstorage.map
diff --git a/spec/dualsync_spec.coffee b/spec/dualsync_spec.coffee
index d5b5e60..ecbf8d9 100644
--- a/spec/dualsync_spec.coffee
+++ b/spec/dualsync_spec.coffee
@@ -344,6 +344,19 @@ describe 'when to call user-specified success and error callbacks', ->
       dualsync('create', model, error: (-> ready = true), errorStatus: 500)
     waitsFor (-> ready), "The error callback should have been called", 100
 
+  it 'when a model with a temp id has been destroyed', ->
+    modelWithTempId = new collection.model();
+    modelWithTempId.url = "http://test.ch/";
+
+    modelWithTempId.save({}, { remote: false });
+    spyOnLocalsync();
+
+    successSpy = jasmine.createSpy("successHandler");
+
+    modelWithTempId.destroy({ success: successSpy });
+
+    expect(successSpy).toHaveBeenCalled();
+
   describe 'when offline', ->
     it 'uses the error callback if no existing local store is found', ->
       ready = false
diff --git a/spec/dualsync_spec.js b/spec/dualsync_spec.js
index eac1d7d..81275bd 100644
--- a/spec/dualsync_spec.js
+++ b/spec/dualsync_spec.js
@@ -675,6 +675,20 @@
         return ready;
       }), "The error callback should have been called", 100);
     });
+    it('when a model with a temp id has been destroyed', function() {
+      var modelWithTempId, successSpy;
+      modelWithTempId = new collection.model();
+      modelWithTempId.url = "http://test.ch/";
+      modelWithTempId.save({}, {
+        remote: false
+      });
+      spyOnLocalsync();
+      successSpy = jasmine.createSpy("successHandler");
+      modelWithTempId.destroy({
+        success: successSpy
+      });
+      return expect(successSpy).toHaveBeenCalled();
+    });
     return describe('when offline', function() {
       it('uses the error callback if no existing local store is found', function() {
         var ready;

From 3ca7dc0cacdbfb439f07e19008f361b205929c91 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Sun, 22 Jun 2014 12:28:02 +0200
Subject: [PATCH 09/10] Delete idea files

---
 .idea/jsLinters/jshint.xml          | 66 -----------------------------
 .idea/libraries/Generated_files.xml | 13 ------
 .idea/watcherTasks.xml              | 26 ------------
 3 files changed, 105 deletions(-)
 delete mode 100644 .idea/jsLinters/jshint.xml
 delete mode 100644 .idea/libraries/Generated_files.xml
 delete mode 100644 .idea/watcherTasks.xml

diff --git a/.idea/jsLinters/jshint.xml b/.idea/jsLinters/jshint.xml
deleted file mode 100644
index 0273db3..0000000
--- a/.idea/jsLinters/jshint.xml
+++ /dev/null
@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JSHintConfiguration" version="2.4.4" use-config-file="true">
-    <option bitwise="true" />
-    <option camelcase="false" />
-    <option curly="true" />
-    <option eqeqeq="true" />
-    <option forin="true" />
-    <option immed="false" />
-    <option latedef="false" />
-    <option newcap="false" />
-    <option noarg="true" />
-    <option noempty="true" />
-    <option nonew="true" />
-    <option plusplus="false" />
-    <option regexp="false" />
-    <option undef="true" />
-    <option unused="false" />
-    <option strict="true" />
-    <option trailing="false" />
-    <option asi="false" />
-    <option boss="false" />
-    <option debug="false" />
-    <option eqnull="false" />
-    <option es5="false" />
-    <option esnext="false" />
-    <option evil="false" />
-    <option expr="false" />
-    <option funcscope="false" />
-    <option globalstrict="false" />
-    <option iterator="false" />
-    <option lastsemic="false" />
-    <option laxbreak="false" />
-    <option laxcomma="false" />
-    <option loopfunc="false" />
-    <option multistr="false" />
-    <option proto="false" />
-    <option onecase="false" />
-    <option regexdash="false" />
-    <option scripturl="false" />
-    <option smarttabs="false" />
-    <option shadow="false" />
-    <option sub="false" />
-    <option supernew="false" />
-    <option validthis="false" />
-    <option browser="true" />
-    <option couch="false" />
-    <option devel="false" />
-    <option dojo="false" />
-    <option jquery="false" />
-    <option mootools="false" />
-    <option node="false" />
-    <option nonstandard="false" />
-    <option prototypejs="false" />
-    <option rhino="false" />
-    <option worker="false" />
-    <option wsh="false" />
-    <option yui="false" />
-    <option nomen="false" />
-    <option onevar="false" />
-    <option passfail="false" />
-    <option white="false" />
-    <option maxerr="50" />
-  </component>
-</project>
-
diff --git a/.idea/libraries/Generated_files.xml b/.idea/libraries/Generated_files.xml
deleted file mode 100644
index af6ac59..0000000
--- a/.idea/libraries/Generated_files.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<component name="libraryTable">
-  <library name="Generated files" type="javaScript">
-    <properties>
-      <sourceFilesUrls>
-        <item url="file://$PROJECT_DIR$/spec/dualsync_spec.js" />
-      </sourceFilesUrls>
-    </properties>
-    <CLASSES>
-      <root url="file://$PROJECT_DIR$/spec/dualsync_spec.js" />
-    </CLASSES>
-    <SOURCES />
-  </library>
-</component>
\ No newline at end of file
diff --git a/.idea/watcherTasks.xml b/.idea/watcherTasks.xml
deleted file mode 100644
index db232d9..0000000
--- a/.idea/watcherTasks.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectTasksOptions">
-    <TaskOptions isEnabled="true">
-      <option name="arguments" value="--map --compile $FileName$" />
-      <option name="checkSyntaxErrors" value="true" />
-      <option name="description" value="Compiles .coffee files into .js files" />
-      <option name="exitCodeBehavior" value="ERROR" />
-      <option name="fileExtension" value="coffee" />
-      <option name="immediateSync" value="true" />
-      <option name="name" value="CoffeeScript" />
-      <option name="output" value="$FileNameWithoutExtension$.js:$FileNameWithoutExtension$.map" />
-      <option name="outputFilters">
-        <array />
-      </option>
-      <option name="outputFromStdout" value="false" />
-      <option name="passParentEnvs" value="true" />
-      <option name="program" value="C:\Users\rem\AppData\Roaming\npm\coffee.cmd" />
-      <option name="scopeName" value="Project Files" />
-      <option name="trackOnlyRoot" value="true" />
-      <option name="workingDir" value="$FileDir$" />
-      <envs />
-    </TaskOptions>
-  </component>
-</project>
-

From 836646dbcda4c1495fb5441c0d4e341a32feb6c1 Mon Sep 17 00:00:00 2001
From: Micha Reiser <micha.reiser@kwsoft.ch>
Date: Sun, 22 Jun 2014 14:53:10 +0200
Subject: [PATCH 10/10] Merge fix for destroyed models with tem pid

---
 backbone.dualstorage.coffee | 2 +-
 backbone.dualstorage.js     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/backbone.dualstorage.coffee b/backbone.dualstorage.coffee
index 4984859..5b8e310 100644
--- a/backbone.dualstorage.coffee
+++ b/backbone.dualstorage.coffee
@@ -205,7 +205,7 @@ localsync = (method, model, options) ->
         store.clean(model, 'dirty')
     when 'delete'
       store.destroy(model)
-      if options.dirty
+      if options.dirty && !model.hasTempId()  
         store.destroyed(model)
       else
         if model.id.toString().length == 36
diff --git a/backbone.dualstorage.js b/backbone.dualstorage.js
index c8538d1..72df717 100644
--- a/backbone.dualstorage.js
+++ b/backbone.dualstorage.js
@@ -274,7 +274,7 @@ as that.
           break;
         case 'delete':
           store.destroy(model);
-          if (options.dirty) {
+          if (options.dirty && !model.hasTempId()) {
             return store.destroyed(model);
           } else {
             if (model.id.toString().length === 36) {