From 3bc3f13651601fc1d19ac1cd45cae837c5bac275 Mon Sep 17 00:00:00 2001 From: danielgrippi Date: Tue, 3 Apr 2012 16:31:17 -0700 Subject: [PATCH] upgrade backbone, fix tests some cukes may be failing non deterministically, I think, do we bump the cuke timeout? --- .../javascripts/app/collections/comments.js | 6 +- app/assets/javascripts/app/models/post.js | 14 + .../javascripts/app/pages/post-viewer.js | 1 - app/assets/javascripts/app/router.js | 2 + .../app/views/comment_stream_view.js | 10 +- .../app/views/post-viewer/new_comment.js | 12 +- features/activity_stream.feature | 3 + features/connects_users.feature | 1 + features/posts_from_main_page.feature | 4 +- features/step_definitions/stream_steps.rb | 2 +- features/step_definitions/user_steps.rb | 9 +- features/support/env.rb | 7 + features/support/publishing_cuke_helpers.rb | 6 +- .../collections/comments_collection_spec.js | 2 +- .../app/views/aspects_dropdown_view_spec.js | 6 +- .../app/views/services_selector_view_spec.js | 5 +- vendor/assets/javascripts/backbone.js | 1139 ++++++++++------- 17 files changed, 763 insertions(+), 466 deletions(-) diff --git a/app/assets/javascripts/app/collections/comments.js b/app/assets/javascripts/app/collections/comments.js index d564f8682..efd825988 100644 --- a/app/assets/javascripts/app/collections/comments.js +++ b/app/assets/javascripts/app/collections/comments.js @@ -1,7 +1,11 @@ app.collections.Comments = Backbone.Collection.extend({ model: app.models.Comment, + url : function(){ + return this.post.url() + "/comments" + }, + initialize : function(models, options) { - this.url = "/posts/" + options.post.id + "/comments" //not delegating to post.url() because when it is in a stream collection it delegates to that url + this.post = options.post } }); diff --git a/app/assets/javascripts/app/models/post.js b/app/assets/javascripts/app/models/post.js index 892571feb..dd7c3671b 100644 --- a/app/assets/javascripts/app/models/post.js +++ b/app/assets/javascripts/app/models/post.js @@ -91,6 +91,20 @@ app.models.Post = Backbone.Model.extend({ }}); }, + comment : function (text) { + + var self = this + , postComments = this.comments; + + postComments.create({"text": text}, { + url : postComments.url(), + wait:true, // added a wait for the time being. 0.5.3 was not optimistic, but 0.9.2 is. + error:function () { + alert(Diaspora.I18n.t("failed_to_post_message")); + } + }); + }, + headline : function() { var headline = this.get("text").trim() , newlineIdx = headline.lastIndexOf("\n") diff --git a/app/assets/javascripts/app/pages/post-viewer.js b/app/assets/javascripts/app/pages/post-viewer.js index 803dbe384..c932bd43c 100644 --- a/app/assets/javascripts/app/pages/post-viewer.js +++ b/app/assets/javascripts/app/pages/post-viewer.js @@ -44,7 +44,6 @@ app.pages.PostViewer = app.views.Base.extend({ postRenderTemplate : function() { /* set the document title */ - console.log(this.model) document.title = this.model.get("title"); this.bindNavHooks(); diff --git a/app/assets/javascripts/app/router.js b/app/assets/javascripts/app/router.js index f45d158e4..8a56a353b 100644 --- a/app/assets/javascripts/app/router.js +++ b/app/assets/javascripts/app/router.js @@ -6,7 +6,9 @@ app.Router = Backbone.Router.extend({ "participate": "stream", "explore": "stream", + "aspects": "stream", "aspects:query": "stream", + "commented": "stream", "liked": "stream", "mentions": "stream", diff --git a/app/assets/javascripts/app/views/comment_stream_view.js b/app/assets/javascripts/app/views/comment_stream_view.js index 1b4710e27..596eca48f 100644 --- a/app/assets/javascripts/app/views/comment_stream_view.js +++ b/app/assets/javascripts/app/views/comment_stream_view.js @@ -38,15 +38,7 @@ app.views.CommentStream = app.views.Base.extend({ createComment: function(evt) { if(evt){ evt.preventDefault(); } - - this.model.comments.create({ - "text" : this.$(".comment_box").val() - }, { - error: function() { - alert(Diaspora.I18n.t("failed_to_post_message")); - } - }); - + this.model.comment(this.$(".comment_box").val()); this.$(".comment_box").val("") return this; }, diff --git a/app/assets/javascripts/app/views/post-viewer/new_comment.js b/app/assets/javascripts/app/views/post-viewer/new_comment.js index 2ab3b45e7..16775a80c 100644 --- a/app/assets/javascripts/app/views/post-viewer/new_comment.js +++ b/app/assets/javascripts/app/views/post-viewer/new_comment.js @@ -9,6 +9,10 @@ app.views.PostViewerNewComment = app.views.Base.extend({ scrollableArea : "#post-reactions", + initialize : function(){ + this.model.comments.bind("sync", this.clearAndReactivateForm, this) + }, + postRenderTemplate : function() { this.$("textarea").placeholder(); this.$("textarea").autoResize({'extraSpace' : 0}); @@ -16,14 +20,8 @@ app.views.PostViewerNewComment = app.views.Base.extend({ createComment: function(evt) { if(evt){ evt.preventDefault(); } - - var self = this; - this.toggleFormState() - this.model.comments.create({ - "text" : this.$("textarea").val() - }, {success : _.bind(self.clearAndReactivateForm, self)}); - + this.model.comment(this.$("textarea").val()); }, clearAndReactivateForm : function() { diff --git a/features/activity_stream.feature b/features/activity_stream.feature index 4b744a329..2cc1a13ab 100644 --- a/features/activity_stream.feature +++ b/features/activity_stream.feature @@ -5,8 +5,11 @@ Feature: The activity stream When I sign in as "bob@bob.bob" And I post "A- I like turtles" + And I wait for 1 second And I post "B- barack obama is your new bicycle" + And I wait for 1 second And I post "C- barack obama is a square" + And I wait for 1 second When I go to the activity stream page Then "C- barack obama is a square" should be post 1 diff --git a/features/connects_users.feature b/features/connects_users.feature index 0342a0048..fec735115 100644 --- a/features/connects_users.feature +++ b/features/connects_users.feature @@ -45,6 +45,7 @@ Feature: following and being followed And I am on "bob@bob.bob"'s page And I add the person to my "Besties" aspect + And I wait for the ajax to finish And I add the person to my "Unicorns" aspect When I go to the home page diff --git a/features/posts_from_main_page.feature b/features/posts_from_main_page.feature index 45cf2df2f..d13ef0438 100644 --- a/features/posts_from_main_page.feature +++ b/features/posts_from_main_page.feature @@ -17,12 +17,12 @@ Feature: posting from the main page Scenario: post a text-only message to all aspects Given I expand the publisher - When I fill in "status_message_fake_text" with "I am eating a yogurt" + When I fill in "status_message_fake_text" with "I am eating yogurt" And I press "Share" And I wait for the ajax to finish And I go to the aspects page - Then I should see "I am eating a yogurt" within ".stream_element" + Then "I am eating yogurt" should be post 1 Scenario: posting a message appends it to the top of the stream When I click the publisher and post "sup dog" diff --git a/features/step_definitions/stream_steps.rb b/features/step_definitions/stream_steps.rb index ec1732680..a3ae86712 100644 --- a/features/step_definitions/stream_steps.rb +++ b/features/step_definitions/stream_steps.rb @@ -7,7 +7,7 @@ Then /^I like the post "([^"]*)"$/ do |post_text| end Then /^"([^"]*)" should be post (\d+)$/ do |post_text, position| - find(".stream_element:nth-child(#{position}) .post-content").text.should == post_text + stream_element_numbers_content(position).text.should == post_text end When /^I toggle nsfw posts$/ do diff --git a/features/step_definitions/user_steps.rb b/features/step_definitions/user_steps.rb index b7c62a60b..bbae4d426 100644 --- a/features/step_definitions/user_steps.rb +++ b/features/step_definitions/user_steps.rb @@ -99,11 +99,10 @@ Then /^I should have (\d) contacts? in "([^"]*)"$/ do |n_contacts, aspect_name| end When /^I (?:add|remove) the person (?:to|from) my "([^\"]*)" aspect$/ do |aspect_name| - steps %Q{ - And I press the first ".toggle.button" - And I click on selector ".dropdown.active .dropdown_list li[data-aspect_id=#{@me.aspects.where(:name => aspect_name).first.id}]" - And I press the first ".toggle.button" - } + aspects_dropdown = find(".aspect_membership .toggle.button:first") + aspects_dropdown.click + find(".dropdown.active .dropdown_list li:contains('#{aspect_name}')").click + aspects_dropdown.click end When /^I post a status with the text "([^\"]*)"$/ do |text| diff --git a/features/support/env.rb b/features/support/env.rb index 5d591929e..b787fd11b 100644 --- a/features/support/env.rb +++ b/features/support/env.rb @@ -65,6 +65,13 @@ Spork.prefork do require File.join(File.dirname(__FILE__), "..", "..", "spec", "support", "fake_resque") require File.join(File.dirname(__FILE__), 'run_resque_in_process') + + #hax to get rubymine to run spork, set RUBYMINE_HOME in your .bash_profile + if ENV["RUBYMINE_HOME"] + puts "Loading rubymine spork extensions" + $:.unshift(File.expand_path("rb/testing/patch/common", ENV["RUBYMINE_HOME"])) + $:.unshift(File.expand_path("rb/testing/patch/bdd", ENV["RUBYMINE_HOME"])) + end end Spork.each_run do diff --git a/features/support/publishing_cuke_helpers.rb b/features/support/publishing_cuke_helpers.rb index aaef7f99d..11043b1c0 100644 --- a/features/support/publishing_cuke_helpers.rb +++ b/features/support/publishing_cuke_helpers.rb @@ -34,7 +34,11 @@ module PublishingCukeHelpers end def first_post_text - find('.stream_element:first .post-content').text() + stream_element_numbers_content(1).text() + end + + def stream_element_numbers_content(position) + find(".stream_element:nth-child(#{position}) .post-content") end def find_post_by_text(text) diff --git a/spec/javascripts/app/collections/comments_collection_spec.js b/spec/javascripts/app/collections/comments_collection_spec.js index 7c94d4501..76f6498e9 100644 --- a/spec/javascripts/app/collections/comments_collection_spec.js +++ b/spec/javascripts/app/collections/comments_collection_spec.js @@ -3,7 +3,7 @@ describe("app.collections.comments", function(){ it("should user the post id", function(){ var post =new app.models.Post({id : 5}) var collection = new app.collections.Comments([], {post : post}) - expect(collection.url).toBe("/posts/5/comments") + expect(collection.url()).toBe("/posts/5/comments") }) }) }) diff --git a/spec/javascripts/app/views/aspects_dropdown_view_spec.js b/spec/javascripts/app/views/aspects_dropdown_view_spec.js index b5a47604d..59117cae8 100644 --- a/spec/javascripts/app/views/aspects_dropdown_view_spec.js +++ b/spec/javascripts/app/views/aspects_dropdown_view_spec.js @@ -1,12 +1,12 @@ describe("app.views.AspectsDropdown", function(){ beforeEach(function(){ - loginAs(factory.user({ + loginAs({ aspects : [ { id : 3, name : "sauce" }, { id : 5, name : "conf" }, { id : 7, name : "lovers" } ] - })) + }) this.view = new app.views.AspectsDropdown }) @@ -62,7 +62,9 @@ describe("app.views.AspectsDropdown", function(){ describe("selecting An Aspect", function(){ beforeEach(function(){ + this.link = this.view.$("a:contains('lovers')") + console.log(app.currentUser.get("aspects"), $("a:contains('lovers')", this.view.el)) this.link.click() }) diff --git a/spec/javascripts/app/views/services_selector_view_spec.js b/spec/javascripts/app/views/services_selector_view_spec.js index afa19486a..78cfebbe5 100644 --- a/spec/javascripts/app/views/services_selector_view_spec.js +++ b/spec/javascripts/app/views/services_selector_view_spec.js @@ -1,10 +1,10 @@ describe("app.views.ServicesSelector", function(){ beforeEach(function(){ - loginAs(factory.user({ + loginAs({ services : [ { provider : "fakeBook" } ] - })); + }); this.view = new app.views.ServicesSelector(); }); @@ -16,7 +16,6 @@ describe("app.views.ServicesSelector", function(){ it("displays all services", function(){ var checkboxes = $(this.view.el).find('input[type="checkbox"]'); - expect(checkboxes.val()).toBe("fakeBook"); }); }); diff --git a/vendor/assets/javascripts/backbone.js b/vendor/assets/javascripts/backbone.js index b2e49322b..3373c952b 100644 --- a/vendor/assets/javascripts/backbone.js +++ b/vendor/assets/javascripts/backbone.js @@ -1,20 +1,27 @@ -// Backbone.js 0.5.3 -// (c) 2010 Jeremy Ashkenas, DocumentCloud Inc. +// Backbone.js 0.9.2 + +// (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc. // Backbone may be freely distributed under the MIT license. // For all details and documentation: -// http://documentcloud.github.com/backbone +// http://backbonejs.org (function(){ // Initial Setup // ------------- - // Save a reference to the global object. + // Save a reference to the global object (`window` in the browser, `global` + // on the server). var root = this; - // Save the previous value of the `Backbone` variable. + // Save the previous value of the `Backbone` variable, so that it can be + // restored later on, if `noConflict` is used. var previousBackbone = root.Backbone; + // Create a local reference to slice/splice. + var slice = Array.prototype.slice; + var splice = Array.prototype.splice; + // The top-level namespace. All public Backbone classes and modules will // be attached to this. Exported for both CommonJS and the browser. var Backbone; @@ -25,14 +32,23 @@ } // Current version of the library. Keep in sync with `package.json`. - Backbone.VERSION = '0.5.3'; + Backbone.VERSION = '0.9.2'; // Require Underscore, if we're on the server, and it's not already present. var _ = root._; - if (!_ && (typeof require !== 'undefined')) _ = require('underscore')._; + if (!_ && (typeof require !== 'undefined')) _ = require('underscore'); - // For Backbone's purposes, jQuery or Zepto owns the `$` variable. - var $ = root.jQuery || root.Zepto; + // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable. + var $ = root.jQuery || root.Zepto || root.ender; + + // Set the JavaScript library that will be used for DOM manipulation and + // Ajax calls (a.k.a. the `$` variable). By default Backbone will use: jQuery, + // Zepto, or Ender; but the `setDomLibrary()` method lets you inject an + // alternate JavaScript library (or a mock library for testing your views + // outside of a browser). + Backbone.setDomLibrary = function(lib) { + $ = lib; + }; // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable // to its previous owner. Returns a reference to this Backbone object. @@ -41,9 +57,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 @@ -55,355 +71,481 @@ // Backbone.Events // ----------------- + // Regular expression used to split event strings + var eventSplitter = /\s+/; + // A module that can be mixed in to *any object* in order to provide it with - // custom events. You may `bind` or `unbind` a callback function to an event; - // `trigger`-ing an event fires all callbacks in succession. + // custom events. You may bind with `on` or remove with `off` callback functions + // to an event; trigger`-ing an event fires all callbacks in succession. // // var object = {}; // _.extend(object, Backbone.Events); - // object.bind('expand', function(){ alert('expanded'); }); + // object.on('expand', function(){ alert('expanded'); }); // object.trigger('expand'); // - Backbone.Events = { + var Events = Backbone.Events = { + + // Bind one or more space separated events, `events`, to a `callback` + // function. Passing `"all"` will bind the callback to all events fired. + on: function(events, callback, context) { + + var calls, event, node, tail, list; + if (!callback) return this; + events = events.split(eventSplitter); + calls = this._callbacks || (this._callbacks = {}); + + // Create an immutable callback list, allowing traversal during + // modification. The tail is an empty object that will always be used + // as the next node. + while (event = events.shift()) { + list = calls[event]; + node = list ? list.tail : {}; + node.next = tail = {}; + node.context = context; + node.callback = callback; + calls[event] = {tail: tail, next: list ? list.next : node}; + } - // 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 = {}); - var list = calls[ev] || (calls[ev] = []); - list.push([callback, context]); return this; }, - // Remove one or many callbacks. If `callback` is null, removes all - // callbacks for the event. If `ev` is null, removes all bound callbacks - // for all events. - unbind : function(ev, callback) { - var calls; - if (!ev) { - this._callbacks = {}; - } else if (calls = this._callbacks) { - if (!callback) { - calls[ev] = []; - } else { - var list = calls[ev]; - if (!list) return this; - for (var i = 0, l = list.length; i < l; i++) { - if (list[i] && callback === list[i][0]) { - list[i] = null; - break; - } + // 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 `events` is null, removes all bound callbacks for all events. + off: function(events, callback, context) { + var event, calls, node, tail, cb, ctx; + + // No events, or removing *all* events. + if (!(calls = this._callbacks)) return; + if (!(events || callback || context)) { + delete this._callbacks; + return this; + } + + // Loop through the listed events and contexts, splicing them out of the + // linked list of callbacks if appropriate. + events = events ? events.split(eventSplitter) : _.keys(calls); + while (event = events.shift()) { + node = calls[event]; + delete calls[event]; + if (!node || !(callback || context)) continue; + // Create a new list, omitting the indicated callbacks. + tail = node.tail; + while ((node = node.next) !== tail) { + cb = node.callback; + ctx = node.context; + if ((callback && cb !== callback) || (context && ctx !== context)) { + this.on(event, cb, ctx); } } } + return this; }, - // Trigger an event, firing all bound callbacks. Callbacks are passed the - // same arguments as `trigger` is, apart from the event name. - // Listening for `"all"` passes the true event name as the first argument. - trigger : function(eventName) { - var list, calls, ev, callback, args; - var both = 2; + // Trigger 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). + trigger: function(events) { + var event, node, calls, tail, args, all, rest; if (!(calls = this._callbacks)) return this; - while (both--) { - ev = both ? eventName : 'all'; - if (list = calls[ev]) { - for (var i = 0, l = list.length; i < l; i++) { - if (!(callback = list[i])) { - list.splice(i, 1); i--; l--; - } else { - args = both ? Array.prototype.slice.call(arguments, 1) : arguments; - callback[0].apply(callback[1] || this, args); - } + all = calls.all; + events = events.split(eventSplitter); + rest = slice.call(arguments, 1); + + // For each event, walk through the linked list of callbacks twice, + // first to trigger the event, then to trigger any `"all"` callbacks. + while (event = events.shift()) { + if (node = calls[event]) { + tail = node.tail; + while ((node = node.next) !== tail) { + node.callback.apply(node.context || this, rest); + } + } + if (node = all) { + tail = node.tail; + args = [event].concat(rest); + while ((node = node.next) !== tail) { + node.callback.apply(node.context || this, args); } } } + return this; } }; + // Aliases for backwards compatibility. + Events.bind = Events.on; + Events.unbind = Events.off; + // Backbone.Model // -------------- // Create a new model, with defined attributes. A client id (`cid`) // is automatically generated and assigned for you. - Backbone.Model = function(attributes, options) { + var Model = Backbone.Model = function(attributes, options) { var defaults; attributes || (attributes = {}); - if (defaults = this.defaults) { - if (_.isFunction(defaults)) defaults = defaults.call(this); + if (options && options.parse) attributes = this.parse(attributes); + if (defaults = getValue(this, 'defaults')) { attributes = _.extend({}, defaults, attributes); } + if (options && options.collection) this.collection = options.collection; this.attributes = {}; this._escapedAttributes = {}; this.cid = _.uniqueId('c'); - this.set(attributes, {silent : true}); - this._changed = false; + this.changed = {}; + this._silent = {}; + this._pending = {}; + this.set(attributes, {silent: true}); + // Reset change tracking. + this.changed = {}; + this._silent = {}; + this._pending = {}; this._previousAttributes = _.clone(this.attributes); - if (options && options.collection) this.collection = options.collection; - this.initialize(attributes, options); + this.initialize.apply(this, arguments); }; // Attach all inheritable methods to the Model prototype. - _.extend(Backbone.Model.prototype, Backbone.Events, { + _.extend(Model.prototype, Events, { - // A snapshot of the model's previous attributes, taken immediately - // after the last `"change"` event was fired. - _previousAttributes : null, + // A hash of attributes whose current and previous value differ. + changed: null, - // Has the item been changed since the last `"change"` event? - _changed : false, + // A hash of attributes that have silently changed since the last time + // `change` was called. Will become pending attributes on the next call. + _silent: null, + + // A hash of attributes that have changed since the last `'change'` event + // began. + _pending: null, // 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(options) { return _.clone(this.attributes); }, // Get the value of an attribute. - get : function(attr) { + get: function(attr) { return this.attributes[attr]; }, // Get the HTML-escaped value of an attribute. - escape : function(attr) { + escape: function(attr) { var html; if (html = this._escapedAttributes[attr]) return html; - var val = this.attributes[attr]; - return this._escapedAttributes[attr] = escapeHTML(val == null ? '' : '' + val); + var val = this.get(attr); + return this._escapedAttributes[attr] = _.escape(val == null ? '' : '' + val); }, // Returns `true` if the attribute contains a value that is not null // or undefined. - has : function(attr) { - return this.attributes[attr] != null; + has: function(attr) { + return this.get(attr) != null; }, - // Set a hash of model attributes on the object, firing `"change"` unless you - // choose to silence it. - set : function(attrs, options) { + // Set a hash of model attributes on the object, firing `"change"` unless + // you choose to silence it. + set: function(key, value, options) { + var attrs, attr, val; + + // Handle both `"key", value` and `{key: value}` -style arguments. + if (_.isObject(key) || key == null) { + attrs = key; + options = value; + } else { + attrs = {}; + attrs[key] = value; + } // Extract attributes and options. options || (options = {}); if (!attrs) return this; - if (attrs.attributes) attrs = attrs.attributes; - var now = this.attributes, escaped = this._escapedAttributes; + if (attrs instanceof Model) attrs = attrs.attributes; + if (options.unset) for (attr in attrs) attrs[attr] = void 0; // Run validation. - if (!options.silent && this.validate && !this._performValidation(attrs, options)) return false; + if (!this._validate(attrs, options)) return false; // Check for changes of `id`. if (this.idAttribute in attrs) this.id = attrs[this.idAttribute]; - // We're about to start triggering change events. - var alreadyChanging = this._changing; - this._changing = true; + var changes = options.changes = {}; + var now = this.attributes; + var escaped = this._escapedAttributes; + var prev = this._previousAttributes || {}; - // Update attributes. - for (var attr in attrs) { - var val = attrs[attr]; - if (!_.isEqual(now[attr], val)) { - now[attr] = val; + // For each `set` attribute... + for (attr in attrs) { + val = attrs[attr]; + + // If the new and current value differ, record the change. + if (!_.isEqual(now[attr], val) || (options.unset && _.has(now, attr))) { delete escaped[attr]; - this._changed = true; - if (!options.silent) this.trigger('change:' + attr, this, val, options); + (options.silent ? this._silent : changes)[attr] = true; + } + + // Update or delete the current value. + options.unset ? delete now[attr] : now[attr] = val; + + // If the new and previous value differ, record the change. If not, + // then remove changes for this attribute. + if (!_.isEqual(prev[attr], val) || (_.has(now, attr) != _.has(prev, attr))) { + this.changed[attr] = val; + if (!options.silent) this._pending[attr] = true; + } else { + delete this.changed[attr]; + delete this._pending[attr]; } } - // Fire the `"change"` event, if the model has been changed. - if (!alreadyChanging && !options.silent && this._changed) this.change(options); - this._changing = false; + // Fire the `"change"` events. + if (!options.silent) this.change(options); return this; }, // Remove an attribute from the model, firing `"change"` unless you choose // to silence it. `unset` is a noop if the attribute doesn't exist. - unset : function(attr, options) { - if (!(attr in this.attributes)) return this; - options || (options = {}); - var value = this.attributes[attr]; - - // Run validation. - var validObj = {}; - validObj[attr] = void 0; - if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false; - - // Remove the attribute. - delete this.attributes[attr]; - delete this._escapedAttributes[attr]; - if (attr == this.idAttribute) delete this.id; - this._changed = true; - if (!options.silent) { - this.trigger('change:' + attr, this, void 0, options); - this.change(options); - } - return this; + unset: function(attr, options) { + (options || (options = {})).unset = true; + return this.set(attr, null, options); }, // Clear all attributes on the model, firing `"change"` unless you choose // to silence it. - clear : function(options) { - options || (options = {}); - var attr; - var old = this.attributes; - - // Run validation. - var validObj = {}; - for (attr in old) validObj[attr] = void 0; - if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false; - - this.attributes = {}; - this._escapedAttributes = {}; - this._changed = true; - if (!options.silent) { - for (attr in old) { - this.trigger('change:' + attr, this, void 0, options); - } - this.change(options); - } - return this; + clear: function(options) { + (options || (options = {})).unset = true; + return this.set(_.clone(this.attributes), options); }, // Fetch the model from the server. If the server's representation of the // model differs from its current attributes, they will be overriden, // triggering a `"change"` event. - fetch : function(options) { - options || (options = {}); + fetch: function(options) { + options = options ? _.clone(options) : {}; var model = this; var success = options.success; options.success = function(resp, status, xhr) { if (!model.set(model.parse(resp, xhr), options)) return false; if (success) success(model, resp); }; - options.error = wrapError(options.error, model, options); + options.error = Backbone.wrapError(options.error, model, options); return (this.sync || Backbone.sync).call(this, 'read', this, options); }, // Set a hash of model attributes, and sync the model to the server. // If the server returns an attributes hash that differs, the model's // state will be `set` again. - save : function(attrs, options) { - options || (options = {}); - if (attrs && !this.set(attrs, options)) return false; + save: function(key, value, options) { + var attrs, current; + + // Handle both `("key", value)` and `({key: value})` -style calls. + if (_.isObject(key) || key == null) { + attrs = key; + options = value; + } else { + attrs = {}; + attrs[key] = value; + } + options = options ? _.clone(options) : {}; + + // If we're "wait"-ing to set changed attributes, validate early. + if (options.wait) { + if (!this._validate(attrs, options)) return false; + current = _.clone(this.attributes); + } + + // Regular saves `set` attributes before persisting to the server. + var silentOptions = _.extend({}, options, {silent: true}); + if (attrs && !this.set(attrs, options.wait ? silentOptions : options)) { + return false; + } + + // After a successful server-side save, the client is (optionally) + // updated with the server-side state. var model = this; var success = options.success; options.success = function(resp, status, xhr) { - if (!model.set(model.parse(resp, xhr), options)) return false; - if (success) success(model, resp, xhr); + var serverAttrs = model.parse(resp, xhr); + if (options.wait) { + delete options.wait; + serverAttrs = _.extend(attrs || {}, serverAttrs); + } + if (!model.set(serverAttrs, options)) return false; + if (success) { + success(model, resp); + } else { + model.trigger('sync', model, resp, options); + } }; - options.error = wrapError(options.error, model, options); + + // Finish configuring and sending the Ajax request. + options.error = Backbone.wrapError(options.error, model, options); var method = this.isNew() ? 'create' : 'update'; - return (this.sync || Backbone.sync).call(this, method, this, options); + var xhr = (this.sync || Backbone.sync).call(this, method, this, options); + if (options.wait) this.set(current, silentOptions); + return xhr; }, - // Destroy this model on the server if it was already persisted. Upon success, the model is removed - // from its collection, if it has one. - destroy : function(options) { - options || (options = {}); - if (this.isNew()) return this.trigger('destroy', this, this.collection, options); + // Destroy this model on the server if it was already persisted. + // Optimistically removes the model from its collection, if it has one. + // If `wait: true` is passed, waits for the server to respond before removal. + destroy: function(options) { + options = options ? _.clone(options) : {}; var model = this; var success = options.success; - options.success = function(resp) { + + var triggerDestroy = function() { model.trigger('destroy', model, model.collection, options); - if (success) success(model, resp); }; - options.error = wrapError(options.error, model, options); - return (this.sync || Backbone.sync).call(this, 'delete', this, options); + + if (this.isNew()) { + triggerDestroy(); + return false; + } + + options.success = function(resp) { + if (options.wait) triggerDestroy(); + if (success) { + success(model, resp); + } else { + model.trigger('sync', model, resp, options); + } + }; + + options.error = Backbone.wrapError(options.error, model, options); + var xhr = (this.sync || Backbone.sync).call(this, 'delete', this, options); + if (!options.wait) triggerDestroy(); + return xhr; }, // Default URL for the model's representation on the server -- if you're // using Backbone's restful methods, override this to change the endpoint // that will be called. - url : function() { - var base = getUrl(this.collection) || this.urlRoot || urlError(); + url: function() { + var base = getValue(this, 'urlRoot') || getValue(this.collection, 'url') || urlError(); if (this.isNew()) return base; return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + encodeURIComponent(this.id); }, // **parse** converts a response into the hash of attributes to be `set` on // the model. The default implementation is just to pass the response along. - parse : function(resp, xhr) { + parse: function(resp, xhr) { return resp; }, // Create a new model with identical attributes to this one. - clone : function() { - return new this.constructor(this); + clone: function() { + return new this.constructor(this.attributes); }, // A model is new if it has never been saved to the server, and lacks an id. - isNew : function() { + isNew: function() { return this.id == null; }, - // Call this method to manually fire a `change` event for this model. + // Call this method to manually fire a `"change"` event for this model and + // a `"change:attribute"` event for each changed attribute. // Calling this will cause all objects observing the model to update. - change : function(options) { - this.trigger('change', this, options); - this._previousAttributes = _.clone(this.attributes); - this._changed = false; + change: function(options) { + options || (options = {}); + var changing = this._changing; + this._changing = true; + + // Silent changes become pending changes. + for (var attr in this._silent) this._pending[attr] = true; + + // Silent changes are triggered. + var changes = _.extend({}, options.changes, this._silent); + this._silent = {}; + for (var attr in changes) { + this.trigger('change:' + attr, this, this.get(attr), options); + } + if (changing) return this; + + // Continue firing `"change"` events while there are pending changes. + while (!_.isEmpty(this._pending)) { + this._pending = {}; + this.trigger('change', this, options); + // Pending and silent changes still remain. + for (var attr in this.changed) { + if (this._pending[attr] || this._silent[attr]) continue; + delete this.changed[attr]; + } + this._previousAttributes = _.clone(this.attributes); + } + + this._changing = false; + return this; }, // Determine if the model has changed since the last `"change"` event. // If you specify an attribute name, determine if that attribute has changed. - hasChanged : function(attr) { - if (attr) return this._previousAttributes[attr] != this.attributes[attr]; - return this._changed; + hasChanged: function(attr) { + if (!arguments.length) return !_.isEmpty(this.changed); + return _.has(this.changed, attr); }, - // Return an object containing all the attributes that have changed, or false - // if there are no changed attributes. Useful for determining what parts of a - // view need to be updated and/or what attributes need to be persisted to - // the server. - changedAttributes : function(now) { - now || (now = this.attributes); - var old = this._previousAttributes; - var changed = false; - for (var attr in now) { - if (!_.isEqual(old[attr], now[attr])) { - changed = changed || {}; - changed[attr] = now[attr]; - } + // Return an object containing all the attributes that have changed, or + // false if there are no changed attributes. Useful for determining what + // parts of a view need to be updated and/or what attributes need to be + // persisted to the server. Unset attributes will be set to undefined. + // You can also pass an attributes object to diff against the model, + // determining if there *would be* a change. + changedAttributes: function(diff) { + if (!diff) return this.hasChanged() ? _.clone(this.changed) : false; + var val, changed = false, old = this._previousAttributes; + for (var attr in diff) { + if (_.isEqual(old[attr], (val = diff[attr]))) continue; + (changed || (changed = {}))[attr] = val; } return changed; }, // Get the previous value of an attribute, recorded at the time the last // `"change"` event was fired. - previous : function(attr) { - if (!attr || !this._previousAttributes) return null; + previous: function(attr) { + if (!arguments.length || !this._previousAttributes) return null; return this._previousAttributes[attr]; }, // Get all of the attributes of the model at the time of the previous // `"change"` event. - previousAttributes : function() { + previousAttributes: function() { return _.clone(this._previousAttributes); }, - // Run validation against a set of incoming attributes, returning `true` - // if all is well. If a specific `error` callback has been passed, - // call that instead of firing the general `"error"` event. - _performValidation : function(attrs, options) { - var error = this.validate(attrs); - if (error) { - if (options.error) { - options.error(this, error, options); - } else { - this.trigger('error', this, error, options); - } - return false; + // 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 the next complete set of model 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); } - return true; + return false; } }); @@ -414,66 +556,142 @@ // Provides a standard collection class for our sets of models, ordered // or unordered. If a `comparator` is specified, the Collection will maintain // its models in sort order, as they're added and removed. - Backbone.Collection = function(models, options) { + var Collection = Backbone.Collection = function(models, options) { options || (options = {}); + if (options.model) this.model = options.model; 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. - _.extend(Backbone.Collection.prototype, Backbone.Events, { + _.extend(Collection.prototype, Events, { // The default model for a collection is just a **Backbone.Model**. // This should be overridden in most cases. - model : Backbone.Model, + model: 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() { - return this.map(function(model){ return model.toJSON(); }); + toJSON: function(options) { + return this.map(function(model){ return model.toJSON(options); }); }, // Add a model, or list of models to the set. Pass **silent** to avoid - // firing the `added` event for every new model. - add : function(models, options) { - if (_.isArray(models)) { - for (var i = 0, l = models.length; i < l; i++) { - this._add(models[i], options); + // firing the `add` event for every new model. + add: function(models, options) { + var i, index, length, model, cid, id, cids = {}, ids = {}, dups = []; + options || (options = {}); + models = _.isArray(models) ? models.slice() : [models]; + + // Begin by turning bare objects into model references, and preventing + // invalid models or duplicate models from being added. + for (i = 0, length = models.length; i < length; i++) { + if (!(model = models[i] = this._prepareModel(models[i], options))) { + throw new Error("Can't add an invalid model to a collection"); } - } else { - this._add(models, options); + cid = model.cid; + id = model.id; + if (cids[cid] || this._byCid[cid] || ((id != null) && (ids[id] || this._byId[id]))) { + dups.push(i); + continue; + } + cids[cid] = ids[id] = model; + } + + // Remove duplicates. + i = dups.length; + while (i--) { + models.splice(dups[i], 1); + } + + // Listen to added models' events, and index models for lookup by + // `id` and by `cid`. + for (i = 0, length = models.length; i < length; i++) { + (model = models[i]).on('all', this._onModelEvent, this); + this._byCid[model.cid] = model; + if (model.id != null) this._byId[model.id] = model; + } + + // Insert models into the collection, re-sorting if needed, and triggering + // `add` events unless silenced. + this.length += length; + index = options.at != null ? options.at : this.models.length; + splice.apply(this.models, [index, 0].concat(models)); + if (this.comparator) this.sort({silent: true}); + if (options.silent) return this; + for (i = 0, length = this.models.length; i < length; i++) { + if (!cids[(model = this.models[i]).cid]) continue; + options.index = i; + model.trigger('add', model, this, options); } return this; }, // Remove a model, or a list of models from the set. Pass silent to avoid - // firing the `removed` event for every model removed. - remove : function(models, options) { - if (_.isArray(models)) { - for (var i = 0, l = models.length; i < l; i++) { - this._remove(models[i], options); + // firing the `remove` event for every model removed. + remove: function(models, options) { + var i, l, index, model; + options || (options = {}); + models = _.isArray(models) ? models.slice() : [models]; + for (i = 0, l = models.length; i < l; i++) { + model = this.getByCid(models[i]) || this.get(models[i]); + if (!model) continue; + delete this._byId[model.id]; + delete this._byCid[model.cid]; + index = this.indexOf(model); + this.models.splice(index, 1); + this.length--; + if (!options.silent) { + options.index = index; + model.trigger('remove', model, this, options); } - } else { - this._remove(models, options); + this._removeReference(model); } return this; }, + // Add a model to the end of the collection. + push: function(model, options) { + model = this._prepareModel(model, options); + this.add(model, options); + return model; + }, + + // Remove a model from the end of the collection. + pop: function(options) { + var model = this.at(this.length - 1); + this.remove(model, options); + return model; + }, + + // Add a model to the beginning of the collection. + unshift: function(model, options) { + model = this._prepareModel(model, options); + this.add(model, _.extend({at: 0}, options)); + return model; + }, + + // Remove a model from the beginning of the collection. + shift: function(options) { + var model = this.at(0); + this.remove(model, options); + return model; + }, + // Get a model from the set by id. - get : function(id) { - if (id == null) return null; + get: function(id) { + if (id == null) return void 0; return this._byId[id.id != null ? id.id : id]; }, // Get a model from the set by client id. - getByCid : function(cid) { + getByCid: function(cid) { return cid && this._byCid[cid.cid || cid]; }, @@ -482,30 +700,49 @@ 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) { + // Return models with matching attributes. Useful for simple cases of `filter`. + where: function(attrs) { + if (_.isEmpty(attrs)) return []; + return this.filter(function(model) { + for (var key in attrs) { + if (attrs[key] !== model.get(key)) return false; + } + return true; + }); + }, + + // Force the collection to re-sort itself. You don't need to call this under + // normal circumstances, as the set will maintain sort order as each item + // is added. + sort: function(options) { options || (options = {}); if (!this.comparator) throw new Error('Cannot sort a set without a comparator'); - this.models = this.sortBy(this.comparator); + var boundComparator = _.bind(this.comparator, this); + if (this.comparator.length == 1) { + this.models = this.sortBy(boundComparator); + } else { + this.models.sort(boundComparator); + } if (!options.silent) this.trigger('reset', this, options); return this; }, // Pluck an attribute from each model in the collection. - pluck : function(attr) { + pluck: function(attr) { return _.map(this.models, function(model){ return model.get(attr); }); }, // When you have more items than you want to add or remove individually, // you can reset the entire set with a new list of models, without firing - // any `added` or `removed` events. Fires `reset` when finished. - reset : function(models, options) { + // any `add` or `remove` events. Fires `reset` when finished. + reset: function(models, options) { models || (models = []); options || (options = {}); - this.each(this._removeReference); + for (var i = 0, l = this.models.length; i < l; i++) { + this._removeReference(this.models[i]); + } this._reset(); - this.add(models, {silent: true}); + this.add(models, _.extend({silent: true}, options)); if (!options.silent) this.trigger('reset', this, options); return this; }, @@ -513,30 +750,36 @@ // Fetch the default set of models for this collection, resetting the // collection when they arrive. If `add: true` is passed, appends the // models to the collection instead of resetting. - fetch : function(options) { - options || (options = {}); + fetch: function(options) { + options = options ? _.clone(options) : {}; + if (options.parse === undefined) options.parse = true; var collection = this; var success = options.success; options.success = function(resp, status, xhr) { collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options); if (success) success(collection, resp); }; - options.error = wrapError(options.error, collection, options); + options.error = Backbone.wrapError(options.error, collection, options); return (this.sync || Backbone.sync).call(this, 'read', this, options); }, - // Create a new instance of a model in this collection. After the model - // has been created on the server, it will be added to the collection. - // Returns the model, or 'false' if validation on a new model fails. - create : function(model, options) { + // Create a new instance of a model in this collection. Add the model to the + // collection immediately, unless `wait: true` is passed, in which case we + // wait for the server to agree. + create: function(model, options) { var coll = this; - options || (options = {}); + options = options ? _.clone(options) : {}; model = this._prepareModel(model, options); if (!model) return false; + if (!options.wait) coll.add(model, options); var success = options.success; options.success = function(nextModel, resp, xhr) { - coll.add(nextModel, options); - if (success) success(nextModel, resp, xhr); + if (options.wait) coll.add(nextModel, options); + if (success) { + success(nextModel, resp); + } else { + nextModel.trigger('sync', model, resp, options); + } }; model.save(null, options); return model; @@ -544,7 +787,7 @@ // **parse** converts a response into a list of models to be added to the // collection. The default implementation is just to pass it through. - parse : function(resp, xhr) { + parse: function(resp, xhr) { return resp; }, @@ -556,79 +799,45 @@ }, // Reset all internal state. Called when the collection is reset. - _reset : function(options) { + _reset: function(options) { this.length = 0; this.models = []; this._byId = {}; this._byCid = {}; }, - // Prepare a model to be added to this collection + // Prepare a model or hash of attributes to be added to this collection. _prepareModel: function(model, options) { - if (!(model instanceof Backbone.Model)) { + options || (options = {}); + if (!(model instanceof Model)) { var attrs = model; - model = new this.model(attrs, {collection: this}); - if (model.validate && !model._performValidation(attrs, options)) model = false; + options.collection = this; + model = new this.model(attrs, options); + if (!model._validate(model.attributes, options)) model = false; } else if (!model.collection) { model.collection = this; } return model; }, - // Internal implementation of adding a single model to the set, updating - // hash indexes for `id` and `cid` lookups. - // Returns the model, or 'false' if validation on a new model fails. - _add : function(model, options) { - options || (options = {}); - model = this._prepareModel(model, options); - if (!model) return false; - var already = this.getByCid(model); - if (already) throw new Error(["Can't add the same model to a set twice", already.id]); - this._byId[model.id] = model; - this._byCid[model.cid] = model; - var index = options.at != null ? options.at : - this.comparator ? this.sortedIndex(model, this.comparator) : - this.length; - this.models.splice(index, 0, model); - model.bind('all', this._onModelEvent); - this.length++; - if (!options.silent) model.trigger('add', model, this, options); - return model; - }, - - // Internal implementation of removing a single model from the set, updating - // hash indexes for `id` and `cid` lookups. - _remove : function(model, options) { - options || (options = {}); - model = this.getByCid(model) || this.get(model); - if (!model) return null; - delete this._byId[model.id]; - delete this._byCid[model.cid]; - this.models.splice(this.indexOf(model), 1); - this.length--; - if (!options.silent) model.trigger('remove', model, this, options); - this._removeReference(model); - return model; - }, - // Internal method to remove a model's ties to a collection. - _removeReference : function(model) { + _removeReference: function(model) { if (this == model.collection) { delete model.collection; } - model.unbind('all', this._onModelEvent); + model.off('all', this._onModelEvent, this); }, // Internal method called every time a model in the set fires an event. // Sets need to update their indexes when models change ids. All other // events simply proxy through. "add" and "remove" events that originate // in other collections are ignored. - _onModelEvent : function(ev, model, collection, options) { - if ((ev == 'add' || ev == 'remove') && collection != this) return; - if (ev == 'destroy') { - this._remove(model, options); + _onModelEvent: function(event, model, collection, options) { + if ((event == 'add' || event == 'remove') && collection != this) return; + if (event == 'destroy') { + this.remove(model, options); } - if (model && ev === 'change:' + model.idAttribute) { + if (model && event === 'change:' + model.idAttribute) { delete this._byId[model.previous(model.idAttribute)]; this._byId[model.id] = model; } @@ -638,14 +847,15 @@ }); // Underscore methods that we want to implement on the Collection. - var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', 'detect', - 'filter', 'select', 'reject', 'every', 'all', 'some', 'any', 'include', - 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size', - 'first', 'rest', 'last', 'without', 'indexOf', 'lastIndexOf', 'isEmpty', 'groupBy']; + var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', + 'detect', 'filter', 'select', 'reject', 'every', 'all', 'some', 'any', + 'include', 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', + 'toArray', 'size', 'first', 'initial', 'rest', 'last', 'without', 'indexOf', + 'shuffle', 'lastIndexOf', 'isEmpty', 'groupBy']; // Mix in each Underscore method as a proxy to `Collection#models`. _.each(methods, function(method) { - Backbone.Collection.prototype[method] = function() { + Collection.prototype[method] = function() { return _[method].apply(_, [this.models].concat(_.toArray(arguments))); }; }); @@ -655,7 +865,7 @@ // Routers map faux-URLs to actions, and fire events when routes are // matched. Creating a new one sets its `routes` hash, if not set statically. - Backbone.Router = function(options) { + var Router = Backbone.Router = function(options) { options || (options = {}); if (options.routes) this.routes = options.routes; this._bindRoutes(); @@ -664,16 +874,16 @@ // Cached regular expressions for matching named param parts and splatted // parts of route strings. - var namedParam = /:([\w\d]+)/g; - var splatParam = /\*([\w\d]+)/g; + var namedParam = /:\w+/g; + var splatParam = /\*\w+/g; var escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g; // Set up all inheritable **Backbone.Router** properties and methods. - _.extend(Backbone.Router.prototype, Backbone.Events, { + _.extend(Router.prototype, Events, { // Initialize is an empty function by default. Override it with your own // initialization logic. - initialize : function(){}, + initialize: function(){}, // Manually bind a single named route to a callback. For example: // @@ -681,25 +891,28 @@ // ... // }); // - route : function(route, name, callback) { - Backbone.history || (Backbone.history = new Backbone.History); + route: function(route, name, callback) { + Backbone.history || (Backbone.history = new History); if (!_.isRegExp(route)) route = this._routeToRegExp(route); + if (!callback) callback = this[name]; Backbone.history.route(route, _.bind(function(fragment) { var args = this._extractParameters(route, fragment); - callback.apply(this, args); + callback && callback.apply(this, args); this.trigger.apply(this, ['route:' + name].concat(args)); + Backbone.history.trigger('route', this, name, args); }, this)); + return this; }, // Simple proxy to `Backbone.history` to save a fragment into the history. - navigate : function(fragment, triggerRoute) { - Backbone.history.navigate(fragment, triggerRoute); + navigate: function(fragment, options) { + Backbone.history.navigate(fragment, options); }, // Bind all defined routes to `Backbone.history`. We have to reverse the // order of the routes here to support behavior where the most general // routes can be defined at the bottom of the route map. - _bindRoutes : function() { + _bindRoutes: function() { if (!this.routes) return; var routes = []; for (var route in this.routes) { @@ -712,16 +925,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); } @@ -732,56 +945,67 @@ // Handles cross-browser history management, based on URL fragments. If the // browser does not support `onhashchange`, falls back to polling. - Backbone.History = function() { + var History = Backbone.History = function() { this.handlers = []; _.bindAll(this, 'checkUrl'); }; - // Cached regex for cleaning hashes. - var hashStrip = /^#*/; + // Cached regex for cleaning leading hashes and slashes . + var routeStripper = /^[#\/]/; // Cached regex for detecting MSIE. var isExplorer = /msie [\w.]+/; // Has the history handling already been started? - var historyStarted = false; + History.started = false; // Set up all inheritable **Backbone.History** properties and methods. - _.extend(Backbone.History.prototype, { + _.extend(History.prototype, Events, { // The default interval to poll for hash changes, if necessary, is // twenty times a second. interval: 50, + // Gets the true hash value. Cannot use location.hash directly due to bug + // in Firefox where location.hash will always be decoded. + getHash: function(windowOverride) { + var loc = windowOverride ? windowOverride.location : window.location; + var match = loc.href.match(/#(.*)$/); + return match ? match[1] : ''; + }, + // 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 = this.getHash(); } } - return decodeURIComponent(fragment.replace(hashStrip, '')); + if (!fragment.indexOf(this.options.root)) fragment = fragment.substr(this.options.root.length); + return fragment.replace(routeStripper, ''); }, // Start the hash change handling, returning `true` if the current URL matches // an existing route, and `false` otherwise. - start : function(options) { + start: function(options) { + if (History.started) throw new Error("Backbone.history has already been started"); + History.started = true; // 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(); var docMode = document.documentMode; var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7)); + if (oldIE) { this.iframe = $('