From 1eb638d3b9d28f27f518cc4c8aba55c9fbc53fa3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Arild=20M=C3=A6land?= Date: Tue, 31 Jan 2012 14:02:25 +0100 Subject: [PATCH 1/3] Upgraded to Backbone 0.9 --- vendor/assets/javascripts/backbone.js | 854 ++++++++++++++------------ 1 file changed, 476 insertions(+), 378 deletions(-) diff --git a/vendor/assets/javascripts/backbone.js b/vendor/assets/javascripts/backbone.js index b2e4932..e0358a6 100644 --- a/vendor/assets/javascripts/backbone.js +++ b/vendor/assets/javascripts/backbone.js @@ -1,20 +1,26 @@ -// Backbone.js 0.5.3 -// (c) 2010 Jeremy Ashkenas, DocumentCloud Inc. +// Backbone.js 0.9.0 +// (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc. // Backbone may be freely distributed under the MIT license. // For all details and documentation: -// http://documentcloud.github.com/backbone +// http://backbonejs.org (function(){ // Initial Setup // ------------- - // Save a reference to the global object. + // Save a reference to the global object (`window` in the browser, `global` + // on the server). var root = this; - // Save the previous value of the `Backbone` variable. + // Save the previous value of the `Backbone` variable, so that it can be + // restored later on, if `noConflict` is used. var previousBackbone = root.Backbone; + // Create a local reference to slice/splice. + var slice = Array.prototype.slice; + var splice = Array.prototype.splice; + // The top-level namespace. All public Backbone classes and modules will // be attached to this. Exported for both CommonJS and the browser. var Backbone; @@ -25,14 +31,14 @@ } // Current version of the library. Keep in sync with `package.json`. - Backbone.VERSION = '0.5.3'; + Backbone.VERSION = '0.9.0'; // Require Underscore, if we're on the server, and it's not already present. var _ = root._; - if (!_ && (typeof require !== 'undefined')) _ = require('underscore')._; + if (!_ && (typeof require !== 'undefined')) _ = require('underscore'); - // For Backbone's purposes, jQuery or Zepto owns the `$` variable. - var $ = root.jQuery || root.Zepto; + // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable. + var $ = root.jQuery || root.Zepto || root.ender; // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable // to its previous owner. Returns a reference to this Backbone object. @@ -41,9 +47,9 @@ return this; }; - // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option will - // fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and set a - // `X-Http-Method-Override` header. + // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option + // will fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and + // set a `X-Http-Method-Override` header. Backbone.emulateHTTP = false; // Turn on `emulateJSON` to support legacy servers that can't deal with direct @@ -56,43 +62,53 @@ // ----------------- // A module that can be mixed in to *any object* in order to provide it with - // custom events. You may `bind` or `unbind` a callback function to an event; - // `trigger`-ing an event fires all callbacks in succession. + // custom events. You may bind with `on` or remove with `off` callback functions + // to an event; trigger`-ing an event fires all callbacks in succession. // // var object = {}; // _.extend(object, Backbone.Events); - // object.bind('expand', function(){ alert('expanded'); }); + // object.on('expand', function(){ alert('expanded'); }); // object.trigger('expand'); // Backbone.Events = { - // Bind an event, specified by a string name, `ev`, to a `callback` function. - // Passing `"all"` will bind the callback to all events fired. - bind : function(ev, callback, context) { + // Bind an event, specified by a string name, `ev`, to a `callback` + // function. Passing `"all"` will bind the callback to all events fired. + on: function(events, callback, context) { + var ev; + events = events.split(/\s+/); var calls = this._callbacks || (this._callbacks = {}); - var list = calls[ev] || (calls[ev] = []); - list.push([callback, context]); + while (ev = events.shift()) { + // Create an immutable callback list, allowing traversal during + // modification. The tail is an empty object that will always be used + // as the next node. + var list = calls[ev] || (calls[ev] = {}); + var tail = list.tail || (list.tail = list.next = {}); + tail.callback = callback; + tail.context = context; + list.tail = tail.next = {}; + } return this; }, - // Remove one or many callbacks. If `callback` is null, removes all - // callbacks for the event. If `ev` is null, removes all bound callbacks - // for all events. - unbind : function(ev, callback) { - var calls; - if (!ev) { - this._callbacks = {}; + // Remove one or many callbacks. If `context` is null, removes all callbacks + // with that function. If `callback` is null, removes all callbacks for the + // event. If `ev` is null, removes all bound callbacks for all events. + off: function(events, callback, context) { + var ev, calls, node; + if (!events) { + delete this._callbacks; } else if (calls = this._callbacks) { - if (!callback) { - calls[ev] = []; - } else { - var list = calls[ev]; - if (!list) return this; - for (var i = 0, l = list.length; i < l; i++) { - if (list[i] && callback === list[i][0]) { - list[i] = null; - break; - } + events = events.split(/\s+/); + while (ev = events.shift()) { + node = calls[ev]; + delete calls[ev]; + if (!callback || !node) continue; + // Create a new list, omitting the indicated event/context pairs. + while ((node = node.next) && node.next) { + if (node.callback === callback && + (!context || node.context === context)) continue; + this.on(ev, node.callback, node.context); } } } @@ -102,21 +118,24 @@ // Trigger an event, firing all bound callbacks. Callbacks are passed the // same arguments as `trigger` is, apart from the event name. // Listening for `"all"` passes the true event name as the first argument. - trigger : function(eventName) { - var list, calls, ev, callback, args; - var both = 2; + trigger: function(events) { + var event, node, calls, tail, args, all, rest; if (!(calls = this._callbacks)) return this; - while (both--) { - ev = both ? eventName : 'all'; - if (list = calls[ev]) { - for (var i = 0, l = list.length; i < l; i++) { - if (!(callback = list[i])) { - list.splice(i, 1); i--; l--; - } else { - args = both ? Array.prototype.slice.call(arguments, 1) : arguments; - callback[0].apply(callback[1] || this, args); - } - } + all = calls['all']; + (events = events.split(/\s+/)).push(null); + // Save references to the current heads & tails. + while (event = events.shift()) { + if (all) events.push({next: all.next, tail: all.tail, event: event}); + if (!(node = calls[event])) continue; + events.push({next: node.next, tail: node.tail}); + } + // Traverse each list, stopping when the saved tail is reached. + rest = slice.call(arguments, 1); + while (node = events.pop()) { + tail = node.tail; + args = node.event ? [node.event].concat(rest) : rest; + while ((node = node.next) !== tail) { + node.callback.apply(node.context || this, args); } } return this; @@ -124,6 +143,10 @@ }; + // Aliases for backwards compatibility. + Backbone.Events.bind = Backbone.Events.on; + Backbone.Events.unbind = Backbone.Events.off; + // Backbone.Model // -------------- @@ -132,269 +155,274 @@ Backbone.Model = function(attributes, options) { var defaults; attributes || (attributes = {}); - if (defaults = this.defaults) { - if (_.isFunction(defaults)) defaults = defaults.call(this); + if (options && options.parse) attributes = this.parse(attributes); + if (defaults = getValue(this, 'defaults')) { attributes = _.extend({}, defaults, attributes); } + if (options && options.collection) this.collection = options.collection; this.attributes = {}; this._escapedAttributes = {}; this.cid = _.uniqueId('c'); - this.set(attributes, {silent : true}); - this._changed = false; + this._changed = {}; + if (!this.set(attributes, {silent: true})) { + throw new Error("Can't create an invalid model"); + } + this._changed = {}; this._previousAttributes = _.clone(this.attributes); - if (options && options.collection) this.collection = options.collection; - this.initialize(attributes, options); + this.initialize.apply(this, arguments); }; // Attach all inheritable methods to the Model prototype. _.extend(Backbone.Model.prototype, Backbone.Events, { - // A snapshot of the model's previous attributes, taken immediately - // after the last `"change"` event was fired. - _previousAttributes : null, - - // Has the item been changed since the last `"change"` event? - _changed : false, - // The default name for the JSON `id` attribute is `"id"`. MongoDB and // CouchDB users may want to set this to `"_id"`. - idAttribute : 'id', + idAttribute: 'id', // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function(){}, // Return a copy of the model's `attributes` object. - toJSON : function() { + toJSON: function() { return _.clone(this.attributes); }, // Get the value of an attribute. - get : function(attr) { + get: function(attr) { return this.attributes[attr]; }, // Get the HTML-escaped value of an attribute. - escape : function(attr) { + escape: function(attr) { var html; if (html = this._escapedAttributes[attr]) return html; var val = this.attributes[attr]; - return this._escapedAttributes[attr] = escapeHTML(val == null ? '' : '' + val); + return this._escapedAttributes[attr] = _.escape(val == null ? '' : '' + val); }, // Returns `true` if the attribute contains a value that is not null // or undefined. - has : function(attr) { + has: function(attr) { return this.attributes[attr] != null; }, - // Set a hash of model attributes on the object, firing `"change"` unless you - // choose to silence it. - set : function(attrs, options) { + // Set a hash of model attributes on the object, firing `"change"` unless + // you choose to silence it. + set: function(key, value, options) { + var attrs, attr, val; + if (_.isObject(key) || key == null) { + attrs = key; + options = value; + } else { + attrs = {}; + attrs[key] = value; + } // Extract attributes and options. options || (options = {}); if (!attrs) return this; - if (attrs.attributes) attrs = attrs.attributes; - var now = this.attributes, escaped = this._escapedAttributes; + if (attrs instanceof Backbone.Model) attrs = attrs.attributes; + if (options.unset) for (var attr in attrs) attrs[attr] = void 0; // Run validation. - if (!options.silent && this.validate && !this._performValidation(attrs, options)) return false; + if (this.validate && !this._performValidation(attrs, options)) return false; // Check for changes of `id`. if (this.idAttribute in attrs) this.id = attrs[this.idAttribute]; - // We're about to start triggering change events. + var now = this.attributes; + var escaped = this._escapedAttributes; + var prev = this._previousAttributes || {}; var alreadyChanging = this._changing; this._changing = true; // Update attributes. - for (var attr in attrs) { - var val = attrs[attr]; - if (!_.isEqual(now[attr], val)) { - now[attr] = val; - delete escaped[attr]; - this._changed = true; - if (!options.silent) this.trigger('change:' + attr, this, val, options); + for (attr in attrs) { + val = attrs[attr]; + if (!_.isEqual(now[attr], val)) delete escaped[attr]; + options.unset ? delete now[attr] : now[attr] = val; + delete this._changed[attr]; + if (!_.isEqual(prev[attr], val) || (_.has(now, attr) != _.has(prev, attr))) { + this._changed[attr] = val; } } - // Fire the `"change"` event, if the model has been changed. - if (!alreadyChanging && !options.silent && this._changed) this.change(options); - this._changing = false; + // Fire the `"change"` events, if the model has been changed. + if (!alreadyChanging) { + if (!options.silent && this.hasChanged()) this.change(options); + this._changing = false; + } return this; }, // Remove an attribute from the model, firing `"change"` unless you choose // to silence it. `unset` is a noop if the attribute doesn't exist. - unset : function(attr, options) { - if (!(attr in this.attributes)) return this; - options || (options = {}); - var value = this.attributes[attr]; - - // Run validation. - var validObj = {}; - validObj[attr] = void 0; - if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false; - - // Remove the attribute. - delete this.attributes[attr]; - delete this._escapedAttributes[attr]; - if (attr == this.idAttribute) delete this.id; - this._changed = true; - if (!options.silent) { - this.trigger('change:' + attr, this, void 0, options); - this.change(options); - } - return this; + unset: function(attr, options) { + (options || (options = {})).unset = true; + return this.set(attr, null, options); }, // Clear all attributes on the model, firing `"change"` unless you choose // to silence it. - clear : function(options) { - options || (options = {}); - var attr; - var old = this.attributes; - - // Run validation. - var validObj = {}; - for (attr in old) validObj[attr] = void 0; - if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false; - - this.attributes = {}; - this._escapedAttributes = {}; - this._changed = true; - if (!options.silent) { - for (attr in old) { - this.trigger('change:' + attr, this, void 0, options); - } - this.change(options); - } - return this; + clear: function(options) { + (options || (options = {})).unset = true; + return this.set(_.clone(this.attributes), options); }, // Fetch the model from the server. If the server's representation of the // model differs from its current attributes, they will be overriden, // triggering a `"change"` event. - fetch : function(options) { - options || (options = {}); + fetch: function(options) { + options = options ? _.clone(options) : {}; var model = this; var success = options.success; options.success = function(resp, status, xhr) { if (!model.set(model.parse(resp, xhr), options)) return false; if (success) success(model, resp); }; - options.error = wrapError(options.error, model, options); + options.error = Backbone.wrapError(options.error, model, options); return (this.sync || Backbone.sync).call(this, 'read', this, options); }, // Set a hash of model attributes, and sync the model to the server. // If the server returns an attributes hash that differs, the model's // state will be `set` again. - save : function(attrs, options) { - options || (options = {}); - if (attrs && !this.set(attrs, options)) return false; + save: function(key, value, options) { + var attrs; + if (_.isObject(key) || key == null) { + attrs = key; + options = value; + } else { + attrs = {}; + attrs[key] = value; + } + + options = options ? _.clone(options) : {}; + if (attrs && !this[options.wait ? '_performValidation' : 'set'](attrs, options)) return false; var model = this; var success = options.success; options.success = function(resp, status, xhr) { - if (!model.set(model.parse(resp, xhr), options)) return false; - if (success) success(model, resp, xhr); + var serverAttrs = model.parse(resp, xhr); + if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs); + if (!model.set(serverAttrs, options)) return false; + if (success) { + success(model, resp); + } else { + model.trigger('sync', model, resp, options); + } }; - options.error = wrapError(options.error, model, options); + options.error = Backbone.wrapError(options.error, model, options); var method = this.isNew() ? 'create' : 'update'; return (this.sync || Backbone.sync).call(this, method, this, options); }, - // Destroy this model on the server if it was already persisted. Upon success, the model is removed - // from its collection, if it has one. - destroy : function(options) { - options || (options = {}); - if (this.isNew()) return this.trigger('destroy', this, this.collection, options); + // Destroy this model on the server if it was already persisted. + // Optimistically removes the model from its collection, if it has one. + // If `wait: true` is passed, waits for the server to respond before removal. + destroy: function(options) { + options = options ? _.clone(options) : {}; var model = this; var success = options.success; - options.success = function(resp) { + + var triggerDestroy = function() { model.trigger('destroy', model, model.collection, options); - if (success) success(model, resp); }; - options.error = wrapError(options.error, model, options); - return (this.sync || Backbone.sync).call(this, 'delete', this, options); + + if (this.isNew()) return triggerDestroy(); + options.success = function(resp) { + if (options.wait) triggerDestroy(); + if (success) { + success(model, resp); + } else { + model.trigger('sync', model, resp, options); + } + }; + options.error = Backbone.wrapError(options.error, model, options); + var xhr = (this.sync || Backbone.sync).call(this, 'delete', this, options); + if (!options.wait) triggerDestroy(); + return xhr; }, // Default URL for the model's representation on the server -- if you're // using Backbone's restful methods, override this to change the endpoint // that will be called. - url : function() { - var base = getUrl(this.collection) || this.urlRoot || urlError(); + url: function() { + var base = getValue(this.collection, 'url') || getValue(this, 'urlRoot') || urlError(); if (this.isNew()) return base; return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + encodeURIComponent(this.id); }, // **parse** converts a response into the hash of attributes to be `set` on // the model. The default implementation is just to pass the response along. - parse : function(resp, xhr) { + parse: function(resp, xhr) { return resp; }, // Create a new model with identical attributes to this one. - clone : function() { - return new this.constructor(this); + clone: function() { + return new this.constructor(this.attributes); }, // A model is new if it has never been saved to the server, and lacks an id. - isNew : function() { + isNew: function() { return this.id == null; }, - // Call this method to manually fire a `change` event for this model. + // Call this method to manually fire a `"change"` event for this model and + // a `"change:attribute"` event for each changed attribute. // Calling this will cause all objects observing the model to update. - change : function(options) { + change: function(options) { + for (var attr in this._changed) { + this.trigger('change:' + attr, this, this._changed[attr], options); + } this.trigger('change', this, options); this._previousAttributes = _.clone(this.attributes); - this._changed = false; + this._changed = {}; }, // Determine if the model has changed since the last `"change"` event. // If you specify an attribute name, determine if that attribute has changed. - hasChanged : function(attr) { - if (attr) return this._previousAttributes[attr] != this.attributes[attr]; - return this._changed; + hasChanged: function(attr) { + if (attr) return _.has(this._changed, attr); + return !_.isEmpty(this._changed); }, - // Return an object containing all the attributes that have changed, or false - // if there are no changed attributes. Useful for determining what parts of a - // view need to be updated and/or what attributes need to be persisted to - // the server. - changedAttributes : function(now) { - now || (now = this.attributes); - var old = this._previousAttributes; - var changed = false; - for (var attr in now) { - if (!_.isEqual(old[attr], now[attr])) { - changed = changed || {}; - changed[attr] = now[attr]; - } + // Return an object containing all the attributes that have changed, or + // false if there are no changed attributes. Useful for determining what + // parts of a view need to be updated and/or what attributes need to be + // persisted to the server. Unset attributes will be set to undefined. + // You can also pass an attributes object to diff against the model, + // determining if there *would be* a change. + changedAttributes: function(diff) { + if (!diff) return this.hasChanged() ? _.clone(this._changed) : false; + var val, changed = false, old = this._previousAttributes; + for (var attr in diff) { + if (_.isEqual(old[attr], (val = diff[attr]))) continue; + (changed || (changed = {}))[attr] = val; } return changed; }, // Get the previous value of an attribute, recorded at the time the last // `"change"` event was fired. - previous : function(attr) { + previous: function(attr) { if (!attr || !this._previousAttributes) return null; return this._previousAttributes[attr]; }, // Get all of the attributes of the model at the time of the previous // `"change"` event. - previousAttributes : function() { + previousAttributes: function() { return _.clone(this._previousAttributes); }, // Run validation against a set of incoming attributes, returning `true` // if all is well. If a specific `error` callback has been passed, // call that instead of firing the general `"error"` event. - _performValidation : function(attrs, options) { - var error = this.validate(attrs); + _performValidation: function(attrs, options) { + var newAttrs = _.extend({}, this.attributes, attrs); + var error = this.validate(newAttrs, options); if (error) { if (options.error) { options.error(this, error, options); @@ -417,10 +445,9 @@ Backbone.Collection = function(models, options) { options || (options = {}); if (options.comparator) this.comparator = options.comparator; - _.bindAll(this, '_onModelEvent', '_removeReference'); this._reset(); - if (models) this.reset(models, {silent: true}); this.initialize.apply(this, arguments); + if (models) this.reset(models, {silent: true, parse: options.parse}); }; // Define the Collection's inheritable methods. @@ -428,52 +455,92 @@ // The default model for a collection is just a **Backbone.Model**. // This should be overridden in most cases. - model : Backbone.Model, + model: Backbone.Model, // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function(){}, // The JSON representation of a Collection is an array of the // models' attributes. - toJSON : function() { + toJSON: function() { return this.map(function(model){ return model.toJSON(); }); }, // Add a model, or list of models to the set. Pass **silent** to avoid - // firing the `added` event for every new model. - add : function(models, options) { - if (_.isArray(models)) { - for (var i = 0, l = models.length; i < l; i++) { - this._add(models[i], options); + // firing the `add` event for every new model. + add: function(models, options) { + var i, index, length, model, cid, id, cids = {}, ids = {}; + options || (options = {}); + models = _.isArray(models) ? models.slice() : [models]; + + // Begin by turning bare objects into model references, and preventing + // invalid models or duplicate models from being added. + for (i = 0, length = models.length; i < length; i++) { + if (!(model = models[i] = this._prepareModel(models[i], options))) { + throw new Error("Can't add an invalid model to a collection"); } - } else { - this._add(models, options); + if (cids[cid = model.cid] || this._byCid[cid] || + (((id = model.id) != null) && (ids[id] || this._byId[id]))) { + throw new Error("Can't add the same model to a collection twice"); + } + cids[cid] = ids[id] = model; + } + + // Listen to added models' events, and index models for lookup by + // `id` and by `cid`. + for (i = 0; i < length; i++) { + (model = models[i]).on('all', this._onModelEvent, this); + this._byCid[model.cid] = model; + if (model.id != null) this._byId[model.id] = model; + } + + // Insert models into the collection, re-sorting if needed, and triggering + // `add` events unless silenced. + this.length += length; + index = options.at != null ? options.at : this.models.length; + splice.apply(this.models, [index, 0].concat(models)); + if (this.comparator) this.sort({silent: true}); + if (options.silent) return this; + for (i = 0, length = this.models.length; i < length; i++) { + if (!cids[(model = this.models[i]).cid]) continue; + options.index = i; + model.trigger('add', model, this, options); } return this; }, // Remove a model, or a list of models from the set. Pass silent to avoid - // firing the `removed` event for every model removed. - remove : function(models, options) { - if (_.isArray(models)) { - for (var i = 0, l = models.length; i < l; i++) { - this._remove(models[i], options); + // firing the `remove` event for every model removed. + remove: function(models, options) { + var i, l, index, model; + options || (options = {}); + models = _.isArray(models) ? models.slice() : [models]; + for (i = 0, l = models.length; i < l; i++) { + model = this.getByCid(models[i]) || this.get(models[i]); + if (!model) continue; + delete this._byId[model.id]; + delete this._byCid[model.cid]; + index = this.indexOf(model); + this.models.splice(index, 1); + this.length--; + if (!options.silent) { + options.index = index; + model.trigger('remove', model, this, options); } - } else { - this._remove(models, options); + this._removeReference(model); } return this; }, // Get a model from the set by id. - get : function(id) { + get: function(id) { if (id == null) return null; return this._byId[id.id != null ? id.id : id]; }, // Get a model from the set by client id. - getByCid : function(cid) { + getByCid: function(cid) { return cid && this._byCid[cid.cid || cid]; }, @@ -482,30 +549,38 @@ return this.models[index]; }, - // Force the collection to re-sort itself. You don't need to call this under normal - // circumstances, as the set will maintain sort order as each item is added. - sort : function(options) { + // Force the collection to re-sort itself. You don't need to call this under + // normal circumstances, as the set will maintain sort order as each item + // is added. + sort: function(options) { options || (options = {}); if (!this.comparator) throw new Error('Cannot sort a set without a comparator'); - this.models = this.sortBy(this.comparator); + var boundComparator = _.bind(this.comparator, this); + if (this.comparator.length == 1) { + this.models = this.sortBy(boundComparator); + } else { + this.models.sort(boundComparator); + } if (!options.silent) this.trigger('reset', this, options); return this; }, // Pluck an attribute from each model in the collection. - pluck : function(attr) { + pluck: function(attr) { return _.map(this.models, function(model){ return model.get(attr); }); }, // When you have more items than you want to add or remove individually, // you can reset the entire set with a new list of models, without firing - // any `added` or `removed` events. Fires `reset` when finished. - reset : function(models, options) { + // any `add` or `remove` events. Fires `reset` when finished. + reset: function(models, options) { models || (models = []); options || (options = {}); - this.each(this._removeReference); + for (var i = 0, l = this.models.length; i < l; i++) { + this._removeReference(this.models[i]); + } this._reset(); - this.add(models, {silent: true}); + this.add(models, {silent: true, parse: options.parse}); if (!options.silent) this.trigger('reset', this, options); return this; }, @@ -513,30 +588,36 @@ // Fetch the default set of models for this collection, resetting the // collection when they arrive. If `add: true` is passed, appends the // models to the collection instead of resetting. - fetch : function(options) { - options || (options = {}); + fetch: function(options) { + options = options ? _.clone(options) : {}; + if (options.parse === undefined) options.parse = true; var collection = this; var success = options.success; options.success = function(resp, status, xhr) { collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options); if (success) success(collection, resp); }; - options.error = wrapError(options.error, collection, options); + options.error = Backbone.wrapError(options.error, collection, options); return (this.sync || Backbone.sync).call(this, 'read', this, options); }, - // Create a new instance of a model in this collection. After the model - // has been created on the server, it will be added to the collection. - // Returns the model, or 'false' if validation on a new model fails. - create : function(model, options) { + // Create a new instance of a model in this collection. Add the model to the + // collection immediately, unless `wait: true` is passed, in which case we + // wait for the server to agree. + create: function(model, options) { var coll = this; - options || (options = {}); + options = options ? _.clone(options) : {}; model = this._prepareModel(model, options); if (!model) return false; + if (!options.wait) coll.add(model, options); var success = options.success; options.success = function(nextModel, resp, xhr) { - coll.add(nextModel, options); - if (success) success(nextModel, resp, xhr); + if (options.wait) coll.add(nextModel, options); + if (success) { + success(nextModel, resp); + } else { + nextModel.trigger('sync', model, resp, options); + } }; model.save(null, options); return model; @@ -544,7 +625,7 @@ // **parse** converts a response into a list of models to be added to the // collection. The default implementation is just to pass it through. - parse : function(resp, xhr) { + parse: function(resp, xhr) { return resp; }, @@ -556,77 +637,42 @@ }, // Reset all internal state. Called when the collection is reset. - _reset : function(options) { + _reset: function(options) { this.length = 0; this.models = []; this._byId = {}; this._byCid = {}; }, - // Prepare a model to be added to this collection + // Prepare a model or hash of attributes to be added to this collection. _prepareModel: function(model, options) { if (!(model instanceof Backbone.Model)) { var attrs = model; - model = new this.model(attrs, {collection: this}); - if (model.validate && !model._performValidation(attrs, options)) model = false; + options.collection = this; + model = new this.model(attrs, options); + if (model.validate && !model._performValidation(model.attributes, options)) model = false; } else if (!model.collection) { model.collection = this; } return model; }, - // Internal implementation of adding a single model to the set, updating - // hash indexes for `id` and `cid` lookups. - // Returns the model, or 'false' if validation on a new model fails. - _add : function(model, options) { - options || (options = {}); - model = this._prepareModel(model, options); - if (!model) return false; - var already = this.getByCid(model); - if (already) throw new Error(["Can't add the same model to a set twice", already.id]); - this._byId[model.id] = model; - this._byCid[model.cid] = model; - var index = options.at != null ? options.at : - this.comparator ? this.sortedIndex(model, this.comparator) : - this.length; - this.models.splice(index, 0, model); - model.bind('all', this._onModelEvent); - this.length++; - if (!options.silent) model.trigger('add', model, this, options); - return model; - }, - - // Internal implementation of removing a single model from the set, updating - // hash indexes for `id` and `cid` lookups. - _remove : function(model, options) { - options || (options = {}); - model = this.getByCid(model) || this.get(model); - if (!model) return null; - delete this._byId[model.id]; - delete this._byCid[model.cid]; - this.models.splice(this.indexOf(model), 1); - this.length--; - if (!options.silent) model.trigger('remove', model, this, options); - this._removeReference(model); - return model; - }, - // Internal method to remove a model's ties to a collection. - _removeReference : function(model) { + _removeReference: function(model) { if (this == model.collection) { delete model.collection; } - model.unbind('all', this._onModelEvent); + model.off('all', this._onModelEvent, this); }, // Internal method called every time a model in the set fires an event. // Sets need to update their indexes when models change ids. All other // events simply proxy through. "add" and "remove" events that originate // in other collections are ignored. - _onModelEvent : function(ev, model, collection, options) { + _onModelEvent: function(ev, model, collection, options) { if ((ev == 'add' || ev == 'remove') && collection != this) return; if (ev == 'destroy') { - this._remove(model, options); + this.remove(model, options); } if (model && ev === 'change:' + model.idAttribute) { delete this._byId[model.previous(model.idAttribute)]; @@ -638,10 +684,11 @@ }); // Underscore methods that we want to implement on the Collection. - var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', 'detect', - 'filter', 'select', 'reject', 'every', 'all', 'some', 'any', 'include', - 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size', - 'first', 'rest', 'last', 'without', 'indexOf', 'lastIndexOf', 'isEmpty', 'groupBy']; + var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', + 'detect', 'filter', 'select', 'reject', 'every', 'all', 'some', 'any', + 'include', 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', + 'toArray', 'size', 'first', 'initial', 'rest', 'last', 'without', 'indexOf', + 'shuffle', 'lastIndexOf', 'isEmpty', 'groupBy']; // Mix in each Underscore method as a proxy to `Collection#models`. _.each(methods, function(method) { @@ -664,8 +711,8 @@ // Cached regular expressions for matching named param parts and splatted // parts of route strings. - var namedParam = /:([\w\d]+)/g; - var splatParam = /\*([\w\d]+)/g; + var namedParam = /:\w+/g; + var splatParam = /\*\w+/g; var escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g; // Set up all inheritable **Backbone.Router** properties and methods. @@ -673,7 +720,7 @@ // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function(){}, // Manually bind a single named route to a callback. For example: // @@ -681,25 +728,28 @@ // ... // }); // - route : function(route, name, callback) { + route: function(route, name, callback) { Backbone.history || (Backbone.history = new Backbone.History); if (!_.isRegExp(route)) route = this._routeToRegExp(route); + if (!callback) callback = this[name]; Backbone.history.route(route, _.bind(function(fragment) { var args = this._extractParameters(route, fragment); - callback.apply(this, args); + callback && callback.apply(this, args); this.trigger.apply(this, ['route:' + name].concat(args)); + Backbone.history.trigger('route', this, name, args); }, this)); + return this; }, // Simple proxy to `Backbone.history` to save a fragment into the history. - navigate : function(fragment, triggerRoute) { - Backbone.history.navigate(fragment, triggerRoute); + navigate: function(fragment, options) { + Backbone.history.navigate(fragment, options); }, // Bind all defined routes to `Backbone.history`. We have to reverse the // order of the routes here to support behavior where the most general // routes can be defined at the bottom of the route map. - _bindRoutes : function() { + _bindRoutes: function() { if (!this.routes) return; var routes = []; for (var route in this.routes) { @@ -712,16 +762,16 @@ // Convert a route string into a regular expression, suitable for matching // against the current location hash. - _routeToRegExp : function(route) { - route = route.replace(escapeRegExp, "\\$&") - .replace(namedParam, "([^\/]*)") - .replace(splatParam, "(.*?)"); + _routeToRegExp: function(route) { + route = route.replace(escapeRegExp, '\\$&') + .replace(namedParam, '([^\/]+)') + .replace(splatParam, '(.*?)'); return new RegExp('^' + route + '$'); }, // Given a route, and a URL fragment that it matches, return the array of // extracted parameters. - _extractParameters : function(route, fragment) { + _extractParameters: function(route, fragment) { return route.exec(fragment).slice(1); } @@ -737,8 +787,8 @@ _.bindAll(this, 'checkUrl'); }; - // Cached regex for cleaning hashes. - var hashStrip = /^#*/; + // Cached regex for cleaning leading hashes and slashes . + var routeStripper = /^[#\/]/; // Cached regex for detecting MSIE. var isExplorer = /msie [\w.]+/; @@ -747,7 +797,7 @@ var historyStarted = false; // Set up all inheritable **Backbone.History** properties and methods. - _.extend(Backbone.History.prototype, { + _.extend(Backbone.History.prototype, Backbone.Events, { // The default interval to poll for hash changes, if necessary, is // twenty times a second. @@ -755,28 +805,30 @@ // Get the cross-browser normalized URL fragment, either from the URL, // the hash, or the override. - getFragment : function(fragment, forcePushState) { + getFragment: function(fragment, forcePushState) { if (fragment == null) { if (this._hasPushState || forcePushState) { fragment = window.location.pathname; var search = window.location.search; if (search) fragment += search; - if (fragment.indexOf(this.options.root) == 0) fragment = fragment.substr(this.options.root.length); } else { fragment = window.location.hash; } } - return decodeURIComponent(fragment.replace(hashStrip, '')); + fragment = decodeURIComponent(fragment.replace(routeStripper, '')); + if (!fragment.indexOf(this.options.root)) fragment = fragment.substr(this.options.root.length); + return fragment; }, // Start the hash change handling, returning `true` if the current URL matches // an existing route, and `false` otherwise. - start : function(options) { + start: function(options) { // Figure out the initial configuration. Do we need an iframe? // Is pushState desired ... is it available? if (historyStarted) throw new Error("Backbone.history has already been started"); this.options = _.extend({}, {root: '/'}, this.options, options); + this._wantsHashChange = this.options.hashChange !== false; this._wantsPushState = !!this.options.pushState; this._hasPushState = !!(this.options.pushState && window.history && window.history.pushState); var fragment = this.getFragment(); @@ -791,10 +843,10 @@ // 'onhashchange' is supported, determine how we check the URL state. if (this._hasPushState) { $(window).bind('popstate', this.checkUrl); - } else if ('onhashchange' in window && !oldIE) { + } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) { $(window).bind('hashchange', this.checkUrl); - } else { - setInterval(this.checkUrl, this.interval); + } else if (this._wantsHashChange) { + this._checkUrlInterval = setInterval(this.checkUrl, this.interval); } // Determine if we need to change the base url, for a pushState link @@ -803,13 +855,19 @@ historyStarted = true; var loc = window.location; var atRoot = loc.pathname == this.options.root; - if (this._wantsPushState && !this._hasPushState && !atRoot) { + + // If we've started off with a route from a `pushState`-enabled browser, + // but we're currently in a browser that doesn't support it... + if (this._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) { this.fragment = this.getFragment(null, true); window.location.replace(this.options.root + '#' + this.fragment); // Return immediately as browser will do redirect to new url return true; + + // Or if we've started out with a hash-based route, but we're currently + // in a browser where it could be `pushState`-based instead... } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) { - this.fragment = loc.hash.replace(hashStrip, ''); + this.fragment = loc.hash.replace(routeStripper, ''); window.history.replaceState({}, document.title, loc.protocol + '//' + loc.host + this.options.root + this.fragment); } @@ -818,15 +876,23 @@ } }, - // Add a route to be tested when the fragment changes. Routes added later may - // override previous routes. - route : function(route, callback) { - this.handlers.unshift({route : route, callback : callback}); + // Disable Backbone.history, perhaps temporarily. Not useful in a real app, + // but possibly useful for unit testing Routers. + stop: function() { + $(window).unbind('popstate', this.checkUrl).unbind('hashchange', this.checkUrl); + clearInterval(this._checkUrlInterval); + historyStarted = false; + }, + + // Add a route to be tested when the fragment changes. Routes added later + // may override previous routes. + route: function(route, callback) { + this.handlers.unshift({route: route, callback: callback}); }, // Checks the current URL to see if it has changed, and if it has, // calls `loadUrl`, normalizing across the hidden iframe. - checkUrl : function(e) { + checkUrl: function(e) { var current = this.getFragment(); if (current == this.fragment && this.iframe) current = this.getFragment(this.iframe.location.hash); if (current == this.fragment || current == decodeURIComponent(this.fragment)) return false; @@ -837,7 +903,7 @@ // Attempt to load the current URL fragment. If a route succeeds with a // match, returns `true`. If no defined routes matches the fragment, // returns `false`. - loadUrl : function(fragmentOverride) { + loadUrl: function(fragmentOverride) { var fragment = this.fragment = this.getFragment(fragmentOverride); var matched = _.any(this.handlers, function(handler) { if (handler.route.test(fragment)) { @@ -848,27 +914,54 @@ return matched; }, - // Save a fragment into the hash history. You are responsible for properly - // URL-encoding the fragment in advance. This does not trigger - // a `hashchange` event. - navigate : function(fragment, triggerRoute) { - var frag = (fragment || '').replace(hashStrip, ''); + // Save a fragment into the hash history, or replace the URL state if the + // 'replace' option is passed. You are responsible for properly URL-encoding + // the fragment in advance. + // + // The options object can contain `trigger: true` if you wish to have the + // route callback be fired (not usually desirable), or `replace: true`, if + // you which to modify the current URL without adding an entry to the history. + navigate: function(fragment, options) { + if (!historyStarted) return false; + if (!options || options === true) options = {trigger: options}; + var frag = (fragment || '').replace(routeStripper, ''); if (this.fragment == frag || this.fragment == decodeURIComponent(frag)) return; + + // If pushState is available, we use it to set the fragment as a real URL. if (this._hasPushState) { - var loc = window.location; if (frag.indexOf(this.options.root) != 0) frag = this.options.root + frag; this.fragment = frag; - window.history.pushState({}, document.title, loc.protocol + '//' + loc.host + frag); - } else { - window.location.hash = this.fragment = frag; + window.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, frag); + + // If hash changes haven't been explicitly disabled, update the hash + // fragment to store history. + } else if (this._wantsHashChange) { + this.fragment = frag; + this._updateHash(window.location, frag, options.replace); if (this.iframe && (frag != this.getFragment(this.iframe.location.hash))) { - this.iframe.document.open().close(); - this.iframe.location.hash = frag; + // Opening and closing the iframe tricks IE7 and earlier to push a history entry on hash-tag change. + // When replace is true, we don't want this. + if(!options.replace) this.iframe.document.open().close(); + this._updateHash(this.iframe.location, frag, options.replace); } + + // If you've told us that you explicitly don't want fallback hashchange- + // based history, then `navigate` becomes a page refresh. + } else { + window.location.assign(this.options.root + fragment); } - if (triggerRoute) this.loadUrl(fragment); - } + if (options.trigger) this.loadUrl(fragment); + }, + // Update the hash location, either replacing the current entry, or adding + // a new one to the browser history. + _updateHash: function(location, fragment, replace) { + if (replace) { + location.replace(location.toString().replace(/(javascript:|#).*$/, '') + '#' + fragment); + } else { + location.hash = fragment; + } + } }); // Backbone.View @@ -880,15 +973,8 @@ this.cid = _.uniqueId('view'); this._configure(options || {}); this._ensureElement(); - this.delegateEvents(); this.initialize.apply(this, arguments); - }; - - // Element lookup, scoped to DOM elements within the current view. - // This should be prefered to global lookups, if you're dealing with - // a specific view. - var selectorDelegate = function(selector) { - return $(selector, this.el); + this.delegateEvents(); }; // Cached regex to split keys for `delegate`. @@ -901,26 +987,29 @@ _.extend(Backbone.View.prototype, Backbone.Events, { // The default `tagName` of a View's element is `"div"`. - tagName : 'div', + tagName: 'div', - // Attach the `selectorDelegate` function as the `$` property. - $ : selectorDelegate, + // jQuery delegate for element lookup, scoped to DOM elements within the + // current view. This should be prefered to global lookups where possible. + $: function(selector) { + return this.$el.find(selector); + }, // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function(){}, // **render** is the core function that your view should override, in order // to populate its element (`this.el`), with the appropriate HTML. The // convention is for **render** to always return `this`. - render : function() { + render: function() { return this; }, // Remove this view from the DOM. Note that the view isn't present in the // DOM by default, so calling this method may be a no-op. - remove : function() { - $(this.el).remove(); + remove: function() { + this.$el.remove(); return this; }, @@ -929,20 +1018,29 @@ // // var el = this.make('li', {'class': 'row'}, this.model.escape('title')); // - make : function(tagName, attributes, content) { + make: function(tagName, attributes, content) { var el = document.createElement(tagName); if (attributes) $(el).attr(attributes); if (content) $(el).html(content); return el; }, - // Set callbacks, where `this.callbacks` is a hash of + // Change the view's element (`this.el` property), including event + // re-delegation. + setElement: function(element, delegate) { + this.$el = $(element); + this.el = this.$el[0]; + if (delegate !== false) this.delegateEvents(); + }, + + // Set callbacks, where `this.events` is a hash of // // *{"event selector": "callback"}* // // { // 'mousedown .title': 'edit', // 'click .button': 'save' + // 'click .open': function(e) { ... } // } // // pairs. Callbacks will be bound to the view, with `this` set properly. @@ -950,29 +1048,36 @@ // Omitting the selector binds the event to `this.el`. // This only works for delegate-able events: not `focus`, `blur`, and // not `change`, `submit`, and `reset` in Internet Explorer. - delegateEvents : function(events) { - if (!(events || (events = this.events))) return; - if (_.isFunction(events)) events = events.call(this); - $(this.el).unbind('.delegateEvents' + this.cid); + delegateEvents: function(events) { + if (!(events || (events = getValue(this, 'events')))) return; + this.undelegateEvents(); for (var key in events) { - var method = this[events[key]]; + var method = events[key]; + if (!_.isFunction(method)) method = this[events[key]]; if (!method) throw new Error('Event "' + events[key] + '" does not exist'); var match = key.match(eventSplitter); var eventName = match[1], selector = match[2]; method = _.bind(method, this); eventName += '.delegateEvents' + this.cid; if (selector === '') { - $(this.el).bind(eventName, method); + this.$el.bind(eventName, method); } else { - $(this.el).delegate(selector, eventName, method); + this.$el.delegate(selector, eventName, method); } } }, + // Clears all callbacks previously bound to the view with `delegateEvents`. + // You usually don't need to use this, but may wish to if you have multiple + // Backbone views attached to the same DOM element. + undelegateEvents: function() { + this.$el.unbind('.delegateEvents' + this.cid); + }, + // Performs the initial configuration of a View with a set of options. // Keys with special meaning *(model, collection, id, className)*, are // attached directly to the view. - _configure : function(options) { + _configure: function(options) { if (this.options) options = _.extend({}, this.options, options); for (var i = 0, l = viewOptions.length; i < l; i++) { var attr = viewOptions[i]; @@ -984,15 +1089,15 @@ // Ensure that the View has a DOM element to render into. // If `this.el` is a string, pass it through `$()`, take the first // matching element, and re-assign it to `el`. Otherwise, create - // an element from the `id`, `className` and `tagName` proeprties. - _ensureElement : function() { + // an element from the `id`, `className` and `tagName` properties. + _ensureElement: function() { if (!this.el) { - var attrs = this.attributes || {}; + var attrs = getValue(this, 'attributes') || {}; if (this.id) attrs.id = this.id; if (this.className) attrs['class'] = this.className; - this.el = this.make(this.tagName, attrs); - } else if (_.isString(this.el)) { - this.el = $(this.el).get(0); + this.setElement(this.make(this.tagName, attrs), false); + } else { + this.setElement(this.el, false); } } @@ -1009,20 +1114,20 @@ Backbone.Model.extend = Backbone.Collection.extend = Backbone.Router.extend = Backbone.View.extend = extend; + // Backbone.sync + // ------------- + // Map from CRUD to HTTP for our default `Backbone.sync` implementation. var methodMap = { 'create': 'POST', 'update': 'PUT', 'delete': 'DELETE', - 'read' : 'GET' + 'read': 'GET' }; - // Backbone.sync - // ------------- - // Override this function to change the manner in which Backbone persists // models to the server. You will be passed the type of request, and the - // model in question. By default, uses makes a RESTful Ajax request + // model in question. By default, makes a RESTful Ajax request // to the model's `url()`. Some possible customizations could be: // // * Use `setTimeout` to batch rapid-fire updates into a single request. @@ -1031,26 +1136,23 @@ // // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests // as `POST`, with a `_method` parameter containing the true HTTP method, - // as well as all requests with the body as `application/x-www-form-urlencoded` instead of - // `application/json` with the model in a param named `model`. + // as well as all requests with the body as `application/x-www-form-urlencoded` + // instead of `application/json` with the model in a param named `model`. // Useful when interfacing with server-side languages like **PHP** that make // it difficult to read the body of `PUT` requests. Backbone.sync = function(method, model, options) { var type = methodMap[method]; // Default JSON-request options. - var params = _.extend({ - type: type, - dataType: 'json' - }, options); + var params = {type: type, dataType: 'json'}; // Ensure that we have a URL. - if (!params.url) { - params.url = getUrl(model) || urlError(); + if (!options.url) { + params.url = getValue(model, 'url') || urlError(); } // Ensure that we have the appropriate request data. - if (!params.data && model && (method == 'create' || method == 'update')) { + if (!options.data && model && (method == 'create' || method == 'update')) { params.contentType = 'application/json'; params.data = JSON.stringify(model.toJSON()); } @@ -1058,7 +1160,7 @@ // For older servers, emulate JSON by encoding the request into an HTML-form. if (Backbone.emulateJSON) { params.contentType = 'application/x-www-form-urlencoded'; - params.data = params.data ? {model : params.data} : {}; + params.data = params.data ? {model: params.data} : {}; } // For older servers, emulate HTTP by mimicking the HTTP method with `_method` @@ -1078,8 +1180,20 @@ params.processData = false; } - // Make the request. - return $.ajax(params); + // Make the request, allowing the user to override any Ajax options. + return $.ajax(_.extend(params, options)); + }; + + // Wrap an optional error callback with a fallback error event. + Backbone.wrapError = function(onError, originalModel, options) { + return function(model, resp) { + var resp = model === originalModel ? resp : model; + if (onError) { + onError(model, resp, options); + } else { + originalModel.trigger('error', model, resp, options); + } + }; }; // Helpers @@ -1096,11 +1210,11 @@ // The constructor function for the new subclass is either defined by you // (the "constructor" property in your `extend` definition), or defaulted - // by us to simply call `super()`. + // by us to simply call the parent's constructor. if (protoProps && protoProps.hasOwnProperty('constructor')) { child = protoProps.constructor; } else { - child = function(){ return parent.apply(this, arguments); }; + child = function(){ parent.apply(this, arguments); }; } // Inherit class (static) properties from parent. @@ -1127,11 +1241,11 @@ return child; }; - // Helper function to get a URL from a Model or Collection as a property + // Helper function to get a value from a Backbone object as a property // or as a function. - var getUrl = function(object) { - if (!(object && object.url)) return null; - return _.isFunction(object.url) ? object.url() : object.url; + var getValue = function(object, prop) { + if (!(object && object[prop])) return null; + return _.isFunction(object[prop]) ? object[prop]() : object[prop]; }; // Throw an error when a URL is needed, and none is supplied. @@ -1139,20 +1253,4 @@ throw new Error('A "url" property or function must be specified'); }; - // Wrap an optional error callback with a fallback error event. - var wrapError = function(onError, model, options) { - return function(resp) { - if (onError) { - onError(model, resp, options); - } else { - model.trigger('error', model, resp, options); - } - }; - }; - - // Helper function to escape a string for HTML rendering. - var escapeHTML = function(string) { - return string.replace(/&(?!\w+;|#\d+;|#x[\da-f]+;)/gi, '&').replace(//g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g,'/'); - }; - }).call(this); From 0476c5f08427c36af6ce84db98f53cc7b2552487 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Arild=20M=C3=A6land?= Date: Fri, 3 Feb 2012 09:09:27 +0100 Subject: [PATCH 2/3] Backbone 0.9.1 --- vendor/assets/javascripts/backbone.js | 104 +++++++++++++++++--------- 1 file changed, 69 insertions(+), 35 deletions(-) diff --git a/vendor/assets/javascripts/backbone.js b/vendor/assets/javascripts/backbone.js index e0358a6..7c56f42 100644 --- a/vendor/assets/javascripts/backbone.js +++ b/vendor/assets/javascripts/backbone.js @@ -1,4 +1,5 @@ -// Backbone.js 0.9.0 +// Backbone.js 0.9.1 + // (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc. // Backbone may be freely distributed under the MIT license. // For all details and documentation: @@ -31,7 +32,7 @@ } // Current version of the library. Keep in sync with `package.json`. - Backbone.VERSION = '0.9.0'; + Backbone.VERSION = '0.9.1'; // Require Underscore, if we're on the server, and it's not already present. var _ = root._; @@ -40,6 +41,15 @@ // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable. var $ = root.jQuery || root.Zepto || root.ender; + // Set the JavaScript library that will be used for DOM manipulation and + // Ajax calls (a.k.a. the `$` variable). By default Backbone will use: jQuery, + // Zepto, or Ender; but the `setDomLibrary()` method lets you inject an + // alternate JavaScript library (or a mock library for testing your views + // outside of a browser). + Backbone.setDomLibrary = function(lib) { + $ = lib; + }; + // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable // to its previous owner. Returns a reference to this Backbone object. Backbone.noConflict = function() { @@ -163,11 +173,10 @@ this.attributes = {}; this._escapedAttributes = {}; this.cid = _.uniqueId('c'); - this._changed = {}; if (!this.set(attributes, {silent: true})) { throw new Error("Can't create an invalid model"); } - this._changed = {}; + delete this._changed; this._previousAttributes = _.clone(this.attributes); this.initialize.apply(this, arguments); }; @@ -223,10 +232,10 @@ options || (options = {}); if (!attrs) return this; if (attrs instanceof Backbone.Model) attrs = attrs.attributes; - if (options.unset) for (var attr in attrs) attrs[attr] = void 0; + if (options.unset) for (attr in attrs) attrs[attr] = void 0; // Run validation. - if (this.validate && !this._performValidation(attrs, options)) return false; + if (!this._validate(attrs, options)) return false; // Check for changes of `id`. if (this.idAttribute in attrs) this.id = attrs[this.idAttribute]; @@ -234,14 +243,19 @@ var now = this.attributes; var escaped = this._escapedAttributes; var prev = this._previousAttributes || {}; - var alreadyChanging = this._changing; - this._changing = true; + var alreadySetting = this._setting; + this._changed || (this._changed = {}); + this._setting = true; // Update attributes. for (attr in attrs) { val = attrs[attr]; if (!_.isEqual(now[attr], val)) delete escaped[attr]; options.unset ? delete now[attr] : now[attr] = val; + if (this._changing && !_.isEqual(this._changed[attr], val)) { + this.trigger('change:' + attr, this, val, options); + this._moreChanges = true; + } delete this._changed[attr]; if (!_.isEqual(prev[attr], val) || (_.has(now, attr) != _.has(prev, attr))) { this._changed[attr] = val; @@ -249,9 +263,9 @@ } // Fire the `"change"` events, if the model has been changed. - if (!alreadyChanging) { + if (!alreadySetting) { if (!options.silent && this.hasChanged()) this.change(options); - this._changing = false; + this._setting = false; } return this; }, @@ -289,7 +303,7 @@ // If the server returns an attributes hash that differs, the model's // state will be `set` again. save: function(key, value, options) { - var attrs; + var attrs, current; if (_.isObject(key) || key == null) { attrs = key; options = value; @@ -299,7 +313,11 @@ } options = options ? _.clone(options) : {}; - if (attrs && !this[options.wait ? '_performValidation' : 'set'](attrs, options)) return false; + if (options.wait) current = _.clone(this.attributes); + var silentOptions = _.extend({}, options, {silent: true}); + if (attrs && !this.set(attrs, options.wait ? silentOptions : options)) { + return false; + } var model = this; var success = options.success; options.success = function(resp, status, xhr) { @@ -314,7 +332,9 @@ }; options.error = Backbone.wrapError(options.error, model, options); var method = this.isNew() ? 'create' : 'update'; - return (this.sync || Backbone.sync).call(this, method, this, options); + var xhr = (this.sync || Backbone.sync).call(this, method, this, options); + if (options.wait) this.set(current, silentOptions); + return xhr; }, // Destroy this model on the server if it was already persisted. @@ -373,19 +393,27 @@ // a `"change:attribute"` event for each changed attribute. // Calling this will cause all objects observing the model to update. change: function(options) { + if (this._changing || !this.hasChanged()) return this; + this._changing = true; + this._moreChanges = true; for (var attr in this._changed) { this.trigger('change:' + attr, this, this._changed[attr], options); } - this.trigger('change', this, options); + while (this._moreChanges) { + this._moreChanges = false; + this.trigger('change', this, options); + } this._previousAttributes = _.clone(this.attributes); - this._changed = {}; + delete this._changed; + this._changing = false; + return this; }, // Determine if the model has changed since the last `"change"` event. // If you specify an attribute name, determine if that attribute has changed. hasChanged: function(attr) { - if (attr) return _.has(this._changed, attr); - return !_.isEmpty(this._changed); + if (!arguments.length) return !_.isEmpty(this._changed); + return this._changed && _.has(this._changed, attr); }, // Return an object containing all the attributes that have changed, or @@ -407,7 +435,7 @@ // Get the previous value of an attribute, recorded at the time the last // `"change"` event was fired. previous: function(attr) { - if (!attr || !this._previousAttributes) return null; + if (!arguments.length || !this._previousAttributes) return null; return this._previousAttributes[attr]; }, @@ -417,21 +445,26 @@ return _.clone(this._previousAttributes); }, + // Check if the model is currently in a valid state. It's only possible to + // get into an *invalid* state if you're using silent changes. + isValid: function() { + return !this.validate(this.attributes); + }, + // Run validation against a set of incoming attributes, returning `true` // if all is well. If a specific `error` callback has been passed, // call that instead of firing the general `"error"` event. - _performValidation: function(attrs, options) { - var newAttrs = _.extend({}, this.attributes, attrs); - var error = this.validate(newAttrs, options); - if (error) { - if (options.error) { - options.error(this, error, options); - } else { - this.trigger('error', this, error, options); - } - return false; + _validate: function(attrs, options) { + if (options.silent || !this.validate) return true; + attrs = _.extend({}, this.attributes, attrs); + var error = this.validate(attrs, options); + if (!error) return true; + if (options && options.error) { + options.error(this, error, options); + } else { + this.trigger('error', this, error, options); } - return true; + return false; } }); @@ -650,7 +683,7 @@ var attrs = model; options.collection = this; model = new this.model(attrs, options); - if (model.validate && !model._performValidation(model.attributes, options)) model = false; + if (!model._validate(model.attributes, options)) model = false; } else if (!model.collection) { model.collection = this; } @@ -815,9 +848,9 @@ fragment = window.location.hash; } } - fragment = decodeURIComponent(fragment.replace(routeStripper, '')); + fragment = decodeURIComponent(fragment); if (!fragment.indexOf(this.options.root)) fragment = fragment.substr(this.options.root.length); - return fragment; + return fragment.replace(routeStripper, ''); }, // Start the hash change handling, returning `true` if the current URL matches @@ -1031,6 +1064,7 @@ this.$el = $(element); this.el = this.$el[0]; if (delegate !== false) this.delegateEvents(); + return this; }, // Set callbacks, where `this.events` is a hash of @@ -1187,11 +1221,11 @@ // Wrap an optional error callback with a fallback error event. Backbone.wrapError = function(onError, originalModel, options) { return function(model, resp) { - var resp = model === originalModel ? resp : model; + resp = model === originalModel ? resp : model; if (onError) { - onError(model, resp, options); + onError(originalModel, resp, options); } else { - originalModel.trigger('error', model, resp, options); + originalModel.trigger('error', originalModel, resp, options); } }; }; From cb6be6080d00ac153f911e5ae77e35a6c6d32d61 Mon Sep 17 00:00:00 2001 From: "Ramiro Jr. Franco" Date: Fri, 3 Feb 2012 07:50:14 -0800 Subject: [PATCH 3/3] Fixing readme to reflect the correct backbone version --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 84b1f23..06f4a42 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Backbone-Rails [![Build Status](https://secure.travis-ci.org/codebrew/backbone-rails.png)](http://travis-ci.org/codebrew/backbone-rails) -Easily setup and use backbone.js (0.5.3) with rails 3.1 and greater +Easily setup and use backbone.js (0.9.1) with rails 3.1 and greater Follow [@TheRyanFitz on Twitter](http://twitter.com/#!/TheRyanFitz). Tweet any questions or suggestions you have about the project.