| Backbone.sync = function(method, model, options) { |
| |
| // we need to make sure we initialize a store, in this case |
| // we will just use a JS object. |
| var cache = {}; |
| |
| // The size will be primarily used to assign ids to newly |
| // created models. Each time a new model is created, the size |
| // will be incremented. |
| var size = 0; |
| |
| // since we need to create a store for the models/collections |
| // we are actually going to invoke the outer function which will |
| // return this function below as the Backbone.sync that will |
| // actually be used. |
| return function(method, model, options) { |
| |
| // create a new deferred object. standard sync returns the $.ajax |
| // request, which internally returns a deferred. It's important to |
| // do this so that people can chain on fetch using the standard .then/.fail |
| // syntax, rather than just the success/error callbacks. |
| var deferred = $.Deferred(); |
| |
| // when creating a new model... |
| if (method === "create") { |
| |
| // first assign it an id. The server would traditionally do this. |
| model.id = size; |
| // store it in our cache |
| cache[model.id] = model; |
| // make sure we increment the number of models we now have. |
| size += 1; |
| |
| // if a success callback was provided, execute it. |
| if (options.success) { |
| options.success(model, model.toJSON(), options); |
| } |
| |
| // resolve the deferred. |
| deferred.resolve(model); |
| |
| // we are updating a model |
| } else if (method === "update") { |
| |
| // as long as the model actually exists in our store |
| if (cache[model.id]) { |
| |
| // overwrite what is currently in the store with this model. |
| cache[model.id] = model; |
| |
| // if a success callback was provided, execute it. |
| if (options.success) { |
| options.success(model, model.toJSON(), options); |
| } |
| |
| deferred.resolve(model); |
| |
| // if this model doesn't exist yet, we can't update it |
| } else { |
| |
| if (options.error) { |
| options.error(model, "Model not found"); |
| } |
| deferred.reject(model); |
| } |
| |
| // if we're trying to read a model... |
| } else if (method === "read") { |
| |
| // as long as it exists |
| if (cache[model.id]) { |
| |
| // if a success callback was provided, execute it. |
| if (options.success) { |
| options.success(model, cache[model.id].toJSON(), options); |
| } |
| |
| // resolve |
| deferred.resolve(model); |
| } else { |
| if (options.error) { |
| options.error(model, "Model not found"); |
| } |
| deferred.reject(model); |
| } |
| |
| // if we're deleting a model... |
| } else if (method === "delete") { |
| |
| // first make sure it exists in the cache |
| if (cache[model.id]) { |
| |
| // then remove it from the cache |
| delete cache[model.id]; |
| |
| // and trigger the success callback. Note we're passing an |
| // empty object as the second argument, because a deletion |
| // would result in an empty return from the server. |
| if (options.success) { |
| options.success(model, {}, options); |
| } |
| |
| // resolve the deferred |
| deferred.resolve(model); |
| |
| // otherwise, error that the model doesn't exist. |
| } else { |
| if (options.error) { |
| options.error(model, "Model not found"); |
| } |
| deferred.reject(model); |
| } |
| } |
| |
| return deferred.promise(); |
| } |
| |
| }(); |