Update vendors.

Former-commit-id: 48e14b4b41c9b26382b09294127e552a794e49be

vendor/backbone/backbone.js

@@ -20,6 +20,7 @@
 
   // Create a local reference to array methods.
   var ArrayProto = Array.prototype;
+  var push = ArrayProto.push;
   var slice = ArrayProto.slice;
   var splice = ArrayProto.splice;
 
@@ -585,59 +586,51 @@
     // 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 = {}, dups = [];
-      options || (options = {});
+      var i, args, length, model, existing;
+      var at = options && options.at;
       models = _.isArray(models) ? models.slice() : [models];
 
       // Begin by turning bare objects into model references, and preventing
-      // invalid models or duplicate models from being added.
+      // invalid 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");
-        }
-        cid = model.cid;
-        id = model.id;
-        if (cids[cid] || this._byCid[cid] || ((id != null) && (ids[id] || this._byId[id]))) {
-          dups.push(i);
+        if (models[i] = this._prepareModel(models[i], options)) continue;
+        throw new Error("Can't add an invalid model to a collection");
+      }
+
+      for (i = models.length - 1; i >= 0; i--) {
+        model = models[i];
+        existing = model.id != null && this._byId[model.id];
+
+        // If a duplicate is found, splice it out and optionally merge it into
+        // the existing model.
+        if (existing || this._byCid[model.cid]) {
+          if (options && options.merge && existing) {
+            existing.set(model, options);
+          }
+          models.splice(i, 1);
           continue;
         }
-        cids[cid] = ids[id] = model;
-      }
 
-      // Remove duplicates.
-      i = dups.length;
-      while (i--) {
-        dups[i] = models.splice(dups[i], 1)[0];
-      }
-
-      // 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);
+        // Listen to added models' events, and index models for lookup by
+        // `id` and by `cid`.
+        model.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));
-
-      // Merge in duplicate models.
-      if (options.merge) {
-        for (i = 0, length = dups.length; i < length; i++) {
-          if (model = this._byId[dups[i].id]) model.set(dups[i], options);
-        }
-      }
+      // Update `length` and splice in new models.
+      this.length += models.length;
+      args = [at != null ? at : this.models.length, 0];
+      push.apply(args, models);
+      splice.apply(this.models, args);
 
       // Sort the collection if appropriate.
-      if (this.comparator && options.at == null) this.sort({silent: true});
+      if (this.comparator && at == null) 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;
+      if (options && options.silent) return this;
+
+      // Trigger `add` events.
+      while (model = models.shift()) {
         model.trigger('add', model, this, options);
       }
 
@@ -1138,7 +1131,7 @@
       fragment = this.getFragment(fragment || '');
       if (this.fragment === fragment) return;
       this.fragment = fragment;
-      var url = (fragment.indexOf(this.root) !== 0 ? this.root : '') + fragment;
+      var url = this.root + fragment;
 
       // If pushState is available, we use it to set the fragment as a real URL.
       if (this._hasPushState) {

vendor/backbone/test/collection.js

@@ -97,7 +97,7 @@ $(document).ready(function() {
     equal(col.pluck('label').join(' '), 'a b c d');
   });
 
-  test("add", 11, function() {
+  test("add", 10, function() {
     var added, opts, secondAdded;
     added = opts = secondAdded = null;
     e = new Backbone.Model({id: 10, label : 'e'});
@@ -107,7 +107,6 @@ $(document).ready(function() {
     });
     col.on('add', function(model, collection, options){
       added = model.get('label');
-      equal(options.index, 4);
       opts = options;
     });
     col.add(e, {amazing: true});
@@ -563,23 +562,6 @@ $(document).ready(function() {
     });
   });
 
-  test("index with comparator", 4, function() {
-    var counter = 0;
-    var col = new Backbone.Collection([{id: 2}, {id: 4}], {
-      comparator: function(model){ return model.id; }
-    }).on('add', function(model, colleciton, options){
-      if (model.id == 1) {
-        equal(options.index, 0);
-        equal(counter++, 0);
-      }
-      if (model.id == 3) {
-        equal(options.index, 2);
-        equal(counter++, 1);
-      }
-    });
-    col.add([{id: 3}, {id: 1}]);
-  });
-
   test("throwing during add leaves consistent state", 4, function() {
     var col = new Backbone.Collection();
     col.on('test', function() { ok(false); });
@@ -699,4 +681,24 @@ $(document).ready(function() {
     deepEqual(values, [1, 2, 3]);
   });
 
+  test("#1604 - Removal during iteration.", 0, function() {
+    var collection = new Backbone.Collection([{}, {}]);
+    collection.on('add', function() {
+      collection.at(0).destroy();
+    });
+    collection.add({}, {at: 0});
+  });
+
+  test("#1638 - `sort` during `add` triggers correctly.", function() {
+    var collection = new Backbone.Collection;
+    collection.comparator = function(model) { return model.get('x'); };
+    var added = [];
+    collection.on('add', function(model) {
+      model.set({x: 3});
+      collection.sort();
+      added.push(model.id);
+    });
+    collection.add([{id: 1, x: 1}, {id: 2, x: 2}]);
+    deepEqual(added, [1, 2]);
+  });
 });

vendor/underscore/test/collections.js

@@ -366,6 +366,15 @@ $(document).ready(function() {
 
     var indexFor30 = _.sortedIndex(numbers, 30);
     equal(indexFor30, 2, '30 should be inserted at index 2');
+
+    var objects = [{x: 10}, {x: 20}, {x: 30}, {x: 40}];
+    var iterator = function(obj){ return obj.x; };
+    strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2);
+    strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3);
+
+    var context = {1: 2, 2: 3, 3: 4};
+    iterator = function(obj){ return this[obj]; };
+    strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1);
   });
 
   test('shuffle', function() {

vendor/underscore/underscore.js

@@ -353,7 +353,7 @@
   // Use a comparator function to figure out the smallest index at which
   // an object should be inserted so as to maintain order. Uses binary search.
   _.sortedIndex = function(array, obj, iterator, context) {
-    iterator || (iterator = _.identity);
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
     var value = iterator.call(context, obj);
     var low = 0, high = array.length;
     while (low < high) {