From 1c2c01a8a6c53109700e9b4eb039164c675461b4 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 16:00:03 +0100
Subject: [PATCH 01/18] Ignored .idea directory

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index e58794b..9d32ed8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@
 tmp/
 ext/
 node_modules
-_SpecRunner.html
\ No newline at end of file
+_SpecRunner.html
+.idea/

From 301f37f1d98fa336d3b0b5fd8ee76bdf7b2e53e4 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 16:21:52 +0100
Subject: [PATCH 02/18] Added Karma config file

---
 spec/javascripts/support/karma.conf.js | 72 ++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 spec/javascripts/support/karma.conf.js

diff --git a/spec/javascripts/support/karma.conf.js b/spec/javascripts/support/karma.conf.js
new file mode 100644
index 0000000..1900128
--- /dev/null
+++ b/spec/javascripts/support/karma.conf.js
@@ -0,0 +1,72 @@
+// Karma configuration
+// Generated on Mon Dec 30 2013 16:14:03 GMT+0100 (CET)
+
+module.exports = function(config) {
+  config.set({
+
+    // base path, that will be used to resolve files and exclude
+    basePath: '',
+
+
+    // frameworks to use
+    frameworks: ['jasmine'],
+
+
+    // list of files / patterns to load in the browser
+    files: [
+      '../../../public/javascripts/underscore.js',
+      '../../../public/javascripts/backbone.js',
+      '../../../src/backbone.picky.js',
+      '../helpers/*.js',
+      '../*.spec.js'
+    ],
+
+
+    // list of files to exclude
+    exclude: [
+      
+    ],
+
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress', 'junit', 'growl', 'coverage'
+    reporters: ['progress'],
+
+
+    // web server port
+    port: 9876,
+
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: false,
+
+
+    // Start these browsers, currently available:
+    // - Chrome
+    // - ChromeCanary
+    // - Firefox
+    // - Opera (has to be installed with `npm install karma-opera-launcher`)
+    // - Safari (only Mac; has to be installed with `npm install karma-safari-launcher`)
+    // - PhantomJS
+    // - IE (only Windows; has to be installed with `npm install karma-ie-launcher`)
+    browsers: ['Firefox'],
+
+
+    // If browser does not capture in given timeout [ms], kill it
+    captureTimeout: 60000,
+
+
+    // Continuous Integration mode
+    // if true, it capture browsers, run tests and exit
+    singleRun: false
+  });
+};

From c8b66fa9e691e04e750b0e88a30233b38394e509 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 19:03:14 +0100
Subject: [PATCH 03/18] Fixed #7 "Attribute vs member" in documentation

---
 readme.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/readme.md b/readme.md
index 3386836..04c87e1 100644
--- a/readme.md
+++ b/readme.md
@@ -27,7 +27,7 @@ Production: [backbone.picky.min.js](https://raw.github.com/derickbailey/backbone
 
 This readme file contains basic usage examples and 
 details on the full API, including methods, 
-attributes and events.
+properties and events.
 
 ### Annotated Source Code
 
@@ -117,7 +117,7 @@ The following methods are included in the `Selectable` object
 
 #### Selectable#select
 
-Select a model, setting the model's `selected` attribute to true and 
+Select a model, setting the model's `selected` property to true and
 triggering a "select" event.
 
 ```js
@@ -132,7 +132,7 @@ myModel.selected; //=> true
 ```
 #### Selectable#deselect
 
-Deselect a model, setting the model's `selected` attribute to false and 
+Deselect a model, setting the model's `selected` property to false and
 triggering a "deselected" event.
 
 ```js
@@ -170,9 +170,9 @@ myModel.toggleSelected(); //=> "I'm selected!"
 myModel.toggleSelected(); //=> "I'm no longer selected!"
 ```
 
-### Selectable Attributes
+### Selectable Properties
 
-The following attributes are manipulated by the Selectable object
+The following properties are manipulated by the Selectable object
 
 #### Selectable#selected
 
@@ -233,7 +233,7 @@ The following methods are provided by the `SingleSelect` object.
 #### SingleSelect#select(model)
 
 Select a model. This method will store the selected model in
-the collection's `selected` attribute, and call the model's `select`
+the collection's `selected` property, and call the model's `select`
 method to ensure the model knows it has been selected.
 
 ```js
@@ -256,7 +256,7 @@ is already selected, the previous model will be deselected.
 #### SingleSelect#deselect(model)
 
 Deselect the currently selected model. This method will remove the 
-model from the collection's `selected` attribute, and call the model's 
+model from the collection's `selected` property, and call the model's
 `deselect` method to ensure the model knows it has been deselected.
 
 ```js
@@ -277,9 +277,9 @@ If the model is not currently selected, this is a no-op. If you try to
 deselect a model that is not the currently selected model, the actual
 selected model will not be deselected.
 
-### SingleSelect Attributes
+### SingleSelect Properties
 
-The following attribute is set by the multi-select automatically
+The following property is set by the multi-select automatically
 
 ### SingleSelect#selected
 
@@ -422,9 +422,9 @@ The following rules are used when toggling:
 * If 1 or more models, but less than all models are selected, select them all
 * If all models are selected, deselect them all
 
-### MultiSelect Attributes
+### MultiSelect Properties
 
-The following attribute is set by the multi-select automatically
+The following property is set by the multi-select automatically
 
 ### MultiSelect#selected
 

From 032bcb25d1624ae42c3dfa7409df690c6d255707 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 17:24:16 +0100
Subject: [PATCH 04/18] Added tests for deselectAll

---
 spec/javascripts/multiSelect.deselect.spec.js | 90 ++++++++++++++++++-
 1 file changed, 87 insertions(+), 3 deletions(-)

diff --git a/spec/javascripts/multiSelect.deselect.spec.js b/spec/javascripts/multiSelect.deselect.spec.js
index 3cf83ee..9cd35ce 100644
--- a/spec/javascripts/multiSelect.deselect.spec.js
+++ b/spec/javascripts/multiSelect.deselect.spec.js
@@ -15,7 +15,7 @@ describe("multi-select collection deselecting", function(){
     }
   });
   
-  describe("when no models are selected, and deselecting all", function(){
+  describe("when no models are selected, and deselecting all (selectNone)", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -42,7 +42,34 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
-  describe("when 1 model is selected, and deselecting all", function(){
+  describe("when no models are selected, and deselecting all (deselectAll)", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      spyOn(collection, "trigger").andCallThrough();
+
+      collection.deselectAll();
+    });
+
+    it("should trigger 'none' selected event", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
+    });
+
+    it("should have a selected count of 0", function(){
+      expect(collection.selectedLength).toBe(0);
+    });
+
+    it("should not have any models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(0);
+    });
+  });
+
+  describe("when 1 model is selected, and deselecting all (selectNone)", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -70,7 +97,35 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
-  describe("when all models are selected, and deselecting all", function(){
+  describe("when 1 model is selected, and deselecting all (deselectAll)", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      collection.deselectAll();
+    });
+
+    it("should trigger 'none' selected event", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
+    });
+
+    it("should have a selected count of 0", function(){
+      expect(collection.selectedLength).toBe(0);
+    });
+
+    it("should not have any models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(0);
+    });
+  });
+
+  describe("when all models are selected, and deselecting all (selectNone)", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -99,4 +154,33 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
+  describe("when all models are selected, and deselecting all (deselectAll)", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+      m2.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      collection.deselectAll();
+    });
+
+    it("should trigger 'none' selected event", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
+    });
+
+    it("should have a selected count of 0", function(){
+      expect(collection.selectedLength).toBe(0);
+    });
+
+    it("should not have any models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(0);
+    });
+  });
+
 });

From 27591be7b4607fb7727934f6896fe86457b5282e Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 17:31:48 +0100
Subject: [PATCH 05/18] Fixed #4 by adding deselectAll as an alias

deselectAll is more consistent with the rest of the API; selectNone is kept around for compatibility.
---
 src/backbone.picky.js | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index ce9d8e5..91ba0ed 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -44,7 +44,7 @@ Backbone.Picky = (function (Backbone, _) {
   // Picky.MultiSelect
   // -----------------
   // A mult-select mixin for Backbone.Collection, allowing a collection to
-  // have multiple items selected, including `selectAll` and `selectNone`
+  // have multiple items selected, including `selectAll` and `deselectAll`
   // capabilities.
 
   Picky.MultiSelect = function (collection) {
@@ -83,18 +83,22 @@ Backbone.Picky = (function (Backbone, _) {
     },
 
     // Deselect all models in this collection
-    selectNone: function () {
+    deselectAll: function () {
       if (this.selectedLength === 0) { return; }
       this.each(function (model) { model.deselect(); });
       calculateSelectedLength(this);
     },
 
-    // Toggle select all / none. If some are selected, it
+    selectNone: function () {
+      this.deselectAll();
+    },
+
+      // Toggle select all / none. If some are selected, it
     // will select all. If all are selected, it will select 
     // none. If none are selected, it will select all.
     toggleSelectAll: function () {
       if (this.selectedLength === this.length) {
-        this.selectNone();
+        this.deselectAll();
       } else {
         this.selectAll();
       }

From 661f8911f1f2940d47db45416a2437d2422c5a12 Mon Sep 17 00:00:00 2001
From: Walther Lalk <waltherlalk@gmail.com>
Date: Thu, 8 Aug 2013 15:23:26 +0200
Subject: [PATCH 06/18] Add support for a model which belongs to more than one
 collection.

If a selectable model belongs to more than one selectable collection then only the initial collection will have it's select() method called.

Also, if a model is initially added to a non-selectable collection, and then later added to a selectable collection the 2nd collection will not have it's select() method called, and a error will be thrown as the initial collection will not have a select() method.
---
 src/backbone.picky.js | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index 91ba0ed..c72f119 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -10,6 +10,8 @@ Backbone.Picky = (function (Backbone, _) {
 
   Picky.SingleSelect = function(collection){
     this.collection = collection;
+    this.collection.listenTo(this.collection, 'selected', this.select);
+    this.collection.listenTo(this.collection, 'deselected', this.deselect);
   };
 
   _.extend(Picky.SingleSelect.prototype, {
@@ -50,6 +52,9 @@ Backbone.Picky = (function (Backbone, _) {
   Picky.MultiSelect = function (collection) {
     this.collection = collection;
     this.selected = {};
+    this.collection.listenTo(this.collection, 'selected', this.select);
+    this.collection.listenTo(this.collection, 'deselected', this.deselect);
+
   };
 
   _.extend(Picky.MultiSelect.prototype, {
@@ -123,10 +128,6 @@ Backbone.Picky = (function (Backbone, _) {
 
       this.selected = true;
       this.trigger("selected", this);
-
-      if (this.collection) {
-        this.collection.select(this);
-      }
     },
 
     // Deselect this model, and tell our
@@ -136,10 +137,6 @@ Backbone.Picky = (function (Backbone, _) {
 
       this.selected = false;
       this.trigger("deselected", this);
-
-      if (this.collection) {
-        this.collection.deselect(this);
-      }
     },
 
     // Change selected to the opposite of what

From de62bb84aaa4d459ea954533626d83ae5dc623f7 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 23:19:25 +0100
Subject: [PATCH 07/18] Updated Backbone and Underscore libs

Backbone 1.0.0, Underscore 1.5.0. Using the listenTo and stopListening methods requires at least Backbone 0.9.9.
---
 public/javascripts/backbone.js   | 1609 +++++++++++++++++++++++++++++-
 public/javascripts/underscore.js | 1289 +++++++++++++++++++++++-
 2 files changed, 2828 insertions(+), 70 deletions(-)

diff --git a/public/javascripts/backbone.js b/public/javascripts/backbone.js
index c1c0d4f..3512d42 100644
--- a/public/javascripts/backbone.js
+++ b/public/javascripts/backbone.js
@@ -1,38 +1,1571 @@
-// 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://backbonejs.org
-(function(){var l=this,y=l.Backbone,z=Array.prototype.slice,A=Array.prototype.splice,g;g="undefined"!==typeof exports?exports:l.Backbone={};g.VERSION="0.9.2";var f=l._;!f&&"undefined"!==typeof require&&(f=require("underscore"));var i=l.jQuery||l.Zepto||l.ender;g.setDomLibrary=function(a){i=a};g.noConflict=function(){l.Backbone=y;return this};g.emulateHTTP=!1;g.emulateJSON=!1;var p=/\s+/,k=g.Events={on:function(a,b,c){var d,e,f,g,j;if(!b)return this;a=a.split(p);for(d=this._callbacks||(this._callbacks=
-{});e=a.shift();)f=(j=d[e])?j.tail:{},f.next=g={},f.context=c,f.callback=b,d[e]={tail:g,next:j?j.next:f};return this},off:function(a,b,c){var d,e,h,g,j,q;if(e=this._callbacks){if(!a&&!b&&!c)return delete this._callbacks,this;for(a=a?a.split(p):f.keys(e);d=a.shift();)if(h=e[d],delete e[d],h&&(b||c))for(g=h.tail;(h=h.next)!==g;)if(j=h.callback,q=h.context,b&&j!==b||c&&q!==c)this.on(d,j,q);return this}},trigger:function(a){var b,c,d,e,f,g;if(!(d=this._callbacks))return this;f=d.all;a=a.split(p);for(g=
-z.call(arguments,1);b=a.shift();){if(c=d[b])for(e=c.tail;(c=c.next)!==e;)c.callback.apply(c.context||this,g);if(c=f){e=c.tail;for(b=[b].concat(g);(c=c.next)!==e;)c.callback.apply(c.context||this,b)}}return this}};k.bind=k.on;k.unbind=k.off;var o=g.Model=function(a,b){var c;a||(a={});b&&b.parse&&(a=this.parse(a));if(c=n(this,"defaults"))a=f.extend({},c,a);b&&b.collection&&(this.collection=b.collection);this.attributes={};this._escapedAttributes={};this.cid=f.uniqueId("c");this.changed={};this._silent=
-{};this._pending={};this.set(a,{silent:!0});this.changed={};this._silent={};this._pending={};this._previousAttributes=f.clone(this.attributes);this.initialize.apply(this,arguments)};f.extend(o.prototype,k,{changed:null,_silent:null,_pending:null,idAttribute:"id",initialize:function(){},toJSON:function(){return f.clone(this.attributes)},get:function(a){return this.attributes[a]},escape:function(a){var b;if(b=this._escapedAttributes[a])return b;b=this.get(a);return this._escapedAttributes[a]=f.escape(null==
-b?"":""+b)},has:function(a){return null!=this.get(a)},set:function(a,b,c){var d,e;f.isObject(a)||null==a?(d=a,c=b):(d={},d[a]=b);c||(c={});if(!d)return this;d instanceof o&&(d=d.attributes);if(c.unset)for(e in d)d[e]=void 0;if(!this._validate(d,c))return!1;this.idAttribute in d&&(this.id=d[this.idAttribute]);var b=c.changes={},h=this.attributes,g=this._escapedAttributes,j=this._previousAttributes||{};for(e in d){a=d[e];if(!f.isEqual(h[e],a)||c.unset&&f.has(h,e))delete g[e],(c.silent?this._silent:
-b)[e]=!0;c.unset?delete h[e]:h[e]=a;!f.isEqual(j[e],a)||f.has(h,e)!=f.has(j,e)?(this.changed[e]=a,c.silent||(this._pending[e]=!0)):(delete this.changed[e],delete this._pending[e])}c.silent||this.change(c);return this},unset:function(a,b){(b||(b={})).unset=!0;return this.set(a,null,b)},clear:function(a){(a||(a={})).unset=!0;return this.set(f.clone(this.attributes),a)},fetch:function(a){var a=a?f.clone(a):{},b=this,c=a.success;a.success=function(d,e,f){if(!b.set(b.parse(d,f),a))return!1;c&&c(b,d)};
-a.error=g.wrapError(a.error,b,a);return(this.sync||g.sync).call(this,"read",this,a)},save:function(a,b,c){var d,e;f.isObject(a)||null==a?(d=a,c=b):(d={},d[a]=b);c=c?f.clone(c):{};if(c.wait){if(!this._validate(d,c))return!1;e=f.clone(this.attributes)}a=f.extend({},c,{silent:!0});if(d&&!this.set(d,c.wait?a:c))return!1;var h=this,i=c.success;c.success=function(a,b,e){b=h.parse(a,e);if(c.wait){delete c.wait;b=f.extend(d||{},b)}if(!h.set(b,c))return false;i?i(h,a):h.trigger("sync",h,a,c)};c.error=g.wrapError(c.error,
-h,c);b=this.isNew()?"create":"update";b=(this.sync||g.sync).call(this,b,this,c);c.wait&&this.set(e,a);return b},destroy:function(a){var a=a?f.clone(a):{},b=this,c=a.success,d=function(){b.trigger("destroy",b,b.collection,a)};if(this.isNew())return d(),!1;a.success=function(e){a.wait&&d();c?c(b,e):b.trigger("sync",b,e,a)};a.error=g.wrapError(a.error,b,a);var e=(this.sync||g.sync).call(this,"delete",this,a);a.wait||d();return e},url:function(){var a=n(this,"urlRoot")||n(this.collection,"url")||t();
-return this.isNew()?a:a+("/"==a.charAt(a.length-1)?"":"/")+encodeURIComponent(this.id)},parse:function(a){return a},clone:function(){return new this.constructor(this.attributes)},isNew:function(){return null==this.id},change:function(a){a||(a={});var b=this._changing;this._changing=!0;for(var c in this._silent)this._pending[c]=!0;var d=f.extend({},a.changes,this._silent);this._silent={};for(c in d)this.trigger("change:"+c,this,this.get(c),a);if(b)return this;for(;!f.isEmpty(this._pending);){this._pending=
-{};this.trigger("change",this,a);for(c in this.changed)!this._pending[c]&&!this._silent[c]&&delete this.changed[c];this._previousAttributes=f.clone(this.attributes)}this._changing=!1;return this},hasChanged:function(a){return!arguments.length?!f.isEmpty(this.changed):f.has(this.changed,a)},changedAttributes:function(a){if(!a)return this.hasChanged()?f.clone(this.changed):!1;var b,c=!1,d=this._previousAttributes,e;for(e in a)if(!f.isEqual(d[e],b=a[e]))(c||(c={}))[e]=b;return c},previous:function(a){return!arguments.length||
-!this._previousAttributes?null:this._previousAttributes[a]},previousAttributes:function(){return f.clone(this._previousAttributes)},isValid:function(){return!this.validate(this.attributes)},_validate:function(a,b){if(b.silent||!this.validate)return!0;var a=f.extend({},this.attributes,a),c=this.validate(a,b);if(!c)return!0;b&&b.error?b.error(this,c,b):this.trigger("error",this,c,b);return!1}});var r=g.Collection=function(a,b){b||(b={});b.model&&(this.model=b.model);b.comparator&&(this.comparator=b.comparator);
-this._reset();this.initialize.apply(this,arguments);a&&this.reset(a,{silent:!0,parse:b.parse})};f.extend(r.prototype,k,{model:o,initialize:function(){},toJSON:function(a){return this.map(function(b){return b.toJSON(a)})},add:function(a,b){var c,d,e,g,i,j={},k={},l=[];b||(b={});a=f.isArray(a)?a.slice():[a];c=0;for(d=a.length;c<d;c++){if(!(e=a[c]=this._prepareModel(a[c],b)))throw Error("Can't add an invalid model to a collection");g=e.cid;i=e.id;j[g]||this._byCid[g]||null!=i&&(k[i]||this._byId[i])?
-l.push(c):j[g]=k[i]=e}for(c=l.length;c--;)a.splice(l[c],1);c=0;for(d=a.length;c<d;c++)(e=a[c]).on("all",this._onModelEvent,this),this._byCid[e.cid]=e,null!=e.id&&(this._byId[e.id]=e);this.length+=d;A.apply(this.models,[null!=b.at?b.at:this.models.length,0].concat(a));this.comparator&&this.sort({silent:!0});if(b.silent)return this;c=0;for(d=this.models.length;c<d;c++)if(j[(e=this.models[c]).cid])b.index=c,e.trigger("add",e,this,b);return this},remove:function(a,b){var c,d,e,g;b||(b={});a=f.isArray(a)?
-a.slice():[a];c=0;for(d=a.length;c<d;c++)if(g=this.getByCid(a[c])||this.get(a[c]))delete this._byId[g.id],delete this._byCid[g.cid],e=this.indexOf(g),this.models.splice(e,1),this.length--,b.silent||(b.index=e,g.trigger("remove",g,this,b)),this._removeReference(g);return this},push:function(a,b){a=this._prepareModel(a,b);this.add(a,b);return a},pop:function(a){var b=this.at(this.length-1);this.remove(b,a);return b},unshift:function(a,b){a=this._prepareModel(a,b);this.add(a,f.extend({at:0},b));return a},
-shift:function(a){var b=this.at(0);this.remove(b,a);return b},get:function(a){return null==a?void 0:this._byId[null!=a.id?a.id:a]},getByCid:function(a){return a&&this._byCid[a.cid||a]},at:function(a){return this.models[a]},where:function(a){return f.isEmpty(a)?[]:this.filter(function(b){for(var c in a)if(a[c]!==b.get(c))return!1;return!0})},sort:function(a){a||(a={});if(!this.comparator)throw Error("Cannot sort a set without a comparator");var b=f.bind(this.comparator,this);1==this.comparator.length?
-this.models=this.sortBy(b):this.models.sort(b);a.silent||this.trigger("reset",this,a);return this},pluck:function(a){return f.map(this.models,function(b){return b.get(a)})},reset:function(a,b){a||(a=[]);b||(b={});for(var c=0,d=this.models.length;c<d;c++)this._removeReference(this.models[c]);this._reset();this.add(a,f.extend({silent:!0},b));b.silent||this.trigger("reset",this,b);return this},fetch:function(a){a=a?f.clone(a):{};void 0===a.parse&&(a.parse=!0);var b=this,c=a.success;a.success=function(d,
-e,f){b[a.add?"add":"reset"](b.parse(d,f),a);c&&c(b,d)};a.error=g.wrapError(a.error,b,a);return(this.sync||g.sync).call(this,"read",this,a)},create:function(a,b){var c=this,b=b?f.clone(b):{},a=this._prepareModel(a,b);if(!a)return!1;b.wait||c.add(a,b);var d=b.success;b.success=function(e,f){b.wait&&c.add(e,b);d?d(e,f):e.trigger("sync",a,f,b)};a.save(null,b);return a},parse:function(a){return a},chain:function(){return f(this.models).chain()},_reset:function(){this.length=0;this.models=[];this._byId=
-{};this._byCid={}},_prepareModel:function(a,b){b||(b={});a instanceof o?a.collection||(a.collection=this):(b.collection=this,a=new this.model(a,b),a._validate(a.attributes,b)||(a=!1));return a},_removeReference:function(a){this==a.collection&&delete a.collection;a.off("all",this._onModelEvent,this)},_onModelEvent:function(a,b,c,d){("add"==a||"remove"==a)&&c!=this||("destroy"==a&&this.remove(b,d),b&&a==="change:"+b.idAttribute&&(delete this._byId[b.previous(b.idAttribute)],this._byId[b.id]=b),this.trigger.apply(this,
-arguments))}});f.each("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".split(","),function(a){r.prototype[a]=function(){return f[a].apply(f,[this.models].concat(f.toArray(arguments)))}});var u=g.Router=function(a){a||(a={});a.routes&&(this.routes=a.routes);this._bindRoutes();this.initialize.apply(this,arguments)},B=/:\w+/g,
-C=/\*\w+/g,D=/[-[\]{}()+?.,\\^$|#\s]/g;f.extend(u.prototype,k,{initialize:function(){},route:function(a,b,c){g.history||(g.history=new m);f.isRegExp(a)||(a=this._routeToRegExp(a));c||(c=this[b]);g.history.route(a,f.bind(function(d){d=this._extractParameters(a,d);c&&c.apply(this,d);this.trigger.apply(this,["route:"+b].concat(d));g.history.trigger("route",this,b,d)},this));return this},navigate:function(a,b){g.history.navigate(a,b)},_bindRoutes:function(){if(this.routes){var a=[],b;for(b in this.routes)a.unshift([b,
-this.routes[b]]);b=0;for(var c=a.length;b<c;b++)this.route(a[b][0],a[b][1],this[a[b][1]])}},_routeToRegExp:function(a){a=a.replace(D,"\\$&").replace(B,"([^/]+)").replace(C,"(.*?)");return RegExp("^"+a+"$")},_extractParameters:function(a,b){return a.exec(b).slice(1)}});var m=g.History=function(){this.handlers=[];f.bindAll(this,"checkUrl")},s=/^[#\/]/,E=/msie [\w.]+/;m.started=!1;f.extend(m.prototype,k,{interval:50,getHash:function(a){return(a=(a?a.location:window.location).href.match(/#(.*)$/))?a[1]:
-""},getFragment:function(a,b){if(null==a)if(this._hasPushState||b){var a=window.location.pathname,c=window.location.search;c&&(a+=c)}else a=this.getHash();a.indexOf(this.options.root)||(a=a.substr(this.options.root.length));return a.replace(s,"")},start:function(a){if(m.started)throw Error("Backbone.history has already been started");m.started=!0;this.options=f.extend({},{root:"/"},this.options,a);this._wantsHashChange=!1!==this.options.hashChange;this._wantsPushState=!!this.options.pushState;this._hasPushState=
-!(!this.options.pushState||!window.history||!window.history.pushState);var a=this.getFragment(),b=document.documentMode;if(b=E.exec(navigator.userAgent.toLowerCase())&&(!b||7>=b))this.iframe=i('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo("body")[0].contentWindow,this.navigate(a);this._hasPushState?i(window).bind("popstate",this.checkUrl):this._wantsHashChange&&"onhashchange"in window&&!b?i(window).bind("hashchange",this.checkUrl):this._wantsHashChange&&(this._checkUrlInterval=setInterval(this.checkUrl,
-this.interval));this.fragment=a;a=window.location;b=a.pathname==this.options.root;if(this._wantsHashChange&&this._wantsPushState&&!this._hasPushState&&!b)return this.fragment=this.getFragment(null,!0),window.location.replace(this.options.root+"#"+this.fragment),!0;this._wantsPushState&&this._hasPushState&&b&&a.hash&&(this.fragment=this.getHash().replace(s,""),window.history.replaceState({},document.title,a.protocol+"//"+a.host+this.options.root+this.fragment));if(!this.options.silent)return this.loadUrl()},
-stop:function(){i(window).unbind("popstate",this.checkUrl).unbind("hashchange",this.checkUrl);clearInterval(this._checkUrlInterval);m.started=!1},route:function(a,b){this.handlers.unshift({route:a,callback:b})},checkUrl:function(){var a=this.getFragment();a==this.fragment&&this.iframe&&(a=this.getFragment(this.getHash(this.iframe)));if(a==this.fragment)return!1;this.iframe&&this.navigate(a);this.loadUrl()||this.loadUrl(this.getHash())},loadUrl:function(a){var b=this.fragment=this.getFragment(a);return f.any(this.handlers,
-function(a){if(a.route.test(b))return a.callback(b),!0})},navigate:function(a,b){if(!m.started)return!1;if(!b||!0===b)b={trigger:b};var c=(a||"").replace(s,"");this.fragment!=c&&(this._hasPushState?(0!=c.indexOf(this.options.root)&&(c=this.options.root+c),this.fragment=c,window.history[b.replace?"replaceState":"pushState"]({},document.title,c)):this._wantsHashChange?(this.fragment=c,this._updateHash(window.location,c,b.replace),this.iframe&&c!=this.getFragment(this.getHash(this.iframe))&&(b.replace||
-this.iframe.document.open().close(),this._updateHash(this.iframe.location,c,b.replace))):window.location.assign(this.options.root+a),b.trigger&&this.loadUrl(a))},_updateHash:function(a,b,c){c?a.replace(a.toString().replace(/(javascript:|#).*$/,"")+"#"+b):a.hash=b}});var v=g.View=function(a){this.cid=f.uniqueId("view");this._configure(a||{});this._ensureElement();this.initialize.apply(this,arguments);this.delegateEvents()},F=/^(\S+)\s*(.*)$/,w="model,collection,el,id,attributes,className,tagName".split(",");
-f.extend(v.prototype,k,{tagName:"div",$:function(a){return this.$el.find(a)},initialize:function(){},render:function(){return this},remove:function(){this.$el.remove();return this},make:function(a,b,c){a=document.createElement(a);b&&i(a).attr(b);c&&i(a).html(c);return a},setElement:function(a,b){this.$el&&this.undelegateEvents();this.$el=a instanceof i?a:i(a);this.el=this.$el[0];!1!==b&&this.delegateEvents();return this},delegateEvents:function(a){if(a||(a=n(this,"events"))){this.undelegateEvents();
-for(var b in a){var c=a[b];f.isFunction(c)||(c=this[a[b]]);if(!c)throw Error('Method "'+a[b]+'" does not exist');var d=b.match(F),e=d[1],d=d[2],c=f.bind(c,this),e=e+(".delegateEvents"+this.cid);""===d?this.$el.bind(e,c):this.$el.delegate(d,e,c)}}},undelegateEvents:function(){this.$el.unbind(".delegateEvents"+this.cid)},_configure:function(a){this.options&&(a=f.extend({},this.options,a));for(var b=0,c=w.length;b<c;b++){var d=w[b];a[d]&&(this[d]=a[d])}this.options=a},_ensureElement:function(){if(this.el)this.setElement(this.el,
-!1);else{var a=n(this,"attributes")||{};this.id&&(a.id=this.id);this.className&&(a["class"]=this.className);this.setElement(this.make(this.tagName,a),!1)}}});o.extend=r.extend=u.extend=v.extend=function(a,b){var c=G(this,a,b);c.extend=this.extend;return c};var H={create:"POST",update:"PUT","delete":"DELETE",read:"GET"};g.sync=function(a,b,c){var d=H[a];c||(c={});var e={type:d,dataType:"json"};c.url||(e.url=n(b,"url")||t());if(!c.data&&b&&("create"==a||"update"==a))e.contentType="application/json",
-e.data=JSON.stringify(b.toJSON());g.emulateJSON&&(e.contentType="application/x-www-form-urlencoded",e.data=e.data?{model:e.data}:{});if(g.emulateHTTP&&("PUT"===d||"DELETE"===d))g.emulateJSON&&(e.data._method=d),e.type="POST",e.beforeSend=function(a){a.setRequestHeader("X-HTTP-Method-Override",d)};"GET"!==e.type&&!g.emulateJSON&&(e.processData=!1);return i.ajax(f.extend(e,c))};g.wrapError=function(a,b,c){return function(d,e){e=d===b?e:d;a?a(b,e,c):b.trigger("error",b,e,c)}};var x=function(){},G=function(a,
-b,c){var d;d=b&&b.hasOwnProperty("constructor")?b.constructor:function(){a.apply(this,arguments)};f.extend(d,a);x.prototype=a.prototype;d.prototype=new x;b&&f.extend(d.prototype,b);c&&f.extend(d,c);d.prototype.constructor=d;d.__super__=a.prototype;return d},n=function(a,b){return!a||!a[b]?null:f.isFunction(a[b])?a[b]():a[b]},t=function(){throw Error('A "url" property or function must be specified');}}).call(this);
+//     Backbone.js 1.0.0
+
+//     (c) 2010-2013 Jeremy Ashkenas, DocumentCloud Inc.
+//     Backbone may be freely distributed under the MIT license.
+//     For all details and documentation:
+//     http://backbonejs.org
+
+(function(){
+
+  // Initial Setup
+  // -------------
+
+  // Save a reference to the global object (`window` in the browser, `exports`
+  // on the server).
+  var root = this;
+
+  // 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 local references to array methods we'll want to use later.
+  var array = [];
+  var push = array.push;
+  var slice = array.slice;
+  var splice = array.splice;
+
+  // The top-level namespace. All public Backbone classes and modules will
+  // be attached to this. Exported for both the browser and the server.
+  var Backbone;
+  if (typeof exports !== 'undefined') {
+    Backbone = exports;
+  } else {
+    Backbone = root.Backbone = {};
+  }
+
+  // Current version of the library. Keep in sync with `package.json`.
+  Backbone.VERSION = '1.0.0';
+
+  // Require Underscore, if we're on the server, and it's not already present.
+  var _ = root._;
+  if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
+
+  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
+  // the `$` variable.
+  Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
+
+  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
+  // to its previous owner. Returns a reference to this Backbone object.
+  Backbone.noConflict = function() {
+    root.Backbone = previousBackbone;
+    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.
+  Backbone.emulateHTTP = false;
+
+  // Turn on `emulateJSON` to support legacy servers that can't deal with direct
+  // `application/json` requests ... will encode the body as
+  // `application/x-www-form-urlencoded` instead and will send the model in a
+  // form param named `model`.
+  Backbone.emulateJSON = false;
+
+  // Backbone.Events
+  // ---------------
+
+  // 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.
+  //
+  //     var object = {};
+  //     _.extend(object, Backbone.Events);
+  //     object.on('expand', function(){ alert('expanded'); });
+  //     object.trigger('expand');
+  //
+  var Events = Backbone.Events = {
+
+    // Bind an event to a `callback` function. Passing `"all"` will bind
+    // the callback to all events fired.
+    on: function(name, callback, context) {
+      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
+      this._events || (this._events = {});
+      var events = this._events[name] || (this._events[name] = []);
+      events.push({callback: callback, context: context, ctx: context || this});
+      return this;
+    },
+
+    // Bind an event to only be triggered a single time. After the first time
+    // the callback is invoked, it will be removed.
+    once: function(name, callback, context) {
+      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
+      var self = this;
+      var once = _.once(function() {
+        self.off(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+      return this.on(name, once, context);
+    },
+
+    // Remove one or many callbacks. If `context` is null, removes all
+    // callbacks with that function. If `callback` is null, removes all
+    // callbacks for the event. If `name` is null, removes all bound
+    // callbacks for all events.
+    off: function(name, callback, context) {
+      var retain, ev, events, names, i, l, j, k;
+      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+      if (!name && !callback && !context) {
+        this._events = {};
+        return this;
+      }
+
+      names = name ? [name] : _.keys(this._events);
+      for (i = 0, l = names.length; i < l; i++) {
+        name = names[i];
+        if (events = this._events[name]) {
+          this._events[name] = retain = [];
+          if (callback || context) {
+            for (j = 0, k = events.length; j < k; j++) {
+              ev = events[j];
+              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
+                  (context && context !== ev.context)) {
+                retain.push(ev);
+              }
+            }
+          }
+          if (!retain.length) delete this._events[name];
+        }
+      }
+
+      return this;
+    },
+
+    // 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(name) {
+      if (!this._events) return this;
+      var args = slice.call(arguments, 1);
+      if (!eventsApi(this, 'trigger', name, args)) return this;
+      var events = this._events[name];
+      var allEvents = this._events.all;
+      if (events) triggerEvents(events, args);
+      if (allEvents) triggerEvents(allEvents, arguments);
+      return this;
+    },
+
+    // Tell this object to stop listening to either specific events ... or
+    // to every object it's currently listening to.
+    stopListening: function(obj, name, callback) {
+      var listeners = this._listeners;
+      if (!listeners) return this;
+      var deleteListener = !name && !callback;
+      if (typeof name === 'object') callback = this;
+      if (obj) (listeners = {})[obj._listenerId] = obj;
+      for (var id in listeners) {
+        listeners[id].off(name, callback, this);
+        if (deleteListener) delete this._listeners[id];
+      }
+      return this;
+    }
+
+  };
+
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Implement fancy features of the Events API such as multiple event
+  // names `"change blur"` and jQuery-style event maps `{change: action}`
+  // in terms of the existing API.
+  var eventsApi = function(obj, action, name, rest) {
+    if (!name) return true;
+
+    // Handle event maps.
+    if (typeof name === 'object') {
+      for (var key in name) {
+        obj[action].apply(obj, [key, name[key]].concat(rest));
+      }
+      return false;
+    }
+
+    // Handle space separated event names.
+    if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        obj[action].apply(obj, [names[i]].concat(rest));
+      }
+      return false;
+    }
+
+    return true;
+  };
+
+  // A difficult-to-believe, but optimized internal dispatch function for
+  // triggering events. Tries to keep the usual cases speedy (most internal
+  // Backbone events have 3 arguments).
+  var triggerEvents = function(events, args) {
+    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
+    switch (args.length) {
+      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
+      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
+      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
+      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
+      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+    }
+  };
+
+  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
+
+  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
+  // listen to an event in another object ... keeping track of what it's
+  // listening to.
+  _.each(listenMethods, function(implementation, method) {
+    Events[method] = function(obj, name, callback) {
+      var listeners = this._listeners || (this._listeners = {});
+      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
+      listeners[id] = obj;
+      if (typeof name === 'object') callback = this;
+      obj[implementation](name, callback, this);
+      return this;
+    };
+  });
+
+  // Aliases for backwards compatibility.
+  Events.bind   = Events.on;
+  Events.unbind = Events.off;
+
+  // Allow the `Backbone` object to serve as a global event bus, for folks who
+  // want global "pubsub" in a convenient place.
+  _.extend(Backbone, Events);
+
+  // Backbone.Model
+  // --------------
+
+  // Backbone **Models** are the basic data object in the framework --
+  // frequently representing a row in a table in a database on your server.
+  // A discrete chunk of data and a bunch of useful, related methods for
+  // performing computations and transformations on that data.
+
+  // Create a new model with the specified attributes. A client id (`cid`)
+  // is automatically generated and assigned for you.
+  var Model = Backbone.Model = function(attributes, options) {
+    var defaults;
+    var attrs = attributes || {};
+    options || (options = {});
+    this.cid = _.uniqueId('c');
+    this.attributes = {};
+    _.extend(this, _.pick(options, modelOptions));
+    if (options.parse) attrs = this.parse(attrs, options) || {};
+    if (defaults = _.result(this, 'defaults')) {
+      attrs = _.defaults({}, attrs, defaults);
+    }
+    this.set(attrs, options);
+    this.changed = {};
+    this.initialize.apply(this, arguments);
+  };
+
+  // A list of options to be attached directly to the model, if provided.
+  var modelOptions = ['url', 'urlRoot', 'collection'];
+
+  // Attach all inheritable methods to the Model prototype.
+  _.extend(Model.prototype, Events, {
+
+    // A hash of attributes whose current and previous value differ.
+    changed: null,
+
+    // The value returned during the last failed validation.
+    validationError: null,
+
+    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+    // CouchDB users may want to set this to `"_id"`.
+    idAttribute: 'id',
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Return a copy of the model's `attributes` object.
+    toJSON: function(options) {
+      return _.clone(this.attributes);
+    },
+
+    // Proxy `Backbone.sync` by default -- but override this if you need
+    // custom syncing semantics for *this* particular model.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Get the value of an attribute.
+    get: function(attr) {
+      return this.attributes[attr];
+    },
+
+    // Get the HTML-escaped value of an attribute.
+    escape: function(attr) {
+      return _.escape(this.get(attr));
+    },
+
+    // Returns `true` if the attribute contains a value that is not null
+    // or undefined.
+    has: function(attr) {
+      return this.get(attr) != null;
+    },
+
+    // Set a hash of model attributes on the object, firing `"change"`. This is
+    // the core primitive operation of a model, updating the data and notifying
+    // anyone who needs to know about the change in state. The heart of the beast.
+    set: function(key, val, options) {
+      var attr, attrs, unset, changes, silent, changing, prev, current;
+      if (key == null) return this;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      options || (options = {});
+
+      // Run validation.
+      if (!this._validate(attrs, options)) return false;
+
+      // Extract attributes and options.
+      unset           = options.unset;
+      silent          = options.silent;
+      changes         = [];
+      changing        = this._changing;
+      this._changing  = true;
+
+      if (!changing) {
+        this._previousAttributes = _.clone(this.attributes);
+        this.changed = {};
+      }
+      current = this.attributes, prev = this._previousAttributes;
+
+      // Check for changes of `id`.
+      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+
+      // For each `set` attribute, update or delete the current value.
+      for (attr in attrs) {
+        val = attrs[attr];
+        if (!_.isEqual(current[attr], val)) changes.push(attr);
+        if (!_.isEqual(prev[attr], val)) {
+          this.changed[attr] = val;
+        } else {
+          delete this.changed[attr];
+        }
+        unset ? delete current[attr] : current[attr] = val;
+      }
+
+      // Trigger all relevant attribute changes.
+      if (!silent) {
+        if (changes.length) this._pending = true;
+        for (var i = 0, l = changes.length; i < l; i++) {
+          this.trigger('change:' + changes[i], this, current[changes[i]], options);
+        }
+      }
+
+      // You might be wondering why there's a `while` loop here. Changes can
+      // be recursively nested within `"change"` events.
+      if (changing) return this;
+      if (!silent) {
+        while (this._pending) {
+          this._pending = false;
+          this.trigger('change', this, options);
+        }
+      }
+      this._pending = false;
+      this._changing = false;
+      return this;
+    },
+
+    // Remove an attribute from the model, firing `"change"`. `unset` is a noop
+    // if the attribute doesn't exist.
+    unset: function(attr, options) {
+      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
+    },
+
+    // Clear all attributes on the model, firing `"change"`.
+    clear: function(options) {
+      var attrs = {};
+      for (var key in this.attributes) attrs[key] = void 0;
+      return this.set(attrs, _.extend({}, options, {unset: true}));
+    },
+
+    // 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 == null) 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. 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;
+      var old = this._changing ? this._previousAttributes : this.attributes;
+      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 == null || !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() {
+      return _.clone(this._previousAttributes);
+    },
+
+    // Fetch the model from the server. If the server's representation of the
+    // model differs from its current attributes, they will be overridden,
+    // triggering a `"change"` event.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var model = this;
+      var success = options.success;
+      options.success = function(resp) {
+        if (!model.set(model.parse(resp, options), options)) return false;
+        if (success) success(model, resp, options);
+        model.trigger('sync', model, resp, options);
+      };
+      wrapError(this, options);
+      return this.sync('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, val, options) {
+      var attrs, method, xhr, attributes = this.attributes;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (key == null || typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
+      if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
+
+      options = _.extend({validate: true}, options);
+
+      // Do not persist invalid models.
+      if (!this._validate(attrs, options)) return false;
+
+      // Set temporary attributes if `{wait: true}`.
+      if (attrs && options.wait) {
+        this.attributes = _.extend({}, attributes, attrs);
+      }
+
+      // After a successful server-side save, the client is (optionally)
+      // updated with the server-side state.
+      if (options.parse === void 0) options.parse = true;
+      var model = this;
+      var success = options.success;
+      options.success = function(resp) {
+        // Ensure attributes are restored during synchronous saves.
+        model.attributes = attributes;
+        var serverAttrs = model.parse(resp, options);
+        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
+        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
+          return false;
+        }
+        if (success) success(model, resp, options);
+        model.trigger('sync', model, resp, options);
+      };
+      wrapError(this, options);
+
+      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+      if (method === 'patch') options.attrs = attrs;
+      xhr = this.sync(method, this, options);
+
+      // Restore attributes.
+      if (attrs && options.wait) this.attributes = attributes;
+
+      return xhr;
+    },
+
+    // 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;
+
+      var destroy = function() {
+        model.trigger('destroy', model, model.collection, options);
+      };
+
+      options.success = function(resp) {
+        if (options.wait || model.isNew()) destroy();
+        if (success) success(model, resp, options);
+        if (!model.isNew()) model.trigger('sync', model, resp, options);
+      };
+
+      if (this.isNew()) {
+        options.success();
+        return false;
+      }
+      wrapError(this, options);
+
+      var xhr = this.sync('delete', this, options);
+      if (!options.wait) destroy();
+      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 = _.result(this, 'urlRoot') || _.result(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, options) {
+      return resp;
+    },
+
+    // Create a new model with identical attributes to this one.
+    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() {
+      return this.id == null;
+    },
+
+    // Check if the model is currently in a valid state.
+    isValid: function(options) {
+      return this._validate({}, _.extend(options || {}, { validate: true }));
+    },
+
+    // Run validation against the next complete set of model attributes,
+    // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
+    _validate: function(attrs, options) {
+      if (!options.validate || !this.validate) return true;
+      attrs = _.extend({}, this.attributes, attrs);
+      var error = this.validationError = this.validate(attrs, options) || null;
+      if (!error) return true;
+      this.trigger('invalid', this, error, _.extend(options || {}, {validationError: error}));
+      return false;
+    }
+
+  });
+
+  // Underscore methods that we want to implement on the Model.
+  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
+
+  // Mix in each Underscore method as a proxy to `Model#attributes`.
+  _.each(modelMethods, function(method) {
+    Model.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.attributes);
+      return _[method].apply(_, args);
+    };
+  });
+
+  // Backbone.Collection
+  // -------------------
+
+  // If models tend to represent a single row of data, a Backbone Collection is
+  // more analagous to a table full of data ... or a small slice or page of that
+  // table, or a collection of rows that belong together for a particular reason
+  // -- all of the messages in this particular folder, all of the documents
+  // belonging to this particular author, and so on. Collections maintain
+  // indexes of their models, both in order, and for lookup by `id`.
+
+  // Create a new **Collection**, perhaps to contain a specific type of `model`.
+  // If a `comparator` is specified, the Collection will maintain
+  // its models in sort order, as they're added and removed.
+  var Collection = Backbone.Collection = function(models, options) {
+    options || (options = {});
+    if (options.url) this.url = options.url;
+    if (options.model) this.model = options.model;
+    if (options.comparator !== void 0) this.comparator = options.comparator;
+    this._reset();
+    this.initialize.apply(this, arguments);
+    if (models) this.reset(models, _.extend({silent: true}, options));
+  };
+
+  // Default options for `Collection#set`.
+  var setOptions = {add: true, remove: true, merge: true};
+  var addOptions = {add: true, merge: false, remove: false};
+
+  // Define the Collection's inheritable methods.
+  _.extend(Collection.prototype, Events, {
+
+    // The default model for a collection is just a **Backbone.Model**.
+    // This should be overridden in most cases.
+    model: Model,
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // The JSON representation of a Collection is an array of the
+    // models' attributes.
+    toJSON: function(options) {
+      return this.map(function(model){ return model.toJSON(options); });
+    },
+
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Add a model, or list of models to the set.
+    add: function(models, options) {
+      return this.set(models, _.defaults(options || {}, addOptions));
+    },
+
+    // Remove a model, or a list of models from the set.
+    remove: function(models, options) {
+      models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, index, model;
+      for (i = 0, l = models.length; i < l; i++) {
+        model = this.get(models[i]);
+        if (!model) continue;
+        delete this._byId[model.id];
+        delete this._byId[model.cid];
+        index = this.indexOf(model);
+        this.models.splice(index, 1);
+        this.length--;
+        if (!options.silent) {
+          options.index = index;
+          model.trigger('remove', model, this, options);
+        }
+        this._removeReference(model);
+      }
+      return this;
+    },
+
+    // Update a collection by `set`-ing a new list of models, adding new ones,
+    // removing models that are no longer present, and merging models that
+    // already exist in the collection, as necessary. Similar to **Model#set**,
+    // the core operation for updating the data contained by the collection.
+    set: function(models, options) {
+      options = _.defaults(options || {}, setOptions);
+      if (options.parse) models = this.parse(models, options);
+      if (!_.isArray(models)) models = models ? [models] : [];
+      var i, l, model, attrs, existing, sort;
+      var at = options.at;
+      var sortable = this.comparator && (at == null) && options.sort !== false;
+      var sortAttr = _.isString(this.comparator) ? this.comparator : null;
+      var toAdd = [], toRemove = [], modelMap = {};
+
+      // Turn bare objects into model references, and prevent invalid models
+      // from being added.
+      for (i = 0, l = models.length; i < l; i++) {
+        if (!(model = this._prepareModel(models[i], options))) continue;
+
+        // If a duplicate is found, prevent it from being added and
+        // optionally merge it into the existing model.
+        if (existing = this.get(model)) {
+          if (options.remove) modelMap[existing.cid] = true;
+          if (options.merge) {
+            existing.set(model.attributes, options);
+            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
+          }
+
+        // This is a new model, push it to the `toAdd` list.
+        } else if (options.add) {
+          toAdd.push(model);
+
+          // Listen to added models' events, and index models for lookup by
+          // `id` and by `cid`.
+          model.on('all', this._onModelEvent, this);
+          this._byId[model.cid] = model;
+          if (model.id != null) this._byId[model.id] = model;
+        }
+      }
+
+      // Remove nonexistent models if appropriate.
+      if (options.remove) {
+        for (i = 0, l = this.length; i < l; ++i) {
+          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
+        }
+        if (toRemove.length) this.remove(toRemove, options);
+      }
+
+      // See if sorting is needed, update `length` and splice in new models.
+      if (toAdd.length) {
+        if (sortable) sort = true;
+        this.length += toAdd.length;
+        if (at != null) {
+          splice.apply(this.models, [at, 0].concat(toAdd));
+        } else {
+          push.apply(this.models, toAdd);
+        }
+      }
+
+      // Silently sort the collection if appropriate.
+      if (sort) this.sort({silent: true});
+
+      if (options.silent) return this;
+
+      // Trigger `add` events.
+      for (i = 0, l = toAdd.length; i < l; i++) {
+        (model = toAdd[i]).trigger('add', model, this, options);
+      }
+
+      // Trigger `sort` if the collection was sorted.
+      if (sort) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // 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 granular `add` or `remove` events. Fires `reset` when finished.
+    // Useful for bulk operations and optimizations.
+    reset: function(models, options) {
+      options || (options = {});
+      for (var i = 0, l = this.models.length; i < l; i++) {
+        this._removeReference(this.models[i]);
+      }
+      options.previousModels = this.models;
+      this._reset();
+      this.add(models, _.extend({silent: true}, options));
+      if (!options.silent) this.trigger('reset', this, options);
+      return this;
+    },
+
+    // Add a model to the end of the collection.
+    push: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: this.length}, 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;
+    },
+
+    // Slice out a sub-array of models from the collection.
+    slice: function(begin, end) {
+      return this.models.slice(begin, end);
+    },
+
+    // Get a model from the set by id.
+    get: function(obj) {
+      if (obj == null) return void 0;
+      return this._byId[obj.id != null ? obj.id : obj.cid || obj];
+    },
+
+    // Get the model at the given index.
+    at: function(index) {
+      return this.models[index];
+    },
+
+    // Return models with matching attributes. Useful for simple cases of
+    // `filter`.
+    where: function(attrs, first) {
+      if (_.isEmpty(attrs)) return first ? void 0 : [];
+      return this[first ? 'find' : 'filter'](function(model) {
+        for (var key in attrs) {
+          if (attrs[key] !== model.get(key)) return false;
+        }
+        return true;
+      });
+    },
+
+    // Return the first model with matching attributes. Useful for simple cases
+    // of `find`.
+    findWhere: function(attrs) {
+      return this.where(attrs, 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) {
+      if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+      options || (options = {});
+
+      // Run sort based on type of `comparator`.
+      if (_.isString(this.comparator) || this.comparator.length === 1) {
+        this.models = this.sortBy(this.comparator, this);
+      } else {
+        this.models.sort(_.bind(this.comparator, this));
+      }
+
+      if (!options.silent) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // Figure out the smallest index at which a model should be inserted so as
+    // to maintain order.
+    sortedIndex: function(model, value, context) {
+      value || (value = this.comparator);
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _.sortedIndex(this.models, model, iterator, context);
+    },
+
+    // Pluck an attribute from each model in the collection.
+    pluck: function(attr) {
+      return _.invoke(this.models, 'get', attr);
+    },
+
+    // Fetch the default set of models for this collection, resetting the
+    // collection when they arrive. If `reset: true` is passed, the response
+    // data will be passed through the `reset` method instead of `set`.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var success = options.success;
+      var collection = this;
+      options.success = function(resp) {
+        var method = options.reset ? 'reset' : 'set';
+        collection[method](resp, options);
+        if (success) success(collection, resp, options);
+        collection.trigger('sync', collection, resp, options);
+      };
+      wrapError(this, options);
+      return this.sync('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) {
+      options = options ? _.clone(options) : {};
+      if (!(model = this._prepareModel(model, options))) return false;
+      if (!options.wait) this.add(model, options);
+      var collection = this;
+      var success = options.success;
+      options.success = function(resp) {
+        if (options.wait) collection.add(model, options);
+        if (success) success(model, resp, options);
+      };
+      model.save(null, options);
+      return model;
+    },
+
+    // **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, options) {
+      return resp;
+    },
+
+    // Create a new collection with an identical list of models as this one.
+    clone: function() {
+      return new this.constructor(this.models);
+    },
+
+    // Private method to reset all internal state. Called when the collection
+    // is first initialized or reset.
+    _reset: function() {
+      this.length = 0;
+      this.models = [];
+      this._byId  = {};
+    },
+
+    // Prepare a hash of attributes (or other model) to be added to this
+    // collection.
+    _prepareModel: function(attrs, options) {
+      if (attrs instanceof Model) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
+      options || (options = {});
+      options.collection = this;
+      var model = new this.model(attrs, options);
+      if (!model._validate(attrs, options)) {
+        this.trigger('invalid', this, attrs, options);
+        return false;
+      }
+      return model;
+    },
+
+    // Internal method to sever a model's ties to a collection.
+    _removeReference: function(model) {
+      if (this === model.collection) delete model.collection;
+      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(event, model, collection, options) {
+      if ((event === 'add' || event === 'remove') && collection !== this) return;
+      if (event === 'destroy') this.remove(model, options);
+      if (model && event === 'change:' + model.idAttribute) {
+        delete this._byId[model.previous(model.idAttribute)];
+        if (model.id != null) this._byId[model.id] = model;
+      }
+      this.trigger.apply(this, arguments);
+    }
+
+  });
+
+  // Underscore methods that we want to implement on the Collection.
+  // 90% of the core usefulness of Backbone Collections is actually implemented
+  // right here:
+  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
+    'isEmpty', 'chain'];
+
+  // Mix in each Underscore method as a proxy to `Collection#models`.
+  _.each(methods, function(method) {
+    Collection.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.models);
+      return _[method].apply(_, args);
+    };
+  });
+
+  // Underscore methods that take a property name as an argument.
+  var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+  // Use attributes instead of properties.
+  _.each(attributeMethods, function(method) {
+    Collection.prototype[method] = function(value, context) {
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _[method](this.models, iterator, context);
+    };
+  });
+
+  // Backbone.View
+  // -------------
+
+  // Backbone Views are almost more convention than they are actual code. A View
+  // is simply a JavaScript object that represents a logical chunk of UI in the
+  // DOM. This might be a single item, an entire list, a sidebar or panel, or
+  // even the surrounding frame which wraps your whole app. Defining a chunk of
+  // UI as a **View** allows you to define your DOM events declaratively, without
+  // having to worry about render order ... and makes it easy for the view to
+  // react to specific changes in the state of your models.
+
+  // Creating a Backbone.View creates its initial element outside of the DOM,
+  // if an existing element is not provided...
+  var View = Backbone.View = function(options) {
+    this.cid = _.uniqueId('view');
+    this._configure(options || {});
+    this._ensureElement();
+    this.initialize.apply(this, arguments);
+    this.delegateEvents();
+  };
+
+  // Cached regex to split keys for `delegate`.
+  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+  // List of view options to be merged as properties.
+  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
+
+  // Set up all inheritable **Backbone.View** properties and methods.
+  _.extend(View.prototype, Events, {
+
+    // The default `tagName` of a View's element is `"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);
+    },
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    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() {
+      return this;
+    },
+
+    // Remove this view by taking the element out of the DOM, and removing any
+    // applicable Backbone.Events listeners.
+    remove: function() {
+      this.$el.remove();
+      this.stopListening();
+      return this;
+    },
+
+    // Change the view's element (`this.el` property), including event
+    // re-delegation.
+    setElement: function(element, delegate) {
+      if (this.$el) this.undelegateEvents();
+      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
+      this.el = this.$el[0];
+      if (delegate !== false) this.delegateEvents();
+      return this;
+    },
+
+    // Set callbacks, where `this.events` is a hash of
+    //
+    // *{"event selector": "callback"}*
+    //
+    //     {
+    //       'mousedown .title':  'edit',
+    //       'click .button':     'save'
+    //       'click .open':       function(e) { ... }
+    //     }
+    //
+    // pairs. Callbacks will be bound to the view, with `this` set properly.
+    // Uses event delegation for efficiency.
+    // 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 = _.result(this, 'events')))) return this;
+      this.undelegateEvents();
+      for (var key in events) {
+        var method = events[key];
+        if (!_.isFunction(method)) method = this[events[key]];
+        if (!method) continue;
+
+        var match = key.match(delegateEventSplitter);
+        var eventName = match[1], selector = match[2];
+        method = _.bind(method, this);
+        eventName += '.delegateEvents' + this.cid;
+        if (selector === '') {
+          this.$el.on(eventName, method);
+        } else {
+          this.$el.on(eventName, selector, method);
+        }
+      }
+      return this;
+    },
+
+    // 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.off('.delegateEvents' + this.cid);
+      return this;
+    },
+
+    // Performs the initial configuration of a View with a set of options.
+    // Keys with special meaning *(e.g. model, collection, id, className)* are
+    // attached directly to the view.  See `viewOptions` for an exhaustive
+    // list.
+    _configure: function(options) {
+      if (this.options) options = _.extend({}, _.result(this, 'options'), options);
+      _.extend(this, _.pick(options, viewOptions));
+      this.options = options;
+    },
+
+    // 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() {
+      if (!this.el) {
+        var attrs = _.extend({}, _.result(this, 'attributes'));
+        if (this.id) attrs.id = _.result(this, 'id');
+        if (this.className) attrs['class'] = _.result(this, 'className');
+        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
+        this.setElement($el, false);
+      } else {
+        this.setElement(_.result(this, 'el'), false);
+      }
+    }
+
+  });
+
+  // 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
+  // to the model's `url()`. Some possible customizations could be:
+  //
+  // * Use `setTimeout` to batch rapid-fire updates into a single request.
+  // * Send up the models as XML instead of JSON.
+  // * Persist models via WebSockets instead of Ajax.
+  //
+  // 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`.
+  // 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 options, unless specified.
+    _.defaults(options || (options = {}), {
+      emulateHTTP: Backbone.emulateHTTP,
+      emulateJSON: Backbone.emulateJSON
+    });
+
+    // Default JSON-request options.
+    var params = {type: type, dataType: 'json'};
+
+    // Ensure that we have a URL.
+    if (!options.url) {
+      params.url = _.result(model, 'url') || urlError();
+    }
+
+    // Ensure that we have the appropriate request data.
+    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+      params.contentType = 'application/json';
+      params.data = JSON.stringify(options.attrs || model.toJSON(options));
+    }
+
+    // For older servers, emulate JSON by encoding the request into an HTML-form.
+    if (options.emulateJSON) {
+      params.contentType = 'application/x-www-form-urlencoded';
+      params.data = params.data ? {model: params.data} : {};
+    }
+
+    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
+    // And an `X-HTTP-Method-Override` header.
+    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
+      params.type = 'POST';
+      if (options.emulateJSON) params.data._method = type;
+      var beforeSend = options.beforeSend;
+      options.beforeSend = function(xhr) {
+        xhr.setRequestHeader('X-HTTP-Method-Override', type);
+        if (beforeSend) return beforeSend.apply(this, arguments);
+      };
+    }
+
+    // Don't process data on a non-GET request.
+    if (params.type !== 'GET' && !options.emulateJSON) {
+      params.processData = false;
+    }
+
+    // If we're sending a `PATCH` request, and we're in an old Internet Explorer
+    // that still has ActiveX enabled by default, override jQuery to use that
+    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
+    if (params.type === 'PATCH' && window.ActiveXObject &&
+          !(window.external && window.external.msActiveXFilteringEnabled)) {
+      params.xhr = function() {
+        return new ActiveXObject("Microsoft.XMLHTTP");
+      };
+    }
+
+    // Make the request, allowing the user to override any Ajax options.
+    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
+    model.trigger('request', model, xhr, options);
+    return xhr;
+  };
+
+  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+  var methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'patch':  'PATCH',
+    'delete': 'DELETE',
+    'read':   'GET'
+  };
+
+  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
+  // Override this if you'd like to use a different library.
+  Backbone.ajax = function() {
+    return Backbone.$.ajax.apply(Backbone.$, arguments);
+  };
+
+  // Backbone.Router
+  // ---------------
+
+  // 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.
+  var Router = Backbone.Router = function(options) {
+    options || (options = {});
+    if (options.routes) this.routes = options.routes;
+    this._bindRoutes();
+    this.initialize.apply(this, arguments);
+  };
+
+  // Cached regular expressions for matching named param parts and splatted
+  // parts of route strings.
+  var optionalParam = /\((.*?)\)/g;
+  var namedParam    = /(\(\?)?:\w+/g;
+  var splatParam    = /\*\w+/g;
+  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+
+  // Set up all inheritable **Backbone.Router** properties and methods.
+  _.extend(Router.prototype, Events, {
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Manually bind a single named route to a callback. For example:
+    //
+    //     this.route('search/:query/p:num', 'search', function(query, num) {
+    //       ...
+    //     });
+    //
+    route: function(route, name, callback) {
+      if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+      if (_.isFunction(name)) {
+        callback = name;
+        name = '';
+      }
+      if (!callback) callback = this[name];
+      var router = this;
+      Backbone.history.route(route, function(fragment) {
+        var args = router._extractParameters(route, fragment);
+        callback && callback.apply(router, args);
+        router.trigger.apply(router, ['route:' + name].concat(args));
+        router.trigger('route', name, args);
+        Backbone.history.trigger('route', router, name, args);
+      });
+      return this;
+    },
+
+    // Simple proxy to `Backbone.history` to save a fragment into the history.
+    navigate: function(fragment, options) {
+      Backbone.history.navigate(fragment, options);
+      return this;
+    },
+
+    // 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() {
+      if (!this.routes) return;
+      this.routes = _.result(this, 'routes');
+      var route, routes = _.keys(this.routes);
+      while ((route = routes.pop()) != null) {
+        this.route(route, this.routes[route]);
+      }
+    },
+
+    // Convert a route string into a regular expression, suitable for matching
+    // against the current location hash.
+    _routeToRegExp: function(route) {
+      route = route.replace(escapeRegExp, '\\$&')
+                   .replace(optionalParam, '(?:$1)?')
+                   .replace(namedParam, function(match, optional){
+                     return optional ? match : '([^\/]+)';
+                   })
+                   .replace(splatParam, '(.*?)');
+      return new RegExp('^' + route + '$');
+    },
+
+    // Given a route, and a URL fragment that it matches, return the array of
+    // extracted decoded parameters. Empty or unmatched parameters will be
+    // treated as `null` to normalize cross-browser behavior.
+    _extractParameters: function(route, fragment) {
+      var params = route.exec(fragment).slice(1);
+      return _.map(params, function(param) {
+        return param ? decodeURIComponent(param) : null;
+      });
+    }
+
+  });
+
+  // Backbone.History
+  // ----------------
+
+  // Handles cross-browser history management, based on either
+  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
+  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
+  // and URL fragments. If the browser supports neither (old IE, natch),
+  // falls back to polling.
+  var History = Backbone.History = function() {
+    this.handlers = [];
+    _.bindAll(this, 'checkUrl');
+
+    // Ensure that `History` can be used outside of the browser.
+    if (typeof window !== 'undefined') {
+      this.location = window.location;
+      this.history = window.history;
+    }
+  };
+
+  // Cached regex for stripping a leading hash/slash and trailing space.
+  var routeStripper = /^[#\/]|\s+$/g;
+
+  // Cached regex for stripping leading and trailing slashes.
+  var rootStripper = /^\/+|\/+$/g;
+
+  // Cached regex for detecting MSIE.
+  var isExplorer = /msie [\w.]+/;
+
+  // Cached regex for removing a trailing slash.
+  var trailingSlash = /\/$/;
+
+  // Has the history handling already been started?
+  History.started = false;
+
+  // Set up all inheritable **Backbone.History** properties and methods.
+  _.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(window) {
+      var match = (window || this).location.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) {
+      if (fragment == null) {
+        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
+          fragment = this.location.pathname;
+          var root = this.root.replace(trailingSlash, '');
+          if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
+        } else {
+          fragment = this.getHash();
+        }
+      }
+      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) {
+      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?
+      this.options          = _.extend({}, {root: '/'}, this.options, options);
+      this.root             = this.options.root;
+      this._wantsHashChange = this.options.hashChange !== false;
+      this._wantsPushState  = !!this.options.pushState;
+      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
+      var fragment          = this.getFragment();
+      var docMode           = document.documentMode;
+      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+
+      // Normalize root to always include a leading and trailing slash.
+      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
+
+      if (oldIE && this._wantsHashChange) {
+        this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+        this.navigate(fragment);
+      }
+
+      // Depending on whether we're using pushState or hashes, and whether
+      // 'onhashchange' is supported, determine how we check the URL state.
+      if (this._hasPushState) {
+        Backbone.$(window).on('popstate', this.checkUrl);
+      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
+        Backbone.$(window).on('hashchange', this.checkUrl);
+      } else if (this._wantsHashChange) {
+        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
+      }
+
+      // Determine if we need to change the base url, for a pushState link
+      // opened by a non-pushState browser.
+      this.fragment = fragment;
+      var loc = this.location;
+      var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.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) {
+        this.fragment = this.getFragment(null, true);
+        this.location.replace(this.root + this.location.search + '#' + 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 = this.getHash().replace(routeStripper, '');
+        this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
+      }
+
+      if (!this.options.silent) return this.loadUrl();
+    },
+
+    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
+    // but possibly useful for unit testing Routers.
+    stop: function() {
+      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+      clearInterval(this._checkUrlInterval);
+      History.started = false;
+    },
+
+    // Add a route to be tested when the fragment changes. Routes added later
+    // may override previous routes.
+    route: function(route, callback) {
+      this.handlers.unshift({route: route, callback: callback});
+    },
+
+    // Checks the current URL to see if it has changed, and if it has,
+    // calls `loadUrl`, normalizing across the hidden iframe.
+    checkUrl: function(e) {
+      var current = this.getFragment();
+      if (current === this.fragment && this.iframe) {
+        current = this.getFragment(this.getHash(this.iframe));
+      }
+      if (current === this.fragment) return false;
+      if (this.iframe) this.navigate(current);
+      this.loadUrl() || this.loadUrl(this.getHash());
+    },
+
+    // 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) {
+      var fragment = this.fragment = this.getFragment(fragmentOverride);
+      var matched = _.any(this.handlers, function(handler) {
+        if (handler.route.test(fragment)) {
+          handler.callback(fragment);
+          return true;
+        }
+      });
+      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 wish to modify the current URL without adding an entry to the history.
+    navigate: function(fragment, options) {
+      if (!History.started) return false;
+      if (!options || options === true) options = {trigger: options};
+      fragment = this.getFragment(fragment || '');
+      if (this.fragment === fragment) return;
+      this.fragment = fragment;
+      var url = this.root + fragment;
+
+      // If pushState is available, we use it to set the fragment as a real URL.
+      if (this._hasPushState) {
+        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
+
+      // If hash changes haven't been explicitly disabled, update the hash
+      // fragment to store history.
+      } else if (this._wantsHashChange) {
+        this._updateHash(this.location, fragment, options.replace);
+        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+          // 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, fragment, options.replace);
+        }
+
+      // If you've told us that you explicitly don't want fallback hashchange-
+      // based history, then `navigate` becomes a page refresh.
+      } else {
+        return this.location.assign(url);
+      }
+      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) {
+        var href = location.href.replace(/(javascript:|#).*$/, '');
+        location.replace(href + '#' + fragment);
+      } else {
+        // Some browsers require that `hash` contains a leading #.
+        location.hash = '#' + fragment;
+      }
+    }
+
+  });
+
+  // Create the default Backbone.history.
+  Backbone.history = new History;
+
+  // Helpers
+  // -------
+
+  // Helper function to correctly set up the prototype chain, for subclasses.
+  // Similar to `goog.inherits`, but uses a hash of prototype properties and
+  // class properties to be extended.
+  var extend = function(protoProps, staticProps) {
+    var parent = this;
+    var child;
+
+    // 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.
+    if (protoProps && _.has(protoProps, 'constructor')) {
+      child = protoProps.constructor;
+    } else {
+      child = function(){ return parent.apply(this, arguments); };
+    }
+
+    // Add static properties to the constructor function, if supplied.
+    _.extend(child, parent, staticProps);
+
+    // Set the prototype chain to inherit from `parent`, without calling
+    // `parent`'s constructor function.
+    var Surrogate = function(){ this.constructor = child; };
+    Surrogate.prototype = parent.prototype;
+    child.prototype = new Surrogate;
+
+    // Add prototype properties (instance properties) to the subclass,
+    // if supplied.
+    if (protoProps) _.extend(child.prototype, protoProps);
+
+    // Set a convenience property in case the parent's prototype is needed
+    // later.
+    child.__super__ = parent.prototype;
+
+    return child;
+  };
+
+  // Set up inheritance for the model, collection, router, view and history.
+  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
+
+  // Throw an error when a URL is needed, and none is supplied.
+  var urlError = function() {
+    throw new Error('A "url" property or function must be specified');
+  };
+
+  // Wrap an optional error callback with a fallback error event.
+  var wrapError = function (model, options) {
+    var error = options.error;
+    options.error = function(resp) {
+      if (error) error(model, resp, options);
+      model.trigger('error', model, resp, options);
+    };
+  };
+
+}).call(this);
diff --git a/public/javascripts/underscore.js b/public/javascripts/underscore.js
index 5a0cb3b..70fae3f 100644
--- a/public/javascripts/underscore.js
+++ b/public/javascripts/underscore.js
@@ -1,32 +1,1257 @@
-// Underscore.js 1.3.3
-// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
-// Underscore is freely distributable under the MIT license.
-// Portions of Underscore are inspired or borrowed from Prototype,
-// Oliver Steele's Functional, and John Resig's Micro-Templating.
-// For all details and documentation:
-// http://documentcloud.github.com/underscore
-(function(){function r(a,c,d){if(a===c)return 0!==a||1/a==1/c;if(null==a||null==c)return a===c;a._chain&&(a=a._wrapped);c._chain&&(c=c._wrapped);if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return!1;switch(e){case "[object String]":return a==""+c;case "[object Number]":return a!=+a?c!=+c:0==a?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source==
-c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if("object"!=typeof a||"object"!=typeof c)return!1;for(var f=d.length;f--;)if(d[f]==a)return!0;d.push(a);var f=0,g=!0;if("[object Array]"==e){if(f=a.length,g=f==c.length)for(;f--&&(g=f in a==f in c&&r(a[f],c[f],d)););}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return!1;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&r(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c,h)&&!f--)break;
-g=!f}}d.pop();return g}var s=this,I=s._,o={},k=Array.prototype,p=Object.prototype,i=k.slice,J=k.unshift,l=p.toString,K=p.hasOwnProperty,y=k.forEach,z=k.map,A=k.reduce,B=k.reduceRight,C=k.filter,D=k.every,E=k.some,q=k.indexOf,F=k.lastIndexOf,p=Array.isArray,L=Object.keys,t=Function.prototype.bind,b=function(a){return new m(a)};"undefined"!==typeof exports?("undefined"!==typeof module&&module.exports&&(exports=module.exports=b),exports._=b):s._=b;b.VERSION="1.3.3";var j=b.each=b.forEach=function(a,
-c,d){if(a!=null)if(y&&a.forEach===y)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e<f;e++){if(e in a&&c.call(d,a[e],e,a)===o)break}else for(e in a)if(b.has(a,e)&&c.call(d,a[e],e,a)===o)break};b.map=b.collect=function(a,c,b){var e=[];if(a==null)return e;if(z&&a.map===z)return a.map(c,b);j(a,function(a,g,h){e[e.length]=c.call(b,a,g,h)});if(a.length===+a.length)e.length=a.length;return e};b.reduce=b.foldl=b.inject=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(A&&
-a.reduce===A){e&&(c=b.bind(c,e));return f?a.reduce(c,d):a.reduce(c)}j(a,function(a,b,i){if(f)d=c.call(e,d,a,b,i);else{d=a;f=true}});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(B&&a.reduceRight===B){e&&(c=b.bind(c,e));return f?a.reduceRight(c,d):a.reduceRight(c)}var g=b.toArray(a).reverse();e&&!f&&(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect=function(a,
-c,b){var e;G(a,function(a,g,h){if(c.call(b,a,g,h)){e=a;return true}});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(C&&a.filter===C)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;if(D&&a.every===D)return a.every(c,b);j(a,function(a,g,h){if(!(e=e&&c.call(b,
-a,g,h)))return o});return!!e};var G=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(E&&a.some===E)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return o});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;if(q&&a.indexOf===q)return a.indexOf(c)!=-1;return b=G(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck=
-function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a)&&a[0]===+a[0])return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a)&&a[0]===+a[0])return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b<e.computed&&
-(e={value:a,computed:b})});return e.value};b.shuffle=function(a){var b=[],d;j(a,function(a,f){d=Math.floor(Math.random()*(f+1));b[f]=b[d];b[d]=a});return b};b.sortBy=function(a,c,d){var e=b.isFunction(c)?c:function(a){return a[c]};return b.pluck(b.map(a,function(a,b,c){return{value:a,criteria:e.call(d,a,b,c)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;return c===void 0?1:d===void 0?-1:c<d?-1:c>d?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};
-j(a,function(a,b){var c=e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a,c,d){d||(d=b.identity);for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?e=g+1:f=g}return e};b.toArray=function(a){return!a?[]:b.isArray(a)||b.isArguments(a)?i.call(a):a.toArray&&b.isFunction(a.toArray)?a.toArray():b.values(a)};b.size=function(a){return b.isArray(a)?a.length:b.keys(a).length};b.first=b.head=b.take=function(a,b,d){return b!=null&&!d?i.call(a,0,b):a[0]};b.initial=function(a,b,d){return i.call(a,
-0,a.length-(b==null||d?1:b))};b.last=function(a,b,d){return b!=null&&!d?i.call(a,Math.max(a.length-b,0)):a[a.length-1]};b.rest=b.tail=function(a,b,d){return i.call(a,b==null||d?1:b)};b.compact=function(a){return b.filter(a,function(a){return!!a})};b.flatten=function(a,c){return b.reduce(a,function(a,e){if(b.isArray(e))return a.concat(c?e:b.flatten(e));a[a.length]=e;return a},[])};b.without=function(a){return b.difference(a,i.call(arguments,1))};b.uniq=b.unique=function(a,c,d){var d=d?b.map(a,d):a,
-e=[];a.length<3&&(c=true);b.reduce(d,function(d,g,h){if(c?b.last(d)!==g||!d.length:!b.include(d,g)){d.push(g);e.push(a[h])}return d},[]);return e};b.union=function(){return b.uniq(b.flatten(arguments,true))};b.intersection=b.intersect=function(a){var c=i.call(arguments,1);return b.filter(b.uniq(a),function(a){return b.every(c,function(c){return b.indexOf(c,a)>=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1),true);return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=
-i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=0;e<c;e++)d[e]=b.pluck(a,""+e);return d};b.indexOf=function(a,c,d){if(a==null)return-1;var e;if(d){d=b.sortedIndex(a,c);return a[d]===c?d:-1}if(q&&a.indexOf===q)return a.indexOf(c);d=0;for(e=a.length;d<e;d++)if(d in a&&a[d]===c)return d;return-1};b.lastIndexOf=function(a,b){if(a==null)return-1;if(F&&a.lastIndexOf===F)return a.lastIndexOf(b);for(var d=a.length;d--;)if(d in a&&a[d]===b)return d;return-1};b.range=function(a,b,d){if(arguments.length<=
-1){b=a||0;a=0}for(var d=arguments[2]||1,e=Math.max(Math.ceil((b-a)/d),0),f=0,g=Array(e);f<e;){g[f++]=a;a=a+d}return g};var H=function(){};b.bind=function(a,c){var d,e;if(a.bind===t&&t)return t.apply(a,i.call(arguments,1));if(!b.isFunction(a))throw new TypeError;e=i.call(arguments,2);return d=function(){if(!(this instanceof d))return a.apply(c,e.concat(i.call(arguments)));H.prototype=a.prototype;var b=new H,g=a.apply(b,e.concat(i.call(arguments)));return Object(g)===g?g:b}};b.bindAll=function(a){var c=
-i.call(arguments,1);c.length==0&&(c=b.functions(a));j(c,function(c){a[c]=b.bind(a[c],a)});return a};b.memoize=function(a,c){var d={};c||(c=b.identity);return function(){var e=c.apply(this,arguments);return b.has(d,e)?d[e]:d[e]=a.apply(this,arguments)}};b.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(null,d)},b)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(i.call(arguments,1)))};b.throttle=function(a,c){var d,e,f,g,h,i,j=b.debounce(function(){h=
-g=false},c);return function(){d=this;e=arguments;f||(f=setTimeout(function(){f=null;h&&a.apply(d,e);j()},c));g?h=true:i=a.apply(d,e);j();g=true;return i}};b.debounce=function(a,b,d){var e;return function(){var f=this,g=arguments;d&&!e&&a.apply(f,g);clearTimeout(e);e=setTimeout(function(){e=null;d||a.apply(f,g)},b)}};b.once=function(a){var b=false,d;return function(){if(b)return d;b=true;return d=a.apply(this,arguments)}};b.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments,0));
-return b.apply(this,d)}};b.compose=function(){var a=arguments;return function(){for(var b=arguments,d=a.length-1;d>=0;d--)b=[a[d].apply(this,b)];return b[0]}};b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=L||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var c=[],d;for(d in a)b.has(a,d)&&(c[c.length]=d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&
-c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};b.pick=function(a){var c={};j(b.flatten(i.call(arguments,1)),function(b){b in a&&(c[b]=a[b])});return c};b.defaults=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return r(a,b,[])};b.isEmpty=
-function(a){if(a==null)return true;if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(b.has(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=p||function(a){return l.call(a)=="[object Array]"};b.isObject=function(a){return a===Object(a)};b.isArguments=function(a){return l.call(a)=="[object Arguments]"};b.isArguments(arguments)||(b.isArguments=function(a){return!(!a||!b.has(a,"callee"))});b.isFunction=function(a){return l.call(a)=="[object Function]"};
-b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isFinite=function(a){return b.isNumber(a)&&isFinite(a)};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};b.isDate=function(a){return l.call(a)=="[object Date]"};b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.has=function(a,
-b){return K.call(a,b)};b.noConflict=function(){s._=I;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};b.escape=function(a){return(""+a).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")};b.result=function(a,c){if(a==null)return null;var d=a[c];return b.isFunction(d)?d.call(a):d};b.mixin=function(a){j(b.functions(a),function(c){M(c,b[c]=a[c])})};var N=0;b.uniqueId=
-function(a){var b=N++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var u=/.^/,n={"\\":"\\","'":"'",r:"\r",n:"\n",t:"\t",u2028:"\u2028",u2029:"\u2029"},v;for(v in n)n[n[v]]=v;var O=/\\|'|\r|\n|\t|\u2028|\u2029/g,P=/\\(\\|'|r|n|t|u2028|u2029)/g,w=function(a){return a.replace(P,function(a,b){return n[b]})};b.template=function(a,c,d){d=b.defaults(d||{},b.templateSettings);a="__p+='"+a.replace(O,function(a){return"\\"+n[a]}).replace(d.escape||
-u,function(a,b){return"'+\n_.escape("+w(b)+")+\n'"}).replace(d.interpolate||u,function(a,b){return"'+\n("+w(b)+")+\n'"}).replace(d.evaluate||u,function(a,b){return"';\n"+w(b)+"\n;__p+='"})+"';\n";d.variable||(a="with(obj||{}){\n"+a+"}\n");var a="var __p='';var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n"+a+"return __p;\n",e=new Function(d.variable||"obj","_",a);if(c)return e(c,b);c=function(a){return e.call(this,a,b)};c.source="function("+(d.variable||"obj")+"){\n"+a+"}";return c};
-b.chain=function(a){return b(a).chain()};var m=function(a){this._wrapped=a};b.prototype=m.prototype;var x=function(a,c){return c?b(a).chain():a},M=function(a,c){m.prototype[a]=function(){var a=i.call(arguments);J.call(a,this._wrapped);return x(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];m.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return x(d,
-this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];m.prototype[a]=function(){return x(b.apply(this._wrapped,arguments),this._chain)}});m.prototype.chain=function(){this._chain=true;return this};m.prototype.value=function(){return this._wrapped}}).call(this);
+//     Underscore.js 1.5.0
+//     http://underscorejs.org
+//     (c) 2009-2011 Jeremy Ashkenas, DocumentCloud Inc.
+//     (c) 2011-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+//     Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+  // Baseline setup
+  // --------------
+
+  // Establish the root object, `window` in the browser, or `global` on the server.
+  var root = this;
+
+  // Save the previous value of the `_` variable.
+  var previousUnderscore = root._;
+
+  // Establish the object that gets returned to break out of a loop iteration.
+  var breaker = {};
+
+  // Save bytes in the minified (but not gzipped) version:
+  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+  // Create quick reference variables for speed access to core prototypes.
+  var
+    push             = ArrayProto.push,
+    slice            = ArrayProto.slice,
+    concat           = ArrayProto.concat,
+    toString         = ObjProto.toString,
+    hasOwnProperty   = ObjProto.hasOwnProperty;
+
+  // All **ECMAScript 5** native function implementations that we hope to use
+  // are declared here.
+  var
+    nativeForEach      = ArrayProto.forEach,
+    nativeMap          = ArrayProto.map,
+    nativeReduce       = ArrayProto.reduce,
+    nativeReduceRight  = ArrayProto.reduceRight,
+    nativeFilter       = ArrayProto.filter,
+    nativeEvery        = ArrayProto.every,
+    nativeSome         = ArrayProto.some,
+    nativeIndexOf      = ArrayProto.indexOf,
+    nativeLastIndexOf  = ArrayProto.lastIndexOf,
+    nativeIsArray      = Array.isArray,
+    nativeKeys         = Object.keys,
+    nativeBind         = FuncProto.bind;
+
+  // Create a safe reference to the Underscore object for use below.
+  var _ = function(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  };
+
+  // Export the Underscore object for **Node.js**, with
+  // backwards-compatibility for the old `require()` API. If we're in
+  // the browser, add `_` as a global object via a string identifier,
+  // for Closure Compiler "advanced" mode.
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = _;
+    }
+    exports._ = _;
+  } else {
+    root._ = _;
+  }
+
+  // Current version.
+  _.VERSION = '1.5.0';
+
+  // Collection Functions
+  // --------------------
+
+  // The cornerstone, an `each` implementation, aka `forEach`.
+  // Handles objects with the built-in `forEach`, arrays, and raw objects.
+  // Delegates to **ECMAScript 5**'s native `forEach` if available.
+  var each = _.each = _.forEach = function(obj, iterator, context) {
+    if (obj == null) return;
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+      for (var i = 0, l = obj.length; i < l; i++) {
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
+      }
+    } else {
+      for (var key in obj) {
+        if (_.has(obj, key)) {
+          if (iterator.call(context, obj[key], key, obj) === breaker) return;
+        }
+      }
+    }
+  };
+
+  // Return the results of applying the iterator to each element.
+  // Delegates to **ECMAScript 5**'s native `map` if available.
+  _.map = _.collect = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+    each(obj, function(value, index, list) {
+      results.push(iterator.call(context, value, index, list));
+    });
+    return results;
+  };
+
+  var reduceError = 'Reduce of empty array with no initial value';
+
+  // **Reduce** builds up a single result from a list of values, aka `inject`,
+  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduce && obj.reduce === nativeReduce) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+    }
+    each(obj, function(value, index, list) {
+      if (!initial) {
+        memo = value;
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, value, index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // The right-associative version of reduce, also known as `foldr`.
+  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+    }
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // Return the first value which passes a truth test. Aliased as `detect`.
+  _.find = _.detect = function(obj, iterator, context) {
+    var result;
+    any(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) {
+        result = value;
+        return true;
+      }
+    });
+    return result;
+  };
+
+  // Return all the elements that pass a truth test.
+  // Delegates to **ECMAScript 5**'s native `filter` if available.
+  // Aliased as `select`.
+  _.filter = _.select = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+    each(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) results.push(value);
+    });
+    return results;
+  };
+
+  // Return all the elements for which a truth test fails.
+  _.reject = function(obj, iterator, context) {
+    return _.filter(obj, function(value, index, list) {
+      return !iterator.call(context, value, index, list);
+    }, context);
+  };
+
+  // Determine whether all of the elements match a truth test.
+  // Delegates to **ECMAScript 5**'s native `every` if available.
+  // Aliased as `all`.
+  _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = true;
+    if (obj == null) return result;
+    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+    each(obj, function(value, index, list) {
+      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if at least one element in the object matches a truth test.
+  // Delegates to **ECMAScript 5**'s native `some` if available.
+  // Aliased as `any`.
+  var any = _.some = _.any = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = false;
+    if (obj == null) return result;
+    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+    each(obj, function(value, index, list) {
+      if (result || (result = iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if the array or object contains a given value (using `===`).
+  // Aliased as `include`.
+  _.contains = _.include = function(obj, target) {
+    if (obj == null) return false;
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+    return any(obj, function(value) {
+      return value === target;
+    });
+  };
+
+  // Invoke a method (with arguments) on every item in a collection.
+  _.invoke = function(obj, method) {
+    var args = slice.call(arguments, 2);
+    var isFunc = _.isFunction(method);
+    return _.map(obj, function(value) {
+      return (isFunc ? method : value[method]).apply(value, args);
+    });
+  };
+
+  // Convenience version of a common use case of `map`: fetching a property.
+  _.pluck = function(obj, key) {
+    return _.map(obj, function(value){ return value[key]; });
+  };
+
+  // Convenience version of a common use case of `filter`: selecting only objects
+  // containing specific `key:value` pairs.
+  _.where = function(obj, attrs, first) {
+    if (_.isEmpty(attrs)) return first ? void 0 : [];
+    return _[first ? 'find' : 'filter'](obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
+
+  // Convenience version of a common use case of `find`: getting the first object
+  // containing specific `key:value` pairs.
+  _.findWhere = function(obj, attrs) {
+    return _.where(obj, attrs, true);
+  };
+
+  // Return the maximum element or (element-based computation).
+  // Can't optimize arrays of integers longer than 65,535 elements.
+  // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
+  _.max = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return -Infinity;
+    var result = {computed : -Infinity, value: -Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed > result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Return the minimum element (or element-based computation).
+  _.min = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return Infinity;
+    var result = {computed : Infinity, value: Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed < result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Shuffle an array.
+  _.shuffle = function(obj) {
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
+      shuffled[rand] = value;
+    });
+    return shuffled;
+  };
+
+  // An internal function to generate lookup iterators.
+  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
+
+  // Sort the object's values by a criterion produced by an iterator.
+  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
+    return _.pluck(_.map(obj, function(value, index, list) {
+      return {
+        value : value,
+        index : index,
+        criteria : iterator.call(context, value, index, list)
+      };
+    }).sort(function(left, right) {
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index < right.index ? -1 : 1;
+    }), 'value');
+  };
+
+  // An internal function used for aggregate "group by" operations.
+  var group = function(obj, value, context, behavior) {
+    var result = {};
+    var iterator = lookupIterator(value == null ? _.identity : value);
+    each(obj, function(value, index) {
+      var key = iterator.call(context, value, index, obj);
+      behavior(result, key, value);
+    });
+    return result;
+  };
+
+  // Groups the object's values by a criterion. Pass either a string attribute
+  // to group by, or a function that returns the criterion.
+  _.groupBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+    });
+  };
+
+  // Counts instances of an object that group by a certain criterion. Pass
+  // either a string attribute to count by, or a function that returns the
+  // criterion.
+  _.countBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key) {
+      if (!_.has(result, key)) result[key] = 0;
+      result[key]++;
+    });
+  };
+
+  // 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 == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
+    var low = 0, high = array.length;
+    while (low < high) {
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+    }
+    return low;
+  };
+
+  // Safely create a real, live array from anything iterable.
+  _.toArray = function(obj) {
+    if (!obj) return [];
+    if (_.isArray(obj)) return slice.call(obj);
+    if (obj.length === +obj.length) return _.map(obj, _.identity);
+    return _.values(obj);
+  };
+
+  // Return the number of elements in an object.
+  _.size = function(obj) {
+    if (obj == null) return 0;
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+  };
+
+  // Array Functions
+  // ---------------
+
+  // Get the first element of an array. Passing **n** will return the first N
+  // values in the array. Aliased as `head` and `take`. The **guard** check
+  // allows it to work with `_.map`.
+  _.first = _.head = _.take = function(array, n, guard) {
+    if (array == null) return void 0;
+    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+  };
+
+  // Returns everything but the last entry of the array. Especially useful on
+  // the arguments object. Passing **n** will return all the values in
+  // the array, excluding the last N. The **guard** check allows it to work with
+  // `_.map`.
+  _.initial = function(array, n, guard) {
+    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+  };
+
+  // Get the last element of an array. Passing **n** will return the last N
+  // values in the array. The **guard** check allows it to work with `_.map`.
+  _.last = function(array, n, guard) {
+    if (array == null) return void 0;
+    if ((n != null) && !guard) {
+      return slice.call(array, Math.max(array.length - n, 0));
+    } else {
+      return array[array.length - 1];
+    }
+  };
+
+  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+  // Especially useful on the arguments object. Passing an **n** will return
+  // the rest N values in the array. The **guard**
+  // check allows it to work with `_.map`.
+  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
+  };
+
+  // Trim out all falsy values from an array.
+  _.compact = function(array) {
+    return _.filter(array, _.identity);
+  };
+
+  // Internal implementation of a recursive `flatten` function.
+  var flatten = function(input, shallow, output) {
+    if (shallow && _.every(input, _.isArray)) {
+      return concat.apply(output, input);
+    }
+    each(input, function(value) {
+      if (_.isArray(value) || _.isArguments(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
+  };
+
+  // Return a completely flattened version of an array.
+  _.flatten = function(array, shallow) {
+    return flatten(array, shallow, []);
+  };
+
+  // Return a version of the array that does not contain the specified value(s).
+  _.without = function(array) {
+    return _.difference(array, slice.call(arguments, 1));
+  };
+
+  // Produce a duplicate-free version of the array. If the array has already
+  // been sorted, you have the option of using a faster algorithm.
+  // Aliased as `unique`.
+  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    if (_.isFunction(isSorted)) {
+      context = iterator;
+      iterator = isSorted;
+      isSorted = false;
+    }
+    var initial = iterator ? _.map(array, iterator, context) : array;
+    var results = [];
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
+        results.push(array[index]);
+      }
+    });
+    return results;
+  };
+
+  // Produce an array that contains the union: each distinct element from all of
+  // the passed-in arrays.
+  _.union = function() {
+    return _.uniq(_.flatten(arguments, true));
+  };
+
+  // Produce an array that contains every item shared between all the
+  // passed-in arrays.
+  _.intersection = function(array) {
+    var rest = slice.call(arguments, 1);
+    return _.filter(_.uniq(array), function(item) {
+      return _.every(rest, function(other) {
+        return _.indexOf(other, item) >= 0;
+      });
+    });
+  };
+
+  // Take the difference between one array and a number of other arrays.
+  // Only the elements present in just the first array will remain.
+  _.difference = function(array) {
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
+  };
+
+  // Zip together multiple lists into a single array -- elements that share
+  // an index go together.
+  _.zip = function() {
+    return _.unzip.apply(_, slice.call(arguments));
+  };
+
+  // The inverse operation to `_.zip`. If given an array of pairs it
+  // returns an array of the paired elements split into two left and
+  // right element arrays, if given an array of triples it returns a
+  // three element array and so on. For example, `_.unzip` given
+  // `[['a',1],['b',2],['c',3]]` returns the array
+  // [['a','b','c'],[1,2,3]].
+  _.unzip = function() {
+    var length = _.max(_.pluck(arguments, "length").concat(0));
+    var results = new Array(length);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(arguments, '' + i);
+    }
+    return results;
+  };
+
+  // Converts lists into objects. Pass either a single array of `[key, value]`
+  // pairs, or two parallel arrays of the same length -- one of keys, and one of
+  // the corresponding values.
+  _.object = function(list, values) {
+    if (list == null) return {};
+    var result = {};
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
+
+  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+  // we need this function. Return the position of the first occurrence of an
+  // item in an array, or -1 if the item is not included in the array.
+  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+  // If the array is large and already in sort order, pass `true`
+  // for **isSorted** to use binary search.
+  _.indexOf = function(array, item, isSorted) {
+    if (array == null) return -1;
+    var i = 0, l = array.length;
+    if (isSorted) {
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
+    }
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < l; i++) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+  _.lastIndexOf = function(array, item, from) {
+    if (array == null) return -1;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Generate an integer Array containing an arithmetic progression. A port of
+  // the native Python `range()` function. See
+  // [the Python documentation](http://docs.python.org/library/functions.html#range).
+  _.range = function(start, stop, step) {
+    if (arguments.length <= 1) {
+      stop = start || 0;
+      start = 0;
+    }
+    step = arguments[2] || 1;
+
+    var len = Math.max(Math.ceil((stop - start) / step), 0);
+    var idx = 0;
+    var range = new Array(len);
+
+    while(idx < len) {
+      range[idx++] = start;
+      start += step;
+    }
+
+    return range;
+  };
+
+  // Function (ahem) Functions
+  // ------------------
+
+  // Reusable constructor function for prototype setting.
+  var ctor = function(){};
+
+  // Create a function bound to a given object (assigning `this`, and arguments,
+  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+  // available.
+  _.bind = function(func, context) {
+    var args, bound;
+    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+    if (!_.isFunction(func)) throw new TypeError;
+    args = slice.call(arguments, 2);
+    return bound = function() {
+      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+      ctor.prototype = func.prototype;
+      var self = new ctor;
+      ctor.prototype = null;
+      var result = func.apply(self, args.concat(slice.call(arguments)));
+      if (Object(result) === result) return result;
+      return self;
+    };
+  };
+
+  // Partially apply a function by creating a version that has had some of its
+  // arguments pre-filled, without changing its dynamic `this` context.
+  _.partial = function(func) {
+    var args = slice.call(arguments, 1);
+    return function() {
+      return func.apply(this, args.concat(slice.call(arguments)));
+    };
+  };
+
+  // Bind all of an object's methods to that object. Useful for ensuring that
+  // all callbacks defined on an object belong to it.
+  _.bindAll = function(obj) {
+    var funcs = slice.call(arguments, 1);
+    if (funcs.length === 0) throw new Error("bindAll must be passed function names");
+    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+    return obj;
+  };
+
+  // Memoize an expensive function by storing its results.
+  _.memoize = function(func, hasher) {
+    var memo = {};
+    hasher || (hasher = _.identity);
+    return function() {
+      var key = hasher.apply(this, arguments);
+      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+    };
+  };
+
+  // Delays a function for the given number of milliseconds, and then calls
+  // it with the arguments supplied.
+  _.delay = function(func, wait) {
+    var args = slice.call(arguments, 2);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
+  };
+
+  // Defers a function, scheduling it to run after the current call stack has
+  // cleared.
+  _.defer = function(func) {
+    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+  };
+
+  // Returns a function, that, when invoked, will only be triggered at most once
+  // during a given window of time. Normally, the throttled function will run
+  // as much as it can, without ever going more than once per `wait` duration;
+  // but if you'd like to disable the execution on the leading edge, pass
+  // `{leading: false}`. To disable execution on the trailing edge, ditto.
+  _.throttle = function(func, wait, options) {
+    var context, args, result;
+    var timeout = null;
+    var previous = 0;
+    options || (options = {});
+    var later = function() {
+      previous = new Date;
+      timeout = null;
+      result = func.apply(context, args);
+    };
+    return function() {
+      var now = new Date;
+      if (!previous && options.leading === false) previous = now;
+      var remaining = wait - (now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0) {
+        clearTimeout(timeout);
+        timeout = null;
+        previous = now;
+        result = func.apply(context, args);
+      } else if (!timeout && options.trailing !== false) {
+        timeout = setTimeout(later, remaining);
+      }
+      return result;
+    };
+  };
+
+  // Returns a function, that, as long as it continues to be invoked, will not
+  // be triggered. The function will be called after it stops being called for
+  // N milliseconds. If `immediate` is passed, trigger the function on the
+  // leading edge, instead of the trailing.
+  _.debounce = function(func, wait, immediate) {
+    var result;
+    var timeout = null;
+    return function() {
+      var context = this, args = arguments;
+      var later = function() {
+        timeout = null;
+        if (!immediate) result = func.apply(context, args);
+      };
+      var callNow = immediate && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+      if (callNow) result = func.apply(context, args);
+      return result;
+    };
+  };
+
+  // Returns a function that will be executed at most one time, no matter how
+  // often you call it. Useful for lazy initialization.
+  _.once = function(func) {
+    var ran = false, memo;
+    return function() {
+      if (ran) return memo;
+      ran = true;
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
+    };
+  };
+
+  // Returns the first function passed as an argument to the second,
+  // allowing you to adjust arguments, run code before and after, and
+  // conditionally execute the original function.
+  _.wrap = function(func, wrapper) {
+    return function() {
+      var args = [func];
+      push.apply(args, arguments);
+      return wrapper.apply(this, args);
+    };
+  };
+
+  // Returns a function that is the composition of a list of functions, each
+  // consuming the return value of the function that follows.
+  _.compose = function() {
+    var funcs = arguments;
+    return function() {
+      var args = arguments;
+      for (var i = funcs.length - 1; i >= 0; i--) {
+        args = [funcs[i].apply(this, args)];
+      }
+      return args[0];
+    };
+  };
+
+  // Returns a function that will only be executed after being called N times.
+  _.after = function(times, func) {
+    return function() {
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
+    };
+  };
+
+  // Object Functions
+  // ----------------
+
+  // Retrieve the names of an object's properties.
+  // Delegates to **ECMAScript 5**'s native `Object.keys`
+  _.keys = nativeKeys || function(obj) {
+    if (obj !== Object(obj)) throw new TypeError('Invalid object');
+    var keys = [];
+    for (var key in obj) if (_.has(obj, key)) keys.push(key);
+    return keys;
+  };
+
+  // Retrieve the values of an object's properties.
+  _.values = function(obj) {
+    var values = [];
+    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+    return values;
+  };
+
+  // Convert an object into a list of `[key, value]` pairs.
+  _.pairs = function(obj) {
+    var pairs = [];
+    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+    return pairs;
+  };
+
+  // Invert the keys and values of an object. The values must be serializable.
+  _.invert = function(obj) {
+    var result = {};
+    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+    return result;
+  };
+
+  // Return a sorted list of the function names available on the object.
+  // Aliased as `methods`
+  _.functions = _.methods = function(obj) {
+    var names = [];
+    for (var key in obj) {
+      if (_.isFunction(obj[key])) names.push(key);
+    }
+    return names.sort();
+  };
+
+  // Extend a given object with all the properties in passed-in object(s).
+  _.extend = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Return a copy of the object only containing the whitelisted properties.
+  _.pick = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
+    });
+    return copy;
+  };
+
+   // Return a copy of the object without the blacklisted properties.
+  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
+  };
+
+  // Fill in a given object with default properties.
+  _.defaults = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          if (obj[prop] === void 0) obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Create a (shallow-cloned) duplicate of an object.
+  _.clone = function(obj) {
+    if (!_.isObject(obj)) return obj;
+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+  };
+
+  // Invokes interceptor with the obj, and then returns obj.
+  // The primary purpose of this method is to "tap into" a method chain, in
+  // order to perform operations on intermediate results within the chain.
+  _.tap = function(obj, interceptor) {
+    interceptor(obj);
+    return obj;
+  };
+
+  // Internal recursive comparison function for `isEqual`.
+  var eq = function(a, b, aStack, bStack) {
+    // Identical objects are equal. `0 === -0`, but they aren't identical.
+    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+    if (a === b) return a !== 0 || 1 / a == 1 / b;
+    // A strict comparison is necessary because `null == undefined`.
+    if (a == null || b == null) return a === b;
+    // Unwrap any wrapped objects.
+    if (a instanceof _) a = a._wrapped;
+    if (b instanceof _) b = b._wrapped;
+    // Compare `[[Class]]` names.
+    var className = toString.call(a);
+    if (className != toString.call(b)) return false;
+    switch (className) {
+      // Strings, numbers, dates, and booleans are compared by value.
+      case '[object String]':
+        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+        // equivalent to `new String("5")`.
+        return a == String(b);
+      case '[object Number]':
+        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+        // other numeric values.
+        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+      case '[object Date]':
+      case '[object Boolean]':
+        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+        // millisecond representations. Note that invalid dates with millisecond representations
+        // of `NaN` are not equivalent.
+        return +a == +b;
+      // RegExps are compared by their source patterns and flags.
+      case '[object RegExp]':
+        return a.source == b.source &&
+               a.global == b.global &&
+               a.multiline == b.multiline &&
+               a.ignoreCase == b.ignoreCase;
+    }
+    if (typeof a != 'object' || typeof b != 'object') return false;
+    // Assume equality for cyclic structures. The algorithm for detecting cyclic
+    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+    var length = aStack.length;
+    while (length--) {
+      // Linear search. Performance is inversely proportional to the number of
+      // unique nested structures.
+      if (aStack[length] == a) return bStack[length] == b;
+    }
+    // Objects with different constructors are not equivalent, but `Object`s
+    // from different frames are.
+    var aCtor = a.constructor, bCtor = b.constructor;
+    if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+                             _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+      return false;
+    }
+    // Add the first object to the stack of traversed objects.
+    aStack.push(a);
+    bStack.push(b);
+    var size = 0, result = true;
+    // Recursively compare objects and arrays.
+    if (className == '[object Array]') {
+      // Compare array lengths to determine if a deep comparison is necessary.
+      size = a.length;
+      result = size == b.length;
+      if (result) {
+        // Deep compare the contents, ignoring non-numeric properties.
+        while (size--) {
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+        }
+      }
+    } else {
+      // Deep compare objects.
+      for (var key in a) {
+        if (_.has(a, key)) {
+          // Count the expected number of properties.
+          size++;
+          // Deep compare each member.
+          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+        }
+      }
+      // Ensure that both objects contain the same number of properties.
+      if (result) {
+        for (key in b) {
+          if (_.has(b, key) && !(size--)) break;
+        }
+        result = !size;
+      }
+    }
+    // Remove the first object from the stack of traversed objects.
+    aStack.pop();
+    bStack.pop();
+    return result;
+  };
+
+  // Perform a deep comparison to check if two objects are equal.
+  _.isEqual = function(a, b) {
+    return eq(a, b, [], []);
+  };
+
+  // Is a given array, string, or object empty?
+  // An "empty" object has no enumerable own-properties.
+  _.isEmpty = function(obj) {
+    if (obj == null) return true;
+    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+    for (var key in obj) if (_.has(obj, key)) return false;
+    return true;
+  };
+
+  // Is a given value a DOM element?
+  _.isElement = function(obj) {
+    return !!(obj && obj.nodeType === 1);
+  };
+
+  // Is a given value an array?
+  // Delegates to ECMA5's native Array.isArray
+  _.isArray = nativeIsArray || function(obj) {
+    return toString.call(obj) == '[object Array]';
+  };
+
+  // Is a given variable an object?
+  _.isObject = function(obj) {
+    return obj === Object(obj);
+  };
+
+  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
+
+  // Define a fallback version of the method in browsers (ahem, IE), where
+  // there isn't any inspectable "Arguments" type.
+  if (!_.isArguments(arguments)) {
+    _.isArguments = function(obj) {
+      return !!(obj && _.has(obj, 'callee'));
+    };
+  }
+
+  // Optimize `isFunction` if appropriate.
+  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
+
+  // Is a given object a finite number?
+  _.isFinite = function(obj) {
+    return isFinite(obj) && !isNaN(parseFloat(obj));
+  };
+
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+  _.isNaN = function(obj) {
+    return _.isNumber(obj) && obj != +obj;
+  };
+
+  // Is a given value a boolean?
+  _.isBoolean = function(obj) {
+    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+  };
+
+  // Is a given value equal to null?
+  _.isNull = function(obj) {
+    return obj === null;
+  };
+
+  // Is a given variable undefined?
+  _.isUndefined = function(obj) {
+    return obj === void 0;
+  };
+
+  // Shortcut function for checking if an object has a given property directly
+  // on itself (in other words, not on a prototype).
+  _.has = function(obj, key) {
+    return hasOwnProperty.call(obj, key);
+  };
+
+  // Utility Functions
+  // -----------------
+
+  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+  // previous owner. Returns a reference to the Underscore object.
+  _.noConflict = function() {
+    root._ = previousUnderscore;
+    return this;
+  };
+
+  // Keep the identity function around for default iterators.
+  _.identity = function(value) {
+    return value;
+  };
+
+  // Run a function **n** times.
+  _.times = function(n, iterator, context) {
+    var accum = Array(Math.max(0, n));
+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+    return accum;
+  };
+
+  // Return a random integer between min and max (inclusive).
+  _.random = function(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + Math.floor(Math.random() * (max - min + 1));
+  };
+
+  // List of HTML entities for escaping.
+  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '/': '&#x2F;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
+
+  // Regexes containing the keys and values listed immediately above.
+  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+  };
+
+  // Functions for escaping and unescaping strings to/from HTML interpolation.
+  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
+
+  // If the value of the named `property` is a function then invoke it with the
+  // `object` as context; otherwise, return it.
+  _.result = function(object, property) {
+    if (object == null) return void 0;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
+
+  // Add your own custom functions to the Underscore object.
+  _.mixin = function(obj) {
+    each(_.functions(obj), function(name){
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
+    });
+  };
+
+  // Generate a unique integer id (unique within the entire client session).
+  // Useful for temporary DOM ids.
+  var idCounter = 0;
+  _.uniqueId = function(prefix) {
+    var id = ++idCounter + '';
+    return prefix ? prefix + id : id;
+  };
+
+  // By default, Underscore uses ERB-style template delimiters, change the
+  // following template settings to use alternative delimiters.
+  _.templateSettings = {
+    evaluate    : /<%([\s\S]+?)%>/g,
+    interpolate : /<%=([\s\S]+?)%>/g,
+    escape      : /<%-([\s\S]+?)%>/g
+  };
+
+  // When customizing `templateSettings`, if you don't want to define an
+  // interpolation, evaluation or escaping regex, we need one that is
+  // guaranteed not to match.
+  var noMatch = /(.)^/;
+
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
+  // JavaScript micro-templating, similar to John Resig's implementation.
+  // Underscore templating handles arbitrary delimiters, preserves whitespace,
+  // and correctly escapes quotes within interpolated code.
+  _.template = function(text, data, settings) {
+    var render;
+    settings = _.defaults({}, settings, _.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      }
+      if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      }
+      if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+      index = offset + match.length;
+      return match;
+    });
+    source += "';\n";
+
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + "return __p;\n";
+
+    try {
+      render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
+    };
+
+    // Provide the compiled function source as a convenience for precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+    return template;
+  };
+
+  // Add a "chain" function, which will delegate to the wrapper.
+  _.chain = function(obj) {
+    return _(obj).chain();
+  };
+
+  // OOP
+  // ---------------
+  // If Underscore is called as a function, it returns a wrapped object that
+  // can be used OO-style. This wrapper holds altered versions of all the
+  // underscore functions. Wrapped objects may be chained.
+
+  // Helper function to continue chaining intermediate results.
+  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
+  };
+
+  // Add all of the Underscore functions to the wrapper object.
+  _.mixin(_);
+
+  // Add all mutator Array functions to the wrapper.
+  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
+    };
+  });
+
+  // Add all accessor Array functions to the wrapper.
+  each(['concat', 'join', 'slice'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
+    };
+  });
+
+  _.extend(_.prototype, {
+
+    // Start chaining a wrapped Underscore object.
+    chain: function() {
+      this._chain = true;
+      return this;
+    },
+
+    // Extracts the result from a wrapped and chained object.
+    value: function() {
+      return this._wrapped;
+    }
+
+  });
+
+}).call(this);

From d4896ff3736f83baf148057bbd323242d27c5d3e Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 30 Dec 2013 23:20:43 +0100
Subject: [PATCH 08/18] Fixed test setup

The extended model or collection is passed to the mixin as an argument now.
---
 spec/javascripts/multiSelect.deselect.spec.js               | 4 ++--
 spec/javascripts/multiSelect.select.spec.js                 | 4 ++--
 spec/javascripts/multiSelect.selectable.interaction.spec.js | 4 ++--
 spec/javascripts/multiSelect.toggle.spec.js                 | 4 ++--
 spec/javascripts/selectable.spec.js                         | 2 +-
 spec/javascripts/singleSelect.spec.js                       | 4 ++--
 6 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/spec/javascripts/multiSelect.deselect.spec.js b/spec/javascripts/multiSelect.deselect.spec.js
index 9cd35ce..efb189b 100644
--- a/spec/javascripts/multiSelect.deselect.spec.js
+++ b/spec/javascripts/multiSelect.deselect.spec.js
@@ -1,7 +1,7 @@
 describe("multi-select collection deselecting", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
-      var selectable = new Backbone.Picky.Selectable();
+      var selectable = new Backbone.Picky.Selectable(this);
       _.extend(this, selectable);
     }
   });
@@ -10,7 +10,7 @@ describe("multi-select collection deselecting", function(){
     model: Model,
 
     initialize: function(){
-      var multiSelect = new Backbone.Picky.MultiSelect();
+      var multiSelect = new Backbone.Picky.MultiSelect(this);
       _.extend(this, multiSelect);
     }
   });
diff --git a/spec/javascripts/multiSelect.select.spec.js b/spec/javascripts/multiSelect.select.spec.js
index 679cf3a..c3812cc 100644
--- a/spec/javascripts/multiSelect.select.spec.js
+++ b/spec/javascripts/multiSelect.select.spec.js
@@ -1,7 +1,7 @@
 describe("multi-select collection selecting", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
-      var selectable = new Backbone.Picky.Selectable();
+      var selectable = new Backbone.Picky.Selectable(this);
       _.extend(this, selectable);
     }
   });
@@ -10,7 +10,7 @@ describe("multi-select collection selecting", function(){
     model: Model,
 
     initialize: function(){
-      var multiSelect = new Backbone.Picky.MultiSelect();
+      var multiSelect = new Backbone.Picky.MultiSelect(this);
       _.extend(this, multiSelect);
     }
   });
diff --git a/spec/javascripts/multiSelect.selectable.interaction.spec.js b/spec/javascripts/multiSelect.selectable.interaction.spec.js
index 9bcf772..9fbc761 100644
--- a/spec/javascripts/multiSelect.selectable.interaction.spec.js
+++ b/spec/javascripts/multiSelect.selectable.interaction.spec.js
@@ -1,7 +1,7 @@
 describe("multi-select selectable interaction", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
-      var selectable = new Backbone.Picky.Selectable();
+      var selectable = new Backbone.Picky.Selectable(this);
       _.extend(this, selectable);
     }
   });
@@ -10,7 +10,7 @@ describe("multi-select selectable interaction", function(){
     model: Model,
 
       initialize: function(){
-        var multiSelect = new Backbone.Picky.MultiSelect();
+        var multiSelect = new Backbone.Picky.MultiSelect(this);
         _.extend(this, multiSelect);
       }
   });
diff --git a/spec/javascripts/multiSelect.toggle.spec.js b/spec/javascripts/multiSelect.toggle.spec.js
index d8f7d62..7e1b06e 100644
--- a/spec/javascripts/multiSelect.toggle.spec.js
+++ b/spec/javascripts/multiSelect.toggle.spec.js
@@ -1,7 +1,7 @@
 describe("multi-select collection toggle", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
-      var selectable = new Backbone.Picky.Selectable();
+      var selectable = new Backbone.Picky.Selectable(this);
       _.extend(this, selectable);
     }
   });
@@ -10,7 +10,7 @@ describe("multi-select collection toggle", function(){
     model: Model,
 
     initialize: function(){
-      var multiSelect = new Backbone.Picky.MultiSelect();
+      var multiSelect = new Backbone.Picky.MultiSelect(this);
       _.extend(this, multiSelect);
     }
   });
diff --git a/spec/javascripts/selectable.spec.js b/spec/javascripts/selectable.spec.js
index 0533e89..6b55def 100644
--- a/spec/javascripts/selectable.spec.js
+++ b/spec/javascripts/selectable.spec.js
@@ -1,7 +1,7 @@
 describe("selectable model", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
-      var selectable = new Backbone.Picky.Selectable();
+      var selectable = new Backbone.Picky.Selectable(this);
       _.extend(this, selectable);
     }
   });
diff --git a/spec/javascripts/singleSelect.spec.js b/spec/javascripts/singleSelect.spec.js
index 9288185..1a966bb 100644
--- a/spec/javascripts/singleSelect.spec.js
+++ b/spec/javascripts/singleSelect.spec.js
@@ -2,7 +2,7 @@ describe("single select collection", function(){
 
   var Model = Backbone.Model.extend({
     initialize: function(){
-      var selectable = new Backbone.Picky.Selectable();
+      var selectable = new Backbone.Picky.Selectable(this);
       _.extend(this, selectable);
     }
   });
@@ -11,7 +11,7 @@ describe("single select collection", function(){
     model: Model,
 
     initialize: function(){
-      var singleSelect = new Backbone.Picky.SingleSelect();
+      var singleSelect = new Backbone.Picky.SingleSelect(this);
       _.extend(this, singleSelect);
     }
   });

From 27727e42f9e8126beb2c735929d5690211161233 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Tue, 31 Dec 2013 02:10:11 +0100
Subject: [PATCH 09/18] Added tests for multiple collections

---
 spec/javascripts/multiple.collections.spec.js | 436 ++++++++++++++++++
 1 file changed, 436 insertions(+)
 create mode 100644 spec/javascripts/multiple.collections.spec.js

diff --git a/spec/javascripts/multiple.collections.spec.js b/spec/javascripts/multiple.collections.spec.js
new file mode 100644
index 0000000..2ef9689
--- /dev/null
+++ b/spec/javascripts/multiple.collections.spec.js
@@ -0,0 +1,436 @@
+describe("models shared between multiple collections", function(){
+
+  var Model = Backbone.Model.extend({
+    initialize: function(){
+      var selectable = new Backbone.Picky.Selectable(this);
+      _.extend(this, selectable);
+    }
+  });
+
+  var SingleSelectCollection = Backbone.Collection.extend({
+    model: Model,
+
+    initialize: function(){
+      var singleSelect = new Backbone.Picky.SingleSelect(this);
+      _.extend(this, singleSelect);
+    }
+  });
+  var MultiSelectCollection = Backbone.Collection.extend({
+    model: Model,
+
+    initialize: function(){
+      var multiSelect = new Backbone.Picky.MultiSelect(this);
+      _.extend(this, multiSelect);
+    }
+  });
+
+
+  describe("when selecting a model in a single-select collection", function(){
+    var model, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      singleCollectionB = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+
+      singleCollectionA.select(model);
+    });
+
+    it("should be selected in the originating collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should be selected in another single-select collection", function(){
+      expect(singleCollectionB.selected).toBe(model);
+    });
+
+    it("should be among the selected models in another multi-select collection", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+
+    it("should be selected itself", function(){
+      expect(model.selected).toBe(true);
+    });
+  });
+
+  describe("when selecting a model in a multi-select collection", function(){
+    var model, singleCollectionA, multiCollectionA, multiCollectionB;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+      multiCollectionB  = new MultiSelectCollection([model]);
+
+      multiCollectionA.select(model);
+    });
+
+    it("should be selected in the originating collection", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+
+    it("should be selected in another single-select collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should be among the selected models in another multi-select collection", function(){
+      expect(multiCollectionB.selected[model.cid]).not.toBeUndefined();
+    });
+
+    it("should be selected itself", function(){
+      expect(model.selected).toBe(true);
+    });
+  });
+
+  describe("when selecting a model, which is shared across collections, with its select method", function(){
+    var model, singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+
+      model.select();
+    });
+
+    it("should be selected in a single-select collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should be among the selected models in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+
+    it("should be selected itself", function(){
+      expect(model.selected).toBe(true);
+    });
+  });
+
+  describe("when adding a selected model to additional collections", function(){
+    var model, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      singleCollectionA.select(model);
+
+      singleCollectionB = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+    });
+
+    it("should remain selected in the originating collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should be selected in another single-select collection it is added to", function(){
+      expect(singleCollectionB.selected).toBe(model);
+    });
+
+    it("should be among the selected models in another multi-select collection it is added to", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+
+    it("should remain selected itself", function(){
+      expect(model.selected).toBe(true);
+    });
+  });
+
+  describe("when re-selecting a model shared across collections", function(){
+    var model, singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+
+      singleCollectionA.select(model);
+      model.select();
+    });
+
+   it("should remain selected in a single-select collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should remain among the selected models in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+
+    it("should remain selected itself", function(){
+      expect(model.selected).toBe(true);
+    });
+  });
+
+  describe("when re-selecting a model, which is shared across collections, in a single-select collection", function(){
+    var model1, model2, singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      multiCollectionA.select(model2);
+      multiCollectionA.select(model1);
+
+      singleCollectionA.select(model1);
+    });
+
+    it("should not deselect other selected models in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+    });
+
+  });
+
+  describe("when a model is already selected and a different model is selected in a single-select collection", function(){
+    var model1, model2, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      singleCollectionB = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      model1.select();
+      singleCollectionA.select(model2);
+    });
+
+    it("should be selected in the originating collection", function(){
+      expect(singleCollectionA.selected).toBe(model2);
+    });
+
+    it("should be selected in another single-select collection", function(){
+      expect(singleCollectionB.selected).toBe(model2);
+    });
+
+    it("should be selected in another multi-select collection", function(){
+      expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+    });
+
+    it("should be selected itself", function(){
+      expect(model2.selected).toBe(true);
+    });
+
+    it("should deselect the first model", function(){
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should deselect the first model in another multi-select collection", function(){
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+  });
+
+  describe("when a model is already selected and a different model is selected with its select method", function(){
+
+    describe("when both models are shared among multi-select collections only", function() {
+      var model1, model2, multiCollectionA, multiCollectionB;
+
+      beforeEach(function(){
+        model1 = new Model();
+        model2 = new Model();
+
+        multiCollectionA  = new MultiSelectCollection([model1, model2]);
+        multiCollectionB  = new MultiSelectCollection([model1, model2]);
+
+        model1.select();
+        model2.select();
+      });
+
+     it("should be selected in all collections", function(){
+       expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+       expect(multiCollectionB.selected[model2.cid]).not.toBeUndefined();
+     });
+
+     it("should leave the first model selected in all collections", function(){
+       expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+       expect(multiCollectionB.selected[model1.cid]).not.toBeUndefined();
+     });
+    });
+
+    describe("when both models are shared, with at least one single-select collection among the collections", function() {
+      // As soon as both models are part of a single-select collection, only one of them can be flagged as selected.
+      // That even extends to multi-select collections sharing those models.
+      var model1, model2, singleCollectionA, multiCollectionA;
+
+      beforeEach(function(){
+        model1 = new Model();
+        model2 = new Model();
+
+        singleCollectionA = new SingleSelectCollection([model1, model2]);
+        multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+        model1.select();
+        model2.select();
+      });
+
+      it("should be selected in the single-select collection", function(){
+        expect(singleCollectionA.selected).toBe(model2);
+      });
+
+      it("should be selected in the multi-select collection", function(){
+        expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+      });
+
+      it("should deselect the first model", function(){
+        expect(model1.selected).toBe(false);
+      });
+
+      it("should deselect the first model in the multi-select collection", function(){
+        expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+      });
+    });
+
+    describe("when the first model is shared with at least one single-select collection, but not the second", function() {
+      var model1, model2, singleCollectionA, multiCollectionA;
+
+      beforeEach(function(){
+        model1 = new Model();
+        model2 = new Model();
+
+        singleCollectionA = new SingleSelectCollection([model1]);
+        multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+        model1.select();
+        model2.select();
+      });
+
+      it("should be selected itself", function(){
+        expect(model2.selected).toBe(true);
+      });
+
+      it("should be selected in the multi-select collection", function(){
+        expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+      });
+
+      it("should leave the first model selected", function(){
+        expect(model1.selected).toBe(true);
+      });
+
+      it("should leave the first model selected in the single-select collection", function(){
+        expect(singleCollectionA.selected).toBe(model1);
+      });
+
+      it("should leave the first model selected in the multi-select collection", function(){
+        expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+      });
+    });
+
+    describe("when the second model is shared with at least one single-select collection, but not the first", function() {
+
+      var model1, model2, singleCollectionA, multiCollectionA;
+
+      beforeEach(function(){
+        model1 = new Model();
+        model2 = new Model();
+
+        singleCollectionA = new SingleSelectCollection([model2]);
+        multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+        model1.select();
+        model2.select();
+      });
+
+      it("should be selected itself", function(){
+        expect(model2.selected).toBe(true);
+      });
+
+      it("should be selected in the single-select collection", function(){
+        expect(singleCollectionA.selected).toBe(model2);
+      });
+
+      it("should be selected in the multi-select collection", function(){
+        expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+      });
+
+      it("should leave the first model selected", function(){
+        expect(model1.selected).toBe(true);
+      });
+
+      it("should leave the first model selected in the multi-select collection", function(){
+        expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+      });
+    });
+  });
+
+  describe("when a model is selected and deselect is called in a single-select collection", function(){
+    var model1, model2, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1]);
+      singleCollectionB = new SingleSelectCollection([model1]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      multiCollectionA.select(model2);
+      singleCollectionA.select(model1);
+
+      singleCollectionA.deselect();
+    });
+
+    it("should be deselected in the originating collection", function(){
+      expect(singleCollectionA.selected).toBeUndefined();
+    });
+
+    it("should be deselected in another single-select collection", function(){
+      expect(singleCollectionB.selected).toBeUndefined();
+    });
+
+    it("should be deselected in another multi-select collection", function(){
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should not deselected another selected model in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+    });
+
+    it("should be deselected itself", function(){
+      expect(model1.selected).toBe(false);
+    });
+  });
+
+  describe("when a selected model is deselected in a multi-select collection", function(){
+    var model1, model2, singleCollectionA, singleCollectionB, multiCollectionA, multiCollectionB;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1]);
+      singleCollectionB = new SingleSelectCollection([model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+      multiCollectionB  = new MultiSelectCollection([model1, model2]);
+
+      multiCollectionA.select(model2);
+      multiCollectionA.select(model1);
+
+      multiCollectionA.deselect(model1);
+    });
+
+    it("should be deselected in the originating collection", function(){
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should be deselected in another single-select collection which shares the model", function(){
+      expect(singleCollectionA.selected).toBeUndefined();
+    });
+
+    it("should be deselected in another multi-select collection", function(){
+      expect(multiCollectionB.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should be deselected itself", function(){
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should not deselect another selected model in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+    });
+
+    it("should not deselect another selected model which is shared between a multi-select collection and a single-select collection", function () {
+      expect(singleCollectionB.selected).toBe(model2);
+    });
+  });
+
+});

From 23463f641412e4f4ae722c8f8552352888ed3e89 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Tue, 7 Jan 2014 19:27:55 +0100
Subject: [PATCH 10/18] Working implementation for multiple collections

Events still need to be improved, those tests are failing.
---
 spec/javascripts/multiple.collections.spec.js | 300 +++++++++++++++++-
 src/backbone.picky.js                         |  85 ++++-
 2 files changed, 373 insertions(+), 12 deletions(-)

diff --git a/spec/javascripts/multiple.collections.spec.js b/spec/javascripts/multiple.collections.spec.js
index 2ef9689..28f129a 100644
--- a/spec/javascripts/multiple.collections.spec.js
+++ b/spec/javascripts/multiple.collections.spec.js
@@ -10,16 +10,16 @@ describe("models shared between multiple collections", function(){
   var SingleSelectCollection = Backbone.Collection.extend({
     model: Model,
 
-    initialize: function(){
-      var singleSelect = new Backbone.Picky.SingleSelect(this);
+    initialize: function(models){
+      var singleSelect = new Backbone.Picky.SingleSelect(this, models);
       _.extend(this, singleSelect);
     }
   });
   var MultiSelectCollection = Backbone.Collection.extend({
     model: Model,
 
-    initialize: function(){
-      var multiSelect = new Backbone.Picky.MultiSelect(this);
+    initialize: function(models){
+      var multiSelect = new Backbone.Picky.MultiSelect(this, models);
       _.extend(this, multiSelect);
     }
   });
@@ -107,7 +107,7 @@ describe("models shared between multiple collections", function(){
     });
   });
 
-  describe("when adding a selected model to additional collections", function(){
+  describe("when creating additional collections with a model that is already selected", function(){
     var model, singleCollectionA, singleCollectionB, multiCollectionA;
 
     beforeEach(function(){
@@ -433,4 +433,294 @@ describe("models shared between multiple collections", function(){
     });
   });
 
+  describe("when a selected model is added", function(){
+    var model1, model2, model3, model4,
+        singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      model3 = new Model();
+      model4 = new Model();
+
+      singleCollectionA = new SingleSelectCollection([model1]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2, model3]);
+
+      model1.select();
+      model2.select();
+      model3.select();
+      model4.select();
+    });
+
+    it("should be selected in a single-select collection it is added to", function(){
+      singleCollectionA.add(model2);
+      expect(singleCollectionA.selected).toBe(model2);
+    });
+
+    it("should deselect any previously selected model in a single-select collection", function(){
+      singleCollectionA.add(model2);
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should be added to the selected models in a multi-select collection", function(){
+      multiCollectionA.add(model4);
+      expect(multiCollectionA.selected[model4.cid]).not.toBeUndefined();
+    });
+
+    it("should deselect other selected models in a multi-select collection if they are shared with the single-select collection the new model is added to", function(){
+      singleCollectionA.add(model2);
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should leave other selected models untouched in a multi-select collection, provided they are not shared with the single-select collection the new model is added to", function(){
+      singleCollectionA.add(model2);
+      expect(multiCollectionA.selected[model3.cid]).not.toBeUndefined();
+    });
+
+    it("should remain selected itself", function(){
+      singleCollectionA.add(model2);
+      expect(model2.selected).toBe(true);
+    });
+  });
+
+  describe("when a selected model is removed", function(){
+    var model1, model2,
+        singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      model1.select();
+    });
+
+    it("should no longer be selected in a single-select collection", function(){
+      singleCollectionA.remove(model1);
+      expect(singleCollectionA.selected).toBeUndefined();
+    });
+
+    it("should no longer be selected in a multi-select collection", function(){
+      multiCollectionA.remove(model1);
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should no longer be selected if removed from all collections", function(){
+      singleCollectionA.remove(model1);
+      multiCollectionA.remove(model1);
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should no longer be selected if removed from all collections, even if it had accidentally been re-added to a collection already holding it", function(){
+      // This is to make sure that the reference counting, which is going on behind the scenes, does not get out of
+      // step.
+      singleCollectionA.add(model1);      // model is already part of the collection, adding it for the second time
+      multiCollectionA.add(model1);       // adding the model for the second time
+
+      singleCollectionA.remove(model1);
+      multiCollectionA.remove(model1);
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should remain selected in those collections it has not been removed from (removed from single-select)", function(){
+      singleCollectionA.remove(model1);
+      expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+    });
+
+    it("should remain selected in those collections it has not been removed from (removed from multi-select)", function(){
+      multiCollectionA.remove(model1);
+      expect(singleCollectionA.selected).toBe(model1);
+    });
+
+    it("should remain selected itself if not removed from all collections", function(){
+      singleCollectionA.remove(model1);
+      expect(model1.selected).toBe(true);
+    });
+  });
+
+  describe("when a selected model is added by resetting the collection", function(){
+    var model1, model2, model3,
+      singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      model3 = new Model();
+
+      singleCollectionA = new SingleSelectCollection([model1]);
+      singleCollectionB = new SingleSelectCollection([model3]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2, model3]);
+
+      model1.select();
+      model2.select();
+      model3.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(model2, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+    });
+
+    it("should be selected in a single-select collection it is added to", function(){
+      singleCollectionA.reset([model1]);
+      expect(singleCollectionA.selected).toBe(model1);
+    });
+
+    it("should be selected in a single-select collection if multiple models with selected status are added, and it is the last of them", function(){
+      singleCollectionA.reset([model1, model2]);
+      expect(model2.selected).toBe(true);
+      expect(singleCollectionA.selected).toBe(model2);
+    });
+
+    it("should be deselected in a single-select collection if multiple models with selected status are added, and it is not the last of them", function(){
+      singleCollectionA.reset([model1, model2]);
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should be added to the selected models in a multi-select collection (being the first of multiple selected models)", function(){
+      multiCollectionA.reset([model1, model3]);
+      expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+    });
+
+    it("should be added to the selected models in a multi-select collection (being the last of multiple selected models)", function(){
+      multiCollectionA.reset([model1, model3]);
+      expect(multiCollectionA.selected[model3.cid]).not.toBeUndefined();
+    });
+
+    it("should deselect other selected models in a multi-select collection if they are shared with the single-select collection the new model is added to", function(){
+      singleCollectionA.reset([model1, model2]);
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should leave other selected models untouched in a multi-select collection, provided they are not shared with the single-select collection the new model is added to", function(){
+      singleCollectionA.reset([model1, model2]);
+      expect(multiCollectionA.selected[model3.cid]).not.toBeUndefined();
+    });
+
+    it("should become deselected if it is not part of any other collections, and is being re-added to the original collection (single-select)", function(){
+      // By resetting the collection, the selected model is first removed, then re-added. If the model is not part of
+      // any other collection, it loses its 'selected' status while being removed.
+      //
+      // This is expected behaviour, and it serves a purpose. A reset, with models which are not shared by any other
+      // collection, should provide a clean slate.
+      multiCollectionA.reset();
+      singleCollectionA.reset([model1]);
+      expect(model1.selected).toBe(false);
+      expect(singleCollectionA.selected).toBeUndefined();
+    });
+
+    it("should become deselected if it is not part of any other collections, and is being re-added to the original collection (multi-select)", function(){
+      // The model loses its 'selected' status while being removed. See comment above.
+      singleCollectionA.reset();
+      multiCollectionA.reset([model1, model2]);
+      expect(model1.selected).toBe(false);
+      expect(model2.selected).toBe(false);
+      expect(multiCollectionA.selected).toEqual({});
+    });
+
+    it('should not trigger a selected/select:one event when added to a single-select collection', function () {
+      singleCollectionA.reset([model1]);
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a selected/select:some/select:all event when added to a multi-select collection', function () {
+      multiCollectionA.reset([model1]);
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should trigger a deselected/select:some event when the reset is inducing a deselection in another multi-select collection', function () {
+      singleCollectionA.reset([model1, model2]);
+      expect(model2.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
+    });
+
+    it("should remain selected itself", function(){
+      singleCollectionA.reset([model1]);
+      expect(model1.selected).toBe(true);
+    });
+  });
+
+  describe("when a selected model is removed by resetting the collection", function(){
+    var model1, model2,
+      singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      model1.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+    });
+
+    it("should no longer be selected in a single-select collection", function(){
+      singleCollectionA.reset();
+      expect(singleCollectionA.selected).toBeUndefined();
+    });
+
+    it("should no longer be selected in a multi-select collection", function(){
+      multiCollectionA.reset();
+      expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
+    });
+
+    it("should no longer be selected if removed from all collections", function(){
+      singleCollectionA.reset();
+      multiCollectionA.reset();
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should remain selected in those collections it has not been removed from (removed from single-select)", function(){
+      singleCollectionA.reset();
+      expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+    });
+
+    it("should remain selected in those collections it has not been removed from (removed from multi-select)", function(){
+      multiCollectionA.reset();
+      expect(singleCollectionA.selected).toBe(model1);
+    });
+
+    it("should remain selected itself if not removed from all collections", function(){
+      singleCollectionA.reset();
+      expect(model1.selected).toBe(true);
+    });
+
+    it('should not trigger a deselected/deselect:one event when removed from a single-select collection', function () {
+      singleCollectionA.reset();
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should not trigger a deselected/select:none event when removed from a multi-select collection', function () {
+      multiCollectionA.reset();
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model2);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:none", multiCollectionA);
+    });
+
+    it('should not trigger a deselected/deselect:one event when removed from all collections, single-select collection last', function () {
+      multiCollectionA.reset();
+      singleCollectionA.reset();
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should not trigger a deselected/select:none event when removed from all collections, multi-select collection last', function () {
+      singleCollectionA.reset();
+      multiCollectionA.reset();
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model2);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:none", multiCollectionA);
+    });
+  });
+
 });
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index c72f119..0ba36fc 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -8,10 +8,21 @@ Backbone.Picky = (function (Backbone, _) {
   // model within the collection causes the previous model to be
   // deselected.
 
-  Picky.SingleSelect = function(collection){
+  Picky.SingleSelect = function(collection, models){
+    this._pickyCid = _.uniqueId('singleSelect-');
     this.collection = collection;
+
+    _.each(models || [], function (model) {
+      registerCollectionWithModel(model, this);
+      if (model.selected) this.selected = model;
+    }, this);
+
     this.collection.listenTo(this.collection, 'selected', this.select);
     this.collection.listenTo(this.collection, 'deselected', this.deselect);
+
+    this.collection.listenTo(this.collection, 'reset', onResetSingleSelect);
+    this.collection.listenTo(this.collection, 'add', onAdd);
+    this.collection.listenTo(this.collection, 'remove', onRemove);
   };
 
   _.extend(Picky.SingleSelect.prototype, {
@@ -30,13 +41,14 @@ Backbone.Picky = (function (Backbone, _) {
 
     // Deselect a model, resulting in no model
     // being selected
-    deselect: function(model){
+    deselect: function(model, options){
+      options || (options = {});
       if (!this.selected){ return; }
 
       model = model || this.selected;
       if (this.selected !== model){ return; }
 
-      this.selected.deselect();
+      if (!options.skipModelCall) this.selected.deselect();
       this.trigger("deselect:one", this.selected);
       delete this.selected;
     }
@@ -45,16 +57,26 @@ Backbone.Picky = (function (Backbone, _) {
 
   // Picky.MultiSelect
   // -----------------
-  // A mult-select mixin for Backbone.Collection, allowing a collection to
+  // A multi-select mixin for Backbone.Collection, allowing a collection to
   // have multiple items selected, including `selectAll` and `deselectAll`
   // capabilities.
 
-  Picky.MultiSelect = function (collection) {
+  Picky.MultiSelect = function (collection, models) {
+    this._pickyCid = _.uniqueId('multiSelect-');
     this.collection = collection;
     this.selected = {};
+
+    _.each(models || [], function (model) {
+      registerCollectionWithModel(model, this);
+      if (model.selected) this.selected[model.cid] = model;
+    }, this);
+
     this.collection.listenTo(this.collection, 'selected', this.select);
     this.collection.listenTo(this.collection, 'deselected', this.deselect);
 
+    this.collection.listenTo(this.collection, 'reset', onResetMultiSelect);
+    this.collection.listenTo(this.collection, 'add', onAdd);
+    this.collection.listenTo(this.collection, 'remove', onRemove);
   };
 
   _.extend(Picky.MultiSelect.prototype, {
@@ -73,11 +95,12 @@ Backbone.Picky = (function (Backbone, _) {
     // Deselect a specified model, make sure the
     // model knows it has been deselected, and remove
     // the model from the selected list.
-    deselect: function (model) {
+    deselect: function (model, options) {
+      options || (options = {});
       if (!this.selected[model.cid]) { return; }
 
       delete this.selected[model.cid];
-      model.deselect();
+      if (!options.skipModelCall) model.deselect();
       calculateSelectedLength(this);
     },
 
@@ -178,5 +201,53 @@ Backbone.Picky = (function (Backbone, _) {
     }
   };
 
+  function onAdd (model, collection) {
+    registerCollectionWithModel(model, collection);
+    if (model.selected) collection.select(model);
+  }
+
+  function deselectLocal (model, collection){
+    if (model.selected){
+      if (model._pickyCollections && model._pickyCollections.length == 0) {
+        collection.deselect(model);
+      } else {
+        collection.deselect(model, {skipModelCall: true});
+      }
+    }
+  }
+
+  function onRemove (model, collection) {
+    if (model._pickyCollections) model._pickyCollections = _.without(model._pickyCollections, collection._pickyCid);
+    deselectLocal(model, collection);
+  }
+
+  function onResetSingleSelect (collection, options) {
+    var selected,
+        deselectOnAdd,
+        deselectOnRemove = _.find(options.previousModels, function (model) { return model.selected; });
+
+    if (deselectOnRemove) onRemove(deselectOnRemove, collection);
+
+    selected = collection.filter(function (model) { return model.selected; });
+    deselectOnAdd = _.initial(selected);
+    if (deselectOnAdd.length) _.each(deselectOnAdd, function (model) { model.deselect(); });
+    if (selected.length) collection.select(_.last(selected));
+  }
+
+  function onResetMultiSelect (collection, options) {
+    var select,
+        deselect = _.filter(options.previousModels, function (model) { return model.selected; });
+
+    if (deselect) _.each(deselect, function (model) { onRemove(model, collection); });
+
+    select = collection.filter(function (model) { return model.selected; });
+    if (select.length) _.each(select, function (model) { collection.select(model); });
+  }
+
+  function registerCollectionWithModel(model, collection) {
+    model._pickyCollections || (model._pickyCollections = []);
+    model._pickyCollections.push(collection._pickyCid);
+  }
+
   return Picky;
 })(Backbone, _);

From e0b078902dc8cdd0caed00125234740b200ce6d4 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Wed, 8 Jan 2014 00:57:59 +0100
Subject: [PATCH 11/18] Events fixed for multiple collections by introducing
 options.silent

---
 spec/javascripts/multiple.collections.spec.js |  71 ++++++++++++
 src/backbone.picky.js                         | 104 +++++++++---------
 2 files changed, 125 insertions(+), 50 deletions(-)

diff --git a/spec/javascripts/multiple.collections.spec.js b/spec/javascripts/multiple.collections.spec.js
index 28f129a..238ca84 100644
--- a/spec/javascripts/multiple.collections.spec.js
+++ b/spec/javascripts/multiple.collections.spec.js
@@ -15,6 +15,7 @@ describe("models shared between multiple collections", function(){
       _.extend(this, singleSelect);
     }
   });
+
   var MultiSelectCollection = Backbone.Collection.extend({
     model: Model,
 
@@ -54,6 +55,27 @@ describe("models shared between multiple collections", function(){
     });
   });
 
+  describe("when selecting a model in a single-select collection, with options.silent enabled", function(){
+    var model, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      singleCollectionB = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+
+      singleCollectionA.select(model, {silent: true});
+    });
+
+    it("should be selected in another single-select collection", function(){
+      expect(singleCollectionB.selected).toBe(model);
+    });
+
+    it("should be among the selected models in another multi-select collection", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+  });
+
   describe("when selecting a model in a multi-select collection", function(){
     var model, singleCollectionA, multiCollectionA, multiCollectionB;
 
@@ -83,6 +105,27 @@ describe("models shared between multiple collections", function(){
     });
   });
 
+  describe("when selecting a model in a multi-select collection, with options.silent enabled", function(){
+    var model, singleCollectionA, multiCollectionA, multiCollectionB;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+      multiCollectionB  = new MultiSelectCollection([model]);
+
+      multiCollectionA.select(model, {silent: true});
+    });
+
+    it("should be selected in another single-select collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should be among the selected models in another multi-select collection", function(){
+      expect(multiCollectionB.selected[model.cid]).not.toBeUndefined();
+    });
+  });
+
   describe("when selecting a model, which is shared across collections, with its select method", function(){
     var model, singleCollectionA, multiCollectionA;
 
@@ -107,6 +150,26 @@ describe("models shared between multiple collections", function(){
     });
   });
 
+  describe("when selecting a model, which is shared across collections, with its select method and options.silent enabled", function(){
+    var model, singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model = new Model();
+      singleCollectionA = new SingleSelectCollection([model]);
+      multiCollectionA  = new MultiSelectCollection([model]);
+
+      model.select({silent: true});
+    });
+
+    it("should be selected in a single-select collection", function(){
+      expect(singleCollectionA.selected).toBe(model);
+    });
+
+    it("should be among the selected models in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
+    });
+  });
+
   describe("when creating additional collections with a model that is already selected", function(){
     var model, singleCollectionA, singleCollectionB, multiCollectionA;
 
@@ -621,12 +684,15 @@ describe("models shared between multiple collections", function(){
     });
 
     it('should not trigger a selected/select:one event when added to a single-select collection', function () {
+      // reset() is meant to suppress individual notifications. Just like the add event, selection events are silenced.
+      // Whatever needs to be done, should be dealt with in the reset event handler.
       singleCollectionA.reset([model1]);
       expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
     });
 
     it('should not trigger a selected/select:some/select:all event when added to a multi-select collection', function () {
+      // For the rationale, see above.
       multiCollectionA.reset([model1]);
       expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
@@ -695,12 +761,15 @@ describe("models shared between multiple collections", function(){
     });
 
     it('should not trigger a deselected/deselect:one event when removed from a single-select collection', function () {
+      // reset() is meant to suppress individual notifications. Just like the add event, selection events are silenced.
+      // Whatever needs to be done, should be dealt with in the reset event handler.
       singleCollectionA.reset();
       expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
     });
 
     it('should not trigger a deselected/select:none event when removed from a multi-select collection', function () {
+      // For the rationale, see above.
       multiCollectionA.reset();
       expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
       expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model2);
@@ -708,6 +777,7 @@ describe("models shared between multiple collections", function(){
     });
 
     it('should not trigger a deselected/deselect:one event when removed from all collections, single-select collection last', function () {
+      // See above.
       multiCollectionA.reset();
       singleCollectionA.reset();
       expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
@@ -715,6 +785,7 @@ describe("models shared between multiple collections", function(){
     });
 
     it('should not trigger a deselected/select:none event when removed from all collections, multi-select collection last', function () {
+      // See above.
       singleCollectionA.reset();
       multiCollectionA.reset();
       expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index 0ba36fc..4763bdb 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -17,8 +17,8 @@ Backbone.Picky = (function (Backbone, _) {
       if (model.selected) this.selected = model;
     }, this);
 
-    this.collection.listenTo(this.collection, 'selected', this.select);
-    this.collection.listenTo(this.collection, 'deselected', this.deselect);
+    this.collection.listenTo(this.collection, '_selected', this.select);
+    this.collection.listenTo(this.collection, '_deselected', this.deselect);
 
     this.collection.listenTo(this.collection, 'reset', onResetSingleSelect);
     this.collection.listenTo(this.collection, 'add', onAdd);
@@ -29,14 +29,15 @@ Backbone.Picky = (function (Backbone, _) {
 
     // Select a model, deselecting any previously
     // selected model
-    select: function(model){
+    select: function(model, options){
+      options || (options = {});
       if (model && this.selected === model) { return; }
 
-      this.deselect();
+      this.deselect(undefined, options);
 
       this.selected = model;
-      this.selected.select();
-      this.trigger("select:one", model);
+      this.selected.select(options);
+      if (!options.silent) this.trigger("select:one", model);
     },
 
     // Deselect a model, resulting in no model
@@ -48,8 +49,8 @@ Backbone.Picky = (function (Backbone, _) {
       model = model || this.selected;
       if (this.selected !== model){ return; }
 
-      if (!options.skipModelCall) this.selected.deselect();
-      this.trigger("deselect:one", this.selected);
+      if (!options._skipModelCall) this.selected.deselect(options);
+      if (!options.silent) this.trigger("deselect:one", this.selected);
       delete this.selected;
     }
 
@@ -71,8 +72,8 @@ Backbone.Picky = (function (Backbone, _) {
       if (model.selected) this.selected[model.cid] = model;
     }, this);
 
-    this.collection.listenTo(this.collection, 'selected', this.select);
-    this.collection.listenTo(this.collection, 'deselected', this.deselect);
+    this.collection.listenTo(this.collection, '_selected', this.select);
+    this.collection.listenTo(this.collection, '_deselected', this.deselect);
 
     this.collection.listenTo(this.collection, 'reset', onResetMultiSelect);
     this.collection.listenTo(this.collection, 'add', onAdd);
@@ -84,12 +85,12 @@ Backbone.Picky = (function (Backbone, _) {
     // Select a specified model, make sure the
     // model knows it's selected, and hold on to
     // the selected model.
-    select: function (model) {
+    select: function (model, options) {
       if (this.selected[model.cid]) { return; }
 
       this.selected[model.cid] = model;
-      model.select();
-      calculateSelectedLength(this);
+      model.select(options);
+      calculateSelectedLength(this, options);
     },
 
     // Deselect a specified model, make sure the
@@ -100,35 +101,35 @@ Backbone.Picky = (function (Backbone, _) {
       if (!this.selected[model.cid]) { return; }
 
       delete this.selected[model.cid];
-      if (!options.skipModelCall) model.deselect();
-      calculateSelectedLength(this);
+      if (!options._skipModelCall) model.deselect(options);
+      calculateSelectedLength(this, options);
     },
 
     // Select all models in this collection
-    selectAll: function () {
-      this.each(function (model) { model.select(); });
-      calculateSelectedLength(this);
+    selectAll: function (options) {
+      this.each(function (model) { model.select(options); });
+      calculateSelectedLength(this, options);
     },
 
     // Deselect all models in this collection
-    deselectAll: function () {
+    deselectAll: function (options) {
       if (this.selectedLength === 0) { return; }
-      this.each(function (model) { model.deselect(); });
-      calculateSelectedLength(this);
+      this.each(function (model) { model.deselect(options); });
+      calculateSelectedLength(this, options);
     },
 
-    selectNone: function () {
-      this.deselectAll();
+    selectNone: function (options) {
+      this.deselectAll(options);
     },
 
       // Toggle select all / none. If some are selected, it
     // will select all. If all are selected, it will select 
     // none. If none are selected, it will select all.
-    toggleSelectAll: function () {
+    toggleSelectAll: function (options) {
       if (this.selectedLength === this.length) {
-        this.deselectAll();
+        this.deselectAll(options);
       } else {
-        this.selectAll();
+        this.selectAll(options);
       }
     }
   });
@@ -146,29 +147,33 @@ Backbone.Picky = (function (Backbone, _) {
 
     // Select this model, and tell our
     // collection that we're selected
-    select: function () {
+    select: function (options) {
+      options || (options = {});
       if (this.selected) { return; }
 
       this.selected = true;
-      this.trigger("selected", this);
+      this.trigger("_selected", this);
+      if (!options.silent) this.trigger("selected", this);
     },
 
     // Deselect this model, and tell our
     // collection that we're deselected
-    deselect: function () {
+    deselect: function (options) {
+      options || (options = {});
       if (!this.selected) { return; }
 
       this.selected = false;
-      this.trigger("deselected", this);
+      this.trigger("_deselected", this);
+      if (!options.silent) this.trigger("deselected", this);
     },
 
     // Change selected to the opposite of what
     // it currently is
-    toggleSelected: function () {
+    toggleSelected: function (options) {
       if (this.selected) {
-        this.deselect();
+        this.deselect(options);
       } else {
-        this.select();
+        this.select(options);
       }
     }
   });
@@ -179,9 +184,12 @@ Backbone.Picky = (function (Backbone, _) {
   // Calculate the number of selected items in a collection
   // and update the collection with that length. Trigger events
   // from the collection based on the number of selected items.
-  var calculateSelectedLength = function (collection) {
+  var calculateSelectedLength = function (collection, options) {
+    options || (options = {});
     collection.selectedLength = _.size(collection.selected);
 
+    if (options.silent) return;
+
     var selectedLength = collection.selectedLength;
     var length = collection.length;
 
@@ -206,42 +214,38 @@ Backbone.Picky = (function (Backbone, _) {
     if (model.selected) collection.select(model);
   }
 
-  function deselectLocal (model, collection){
-    if (model.selected){
+  function onRemove (model, collection, options) {
+    if (model._pickyCollections) model._pickyCollections = _.without(model._pickyCollections, collection._pickyCid);
+    if (model.selected) {
       if (model._pickyCollections && model._pickyCollections.length == 0) {
-        collection.deselect(model);
+        collection.deselect(model, options);
       } else {
-        collection.deselect(model, {skipModelCall: true});
+        collection.deselect(model, _.extend({}, options, {_skipModelCall: true}));
       }
     }
   }
 
-  function onRemove (model, collection) {
-    if (model._pickyCollections) model._pickyCollections = _.without(model._pickyCollections, collection._pickyCid);
-    deselectLocal(model, collection);
-  }
-
   function onResetSingleSelect (collection, options) {
     var selected,
-        deselectOnAdd,
+        excessiveSelections,
         deselectOnRemove = _.find(options.previousModels, function (model) { return model.selected; });
 
-    if (deselectOnRemove) onRemove(deselectOnRemove, collection);
+    if (deselectOnRemove) onRemove(deselectOnRemove, collection, {silent: true});
 
     selected = collection.filter(function (model) { return model.selected; });
-    deselectOnAdd = _.initial(selected);
-    if (deselectOnAdd.length) _.each(deselectOnAdd, function (model) { model.deselect(); });
-    if (selected.length) collection.select(_.last(selected));
+    excessiveSelections = _.initial(selected);
+    if (excessiveSelections.length) _.each(excessiveSelections, function (model) { model.deselect({silent: true}); });
+    if (selected.length) collection.select(_.last(selected), {silent: true});
   }
 
   function onResetMultiSelect (collection, options) {
     var select,
         deselect = _.filter(options.previousModels, function (model) { return model.selected; });
 
-    if (deselect) _.each(deselect, function (model) { onRemove(model, collection); });
+    if (deselect) _.each(deselect, function (model) { onRemove(model, collection, {silent: true}); });
 
     select = collection.filter(function (model) { return model.selected; });
-    if (select.length) _.each(select, function (model) { collection.select(model); });
+    if (select.length) _.each(select, function (model) { collection.select(model, {silent: true}); });
   }
 
   function registerCollectionWithModel(model, collection) {

From 453d5147354fb2b81d70269bcfd4b9dc6d078940 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 13 Jan 2014 14:02:03 +0100
Subject: [PATCH 12/18] Added full support for multiple collections (fixing
 #16)

---
 readme.md                                     | 201 ++++--
 spec/javascripts/helpers/SpecHelper.js        |  21 +-
 spec/javascripts/multiSelect.deselect.spec.js |  79 ++-
 spec/javascripts/multiSelect.select.spec.js   | 181 ++++++
 ...multiSelect.selectable.interaction.spec.js | 288 +++++++++
 spec/javascripts/multiSelect.toggle.spec.js   |  57 ++
 spec/javascripts/multiple.collections.spec.js | 590 +++++++++++++++++-
 spec/javascripts/selectable.spec.js           |  39 ++
 spec/javascripts/singleSelect.spec.js         | 186 ++++++
 spec/javascripts/support/jasmine.yml          |   1 +
 src/backbone.picky.js                         | 108 ++--
 11 files changed, 1637 insertions(+), 114 deletions(-)

diff --git a/readme.md b/readme.md
index 04c87e1..15262a6 100644
--- a/readme.md
+++ b/readme.md
@@ -37,6 +37,10 @@ at what each section of is doing.
 
 ##### [View The Annotated Source Code](http://derickbailey.github.com/backbone.picky/docs/backbone.picky.html)
 
+## Requirements
+
+Backbone.Picky requires Backbone 0.9.9 or later.
+
 ## Method Name Overrides
 
 #### IMPORTANT NOTE ABOUT METHOD NAME "select"
@@ -73,16 +77,9 @@ col.select(model);
 
 ### Model Requirements For Picky Collections
 
-Your model for a Picky collection must implement the following API to be
-usable by the selection methods and functionality:
-
-* `select: function(){...}`
-* `deselect: function(){...}`
+Your model for a Picky collection must extend `Selectable`.
 
-The easiest way to do this is to have your model extend `Selectable`. You
-can, however, implement your own version of these methods.
-
-## Backbone.Picky's Components:
+## Components of Backbone.Picky:
 
 * **Picky.Selectable:** Creates select / deselect capabilities for a model
 * **Picky.MultiSelect:** Allows a collection to know about the selection of multiple models, including select all / deselect all
@@ -113,9 +110,9 @@ SelectableModel = Backbone.Model.extend({
 
 ### Selectable Methods
 
-The following methods are included in the `Selectable` object
+The following methods are included in the `Selectable` object.
 
-#### Selectable#select
+#### Selectable#select([options])
 
 Select a model, setting the model's `selected` property to true and
 triggering a "select" event.
@@ -130,7 +127,11 @@ myModel.on("select", function(){
 myModel.select(); //=> logs "I'm selected!"
 myModel.selected; //=> true
 ```
-#### Selectable#deselect
+
+The `select` method can be called with the `{silent: true}` option to prevent
+selection-related events from firing. See the events section below.
+
+#### Selectable#deselect([options])
 
 Deselect a model, setting the model's `selected` property to false and
 triggering a "deselected" event.
@@ -149,7 +150,9 @@ myModel.deselect(); //=> logs "I'm no longer selected!";
 myModel.selected; //=> false
 ```
 
-#### Selectable#toggleSelected
+The `deselect` method supports the `silent` option.
+
+#### Selectable#toggleSelected([options])
 
 Toggles the selection state between selected and deselected by calling
 the `select` or `deselect` method appropriately.
@@ -170,9 +173,11 @@ myModel.toggleSelected(); //=> "I'm selected!"
 myModel.toggleSelected(); //=> "I'm no longer selected!"
 ```
 
+The `toggleSelected` method supports the `silent` option.
+
 ### Selectable Properties
 
-The following properties are manipulated by the Selectable object
+The following properties are manipulated by the Selectable object.
 
 #### Selectable#selected
 
@@ -181,7 +186,9 @@ currently selected.
 
 ### Selectable Events
 
-The following events are triggered from Selectable models
+The events listed below are are triggered from Selectable models. Events can be
+prevented from firing when Backbone.Picky methods are called with the `silent`
+option, as in `myModel.select({silent: true})`.
 
 #### "selected"
 
@@ -196,7 +203,7 @@ as the first parameter.
 ## Picky.SingleSelect
 
 Creates single-select capabilities for a `Backbone.Collection`, allowing
-a single model to be exclusively selected within the colllection. Selecting
+a single model to be exclusively selected within the collection. Selecting
 another model will cause the first one to be deselected.
 
 ```js
@@ -226,11 +233,28 @@ SingleCollection = Backbone.Collection.extend({
 });
 ```
 
+If you share models among multiple collections, Backbone.Picky will handle the
+interaction for you. To turn on model-sharing mode, you must provide the models
+as a second argument during initialization:
+
+```js
+SingleCollection = Backbone.Collection.extend({
+  model: SelectableModel,
+
+  initialize: function(models){
+    var singleSelect = new Backbone.Picky.SingleSelect(this, models);
+    _.extend(this, singleSelect);
+  }
+});
+```
+
+See the section on model sharing, below, for more.
+
 ### SingleSelect Methods
 
 The following methods are provided by the `SingleSelect` object.
 
-#### SingleSelect#select(model)
+#### SingleSelect#select(model, [options])
 
 Select a model. This method will store the selected model in
 the collection's `selected` property, and call the model's `select`
@@ -238,7 +262,7 @@ method to ensure the model knows it has been selected.
 
 ```js
 myModel = new SelectableModel();
-myCol = new MultiCollection();
+myCol = new SingleCollection([myModel]);
 myCol.select(myModel);
 ```
 
@@ -246,14 +270,16 @@ Or
 
 ```js
 myModel = new SelectableModel();
-myCol = new MultiCollection([myModel]);
+myCol = new SingleCollection([myModel]);
 myModel.select();
 ```
 
 If the model is already selected, this is a no-op. If a previous model
 is already selected, the previous model will be deselected.
 
-#### SingleSelect#deselect(model)
+The `select` method supports the `silent` option.
+
+#### SingleSelect#deselect([model], [options])
 
 Deselect the currently selected model. This method will remove the 
 model from the collection's `selected` property, and call the model's
@@ -261,7 +287,7 @@ model from the collection's `selected` property, and call the model's
 
 ```js
 myModel = new SelectableModel();
-myCol = new MultiCollection();
+myCol = new SingleCollection([myModel]);
 myCol.deselect(myModel);
 ```
 
@@ -269,7 +295,7 @@ Or
 
 ```js
 myModel = new SelectableModel();
-myCol = new MultiCollection();
+myCol = new SingleCollection([myModel]);
 myModel.deselect();
 ```
 
@@ -277,16 +303,21 @@ If the model is not currently selected, this is a no-op. If you try to
 deselect a model that is not the currently selected model, the actual
 selected model will not be deselected.
 
+You can call `deselect` without a model argument. The currently selected model,
+if any, will be deselected in that case.
+
+The `deselect` method supports the `silent` option.
+
 ### SingleSelect Properties
 
-The following property is set by the multi-select automatically
+The following property is set by the multi-select automatically.
 
 ### SingleSelect#selected
 
 Returns the one selected model for this collection
 
 ```js
-myCol = new MultiCollection();
+myCol = new SingleCollection();
 myCol.select(model);
 
 myCol.selected; //=> model
@@ -294,8 +325,9 @@ myCol.selected; //=> model
 
 ### SingleSelect Events
 
-The following events are triggered by the SingleSelect based on changes
-in selection:
+The events listed below are triggered by the SingleSelect based on changes in
+selection. Events can be prevented from firing when Backbone.Picky methods are
+called with the `silent` option, as in `myCol.select(myModel, {silent: true})`.
 
 #### "select:one"
 
@@ -321,7 +353,7 @@ var multiSelect = new Backbone.Picky.MultiSelect(myCollection) ;
 
 ### Basic Usage
 
-Extend your collection with the `MultiSleect` instance to make your 
+Extend your collection with the `MultiSelect` instance to make your
 collection support multiple selections directly.
 
 ```js
@@ -342,39 +374,61 @@ MultiCollection = Backbone.Collection.extend({
   }
 });
 ```
+
+If you share models among different collections, Backbone.Picky will handle the
+interaction for you. To turn on model-sharing mode, you must provide the models
+as a second argument during initialization:
+
+```js
+MultiCollection = Backbone.Collection.extend({
+  model: SelectableModel,
+
+  initialize: function(models){
+    var multiSelect = new Backbone.Picky.MultiSelect(this, models);
+    _.extend(this, multiSelect);
+  }
+});
+```
+
+See the section on model sharing, below, for more.
+
 ### MultiSelect Methods
 
-The following methods are provided by the `MultiSelect` object
+The following methods are provided by the `MultiSelect` object.
 
-#### MultiSelect#select(model)
+#### MultiSelect#select(model, [options])
 
 Select a model. This method will store the selected model in
 the collection's `selected` list, and call the model's `select`
 method to ensure the model knows it has been selected.
 
 ```js
-myCol = new MultiCollection();
+myCol = new MultiCollection([myModel]);
 
 myCol.select(myModel);
 ```
 
 If the model is already selected, this is a no-op.
 
-#### MultiSelect#deselect(model)
+The `select` method supports the `silent` option.
+
+#### MultiSelect#deselect(model, [options])
 
 Deselect a model. This method will remove the  model from
 the collection's `selected` list, and call the model's `deselect`
 method to ensure the model knows it has been deselected.
 
 ```js
-myCol = new MultiCollection();
+myCol = new MultiCollection([myModel]);
 
 myCol.deselect(myModel);
 ```
 
 If the model is not currently selected, this is a no-op.
 
-#### MultiSelect#selectAll
+The `deselect` method supports the `silent` option.
+
+#### MultiSelect#selectAll([options])
 
 Select all models in the collection.
 
@@ -389,7 +443,9 @@ Models that are not currently selected will be selected.
 The end result will be all models in the collection are
 selected.
 
-#### MultiSelect#deselectAll
+The `selectAll` method supports the `silent` option.
+
+#### MultiSelect#deselectAll([options])
 
 Deselect all models in the collection.
 
@@ -404,7 +460,9 @@ Models that are not selected will not be deselected again.
 The end result will be no models in the collection are
 selected.
 
-#### MultiSelect#toggleSelectAll
+The `deselectAll` method supports the `silent` option.
+
+#### MultiSelect#toggleSelectAll([options])
 
 Toggle selection of all models in the collection:
 
@@ -422,9 +480,11 @@ The following rules are used when toggling:
 * If 1 or more models, but less than all models are selected, select them all
 * If all models are selected, deselect them all
 
+The `toggleSelectAll` method supports the `silent` option.
+
 ### MultiSelect Properties
 
-The following property is set by the multi-select automatically
+The following property is set by the multi-select automatically.
 
 ### MultiSelect#selected
 
@@ -455,8 +515,9 @@ myCol.selectedLength; //=> 1
 
 ### MultiSelect Events
 
-The following events are triggered by the MultiSelect based on changes
-in selection:
+The events below are triggered by the MultiSelect based on changes in selection.
+Events can be prevented from firing when Backbone.Picky methods are called with
+the `silent` option, as in `myCol.select(myModel, {silent: true})`.
 
 #### "select:all"
 
@@ -471,6 +532,70 @@ Triggered when all models have been deselected
 Triggered when at least 1 model is selected, but less than all models have
 been selected
 
+## Sharing models among collections
+
+Models can be part of more than one collection, and Backbone.Picky still manages
+selections correctly.
+
+Collections don't have to be of the same type. A model can be part of single-
+select and multi-select collections at the same time. Backbone.Picky handles all
+aspects of it:
+
+- Suppose you have selected a model (or models) in one collection, and then you
+  create another one with these models. The new collection will pick up the
+  selections you have already made. That also works when adding models to
+  existing collections.
+
+- The selections in a collection are updated as needed when models are removed.
+  A model loses its `selected` status when it is removed from the last collection
+  holding it. Resetting collections is governed by the same rules.
+
+- When a selection, or deselection, is made with the `silent` option enabled,
+  selection-related events will be silenced in all of the collections sharing
+  the model.
+
+- Edge cases are covered as well. Suppose a number of models are selected in a
+  multi-select collection. You then proceed to add them to a single-select
+  collection. Only one model can be selected there, so Backbone.Picky will
+  deselect all but one of them. The last model added to the single-select
+  collection "wins", ie its `selected` status survives.
+
+That said, there are a few things you must and mustn't do in order to make
+sharing work.
+
+- Models passed in during instantiation must be passed on to the mixin
+  constructor. Create the mixin with `new Backbone.Picky.SingleSelect(this, models)`
+  instead of `new Backbone.Picky.SingleSelect(this, models)` (without the `models`
+  argument).
+
+  Setting up the second parameter like this turns on the "model-sharing mode".
+  See the Basic Usage sections of SingleSelect and MultiSelect.
+
+- Don't use the `silent` option when adding models, removing them, or resetting
+  a collection. If you change the contents of a collection silently, the
+  `selected`/`deselected` status of the shared models won't be synced across
+  collections reliably.
+
+- When a collection is no longer in use, call `close()` on it to avoid memory
+  leaks.
+
+  So don't just replace a collection like this:
+
+    var myCol = new MySelectableCollection([myModel]);
+    // ... do stuff
+    myCol = new MySelectableCollection([myModel]);
+
+  Instead, call `close()` before you let an obsolete collection fade away into
+  oblivion:
+
+    var myCol = new MySelectableCollection([myModel]);
+    // ... do stuff
+    myCol.close();
+    myCol = new MySelectableCollection([myModel]);
+
+  Note that you don't need to call `close()` if you use Backbone.Picky in
+  "single-collection mode", without sharing models among collections.
+
 ## Building Backbone.Picky
 
 If you wish to build Backbone.Picky on your system, you will
diff --git a/spec/javascripts/helpers/SpecHelper.js b/spec/javascripts/helpers/SpecHelper.js
index e9b8284..a51008a 100644
--- a/spec/javascripts/helpers/SpecHelper.js
+++ b/spec/javascripts/helpers/SpecHelper.js
@@ -1,9 +1,12 @@
-beforeEach(function() {
-  this.addMatchers({
-    toBePlaying: function(expectedSong) {
-      var player = this.actual;
-      return player.currentlyPlayingSong === expectedSong && 
-             player.isPlaying;
-    }
-  });
-});
+var Logger = function () {
+  this.reset();
+};
+
+_.extend(Logger.prototype, {
+  log: function (content) {
+    this.entries.push(content);
+  },
+  reset: function () {
+    this.entries = [];
+  }
+});
\ No newline at end of file
diff --git a/spec/javascripts/multiSelect.deselect.spec.js b/spec/javascripts/multiSelect.deselect.spec.js
index efb189b..8531b6f 100644
--- a/spec/javascripts/multiSelect.deselect.spec.js
+++ b/spec/javascripts/multiSelect.deselect.spec.js
@@ -15,7 +15,7 @@ describe("multi-select collection deselecting", function(){
     }
   });
   
-  describe("when no models are selected, and deselecting all (selectNone)", function(){
+  describe("when no models are selected, and deselecting all", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -25,7 +25,7 @@ describe("multi-select collection deselecting", function(){
       collection = new Collection([m1, m2]);
       spyOn(collection, "trigger").andCallThrough();
 
-      collection.selectNone();
+      collection.deselectAll();
     });
     
     it("should trigger 'none' selected event", function(){
@@ -42,7 +42,7 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
-  describe("when no models are selected, and deselecting all (deselectAll)", function(){
+  describe("when no models are selected, and deselecting all, with options.silent enabled", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -52,9 +52,37 @@ describe("multi-select collection deselecting", function(){
       collection = new Collection([m1, m2]);
       spyOn(collection, "trigger").andCallThrough();
 
-      collection.deselectAll();
+      collection.deselectAll({silent: true});
+    });
+
+    it("should not trigger 'none' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
+    it("should have a selected count of 0", function(){
+      expect(collection.selectedLength).toBe(0);
+    });
+
+    it("should not have any models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(0);
+    });
+  });
+
+  describe("when 1 model is selected, and deselecting all", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      collection.deselectAll();
+    });
+    
     it("should trigger 'none' selected event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
@@ -69,6 +97,34 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
+  describe("when 1 model is selected, and deselecting all, with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      collection.deselectAll({silent: true});
+    });
+
+    it("should not trigger 'none' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+    });
+
+    it("should have a selected count of 0", function(){
+      expect(collection.selectedLength).toBe(0);
+    });
+
+    it("should not have any models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(0);
+    });
+  });
+
   describe("when 1 model is selected, and deselecting all (selectNone)", function(){
     var m1, m2, collection;
 
@@ -82,7 +138,7 @@ describe("multi-select collection deselecting", function(){
       spyOn(collection, "trigger").andCallThrough();
       collection.selectNone();
     });
-    
+
     it("should trigger 'none' selected event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
@@ -97,7 +153,7 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
-  describe("when 1 model is selected, and deselecting all (deselectAll)", function(){
+  describe("when all models are selected, and deselecting all", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -106,11 +162,12 @@ describe("multi-select collection deselecting", function(){
 
       collection = new Collection([m1, m2]);
       m1.select();
+      m2.select();
 
       spyOn(collection, "trigger").andCallThrough();
       collection.deselectAll();
     });
-
+    
     it("should trigger 'none' selected event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
@@ -154,7 +211,7 @@ describe("multi-select collection deselecting", function(){
     });
   });
 
-  describe("when all models are selected, and deselecting all (deselectAll)", function(){
+  describe("when all models are selected, and deselecting all, with options.silent enabled", function(){
     var m1, m2, collection;
 
     beforeEach(function(){
@@ -166,11 +223,11 @@ describe("multi-select collection deselecting", function(){
       m2.select();
 
       spyOn(collection, "trigger").andCallThrough();
-      collection.deselectAll();
+      collection.deselectAll({silent: true});
     });
 
-    it("should trigger 'none' selected event", function(){
-      expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
+    it("should not trigger 'none' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
     it("should have a selected count of 0", function(){
diff --git a/spec/javascripts/multiSelect.select.spec.js b/spec/javascripts/multiSelect.select.spec.js
index c3812cc..49c0c50 100644
--- a/spec/javascripts/multiSelect.select.spec.js
+++ b/spec/javascripts/multiSelect.select.spec.js
@@ -45,6 +45,36 @@ describe("multi-select collection selecting", function(){
     });
   });
 
+  describe("when no models are selected, and selecting all, with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      spyOn(collection, "trigger").andCallThrough();
+
+      collection.selectAll({silent: true});
+    });
+
+    it("should not trigger an 'all' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+    });
+
+    it("should have a selected count of 2", function(){
+      expect(collection.selectedLength).toBe(2);
+    });
+
+    it("should have the first selected model in the selected list", function(){
+      expect(collection.selected[m1.cid]).not.toBeUndefined();
+    });
+
+    it("should have the second selected model in the selected list", function(){
+      expect(collection.selected[m2.cid]).not.toBeUndefined();
+    });
+  });
+
   describe("when 1 model is selected, and selecting all", function(){
     var m1, m2, collection;
 
@@ -76,6 +106,37 @@ describe("multi-select collection selecting", function(){
     });
   });
 
+  describe("when 1 model is selected, and selecting all, with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      collection.selectAll({silent: true});
+    });
+
+    it("should not trigger an 'all' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+    });
+
+    it("should have a selected count of 2", function(){
+      expect(collection.selectedLength).toBe(2);
+    });
+
+    it("should have the first selected model in the selected list", function(){
+      expect(collection.selected[m1.cid]).not.toBeUndefined();
+    });
+
+    it("should have the second selected model in the selected list", function(){
+      expect(collection.selected[m2.cid]).not.toBeUndefined();
+    });
+  });
+
   describe("when all models are selected, and selecting all", function(){
     var m1, m2, collection;
 
@@ -108,4 +169,124 @@ describe("multi-select collection selecting", function(){
     });
   });
 
+  describe("when all models are selected, and selecting all, with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+      m2.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      collection.selectAll({silent: true});
+    });
+
+    it("should trigger 'all' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+    });
+
+    it("should have a selected count of 2", function(){
+      expect(collection.selectedLength).toBe(2);
+    });
+
+    it("should have the first selected model in the selected list", function(){
+      expect(collection.selected[m1.cid]).not.toBeUndefined();
+    });
+
+    it("should have the second selected model in the selected list", function(){
+      expect(collection.selected[m2.cid]).not.toBeUndefined();
+    });
+  });
+
+  describe('Checking for memory leaks', function () {
+
+    describe('when a collection is replaced by another one and is not referenced by a variable any more, with model sharing disabled', function () {
+      var logger, LoggedCollection, m1, m2, collection;
+
+      beforeEach(function () {
+        logger = new Logger();
+
+        LoggedCollection = Collection.extend({
+          initialize: function(models){
+            this.on("select:none", function () {
+              logger.log( "select:none event fired in selected in collection " + this._pickyCid );
+            });
+            this.on("select:some", function () {
+              logger.log( "select:some event fired in selected in collection " + this._pickyCid );
+            });
+            this.on("select:all", function () {
+              logger.log( "select:all event fired in selected in collection " + this._pickyCid );
+            });
+
+            Collection.prototype.initialize.call(this, models);
+          }
+        });
+
+        m1 = new Model();
+        m2 = new Model();
+      });
+
+      it('should no longer respond to model events', function () {
+        // With only variable holding a collection, only one 'select:*' event
+        // should be logged.
+        collection = new LoggedCollection([m1, m2]);
+        collection = new LoggedCollection([m1, m2]);
+
+        m2.select();
+        expect(logger.entries.length).toBe(1);
+      });
+    });
+
+    describe('when a collection is replaced by another one and is not referenced by a variable any more, with model sharing enabled', function () {
+      var logger, Collection, LoggedCollection, m1, m2, collection;
+
+      beforeEach(function () {
+        logger = new Logger();
+
+        Collection = Backbone.Collection.extend({
+          model: Model,
+
+          initialize: function(models){
+            var multiSelect = new Backbone.Picky.MultiSelect(this, models);
+            _.extend(this, multiSelect);
+          }
+        });
+
+        LoggedCollection = Collection.extend({
+          initialize: function(models){
+            this.on("select:none", function () {
+              logger.log( "select:none event fired in selected in collection " + this._pickyCid );
+            });
+            this.on("select:some", function () {
+              logger.log( "select:some event fired in selected in collection " + this._pickyCid );
+            });
+            this.on("select:all", function () {
+              logger.log( "select:all event fired in selected in collection " + this._pickyCid );
+            });
+
+            Collection.prototype.initialize.call(this, models);
+          }
+        });
+
+        m1 = new Model();
+        m2 = new Model();
+      });
+
+      it('should no longer respond to model events after calling close on it', function () {
+        // With only variable holding a collection, only one 'select:*' event
+        // should be logged.
+        collection = new LoggedCollection([m1, m2]);
+        collection.close();
+        collection = new LoggedCollection([m1, m2]);
+
+        m2.select();
+        expect(logger.entries.length).toBe(1);
+      });
+    });
+
+  });
+
 });
diff --git a/spec/javascripts/multiSelect.selectable.interaction.spec.js b/spec/javascripts/multiSelect.selectable.interaction.spec.js
index 9fbc761..f551dd4 100644
--- a/spec/javascripts/multiSelect.selectable.interaction.spec.js
+++ b/spec/javascripts/multiSelect.selectable.interaction.spec.js
@@ -48,6 +48,37 @@ describe("multi-select selectable interaction", function(){
 
     });
 
+    describe("when 1 out of 2 models in a collection is selected, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select({silent: true});
+      });
+
+      it("should not trigger 'some' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+      });
+
+      it("should have a selected count of 1", function(){
+        expect(collection.selectedLength).toBe(1);
+      });
+
+      it("should have the selected model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it("should not have the unselected model in the selected list", function(){
+        expect(collection.selected[m2.cid]).toBeUndefined();
+      });
+
+    });
+
     describe("when 2 out of 2 models in a collection are selected", function(){
       var m1, m2, collection;
 
@@ -79,6 +110,37 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
+    describe("when 2 out of 2 models in a collection are selected, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select({silent: true});
+        m2.select({silent: true});
+      });
+
+      it("should not trigger 'all' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should have a selected count of 2", function(){
+        expect(collection.selectedLength).toBe(2);
+      });
+
+      it("should have the first selected model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it("should have the second selected model in the selected list", function(){
+        expect(collection.selected[m2.cid]).toBe(m2);
+      });
+    });
+
     describe("when a model is selected and then deselected", function(){
       var m1, collection;
 
@@ -113,6 +175,40 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
+    describe("when a model is selected and then deselected, with options.silent enabled", function(){
+      var m1, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+
+        collection = new Collection([m1]);
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select({silent: true});
+        m1.deselect({silent: true});
+      });
+
+      it("should not trigger 'none' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+      });
+
+      it("should not trigger 'selected' event with the selected model", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("selected", m1);
+      });
+
+      it("should not trigger 'deselected' event with the deselected model", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("deselected", m1);
+      });
+
+      it("should have a selected count of 0", function(){
+        expect(collection.selectedLength).toBe(0);
+      });
+
+      it("should not have the model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBeUndefined();
+      });
+    });
+
     describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the model's select", function(){
       var m1, m2, collection;
 
@@ -146,6 +242,39 @@ describe("multi-select selectable interaction", function(){
 
     });
 
+    describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the model's select, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m2.select({silent: true});
+      });
+
+      it("should not trigger 'all' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should have a selected count of 2", function(){
+        expect(collection.selectedLength).toBe(2);
+      });
+
+      it("should have the first selected model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it("should have the second selected model in the selected list", function(){
+        expect(collection.selected[m2.cid]).toBe(m2);
+      });
+
+    });
+
     describe("when all models are selected and deselecting one via the model's deselect", function(){
       var m1, m2, collection;
 
@@ -180,6 +309,40 @@ describe("multi-select selectable interaction", function(){
 
     });
 
+    describe("when all models are selected and deselecting one via the model's deselect, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+        m2.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.deselect({silent: true});
+      });
+
+      it("should not trigger 'some' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+      });
+
+      it("should have a selected count of 1", function(){
+        expect(collection.selectedLength).toBe(1);
+      });
+
+      it("should not have the first selected model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBeUndefined();
+      });
+
+      it("should have the second selected model in the selected list", function(){
+        expect(collection.selected[m2.cid]).toBe(m2);
+      });
+
+    });
+
     describe("when 1 out of 2 models in a collection is selected, and deselecting the last one via the model's deselect", function(){
       var m1, m2, collection;
 
@@ -209,6 +372,35 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
+    describe("when 1 out of 2 models in a collection is selected, and deselecting the last one via the model's deselect, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.deselect({silent: true});
+      });
+
+      it("should not trigger 'none' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+      });
+
+      it("should have a selected count of 0", function(){
+        expect(collection.selectedLength).toBe(0);
+      });
+
+      it("should not have any models in the selected list", function(){
+        var size = _.size(collection.selected);
+        expect(size).toBe(0);
+      });
+    });
+
   });
 
   describe("select / deselect through the collection", function(){
@@ -280,6 +472,39 @@ describe("multi-select selectable interaction", function(){
 
     });
 
+    describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the collection's select, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.select(m2, {silent: true});
+      });
+
+      it("should not trigger 'all' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should have a selected count of 2", function(){
+        expect(collection.selectedLength).toBe(2);
+      });
+
+      it("should have the first selected model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it("should have the second selected model in the selected list", function(){
+        expect(collection.selected[m2.cid]).toBe(m2);
+      });
+
+    });
+
     describe("when all models are selected and deselecting one via the collection's deselect", function(){
       var m1, m2, collection;
 
@@ -314,6 +539,40 @@ describe("multi-select selectable interaction", function(){
 
     });
 
+    describe("when all models are selected and deselecting one via the collection's deselect, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+        collection.select(m2);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.deselect(m1, {silent: true});
+      });
+
+      it("should not trigger 'some' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+      });
+
+      it("should have a selected count of 1", function(){
+        expect(collection.selectedLength).toBe(1);
+      });
+
+      it("should not have the first selected model in the selected list", function(){
+        expect(collection.selected[m1.cid]).toBeUndefined();
+      });
+
+      it("should have the second selected model in the selected list", function(){
+        expect(collection.selected[m2.cid]).toBe(m2);
+      });
+
+    });
+
     describe("when 1 out of 2 models in a collection is selected, and deselecting the last one via the collection's deselect", function(){
       var m1, m2, collection;
 
@@ -343,6 +602,35 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
+    describe("when 1 out of 2 models in a collection is selected, and deselecting the last one via the collection's deselect, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.deselect(m1, {silent: true});
+      });
+
+      it("should not trigger 'none' selected event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+      });
+
+      it("should have a selected count of 0", function(){
+        expect(collection.selectedLength).toBe(0);
+      });
+
+      it("should not have any models in the selected list", function(){
+        var size = _.size(collection.selected);
+        expect(size).toBe(0);
+      });
+    });
+
   });
 
 });
diff --git a/spec/javascripts/multiSelect.toggle.spec.js b/spec/javascripts/multiSelect.toggle.spec.js
index 7e1b06e..f848a38 100644
--- a/spec/javascripts/multiSelect.toggle.spec.js
+++ b/spec/javascripts/multiSelect.toggle.spec.js
@@ -42,6 +42,33 @@ describe("multi-select collection toggle", function(){
     });
   });
   
+  describe("when no models are selected, and toggling with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      spyOn(collection, "trigger").andCallThrough();
+
+      collection.toggleSelectAll({silent: true});
+    });
+
+    it("should not trigger 'all' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+    });
+
+    it("should have a selected count of 2", function(){
+      expect(collection.selectedLength).toBe(2);
+    });
+
+    it("should have 2 models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(2);
+    });
+  });
+
   describe("when some models are selected, and toggling", function(){
     var m1, m2, collection;
 
@@ -101,4 +128,34 @@ describe("multi-select collection toggle", function(){
     });
   });
 
+  describe("when all models are selected, and toggling with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+
+      collection = new Collection([m1, m2]);
+      m1.select();
+      m2.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+
+      collection.toggleSelectAll({silent: true});
+    });
+
+    it("should not trigger 'none' selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+    });
+
+    it("should have a selected count of 0", function(){
+      expect(collection.selectedLength).toBe(0);
+    });
+
+    it("should have 0 models in the selected list", function(){
+      var size = _.size(collection.selected);
+      expect(size).toBe(0);
+    });
+  });
+
 });
diff --git a/spec/javascripts/multiple.collections.spec.js b/spec/javascripts/multiple.collections.spec.js
index 238ca84..1b42ab4 100644
--- a/spec/javascripts/multiple.collections.spec.js
+++ b/spec/javascripts/multiple.collections.spec.js
@@ -35,6 +35,11 @@ describe("models shared between multiple collections", function(){
       singleCollectionB = new SingleSelectCollection([model]);
       multiCollectionA  = new MultiSelectCollection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       singleCollectionA.select(model);
     });
 
@@ -53,6 +58,22 @@ describe("models shared between multiple collections", function(){
     it("should be selected itself", function(){
       expect(model.selected).toBe(true);
     });
+
+    it('should trigger a selected event on the model', function () {
+      expect(model.trigger).toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when selecting a model in a single-select collection, with options.silent enabled", function(){
@@ -64,6 +85,11 @@ describe("models shared between multiple collections", function(){
       singleCollectionB = new SingleSelectCollection([model]);
       multiCollectionA  = new MultiSelectCollection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       singleCollectionA.select(model, {silent: true});
     });
 
@@ -74,6 +100,23 @@ describe("models shared between multiple collections", function(){
     it("should be among the selected models in another multi-select collection", function(){
       expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
     });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should not trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should not trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when selecting a model in a multi-select collection", function(){
@@ -85,6 +128,11 @@ describe("models shared between multiple collections", function(){
       multiCollectionA  = new MultiSelectCollection([model]);
       multiCollectionB  = new MultiSelectCollection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionB, "trigger").andCallThrough();
+
       multiCollectionA.select(model);
     });
 
@@ -103,6 +151,22 @@ describe("models shared between multiple collections", function(){
     it("should be selected itself", function(){
       expect(model.selected).toBe(true);
     });
+
+    it('should trigger a selected event on the model', function () {
+      expect(model.trigger).toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should trigger a select:some or selected:all event on the originating collection', function () {
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionB.trigger).toHaveBeenCalledWith("select:all", multiCollectionB);
+    });
   });
 
   describe("when selecting a model in a multi-select collection, with options.silent enabled", function(){
@@ -114,6 +178,11 @@ describe("models shared between multiple collections", function(){
       multiCollectionA  = new MultiSelectCollection([model]);
       multiCollectionB  = new MultiSelectCollection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionB, "trigger").andCallThrough();
+
       multiCollectionA.select(model, {silent: true});
     });
 
@@ -124,6 +193,24 @@ describe("models shared between multiple collections", function(){
     it("should be among the selected models in another multi-select collection", function(){
       expect(multiCollectionB.selected[model.cid]).not.toBeUndefined();
     });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should not trigger a select:some or selected:all event on the originating collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should not trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionB);
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionB);
+    });
   });
 
   describe("when selecting a model, which is shared across collections, with its select method", function(){
@@ -134,6 +221,10 @@ describe("models shared between multiple collections", function(){
       singleCollectionA = new SingleSelectCollection([model]);
       multiCollectionA  = new MultiSelectCollection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       model.select();
     });
 
@@ -148,6 +239,18 @@ describe("models shared between multiple collections", function(){
     it("should be selected itself", function(){
       expect(model.selected).toBe(true);
     });
+
+    it('should trigger a selected event on the model', function () {
+      expect(model.trigger).toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should trigger a select:one event on the single-select collection', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should trigger a select:some or selected:all event on the multi-select collection', function () {
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when selecting a model, which is shared across collections, with its select method and options.silent enabled", function(){
@@ -158,6 +261,10 @@ describe("models shared between multiple collections", function(){
       singleCollectionA = new SingleSelectCollection([model]);
       multiCollectionA  = new MultiSelectCollection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       model.select({silent: true});
     });
 
@@ -168,18 +275,68 @@ describe("models shared between multiple collections", function(){
     it("should be among the selected models in a multi-select collection", function(){
       expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
     });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should not trigger a select:one event on the single-select collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should not trigger a select:some or selected:all event on the multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when creating additional collections with a model that is already selected", function(){
-    var model, singleCollectionA, singleCollectionB, multiCollectionA;
+    var logger, LoggedSingleSelectCollection, LoggedMultiSelectCollection,
+        model, singleCollectionA, singleCollectionB, multiCollectionA;
 
     beforeEach(function(){
+      logger = new Logger();
+
+      // Always create a `var logger = new Logger();` before instantiating LoggedSingleSelectCollection
+      LoggedSingleSelectCollection = SingleSelectCollection.extend({
+        initialize: function(models){
+          this.on("select:one", function (model) {
+            logger.log( "select:one event: Model " + model.cid + " selected in collection " + this._pickyCid );
+          });
+          this.on("deselect:one", function (model) {
+            logger.log( "deselect:one event: Model " + model.cid + " deselected in collection " + this._pickyCid );
+          });
+
+          SingleSelectCollection.prototype.initialize.call(this, models);
+        }
+      });
+
+      // Always create a `var logger = new Logger();` before instantiating LoggedMultiSelectCollection
+      LoggedMultiSelectCollection = MultiSelectCollection.extend({
+        initialize: function(models){
+          this.on("select:none", function () {
+            logger.log( "select:none event fired in selected in collection " + this._pickyCid );
+          });
+          this.on("select:some", function () {
+            logger.log( "select:some event fired in selected in collection " + this._pickyCid );
+          });
+          this.on("select:all", function () {
+            logger.log( "select:all event fired in selected in collection " + this._pickyCid );
+          });
+
+          MultiSelectCollection.prototype.initialize.call(this, models);
+        }
+      });
+
       model = new Model();
       singleCollectionA = new SingleSelectCollection([model]);
       singleCollectionA.select(model);
 
-      singleCollectionB = new SingleSelectCollection([model]);
-      multiCollectionA  = new MultiSelectCollection([model]);
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+
+      singleCollectionB = new LoggedSingleSelectCollection([model]);
+      multiCollectionA  = new LoggedMultiSelectCollection([model]);
     });
 
     it("should remain selected in the originating collection", function(){
@@ -197,6 +354,26 @@ describe("models shared between multiple collections", function(){
     it("should remain selected itself", function(){
       expect(model.selected).toBe(true);
     });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should not trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should not trigger a select:one, select:some or select:all events on a collections it is added to', function () {
+      // That is because
+      //
+      // - the initialize method of a collection is called before the models are
+      //   added to it, so it would be too early to fire select:* events
+      // - the models are added with a silent reset, so there is nothing to
+      //   listen to when the addition is done.
+      //
+      // These events, if they occurred, would be captured by the logger.
+      expect(logger.entries.length).toEqual(0);
+    });
   });
 
   describe("when re-selecting a model shared across collections", function(){
@@ -208,6 +385,11 @@ describe("models shared between multiple collections", function(){
       multiCollectionA  = new MultiSelectCollection([model]);
 
       singleCollectionA.select(model);
+
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       model.select();
     });
 
@@ -222,6 +404,19 @@ describe("models shared between multiple collections", function(){
     it("should remain selected itself", function(){
       expect(model.selected).toBe(true);
     });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it('should not trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when re-selecting a model, which is shared across collections, in a single-select collection", function(){
@@ -236,6 +431,10 @@ describe("models shared between multiple collections", function(){
       multiCollectionA.select(model2);
       multiCollectionA.select(model1);
 
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       singleCollectionA.select(model1);
     });
 
@@ -243,6 +442,18 @@ describe("models shared between multiple collections", function(){
       expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
     });
 
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when a model is already selected and a different model is selected in a single-select collection", function(){
@@ -257,6 +468,13 @@ describe("models shared between multiple collections", function(){
       multiCollectionA  = new MultiSelectCollection([model1, model2]);
 
       model1.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(model2, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       singleCollectionA.select(model2);
     });
 
@@ -283,6 +501,34 @@ describe("models shared between multiple collections", function(){
     it("should deselect the first model in another multi-select collection", function(){
       expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
     });
+
+    it('should trigger a selected event on the selected model', function () {
+      expect(model2.trigger).toHaveBeenCalledWith("selected", model2);
+    });
+
+    it('should trigger a deselected event on the first model', function () {
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a deselect:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model2);
+    });
+
+    it('should trigger a deselect:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).toHaveBeenCalledWith("select:one", model2);
+    });
+
+    it('should trigger a select:some event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
+    });
   });
 
   describe("when a model is already selected and a different model is selected with its select method", function(){
@@ -298,6 +544,11 @@ describe("models shared between multiple collections", function(){
         multiCollectionB  = new MultiSelectCollection([model1, model2]);
 
         model1.select();
+
+        spyOn(model1, "trigger").andCallThrough();
+        spyOn(model2, "trigger").andCallThrough();
+        spyOn(multiCollectionA, "trigger").andCallThrough();
+
         model2.select();
       });
 
@@ -310,6 +561,22 @@ describe("models shared between multiple collections", function(){
        expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
        expect(multiCollectionB.selected[model1.cid]).not.toBeUndefined();
      });
+
+      it('should not trigger a selected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+      });
+
+      it('should not trigger a deselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      });
+
+      it('should trigger a selected event on the second model', function () {
+        expect(model2.trigger).toHaveBeenCalledWith("selected", model2);
+      });
+
+      it('should trigger a select:some or selected:all event on a multi-select collection', function () {
+        expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+      });
     });
 
     describe("when both models are shared, with at least one single-select collection among the collections", function() {
@@ -325,6 +592,12 @@ describe("models shared between multiple collections", function(){
         multiCollectionA  = new MultiSelectCollection([model1, model2]);
 
         model1.select();
+
+        spyOn(model1, "trigger").andCallThrough();
+        spyOn(model2, "trigger").andCallThrough();
+        spyOn(singleCollectionA, "trigger").andCallThrough();
+        spyOn(multiCollectionA, "trigger").andCallThrough();
+
         model2.select();
       });
 
@@ -343,6 +616,30 @@ describe("models shared between multiple collections", function(){
       it("should deselect the first model in the multi-select collection", function(){
         expect(multiCollectionA.selected[model1.cid]).toBeUndefined();
       });
+
+      it('should not trigger a selected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+      });
+
+      it('should trigger a deselected event on the first model', function () {
+        expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+      });
+
+      it('should trigger a selected event on the second model', function () {
+        expect(model2.trigger).toHaveBeenCalledWith("selected", model2);
+      });
+
+      it('should trigger a deselect:one event on the single-select collection', function () {
+        expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
+      });
+
+      it('should trigger a select:one event on the single-select collection', function () {
+        expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model2);
+      });
+
+      it('should trigger a select:some event on the multi-select collection', function () {
+        expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
+      });
     });
 
     describe("when the first model is shared with at least one single-select collection, but not the second", function() {
@@ -356,6 +653,12 @@ describe("models shared between multiple collections", function(){
         multiCollectionA  = new MultiSelectCollection([model1, model2]);
 
         model1.select();
+
+        spyOn(model1, "trigger").andCallThrough();
+        spyOn(model2, "trigger").andCallThrough();
+        spyOn(singleCollectionA, "trigger").andCallThrough();
+        spyOn(multiCollectionA, "trigger").andCallThrough();
+
         model2.select();
       });
 
@@ -378,6 +681,30 @@ describe("models shared between multiple collections", function(){
       it("should leave the first model selected in the multi-select collection", function(){
         expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
       });
+
+      it('should not trigger a selected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+      });
+
+      it('should not trigger a deselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      });
+
+      it('should trigger a selected event on the second model', function () {
+        expect(model2.trigger).toHaveBeenCalledWith("selected", model2);
+      });
+
+      it('should not trigger a deselect:one event on the single-select collection', function () {
+        expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
+      });
+
+      it('should not trigger a select:one event on the single-select collection', function () {
+        expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model2);
+      });
+
+      it('should trigger a select:some or select:all event on the multi-select collection', function () {
+        expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+      });
     });
 
     describe("when the second model is shared with at least one single-select collection, but not the first", function() {
@@ -392,6 +719,12 @@ describe("models shared between multiple collections", function(){
         multiCollectionA  = new MultiSelectCollection([model1, model2]);
 
         model1.select();
+
+        spyOn(model1, "trigger").andCallThrough();
+        spyOn(model2, "trigger").andCallThrough();
+        spyOn(singleCollectionA, "trigger").andCallThrough();
+        spyOn(multiCollectionA, "trigger").andCallThrough();
+
         model2.select();
       });
 
@@ -414,6 +747,26 @@ describe("models shared between multiple collections", function(){
       it("should leave the first model selected in the multi-select collection", function(){
         expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
       });
+
+      it('should not trigger a selected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+      });
+
+      it('should not trigger a deselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+      });
+
+      it('should trigger a selected event on the second model', function () {
+        expect(model2.trigger).toHaveBeenCalledWith("selected", model2);
+      });
+
+      it('should trigger a select:one event on the single-select collection', function () {
+        expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model2);
+      });
+
+      it('should trigger a select:some or select:all event on the multi-select collection', function () {
+        expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+      });
     });
   });
 
@@ -430,6 +783,12 @@ describe("models shared between multiple collections", function(){
       multiCollectionA.select(model2);
       singleCollectionA.select(model1);
 
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(model2, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
       singleCollectionA.deselect();
     });
 
@@ -452,6 +811,26 @@ describe("models shared between multiple collections", function(){
     it("should be deselected itself", function(){
       expect(model1.selected).toBe(false);
     });
+
+    it('should trigger a deselected event on the model', function () {
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a selected event on another selected model in a multi-select collection', function () {
+      expect(model2.trigger).not.toHaveBeenCalledWith("deselected", model2);
+    });
+
+    it('should trigger a deselect:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a deselect:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:some or selected:none event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
+    });
   });
 
   describe("when a selected model is deselected in a multi-select collection", function(){
@@ -468,6 +847,12 @@ describe("models shared between multiple collections", function(){
       multiCollectionA.select(model2);
       multiCollectionA.select(model1);
 
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(model2, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionB, "trigger").andCallThrough();
+
       multiCollectionA.deselect(model1);
     });
 
@@ -494,11 +879,31 @@ describe("models shared between multiple collections", function(){
     it("should not deselect another selected model which is shared between a multi-select collection and a single-select collection", function () {
       expect(singleCollectionB.selected).toBe(model2);
     });
+
+    it('should trigger a deselected event on the model', function () {
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a deselected event on another selected model in a multi-select collection', function () {
+      expect(model2.trigger).not.toHaveBeenCalledWith("deselected", model2);
+    });
+
+     it('should trigger a select:some or select:none event on the originating collection', function () {
+       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
+    });
+
+    it('should trigger a deselect:one event on a single-select collection sharing the model', function () {
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:some or selected:none event on another multi-select collection', function () {
+      expect(multiCollectionB.trigger).toHaveBeenCalledWith("select:some", multiCollectionB);
+    });
   });
 
   describe("when a selected model is added", function(){
-    var model1, model2, model3, model4,
-        singleCollectionA, multiCollectionA;
+    var model1, model2, model3, model4, model5,
+        singleCollectionA, singleCollectionB, multiCollectionA;
 
     beforeEach(function(){
       model1 = new Model();
@@ -513,6 +918,13 @@ describe("models shared between multiple collections", function(){
       model2.select();
       model3.select();
       model4.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(model2, "trigger").andCallThrough();
+      spyOn(model3, "trigger").andCallThrough();
+      spyOn(model4, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
     });
 
     it("should be selected in a single-select collection it is added to", function(){
@@ -544,6 +956,59 @@ describe("models shared between multiple collections", function(){
       singleCollectionA.add(model2);
       expect(model2.selected).toBe(true);
     });
+
+    it('should not trigger a selected event on the model when added to a single-select collection', function () {
+      singleCollectionA.add(model2);
+      expect(model2.trigger).not.toHaveBeenCalledWith("selected", model2);
+    });
+
+    it('should not trigger a selected event on the model when added to a multi-select collection', function () {
+      multiCollectionA.add(model4);
+      expect(model4.trigger).not.toHaveBeenCalledWith("selected", model4);
+    });
+
+    it('should trigger a deselected event on the previously selected model when added to a single-select collection', function () {
+      singleCollectionA.add(model2);
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a deselected event on a previously selected model when added to a multi-select collection, as long as old and new models are not shared with a single-select collection', function () {
+      // ... in which case only one of them can remain selected, of course. See test below.
+      multiCollectionA.add(model4);
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a select:one event when added to a single-select collection', function () {
+      singleCollectionA.add(model2);
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("select:one", model2);
+    });
+
+    it('should trigger a deselect:one event when added to a single-select collection', function () {
+      singleCollectionA.add(model2);
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:some/select:all event when added to a multi-select collection', function () {
+      multiCollectionA.add(model4);
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should trigger a select:some or select:none event when the addition is inducing a deselection in another multi-select collection', function () {
+      singleCollectionA.add(model2);
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
+    });
+
+    it('should not trigger a select:all, select:some or select:none event when the addition does not deselect a model in another multi-select collection', function () {
+      model5 = new Model();
+      singleCollectionB = new SingleSelectCollection([model5]);
+      model5.select();
+
+      singleCollectionB.add(model2);
+
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:none", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when a selected model is removed", function(){
@@ -558,6 +1023,11 @@ describe("models shared between multiple collections", function(){
       multiCollectionA  = new MultiSelectCollection([model1, model2]);
 
       model1.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(model2, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
     });
 
     it("should no longer be selected in a single-select collection", function(){
@@ -601,6 +1071,51 @@ describe("models shared between multiple collections", function(){
       singleCollectionA.remove(model1);
       expect(model1.selected).toBe(true);
     });
+
+    it('should not trigger a deselected event on the model when it is still part of another collection (removed from single-select)', function () {
+      singleCollectionA.remove(model1);
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a deselected event on the model when it is still part of another collection (removed from multi-select)', function () {
+      multiCollectionA.remove(model1);
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a deselected event on the model when removed from all collections (single-select collection last)', function () {
+      multiCollectionA.remove(model1);
+      singleCollectionA.remove(model1);
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a deselected event on the model when removed from all collections (multi-select collection last)', function () {
+      singleCollectionA.remove(model1);
+      multiCollectionA.remove(model1);
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a deselect:one event on a single-select collection it is removed from', function () {
+      singleCollectionA.remove(model1);
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:some or select:none event on a multi-select collection it is removed from', function () {
+      multiCollectionA.remove(model1);
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:none", multiCollectionA);
+    });
+
+    it('should not trigger a deselect:one or select:one event on a single-select collection it remains part of', function () {
+      multiCollectionA.remove(model1);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:none, select:some or select:all event on a multi-select collection it remains part of', function () {
+      singleCollectionA.remove(model1);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:none", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
   });
 
   describe("when a selected model is added by resetting the collection", function(){
@@ -683,25 +1198,42 @@ describe("models shared between multiple collections", function(){
       expect(multiCollectionA.selected).toEqual({});
     });
 
-    it('should not trigger a selected/select:one event when added to a single-select collection', function () {
+    it('should not trigger a selected event on the model (added to a single-select collection)', function () {
+      singleCollectionA.reset([model1]);
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a selected event on the model (added to a multi-select collection)', function () {
+      multiCollectionA.reset([model1]);
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:one event when added to a single-select collection', function () {
       // reset() is meant to suppress individual notifications. Just like the add event, selection events are silenced.
       // Whatever needs to be done, should be dealt with in the reset event handler.
       singleCollectionA.reset([model1]);
-      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
     });
 
-    it('should not trigger a selected/select:some/select:all event when added to a multi-select collection', function () {
+    it('should not trigger a select:some or select:all event when added to a multi-select collection', function () {
       // For the rationale, see above.
       multiCollectionA.reset([model1]);
-      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
     });
 
-    it('should trigger a deselected/select:some event when the reset is inducing a deselection in another multi-select collection', function () {
+    it('should trigger a deselected event on a different model when the reset is inducing a deselection in another multi-select collection', function () {
+      singleCollectionA.reset([model1, model2]);
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a deselect:one event when added to a singe-select collection, even if multiple models with selected status are added, and all but the last one are deselected', function () {
+      singleCollectionA.reset([model1, model2]);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
+    });
+
+    it('should trigger a select:some or select:none event when the reset is inducing a deselection in another multi-select collection', function () {
       singleCollectionA.reset([model1, model2]);
-      expect(model2.trigger).not.toHaveBeenCalledWith("deselected", model1);
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
     });
 
@@ -760,36 +1292,52 @@ describe("models shared between multiple collections", function(){
       expect(model1.selected).toBe(true);
     });
 
-    it('should not trigger a deselected/deselect:one event when removed from a single-select collection', function () {
+    it('should not trigger a deselected event on the model when it is still part of another collection (removed from single-select)', function () {
+      singleCollectionA.reset();
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a deselected event on the model when it is still part of another collection (removed from multi-select)', function () {
+      multiCollectionA.reset();
+      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a deselected event on the model when removed from all collections (single-select collection last)', function () {
+      multiCollectionA.reset();
+      singleCollectionA.reset();
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should trigger a deselected event on the model when removed from all collections (multi-select collection last)', function () {
+      singleCollectionA.reset();
+      multiCollectionA.reset();
+      expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
+    });
+
+    it('should not trigger a deselect:one event when removed from a single-select collection', function () {
       // reset() is meant to suppress individual notifications. Just like the add event, selection events are silenced.
       // Whatever needs to be done, should be dealt with in the reset event handler.
       singleCollectionA.reset();
-      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
     });
 
-    it('should not trigger a deselected/select:none event when removed from a multi-select collection', function () {
+    it('should not trigger a select:none event when removed from a multi-select collection', function () {
       // For the rationale, see above.
       multiCollectionA.reset();
-      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
-      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model2);
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:none", multiCollectionA);
     });
 
-    it('should not trigger a deselected/deselect:one event when removed from all collections, single-select collection last', function () {
+    it('should not trigger a deselect:one event when removed from all collections, single-select collection last', function () {
       // See above.
       multiCollectionA.reset();
       singleCollectionA.reset();
-      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
     });
 
-    it('should not trigger a deselected/select:none event when removed from all collections, multi-select collection last', function () {
+    it('should not trigger a select:none event when removed from all collections, multi-select collection last', function () {
       // See above.
       singleCollectionA.reset();
       multiCollectionA.reset();
-      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model1);
-      expect(model1.trigger).not.toHaveBeenCalledWith("deselected", model2);
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:none", multiCollectionA);
     });
   });
diff --git a/spec/javascripts/selectable.spec.js b/spec/javascripts/selectable.spec.js
index 6b55def..93ed8dc 100644
--- a/spec/javascripts/selectable.spec.js
+++ b/spec/javascripts/selectable.spec.js
@@ -25,6 +25,25 @@ describe("selectable model", function(){
     });
   });
 
+  describe("when selecting a model, with options.silent enabled", function(){
+    var model;
+
+    beforeEach(function(){
+      model = new Model();
+      spyOn(model, "trigger").andCallThrough();
+
+      model.select({silent: true});
+    });
+
+    it("should be selected", function(){
+      expect(model.selected).toBe(true);
+    });
+
+    it("should not notify of selection", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+  });
+
   describe("when selecting a model that is already selected", function(){
     var model;
 
@@ -65,6 +84,26 @@ describe("selectable model", function(){
     });
   });
 
+  describe("when deselecting a model that has been selected, with options.silent enabled", function(){
+    var model;
+
+    beforeEach(function(){
+      model = new Model();
+      model.select();
+
+      spyOn(model, "trigger").andCallThrough();
+      model.deselect({silent: true});
+    });
+
+    it("should not be selected", function(){
+      expect(model.selected).toBe(false);
+    });
+
+    it("should not notify of deselection", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("deselected", model);
+    });
+  });
+
   describe("when deselecting a model that is not selected", function(){
     var model;
 
diff --git a/spec/javascripts/singleSelect.spec.js b/spec/javascripts/singleSelect.spec.js
index 1a966bb..991ddd4 100644
--- a/spec/javascripts/singleSelect.spec.js
+++ b/spec/javascripts/singleSelect.spec.js
@@ -42,6 +42,32 @@ describe("single select collection", function(){
     });
   });
 
+  describe("when selecting a model via the model's select, with options.silent enabled", function(){
+    var model, collection;
+
+    beforeEach(function(){
+      model = new Model();
+      collection = new Collection([model]);
+
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(collection, "trigger").andCallThrough();
+
+      model.select({silent: true});
+    });
+
+    it("should hang on to the currently selected model", function(){
+      expect(collection.selected).toBe(model);
+    });
+
+    it("should not trigger a selected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it("should not trigger a collection selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+  });
+
   describe("when selecting a model via the collection's select", function(){
     var model, collection;
 
@@ -68,6 +94,32 @@ describe("single select collection", function(){
     });
   });
 
+  describe("when selecting a model via the collection's select, with options.silent enabled", function(){
+    var model, collection;
+
+    beforeEach(function(){
+      model = new Model();
+      collection = new Collection([model]);
+
+      spyOn(collection, "trigger").andCallThrough();
+      spyOn(model, "select").andCallThrough();
+
+      collection.select(model, {silent: true});
+    });
+
+    it("should hang on to the currently selected model", function(){
+      expect(collection.selected).toBe(model);
+    });
+
+    it("should not trigger a selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:one", model);
+    });
+
+    it("should tell the model to select itself", function(){
+      expect(model.select).toHaveBeenCalled();
+    });
+  });
+
   describe("when selecting a model that is already selected", function(){
     var model, collection;
 
@@ -119,6 +171,38 @@ describe("single select collection", function(){
     });
   });
 
+  describe("when a model is already selected and selecting a different model, with options.silent enabled", function(){
+    var m1, m2, collection;
+
+    beforeEach(function(){
+      m1 = new Model();
+      m2 = new Model();
+      collection = new Collection([m1, m2]);
+      m1.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+      spyOn(m1, "deselect").andCallThrough();
+
+      m2.select({silent: true});
+    });
+
+    it("should hang on to the currently selected model", function(){
+      expect(collection.selected).toBe(m2);
+    });
+
+    it("should not trigger a selected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:one", m2);
+    });
+
+    it("should deselect the first model", function(){
+      expect(m1.deselect).toHaveBeenCalled();
+    });
+
+    it("should not fire a deselect event for the first model", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", m1);
+    });
+  });
+
   describe("when no model is selected and deselecting", function(){
     var collection;
 
@@ -157,6 +241,28 @@ describe("single select collection", function(){
     });
   });
 
+  describe("when a model is selected and deselecting the model, with options.silent enabled", function(){
+    var model, collection;
+
+    beforeEach(function(){
+      model = new Model();
+      collection = new Collection([model]);
+      model.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+
+      collection.deselect(undefined, {silent: true});
+    });
+
+    it("should not hang on to the currently selected model", function(){
+      expect(collection.selected).toBeUndefined();
+    });
+
+    it("should not trigger a deselected event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", model);
+    });
+  });
+
   describe("when one model is selected and deselecting another model through the collection's deselect", function(){
     var m1, m2, collection;
 
@@ -229,4 +335,84 @@ describe("single select collection", function(){
     });
   });
 
+  describe('Checking for memory leaks', function () {
+
+    describe('when a collection is replaced by another one and is not referenced by a variable any more, with model sharing disabled', function () {
+      var logger, LoggedCollection, m1, m2, collection;
+
+      beforeEach(function () {
+        logger = new Logger();
+
+        LoggedCollection = Collection.extend({
+          initialize: function(models){
+            this.on("select:one", function (model) {
+              logger.log( "select:one event: Model " + model.cid + " selected in collection " + this._pickyCid );
+            });
+            this.on("deselect:one", function (model) {
+              logger.log( "deselect:one event: Model " + model.cid + " deselected in collection " + this._pickyCid );
+            });
+
+            Collection.prototype.initialize.call(this, models);
+          }
+        });
+
+        m1 = new Model();
+        m2 = new Model();
+      });
+
+      it('should no longer respond to model events', function () {
+        // With only variable holding a collection, only one 'select:*' event
+        // should be logged.
+        collection = new LoggedCollection([m1, m2]);
+        collection = new LoggedCollection([m1, m2]);
+
+        m2.select();
+        expect(logger.entries.length).toBe(1);
+      });
+    });
+    describe('when a collection is replaced by another one and is not referenced by a variable any more, with model sharing enabled', function () {
+      var logger, Collection, LoggedCollection, m1, m2, collection;
+
+      beforeEach(function () {
+        logger = new Logger();
+        Collection = Backbone.Collection.extend({
+          model: Model,
+
+          initialize: function(models){
+            var singleSelect = new Backbone.Picky.SingleSelect(this, models);
+            _.extend(this, singleSelect);
+          }
+        });
+
+        LoggedCollection = Collection.extend({
+          initialize: function(models){
+            this.on("select:one", function (model) {
+              logger.log( "select:one event: Model " + model.cid + " selected in collection " + this._pickyCid );
+            });
+            this.on("deselect:one", function (model) {
+              logger.log( "deselect:one event: Model " + model.cid + " deselected in collection " + this._pickyCid );
+            });
+
+            Collection.prototype.initialize.call(this, models);
+          }
+        });
+
+        m1 = new Model();
+        m2 = new Model();
+      });
+
+      it('should no longer respond to model events after calling close on it', function () {
+        // With only variable holding a collection, only one 'select:*' event
+        // should be logged.
+        collection = new LoggedCollection([m1, m2]);
+        collection.close();
+        collection = new LoggedCollection([m1, m2]);
+
+        m2.select();
+        expect(logger.entries.length).toBe(1);
+      });
+    });
+
+  });
+
 });
diff --git a/spec/javascripts/support/jasmine.yml b/spec/javascripts/support/jasmine.yml
index 2526b95..abe8e6d 100644
--- a/spec/javascripts/support/jasmine.yml
+++ b/spec/javascripts/support/jasmine.yml
@@ -14,6 +14,7 @@ src_files:
     - public/javascripts/underscore.js
     - public/javascripts/backbone.js
     - src/backbone.picky.js
+    - spec/javascripts/helpers/*.js
     - src/**/*.js
 
 # stylesheets
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index 4763bdb..e1bd5fa 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -12,17 +12,23 @@ Backbone.Picky = (function (Backbone, _) {
     this._pickyCid = _.uniqueId('singleSelect-');
     this.collection = collection;
 
-    _.each(models || [], function (model) {
-      registerCollectionWithModel(model, this);
-      if (model.selected) this.selected = model;
-    }, this);
+    if (arguments.length > 1) {
 
-    this.collection.listenTo(this.collection, '_selected', this.select);
-    this.collection.listenTo(this.collection, '_deselected', this.deselect);
+      // 'models' argument provided, model-sharing mode
+      _.each(models || [], function (model) {
+        registerCollectionWithModel(model, this);
+        if (model.selected) this.selected = model;
+      }, this);
+
+      this.collection.listenTo(this.collection, '_selected', this.select);
+      this.collection.listenTo(this.collection, '_deselected', this.deselect);
+
+      this.collection.listenTo(this.collection, 'reset', onResetSingleSelect);
+      this.collection.listenTo(this.collection, 'add', onAdd);
+      this.collection.listenTo(this.collection, 'remove', onRemove);
+
+    }
 
-    this.collection.listenTo(this.collection, 'reset', onResetSingleSelect);
-    this.collection.listenTo(this.collection, 'add', onAdd);
-    this.collection.listenTo(this.collection, 'remove', onRemove);
   };
 
   _.extend(Picky.SingleSelect.prototype, {
@@ -33,11 +39,11 @@ Backbone.Picky = (function (Backbone, _) {
       options || (options = {});
       if (model && this.selected === model) { return; }
 
-      this.deselect(undefined, options);
+      this.deselect(undefined, _.omit(options, "_localSilent"));
 
       this.selected = model;
-      this.selected.select(options);
-      if (!options.silent) this.trigger("select:one", model);
+      this.selected.select(_.omit(options, "_localSilent"));
+      if (!(options.silent || options._localSilent)) this.trigger("select:one", model);
     },
 
     // Deselect a model, resulting in no model
@@ -49,9 +55,13 @@ Backbone.Picky = (function (Backbone, _) {
       model = model || this.selected;
       if (this.selected !== model){ return; }
 
-      if (!options._skipModelCall) this.selected.deselect(options);
-      if (!options.silent) this.trigger("deselect:one", this.selected);
+      if (!options._skipModelCall) this.selected.deselect(_.omit(options, "_localSilent"));
+      if (!(options.silent || options._localSilent)) this.trigger("deselect:one", this.selected);
       delete this.selected;
+    },
+
+    close: function () {
+      this.stopListening();
     }
 
   });
@@ -67,17 +77,23 @@ Backbone.Picky = (function (Backbone, _) {
     this.collection = collection;
     this.selected = {};
 
-    _.each(models || [], function (model) {
-      registerCollectionWithModel(model, this);
-      if (model.selected) this.selected[model.cid] = model;
-    }, this);
+    if (arguments.length > 1) {
+
+      // 'models' argument provided, model-sharing mode
+      _.each(models || [], function (model) {
+        registerCollectionWithModel(model, this);
+        if (model.selected) this.selected[model.cid] = model;
+      }, this);
+
+      this.collection.listenTo(this.collection, '_selected', this.select);
+      this.collection.listenTo(this.collection, '_deselected', this.deselect);
+
+      this.collection.listenTo(this.collection, 'reset', onResetMultiSelect);
+      this.collection.listenTo(this.collection, 'add', onAdd);
+      this.collection.listenTo(this.collection, 'remove', onRemove);
 
-    this.collection.listenTo(this.collection, '_selected', this.select);
-    this.collection.listenTo(this.collection, '_deselected', this.deselect);
+    }
 
-    this.collection.listenTo(this.collection, 'reset', onResetMultiSelect);
-    this.collection.listenTo(this.collection, 'add', onAdd);
-    this.collection.listenTo(this.collection, 'remove', onRemove);
   };
 
   _.extend(Picky.MultiSelect.prototype, {
@@ -89,7 +105,7 @@ Backbone.Picky = (function (Backbone, _) {
       if (this.selected[model.cid]) { return; }
 
       this.selected[model.cid] = model;
-      model.select(options);
+      model.select(_.omit(options, "_localSilent"));
       calculateSelectedLength(this, options);
     },
 
@@ -101,20 +117,20 @@ Backbone.Picky = (function (Backbone, _) {
       if (!this.selected[model.cid]) { return; }
 
       delete this.selected[model.cid];
-      if (!options._skipModelCall) model.deselect(options);
+      if (!options._skipModelCall) model.deselect(_.omit(options, "_localSilent"));
       calculateSelectedLength(this, options);
     },
 
     // Select all models in this collection
     selectAll: function (options) {
-      this.each(function (model) { model.select(options); });
+      this.each(function (model) { model.select(_.omit(options, "_localSilent")); });
       calculateSelectedLength(this, options);
     },
 
     // Deselect all models in this collection
     deselectAll: function (options) {
       if (this.selectedLength === 0) { return; }
-      this.each(function (model) { model.deselect(options); });
+      this.each(function (model) { model.deselect(_.omit(options, "_localSilent")); });
       calculateSelectedLength(this, options);
     },
 
@@ -131,6 +147,10 @@ Backbone.Picky = (function (Backbone, _) {
       } else {
         this.selectAll(options);
       }
+    },
+
+    close: function () {
+      this.stopListening();
     }
   });
 
@@ -152,8 +172,17 @@ Backbone.Picky = (function (Backbone, _) {
       if (this.selected) { return; }
 
       this.selected = true;
-      this.trigger("_selected", this);
-      if (!options.silent) this.trigger("selected", this);
+
+      if (this._pickyCollections) {
+        // Model-sharing mode: notify collections with an event
+        this.trigger("_selected", this, _.omit(options, "_localSilent"));
+      } else if (this.collection) {
+        // Single collection only: no event listeners set up in collection, call
+        // it directly
+        this.collection.select(this, _.omit(options, "_localSilent"));
+      }
+
+      if (!(options.silent || options._localSilent)) this.trigger("selected", this);
     },
 
     // Deselect this model, and tell our
@@ -163,8 +192,17 @@ Backbone.Picky = (function (Backbone, _) {
       if (!this.selected) { return; }
 
       this.selected = false;
-      this.trigger("_deselected", this);
-      if (!options.silent) this.trigger("deselected", this);
+
+      if (this._pickyCollections) {
+        // Model-sharing mode: notify collections with an event
+        this.trigger("_deselected", this, _.omit(options, "_localSilent"));
+      } else if (this.collection) {
+        // Single collection only: no event listeners set up in collection, call
+        // it directly
+        this.collection.deselect(this, _.omit(options, "_localSilent"));
+      }
+
+      if (!(options.silent || options._localSilent)) this.trigger("deselected", this);
     },
 
     // Change selected to the opposite of what
@@ -188,7 +226,7 @@ Backbone.Picky = (function (Backbone, _) {
     options || (options = {});
     collection.selectedLength = _.size(collection.selected);
 
-    if (options.silent) return;
+    if (options.silent || options._localSilent) return;
 
     var selectedLength = collection.selectedLength;
     var length = collection.length;
@@ -230,11 +268,11 @@ Backbone.Picky = (function (Backbone, _) {
         excessiveSelections,
         deselectOnRemove = _.find(options.previousModels, function (model) { return model.selected; });
 
-    if (deselectOnRemove) onRemove(deselectOnRemove, collection, {silent: true});
+    if (deselectOnRemove) onRemove(deselectOnRemove, collection, {_localSilent: true});
 
     selected = collection.filter(function (model) { return model.selected; });
     excessiveSelections = _.initial(selected);
-    if (excessiveSelections.length) _.each(excessiveSelections, function (model) { model.deselect({silent: true}); });
+    if (excessiveSelections.length) _.each(excessiveSelections, function (model) { model.deselect(); });
     if (selected.length) collection.select(_.last(selected), {silent: true});
   }
 
@@ -242,7 +280,7 @@ Backbone.Picky = (function (Backbone, _) {
     var select,
         deselect = _.filter(options.previousModels, function (model) { return model.selected; });
 
-    if (deselect) _.each(deselect, function (model) { onRemove(model, collection, {silent: true}); });
+    if (deselect) _.each(deselect, function (model) { onRemove(model, collection, {_localSilent: true}); });
 
     select = collection.filter(function (model) { return model.selected; });
     if (select.length) _.each(select, function (model) { collection.select(model, {silent: true}); });

From 74845c8b396e94e22fa3f12570ae3ec2152fe789 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Tue, 14 Jan 2014 00:38:48 +0100
Subject: [PATCH 13/18] Made events fire when model and collection states are
 consistent (fixing #18)

---
 spec/javascripts/multiSelect.deselect.spec.js |  52 +++++-
 spec/javascripts/multiSelect.select.spec.js   |  52 +++++-
 ...multiSelect.selectable.interaction.spec.js | 168 +++++++++++++++++-
 spec/javascripts/singleSelect.spec.js         | 156 +++++++++++++++-
 src/backbone.picky.js                         |  38 ++--
 5 files changed, 437 insertions(+), 29 deletions(-)

diff --git a/spec/javascripts/multiSelect.deselect.spec.js b/spec/javascripts/multiSelect.deselect.spec.js
index 8531b6f..2f8c907 100644
--- a/spec/javascripts/multiSelect.deselect.spec.js
+++ b/spec/javascripts/multiSelect.deselect.spec.js
@@ -154,9 +154,12 @@ describe("multi-select collection deselecting", function(){
   });
 
   describe("when all models are selected, and deselecting all", function(){
-    var m1, m2, collection;
+    var m1, m2, collection, selectedEventState, selectNoneEventState;
 
     beforeEach(function(){
+      selectedEventState = { model: {}, collection: {} };
+      selectNoneEventState = { m1: {}, m2: {}, collection: {} };
+
       m1 = new Model();
       m2 = new Model();
 
@@ -165,6 +168,20 @@ describe("multi-select collection deselecting", function(){
       m2.select();
 
       spyOn(collection, "trigger").andCallThrough();
+
+      m1.on('deselected', function (model) {
+        selectedEventState.model.selected = model && model.selected;
+        selectedEventState.collection.selected = _.clone(collection.selected);
+        selectedEventState.collection.selectedLength = collection.selectedLength;
+      });
+
+      collection.on('select:none', function () {
+        selectNoneEventState.m1.selected = m1.selected;
+        selectNoneEventState.m2.selected = m2.selected;
+        selectNoneEventState.collection.selected = _.clone(collection.selected);
+        selectNoneEventState.collection.selectedLength = collection.selectedLength;
+      });
+
       collection.deselectAll();
     });
     
@@ -180,6 +197,39 @@ describe("multi-select collection deselecting", function(){
       var size = _.size(collection.selected);
       expect(size).toBe(0);
     });
+
+    it('should trigger a model\'s deselected event after the model status has been updated', function () {
+      expect(selectedEventState.model.selected).toEqual(false);
+    });
+
+    it('should trigger a model\'s selected event after the collection\'s selected models have been updated with that model', function () {
+      // m2 doesn't necessarily have to be removed from collection.selected at
+      // this time. The point is that events are fired when model and collection
+      // states are consistent. When m1 fires the 'deselected' event, only m1
+      // must have been removed from the collection.
+      expect(selectedEventState.collection.selected[m1.cid]).toBeUndefined();
+    });
+
+    it('should trigger a model\'s selected event after the collection\'s selected length has been updated', function () {
+      // collection.selectedLength could be 0 or 1 at this time. Again, all we
+      // are asking for is consistency - see comment above.
+      expect(selectedEventState.collection.selectedLength).toBeLessThan(2);
+      expect(selectedEventState.collection.selectedLength).toEqual(_.size(selectedEventState.collection.selected));
+    });
+
+    it('should trigger the collection\'s select:none event after the model status has been updated', function () {
+      expect(selectNoneEventState.m1.selected).toEqual(false);
+      expect(selectNoneEventState.m2.selected).toEqual(false);
+    });
+
+    it('should trigger the collection\'s select:none event after the collection\'s selected models have been updated', function () {
+      expect(selectNoneEventState.collection.selected).toEqual({});
+    });
+
+    it('should trigger the collection\'s select:none event after the collection\'s selected length has been updated', function () {
+      expect(selectNoneEventState.collection.selectedLength).toBe(0);
+    });
+
   });
 
   describe("when all models are selected, and deselecting all (selectNone)", function(){
diff --git a/spec/javascripts/multiSelect.select.spec.js b/spec/javascripts/multiSelect.select.spec.js
index 49c0c50..f2c5faf 100644
--- a/spec/javascripts/multiSelect.select.spec.js
+++ b/spec/javascripts/multiSelect.select.spec.js
@@ -16,15 +16,31 @@ describe("multi-select collection selecting", function(){
   });
   
   describe("when no models are selected, and selecting all", function(){
-    var m1, m2, collection;
+    var m1, m2, collection, selectedEventState, selectAllEventState;
 
     beforeEach(function(){
+      selectedEventState = { model: {}, collection: {} };
+      selectAllEventState = { m1: {}, m2: {}, collection: {} };
+
       m1 = new Model();
       m2 = new Model();
 
       collection = new Collection([m1, m2]);
       spyOn(collection, "trigger").andCallThrough();
 
+      m1.on('selected', function (model) {
+        selectedEventState.model.selected = model && model.selected;
+        selectedEventState.collection.selected = _.clone(collection.selected);
+        selectedEventState.collection.selectedLength = collection.selectedLength;
+      });
+
+      collection.on('select:all', function () {
+        selectAllEventState.m1.selected = m1.selected;
+        selectAllEventState.m2.selected = m2.selected;
+        selectAllEventState.collection.selected = _.clone(collection.selected);
+        selectAllEventState.collection.selectedLength = collection.selectedLength;
+      });
+
       collection.selectAll();
     });
     
@@ -43,6 +59,40 @@ describe("multi-select collection selecting", function(){
     it("should have the second selected model in the selected list", function(){
       expect(collection.selected[m2.cid]).not.toBeUndefined();
     });
+
+    it('should trigger a model\'s selected event after the model status has been updated', function () {
+      expect(selectedEventState.model.selected).toEqual(true);
+    });
+
+    it('should trigger a model\'s selected event after the collection\'s selected models have been updated with that model', function () {
+      // m2 doesn't necessarily have to be part of collection.selected at this
+      // time. The point is that events are fired when model and collection
+      // states are consistent. When m1 fires the 'selected' event, only m1 must
+      // be part of the collection.
+      expect(selectedEventState.collection.selected[m1.cid]).toBe(m1);
+    });
+
+    it('should trigger a model\'s selected event after the collection\'s selected length has been updated', function () {
+      // collection.selectedLength could be 1 or 2 at this time. Again, all we
+      // are asking for is consistency - see comment above.
+      expect(selectedEventState.collection.selectedLength).toBeGreaterThan(0);
+      expect(selectedEventState.collection.selectedLength).toEqual(_.size(selectedEventState.collection.selected));
+    });
+
+    it('should trigger the collection\'s select:all event after the model status has been updated', function () {
+      expect(selectAllEventState.m1.selected).toEqual(true);
+      expect(selectAllEventState.m2.selected).toEqual(true);
+    });
+
+    it('should trigger the collection\'s select:all event after the collection\'s selected models have been updated', function () {
+      expect(selectAllEventState.collection.selected[m1.cid]).toBe(m1);
+      expect(selectAllEventState.collection.selected[m2.cid]).toBe(m2);
+    });
+
+    it('should trigger the collection\'s select:all event after the collection\'s selected length has been updated', function () {
+      expect(selectAllEventState.collection.selectedLength).toBe(2);
+    });
+
   });
 
   describe("when no models are selected, and selecting all, with options.silent enabled", function(){
diff --git a/spec/javascripts/multiSelect.selectable.interaction.spec.js b/spec/javascripts/multiSelect.selectable.interaction.spec.js
index f551dd4..772f718 100644
--- a/spec/javascripts/multiSelect.selectable.interaction.spec.js
+++ b/spec/javascripts/multiSelect.selectable.interaction.spec.js
@@ -18,15 +18,30 @@ describe("multi-select selectable interaction", function(){
   describe("select / deselect the model directly", function(){
 
     describe("when 1 out of 2 models in a collection is selected", function(){
-      var m1, m2, collection;
+      var m1, m2, collection, selectedEventState, selectSomeEventState;
 
       beforeEach(function(){
+        selectedEventState = { model: {}, collection: {} };
+        selectSomeEventState = { m1: {}, collection: {} };
+
         m1 = new Model();
         m2 = new Model();
 
         collection = new Collection([m1, m2]);
         spyOn(collection, "trigger").andCallThrough();
 
+        m1.on('selected', function (model) {
+          selectedEventState.model.selected = model.selected;
+          selectedEventState.collection.selected = _.clone(collection.selected);
+          selectedEventState.collection.selectedLength = collection.selectedLength;
+        });
+
+        collection.on('select:some', function () {
+          selectSomeEventState.m1.selected = m1.selected;
+          selectSomeEventState.collection.selected = _.clone(collection.selected);
+          selectSomeEventState.collection.selectedLength = collection.selectedLength;
+        });
+
         m1.select();
       });
 
@@ -46,6 +61,30 @@ describe("multi-select selectable interaction", function(){
         expect(collection.selected[m2.cid]).toBeUndefined();
       });
 
+      it('should trigger the model\'s selected event after the model status has been updated', function () {
+        expect(selectedEventState.model.selected).toEqual(true);
+      });
+
+      it('should trigger the model\'s selected event after the collection\'s selected models have been updated', function () {
+        expect(selectedEventState.collection.selected[m1.cid]).toEqual(m1);
+      });
+
+      it('should trigger the model\'s selected event after the collection\'s selected length has been updated', function () {
+        expect(selectedEventState.collection.selectedLength).toBe(1);
+      });
+
+      it('should trigger the collection\'s select:some event after the model status has been updated', function () {
+        expect(selectSomeEventState.m1.selected).toEqual(true);
+      });
+
+      it('should trigger the collection\'s select:some event after the collection\'s selected models have been updated', function () {
+        expect(selectSomeEventState.collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it('should trigger the collection\'s select:some event after the collection\'s selected length has been updated', function () {
+        expect(selectSomeEventState.collection.selectedLength).toBe(1);
+      });
+
     });
 
     describe("when 1 out of 2 models in a collection is selected, with options.silent enabled", function(){
@@ -142,15 +181,31 @@ describe("multi-select selectable interaction", function(){
     });
 
     describe("when a model is selected and then deselected", function(){
-      var m1, collection;
+      var m1, collection, selectedEventState, selectNoneEventState;
 
       beforeEach(function(){
+        selectedEventState = { model: {}, collection: {} };
+        selectNoneEventState = { m1: {}, collection: {} };
+
         m1 = new Model();
 
         collection = new Collection([m1]);
         spyOn(collection, "trigger").andCallThrough();
 
         m1.select();
+
+        m1.on('deselected', function (model) {
+          selectedEventState.model.selected = model && model.selected;
+          selectedEventState.collection.selected = _.clone(collection.selected);
+          selectedEventState.collection.selectedLength = collection.selectedLength;
+        });
+
+        collection.on('select:none', function () {
+          selectNoneEventState.m1.selected = m1.selected;
+          selectNoneEventState.collection.selected = _.clone(collection.selected);
+          selectNoneEventState.collection.selectedLength = collection.selectedLength;
+        });
+
         m1.deselect();
       });
 
@@ -173,6 +228,31 @@ describe("multi-select selectable interaction", function(){
       it("should not have the model in the selected list", function(){
         expect(collection.selected[m1.cid]).toBeUndefined();
       });
+
+      it('should trigger the model\'s deselected event after the model status has been updated', function () {
+        expect(selectedEventState.model.selected).toEqual(false);
+      });
+
+      it('should trigger the model\'s deselected event after the collection\'s selected models have been updated', function () {
+        expect(selectedEventState.collection.selected).toEqual({});
+      });
+
+      it('should trigger the model\'s deselected event after the collection\'s selected length has been updated', function () {
+        expect(selectedEventState.collection.selectedLength).toBe(0);
+      });
+
+      it('should trigger the collection\'s select:none event after the model status has been updated', function () {
+        expect(selectNoneEventState.m1.selected).toEqual(false);
+      });
+
+      it('should trigger the collection\'s select:none event after the collection\'s selected models have been updated', function () {
+        expect(selectNoneEventState.collection.selected).toEqual({});
+      });
+
+      it('should trigger the collection\'s select:none event after the collection\'s selected length has been updated', function () {
+        expect(selectNoneEventState.collection.selectedLength).toBe(0);
+      });
+
     });
 
     describe("when a model is selected and then deselected, with options.silent enabled", function(){
@@ -406,37 +486,117 @@ describe("multi-select selectable interaction", function(){
   describe("select / deselect through the collection", function(){
 
     describe("when selecting a model through the collection's select method", function(){
-      var m1, collection;
+      var m1, collection, selectedEventState, selectAllEventState;
 
       beforeEach(function(){
+        selectedEventState = { model: {}, collection: {} };
+        selectAllEventState = { m1: {}, collection: {} };
+
         m1 = new Model();
         spyOn(m1, "select").andCallThrough();
         collection = new Collection([m1]);
 
+        m1.on('selected', function (model) {
+          selectedEventState.model.selected = model && model.selected;
+          selectedEventState.collection.selected = _.clone(collection.selected);
+          selectedEventState.collection.selectedLength = collection.selectedLength;
+        });
+
+        collection.on('select:all', function () {
+          selectAllEventState.m1.selected = m1.selected;
+          selectAllEventState.collection.selected = _.clone(collection.selected);
+          selectAllEventState.collection.selectedLength = collection.selectedLength;
+        });
+
         collection.select(m1);
       });
 
       it("should select the model", function(){
         expect(m1.select).toHaveBeenCalled();
       });
+
+      it('should trigger the model\'s selected event after the model status has been updated', function () {
+        expect(selectedEventState.model.selected).toEqual(true);
+      });
+
+      it('should trigger the model\'s selected event after the collection\'s selected models have been updated', function () {
+        expect(selectedEventState.collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it('should trigger the model\'s selected event after the collection\'s selected length has been updated', function () {
+        expect(selectedEventState.collection.selectedLength).toBe(1);
+      });
+
+      it('should trigger the collection\'s select:all event after the model status has been updated', function () {
+        expect(selectAllEventState.m1.selected).toEqual(true);
+      });
+
+      it('should trigger the collection\'s select:all event after the collection\'s selected models have been updated', function () {
+        expect(selectAllEventState.collection.selected[m1.cid]).toBe(m1);
+      });
+
+      it('should trigger the collection\'s select:all event after the collection\'s selected length has been updated', function () {
+        expect(selectAllEventState.collection.selectedLength).toBe(1);
+      });
+
     });
 
     describe("when deselecting a model through the collection's select method", function(){
-      var m1, collection;
+      var m1, collection, selectedEventState, selectNoneEventState;
 
       beforeEach(function(){
+        selectedEventState = { model: {}, collection: {} };
+        selectNoneEventState = { m1: {}, collection: {} };
+
         m1 = new Model();
         spyOn(m1, "deselect").andCallThrough();
 
         collection = new Collection([m1]);
         m1.select();
 
+        m1.on('deselected', function (model) {
+          selectedEventState.model.selected = model && model.selected;
+          selectedEventState.collection.selected = _.clone(collection.selected);
+          selectedEventState.collection.selectedLength = collection.selectedLength;
+        });
+
+        collection.on('select:none', function () {
+          selectNoneEventState.m1.selected = m1.selected;
+          selectNoneEventState.collection.selected = _.clone(collection.selected);
+          selectNoneEventState.collection.selectedLength = collection.selectedLength;
+        });
+
         collection.deselect(m1);
       });
 
       it("should deselect the model", function(){
         expect(m1.deselect).toHaveBeenCalled();
       });
+
+      it('should trigger the model\'s deselected event after the model status has been updated', function () {
+        expect(selectedEventState.model.selected).toEqual(false);
+      });
+
+      it('should trigger the model\'s deselected event after the collection\'s selected models have been updated', function () {
+        expect(selectedEventState.collection.selected).toEqual({});
+      });
+
+      it('should trigger the model\'s deselected event after the collection\'s selected length has been updated', function () {
+        expect(selectedEventState.collection.selectedLength).toBe(0);
+      });
+
+      it('should trigger the collection\'s select:none event after the model status has been updated', function () {
+        expect(selectNoneEventState.m1.selected).toEqual(false);
+      });
+
+      it('should trigger the collection\'s select:none event after the collection\'s selected models have been updated', function () {
+        expect(selectNoneEventState.collection.selected).toEqual({});
+      });
+
+      it('should trigger the collection\'s select:none event after the collection\'s selected length has been updated', function () {
+        expect(selectNoneEventState.collection.selectedLength).toBe(0);
+      });
+
     });
 
     describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the collection's select", function(){
diff --git a/spec/javascripts/singleSelect.spec.js b/spec/javascripts/singleSelect.spec.js
index 991ddd4..959fd4c 100644
--- a/spec/javascripts/singleSelect.spec.js
+++ b/spec/javascripts/singleSelect.spec.js
@@ -17,15 +17,28 @@ describe("single select collection", function(){
   });
 
   describe("when selecting a model via the model's select", function(){
-    var model, collection;
+    var model, collection, selectedEventState, selectOneEventState;
 
     beforeEach(function(){
+      selectedEventState = { model: {}, collection: {} };
+      selectOneEventState = { model: {}, collection: {} };
+
       model = new Model();
       collection = new Collection([model]);
 
       spyOn(model, "trigger").andCallThrough();
       spyOn(collection, "trigger").andCallThrough();
 
+      model.on('selected', function (model) {
+        selectedEventState.model.selected = model && model.selected;
+        selectedEventState.collection.selected = collection.selected;
+      });
+
+      collection.on('select:one', function (model) {
+        selectOneEventState.model.selected = model && model.selected;
+        selectOneEventState.collection.selected = collection.selected;
+      });
+
       model.select();
     });
 
@@ -37,9 +50,25 @@ describe("single select collection", function(){
       expect(model.trigger).toHaveBeenCalledWith("selected", model);
     });
 
-    it("should trigger a collection selected event", function(){
+    it("should trigger a collection select:one event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:one", model);
     });
+
+    it('should trigger the model\'s selected event after the model status has been updated', function () {
+      expect(selectedEventState.model.selected).toEqual(true);
+    });
+
+    it('should trigger the model\'s selected event after the collection status has been updated', function () {
+      expect(selectedEventState.collection.selected).toBe(model);
+    });
+
+    it('should trigger the collection\'s select:one event after the model status has been updated', function () {
+      expect(selectOneEventState.model.selected).toEqual(true);
+    });
+
+    it('should trigger the collection\'s select:one event after the collection status has been updated', function () {
+      expect(selectOneEventState.collection.selected).toBe(model);
+    });
   });
 
   describe("when selecting a model via the model's select, with options.silent enabled", function(){
@@ -63,21 +92,34 @@ describe("single select collection", function(){
       expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
     });
 
-    it("should not trigger a collection selected event", function(){
+    it("should not trigger a collection select:one event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:one", model);
     });
   });
 
   describe("when selecting a model via the collection's select", function(){
-    var model, collection;
+    var model, collection, selectedEventState, selectOneEventState;
 
     beforeEach(function(){
+      selectedEventState = { model: {}, collection: {} };
+      selectOneEventState = { model: {}, collection: {} };
+
       model = new Model();
       collection = new Collection([model]);
 
       spyOn(collection, "trigger").andCallThrough();
       spyOn(model, "select").andCallThrough();
 
+      model.on('selected', function (model) {
+        selectedEventState.model.selected = model && model.selected;
+        selectedEventState.collection.selected = collection.selected;
+      });
+
+      collection.on('select:one', function (model) {
+        selectOneEventState.model.selected = model && model.selected;
+        selectOneEventState.collection.selected = collection.selected;
+      });
+
       collection.select(model);
     });
 
@@ -85,13 +127,29 @@ describe("single select collection", function(){
       expect(collection.selected).toBe(model);
     });
 
-    it("should trigger a selected event", function(){
+    it("should trigger a select:one event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:one", model);
     });
 
     it("should tell the model to select itself", function(){
       expect(model.select).toHaveBeenCalled();
     });
+
+    it('should trigger the model\'s selected event after the model status has been updated', function () {
+      expect(selectedEventState.model.selected).toEqual(true);
+    });
+
+    it('should trigger the model\'s selected event after the collection status has been updated', function () {
+      expect(selectedEventState.collection.selected).toBe(model);
+    });
+
+    it('should trigger the collection\'s select:one event after the model status has been updated', function () {
+      expect(selectOneEventState.model.selected).toEqual(true);
+    });
+
+    it('should trigger the collection\'s select:one event after the collection status has been updated', function () {
+      expect(selectOneEventState.collection.selected).toBe(model);
+    });
   });
 
   describe("when selecting a model via the collection's select, with options.silent enabled", function(){
@@ -111,7 +169,7 @@ describe("single select collection", function(){
       expect(collection.selected).toBe(model);
     });
 
-    it("should not trigger a selected event", function(){
+    it("should not trigger a select:one event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:one", model);
     });
 
@@ -219,16 +277,80 @@ describe("single select collection", function(){
     });
   });
 
-  describe("when a model is selected and deselecting the model", function(){
-    var model, collection;
+  describe("when a model is selected and deselecting the model through the model's deselect", function(){
+    var model, collection, deselectedEventState, deselectOneEventState;
 
     beforeEach(function(){
+      deselectedEventState = { model: {}, collection: {} };
+      deselectOneEventState = { model: {}, collection: {} };
+
       model = new Model();
       collection = new Collection([model]);
       model.select();
 
       spyOn(collection, "trigger").andCallThrough();
 
+      model.on('deselected', function (model) {
+        deselectedEventState.model.selected = model && model.selected;
+        deselectedEventState.collection.selected = collection.selected;
+      });
+
+      collection.on('deselect:one', function (model) {
+        deselectOneEventState.model.selected = model && model.selected;
+        deselectOneEventState.collection.selected = collection.selected;
+      });
+
+      model.deselect();
+    });
+
+    it("should not hang on to the currently selected model", function(){
+      expect(collection.selected).toBeUndefined();
+    });
+
+    it("should trigger a deselect:one event", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("deselect:one", model);
+    });
+
+    it('should trigger the model\'s deselected event after the model status has been updated', function () {
+      expect(deselectedEventState.model.selected).toEqual(false);
+    });
+
+    it('should trigger the model\'s deselected event after the collection status has been updated', function () {
+      expect(deselectedEventState.collection.selected).toBeUndefined();
+    });
+
+    it('should trigger the collection\'s deselect:one event after the model status has been updated', function () {
+      expect(deselectOneEventState.model.selected).toEqual(false);
+    });
+
+    it('should trigger the collection\'s deselect:one event after the collection status has been updated', function () {
+      expect(deselectOneEventState.collection.selected).toBeUndefined();
+    });
+  });
+
+  describe("when a model is selected and deselecting the model through the collection's deselect", function(){
+    var model, collection, deselectedEventState, deselectOneEventState;
+
+    beforeEach(function(){
+      deselectedEventState = { model: {}, collection: {} };
+      deselectOneEventState = { model: {}, collection: {} };
+
+      model = new Model();
+      collection = new Collection([model]);
+      model.select();
+
+      spyOn(collection, "trigger").andCallThrough();
+
+      model.on('deselected', function (model) {
+        deselectedEventState.model.selected = model && model.selected;
+        deselectedEventState.collection.selected = collection.selected;
+      });
+
+      collection.on('deselect:one', function (model) {
+        deselectOneEventState.model.selected = model && model.selected;
+        deselectOneEventState.collection.selected = collection.selected;
+      });
+
       collection.deselect();
     });
 
@@ -236,9 +358,25 @@ describe("single select collection", function(){
       expect(collection.selected).toBeUndefined();
     });
 
-    it("should trigger a deselected event", function(){
+    it("should trigger a deselect:one event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("deselect:one", model);
     });
+
+    it('should trigger the model\'s deselected event after the model status has been updated', function () {
+      expect(deselectedEventState.model.selected).toEqual(false);
+    });
+
+    it('should trigger the model\'s deselected event after the collection status has been updated', function () {
+      expect(deselectedEventState.collection.selected).toBeUndefined();
+    });
+
+    it('should trigger the collection\'s deselect:one event after the model status has been updated', function () {
+      expect(deselectOneEventState.model.selected).toEqual(false);
+    });
+
+    it('should trigger the collection\'s deselect:one event after the collection status has been updated', function () {
+      expect(deselectOneEventState.collection.selected).toBeUndefined();
+    });
   });
 
   describe("when a model is selected and deselecting the model, with options.silent enabled", function(){
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index e1bd5fa..94bbe11 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -55,9 +55,9 @@ Backbone.Picky = (function (Backbone, _) {
       model = model || this.selected;
       if (this.selected !== model){ return; }
 
-      if (!options._skipModelCall) this.selected.deselect(_.omit(options, "_localSilent"));
-      if (!(options.silent || options._localSilent)) this.trigger("deselect:one", this.selected);
       delete this.selected;
+      if (!options._skipModelCall) model.deselect(_.omit(options, "_localSilent"));
+      if (!(options.silent || options._localSilent)) this.trigger("deselect:one", model);
     },
 
     close: function () {
@@ -105,8 +105,10 @@ Backbone.Picky = (function (Backbone, _) {
       if (this.selected[model.cid]) { return; }
 
       this.selected[model.cid] = model;
+      this.selectedLength = _.size(this.selected);
+
       model.select(_.omit(options, "_localSilent"));
-      calculateSelectedLength(this, options);
+      triggerMultiSelectEvents(this, options);
     },
 
     // Deselect a specified model, make sure the
@@ -117,21 +119,32 @@ Backbone.Picky = (function (Backbone, _) {
       if (!this.selected[model.cid]) { return; }
 
       delete this.selected[model.cid];
+      this.selectedLength = _.size(this.selected);
+
       if (!options._skipModelCall) model.deselect(_.omit(options, "_localSilent"));
-      calculateSelectedLength(this, options);
+      triggerMultiSelectEvents(this, options);
     },
 
     // Select all models in this collection
     selectAll: function (options) {
-      this.each(function (model) { model.select(_.omit(options, "_localSilent")); });
-      calculateSelectedLength(this, options);
+      this.selectedLength = 0;
+      this.each(function (model) {
+        this.selectedLength++;
+        model.select(_.omit(options, "_localSilent"));
+      }, this);
+      triggerMultiSelectEvents(this, options);
     },
 
     // Deselect all models in this collection
     deselectAll: function (options) {
       if (this.selectedLength === 0) { return; }
-      this.each(function (model) { model.deselect(_.omit(options, "_localSilent")); });
-      calculateSelectedLength(this, options);
+      this.each(function (model) {
+        if (model.selected) this.selectedLength--;
+        model.deselect(_.omit(options, "_localSilent"));
+      }, this);
+
+      this.selectedLength = 0;
+      triggerMultiSelectEvents(this, options);
     },
 
     selectNone: function (options) {
@@ -219,13 +232,10 @@ Backbone.Picky = (function (Backbone, _) {
   // Helper Methods
   // --------------
 
-  // Calculate the number of selected items in a collection
-  // and update the collection with that length. Trigger events
-  // from the collection based on the number of selected items.
-  var calculateSelectedLength = function (collection, options) {
+  // Trigger events from a multi-select collection based on the number of
+  // selected items.
+  var triggerMultiSelectEvents = function (collection, options) {
     options || (options = {});
-    collection.selectedLength = _.size(collection.selected);
-
     if (options.silent || options._localSilent) return;
 
     var selectedLength = collection.selectedLength;

From bfc7085d6a1be6e220e11ed79195ecde03fc668b Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Tue, 14 Jan 2014 13:36:32 +0100
Subject: [PATCH 14/18] Fixed model status not updating when closing a
 collection

Plus trivial changes in the tests to get rid of some warnings when committing.
---
 spec/javascripts/multiSelect.select.spec.js   |  2 +
 spec/javascripts/multiple.collections.spec.js | 34 ++++++++++++++++
 spec/javascripts/selectable.spec.js           | 39 +++++++++++++++++++
 spec/javascripts/singleSelect.spec.js         |  2 +
 src/backbone.picky.js                         |  8 ++++
 5 files changed, 85 insertions(+)

diff --git a/spec/javascripts/multiSelect.select.spec.js b/spec/javascripts/multiSelect.select.spec.js
index f2c5faf..22132d8 100644
--- a/spec/javascripts/multiSelect.select.spec.js
+++ b/spec/javascripts/multiSelect.select.spec.js
@@ -282,6 +282,8 @@ describe("multi-select collection selecting", function(){
       it('should no longer respond to model events', function () {
         // With only variable holding a collection, only one 'select:*' event
         // should be logged.
+
+        //noinspection JSUnusedAssignment
         collection = new LoggedCollection([m1, m2]);
         collection = new LoggedCollection([m1, m2]);
 
diff --git a/spec/javascripts/multiple.collections.spec.js b/spec/javascripts/multiple.collections.spec.js
index 1b42ab4..03e416b 100644
--- a/spec/javascripts/multiple.collections.spec.js
+++ b/spec/javascripts/multiple.collections.spec.js
@@ -1057,6 +1057,40 @@ describe("models shared between multiple collections", function(){
       expect(model1.selected).toBe(false);
     });
 
+    it("should no longer be selected if removed from all collections, even if it had been part of a collection which had simply been closed and all references to it removed (single-select collection, closed first)", function(){
+      singleCollectionA.close();
+      singleCollectionA = undefined;
+
+      multiCollectionA.remove(model1);
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should no longer be selected if removed from all collections, even if it had been part of a collection which had simply been closed and all references to it removed (multi-select collection, closed first)", function(){
+      multiCollectionA.close();
+      multiCollectionA = undefined;
+
+      singleCollectionA.remove(model1);
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should no longer be selected if removed from all collections, even if it had been part of a collection which had simply been closed and all references to it removed (single-select collection, closed last)", function(){
+      multiCollectionA.remove(model1);
+
+      singleCollectionA.close();
+      singleCollectionA = undefined;
+
+      expect(model1.selected).toBe(false);
+    });
+
+    it("should no longer be selected if removed from all collections, even if it had been part of a collection which had simply been closed and all references to it removed (multi-select collection, closed last)", function(){
+      singleCollectionA.remove(model1);
+
+      multiCollectionA.close();
+      multiCollectionA = undefined;
+
+      expect(model1.selected).toBe(false);
+    });
+
     it("should remain selected in those collections it has not been removed from (removed from single-select)", function(){
       singleCollectionA.remove(model1);
       expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
diff --git a/spec/javascripts/selectable.spec.js b/spec/javascripts/selectable.spec.js
index 93ed8dc..e4bed95 100644
--- a/spec/javascripts/selectable.spec.js
+++ b/spec/javascripts/selectable.spec.js
@@ -123,4 +123,43 @@ describe("selectable model", function(){
     });
   });
 
+  describe("when toggling the selected status of a model that is selected", function(){
+    var model;
+
+    beforeEach(function(){
+      model = new Model();
+      model.select();
+
+      spyOn(model, "trigger").andCallThrough();
+      model.toggleSelected();
+    });
+
+    it("should not be selected", function(){
+      expect(model.selected).toBe(false);
+    });
+
+    it("should notify of deselection", function(){
+      expect(model.trigger).toHaveBeenCalledWith("deselected", model);
+    });
+  });
+
+  describe("when toggling the selected status of a model that is not selected", function(){
+    var model;
+
+    beforeEach(function(){
+      model = new Model();
+
+      spyOn(model, "trigger").andCallThrough();
+      model.toggleSelected();
+    });
+
+    it("should be selected", function(){
+      expect(model.selected).toBe(true);
+    });
+
+    it("should notify of selection", function(){
+      expect(model.trigger).toHaveBeenCalledWith("selected", model);
+    });
+  });
+
 });
diff --git a/spec/javascripts/singleSelect.spec.js b/spec/javascripts/singleSelect.spec.js
index 959fd4c..83b0815 100644
--- a/spec/javascripts/singleSelect.spec.js
+++ b/spec/javascripts/singleSelect.spec.js
@@ -501,6 +501,8 @@ describe("single select collection", function(){
       it('should no longer respond to model events', function () {
         // With only variable holding a collection, only one 'select:*' event
         // should be logged.
+
+        //noinspection JSUnusedAssignment
         collection = new LoggedCollection([m1, m2]);
         collection = new LoggedCollection([m1, m2]);
 
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index 94bbe11..4df9fc7 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -61,6 +61,7 @@ Backbone.Picky = (function (Backbone, _) {
     },
 
     close: function () {
+      unregisterCollectionWithModels(this);
       this.stopListening();
     }
 
@@ -163,6 +164,7 @@ Backbone.Picky = (function (Backbone, _) {
     },
 
     close: function () {
+      unregisterCollectionWithModels(this);
       this.stopListening();
     }
   });
@@ -301,5 +303,11 @@ Backbone.Picky = (function (Backbone, _) {
     model._pickyCollections.push(collection._pickyCid);
   }
 
+  function unregisterCollectionWithModels (collection) {
+    collection.each(function (model) {
+      onRemove(model, collection, {_localSilent: true});
+    });
+  }
+
   return Picky;
 })(Backbone, _);

From e444b416bcd23797eb8fa8dff299216cde7ab2ea Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 20 Jan 2014 17:42:13 +0100
Subject: [PATCH 15/18] Added tests for reselection events

---
 ...pec.js => multiSelect.deselectAll.spec.js} |  35 +-
 ....spec.js => multiSelect.selectAll.spec.js} |  69 +-
 ...multiSelect.selectable.interaction.spec.js | 362 +++++++++-
 ...js => multiSelect.toggleSelectAll.spec.js} |  12 +-
 spec/javascripts/multiple.collections.spec.js | 654 +++++++++++++++---
 spec/javascripts/selectable.spec.js           |  36 +
 spec/javascripts/singleSelect.spec.js         |  93 ++-
 7 files changed, 1109 insertions(+), 152 deletions(-)
 rename spec/javascripts/{multiSelect.deselect.spec.js => multiSelect.deselectAll.spec.js} (87%)
 rename spec/javascripts/{multiSelect.select.spec.js => multiSelect.selectAll.spec.js} (77%)
 rename spec/javascripts/{multiSelect.toggle.spec.js => multiSelect.toggleSelectAll.spec.js} (91%)

diff --git a/spec/javascripts/multiSelect.deselect.spec.js b/spec/javascripts/multiSelect.deselectAll.spec.js
similarity index 87%
rename from spec/javascripts/multiSelect.deselect.spec.js
rename to spec/javascripts/multiSelect.deselectAll.spec.js
index 2f8c907..0daa370 100644
--- a/spec/javascripts/multiSelect.deselect.spec.js
+++ b/spec/javascripts/multiSelect.deselectAll.spec.js
@@ -1,4 +1,4 @@
-describe("multi-select collection deselecting", function(){
+describe("multi-select collection: deselectAll", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
       var selectable = new Backbone.Picky.Selectable(this);
@@ -28,7 +28,8 @@ describe("multi-select collection deselecting", function(){
       collection.deselectAll();
     });
     
-    it("should trigger 'none' selected event", function(){
+    it("should trigger a select:none event", function(){
+      // todo This is doesn't make sense and is inconsistent with the behaviour elsewhere: an event triggered by a no-op
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
 
@@ -55,7 +56,7 @@ describe("multi-select collection deselecting", function(){
       collection.deselectAll({silent: true});
     });
 
-    it("should not trigger 'none' selected event", function(){
+    it("should not trigger a select:none event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
@@ -83,10 +84,14 @@ describe("multi-select collection deselecting", function(){
       collection.deselectAll();
     });
     
-    it("should trigger 'none' selected event", function(){
+    it("should trigger a select:none event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 0", function(){
       expect(collection.selectedLength).toBe(0);
     });
@@ -111,7 +116,7 @@ describe("multi-select collection deselecting", function(){
       collection.deselectAll({silent: true});
     });
 
-    it("should not trigger 'none' selected event", function(){
+    it("should not trigger a select:none event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
@@ -139,10 +144,14 @@ describe("multi-select collection deselecting", function(){
       collection.selectNone();
     });
 
-    it("should trigger 'none' selected event", function(){
+    it("should trigger a select:none event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 0", function(){
       expect(collection.selectedLength).toBe(0);
     });
@@ -185,10 +194,14 @@ describe("multi-select collection deselecting", function(){
       collection.deselectAll();
     });
     
-    it("should trigger 'none' selected event", function(){
+    it("should trigger a select:none event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 0", function(){
       expect(collection.selectedLength).toBe(0);
     });
@@ -247,10 +260,14 @@ describe("multi-select collection deselecting", function(){
       collection.selectNone();
     });
     
-    it("should trigger 'none' selected event", function(){
+    it("should trigger a select:none event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 0", function(){
       expect(collection.selectedLength).toBe(0);
     });
@@ -276,7 +293,7 @@ describe("multi-select collection deselecting", function(){
       collection.deselectAll({silent: true});
     });
 
-    it("should not trigger 'none' selected event", function(){
+    it("should not trigger a select:none event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
diff --git a/spec/javascripts/multiSelect.select.spec.js b/spec/javascripts/multiSelect.selectAll.spec.js
similarity index 77%
rename from spec/javascripts/multiSelect.select.spec.js
rename to spec/javascripts/multiSelect.selectAll.spec.js
index 22132d8..7bb9b57 100644
--- a/spec/javascripts/multiSelect.select.spec.js
+++ b/spec/javascripts/multiSelect.selectAll.spec.js
@@ -1,4 +1,4 @@
-describe("multi-select collection selecting", function(){
+describe("multi-select collection: selectAll", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
       var selectable = new Backbone.Picky.Selectable(this);
@@ -48,6 +48,10 @@ describe("multi-select collection selecting", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 2", function(){
       expect(collection.selectedLength).toBe(2);
     });
@@ -126,9 +130,12 @@ describe("multi-select collection selecting", function(){
   });
 
   describe("when 1 model is selected, and selecting all", function(){
-    var m1, m2, collection;
+    var m1, m2, collection, reselectedEventState, reselectAnyEventState;
 
     beforeEach(function(){
+      reselectedEventState = { model: {}, collection: {} };
+      reselectAnyEventState = { m1: {}, m2: {}, collection: {} };
+
       m1 = new Model();
       m2 = new Model();
 
@@ -136,6 +143,19 @@ describe("multi-select collection selecting", function(){
       m1.select();
 
       spyOn(collection, "trigger").andCallThrough();
+      m1.on('reselected', function (model) {
+        reselectedEventState.model.selected = model && model.selected;
+        reselectedEventState.collection.selected = _.clone(collection.selected);
+        reselectedEventState.collection.selectedLength = collection.selectedLength;
+      });
+
+      collection.on('reselect:any', function () {
+        reselectAnyEventState.m1.selected = m1.selected;
+        reselectAnyEventState.m2.selected = m2.selected;
+        reselectAnyEventState.collection.selected = _.clone(collection.selected);
+        reselectAnyEventState.collection.selectedLength = collection.selectedLength;
+      });
+
       collection.selectAll();
     });
     
@@ -143,6 +163,10 @@ describe("multi-select collection selecting", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
     });
 
+    it("should trigger a reselect:any event, with an array containing the previously selected model as a parameter", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("reselect:any", [m1]);
+    });
+
     it("should have a selected count of 2", function(){
       expect(collection.selectedLength).toBe(2);
     });
@@ -154,6 +178,30 @@ describe("multi-select collection selecting", function(){
     it("should have the second selected model in the selected list", function(){
       expect(collection.selected[m2.cid]).not.toBeUndefined();
     });
+
+    it('should trigger a model\'s reselected event when the collection\'s selected length is consistent with its selected models', function () {
+      // m2 doesn't necessarily have to be part of collection.selected at this
+      // time. The point is that events are fired when model and collection
+      // states are consistent. When m1 fires the 'reselected' event, only m1
+      // must be part of the collection.
+      expect(reselectedEventState.collection.selectedLength).toBeGreaterThan(0);
+      expect(reselectedEventState.collection.selectedLength).toEqual(_.size(reselectedEventState.collection.selected));
+    });
+
+    it('should trigger the collection\'s reselect:any event after the model status has been updated', function () {
+      expect(reselectAnyEventState.m1.selected).toEqual(true);
+      expect(reselectAnyEventState.m2.selected).toEqual(true);
+    });
+
+    it('should trigger the collection\'s reselect:any event after the collection\'s selected models have been updated', function () {
+      expect(reselectAnyEventState.collection.selected[m1.cid]).toBe(m1);
+      expect(reselectAnyEventState.collection.selected[m2.cid]).toBe(m2);
+    });
+
+    it('should trigger the collection\'s reselect:any event after the collection\'s selected length has been updated', function () {
+      expect(reselectAnyEventState.collection.selectedLength).toBe(2);
+    });
+
   });
 
   describe("when 1 model is selected, and selecting all, with options.silent enabled", function(){
@@ -174,6 +222,10 @@ describe("multi-select collection selecting", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 2", function(){
       expect(collection.selectedLength).toBe(2);
     });
@@ -202,10 +254,15 @@ describe("multi-select collection selecting", function(){
       collection.selectAll();
     });
     
-    it("should trigger 'all' selected event", function(){
+    it("should trigger a select:all event", function(){
+      // todo This is doesn't make sense and is inconsistent with the behaviour elsewhere: an event triggered by a no-op
       expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
     });
 
+    it("should trigger a reselect:any event, with an array containing all models as a parameter", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("reselect:any", [m1, m2]);
+    });
+
     it("should have a selected count of 2", function(){
       expect(collection.selectedLength).toBe(2);
     });
@@ -234,10 +291,14 @@ describe("multi-select collection selecting", function(){
       collection.selectAll({silent: true});
     });
 
-    it("should trigger 'all' selected event", function(){
+    it("should not trigger a select:all event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
     });
 
+    it("should not trigger a reselect:any event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should have a selected count of 2", function(){
       expect(collection.selectedLength).toBe(2);
     });
diff --git a/spec/javascripts/multiSelect.selectable.interaction.spec.js b/spec/javascripts/multiSelect.selectable.interaction.spec.js
index 772f718..63109ae 100644
--- a/spec/javascripts/multiSelect.selectable.interaction.spec.js
+++ b/spec/javascripts/multiSelect.selectable.interaction.spec.js
@@ -1,4 +1,4 @@
-describe("multi-select selectable interaction", function(){
+describe("multi-select collection: interaction with selectable models", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
       var selectable = new Backbone.Picky.Selectable(this);
@@ -17,7 +17,7 @@ describe("multi-select selectable interaction", function(){
 
   describe("select / deselect the model directly", function(){
 
-    describe("when 1 out of 2 models in a collection is selected", function(){
+    describe("when 1 out of 2 models in a collection is being selected", function(){
       var m1, m2, collection, selectedEventState, selectSomeEventState;
 
       beforeEach(function(){
@@ -45,11 +45,15 @@ describe("multi-select selectable interaction", function(){
         m1.select();
       });
 
-      it("should trigger 'some' selected event", function(){
+      it("should trigger a select:some event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:some", collection);
       });
 
-      it("should have a selected count of 1", function(){
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+     it("should have a selected count of 1", function(){
         expect(collection.selectedLength).toBe(1);
       });
 
@@ -87,7 +91,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when 1 out of 2 models in a collection is selected, with options.silent enabled", function(){
+    describe("when 1 out of 2 models in a collection is being selected, with options.silent enabled", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -100,7 +104,7 @@ describe("multi-select selectable interaction", function(){
         m1.select({silent: true});
       });
 
-      it("should not trigger 'some' selected event", function(){
+      it("should not trigger a select:some event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
       });
 
@@ -118,7 +122,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when 2 out of 2 models in a collection are selected", function(){
+    describe("when 2 out of 2 models in a collection are being selected", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -132,10 +136,14 @@ describe("multi-select selectable interaction", function(){
         m2.select();
       });
 
-      it("should trigger 'all' selected event", function(){
+      it("should trigger a select:all event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
       });
 
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
       it("should have a selected count of 2", function(){
         expect(collection.selectedLength).toBe(2);
       });
@@ -149,7 +157,7 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
-    describe("when 2 out of 2 models in a collection are selected, with options.silent enabled", function(){
+    describe("when 2 out of 2 models in a collection are being selected, with options.silent enabled", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -163,7 +171,7 @@ describe("multi-select selectable interaction", function(){
         m2.select({silent: true});
       });
 
-      it("should not trigger 'all' selected event", function(){
+      it("should not trigger a select:all event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
       });
 
@@ -180,7 +188,7 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
-    describe("when a model is selected and then deselected", function(){
+    describe("when a model is being selected and then deselected", function(){
       var m1, collection, selectedEventState, selectNoneEventState;
 
       beforeEach(function(){
@@ -209,15 +217,15 @@ describe("multi-select selectable interaction", function(){
         m1.deselect();
       });
 
-      it("should trigger 'none' selected event", function(){
+      it("should trigger a select:none event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
       });
 
-      it("should trigger 'selected' event with the selected model", function(){
+      it("should trigger a 'selected' event with the selected model", function(){
         expect(collection.trigger).toHaveBeenCalledWith("selected", m1);
       });
 
-      it("should trigger 'deselected' event with the deselected model", function(){
+      it("should trigger a 'deselected' event with the deselected model", function(){
         expect(collection.trigger).toHaveBeenCalledWith("deselected", m1);
       });
 
@@ -255,7 +263,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when a model is selected and then deselected, with options.silent enabled", function(){
+    describe("when a model is being selected and then deselected, with options.silent enabled", function(){
       var m1, collection;
 
       beforeEach(function(){
@@ -268,15 +276,15 @@ describe("multi-select selectable interaction", function(){
         m1.deselect({silent: true});
       });
 
-      it("should not trigger 'none' selected event", function(){
+      it("should not trigger a select:none event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
       });
 
-      it("should not trigger 'selected' event with the selected model", function(){
+      it("should not trigger a 'selected' event with the selected model", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("selected", m1);
       });
 
-      it("should not trigger 'deselected' event with the deselected model", function(){
+      it("should not trigger a 'deselected' event with the deselected model", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("deselected", m1);
       });
 
@@ -289,7 +297,7 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
-    describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the model's select", function(){
+    describe("when 1 out of 2 models in a collection is already selected, and selecting the second one via the model's select", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -304,10 +312,14 @@ describe("multi-select selectable interaction", function(){
         m2.select();
       });
 
-      it("should trigger 'all' selected event", function(){
+      it("should trigger a select:all event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
       });
 
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
       it("should have a selected count of 2", function(){
         expect(collection.selectedLength).toBe(2);
       });
@@ -322,7 +334,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the model's select, with options.silent enabled", function(){
+    describe("when 1 out of 2 models in a collection is already selected, and selecting the second one via the model's select, with options.silent enabled", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -337,7 +349,7 @@ describe("multi-select selectable interaction", function(){
         m2.select({silent: true});
       });
 
-      it("should not trigger 'all' selected event", function(){
+      it("should not trigger a select:all event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
       });
 
@@ -371,10 +383,14 @@ describe("multi-select selectable interaction", function(){
         m1.deselect();
       });
 
-      it("should trigger 'some' selected event", function(){
+      it("should trigger a select:some event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:some", collection);
       });
 
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
       it("should have a selected count of 1", function(){
         expect(collection.selectedLength).toBe(1);
       });
@@ -405,7 +421,7 @@ describe("multi-select selectable interaction", function(){
         m1.deselect({silent: true});
       });
 
-      it("should not trigger 'some' selected event", function(){
+      it("should not trigger a select:some event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
       });
 
@@ -438,7 +454,7 @@ describe("multi-select selectable interaction", function(){
         m1.deselect();
       });
 
-      it("should trigger 'none' selected event", function(){
+      it("should trigger a select:none event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
       });
 
@@ -467,7 +483,7 @@ describe("multi-select selectable interaction", function(){
         m1.deselect({silent: true});
       });
 
-      it("should not trigger 'none' selected event", function(){
+      it("should not trigger a select:none event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
       });
 
@@ -481,6 +497,138 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
+    describe("when 1 out of 2 models in a collection is selected, and re-selecting a model via the model's select", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select();
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should trigger a reselect:any event", function(){
+        expect(collection.trigger).toHaveBeenCalledWith("reselect:any", [m1]);
+      });
+
+    });
+
+    describe("when 1 out of 2 models in a collection is selected, and re-selecting a model via the model's select, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select({silent: true});
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+    });
+
+    describe("when all models are selected, and re-selecting a model via the model's select", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+        m2.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select();
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should trigger a reselect:any event", function(){
+        expect(collection.trigger).toHaveBeenCalledWith("reselect:any", [m1]);
+      });
+
+    });
+
+    describe("when all models are selected, and re-selecting a model via the model's select, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        m1.select();
+        m2.select();
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m1.select({silent: true});
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+    });
+
+    describe("when 1 out of 2 models in a collection is selected, and deselecting the one which hadn't been selected, via the model's deselect", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        m2.deselect();
+      });
+
+      it("should not trigger a select:some or select:none event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+      });
+
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+    });
+
   });
 
   describe("select / deselect through the collection", function(){
@@ -496,6 +644,8 @@ describe("multi-select selectable interaction", function(){
         spyOn(m1, "select").andCallThrough();
         collection = new Collection([m1]);
 
+        spyOn(collection, "trigger").andCallThrough();
+
         m1.on('selected', function (model) {
           selectedEventState.model.selected = model && model.selected;
           selectedEventState.collection.selected = _.clone(collection.selected);
@@ -539,6 +689,10 @@ describe("multi-select selectable interaction", function(){
         expect(selectAllEventState.collection.selectedLength).toBe(1);
       });
 
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
     });
 
     describe("when deselecting a model through the collection's select method", function(){
@@ -599,7 +753,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the collection's select", function(){
+    describe("when 1 out of 2 models in a collection is already selected, and selecting the second one via the collection's select", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -614,7 +768,7 @@ describe("multi-select selectable interaction", function(){
         collection.select(m2);
       });
 
-      it("should trigger 'all' selected event", function(){
+      it("should trigger a select:all event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
       });
 
@@ -632,7 +786,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when 1 out of 2 models in a collection is selected, and selecting the last one via the collection's select, with options.silent enabled", function(){
+    describe("when 1 out of 2 models in a collection is already selected, and selecting the second one via the collection's select, with options.silent enabled", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -647,7 +801,7 @@ describe("multi-select selectable interaction", function(){
         collection.select(m2, {silent: true});
       });
 
-      it("should not trigger 'all' selected event", function(){
+      it("should not trigger a select:all event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
       });
 
@@ -681,10 +835,14 @@ describe("multi-select selectable interaction", function(){
         collection.deselect(m1);
       });
 
-      it("should trigger 'some' selected event", function(){
+      it("should trigger a select:some event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:some", collection);
       });
 
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
       it("should have a selected count of 1", function(){
         expect(collection.selectedLength).toBe(1);
       });
@@ -715,7 +873,7 @@ describe("multi-select selectable interaction", function(){
         collection.deselect(m1, {silent: true});
       });
 
-      it("should not trigger 'some' selected event", function(){
+      it("should not trigger a select:some event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
       });
 
@@ -733,7 +891,7 @@ describe("multi-select selectable interaction", function(){
 
     });
 
-    describe("when 1 out of 2 models in a collection is selected, and deselecting the last one via the collection's deselect", function(){
+    describe("when 1 out of 2 models in a collection is selected, and it is being deselected via the collection's deselect", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -748,7 +906,7 @@ describe("multi-select selectable interaction", function(){
         collection.deselect(m1);
       });
 
-      it("should trigger 'none' selected event", function(){
+      it("should trigger a select:none event", function(){
         expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
       });
 
@@ -762,7 +920,7 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
-    describe("when 1 out of 2 models in a collection is selected, and deselecting the last one via the collection's deselect, with options.silent enabled", function(){
+    describe("when 1 out of 2 models in a collection is selected, and it is being deselected via the collection's deselect, with options.silent enabled", function(){
       var m1, m2, collection;
 
       beforeEach(function(){
@@ -777,7 +935,7 @@ describe("multi-select selectable interaction", function(){
         collection.deselect(m1, {silent: true});
       });
 
-      it("should not trigger 'none' selected event", function(){
+      it("should not trigger a select:none event", function(){
         expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
       });
 
@@ -791,6 +949,138 @@ describe("multi-select selectable interaction", function(){
       });
     });
 
+    describe("when 1 out of 2 models in a collection is selected, and it is being re-selected via the collection's select", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.select(m1);
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should trigger a reselect:any event", function(){
+        expect(collection.trigger).toHaveBeenCalledWith("reselect:any", [m1]);
+      });
+
+    });
+
+    describe("when 1 out of 2 models in a collection is selected, and it is being re-selected via the collection's select, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.select(m1, {silent: true});
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+    });
+
+    describe("when all models are selected, and re-selecting a model via the collection's select", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+        collection.select(m2);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.select(m1);
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should trigger a reselect:any event", function(){
+        expect(collection.trigger).toHaveBeenCalledWith("reselect:any", [m1]);
+      });
+
+    });
+
+    describe("when all models are selected, and re-selecting a model via the collection's select, with options.silent enabled", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+        collection.select(m2);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.select(m1, {silent: true});
+      });
+
+      it("should not trigger a select:some or select:all event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
+      });
+
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+    });
+
+    describe("when 1 out of 2 models in a collection is selected, and deselecting the one which hadn't been selected, via the collection's deselect", function(){
+      var m1, m2, collection;
+
+      beforeEach(function(){
+        m1 = new Model();
+        m2 = new Model();
+
+        collection = new Collection([m1, m2]);
+        collection.select(m1);
+
+        spyOn(collection, "trigger").andCallThrough();
+
+        collection.deselect(m2);
+      });
+
+      it("should not trigger a select:some or select:none event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:some", collection);
+        expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
+      });
+
+      it("should not trigger a reselect:any event", function(){
+        expect(collection.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
+    });
+
   });
 
 });
diff --git a/spec/javascripts/multiSelect.toggle.spec.js b/spec/javascripts/multiSelect.toggleSelectAll.spec.js
similarity index 91%
rename from spec/javascripts/multiSelect.toggle.spec.js
rename to spec/javascripts/multiSelect.toggleSelectAll.spec.js
index f848a38..cc0feda 100644
--- a/spec/javascripts/multiSelect.toggle.spec.js
+++ b/spec/javascripts/multiSelect.toggleSelectAll.spec.js
@@ -1,4 +1,4 @@
-describe("multi-select collection toggle", function(){
+describe("multi-select collection: toggleSelectAll", function(){
   var Model = Backbone.Model.extend({
     initialize: function(){
       var selectable = new Backbone.Picky.Selectable(this);
@@ -28,7 +28,7 @@ describe("multi-select collection toggle", function(){
       collection.toggleSelectAll();
     });
     
-    it("should trigger 'all' selected event", function(){
+    it("should trigger a select:all event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
     });
 
@@ -55,7 +55,7 @@ describe("multi-select collection toggle", function(){
       collection.toggleSelectAll({silent: true});
     });
 
-    it("should not trigger 'all' selected event", function(){
+    it("should not trigger a select:all event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
     });
 
@@ -84,7 +84,7 @@ describe("multi-select collection toggle", function(){
       collection.toggleSelectAll();
     });
     
-    it("should trigger 'all' selected event", function(){
+    it("should trigger a select:all event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
     });
 
@@ -114,7 +114,7 @@ describe("multi-select collection toggle", function(){
       collection.toggleSelectAll();
     });
     
-    it("should trigger 'none' selected event", function(){
+    it("should trigger a select:none event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
     });
 
@@ -144,7 +144,7 @@ describe("multi-select collection toggle", function(){
       collection.toggleSelectAll({silent: true});
     });
 
-    it("should not trigger 'none' selected event", function(){
+    it("should not trigger a select:none event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
diff --git a/spec/javascripts/multiple.collections.spec.js b/spec/javascripts/multiple.collections.spec.js
index 03e416b..36d3eaa 100644
--- a/spec/javascripts/multiple.collections.spec.js
+++ b/spec/javascripts/multiple.collections.spec.js
@@ -74,6 +74,23 @@ describe("models shared between multiple collections", function(){
     it('should trigger a select:some or selected:all event on another multi-select collection', function () {
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
     });
+
+    it('should not trigger a reselected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
+
+    it("should not trigger a reselect:one event on the originating collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
+
+    it("should not trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
+
+    it("should not trigger a reselect:any event on another multi-select collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
   });
 
   describe("when selecting a model in a single-select collection, with options.silent enabled", function(){
@@ -167,6 +184,23 @@ describe("models shared between multiple collections", function(){
     it('should trigger a select:some or selected:all event on another multi-select collection', function () {
       expect(multiCollectionB.trigger).toHaveBeenCalledWith("select:all", multiCollectionB);
     });
+
+    it('should not trigger a reselected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
+
+    it("should not trigger a reselect:any event on the originating collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
+    it("should not trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
+
+    it("should not trigger a reselect:any event on another multi-select collection", function(){
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
   });
 
   describe("when selecting a model in a multi-select collection, with options.silent enabled", function(){
@@ -251,6 +285,19 @@ describe("models shared between multiple collections", function(){
     it('should trigger a select:some or selected:all event on the multi-select collection', function () {
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
     });
+
+    it('should not trigger a reselected event on the model', function () {
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
+
+    it("should not trigger a reselect:one event on the single-select collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
+
+    it("should not trigger a reselect:any event on the multi-select collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
   });
 
   describe("when selecting a model, which is shared across collections, with its select method and options.silent enabled", function(){
@@ -290,38 +337,377 @@ describe("models shared between multiple collections", function(){
     });
   });
 
+  describe("when re-selecting a model in a single-select collection", function(){
+    var model1, model2, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1]);
+      singleCollectionB = new SingleSelectCollection([model1]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      multiCollectionA.select(model2);
+      multiCollectionA.select(model1);
+
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
+      singleCollectionA.select(model1);
+    });
+
+    it("should not deselect other selected models in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+    });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should trigger a reselected event on the model', function () {
+      expect(model1.trigger).toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it("should trigger a reselect:one event on the originating collection", function(){
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionB.trigger).toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should trigger a reselect:any event on another multi-select collection, with an array containing the model as second parameter", function(){
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("reselect:any", [model1]);
+    });
+
+  });
+
+  describe("when re-selecting a model in a single-select collection, with options.silent enabled", function(){
+    var model1, model2, singleCollectionA, singleCollectionB, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2= new Model();
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      singleCollectionB = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      singleCollectionA.select(model1);
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
+      singleCollectionA.select(model1, {silent: true});
+    });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:one event on the originating collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should not trigger a reselected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it("should not trigger a reselect:one event on the originating collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should not trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should not trigger a reselect:any event on another multi-select collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
+  });
+
+  describe("when re-selecting a model in a multi-select collection", function(){
+    var model1, model2, singleCollectionA, multiCollectionA, multiCollectionB;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+      multiCollectionB  = new MultiSelectCollection([model1, model2]);
+
+      multiCollectionA.select(model1);
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionB, "trigger").andCallThrough();
+
+      multiCollectionA.select(model1);
+    });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on the originating collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should not trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionB);
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionB);
+    });
+
+    it('should trigger a reselected event on the model', function () {
+      expect(model1.trigger).toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it("should trigger a reselect:any event on the originating collection, with an array containing the model as second parameter", function(){
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("reselect:any", [model1]);
+    });
+
+    it("should trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should trigger a reselect:any event on another multi-select collection, with an array containing the model as second parameter", function(){
+      expect(multiCollectionB.trigger).toHaveBeenCalledWith("reselect:any", [model1]);
+    });
+
+  });
+
+  describe("when re-selecting a model in a multi-select collection, with options.silent enabled", function(){
+    var model1, model2, singleCollectionA, multiCollectionA, multiCollectionB;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+      multiCollectionB  = new MultiSelectCollection([model1, model2]);
+
+      multiCollectionA.select(model1);
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionB, "trigger").andCallThrough();
+
+      multiCollectionA.select(model1, {silent: true});
+    });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on the originating collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should not trigger a select:one event on another single-select collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionB);
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionB);
+    });
+
+    it('should not trigger a reselected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it("should not trigger a reselect:any event on the originating collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
+    it("should not trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should not trigger a reselect:any event on another multi-select collection", function(){
+      expect(multiCollectionB.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
+  });
+
+  describe("when re-selecting a model, which is shared across collections, with its select method", function(){
+    var model1, model2, singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      model1.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
+      model1.select();
+    });
+
+    it("should remain selected in a single-select collection", function(){
+      expect(singleCollectionA.selected).toBe(model1);
+    });
+
+    it("should remain among the selected models in a multi-select collection", function(){
+      expect(multiCollectionA.selected[model1.cid]).not.toBeUndefined();
+    });
+
+    it("should remain selected itself", function(){
+      expect(model1.selected).toBe(true);
+    });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:one event on the single-select collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on the multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should trigger a reselected event on the model', function () {
+      expect(model1.trigger).toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it("should trigger a reselect:one event on the single-select collection", function(){
+      expect(singleCollectionA.trigger).toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should trigger a reselect:any event on the multi-select collection, with an array containing the model as second parameter", function(){
+      expect(multiCollectionA.trigger).toHaveBeenCalledWith("reselect:any", [model1]);
+    });
+
+  });
+
+  describe("when selecting a model, which is shared across collections and has already been selected, with its select method and options.silent enabled", function(){
+    var model1, model2, singleCollectionA, multiCollectionA;
+
+    beforeEach(function(){
+      model1 = new Model();
+      model2 = new Model();
+      singleCollectionA = new SingleSelectCollection([model1, model2]);
+      multiCollectionA  = new MultiSelectCollection([model1, model2]);
+
+      model1.select();
+
+      spyOn(model1, "trigger").andCallThrough();
+      spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(multiCollectionA, "trigger").andCallThrough();
+
+      model1.select({silent: true});
+    });
+
+    it('should not trigger a selected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    });
+
+    it('should not trigger a select:one event on the single-select collection', function () {
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
+    it('should not trigger a select:some or selected:all event on the multi-select collection', function () {
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
+    });
+
+    it('should not trigger a reselected event on the model', function () {
+      expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it("should not trigger a reselect:one event on the single-select collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it("should not trigger a reselect:any event on the multi-select collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
+  });
+
   describe("when creating additional collections with a model that is already selected", function(){
-    var logger, LoggedSingleSelectCollection, LoggedMultiSelectCollection,
+    var selectLogger, reselectLogger, LoggedSingleSelectCollection, LoggedMultiSelectCollection,
         model, singleCollectionA, singleCollectionB, multiCollectionA;
 
     beforeEach(function(){
-      logger = new Logger();
+      selectLogger = new Logger();
+      reselectLogger = new Logger();
 
-      // Always create a `var logger = new Logger();` before instantiating LoggedSingleSelectCollection
+      // Always create `var selectLogger = new Logger(); var reselectLogger =
+      // new Logger();` before instantiating LoggedMultiSelectCollection
       LoggedSingleSelectCollection = SingleSelectCollection.extend({
         initialize: function(models){
           this.on("select:one", function (model) {
-            logger.log( "select:one event: Model " + model.cid + " selected in collection " + this._pickyCid );
+            selectLogger.log( "select:one event: Model " + model.cid + " selected in collection " + this._pickyCid );
           });
           this.on("deselect:one", function (model) {
-            logger.log( "deselect:one event: Model " + model.cid + " deselected in collection " + this._pickyCid );
+            selectLogger.log( "deselect:one event: Model " + model.cid + " deselected in collection " + this._pickyCid );
+          });
+          this.on("reselect:one", function (model) {
+            reselectLogger.log( "reselect:one event: Model " + model.cid + " reselected in collection " + this._pickyCid );
           });
 
           SingleSelectCollection.prototype.initialize.call(this, models);
         }
       });
 
-      // Always create a `var logger = new Logger();` before instantiating LoggedMultiSelectCollection
+      // Always create `var selectLogger = new Logger(); var reselectLogger =
+      // new Logger();` before instantiating LoggedMultiSelectCollection
       LoggedMultiSelectCollection = MultiSelectCollection.extend({
         initialize: function(models){
           this.on("select:none", function () {
-            logger.log( "select:none event fired in selected in collection " + this._pickyCid );
+            selectLogger.log( "select:none event fired in collection " + this._pickyCid );
           });
           this.on("select:some", function () {
-            logger.log( "select:some event fired in selected in collection " + this._pickyCid );
+            selectLogger.log( "select:some event fired in collection " + this._pickyCid );
           });
           this.on("select:all", function () {
-            logger.log( "select:all event fired in selected in collection " + this._pickyCid );
+            selectLogger.log( "select:all event fired in collection " + this._pickyCid );
+          });
+          this.on("reselect:any", function () {
+            reselectLogger.log( "reselect:any event fired in selected in collection " + this._pickyCid );
           });
 
           MultiSelectCollection.prototype.initialize.call(this, models);
@@ -372,88 +758,25 @@ describe("models shared between multiple collections", function(){
       //   listen to when the addition is done.
       //
       // These events, if they occurred, would be captured by the logger.
-      expect(logger.entries.length).toEqual(0);
-    });
-  });
-
-  describe("when re-selecting a model shared across collections", function(){
-    var model, singleCollectionA, multiCollectionA;
-
-    beforeEach(function(){
-      model = new Model();
-      singleCollectionA = new SingleSelectCollection([model]);
-      multiCollectionA  = new MultiSelectCollection([model]);
-
-      singleCollectionA.select(model);
-
-      spyOn(model, "trigger").andCallThrough();
-      spyOn(singleCollectionA, "trigger").andCallThrough();
-      spyOn(multiCollectionA, "trigger").andCallThrough();
-
-      model.select();
-    });
-
-   it("should remain selected in a single-select collection", function(){
-      expect(singleCollectionA.selected).toBe(model);
-    });
-
-    it("should remain among the selected models in a multi-select collection", function(){
-      expect(multiCollectionA.selected[model.cid]).not.toBeUndefined();
-    });
-
-    it("should remain selected itself", function(){
-      expect(model.selected).toBe(true);
-    });
-
-    it('should not trigger a selected event on the model', function () {
-      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
-    });
-
-    it('should not trigger a select:one event on the originating collection', function () {
-      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model);
-    });
-
-    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
-      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
-      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
-    });
-  });
-
-  describe("when re-selecting a model, which is shared across collections, in a single-select collection", function(){
-    var model1, model2, singleCollectionA, multiCollectionA;
-
-    beforeEach(function(){
-      model1 = new Model();
-      model2 = new Model();
-      singleCollectionA = new SingleSelectCollection([model1]);
-      multiCollectionA  = new MultiSelectCollection([model1, model2]);
-
-      multiCollectionA.select(model2);
-      multiCollectionA.select(model1);
-
-      spyOn(model1, "trigger").andCallThrough();
-      spyOn(singleCollectionA, "trigger").andCallThrough();
-      spyOn(multiCollectionA, "trigger").andCallThrough();
-
-      singleCollectionA.select(model1);
+      expect(selectLogger.entries.length).toEqual(0);
     });
 
-    it("should not deselect other selected models in a multi-select collection", function(){
-      expect(multiCollectionA.selected[model2.cid]).not.toBeUndefined();
+    it('should not trigger a reselected event on the model', function () {
+      // The reselect event implies some sort of active 'select' action. Simply
+      // registering the model status in the new collection does not belong into
+      // that category. It does not reflect the action of a user reaffirming a
+      // selection.
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
     });
 
-    it('should not trigger a selected event on the model', function () {
-      expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
+    it("should not trigger a reselect:one event on the originating collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model);
     });
 
-    it('should not trigger a select:one event on the originating collection', function () {
-      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    it("should not trigger a reselect:one or reselect:any event on a collection it is added to", function(){
+      expect(reselectLogger.entries.length).toEqual(0);
     });
 
-    it('should not trigger a select:some or selected:all event on another multi-select collection', function () {
-      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
-      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
-    });
   });
 
   describe("when a model is already selected and a different model is selected in a single-select collection", function(){
@@ -529,6 +852,23 @@ describe("models shared between multiple collections", function(){
     it('should trigger a select:some event on another multi-select collection', function () {
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
     });
+
+    it('should not trigger a reselected event on the selected model', function () {
+      expect(model2.trigger).not.toHaveBeenCalledWith("reselected", model2);
+    });
+
+    it("should not trigger a reselect:one event on the originating collection", function(){
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+    });
+
+    it("should not trigger a reselect:one event on another single-select collection", function(){
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+    });
+
+    it("should not trigger a reselect:any event on another multi-select collection", function(){
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
   });
 
   describe("when a model is already selected and a different model is selected with its select method", function(){
@@ -577,6 +917,19 @@ describe("models shared between multiple collections", function(){
       it('should trigger a select:some or selected:all event on a multi-select collection', function () {
         expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
       });
+
+      it('should not trigger a reselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+      });
+
+      it('should not trigger a reselected event on the second model', function () {
+        expect(model2.trigger).not.toHaveBeenCalledWith("reselected", model2);
+      });
+
+      it("should not trigger a reselect:any event on a multi-select collection", function(){
+        expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
     });
 
     describe("when both models are shared, with at least one single-select collection among the collections", function() {
@@ -640,6 +993,23 @@ describe("models shared between multiple collections", function(){
       it('should trigger a select:some event on the multi-select collection', function () {
         expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
       });
+
+      it('should not trigger a reselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+      });
+
+      it('should not trigger a reselected event on the second model', function () {
+        expect(model2.trigger).not.toHaveBeenCalledWith("reselected", model2);
+      });
+
+     it("should not trigger a reselect:one event on the single-select collection", function(){
+        expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+      });
+
+      it("should not trigger a reselect:any event on the multi-select collection", function(){
+        expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
     });
 
     describe("when the first model is shared with at least one single-select collection, but not the second", function() {
@@ -705,6 +1075,23 @@ describe("models shared between multiple collections", function(){
       it('should trigger a select:some or select:all event on the multi-select collection', function () {
         expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
       });
+
+      it('should not trigger a reselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+      });
+
+      it('should not trigger a reselected event on the second model', function () {
+        expect(model2.trigger).not.toHaveBeenCalledWith("reselected", model2);
+      });
+
+      it("should not trigger a reselect:one event on the single-select collection", function(){
+        expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+      });
+
+      it("should not trigger a reselect:any event on the multi-select collection", function(){
+        expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
     });
 
     describe("when the second model is shared with at least one single-select collection, but not the first", function() {
@@ -767,6 +1154,23 @@ describe("models shared between multiple collections", function(){
       it('should trigger a select:some or select:all event on the multi-select collection', function () {
         expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
       });
+
+      it('should not trigger a reselected event on the first model', function () {
+        expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+      });
+
+      it('should not trigger a reselected event on the second model', function () {
+        expect(model2.trigger).not.toHaveBeenCalledWith("reselected", model2);
+      });
+
+      it("should not trigger a reselect:one event on the single-select collection", function(){
+        expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+      });
+
+      it("should not trigger a reselect:any event on the multi-select collection", function(){
+        expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+      });
+
     });
   });
 
@@ -962,11 +1366,26 @@ describe("models shared between multiple collections", function(){
       expect(model2.trigger).not.toHaveBeenCalledWith("selected", model2);
     });
 
+    it('should not trigger a reselected event on the model when added to a single-select collection', function () {
+      // The reselect event implies some sort of active 'select' action. Simply
+      // registering the model status in the new collection does not belong into
+      // that category. It does not reflect the action of a user reaffirming a
+      // selection.
+      singleCollectionA.add(model2);
+      expect(model2.trigger).not.toHaveBeenCalledWith("reselected", model2);
+    });
+
     it('should not trigger a selected event on the model when added to a multi-select collection', function () {
       multiCollectionA.add(model4);
       expect(model4.trigger).not.toHaveBeenCalledWith("selected", model4);
     });
 
+    it('should not trigger a reselected event on the model when added to a multi-select collection', function () {
+      // See the comment above for the rationale.
+      multiCollectionA.add(model4);
+      expect(model4.trigger).not.toHaveBeenCalledWith("reselected", model4);
+    });
+
     it('should trigger a deselected event on the previously selected model when added to a single-select collection', function () {
       singleCollectionA.add(model2);
       expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
@@ -988,11 +1407,21 @@ describe("models shared between multiple collections", function(){
       expect(singleCollectionA.trigger).toHaveBeenCalledWith("deselect:one", model1);
     });
 
+    it('should not trigger a reselect:one event when added to a single-select collection', function () {
+      singleCollectionA.add(model2);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+    });
+
     it('should trigger a select:some/select:all event when added to a multi-select collection', function () {
       multiCollectionA.add(model4);
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:all", multiCollectionA);
     });
 
+    it('should not trigger a reselect:any event when added to a multi-select collection', function () {
+      multiCollectionA.add(model4);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it('should trigger a select:some or select:none event when the addition is inducing a deselection in another multi-select collection', function () {
       singleCollectionA.add(model2);
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
@@ -1009,6 +1438,19 @@ describe("models shared between multiple collections", function(){
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:some", multiCollectionA);
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
     });
+
+    it('should not trigger a reselect:one event on another single-select collection holding the model', function () {
+      singleCollectionB = new SingleSelectCollection();
+      singleCollectionB.add(model1);
+
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model1);
+    });
+
+    it('should not trigger a reselect:any event on another multi-select collection holding the model', function () {
+      singleCollectionA.add(model2);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
   });
 
   describe("when a selected model is removed", function(){
@@ -1172,6 +1614,7 @@ describe("models shared between multiple collections", function(){
       spyOn(model1, "trigger").andCallThrough();
       spyOn(model2, "trigger").andCallThrough();
       spyOn(singleCollectionA, "trigger").andCallThrough();
+      spyOn(singleCollectionB, "trigger").andCallThrough();
       spyOn(multiCollectionA, "trigger").andCallThrough();
     });
 
@@ -1242,6 +1685,20 @@ describe("models shared between multiple collections", function(){
       expect(model1.trigger).not.toHaveBeenCalledWith("selected", model1);
     });
 
+    it('should not trigger a reselected event on the model (added to a single-select collection)', function () {
+      // For one, reset() is meant to suppress individual notifications. Also,
+      // the reselect event implies some sort of active 'select' action, which
+      // is not present here. See comments in the 'add' tests for more on the
+      // rationale.
+      singleCollectionA.reset([model1]);
+      expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+    });
+
+    it('should not trigger a reselected event on the model (added to a multi-select collection)', function () {
+      multiCollectionA.reset([model1]);
+      expect(model1.trigger).not.toHaveBeenCalledWith("reselected", model1);
+    });
+
     it('should not trigger a select:one event when added to a single-select collection', function () {
       // reset() is meant to suppress individual notifications. Just like the add event, selection events are silenced.
       // Whatever needs to be done, should be dealt with in the reset event handler.
@@ -1249,6 +1706,11 @@ describe("models shared between multiple collections", function(){
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
     });
 
+    it('should not trigger a reselect:one event when added to a single-select collection', function () {
+      singleCollectionA.reset([model1]);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("select:one", model1);
+    });
+
     it('should not trigger a select:some or select:all event when added to a multi-select collection', function () {
       // For the rationale, see above.
       multiCollectionA.reset([model1]);
@@ -1256,6 +1718,12 @@ describe("models shared between multiple collections", function(){
       expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("select:all", multiCollectionA);
     });
 
+    it('should not trigger a reselect:any event when added to a multi-select collection', function () {
+      // For the rationale, see above.
+      multiCollectionA.reset([model1]);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it('should trigger a deselected event on a different model when the reset is inducing a deselection in another multi-select collection', function () {
       singleCollectionA.reset([model1, model2]);
       expect(model1.trigger).toHaveBeenCalledWith("deselected", model1);
@@ -1266,11 +1734,31 @@ describe("models shared between multiple collections", function(){
       expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("deselect:one", model1);
     });
 
+    it('should not trigger a reselect:one event when added to a singe-select collection, even if multiple models with selected status are added, and all but the last one are deselected', function () {
+      singleCollectionA.reset([model1, model2]);
+      expect(singleCollectionA.trigger).not.toHaveBeenCalledWith("reselect:one", model2);
+    });
+
     it('should trigger a select:some or select:none event when the reset is inducing a deselection in another multi-select collection', function () {
       singleCollectionA.reset([model1, model2]);
       expect(multiCollectionA.trigger).toHaveBeenCalledWith("select:some", multiCollectionA);
     });
 
+    it('should not trigger a reselect:one event on another single-select collection holding the model', function () {
+      singleCollectionA.reset([model3]);
+      expect(singleCollectionB.trigger).not.toHaveBeenCalledWith("reselect:one", model3);
+    });
+
+    it('should not trigger a reselect:any event on another multi-select collection holding the model', function () {
+      singleCollectionA.reset([model1]);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
+    it('should not trigger a reselect:any event on another multi-select collection, even when the reset is inducing a change (a deselection) there', function () {
+      singleCollectionA.reset([model1, model2]);
+      expect(multiCollectionA.trigger).not.toHaveBeenCalledWith("reselect:any", jasmine.any(Array));
+    });
+
     it("should remain selected itself", function(){
       singleCollectionA.reset([model1]);
       expect(model1.selected).toBe(true);
diff --git a/spec/javascripts/selectable.spec.js b/spec/javascripts/selectable.spec.js
index e4bed95..d390047 100644
--- a/spec/javascripts/selectable.spec.js
+++ b/spec/javascripts/selectable.spec.js
@@ -23,6 +23,10 @@ describe("selectable model", function(){
     it("should notify of selection", function(){
       expect(model.trigger).toHaveBeenCalledWith("selected", model);
     });
+
+    it("should not trigger a reselected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
   });
 
   describe("when selecting a model, with options.silent enabled", function(){
@@ -62,6 +66,34 @@ describe("selectable model", function(){
     it("should not notify of selection", function(){
       expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
     });
+
+    it("should trigger a reselected event", function(){
+      expect(model.trigger).toHaveBeenCalledWith("reselected", model);
+    });
+  });
+
+  describe("when selecting a model that is already selected, with options.silent enabled", function(){
+    var model;
+
+    beforeEach(function(){
+      model = new Model();
+      model.select();
+
+      spyOn(model, "trigger").andCallThrough();
+      model.select({silent: true});
+    });
+
+    it("should still be selected", function(){
+      expect(model.selected).toBe(true);
+    });
+
+    it("should not notify of selection", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("selected", model);
+    });
+
+    it("should not trigger a reselected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
   });
 
   describe("when deselecting a model that has been selected", function(){
@@ -121,6 +153,10 @@ describe("selectable model", function(){
     it("should not notify of deselection", function(){
       expect(model.trigger).not.toHaveBeenCalledWith("deselected", model);
     });
+
+    it("should not trigger a reselected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
   });
 
   describe("when toggling the selected status of a model that is selected", function(){
diff --git a/spec/javascripts/singleSelect.spec.js b/spec/javascripts/singleSelect.spec.js
index 83b0815..f767c50 100644
--- a/spec/javascripts/singleSelect.spec.js
+++ b/spec/javascripts/singleSelect.spec.js
@@ -1,4 +1,4 @@
-describe("single select collection", function(){
+describe("single-select collection", function(){
 
   var Model = Backbone.Model.extend({
     initialize: function(){
@@ -50,6 +50,10 @@ describe("single select collection", function(){
       expect(model.trigger).toHaveBeenCalledWith("selected", model);
     });
 
+   it("should not trigger a reselected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
+
     it("should trigger a collection select:one event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:one", model);
     });
@@ -69,6 +73,10 @@ describe("single select collection", function(){
     it('should trigger the collection\'s select:one event after the collection status has been updated', function () {
       expect(selectOneEventState.collection.selected).toBe(model);
     });
+
+    it("should not trigger a collection reselect:one event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
   });
 
   describe("when selecting a model via the model's select, with options.silent enabled", function(){
@@ -108,6 +116,7 @@ describe("single select collection", function(){
       collection = new Collection([model]);
 
       spyOn(collection, "trigger").andCallThrough();
+      spyOn(model, "trigger").andCallThrough();
       spyOn(model, "select").andCallThrough();
 
       model.on('selected', function (model) {
@@ -127,10 +136,18 @@ describe("single select collection", function(){
       expect(collection.selected).toBe(model);
     });
 
+    it("should not trigger a reselected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
+
     it("should trigger a select:one event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:one", model);
     });
 
+    it("should not trigger a reselect:one event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
+
     it("should tell the model to select itself", function(){
       expect(model.select).toHaveBeenCalled();
     });
@@ -187,14 +204,47 @@ describe("single select collection", function(){
 
       model.select();
 
+      spyOn(model, "trigger").andCallThrough();
       spyOn(collection, "trigger").andCallThrough();
 
       collection.select(model);
     });
 
-    it("should not trigger a selected event", function(){
+    it("should not trigger a select:one event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:one", model);
     });
+
+    it("should trigger a reselected event", function(){
+      expect(model.trigger).toHaveBeenCalledWith("reselected", model);
+    });
+
+    it("should trigger a reselect:one event", function(){
+      expect(collection.trigger).toHaveBeenCalledWith("reselect:one", model);
+    });
+  });
+
+  describe("when selecting a model that is already selected, with options.silent enabled", function(){
+    var model, collection;
+
+    beforeEach(function(){
+      model = new Model();
+      collection = new Collection([model]);
+
+      model.select();
+
+      spyOn(model, "trigger").andCallThrough();
+      spyOn(collection, "trigger").andCallThrough();
+
+      collection.select(model, {silent: true});
+    });
+
+    it("should not trigger a reselected event", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("reselected", model);
+    });
+
+    it("should not trigger a reselect:one event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:one", model);
+    });
   });
 
   describe("when a model is already selected and selecting a different model", function(){
@@ -216,15 +266,19 @@ describe("single select collection", function(){
       expect(collection.selected).toBe(m2);
     });
 
-    it("should trigger a selected event", function(){
+    it("should trigger a select:one event", function(){
       expect(collection.trigger).toHaveBeenCalledWith("select:one", m2);
     });
 
+    it("should not trigger a reselect:one event", function(){
+      expect(collection.trigger).not.toHaveBeenCalledWith("reselect:one", m2);
+    });
+
     it("should deselect the first model", function(){
       expect(m1.deselect).toHaveBeenCalled();
     });
 
-    it("should fire a deselect event for the first model", function(){
+    it("should fire a deselect:one event for the first model", function(){
       expect(collection.trigger).toHaveBeenCalledWith("deselect:one", m1);
     });
   });
@@ -248,7 +302,7 @@ describe("single select collection", function(){
       expect(collection.selected).toBe(m2);
     });
 
-    it("should not trigger a selected event", function(){
+    it("should not trigger a select:one event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("select:one", m2);
     });
 
@@ -256,23 +310,29 @@ describe("single select collection", function(){
       expect(m1.deselect).toHaveBeenCalled();
     });
 
-    it("should not fire a deselect event for the first model", function(){
+    it("should not fire a deselect:one event for the first model", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", m1);
     });
   });
 
   describe("when no model is selected and deselecting", function(){
-    var collection;
+    var model, collection;
 
     beforeEach(function(){
-      collection = new Collection();
+      model = new Model();
+      collection = new Collection([model]);
 
+      spyOn(model, "trigger").andCallThrough();
       spyOn(collection, "trigger").andCallThrough();
 
       collection.deselect();
     });
 
-    it("should not trigger a selected or deselected event", function(){
+    it("should not trigger a selected, reselected or deselected event on the model", function(){
+      expect(model.trigger).not.toHaveBeenCalled();
+    });
+
+    it("should not trigger a select:one, reselect:one or deselect:one event", function(){
       expect(collection.trigger).not.toHaveBeenCalled();
     });
   });
@@ -387,6 +447,7 @@ describe("single select collection", function(){
       collection = new Collection([model]);
       model.select();
 
+      spyOn(model, "trigger").andCallThrough();
       spyOn(collection, "trigger").andCallThrough();
 
       collection.deselect(undefined, {silent: true});
@@ -396,7 +457,11 @@ describe("single select collection", function(){
       expect(collection.selected).toBeUndefined();
     });
 
-    it("should not trigger a deselected event", function(){
+    it("should not trigger a deselected event on the model", function(){
+      expect(model.trigger).not.toHaveBeenCalledWith("deselected", model);
+    });
+
+    it("should not trigger a deselect:one event", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", model);
     });
   });
@@ -428,11 +493,11 @@ describe("single select collection", function(){
       expect(m1.deselect).not.toHaveBeenCalled();
     });
 
-    it("should not trigger a deselected event for the selected model", function(){
+    it("should not trigger a deselect:one event for the selected model", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", m1);
     });
 
-    it("should not trigger a deselected event for the non-selected model", function(){
+    it("should not trigger a deselect:one event for the non-selected model", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", m2);
     });
   });
@@ -464,11 +529,11 @@ describe("single select collection", function(){
       expect(m1.deselect).not.toHaveBeenCalled();
     });
 
-    it("should not trigger a deselected event for the selected model", function(){
+    it("should not trigger a deselect:one event for the selected model", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", m1);
     });
 
-    it("should not trigger a deselected event for the non-selected model", function(){
+    it("should not trigger a deselect:one event for the non-selected model", function(){
       expect(collection.trigger).not.toHaveBeenCalledWith("deselect:one", m2);
     });
   });

From ff32084d50cf4328d7e82d64b62479f261e86144 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 20 Jan 2014 18:14:51 +0100
Subject: [PATCH 16/18] Updated release notes

---
 readme.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/readme.md b/readme.md
index 15262a6..df1c2a8 100644
--- a/readme.md
+++ b/readme.md
@@ -623,6 +623,15 @@ see all of the specs for Backbone.Picky
 
 ## Release Notes
 
+### pre v0.3.0
+
+* Added support for sharing models among collections
+* Added a `silent` option
+* Improved events, now firing when model and collection are in a consistent state (issue #18)
+* Added `deselectAll`, while keeping `selectNone` around as an alias
+* More comprehensive testing
+* Added config file for the Karma test runner
+
 ### v0.2.0
 
 * Renamed `SingleSelect` events from "select" and "deselect" to "select:one" and "deselect:one"

From 7b9c76c6daaf92c97877889af666d8010f2dab7c Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 20 Jan 2014 21:50:31 +0100
Subject: [PATCH 17/18] Prevented multi-select events from firing if action is
 a no-op (change in spec)

Previously, selectAll fired a select:all event even if all models had already
been selected beforehand. Similarly, deselectAll fired a select:none event
even if no model had been selected in the first place.

No-ops like this don't trigger an event any more.
---
 readme.md                                     |  1 +
 .../multiSelect.deselectAll.spec.js           |  8 +++--
 .../javascripts/multiSelect.selectAll.spec.js |  8 +++--
 src/backbone.picky.js                         | 35 +++++++++++++------
 4 files changed, 35 insertions(+), 17 deletions(-)

diff --git a/readme.md b/readme.md
index df1c2a8..8870bbb 100644
--- a/readme.md
+++ b/readme.md
@@ -625,6 +625,7 @@ see all of the specs for Backbone.Picky
 
 ### pre v0.3.0
 
+* Multi-select events no longer fire when `selectAll`, `deselectAll` actions are a no-op (change in spec)
 * Added support for sharing models among collections
 * Added a `silent` option
 * Improved events, now firing when model and collection are in a consistent state (issue #18)
diff --git a/spec/javascripts/multiSelect.deselectAll.spec.js b/spec/javascripts/multiSelect.deselectAll.spec.js
index 0daa370..085d8d6 100644
--- a/spec/javascripts/multiSelect.deselectAll.spec.js
+++ b/spec/javascripts/multiSelect.deselectAll.spec.js
@@ -28,9 +28,11 @@ describe("multi-select collection: deselectAll", function(){
       collection.deselectAll();
     });
     
-    it("should trigger a select:none event", function(){
-      // todo This is doesn't make sense and is inconsistent with the behaviour elsewhere: an event triggered by a no-op
-      expect(collection.trigger).toHaveBeenCalledWith("select:none", collection);
+    it("should not trigger a select:none event", function(){
+      // NB This is a change in the spec. Up to version 0.2.0, it _did_ trigger
+      // a select:none event. But an event triggered by a no-op didn't make
+      // sense and was inconsistent with the behaviour elsewhere.
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:none", collection);
     });
 
     it("should have a selected count of 0", function(){
diff --git a/spec/javascripts/multiSelect.selectAll.spec.js b/spec/javascripts/multiSelect.selectAll.spec.js
index 7bb9b57..83e0403 100644
--- a/spec/javascripts/multiSelect.selectAll.spec.js
+++ b/spec/javascripts/multiSelect.selectAll.spec.js
@@ -254,9 +254,11 @@ describe("multi-select collection: selectAll", function(){
       collection.selectAll();
     });
     
-    it("should trigger a select:all event", function(){
-      // todo This is doesn't make sense and is inconsistent with the behaviour elsewhere: an event triggered by a no-op
-      expect(collection.trigger).toHaveBeenCalledWith("select:all", collection);
+    it("should not trigger a select:all event", function(){
+      // NB This is a change in the spec. Up to version 0.2.0, it _did_ trigger
+      // a select:all event. But an event triggered by a no-op didn't make sense
+      // and was inconsistent with the behaviour elsewhere.
+      expect(collection.trigger).not.toHaveBeenCalledWith("select:all", collection);
     });
 
     it("should trigger a reselect:any event, with an array containing all models as a parameter", function(){
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index 4df9fc7..553ea8a 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -9,7 +9,7 @@ Backbone.Picky = (function (Backbone, _) {
   // deselected.
 
   Picky.SingleSelect = function(collection, models){
-    this._pickyCid = _.uniqueId('singleSelect-');
+    this._pickyCid = _.uniqueId('singleSelect');
     this.collection = collection;
 
     if (arguments.length > 1) {
@@ -74,7 +74,7 @@ Backbone.Picky = (function (Backbone, _) {
   // capabilities.
 
   Picky.MultiSelect = function (collection, models) {
-    this._pickyCid = _.uniqueId('multiSelect-');
+    this._pickyCid = _.uniqueId('multiSelect');
     this.collection = collection;
     this.selected = {};
 
@@ -103,19 +103,23 @@ Backbone.Picky = (function (Backbone, _) {
     // model knows it's selected, and hold on to
     // the selected model.
     select: function (model, options) {
+      var prevSelectedCids = _.keys(this.selected);
+
       if (this.selected[model.cid]) { return; }
 
       this.selected[model.cid] = model;
       this.selectedLength = _.size(this.selected);
 
       model.select(_.omit(options, "_localSilent"));
-      triggerMultiSelectEvents(this, options);
+      triggerMultiSelectEvents(this, prevSelectedCids, options);
     },
 
     // Deselect a specified model, make sure the
     // model knows it has been deselected, and remove
     // the model from the selected list.
     deselect: function (model, options) {
+      var prevSelectedCids = _.keys(this.selected);
+
       options || (options = {});
       if (!this.selected[model.cid]) { return; }
 
@@ -123,29 +127,35 @@ Backbone.Picky = (function (Backbone, _) {
       this.selectedLength = _.size(this.selected);
 
       if (!options._skipModelCall) model.deselect(_.omit(options, "_localSilent"));
-      triggerMultiSelectEvents(this, options);
+      triggerMultiSelectEvents(this, prevSelectedCids, options);
     },
 
     // Select all models in this collection
     selectAll: function (options) {
+      var prevSelectedCids = _.keys(this.selected);
+
       this.selectedLength = 0;
       this.each(function (model) {
         this.selectedLength++;
-        model.select(_.omit(options, "_localSilent"));
+        this.select(model, _.extend({}, options, {_localSilent: true}));
       }, this);
-      triggerMultiSelectEvents(this, options);
+      triggerMultiSelectEvents(this, prevSelectedCids, options);
     },
 
     // Deselect all models in this collection
     deselectAll: function (options) {
+      var prevSelectedCids;
+
       if (this.selectedLength === 0) { return; }
+      prevSelectedCids = _.keys(this.selected);
+
       this.each(function (model) {
         if (model.selected) this.selectedLength--;
-        model.deselect(_.omit(options, "_localSilent"));
+        this.deselect(model, _.extend({}, options, {_localSilent: true}));
       }, this);
 
       this.selectedLength = 0;
-      triggerMultiSelectEvents(this, options);
+      triggerMultiSelectEvents(this, prevSelectedCids, options);
     },
 
     selectNone: function (options) {
@@ -236,12 +246,15 @@ Backbone.Picky = (function (Backbone, _) {
 
   // Trigger events from a multi-select collection based on the number of
   // selected items.
-  var triggerMultiSelectEvents = function (collection, options) {
+  var triggerMultiSelectEvents = function (collection, prevSelectedCids, options) {
     options || (options = {});
     if (options.silent || options._localSilent) return;
 
-    var selectedLength = collection.selectedLength;
-    var length = collection.length;
+    var selectedLength = collection.selectedLength,
+        length = collection.length,
+        unchanged = (selectedLength === prevSelectedCids.length && _.intersection(_.keys(collection.selected), prevSelectedCids).length === selectedLength);
+
+    if (unchanged) return;
 
     if (selectedLength === length) {
       collection.trigger("select:all", collection);

From dbfd613a5eadad4e7475488bca204feb159c10a3 Mon Sep 17 00:00:00 2001
From: hashchange <heim@zeilenwechsel.de>
Date: Mon, 20 Jan 2014 22:27:11 +0100
Subject: [PATCH 18/18] Added reselection events

---
 readme.md             |  29 ++++++++++--
 src/backbone.picky.js | 104 +++++++++++++++++++++++++++++-------------
 2 files changed, 98 insertions(+), 35 deletions(-)

diff --git a/readme.md b/readme.md
index 8870bbb..9bcf64f 100644
--- a/readme.md
+++ b/readme.md
@@ -200,6 +200,11 @@ as the first parameter.
 Triggers when a model is deselected. Provides the selected model
 as the first parameter.
 
+#### "reselected"
+
+Triggers when a model, which is already selected, is selected again. Provides
+the re-selected model as the first parameter.
+
 ## Picky.SingleSelect
 
 Creates single-select capabilities for a `Backbone.Collection`, allowing
@@ -340,7 +345,12 @@ Triggered when a model has been deselected. Provides the deselected model
 as the first parameter.
 
 This fires whether `deselect` has been called explicitly, or the
-selection is being replace through another call to `select`.
+selection is being replaced through another call to `select`.
+
+#### "reselect:one"
+
+Triggered when a model, which is already selected, is selected again. Provides
+the selected model as the first parameter.
 
 ## Picky.MultiSelect
 
@@ -521,16 +531,26 @@ the `silent` option, as in `myCol.select(myModel, {silent: true})`.
 
 #### "select:all"
 
-Triggered when all models have been selected
+Triggered when all models have been selected.
 
 #### "select:none"
 
-Triggered when all models have been deselected
+Triggered when all models have been deselected.
 
 #### "select:some"
 
 Triggered when at least 1 model is selected, but less than all models have
-been selected
+been selected.
+
+#### "reselect:any"
+
+Triggered when at least one model, which is already selected, is selected again.
+Provides an array of the re-selected models as the first parameter.
+
+In contrast to the other events, this event fires even if there isn't any change
+in the resulting selection at all. Note that there is no separate reselect:all
+event; the re-selection of all items in the collection is also covered by
+`reselect:any`.
 
 ## Sharing models among collections
 
@@ -625,6 +645,7 @@ see all of the specs for Backbone.Picky
 
 ### pre v0.3.0
 
+* New events capture when models are re-selected: `reselected` (model), `reselect:one` (single-select collection), `reselect:any` (multi-select collection)
 * Multi-select events no longer fire when `selectAll`, `deselectAll` actions are a no-op (change in spec)
 * Added support for sharing models among collections
 * Added a `silent` option
diff --git a/src/backbone.picky.js b/src/backbone.picky.js
index 553ea8a..ec26ff6 100644
--- a/src/backbone.picky.js
+++ b/src/backbone.picky.js
@@ -36,14 +36,27 @@ Backbone.Picky = (function (Backbone, _) {
     // Select a model, deselecting any previously
     // selected model
     select: function(model, options){
+      var reselected = model && this.selected === model ? model : undefined;
+
       options || (options = {});
-      if (model && this.selected === model) { return; }
+      options._processedBy || (options._processedBy = []);
+      if (options._processedBy[this._pickyCid]) { return; }
+
+      if (!reselected) {
+        this.deselect(undefined, _.omit(options, "_silentLocally"));
+        this.selected = model;
+      }
+      options._processedBy[this._pickyCid] = this;
 
-      this.deselect(undefined, _.omit(options, "_localSilent"));
+      if (!options._processedBy[this.selected.cid]) this.selected.select(_.omit(options, "_silentLocally"));
 
-      this.selected = model;
-      this.selected.select(_.omit(options, "_localSilent"));
-      if (!(options.silent || options._localSilent)) this.trigger("select:one", model);
+      if (!(options.silent || options._silentLocally)) {
+        if (reselected) {
+          if (!options._silentReselect) this.trigger("reselect:one", model);
+        } else {
+          this.trigger("select:one", model);
+        }
+      }
     },
 
     // Deselect a model, resulting in no model
@@ -56,8 +69,8 @@ Backbone.Picky = (function (Backbone, _) {
       if (this.selected !== model){ return; }
 
       delete this.selected;
-      if (!options._skipModelCall) model.deselect(_.omit(options, "_localSilent"));
-      if (!(options.silent || options._localSilent)) this.trigger("deselect:one", model);
+      if (!options._skipModelCall) model.deselect(_.omit(options, "_silentLocally"));
+      if (!(options.silent || options._silentLocally)) this.trigger("deselect:one", model);
     },
 
     close: function () {
@@ -103,15 +116,22 @@ Backbone.Picky = (function (Backbone, _) {
     // model knows it's selected, and hold on to
     // the selected model.
     select: function (model, options) {
-      var prevSelectedCids = _.keys(this.selected);
+      var prevSelectedCids = _.keys(this.selected),
+          reselected = this.selected[model.cid] ? [ model ] : [];
 
-      if (this.selected[model.cid]) { return; }
+      options || (options = {});
+      options._processedBy || (options._processedBy = []);
 
-      this.selected[model.cid] = model;
-      this.selectedLength = _.size(this.selected);
+      if (reselected.length && options._processedBy[this._pickyCid]) { return; }
 
-      model.select(_.omit(options, "_localSilent"));
-      triggerMultiSelectEvents(this, prevSelectedCids, options);
+      if (!reselected.length) {
+        this.selected[model.cid] = model;
+        this.selectedLength = _.size(this.selected);
+      }
+      options._processedBy[this._pickyCid] = this;
+
+      if (!options._processedBy[model.cid]) model.select(_.omit(options, "_silentLocally"));
+      triggerMultiSelectEvents(this, prevSelectedCids, options, reselected);
     },
 
     // Deselect a specified model, make sure the
@@ -126,20 +146,27 @@ Backbone.Picky = (function (Backbone, _) {
       delete this.selected[model.cid];
       this.selectedLength = _.size(this.selected);
 
-      if (!options._skipModelCall) model.deselect(_.omit(options, "_localSilent"));
+      if (!options._skipModelCall) model.deselect(_.omit(options, "_silentLocally"));
       triggerMultiSelectEvents(this, prevSelectedCids, options);
     },
 
     // Select all models in this collection
     selectAll: function (options) {
-      var prevSelectedCids = _.keys(this.selected);
+      var prevSelectedCids = _.keys(this.selected),
+          reselected = [];
+
+      options || (options = {});
+      options._processedBy || (options._processedBy = []);
 
       this.selectedLength = 0;
       this.each(function (model) {
         this.selectedLength++;
-        this.select(model, _.extend({}, options, {_localSilent: true}));
+        if (this.selected[model.cid]) reselected.push(model);
+        this.select(model, _.extend({}, options, {_silentLocally: true}));
       }, this);
-      triggerMultiSelectEvents(this, prevSelectedCids, options);
+      options._processedBy[this._pickyCid] = this;
+
+      triggerMultiSelectEvents(this, prevSelectedCids, options, reselected);
     },
 
     // Deselect all models in this collection
@@ -151,7 +178,7 @@ Backbone.Picky = (function (Backbone, _) {
 
       this.each(function (model) {
         if (model.selected) this.selectedLength--;
-        this.deselect(model, _.extend({}, options, {_localSilent: true}));
+        this.deselect(model, _.extend({}, options, {_silentLocally: true}));
       }, this);
 
       this.selectedLength = 0;
@@ -193,21 +220,32 @@ Backbone.Picky = (function (Backbone, _) {
     // Select this model, and tell our
     // collection that we're selected
     select: function (options) {
+      var reselected = this.selected;
+
       options || (options = {});
-      if (this.selected) { return; }
+      options._processedBy || (options._processedBy = []);
+
+      if (options._processedBy[this.cid]) { return; }
 
       this.selected = true;
+      options._processedBy[this.cid] = this;
 
       if (this._pickyCollections) {
         // Model-sharing mode: notify collections with an event
-        this.trigger("_selected", this, _.omit(options, "_localSilent"));
+        this.trigger("_selected", this, _.omit(options, "_silentLocally"));
       } else if (this.collection) {
         // Single collection only: no event listeners set up in collection, call
         // it directly
-        this.collection.select(this, _.omit(options, "_localSilent"));
+        if (!options._processedBy[this.collection._pickyCid]) this.collection.select(this, _.omit(options, "_silentLocally"));
       }
 
-      if (!(options.silent || options._localSilent)) this.trigger("selected", this);
+      if (!(options.silent || options._silentLocally)) {
+        if (reselected) {
+          if (!options._silentReselect) this.trigger("reselected", this);
+        } else {
+          this.trigger("selected", this);
+        }
+      }
     },
 
     // Deselect this model, and tell our
@@ -220,14 +258,14 @@ Backbone.Picky = (function (Backbone, _) {
 
       if (this._pickyCollections) {
         // Model-sharing mode: notify collections with an event
-        this.trigger("_deselected", this, _.omit(options, "_localSilent"));
+        this.trigger("_deselected", this, _.omit(options, "_silentLocally"));
       } else if (this.collection) {
         // Single collection only: no event listeners set up in collection, call
         // it directly
-        this.collection.deselect(this, _.omit(options, "_localSilent"));
+        this.collection.deselect(this, _.omit(options, "_silentLocally"));
       }
 
-      if (!(options.silent || options._localSilent)) this.trigger("deselected", this);
+      if (!(options.silent || options._silentLocally)) this.trigger("deselected", this);
     },
 
     // Change selected to the opposite of what
@@ -246,14 +284,18 @@ Backbone.Picky = (function (Backbone, _) {
 
   // Trigger events from a multi-select collection based on the number of
   // selected items.
-  var triggerMultiSelectEvents = function (collection, prevSelectedCids, options) {
+  var triggerMultiSelectEvents = function (collection, prevSelectedCids, options, reselected) {
     options || (options = {});
-    if (options.silent || options._localSilent) return;
+    if (options.silent || options._silentLocally) return;
 
     var selectedLength = collection.selectedLength,
         length = collection.length,
         unchanged = (selectedLength === prevSelectedCids.length && _.intersection(_.keys(collection.selected), prevSelectedCids).length === selectedLength);
 
+    if (reselected && reselected.length && !options._silentReselect) {
+      collection.trigger("reselect:any", reselected);
+    }
+
     if (unchanged) return;
 
     if (selectedLength === length) {
@@ -274,7 +316,7 @@ Backbone.Picky = (function (Backbone, _) {
 
   function onAdd (model, collection) {
     registerCollectionWithModel(model, collection);
-    if (model.selected) collection.select(model);
+    if (model.selected) collection.select(model, {_silentReselect: true});
   }
 
   function onRemove (model, collection, options) {
@@ -293,7 +335,7 @@ Backbone.Picky = (function (Backbone, _) {
         excessiveSelections,
         deselectOnRemove = _.find(options.previousModels, function (model) { return model.selected; });
 
-    if (deselectOnRemove) onRemove(deselectOnRemove, collection, {_localSilent: true});
+    if (deselectOnRemove) onRemove(deselectOnRemove, collection, {_silentLocally: true});
 
     selected = collection.filter(function (model) { return model.selected; });
     excessiveSelections = _.initial(selected);
@@ -305,7 +347,7 @@ Backbone.Picky = (function (Backbone, _) {
     var select,
         deselect = _.filter(options.previousModels, function (model) { return model.selected; });
 
-    if (deselect) _.each(deselect, function (model) { onRemove(model, collection, {_localSilent: true}); });
+    if (deselect) _.each(deselect, function (model) { onRemove(model, collection, {_silentLocally: true}); });
 
     select = collection.filter(function (model) { return model.selected; });
     if (select.length) _.each(select, function (model) { collection.select(model, {silent: true}); });
@@ -318,7 +360,7 @@ Backbone.Picky = (function (Backbone, _) {
 
   function unregisterCollectionWithModels (collection) {
     collection.each(function (model) {
-      onRemove(model, collection, {_localSilent: true});
+      onRemove(model, collection, {_silentLocally: true});
     });
   }