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