"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "vendor/backbone/backbone.js" between
lodash-3.0.0.tar.gz and lodash-4.0.0.tar.gz

About: lodash is a modern JavaScript utility library delivering modularity, performance, & extras.

[ To the main lodash source changes report ]

backbone.js  (lodash-3.0.0):backbone.js  (lodash-4.0.0)
// Backbone.js 1.1.2 // Backbone.js 1.2.3
// (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors // (c) 2010-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
// Backbone may be freely distributed under the MIT license. // Backbone may be freely distributed under the MIT license.
// For all details and documentation: // For all details and documentation:
// http://backbonejs.org // http://backbonejs.org
(function(root, factory) { (function(factory) {
// Establish the root object, `window` (`self`) in the browser, or `global` on
the server.
// We use `self` instead of `window` for `WebWorker` support.
var root = (typeof self == 'object' && self.self == self && self) ||
(typeof global == 'object' && global.global == global && global);
// Set up Backbone appropriately for the environment. Start with AMD. // Set up Backbone appropriately for the environment. Start with AMD.
if (typeof define === 'function' && define.amd) { if (typeof define === 'function' && define.amd) {
define(['underscore', 'jquery', 'exports'], function(_, $, exports) { define(['underscore', 'jquery', 'exports'], function(_, $, exports) {
// Export global even in AMD case in case this script is loaded with // Export global even in AMD case in case this script is loaded with
// others that may still expect a global Backbone. // others that may still expect a global Backbone.
root.Backbone = factory(root, exports, _, $); root.Backbone = factory(root, exports, _, $);
}); });
// Next for Node.js or CommonJS. jQuery may not be needed as a module. // Next for Node.js or CommonJS. jQuery may not be needed as a module.
} else if (typeof exports !== 'undefined') { } else if (typeof exports !== 'undefined') {
var _ = require('underscore'); var _ = require('underscore'), $;
factory(root, exports, _); try { $ = require('jquery'); } catch (e) {}
factory(root, exports, _, $);
// Finally, as a browser global. // Finally, as a browser global.
} else { } else {
root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root .ender || root.$)); root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root .ender || root.$));
} }
}(this, function(root, Backbone, _, $) { })(function(root, Backbone, _, $) {
// Initial Setup // Initial Setup
// ------------- // -------------
// Save the previous value of the `Backbone` variable, so that it can be // Save the previous value of the `Backbone` variable, so that it can be
// restored later on, if `noConflict` is used. // restored later on, if `noConflict` is used.
var previousBackbone = root.Backbone; var previousBackbone = root.Backbone;
// Create local references to array methods we'll want to use later. // Create a local reference to a common array method we'll want to use later.
var array = []; var slice = Array.prototype.slice;
var push = array.push;
var slice = array.slice;
var splice = array.splice;
// Current version of the library. Keep in sync with `package.json`. // Current version of the library. Keep in sync with `package.json`.
Backbone.VERSION = '1.1.2'; Backbone.VERSION = '1.2.3';
// For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
// the `$` variable. // the `$` variable.
Backbone.$ = $; Backbone.$ = $;
// Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
// to its previous owner. Returns a reference to this Backbone object. // to its previous owner. Returns a reference to this Backbone object.
Backbone.noConflict = function() { Backbone.noConflict = function() {
root.Backbone = previousBackbone; root.Backbone = previousBackbone;
return this; return this;
}; };
// Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
// will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` para meter and // will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` para meter and
// set a `X-Http-Method-Override` header. // set a `X-Http-Method-Override` header.
Backbone.emulateHTTP = false; Backbone.emulateHTTP = false;
// Turn on `emulateJSON` to support legacy servers that can't deal with direct // Turn on `emulateJSON` to support legacy servers that can't deal with direct
// `application/json` requests ... will encode the body as // `application/json` requests ... this will encode the body as
// `application/x-www-form-urlencoded` instead and will send the model in a // `application/x-www-form-urlencoded` instead and will send the model in a
// form param named `model`. // form param named `model`.
Backbone.emulateJSON = false; Backbone.emulateJSON = false;
// Proxy Backbone class methods to Underscore functions, wrapping the model's
// `attributes` object or collection's `models` array behind the scenes.
//
// collection.filter(function(model) { return model.get('age') > 10 });
// collection.each(this.addView);
//
// `Function#apply` can be slow so we use the method's arg count, if we know i
t.
var addMethod = function(length, method, attribute) {
switch (length) {
case 1: return function() {
return _[method](this[attribute]);
};
case 2: return function(value) {
return _[method](this[attribute], value);
};
case 3: return function(iteratee, context) {
return _[method](this[attribute], cb(iteratee, this), context);
};
case 4: return function(iteratee, defaultVal, context) {
return _[method](this[attribute], cb(iteratee, this), defaultVal, contex
t);
};
default: return function() {
var args = slice.call(arguments);
args.unshift(this[attribute]);
return _[method].apply(_, args);
};
}
};
var addUnderscoreMethods = function(Class, methods, attribute) {
_.each(methods, function(length, method) {
if (_[method]) Class.prototype[method] = addMethod(length, method, attribu
te);
});
};
// Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.
var cb = function(iteratee, instance) {
if (_.isFunction(iteratee)) return iteratee;
if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatche
r(iteratee);
if (_.isString(iteratee)) return function(model) { return model.get(iteratee
); };
return iteratee;
};
var modelMatcher = function(attrs) {
var matcher = _.matches(attrs);
return function(model) {
return matcher(model.attributes);
};
};
// Backbone.Events // Backbone.Events
// --------------- // ---------------
// A module that can be mixed in to *any object* in order to provide it with // A module that can be mixed in to *any object* in order to provide it with
// custom events. You may bind with `on` or remove with `off` callback // a custom event channel. You may bind a callback to an event with `on` or
// functions to an event; `trigger`-ing an event fires all callbacks in // remove with `off`; `trigger`-ing an event fires all callbacks in
// succession. // succession.
// //
// var object = {}; // var object = {};
// _.extend(object, Backbone.Events); // _.extend(object, Backbone.Events);
// object.on('expand', function(){ alert('expanded'); }); // object.on('expand', function(){ alert('expanded'); });
// object.trigger('expand'); // object.trigger('expand');
// //
var Events = Backbone.Events = { var Events = Backbone.Events = {};
// Bind an event to a `callback` function. Passing `"all"` will bind
// the callback to all events fired.
on: function(name, callback, context) {
if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return
this;
this._events || (this._events = {});
var events = this._events[name] || (this._events[name] = []);
events.push({callback: callback, context: context, ctx: context || this});
return this;
},
// Bind an event to only be triggered a single time. After the first time // Regular expression used to split event strings.
// the callback is invoked, it will be removed. var eventSplitter = /\s+/;
once: function(name, callback, context) {
if (!eventsApi(this, 'once', name, [callback, context]) || !callback) retu
rn this;
var self = this;
var once = _.once(function() {
self.off(name, once);
callback.apply(this, arguments);
});
once._callback = callback;
return this.on(name, once, context);
},
// Remove one or many callbacks. If `context` is null, removes all // Iterates over the standard `event, callback` (as well as the fancy multiple
// callbacks with that function. If `callback` is null, removes all // space-separated events `"change blur", callback` and jQuery-style event
// callbacks for the event. If `name` is null, removes all bound // maps `{event: callback}`).
// callbacks for all events. var eventsApi = function(iteratee, events, name, callback, opts) {
off: function(name, callback, context) { var i = 0, names;
var retain, ev, events, names, i, l, j, k; if (name && typeof name === 'object') {
if (!this._events || !eventsApi(this, 'off', name, [callback, context])) r // Handle event maps.
eturn this; if (callback !== void 0 && 'context' in opts && opts.context === void 0) o
if (!name && !callback && !context) { pts.context = callback;
this._events = void 0; for (names = _.keys(name); i < names.length ; i++) {
return this; events = eventsApi(iteratee, events, names[i], name[names[i]], opts);
} }
names = name ? [name] : _.keys(this._events); } else if (name && eventSplitter.test(name)) {
for (i = 0, l = names.length; i < l; i++) { // Handle space separated event names by delegating them individually.
name = names[i]; for (names = name.split(eventSplitter); i < names.length; i++) {
if (events = this._events[name]) { events = iteratee(events, names[i], callback, opts);
this._events[name] = retain = [];
if (callback || context) {
for (j = 0, k = events.length; j < k; j++) {
ev = events[j];
if ((callback && callback !== ev.callback && callback !== ev.callb
ack._callback) ||
(context && context !== ev.context)) {
retain.push(ev);
}
}
}
if (!retain.length) delete this._events[name];
}
} }
} else {
// Finally, standard events.
events = iteratee(events, name, callback, opts);
}
return events;
};
return this; // Bind an event to a `callback` function. Passing `"all"` will bind
}, // the callback to all events fired.
Events.on = function(name, callback, context) {
return internalOn(this, name, callback, context);
};
// Trigger one or many events, firing all bound callbacks. Callbacks are // Guard the `listening` argument from the public API.
// passed the same arguments as `trigger` is, apart from the event name var internalOn = function(obj, name, callback, context, listening) {
// (unless you're listening on `"all"`, which will cause your callback to obj._events = eventsApi(onApi, obj._events || {}, name, callback, {
// receive the true name of the event as the first argument). context: context,
trigger: function(name) { ctx: obj,
if (!this._events) return this; listening: listening
var args = slice.call(arguments, 1); });
if (!eventsApi(this, 'trigger', name, args)) return this;
var events = this._events[name];
var allEvents = this._events.all;
if (events) triggerEvents(events, args);
if (allEvents) triggerEvents(allEvents, arguments);
return this;
},
// Tell this object to stop listening to either specific events ... or if (listening) {
// to every object it's currently listening to. var listeners = obj._listeners || (obj._listeners = {});
stopListening: function(obj, name, callback) { listeners[listening.id] = listening;
var listeningTo = this._listeningTo;
if (!listeningTo) return this;
var remove = !name && !callback;
if (!callback && typeof name === 'object') callback = this;
if (obj) (listeningTo = {})[obj._listenId] = obj;
for (var id in listeningTo) {
obj = listeningTo[id];
obj.off(name, callback, this);
if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
}
return this;
} }
return obj;
}; };
// Regular expression used to split event strings. // Inversion-of-control versions of `on`. Tell *this* object to listen to
var eventSplitter = /\s+/; // an event in another object... keeping track of what it's listening to
// for easier unbinding later.
Events.listenTo = function(obj, name, callback) {
if (!obj) return this;
var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
var listeningTo = this._listeningTo || (this._listeningTo = {});
var listening = listeningTo[id];
// This object is not listening to any other events on `obj` yet.
// Setup the necessary references to track the listening callbacks.
if (!listening) {
var thisId = this._listenId || (this._listenId = _.uniqueId('l'));
listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningT
o: listeningTo, count: 0};
}
// Bind callbacks on obj, and keep track of them on listening.
internalOn(obj, name, callback, this, listening);
return this;
};
// Implement fancy features of the Events API such as multiple event // The reducing API that adds a callback to the `events` object.
// names `"change blur"` and jQuery-style event maps `{change: action}` var onApi = function(events, name, callback, options) {
// in terms of the existing API. if (callback) {
var eventsApi = function(obj, action, name, rest) { var handlers = events[name] || (events[name] = []);
if (!name) return true; var context = options.context, ctx = options.ctx, listening = options.list
ening;
// Handle event maps. if (listening) listening.count++;
if (typeof name === 'object') {
for (var key in name) { handlers.push({callback: callback, context: context, ctx: context || ctx,
obj[action].apply(obj, [key, name[key]].concat(rest)); listening: listening});
}
return events;
};
// 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 `name` is null, removes all bound
// callbacks for all events.
Events.off = function(name, callback, context) {
if (!this._events) return this;
this._events = eventsApi(offApi, this._events, name, callback, {
context: context,
listeners: this._listeners
});
return this;
};
// Tell this object to stop listening to either specific events ... or
// to every object it's currently listening to.
Events.stopListening = function(obj, name, callback) {
var listeningTo = this._listeningTo;
if (!listeningTo) return this;
var ids = obj ? [obj._listenId] : _.keys(listeningTo);
for (var i = 0; i < ids.length; i++) {
var listening = listeningTo[ids[i]];
// If listening doesn't exist, this object is not currently
// listening to obj. Break out early.
if (!listening) break;
listening.obj.off(name, callback, this);
}
if (_.isEmpty(listeningTo)) this._listeningTo = void 0;
return this;
};
// The reducing API that removes a callback from the `events` object.
var offApi = function(events, name, callback, options) {
if (!events) return;
var i = 0, listening;
var context = options.context, listeners = options.listeners;
// Delete all events listeners and "drop" events.
if (!name && !callback && !context) {
var ids = _.keys(listeners);
for (; i < ids.length; i++) {
listening = listeners[ids[i]];
delete listeners[listening.id];
delete listening.listeningTo[listening.objId];
} }
return false; return;
} }
// Handle space separated event names. var names = name ? [name] : _.keys(events);
if (eventSplitter.test(name)) { for (; i < names.length; i++) {
var names = name.split(eventSplitter); name = names[i];
for (var i = 0, l = names.length; i < l; i++) { var handlers = events[name];
obj[action].apply(obj, [names[i]].concat(rest));
// Bail out if there are no events stored.
if (!handlers) break;
// Replace events if there are any remaining. Otherwise, clean up.
var remaining = [];
for (var j = 0; j < handlers.length; j++) {
var handler = handlers[j];
if (
callback && callback !== handler.callback &&
callback !== handler.callback._callback ||
context && context !== handler.context
) {
remaining.push(handler);
} else {
listening = handler.listening;
if (listening && --listening.count === 0) {
delete listeners[listening.id];
delete listening.listeningTo[listening.objId];
}
}
}
// Update tail event if the list has any events. Otherwise, clean up.
if (remaining.length) {
events[name] = remaining;
} else {
delete events[name];
} }
return false;
} }
if (_.size(events)) return events;
};
// Bind an event to only be triggered a single time. After the first time
// the callback is invoked, its listener will be removed. If multiple events
// are passed in using the space-separated syntax, the handler will fire
// once for each event, not once for a combination of all events.
Events.once = function(name, callback, context) {
// Map the event into a `{event: once}` object.
var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));
return this.on(events, void 0, context);
};
return true; // Inversion-of-control versions of `once`.
Events.listenToOnce = function(obj, name, callback) {
// Map the event into a `{event: once}` object.
var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListenin
g, this, obj));
return this.listenTo(obj, events);
};
// Reduces the event callbacks into a map of `{event: onceWrapper}`.
// `offer` unbinds the `onceWrapper` after it has been called.
var onceMap = function(map, name, callback, offer) {
if (callback) {
var once = map[name] = _.once(function() {
offer(name, once);
callback.apply(this, arguments);
});
once._callback = callback;
}
return map;
};
// Trigger one or many events, firing all bound callbacks. Callbacks are
// passed the same arguments as `trigger` is, apart from the event name
// (unless you're listening on `"all"`, which will cause your callback to
// receive the true name of the event as the first argument).
Events.trigger = function(name) {
if (!this._events) return this;
var length = Math.max(0, arguments.length - 1);
var args = Array(length);
for (var i = 0; i < length; i++) args[i] = arguments[i + 1];
eventsApi(triggerApi, this._events, name, void 0, args);
return this;
};
// Handles triggering the appropriate event callbacks.
var triggerApi = function(objEvents, name, cb, args) {
if (objEvents) {
var events = objEvents[name];
var allEvents = objEvents.all;
if (events && allEvents) allEvents = allEvents.slice();
if (events) triggerEvents(events, args);
if (allEvents) triggerEvents(allEvents, [name].concat(args));
}
return objEvents;
}; };
// A difficult-to-believe, but optimized internal dispatch function for // A difficult-to-believe, but optimized internal dispatch function for
// triggering events. Tries to keep the usual cases speedy (most internal // triggering events. Tries to keep the usual cases speedy (most internal
// Backbone events have 3 arguments). // Backbone events have 3 arguments).
var triggerEvents = function(events, args) { var triggerEvents = function(events, args) {
var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2]; var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
switch (args.length) { switch (args.length) {
case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return; case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return ; case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return ;
case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); re turn; case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); re turn;
case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3) ; return; case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3) ; return;
default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); re turn; default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); re turn;
} }
}; };
var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
// Inversion-of-control versions of `on` and `once`. Tell *this* object to
// listen to an event in another object ... keeping track of what it's
// listening to.
_.each(listenMethods, function(implementation, method) {
Events[method] = function(obj, name, callback) {
var listeningTo = this._listeningTo || (this._listeningTo = {});
var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
listeningTo[id] = obj;
if (!callback && typeof name === 'object') callback = this;
obj[implementation](name, callback, this);
return this;
};
});
// Aliases for backwards compatibility. // Aliases for backwards compatibility.
Events.bind = Events.on; Events.bind = Events.on;
Events.unbind = Events.off; Events.unbind = Events.off;
// Allow the `Backbone` object to serve as a global event bus, for folks who // Allow the `Backbone` object to serve as a global event bus, for folks who
// want global "pubsub" in a convenient place. // want global "pubsub" in a convenient place.
_.extend(Backbone, Events); _.extend(Backbone, Events);
// Backbone.Model // Backbone.Model
// -------------- // --------------
skipping to change at line 251 skipping to change at line 397
// Backbone **Models** are the basic data object in the framework -- // Backbone **Models** are the basic data object in the framework --
// frequently representing a row in a table in a database on your server. // frequently representing a row in a table in a database on your server.
// A discrete chunk of data and a bunch of useful, related methods for // A discrete chunk of data and a bunch of useful, related methods for
// performing computations and transformations on that data. // performing computations and transformations on that data.
// Create a new model with the specified attributes. A client id (`cid`) // Create a new model with the specified attributes. A client id (`cid`)
// is automatically generated and assigned for you. // is automatically generated and assigned for you.
var Model = Backbone.Model = function(attributes, options) { var Model = Backbone.Model = function(attributes, options) {
var attrs = attributes || {}; var attrs = attributes || {};
options || (options = {}); options || (options = {});
this.cid = _.uniqueId('c'); this.cid = _.uniqueId(this.cidPrefix);
this.attributes = {}; this.attributes = {};
if (options.collection) this.collection = options.collection; if (options.collection) this.collection = options.collection;
if (options.parse) attrs = this.parse(attrs, options) || {}; if (options.parse) attrs = this.parse(attrs, options) || {};
attrs = _.defaults({}, attrs, _.result(this, 'defaults')); attrs = _.defaults({}, attrs, _.result(this, 'defaults'));
this.set(attrs, options); this.set(attrs, options);
this.changed = {}; this.changed = {};
this.initialize.apply(this, arguments); this.initialize.apply(this, arguments);
}; };
// Attach all inheritable methods to the Model prototype. // Attach all inheritable methods to the Model prototype.
skipping to change at line 274 skipping to change at line 420
// A hash of attributes whose current and previous value differ. // A hash of attributes whose current and previous value differ.
changed: null, changed: null,
// The value returned during the last failed validation. // The value returned during the last failed validation.
validationError: null, validationError: null,
// The default name for the JSON `id` attribute is `"id"`. MongoDB and // The default name for the JSON `id` attribute is `"id"`. MongoDB and
// CouchDB users may want to set this to `"_id"`. // CouchDB users may want to set this to `"_id"`.
idAttribute: 'id', idAttribute: 'id',
// The prefix is used to create the client id which is used to identify mode
ls locally.
// You may want to override this if you're experiencing name clashes with mo
del ids.
cidPrefix: 'c',
// Initialize is an empty function by default. Override it with your own // Initialize is an empty function by default. Override it with your own
// initialization logic. // initialization logic.
initialize: function(){}, initialize: function(){},
// Return a copy of the model's `attributes` object. // Return a copy of the model's `attributes` object.
toJSON: function(options) { toJSON: function(options) {
return _.clone(this.attributes); return _.clone(this.attributes);
}, },
// Proxy `Backbone.sync` by default -- but override this if you need // Proxy `Backbone.sync` by default -- but override this if you need
skipping to change at line 305 skipping to change at line 455
escape: function(attr) { escape: function(attr) {
return _.escape(this.get(attr)); return _.escape(this.get(attr));
}, },
// Returns `true` if the attribute contains a value that is not null // Returns `true` if the attribute contains a value that is not null
// or undefined. // or undefined.
has: function(attr) { has: function(attr) {
return this.get(attr) != null; return this.get(attr) != null;
}, },
// Special-cased proxy to underscore's `_.matches` method.
matches: function(attrs) {
return !!_.iteratee(attrs, this)(this.attributes);
},
// Set a hash of model attributes on the object, firing `"change"`. This is // Set a hash of model attributes on the object, firing `"change"`. This is
// the core primitive operation of a model, updating the data and notifying // the core primitive operation of a model, updating the data and notifying
// anyone who needs to know about the change in state. The heart of the beas t. // anyone who needs to know about the change in state. The heart of the beas t.
set: function(key, val, options) { set: function(key, val, options) {
var attr, attrs, unset, changes, silent, changing, prev, current;
if (key == null) return this; if (key == null) return this;
// Handle both `"key", value` and `{key: value}` -style arguments. // Handle both `"key", value` and `{key: value}` -style arguments.
var attrs;
if (typeof key === 'object') { if (typeof key === 'object') {
attrs = key; attrs = key;
options = val; options = val;
} else { } else {
(attrs = {})[key] = val; (attrs = {})[key] = val;
} }
options || (options = {}); options || (options = {});
// Run validation. // Run validation.
if (!this._validate(attrs, options)) return false; if (!this._validate(attrs, options)) return false;
// Extract attributes and options. // Extract attributes and options.
unset = options.unset; var unset = options.unset;
silent = options.silent; var silent = options.silent;
changes = []; var changes = [];
changing = this._changing; var changing = this._changing;
this._changing = true; this._changing = true;
if (!changing) { if (!changing) {
this._previousAttributes = _.clone(this.attributes); this._previousAttributes = _.clone(this.attributes);
this.changed = {}; this.changed = {};
} }
current = this.attributes, prev = this._previousAttributes;
// Check for changes of `id`. var current = this.attributes;
if (this.idAttribute in attrs) this.id = attrs[this.idAttribute]; var changed = this.changed;
var prev = this._previousAttributes;
// For each `set` attribute, update or delete the current value. // For each `set` attribute, update or delete the current value.
for (attr in attrs) { for (var attr in attrs) {
val = attrs[attr]; val = attrs[attr];
if (!_.isEqual(current[attr], val)) changes.push(attr); if (!_.isEqual(current[attr], val)) changes.push(attr);
if (!_.isEqual(prev[attr], val)) { if (!_.isEqual(prev[attr], val)) {
this.changed[attr] = val; changed[attr] = val;
} else { } else {
delete this.changed[attr]; delete changed[attr];
} }
unset ? delete current[attr] : current[attr] = val; unset ? delete current[attr] : current[attr] = val;
} }
// Update the `id`.
if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);
// Trigger all relevant attribute changes. // Trigger all relevant attribute changes.
if (!silent) { if (!silent) {
if (changes.length) this._pending = options; if (changes.length) this._pending = options;
for (var i = 0, l = changes.length; i < l; i++) { for (var i = 0; i < changes.length; i++) {
this.trigger('change:' + changes[i], this, current[changes[i]], option s); this.trigger('change:' + changes[i], this, current[changes[i]], option s);
} }
} }
// You might be wondering why there's a `while` loop here. Changes can // You might be wondering why there's a `while` loop here. Changes can
// be recursively nested within `"change"` events. // be recursively nested within `"change"` events.
if (changing) return this; if (changing) return this;
if (!silent) { if (!silent) {
while (this._pending) { while (this._pending) {
options = this._pending; options = this._pending;
skipping to change at line 404 skipping to change at line 562
}, },
// Return an object containing all the attributes that have changed, or // Return an object containing all the attributes that have changed, or
// false if there are no changed attributes. Useful for determining what // 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 // 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. // persisted to the server. Unset attributes will be set to undefined.
// You can also pass an attributes object to diff against the model, // You can also pass an attributes object to diff against the model,
// determining if there *would be* a change. // determining if there *would be* a change.
changedAttributes: function(diff) { changedAttributes: function(diff) {
if (!diff) return this.hasChanged() ? _.clone(this.changed) : false; if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
var val, changed = false;
var old = this._changing ? this._previousAttributes : this.attributes; var old = this._changing ? this._previousAttributes : this.attributes;
var changed = {};
for (var attr in diff) { for (var attr in diff) {
if (_.isEqual(old[attr], (val = diff[attr]))) continue; var val = diff[attr];
(changed || (changed = {}))[attr] = val; if (_.isEqual(old[attr], val)) continue;
changed[attr] = val;
} }
return changed; return _.size(changed) ? changed : false;
}, },
// Get the previous value of an attribute, recorded at the time the last // Get the previous value of an attribute, recorded at the time the last
// `"change"` event was fired. // `"change"` event was fired.
previous: function(attr) { previous: function(attr) {
if (attr == null || !this._previousAttributes) return null; if (attr == null || !this._previousAttributes) return null;
return this._previousAttributes[attr]; return this._previousAttributes[attr];
}, },
// Get all of the attributes of the model at the time of the previous // Get all of the attributes of the model at the time of the previous
// `"change"` event. // `"change"` event.
previousAttributes: function() { previousAttributes: function() {
return _.clone(this._previousAttributes); return _.clone(this._previousAttributes);
}, },
// Fetch the model from the server. If the server's representation of the // Fetch the model from the server, merging the response with the model's
// model differs from its current attributes, they will be overridden, // local attributes. Any changed attributes will trigger a "change" event.
// triggering a `"change"` event.
fetch: function(options) { fetch: function(options) {
options = options ? _.clone(options) : {}; options = _.extend({parse: true}, options);
if (options.parse === void 0) options.parse = true;
var model = this; var model = this;
var success = options.success; var success = options.success;
options.success = function(resp) { options.success = function(resp) {
if (!model.set(model.parse(resp, options), options)) return false; var serverAttrs = options.parse ? model.parse(resp, options) : resp;
if (success) success(model, resp, options); if (!model.set(serverAttrs, options)) return false;
if (success) success.call(options.context, model, resp, options);
model.trigger('sync', model, resp, options); model.trigger('sync', model, resp, options);
}; };
wrapError(this, options); wrapError(this, options);
return this.sync('read', this, options); return this.sync('read', this, options);
}, },
// Set a hash of model attributes, and sync the model to the server. // 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 // If the server returns an attributes hash that differs, the model's
// state will be `set` again. // state will be `set` again.
save: function(key, val, options) { save: function(key, val, options) {
var attrs, method, xhr, attributes = this.attributes;
// Handle both `"key", value` and `{key: value}` -style arguments. // Handle both `"key", value` and `{key: value}` -style arguments.
var attrs;
if (key == null || typeof key === 'object') { if (key == null || typeof key === 'object') {
attrs = key; attrs = key;
options = val; options = val;
} else { } else {
(attrs = {})[key] = val; (attrs = {})[key] = val;
} }
options = _.extend({validate: true}, options); options = _.extend({validate: true, parse: true}, options);
var wait = options.wait;
// If we're not waiting and attributes exist, save acts as // If we're not waiting and attributes exist, save acts as
// `set(attr).save(null, opts)` with validation. Otherwise, check if // `set(attr).save(null, opts)` with validation. Otherwise, check if
// the model will be valid when the attributes, if any, are set. // the model will be valid when the attributes, if any, are set.
if (attrs && !options.wait) { if (attrs && !wait) {
if (!this.set(attrs, options)) return false; if (!this.set(attrs, options)) return false;
} else { } else if (!this._validate(attrs, options)) {
if (!this._validate(attrs, options)) return false; return false;
}
// Set temporary attributes if `{wait: true}`.
if (attrs && options.wait) {
this.attributes = _.extend({}, attributes, attrs);
} }
// After a successful server-side save, the client is (optionally) // After a successful server-side save, the client is (optionally)
// updated with the server-side state. // updated with the server-side state.
if (options.parse === void 0) options.parse = true;
var model = this; var model = this;
var success = options.success; var success = options.success;
var attributes = this.attributes;
options.success = function(resp) { options.success = function(resp) {
// Ensure attributes are restored during synchronous saves. // Ensure attributes are restored during synchronous saves.
model.attributes = attributes; model.attributes = attributes;
var serverAttrs = model.parse(resp, options); var serverAttrs = options.parse ? model.parse(resp, options) : resp;
if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs); if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);
if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) { if (serverAttrs && !model.set(serverAttrs, options)) return false;
return false; if (success) success.call(options.context, model, resp, options);
}
if (success) success(model, resp, options);
model.trigger('sync', model, resp, options); model.trigger('sync', model, resp, options);
}; };
wrapError(this, options); wrapError(this, options);
method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update'); // Set temporary attributes if `{wait: true}` to properly find new ids.
if (method === 'patch') options.attrs = attrs; if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);
xhr = this.sync(method, this, options);
var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update'
);
if (method === 'patch' && !options.attrs) options.attrs = attrs;
var xhr = this.sync(method, this, options);
// Restore attributes. // Restore attributes.
if (attrs && options.wait) this.attributes = attributes; this.attributes = attributes;
return xhr; return xhr;
}, },
// Destroy this model on the server if it was already persisted. // Destroy this model on the server if it was already persisted.
// Optimistically removes the model from its collection, if it has one. // Optimistically removes the model from its collection, if it has one.
// If `wait: true` is passed, waits for the server to respond before removal . // If `wait: true` is passed, waits for the server to respond before removal .
destroy: function(options) { destroy: function(options) {
options = options ? _.clone(options) : {}; options = options ? _.clone(options) : {};
var model = this; var model = this;
var success = options.success; var success = options.success;
var wait = options.wait;
var destroy = function() { var destroy = function() {
model.stopListening();
model.trigger('destroy', model, model.collection, options); model.trigger('destroy', model, model.collection, options);
}; };
options.success = function(resp) { options.success = function(resp) {
if (options.wait || model.isNew()) destroy(); if (wait) destroy();
if (success) success(model, resp, options); if (success) success.call(options.context, model, resp, options);
if (!model.isNew()) model.trigger('sync', model, resp, options); if (!model.isNew()) model.trigger('sync', model, resp, options);
}; };
var xhr = false;
if (this.isNew()) { if (this.isNew()) {
options.success(); _.defer(options.success);
return false; } else {
wrapError(this, options);
xhr = this.sync('delete', this, options);
} }
wrapError(this, options); if (!wait) destroy();
var xhr = this.sync('delete', this, options);
if (!options.wait) destroy();
return xhr; return xhr;
}, },
// Default URL for the model's representation on the server -- if you're // Default URL for the model's representation on the server -- if you're
// using Backbone's restful methods, override this to change the endpoint // using Backbone's restful methods, override this to change the endpoint
// that will be called. // that will be called.
url: function() { url: function() {
var base = var base =
_.result(this, 'urlRoot') || _.result(this, 'urlRoot') ||
_.result(this.collection, 'url') || _.result(this.collection, 'url') ||
urlError(); urlError();
if (this.isNew()) return base; if (this.isNew()) return base;
return base.replace(/([^\/])$/, '$1/') + encodeURIComponent(this.id); var id = this.get(this.idAttribute);
return base.replace(/[^\/]$/, '$&/') + encodeURIComponent(id);
}, },
// **parse** converts a response into the hash of attributes to be `set` on // **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. // the model. The default implementation is just to pass the response along.
parse: function(resp, options) { parse: function(resp, options) {
return resp; return resp;
}, },
// Create a new model with identical attributes to this one. // Create a new model with identical attributes to this one.
clone: function() { clone: function() {
return new this.constructor(this.attributes); return new this.constructor(this.attributes);
}, },
// A model is new if it has never been saved to the server, and lacks an id. // A model is new if it has never been saved to the server, and lacks an id.
isNew: function() { isNew: function() {
return !this.has(this.idAttribute); return !this.has(this.idAttribute);
}, },
// Check if the model is currently in a valid state. // Check if the model is currently in a valid state.
isValid: function(options) { isValid: function(options) {
return this._validate({}, _.extend(options || {}, { validate: true })); return this._validate({}, _.defaults({validate: true}, options));
}, },
// Run validation against the next complete set of model attributes, // Run validation against the next complete set of model attributes,
// returning `true` if all is well. Otherwise, fire an `"invalid"` event. // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
_validate: function(attrs, options) { _validate: function(attrs, options) {
if (!options.validate || !this.validate) return true; if (!options.validate || !this.validate) return true;
attrs = _.extend({}, this.attributes, attrs); attrs = _.extend({}, this.attributes, attrs);
var error = this.validationError = this.validate(attrs, options) || null; var error = this.validationError = this.validate(attrs, options) || null;
if (!error) return true; if (!error) return true;
this.trigger('invalid', this, error, _.extend(options, {validationError: e rror})); this.trigger('invalid', this, error, _.extend(options, {validationError: e rror}));
return false; return false;
} }
}); });
// Underscore methods that we want to implement on the Model. // Underscore methods that we want to implement on the Model, mapped to the
var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit']; // number of arguments they take.
var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,
omit: 0, chain: 1, isEmpty: 1};
// Mix in each Underscore method as a proxy to `Model#attributes`. // Mix in each Underscore method as a proxy to `Model#attributes`.
_.each(modelMethods, function(method) { addUnderscoreMethods(Model, modelMethods, 'attributes');
Model.prototype[method] = function() {
var args = slice.call(arguments);
args.unshift(this.attributes);
return _[method].apply(_, args);
};
});
// Backbone.Collection // Backbone.Collection
// ------------------- // -------------------
// If models tend to represent a single row of data, a Backbone Collection is // If models tend to represent a single row of data, a Backbone Collection is
// more analagous to a table full of data ... or a small slice or page of that // more analogous to a table full of data ... or a small slice or page of that
// table, or a collection of rows that belong together for a particular reason // table, or a collection of rows that belong together for a particular reason
// -- all of the messages in this particular folder, all of the documents // -- all of the messages in this particular folder, all of the documents
// belonging to this particular author, and so on. Collections maintain // belonging to this particular author, and so on. Collections maintain
// indexes of their models, both in order, and for lookup by `id`. // indexes of their models, both in order, and for lookup by `id`.
// Create a new **Collection**, perhaps to contain a specific type of `model`. // Create a new **Collection**, perhaps to contain a specific type of `model`.
// If a `comparator` is specified, the Collection will maintain // If a `comparator` is specified, the Collection will maintain
// its models in sort order, as they're added and removed. // its models in sort order, as they're added and removed.
var Collection = Backbone.Collection = function(models, options) { var Collection = Backbone.Collection = function(models, options) {
options || (options = {}); options || (options = {});
skipping to change at line 614 skipping to change at line 767
if (options.comparator !== void 0) this.comparator = options.comparator; if (options.comparator !== void 0) this.comparator = options.comparator;
this._reset(); this._reset();
this.initialize.apply(this, arguments); this.initialize.apply(this, arguments);
if (models) this.reset(models, _.extend({silent: true}, options)); if (models) this.reset(models, _.extend({silent: true}, options));
}; };
// Default options for `Collection#set`. // Default options for `Collection#set`.
var setOptions = {add: true, remove: true, merge: true}; var setOptions = {add: true, remove: true, merge: true};
var addOptions = {add: true, remove: false}; var addOptions = {add: true, remove: false};
// Splices `insert` into `array` at index `at`.
var splice = function(array, insert, at) {
at = Math.min(Math.max(at, 0), array.length);
var tail = Array(array.length - at);
var length = insert.length;
for (var i = 0; i < tail.length; i++) tail[i] = array[i + at];
for (i = 0; i < length; i++) array[i + at] = insert[i];
for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];
};
// Define the Collection's inheritable methods. // Define the Collection's inheritable methods.
_.extend(Collection.prototype, Events, { _.extend(Collection.prototype, Events, {
// The default model for a collection is just a **Backbone.Model**. // The default model for a collection is just a **Backbone.Model**.
// This should be overridden in most cases. // This should be overridden in most cases.
model: Model, model: Model,
// Initialize is an empty function by default. Override it with your own // Initialize is an empty function by default. Override it with your own
// initialization logic. // initialization logic.
initialize: function(){}, initialize: function(){},
// The JSON representation of a Collection is an array of the // The JSON representation of a Collection is an array of the
// models' attributes. // models' attributes.
toJSON: function(options) { toJSON: function(options) {
return this.map(function(model){ return model.toJSON(options); }); return this.map(function(model) { return model.toJSON(options); });
}, },
// Proxy `Backbone.sync` by default. // Proxy `Backbone.sync` by default.
sync: function() { sync: function() {
return Backbone.sync.apply(this, arguments); return Backbone.sync.apply(this, arguments);
}, },
// Add a model, or list of models to the set. // Add a model, or list of models to the set. `models` may be Backbone
// Models or raw JavaScript objects to be converted to Models, or any
// combination of the two.
add: function(models, options) { add: function(models, options) {
return this.set(models, _.extend({merge: false}, options, addOptions)); return this.set(models, _.extend({merge: false}, options, addOptions));
}, },
// Remove a model, or a list of models from the set. // Remove a model, or a list of models from the set.
remove: function(models, options) { remove: function(models, options) {
options = _.extend({}, options);
var singular = !_.isArray(models); var singular = !_.isArray(models);
models = singular ? [models] : _.clone(models); models = singular ? [models] : models.slice();
options || (options = {}); var removed = this._removeModels(models, options);
var i, l, index, model; if (!options.silent && removed.length) this.trigger('update', this, option
for (i = 0, l = models.length; i < l; i++) { s);
model = models[i] = this.get(models[i]); return singular ? removed[0] : removed;
if (!model) continue;
delete this._byId[model.id];
delete this._byId[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);
}
this._removeReference(model, options);
}
return singular ? models[0] : models;
}, },
// Update a collection by `set`-ing a new list of models, adding new ones, // Update a collection by `set`-ing a new list of models, adding new ones,
// removing models that are no longer present, and merging models that // removing models that are no longer present, and merging models that
// already exist in the collection, as necessary. Similar to **Model#set**, // already exist in the collection, as necessary. Similar to **Model#set**,
// the core operation for updating the data contained by the collection. // the core operation for updating the data contained by the collection.
set: function(models, options) { set: function(models, options) {
if (models == null) return;
options = _.defaults({}, options, setOptions); options = _.defaults({}, options, setOptions);
if (options.parse) models = this.parse(models, options); if (options.parse && !this._isModel(models)) models = this.parse(models, o
ptions);
var singular = !_.isArray(models); var singular = !_.isArray(models);
models = singular ? (models ? [models] : []) : _.clone(models); models = singular ? (models ? [models] : []) : models.slice();
var i, l, id, model, attrs, existing, sort;
var at = options.at; var at = options.at;
var targetModel = this.model; if (at != null) at = +at;
var sortable = this.comparator && (at == null) && options.sort !== false; if (at < 0) at += this.length + 1;
var set = [];
var toAdd = [];
var toRemove = [];
var modelMap = {};
var add = options.add;
var merge = options.merge;
var remove = options.remove;
var sort = false;
var sortable = this.comparator && at == null && options.sort !== false;
var sortAttr = _.isString(this.comparator) ? this.comparator : null; var sortAttr = _.isString(this.comparator) ? this.comparator : null;
var toAdd = [], toRemove = [], modelMap = {};
var add = options.add, merge = options.merge, remove = options.remove;
var order = !sortable && add && remove ? [] : false;
// Turn bare objects into model references, and prevent invalid models // Turn bare objects into model references, and prevent invalid models
// from being added. // from being added.
for (i = 0, l = models.length; i < l; i++) { var model;
attrs = models[i] || {}; for (var i = 0; i < models.length; i++) {
if (attrs instanceof Model) { model = models[i];
id = model = attrs;
} else {
id = attrs[targetModel.prototype.idAttribute || 'id'];
}
// If a duplicate is found, prevent it from being added and // If a duplicate is found, prevent it from being added and
// optionally merge it into the existing model. // optionally merge it into the existing model.
if (existing = this.get(id)) { var existing = this.get(model);
if (remove) modelMap[existing.cid] = true; if (existing) {
if (merge) { if (merge && model !== existing) {
attrs = attrs === model ? model.attributes : attrs; var attrs = this._isModel(model) ? model.attributes : model;
if (options.parse) attrs = existing.parse(attrs, options); if (options.parse) attrs = existing.parse(attrs, options);
existing.set(attrs, options); existing.set(attrs, options);
if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true; if (sortable && !sort) sort = existing.hasChanged(sortAttr);
}
if (!modelMap[existing.cid]) {
modelMap[existing.cid] = true;
set.push(existing);
} }
models[i] = existing; models[i] = existing;
// If this is a new, valid model, push it to the `toAdd` list. // If this is a new, valid model, push it to the `toAdd` list.
} else if (add) { } else if (add) {
model = models[i] = this._prepareModel(attrs, options); model = models[i] = this._prepareModel(model, options);
if (!model) continue; if (model) {
toAdd.push(model); toAdd.push(model);
this._addReference(model, options); this._addReference(model, options);
modelMap[model.cid] = true;
set.push(model);
}
} }
// Do not add multiple models with the same `id`.
model = existing || model;
if (order && (model.isNew() || !modelMap[model.id])) order.push(model);
modelMap[model.id] = true;
} }
// Remove nonexistent models if appropriate. // Remove stale models.
if (remove) { if (remove) {
for (i = 0, l = this.length; i < l; ++i) { for (i = 0; i < this.length; i++) {
if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model); model = this.models[i];
if (!modelMap[model.cid]) toRemove.push(model);
} }
if (toRemove.length) this.remove(toRemove, options); if (toRemove.length) this._removeModels(toRemove, options);
} }
// See if sorting is needed, update `length` and splice in new models. // See if sorting is needed, update `length` and splice in new models.
if (toAdd.length || (order && order.length)) { var orderChanged = false;
var replace = !sortable && add && remove;
if (set.length && replace) {
orderChanged = this.length != set.length || _.some(this.models, function
(model, index) {
return model !== set[index];
});
this.models.length = 0;
splice(this.models, set, 0);
this.length = this.models.length;
} else if (toAdd.length) {
if (sortable) sort = true; if (sortable) sort = true;
this.length += toAdd.length; splice(this.models, toAdd, at == null ? this.length : at);
if (at != null) { this.length = this.models.length;
for (i = 0, l = toAdd.length; i < l; i++) {
this.models.splice(at + i, 0, toAdd[i]);
}
} else {
if (order) this.models.length = 0;
var orderedModels = order || toAdd;
for (i = 0, l = orderedModels.length; i < l; i++) {
this.models.push(orderedModels[i]);
}
}
} }
// Silently sort the collection if appropriate. // Silently sort the collection if appropriate.
if (sort) this.sort({silent: true}); if (sort) this.sort({silent: true});
// Unless silenced, it's time to fire all appropriate add/sort events. // Unless silenced, it's time to fire all appropriate add/sort events.
if (!options.silent) { if (!options.silent) {
for (i = 0, l = toAdd.length; i < l; i++) { for (i = 0; i < toAdd.length; i++) {
(model = toAdd[i]).trigger('add', model, this, options); if (at != null) options.index = at + i;
model = toAdd[i];
model.trigger('add', model, this, options);
} }
if (sort || (order && order.length)) this.trigger('sort', this, options) if (sort || orderChanged) this.trigger('sort', this, options);
; if (toAdd.length || toRemove.length) this.trigger('update', this, option
s);
} }
// Return the added (or merged) model (or models). // Return the added (or merged) model (or models).
return singular ? models[0] : models; return singular ? models[0] : models;
}, },
// When you have more items than you want to add or remove individually, // 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 // you can reset the entire set with a new list of models, without firing
// any granular `add` or `remove` events. Fires `reset` when finished. // any granular `add` or `remove` events. Fires `reset` when finished.
// Useful for bulk operations and optimizations. // Useful for bulk operations and optimizations.
reset: function(models, options) { reset: function(models, options) {
options || (options = {}); options = options ? _.clone(options) : {};
for (var i = 0, l = this.models.length; i < l; i++) { for (var i = 0; i < this.models.length; i++) {
this._removeReference(this.models[i], options); this._removeReference(this.models[i], options);
} }
options.previousModels = this.models; options.previousModels = this.models;
this._reset(); this._reset();
models = this.add(models, _.extend({silent: true}, options)); models = this.add(models, _.extend({silent: true}, options));
if (!options.silent) this.trigger('reset', this, options); if (!options.silent) this.trigger('reset', this, options);
return models; return models;
}, },
// Add a model to the end of the collection. // Add a model to the end of the collection.
push: function(model, options) { push: function(model, options) {
return this.add(model, _.extend({at: this.length}, options)); return this.add(model, _.extend({at: this.length}, options));
}, },
// Remove a model from the end of the collection. // Remove a model from the end of the collection.
pop: function(options) { pop: function(options) {
var model = this.at(this.length - 1); var model = this.at(this.length - 1);
this.remove(model, options); return this.remove(model, options);
return model;
}, },
// Add a model to the beginning of the collection. // Add a model to the beginning of the collection.
unshift: function(model, options) { unshift: function(model, options) {
return this.add(model, _.extend({at: 0}, options)); return this.add(model, _.extend({at: 0}, options));
}, },
// Remove a model from the beginning of the collection. // Remove a model from the beginning of the collection.
shift: function(options) { shift: function(options) {
var model = this.at(0); var model = this.at(0);
this.remove(model, options); return this.remove(model, options);
return model;
}, },
// Slice out a sub-array of models from the collection. // Slice out a sub-array of models from the collection.
slice: function() { slice: function() {
return slice.apply(this.models, arguments); return slice.apply(this.models, arguments);
}, },
// Get a model from the set by id. // Get a model from the set by id.
get: function(obj) { get: function(obj) {
if (obj == null) return void 0; if (obj == null) return void 0;
return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid]; var id = this.modelId(this._isModel(obj) ? obj.attributes : obj);
return this._byId[obj] || this._byId[id] || this._byId[obj.cid];
}, },
// Get the model at the given index. // Get the model at the given index.
at: function(index) { at: function(index) {
if (index < 0) index += this.length;
return this.models[index]; return this.models[index];
}, },
// Return models with matching attributes. Useful for simple cases of // Return models with matching attributes. Useful for simple cases of
// `filter`. // `filter`.
where: function(attrs, first) { where: function(attrs, first) {
if (_.isEmpty(attrs)) return first ? void 0 : []; return this[first ? 'find' : 'filter'](attrs);
return this[first ? 'find' : 'filter'](function(model) {
for (var key in attrs) {
if (attrs[key] !== model.get(key)) return false;
}
return true;
});
}, },
// Return the first model with matching attributes. Useful for simple cases // Return the first model with matching attributes. Useful for simple cases
// of `find`. // of `find`.
findWhere: function(attrs) { findWhere: function(attrs) {
return this.where(attrs, true); return this.where(attrs, true);
}, },
// Force the collection to re-sort itself. You don't need to call this under // 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 // normal circumstances, as the set will maintain sort order as each item
// is added. // is added.
sort: function(options) { sort: function(options) {
if (!this.comparator) throw new Error('Cannot sort a set without a compara var comparator = this.comparator;
tor'); if (!comparator) throw new Error('Cannot sort a set without a comparator')
;
options || (options = {}); options || (options = {});
var length = comparator.length;
if (_.isFunction(comparator)) comparator = _.bind(comparator, this);
// Run sort based on type of `comparator`. // Run sort based on type of `comparator`.
if (_.isString(this.comparator) || this.comparator.length === 1) { if (length === 1 || _.isString(comparator)) {
this.models = this.sortBy(this.comparator, this); this.models = this.sortBy(comparator);
} else { } else {
this.models.sort(_.bind(this.comparator, this)); this.models.sort(comparator);
} }
if (!options.silent) this.trigger('sort', this, options); if (!options.silent) this.trigger('sort', this, options);
return this; return this;
}, },
// Pluck an attribute from each model in the collection. // Pluck an attribute from each model in the collection.
pluck: function(attr) { pluck: function(attr) {
return _.invoke(this.models, 'get', attr); return this.map(attr + '');
}, },
// Fetch the default set of models for this collection, resetting the // Fetch the default set of models for this collection, resetting the
// collection when they arrive. If `reset: true` is passed, the response // collection when they arrive. If `reset: true` is passed, the response
// data will be passed through the `reset` method instead of `set`. // data will be passed through the `reset` method instead of `set`.
fetch: function(options) { fetch: function(options) {
options = options ? _.clone(options) : {}; options = _.extend({parse: true}, options);
if (options.parse === void 0) options.parse = true;
var success = options.success; var success = options.success;
var collection = this; var collection = this;
options.success = function(resp) { options.success = function(resp) {
var method = options.reset ? 'reset' : 'set'; var method = options.reset ? 'reset' : 'set';
collection[method](resp, options); collection[method](resp, options);
if (success) success(collection, resp, options); if (success) success.call(options.context, collection, resp, options);
collection.trigger('sync', collection, resp, options); collection.trigger('sync', collection, resp, options);
}; };
wrapError(this, options); wrapError(this, options);
return this.sync('read', this, options); return this.sync('read', this, options);
}, },
// Create a new instance of a model in this collection. Add the model to the // 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 // collection immediately, unless `wait: true` is passed, in which case we
// wait for the server to agree. // wait for the server to agree.
create: function(model, options) { create: function(model, options) {
options = options ? _.clone(options) : {}; options = options ? _.clone(options) : {};
if (!(model = this._prepareModel(model, options))) return false; var wait = options.wait;
if (!options.wait) this.add(model, options); model = this._prepareModel(model, options);
if (!model) return false;
if (!wait) this.add(model, options);
var collection = this; var collection = this;
var success = options.success; var success = options.success;
options.success = function(model, resp) { options.success = function(model, resp, callbackOpts) {
if (options.wait) collection.add(model, options); if (wait) collection.add(model, callbackOpts);
if (success) success(model, resp, options); if (success) success.call(callbackOpts.context, model, resp, callbackOpt
s);
}; };
model.save(null, options); model.save(null, options);
return model; return model;
}, },
// **parse** converts a response into a list of models to be added to the // **parse** converts a response into a list of models to be added to the
// collection. The default implementation is just to pass it through. // collection. The default implementation is just to pass it through.
parse: function(resp, options) { parse: function(resp, options) {
return resp; return resp;
}, },
// Create a new collection with an identical list of models as this one. // Create a new collection with an identical list of models as this one.
clone: function() { clone: function() {
return new this.constructor(this.models); return new this.constructor(this.models, {
model: this.model,
comparator: this.comparator
});
},
// Define how to uniquely identify models in the collection.
modelId: function(attrs) {
return attrs[this.model.prototype.idAttribute || 'id'];
}, },
// Private method to reset all internal state. Called when the collection // Private method to reset all internal state. Called when the collection
// is first initialized or reset. // is first initialized or reset.
_reset: function() { _reset: function() {
this.length = 0; this.length = 0;
this.models = []; this.models = [];
this._byId = {}; this._byId = {};
}, },
// Prepare a hash of attributes (or other model) to be added to this // Prepare a hash of attributes (or other model) to be added to this
// collection. // collection.
_prepareModel: function(attrs, options) { _prepareModel: function(attrs, options) {
if (attrs instanceof Model) return attrs; if (this._isModel(attrs)) {
if (!attrs.collection) attrs.collection = this;
return attrs;
}
options = options ? _.clone(options) : {}; options = options ? _.clone(options) : {};
options.collection = this; options.collection = this;
var model = new this.model(attrs, options); var model = new this.model(attrs, options);
if (!model.validationError) return model; if (!model.validationError) return model;
this.trigger('invalid', this, model.validationError, options); this.trigger('invalid', this, model.validationError, options);
return false; return false;
}, },
// Internal method called by both remove and set.
_removeModels: function(models, options) {
var removed = [];
for (var i = 0; i < models.length; i++) {
var model = this.get(models[i]);
if (!model) continue;
var index = this.indexOf(model);
this.models.splice(index, 1);
this.length--;
// Remove references before triggering 'remove' event to prevent an
// infinite loop. #3693
delete this._byId[model.cid];
var id = this.modelId(model.attributes);
if (id != null) delete this._byId[id];
if (!options.silent) {
options.index = index;
model.trigger('remove', model, this, options);
}
removed.push(model);
this._removeReference(model, options);
}
return removed;
},
// Method for checking whether an object should be considered a model for
// the purposes of adding to the collection.
_isModel: function(model) {
return model instanceof Model;
},
// Internal method to create a model's ties to a collection. // Internal method to create a model's ties to a collection.
_addReference: function(model, options) { _addReference: function(model, options) {
this._byId[model.cid] = model; this._byId[model.cid] = model;
if (model.id != null) this._byId[model.id] = model; var id = this.modelId(model.attributes);
if (!model.collection) model.collection = this; if (id != null) this._byId[id] = model;
model.on('all', this._onModelEvent, this); model.on('all', this._onModelEvent, this);
}, },
// Internal method to sever a model's ties to a collection. // Internal method to sever a model's ties to a collection.
_removeReference: function(model, options) { _removeReference: function(model, options) {
delete this._byId[model.cid];
var id = this.modelId(model.attributes);
if (id != null) delete this._byId[id];
if (this === model.collection) delete model.collection; if (this === model.collection) delete model.collection;
model.off('all', this._onModelEvent, this); model.off('all', this._onModelEvent, this);
}, },
// Internal method called every time a model in the set fires an event. // 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 // Sets need to update their indexes when models change ids. All other
// events simply proxy through. "add" and "remove" events that originate // events simply proxy through. "add" and "remove" events that originate
// in other collections are ignored. // in other collections are ignored.
_onModelEvent: function(event, model, collection, options) { _onModelEvent: function(event, model, collection, options) {
if ((event === 'add' || event === 'remove') && collection !== this) return if (model) {
; if ((event === 'add' || event === 'remove') && collection !== this) retu
if (event === 'destroy') this.remove(model, options); rn;
if (model && event === 'change:' + model.idAttribute) { if (event === 'destroy') this.remove(model, options);
delete this._byId[model.previous(model.idAttribute)]; if (event === 'change') {
if (model.id != null) this._byId[model.id] = model; var prevId = this.modelId(model.previousAttributes());
var id = this.modelId(model.attributes);
if (prevId !== id) {
if (prevId != null) delete this._byId[prevId];
if (id != null) this._byId[id] = model;
}
}
} }
this.trigger.apply(this, arguments); this.trigger.apply(this, arguments);
} }
}); });
// Underscore methods that we want to implement on the Collection. // Underscore methods that we want to implement on the Collection.
// 90% of the core usefulness of Backbone Collections is actually implemented // 90% of the core usefulness of Backbone Collections is actually implemented
// right here: // right here:
var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl', var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,
'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select', foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter:
'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke', 3,
'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest', select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, inclu
'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle', des: 3,
'lastIndexOf', 'isEmpty', 'chain', 'sample']; contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,
head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,
without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,
isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,
sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};
// Mix in each Underscore method as a proxy to `Collection#models`. // Mix in each Underscore method as a proxy to `Collection#models`.
_.each(methods, function(method) { addUnderscoreMethods(Collection, collectionMethods, 'models');
Collection.prototype[method] = function() {
var args = slice.call(arguments);
args.unshift(this.models);
return _[method].apply(_, args);
};
});
// Underscore methods that take a property name as an argument.
var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];
// Use attributes instead of properties.
_.each(attributeMethods, function(method) {
Collection.prototype[method] = function(value, context) {
var iterator = _.isFunction(value) ? value : function(model) {
return model.get(value);
};
return _[method](this.models, iterator, context);
};
});
// Backbone.View // Backbone.View
// ------------- // -------------
// Backbone Views are almost more convention than they are actual code. A View // Backbone Views are almost more convention than they are actual code. A View
// is simply a JavaScript object that represents a logical chunk of UI in the // is simply a JavaScript object that represents a logical chunk of UI in the
// DOM. This might be a single item, an entire list, a sidebar or panel, or // DOM. This might be a single item, an entire list, a sidebar or panel, or
// even the surrounding frame which wraps your whole app. Defining a chunk of // even the surrounding frame which wraps your whole app. Defining a chunk of
// UI as a **View** allows you to define your DOM events declaratively, withou t // UI as a **View** allows you to define your DOM events declaratively, withou t
// having to worry about render order ... and makes it easy for the view to // having to worry about render order ... and makes it easy for the view to
// react to specific changes in the state of your models. // react to specific changes in the state of your models.
// Creating a Backbone.View creates its initial element outside of the DOM, // Creating a Backbone.View creates its initial element outside of the DOM,
// if an existing element is not provided... // if an existing element is not provided...
var View = Backbone.View = function(options) { var View = Backbone.View = function(options) {
this.cid = _.uniqueId('view'); this.cid = _.uniqueId('view');
options || (options = {});
_.extend(this, _.pick(options, viewOptions)); _.extend(this, _.pick(options, viewOptions));
this._ensureElement(); this._ensureElement();
this.initialize.apply(this, arguments); this.initialize.apply(this, arguments);
this.delegateEvents();
}; };
// Cached regex to split keys for `delegate`. // Cached regex to split keys for `delegate`.
var delegateEventSplitter = /^(\S+)\s*(.*)$/; var delegateEventSplitter = /^(\S+)\s*(.*)$/;
// List of view options to be merged as properties. // List of view options to be set as properties.
var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className ', 'tagName', 'events']; var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className ', 'tagName', 'events'];
// Set up all inheritable **Backbone.View** properties and methods. // Set up all inheritable **Backbone.View** properties and methods.
_.extend(View.prototype, Events, { _.extend(View.prototype, Events, {
// The default `tagName` of a View's element is `"div"`. // The default `tagName` of a View's element is `"div"`.
tagName: 'div', tagName: 'div',
// jQuery delegate for element lookup, scoped to DOM elements within the // jQuery delegate for element lookup, scoped to DOM elements within the
// current view. This should be preferred to global lookups where possible. // current view. This should be preferred to global lookups where possible.
skipping to change at line 1037 skipping to change at line 1235
// **render** is the core function that your view should override, in order // **render** is the core function that your view should override, in order
// to populate its element (`this.el`), with the appropriate HTML. The // to populate its element (`this.el`), with the appropriate HTML. The
// convention is for **render** to always return `this`. // convention is for **render** to always return `this`.
render: function() { render: function() {
return this; return this;
}, },
// Remove this view by taking the element out of the DOM, and removing any // Remove this view by taking the element out of the DOM, and removing any
// applicable Backbone.Events listeners. // applicable Backbone.Events listeners.
remove: function() { remove: function() {
this.$el.remove(); this._removeElement();
this.stopListening(); this.stopListening();
return this; return this;
}, },
// Change the view's element (`this.el` property), including event // Remove this view's element from the document and all event listeners
// re-delegation. // attached to it. Exposed for subclasses using an alternative DOM
setElement: function(element, delegate) { // manipulation API.
if (this.$el) this.undelegateEvents(); _removeElement: function() {
this.$el = element instanceof Backbone.$ ? element : Backbone.$(element); this.$el.remove();
this.el = this.$el[0]; },
if (delegate !== false) this.delegateEvents();
// Change the view's element (`this.el` property) and re-delegate the
// view's events on the new element.
setElement: function(element) {
this.undelegateEvents();
this._setElement(element);
this.delegateEvents();
return this; return this;
}, },
// Creates the `this.el` and `this.$el` references for this view using the
// given `el`. `el` can be a CSS selector or an HTML string, a jQuery
// context or an element. Subclasses can override this to utilize an
// alternative DOM manipulation API and are only required to set the
// `this.el` property.
_setElement: function(el) {
this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);
this.el = this.$el[0];
},
// Set callbacks, where `this.events` is a hash of // Set callbacks, where `this.events` is a hash of
// //
// *{"event selector": "callback"}* // *{"event selector": "callback"}*
// //
// { // {
// 'mousedown .title': 'edit', // 'mousedown .title': 'edit',
// 'click .button': 'save', // 'click .button': 'save',
// 'click .open': function(e) { ... } // 'click .open': function(e) { ... }
// } // }
// //
// pairs. Callbacks will be bound to the view, with `this` set properly. // pairs. Callbacks will be bound to the view, with `this` set properly.
// Uses event delegation for efficiency. // Uses event delegation for efficiency.
// Omitting the selector binds the event to `this.el`. // 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) { delegateEvents: function(events) {
if (!(events || (events = _.result(this, 'events')))) return this; events || (events = _.result(this, 'events'));
if (!events) return this;
this.undelegateEvents(); this.undelegateEvents();
for (var key in events) { for (var key in events) {
var method = events[key]; var method = events[key];
if (!_.isFunction(method)) method = this[events[key]]; if (!_.isFunction(method)) method = this[method];
if (!method) continue; if (!method) continue;
var match = key.match(delegateEventSplitter); var match = key.match(delegateEventSplitter);
var eventName = match[1], selector = match[2]; this.delegate(match[1], match[2], _.bind(method, this));
method = _.bind(method, this);
eventName += '.delegateEvents' + this.cid;
if (selector === '') {
this.$el.on(eventName, method);
} else {
this.$el.on(eventName, selector, method);
}
} }
return this; return this;
}, },
// Clears all callbacks previously bound to the view with `delegateEvents`. // Add a single event listener to the view's element (or a child element
// using `selector`). This only works for delegate-able events: not `focus`,
// `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.
delegate: function(eventName, selector, listener) {
this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);
return this;
},
// Clears all callbacks previously bound to the view by `delegateEvents`.
// You usually don't need to use this, but may wish to if you have multiple // You usually don't need to use this, but may wish to if you have multiple
// Backbone views attached to the same DOM element. // Backbone views attached to the same DOM element.
undelegateEvents: function() { undelegateEvents: function() {
this.$el.off('.delegateEvents' + this.cid); if (this.$el) this.$el.off('.delegateEvents' + this.cid);
return this;
},
// A finer-grained `undelegateEvents` for removing a single delegated event.
// `selector` and `listener` are both optional.
undelegate: function(eventName, selector, listener) {
this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener)
;
return this; return this;
}, },
// Produces a DOM element to be assigned to your view. Exposed for
// subclasses using an alternative DOM manipulation API.
_createElement: function(tagName) {
return document.createElement(tagName);
},
// Ensure that the View has a DOM element to render into. // Ensure that the View has a DOM element to render into.
// If `this.el` is a string, pass it through `$()`, take the first // If `this.el` is a string, pass it through `$()`, take the first
// matching element, and re-assign it to `el`. Otherwise, create // matching element, and re-assign it to `el`. Otherwise, create
// an element from the `id`, `className` and `tagName` properties. // an element from the `id`, `className` and `tagName` properties.
_ensureElement: function() { _ensureElement: function() {
if (!this.el) { if (!this.el) {
var attrs = _.extend({}, _.result(this, 'attributes')); var attrs = _.extend({}, _.result(this, 'attributes'));
if (this.id) attrs.id = _.result(this, 'id'); if (this.id) attrs.id = _.result(this, 'id');
if (this.className) attrs['class'] = _.result(this, 'className'); if (this.className) attrs['class'] = _.result(this, 'className');
var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs); this.setElement(this._createElement(_.result(this, 'tagName')));
this.setElement($el, false); this._setAttributes(attrs);
} else { } else {
this.setElement(_.result(this, 'el'), false); this.setElement(_.result(this, 'el'));
} }
},
// Set attributes from a hash on this view's element. Exposed for
// subclasses using an alternative DOM manipulation API.
_setAttributes: function(attributes) {
this.$el.attr(attributes);
} }
}); });
// Backbone.sync // Backbone.sync
// ------------- // -------------
// Override this function to change the manner in which Backbone persists // 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 // models to the server. You will be passed the type of request, and the
// model in question. By default, makes a RESTful Ajax request // model in question. By default, makes a RESTful Ajax request
skipping to change at line 1178 skipping to change at line 1410
xhr.setRequestHeader('X-HTTP-Method-Override', type); xhr.setRequestHeader('X-HTTP-Method-Override', type);
if (beforeSend) return beforeSend.apply(this, arguments); if (beforeSend) return beforeSend.apply(this, arguments);
}; };
} }
// Don't process data on a non-GET request. // Don't process data on a non-GET request.
if (params.type !== 'GET' && !options.emulateJSON) { if (params.type !== 'GET' && !options.emulateJSON) {
params.processData = false; params.processData = false;
} }
// If we're sending a `PATCH` request, and we're in an old Internet Explorer // Pass along `textStatus` and `errorThrown` from jQuery.
// that still has ActiveX enabled by default, override jQuery to use that var error = options.error;
// for XHR instead. Remove this line when jQuery supports `PATCH` on IE8. options.error = function(xhr, textStatus, errorThrown) {
if (params.type === 'PATCH' && noXhrPatch) { options.textStatus = textStatus;
params.xhr = function() { options.errorThrown = errorThrown;
return new ActiveXObject("Microsoft.XMLHTTP"); if (error) error.call(options.context, xhr, textStatus, errorThrown);
}; };
}
// Make the request, allowing the user to override any Ajax options. // Make the request, allowing the user to override any Ajax options.
var xhr = options.xhr = Backbone.ajax(_.extend(params, options)); var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
model.trigger('request', model, xhr, options); model.trigger('request', model, xhr, options);
return xhr; return xhr;
}; };
var noXhrPatch =
typeof window !== 'undefined' && !!window.ActiveXObject &&
!(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);
// Map from CRUD to HTTP for our default `Backbone.sync` implementation. // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
var methodMap = { var methodMap = {
'create': 'POST', 'create': 'POST',
'update': 'PUT', 'update': 'PUT',
'patch': 'PATCH', 'patch': 'PATCH',
'delete': 'DELETE', 'delete': 'DELETE',
'read': 'GET' 'read': 'GET'
}; };
// Set the default implementation of `Backbone.ajax` to proxy through to `$`. // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
// Override this if you'd like to use a different library. // Override this if you'd like to use a different library.
Backbone.ajax = function() { Backbone.ajax = function() {
return Backbone.$.ajax.apply(Backbone.$, arguments); return Backbone.$.ajax.apply(Backbone.$, arguments);
}; };
// Backbone.Router // Backbone.Router
// --------------- // ---------------
skipping to change at line 1254 skipping to change at line 1481
route: function(route, name, callback) { route: function(route, name, callback) {
if (!_.isRegExp(route)) route = this._routeToRegExp(route); if (!_.isRegExp(route)) route = this._routeToRegExp(route);
if (_.isFunction(name)) { if (_.isFunction(name)) {
callback = name; callback = name;
name = ''; name = '';
} }
if (!callback) callback = this[name]; if (!callback) callback = this[name];
var router = this; var router = this;
Backbone.history.route(route, function(fragment) { Backbone.history.route(route, function(fragment) {
var args = router._extractParameters(route, fragment); var args = router._extractParameters(route, fragment);
router.execute(callback, args); if (router.execute(callback, args, name) !== false) {
router.trigger.apply(router, ['route:' + name].concat(args)); router.trigger.apply(router, ['route:' + name].concat(args));
router.trigger('route', name, args); router.trigger('route', name, args);
Backbone.history.trigger('route', router, name, args); Backbone.history.trigger('route', router, name, args);
}
}); });
return this; return this;
}, },
// Execute a route handler with the provided parameters. This is an // Execute a route handler with the provided parameters. This is an
// excellent place to do pre-route setup or post-route cleanup. // excellent place to do pre-route setup or post-route cleanup.
execute: function(callback, args) { execute: function(callback, args, name) {
if (callback) callback.apply(this, args); if (callback) callback.apply(this, args);
}, },
// Simple proxy to `Backbone.history` to save a fragment into the history. // Simple proxy to `Backbone.history` to save a fragment into the history.
navigate: function(fragment, options) { navigate: function(fragment, options) {
Backbone.history.navigate(fragment, options); Backbone.history.navigate(fragment, options);
return this; return this;
}, },
// Bind all defined routes to `Backbone.history`. We have to reverse the // Bind all defined routes to `Backbone.history`. We have to reverse the
skipping to change at line 1322 skipping to change at line 1550
// Backbone.History // Backbone.History
// ---------------- // ----------------
// Handles cross-browser history management, based on either // Handles cross-browser history management, based on either
// [pushState](http://diveintohtml5.info/history.html) and real URLs, or // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
// [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashch ange) // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashch ange)
// and URL fragments. If the browser supports neither (old IE, natch), // and URL fragments. If the browser supports neither (old IE, natch),
// falls back to polling. // falls back to polling.
var History = Backbone.History = function() { var History = Backbone.History = function() {
this.handlers = []; this.handlers = [];
_.bindAll(this, 'checkUrl'); this.checkUrl = _.bind(this.checkUrl, this);
// Ensure that `History` can be used outside of the browser. // Ensure that `History` can be used outside of the browser.
if (typeof window !== 'undefined') { if (typeof window !== 'undefined') {
this.location = window.location; this.location = window.location;
this.history = window.history; this.history = window.history;
} }
}; };
// Cached regex for stripping a leading hash/slash and trailing space. // Cached regex for stripping a leading hash/slash and trailing space.
var routeStripper = /^[#\/]|\s+$/g; var routeStripper = /^[#\/]|\s+$/g;
// Cached regex for stripping leading and trailing slashes. // Cached regex for stripping leading and trailing slashes.
var rootStripper = /^\/+|\/+$/g; var rootStripper = /^\/+|\/+$/g;
// Cached regex for detecting MSIE.
var isExplorer = /msie [\w.]+/;
// Cached regex for removing a trailing slash.
var trailingSlash = /\/$/;
// Cached regex for stripping urls of hash. // Cached regex for stripping urls of hash.
var pathStripper = /#.*$/; var pathStripper = /#.*$/;
// Has the history handling already been started? // Has the history handling already been started?
History.started = false; History.started = false;
// Set up all inheritable **Backbone.History** properties and methods. // Set up all inheritable **Backbone.History** properties and methods.
_.extend(History.prototype, Events, { _.extend(History.prototype, Events, {
// The default interval to poll for hash changes, if necessary, is // The default interval to poll for hash changes, if necessary, is
// twenty times a second. // twenty times a second.
interval: 50, interval: 50,
// Are we at the app root? // Are we at the app root?
atRoot: function() { atRoot: function() {
return this.location.pathname.replace(/[^\/]$/, '$&/') === this.root; var path = this.location.pathname.replace(/[^\/]$/, '$&/');
return path === this.root && !this.getSearch();
},
// Does the pathname match the root?
matchRoot: function() {
var path = this.decodeFragment(this.location.pathname);
var root = path.slice(0, this.root.length - 1) + '/';
return root === this.root;
},
// Unicode characters in `location.pathname` are percent encoded so they're
// decoded for comparison. `%25` should not be decoded since it may be part
// of an encoded parameter.
decodeFragment: function(fragment) {
return decodeURI(fragment.replace(/%25/g, '%2525'));
},
// In IE6, the hash fragment and search params are incorrect if the
// fragment contains `?`.
getSearch: function() {
var match = this.location.href.replace(/#.*/, '').match(/\?.+/);
return match ? match[0] : '';
}, },
// Gets the true hash value. Cannot use location.hash directly due to bug // Gets the true hash value. Cannot use location.hash directly due to bug
// in Firefox where location.hash will always be decoded. // in Firefox where location.hash will always be decoded.
getHash: function(window) { getHash: function(window) {
var match = (window || this).location.href.match(/#(.*)$/); var match = (window || this).location.href.match(/#(.*)$/);
return match ? match[1] : ''; return match ? match[1] : '';
}, },
// Get the cross-browser normalized URL fragment, either from the URL, // Get the pathname and search params, without the root.
// the hash, or the override. getPath: function() {
getFragment: function(fragment, forcePushState) { var path = this.decodeFragment(
this.location.pathname + this.getSearch()
).slice(this.root.length - 1);
return path.charAt(0) === '/' ? path.slice(1) : path;
},
// Get the cross-browser normalized URL fragment from the path or hash.
getFragment: function(fragment) {
if (fragment == null) { if (fragment == null) {
if (this._hasPushState || !this._wantsHashChange || forcePushState) { if (this._usePushState || !this._wantsHashChange) {
fragment = decodeURI(this.location.pathname + this.location.search); fragment = this.getPath();
var root = this.root.replace(trailingSlash, '');
if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
} else { } else {
fragment = this.getHash(); fragment = this.getHash();
} }
} }
return fragment.replace(routeStripper, ''); return fragment.replace(routeStripper, '');
}, },
// Start the hash change handling, returning `true` if the current URL match es // Start the hash change handling, returning `true` if the current URL match es
// an existing route, and `false` otherwise. // an existing route, and `false` otherwise.
start: function(options) { start: function(options) {
if (History.started) throw new Error("Backbone.history has already been st arted"); if (History.started) throw new Error('Backbone.history has already been st arted');
History.started = true; History.started = true;
// Figure out the initial configuration. Do we need an iframe? // Figure out the initial configuration. Do we need an iframe?
// Is pushState desired ... is it available? // Is pushState desired ... is it available?
this.options = _.extend({root: '/'}, this.options, options); this.options = _.extend({root: '/'}, this.options, options);
this.root = this.options.root; this.root = this.options.root;
this._wantsHashChange = this.options.hashChange !== false; this._wantsHashChange = this.options.hashChange !== false;
this._hasHashChange = 'onhashchange' in window && (document.documentMode
=== void 0 || document.documentMode > 7);
this._useHashChange = this._wantsHashChange && this._hasHashChange;
this._wantsPushState = !!this.options.pushState; this._wantsPushState = !!this.options.pushState;
this._hasPushState = !!(this.options.pushState && this.history && this. this._hasPushState = !!(this.history && this.history.pushState);
history.pushState); this._usePushState = this._wantsPushState && this._hasPushState;
var fragment = this.getFragment(); this.fragment = this.getFragment();
var docMode = document.documentMode;
var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()
) && (!docMode || docMode <= 7));
// Normalize root to always include a leading and trailing slash. // Normalize root to always include a leading and trailing slash.
this.root = ('/' + this.root + '/').replace(rootStripper, '/'); this.root = ('/' + this.root + '/').replace(rootStripper, '/');
if (oldIE && this._wantsHashChange) {
var frame = Backbone.$('<iframe src="javascript:0" tabindex="-1">');
this.iframe = frame.hide().appendTo('body')[0].contentWindow;
this.navigate(fragment);
}
// Depending on whether we're using pushState or hashes, and whether
// 'onhashchange' is supported, determine how we check the URL state.
if (this._hasPushState) {
Backbone.$(window).on('popstate', this.checkUrl);
} else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE)
{
Backbone.$(window).on('hashchange', this.checkUrl);
} else if (this._wantsHashChange) {
this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
}
// Determine if we need to change the base url, for a pushState link
// opened by a non-pushState browser.
this.fragment = fragment;
var loc = this.location;
// Transition from hashChange to pushState or vice versa if both are // Transition from hashChange to pushState or vice versa if both are
// requested. // requested.
if (this._wantsHashChange && this._wantsPushState) { if (this._wantsHashChange && this._wantsPushState) {
// If we've started off with a route from a `pushState`-enabled // 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... // browser, but we're currently in a browser that doesn't support it...
if (!this._hasPushState && !this.atRoot()) { if (!this._hasPushState && !this.atRoot()) {
this.fragment = this.getFragment(null, true); var root = this.root.slice(0, -1) || '/';
this.location.replace(this.root + '#' + this.fragment); this.location.replace(root + '#' + this.getPath());
// Return immediately as browser will do redirect to new url // Return immediately as browser will do redirect to new url
return true; return true;
// Or if we've started out with a hash-based route, but we're currently // 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... // in a browser where it could be `pushState`-based instead...
} else if (this._hasPushState && this.atRoot() && loc.hash) { } else if (this._hasPushState && this.atRoot()) {
this.fragment = this.getHash().replace(routeStripper, ''); this.navigate(this.getHash(), {replace: true});
this.history.replaceState({}, document.title, this.root + this.fragmen
t);
} }
} }
// Proxy an iframe to handle location events if the browser doesn't
// support the `hashchange` event, HTML5 history, or the user wants
// `hashChange` but not `pushState`.
if (!this._hasHashChange && this._wantsHashChange && !this._usePushState)
{
this.iframe = document.createElement('iframe');
this.iframe.src = 'javascript:0';
this.iframe.style.display = 'none';
this.iframe.tabIndex = -1;
var body = document.body;
// Using `appendChild` will throw on IE < 9 if the document is not ready
.
var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWin
dow;
iWindow.document.open();
iWindow.document.close();
iWindow.location.hash = '#' + this.fragment;
}
// Add a cross-platform `addEventListener` shim for older browsers.
var addEventListener = window.addEventListener || function(eventName, list
ener) {
return attachEvent('on' + eventName, listener);
};
// Depending on whether we're using pushState or hashes, and whether
// 'onhashchange' is supported, determine how we check the URL state.
if (this._usePushState) {
addEventListener('popstate', this.checkUrl, false);
} else if (this._useHashChange && !this.iframe) {
addEventListener('hashchange', this.checkUrl, false);
} else if (this._wantsHashChange) {
this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
}
if (!this.options.silent) return this.loadUrl(); if (!this.options.silent) return this.loadUrl();
}, },
// Disable Backbone.history, perhaps temporarily. Not useful in a real app, // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
// but possibly useful for unit testing Routers. // but possibly useful for unit testing Routers.
stop: function() { stop: function() {
Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.c // Add a cross-platform `removeEventListener` shim for older browsers.
heckUrl); var removeEventListener = window.removeEventListener || function(eventName
, listener) {
return detachEvent('on' + eventName, listener);
};
// Remove window listeners.
if (this._usePushState) {
removeEventListener('popstate', this.checkUrl, false);
} else if (this._useHashChange && !this.iframe) {
removeEventListener('hashchange', this.checkUrl, false);
}
// Clean up the iframe if necessary.
if (this.iframe) {
document.body.removeChild(this.iframe);
this.iframe = null;
}
// Some environments will throw when clearing an undefined interval.
if (this._checkUrlInterval) clearInterval(this._checkUrlInterval); if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);
History.started = false; History.started = false;
}, },
// Add a route to be tested when the fragment changes. Routes added later // Add a route to be tested when the fragment changes. Routes added later
// may override previous routes. // may override previous routes.
route: function(route, callback) { route: function(route, callback) {
this.handlers.unshift({route: route, callback: callback}); this.handlers.unshift({route: route, callback: callback});
}, },
// Checks the current URL to see if it has changed, and if it has, // Checks the current URL to see if it has changed, and if it has,
// calls `loadUrl`, normalizing across the hidden iframe. // calls `loadUrl`, normalizing across the hidden iframe.
checkUrl: function(e) { checkUrl: function(e) {
var current = this.getFragment(); var current = this.getFragment();
// If the user pressed the back button, the iframe's hash will have
// changed and we should use that for comparison.
if (current === this.fragment && this.iframe) { if (current === this.fragment && this.iframe) {
current = this.getFragment(this.getHash(this.iframe)); current = this.getHash(this.iframe.contentWindow);
} }
if (current === this.fragment) return false; if (current === this.fragment) return false;
if (this.iframe) this.navigate(current); if (this.iframe) this.navigate(current);
this.loadUrl(); this.loadUrl();
}, },
// Attempt to load the current URL fragment. If a route succeeds with a // Attempt to load the current URL fragment. If a route succeeds with a
// match, returns `true`. If no defined routes matches the fragment, // match, returns `true`. If no defined routes matches the fragment,
// returns `false`. // returns `false`.
loadUrl: function(fragment) { loadUrl: function(fragment) {
// If the root doesn't match, no routes can match either.
if (!this.matchRoot()) return false;
fragment = this.fragment = this.getFragment(fragment); fragment = this.fragment = this.getFragment(fragment);
return _.any(this.handlers, function(handler) { return _.some(this.handlers, function(handler) {
if (handler.route.test(fragment)) { if (handler.route.test(fragment)) {
handler.callback(fragment); handler.callback(fragment);
return true; return true;
} }
}); });
}, },
// Save a fragment into the hash history, or replace the URL state if the // 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 // 'replace' option is passed. You are responsible for properly URL-encoding
// the fragment in advance. // the fragment in advance.
// //
// The options object can contain `trigger: true` if you wish to have the // The options object can contain `trigger: true` if you wish to have the
// route callback be fired (not usually desirable), or `replace: true`, if // route callback be fired (not usually desirable), or `replace: true`, if
// you wish to modify the current URL without adding an entry to the history . // you wish to modify the current URL without adding an entry to the history .
navigate: function(fragment, options) { navigate: function(fragment, options) {
if (!History.started) return false; if (!History.started) return false;
if (!options || options === true) options = {trigger: !!options}; if (!options || options === true) options = {trigger: !!options};
var url = this.root + (fragment = this.getFragment(fragment || '')); // Normalize the fragment.
fragment = this.getFragment(fragment || '');
// Strip the hash for matching. // Don't include a trailing slash on the root.
fragment = fragment.replace(pathStripper, ''); var root = this.root;
if (fragment === '' || fragment.charAt(0) === '?') {
root = root.slice(0, -1) || '/';
}
var url = root + fragment;
// Strip the hash and decode for matching.
fragment = this.decodeFragment(fragment.replace(pathStripper, ''));
if (this.fragment === fragment) return; if (this.fragment === fragment) return;
this.fragment = fragment; this.fragment = fragment;
// Don't include a trailing slash on the root.
if (fragment === '' && url !== '/') url = url.slice(0, -1);
// If pushState is available, we use it to set the fragment as a real URL. // If pushState is available, we use it to set the fragment as a real URL.
if (this._hasPushState) { if (this._usePushState) {
this.history[options.replace ? 'replaceState' : 'pushState']({}, documen t.title, url); this.history[options.replace ? 'replaceState' : 'pushState']({}, documen t.title, url);
// If hash changes haven't been explicitly disabled, update the hash // If hash changes haven't been explicitly disabled, update the hash
// fragment to store history. // fragment to store history.
} else if (this._wantsHashChange) { } else if (this._wantsHashChange) {
this._updateHash(this.location, fragment, options.replace); this._updateHash(this.location, fragment, options.replace);
if (this.iframe && (fragment !== this.getFragment(this.getHash(this.ifra if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow))
me)))) { {
var iWindow = this.iframe.contentWindow;
// Opening and closing the iframe tricks IE7 and earlier to push a // 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 // history entry on hash-tag change. When replace is true, we don't
// want this. // want this.
if(!options.replace) this.iframe.document.open().close(); if (!options.replace) {
this._updateHash(this.iframe.location, fragment, options.replace); iWindow.document.open();
iWindow.document.close();
}
this._updateHash(iWindow.location, fragment, options.replace);
} }
// If you've told us that you explicitly don't want fallback hashchange- // If you've told us that you explicitly don't want fallback hashchange-
// based history, then `navigate` becomes a page refresh. // based history, then `navigate` becomes a page refresh.
} else { } else {
return this.location.assign(url); return this.location.assign(url);
} }
if (options.trigger) return this.loadUrl(fragment); if (options.trigger) return this.loadUrl(fragment);
}, },
skipping to change at line 1553 skipping to change at line 1847
} }
}); });
// Create the default Backbone.history. // Create the default Backbone.history.
Backbone.history = new History; Backbone.history = new History;
// Helpers // Helpers
// ------- // -------
// Helper function to correctly set up the prototype chain, for subclasses. // Helper function to correctly set up the prototype chain for subclasses.
// Similar to `goog.inherits`, but uses a hash of prototype properties and // Similar to `goog.inherits`, but uses a hash of prototype properties and
// class properties to be extended. // class properties to be extended.
var extend = function(protoProps, staticProps) { var extend = function(protoProps, staticProps) {
var parent = this; var parent = this;
var child; var child;
// The constructor function for the new subclass is either defined by you // The constructor function for the new subclass is either defined by you
// (the "constructor" property in your `extend` definition), or defaulted // (the "constructor" property in your `extend` definition), or defaulted
// by us to simply call the parent's constructor. // by us to simply call the parent constructor.
if (protoProps && _.has(protoProps, 'constructor')) { if (protoProps && _.has(protoProps, 'constructor')) {
child = protoProps.constructor; child = protoProps.constructor;
} else { } else {
child = function(){ return parent.apply(this, arguments); }; child = function(){ return parent.apply(this, arguments); };
} }
// Add static properties to the constructor function, if supplied. // Add static properties to the constructor function, if supplied.
_.extend(child, parent, staticProps); _.extend(child, parent, staticProps);
// Set the prototype chain to inherit from `parent`, without calling // Set the prototype chain to inherit from `parent`, without calling
// `parent`'s constructor function. // `parent`'s constructor function and add the prototype properties.
var Surrogate = function(){ this.constructor = child; }; child.prototype = _.create(parent.prototype, protoProps);
Surrogate.prototype = parent.prototype; child.prototype.constructor = child;
child.prototype = new Surrogate;
// Add prototype properties (instance properties) to the subclass,
// if supplied.
if (protoProps) _.extend(child.prototype, protoProps);
// Set a convenience property in case the parent's prototype is needed // Set a convenience property in case the parent's prototype is needed
// later. // later.
child.__super__ = parent.prototype; child.__super__ = parent.prototype;
return child; return child;
}; };
// Set up inheritance for the model, collection, router, view and history. // Set up inheritance for the model, collection, router, view and history.
Model.extend = Collection.extend = Router.extend = View.extend = History.exten d = extend; Model.extend = Collection.extend = Router.extend = View.extend = History.exten d = extend;
// Throw an error when a URL is needed, and none is supplied. // Throw an error when a URL is needed, and none is supplied.
var urlError = function() { var urlError = function() {
throw new Error('A "url" property or function must be specified'); throw new Error('A "url" property or function must be specified');
}; };
// Wrap an optional error callback with a fallback error event. // Wrap an optional error callback with a fallback error event.
var wrapError = function(model, options) { var wrapError = function(model, options) {
var error = options.error; var error = options.error;
options.error = function(resp) { options.error = function(resp) {
if (error) error(model, resp, options); if (error) error.call(options.context, model, resp, options);
model.trigger('error', model, resp, options); model.trigger('error', model, resp, options);
}; };
}; };
return Backbone; return Backbone;
})); });
 End of changes. 165 change blocks. 
461 lines changed or deleted 768 lines changed or added
To the JavaScript Files section of the lodash source changes report or the top of this page
Mainly generated by pkgdiff using rfcdiff
Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)