├── .editorconfig
├── .gitignore
├── .jshintrc
├── .npmignore
├── .travis.yml
├── CHANGELOG.md
├── NOTES.md
├── README.md
├── bower.json
├── component.json
├── dist
    ├── ractive-adaptors-backbone.js
    └── ractive-adaptors-backbone.min.js
├── gobblefile.js
├── package.json
├── src
    └── ractive-adaptors-backbone.js
├── test
    └── test.js
└── vendor
    ├── backbone
        ├── backbone-1.0.0.js
        └── backbone-1.1.2.js
    └── ractive
        ├── ractive-0.4.0.js
        ├── ractive-0.5.0.js
        ├── ractive-0.5.8.js
        ├── ractive-0.6.0.js
        └── ractive-0.7.2.js


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | indent_style = tab
 5 | end_of_line = lf
 6 | insert_final_newline = true
 7 | 
 8 | [*.js]
 9 | ; npmjs.org/package/codepainter
10 | quote_type = single
11 | space_after_anonymous_functions = true
12 | space_after_control_statements = true
13 | spaces_around_operators = true
14 | trim_trailing_whitespace = true
15 | spaces_in_brackets = hybrid
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .gobble-build
2 | !.gitignore
3 | node_modules/
4 | tmp/
5 | coverage.html
6 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
1 | {
2 | 	"esnext": true,
3 | 	"undef": true,
4 | 	"unused": true,
5 | 	"globals": {
6 | 		"window": true
7 | 	}
8 | }


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | test
2 | vendor
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "0.10"
4 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | ## v0.3.0 - April 6, 2015
 2 | 
 3 | * Adaptor no longer self-registers in a module environment, and no longer has a dependency on Ractive or Backbone (@rich-harris, #31)
 4 | 
 5 | * Internal: Rewrote as ES6 module (@rich-harris, #31)
 6 | 
 7 | ## v0.2.0 - October 4, 2014
 8 | 
 9 | This release brings better compatibility with Ractive 0.6.x and Backbone 1.1.x.
10 | 
11 | * Fix infinite loop issue that arises when one model is wrapped twice.
12 |   (@anton-ryzhov, #21)
13 | 
14 | * Fix nested collections support. (#13)
15 | 
16 | * Internal: update test suite to Mocha. (@rstacruz, #17, #18)
17 | 
18 | * Internal: remove Grunt dependency. (@rstacruz, #25, #26)
19 | 
20 | * List Backbone and Ractive as peer dependencies. (@rstacruz, #19)
21 | 
22 | * Update required versions of Backbone and Ractive to allow future versions.
23 |   (@rstacruz, #19)
24 | 
25 | * Use Backbone's `model.set` instead of `model.reset`. Fixes Backbone 1.1.2
26 |   support. (@browniefed, #12, #10)
27 | 
28 | ## v0.1.1 - June 9, 2014
29 | 
30 | * BREAKING CHANGE: Rename to `ractive-adaptors-backbone`.
31 | 
32 | * Fix `reset` issue when performing `set('model', null)`. (@bartsqueezy, #3)
33 | 
34 | * Fix browserify compatibility. (@ahdinosaur, #1)
35 | 
36 | ## v0.1.0 - October 30, 2013
37 | 
38 | * Initial release as `ractive-backbone`.
39 | 


--------------------------------------------------------------------------------
/NOTES.md:
--------------------------------------------------------------------------------
 1 | Developer notes
 2 | ===============
 3 | 
 4 | Testing:
 5 | 
 6 |     npm test
 7 | 
 8 | Building .min.js:
 9 | 
10 |     npm run prepublish
11 | 
12 | Releasing new versions:
13 | 
14 |     # update version numbers
15 |       bump *.json *bone.js
16 | 
17 |     # update changelog with date
18 |       vim CHANGELOG.md
19 | 
20 |     # test
21 |       npm test
22 | 
23 |     # publish to npm (this will already build .min)
24 |       npm publish
25 | 
26 |       git release v1.0.0
27 | 
28 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ractive-adaptors-backbone
 2 | 
 3 | Use Backbone models and collections in your [Ractive] components.<br>
 4 | **[View demo ›][Example]**
 5 | 
 6 | [![Status](http://img.shields.io/travis/ractivejs/ractive-adaptors-backbone/master.svg?style=flat)](https://travis-ci.org/ractivejs/ractive-adaptors-backbone "See test builds")
 7 | 
 8 | *Find more Ractive.js plugins at
 9 | [docs.ractivejs.org/latest/plugins](http://docs.ractivejs.org/latest/plugins)*
10 | 
11 | ## Installation
12 | 
13 | Include `ractive-adaptors-backbone.min.js` on your page below Ractive, e.g:
14 | 
15 | ```html
16 | <script src='lib/ractive.min.js'></script>
17 | <script src='lib/ractive-adaptors-backbone.min.js'></script>
18 | ```
19 | 
20 | To get ractive-adaptors-backbone you can:
21 | 
22 | #### Use CDN
23 | 
24 |     https://cdn.jsdelivr.net/npm/ractive-adaptors-backbone@0.3.0/dist/ractive-adaptors-backbone.min.js
25 | 
26 | #### Use bower
27 | 
28 |     $ bower i ractive-adaptors-backbone
29 | 
30 | #### Use npm
31 | 
32 |     $ npm install --save ractive-adaptors-backbone
33 | 
34 | #### Download
35 | 
36 | - [Download the latest release](https://github.com/ractivejs/ractive-adaptors-backbone/releases).
37 | 
38 | ## Usage
39 | 
40 | If you're using `<script>` tags to manage your dependencies, everything is already set up, and you can use the adaptor like so:
41 | 
42 | ```js
43 | var user = new Backbone.Model({
44 |   name: 'world'
45 | });
46 | 
47 | var ractive = new Ractive({
48 |   el: 'main',
49 |   template: '<h1>Hello {{user.name}}!</h1>',
50 |   data: {
51 |     user: user
52 |   }
53 | });
54 | 
55 | // If you interact with the model, the view will change
56 | user.set( 'name', 'everybody' );
57 | ```
58 | 
59 | If `Backbone` isn't a global variable (e.g. you're using Browserify or RequireJS), you need to *register* it:
60 | 
61 | ```js
62 | // Example with CommonJS modules - it also works with AMD
63 | var Backbone = require( 'backbone' );
64 | var Ractive = require( 'ractive' );
65 | var backboneAdaptor = require( 'ractive-adaptors-backbone' );
66 | 
67 | backboneAdaptor.Backbone = Backbone;
68 | 
69 | var ractive = new Ractive({
70 |   el: 'main',
71 |   template: '<h1>Hello {{user.name}}!</h1>',
72 |   data: {
73 |     user: user
74 |   },
75 | 
76 |   // this line tells Ractive to look out
77 |   // for Backbone models
78 |   adapt: [ backboneAdaptor ]
79 | });
80 | ```
81 | 
82 | 
83 | ## License
84 | 
85 | MIT
86 | 
87 | [Example]: http://examples.ractivejs.org/backbone
88 | [Ractive]: http://www.ractivejs.org
89 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "ractive-backbone",
 3 | 	"description": "Backbone adaptor for Ractive.js",
 4 | 	"version": "0.3.0",
 5 | 	"author": "Rich Harris",
 6 | 	"license": "MIT",
 7 | 	"main": "dist/ractive-adaptors-backbone.js",
 8 | 	"ignore": [
 9 | 		"**/.*",
10 | 		"src",
11 | 		"test",
12 | 		"Gruntfile.js"
13 | 	],
14 | 	"repository": {
15 | 		"type": "git",
16 | 		"url": "https://github.com/ractivejs/ractive-adaptors-backbone.git"
17 | 	},
18 | 	"keywords": [
19 | 		"backbone",
20 | 		"ractive",
21 | 		"data binding",
22 | 		"templates"
23 | 	]
24 | }
25 | 


--------------------------------------------------------------------------------
/component.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ractive-adaptors-backbone",
 3 |   "repository": "ractivejs/ractive-adaptors-backbone",
 4 |   "description": "Backbone adaptor for Ractive.js",
 5 |   "version": "0.3.0",
 6 |   "keywords": [
 7 |     "backbone",
 8 |     "ractive",
 9 |     "data binding",
10 |     "templates"
11 |   ],
12 |   "license": "MIT",
13 |   "dependencies": {
14 |     "ractivejs/ractive": "*"
15 |   },
16 |   "main": "dist/ractive-adaptors-backbone.js",
17 |   "scripts": [
18 |     "dist/ractive-adaptors-backbone.js"
19 |   ]
20 | }
21 | 


--------------------------------------------------------------------------------
/dist/ractive-adaptors-backbone.js:
--------------------------------------------------------------------------------
  1 | (function (global, factory) {
  2 | 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  3 | 	typeof define === 'function' && define.amd ? define(factory) :
  4 | 	global.Ractive.adaptors.Backbone = factory()
  5 | }(this, function () { 'use strict';
  6 | 
  7 | 	var lockProperty = "_ractiveAdaptorsBackboneLock";
  8 | 
  9 | 	function acquireLock(key) {
 10 | 		key[lockProperty] = (key[lockProperty] || 0) + 1;
 11 | 		return function release() {
 12 | 			key[lockProperty] -= 1;
 13 | 			if (!key[lockProperty]) {
 14 | 				delete key[lockProperty];
 15 | 			}
 16 | 		};
 17 | 	}
 18 | 
 19 | 	function isLocked(key) {
 20 | 		return !!key[lockProperty];
 21 | 	}
 22 | 
 23 | 	var adaptor = {
 24 | 		// self-init, if being used as a <script> tag
 25 | 		Backbone: typeof window !== "undefined" && window.Backbone || null,
 26 | 
 27 | 		filter: function filter(object) {
 28 | 			if (!adaptor.Backbone) {
 29 | 				throw new Error("Could not find Backbone. You must call adaptor.init(Backbone) - see http://TKTKTK.com for more information");
 30 | 			}
 31 | 			return object instanceof adaptor.Backbone.Model || object instanceof adaptor.Backbone.Collection;
 32 | 		},
 33 | 		wrap: function wrap(ractive, object, keypath, prefix) {
 34 | 			if (object instanceof adaptor.Backbone.Model) {
 35 | 				return new BackboneModelWrapper(ractive, object, keypath, prefix);
 36 | 			}
 37 | 
 38 | 			return new BackboneCollectionWrapper(ractive, object, keypath, prefix);
 39 | 		}
 40 | 	};
 41 | 
 42 | 	function BackboneModelWrapper(ractive, model, keypath, prefix) {
 43 | 		this.value = model;
 44 | 
 45 | 		model.on("change", this.modelChangeHandler = function () {
 46 | 			var release = acquireLock(model);
 47 | 			ractive.set(prefix(model.changed));
 48 | 			release();
 49 | 		});
 50 | 	}
 51 | 
 52 | 	BackboneModelWrapper.prototype = {
 53 | 		teardown: function teardown() {
 54 | 			this.value.off("change", this.modelChangeHandler);
 55 | 		},
 56 | 		get: function get() {
 57 | 			return this.value.toJSON();
 58 | 		},
 59 | 		set: function set(keypath, value) {
 60 | 			// Only set if the model didn't originate the change itself, and
 61 | 			// only if it's an immediate child property
 62 | 			if (!isLocked(this.value) && keypath.indexOf(".") === -1) {
 63 | 				this.value.set(keypath, value);
 64 | 			}
 65 | 		},
 66 | 		reset: function reset(object) {
 67 | 			// If the new object is a Backbone model, assume this one is
 68 | 			// being retired. Ditto if it's not a model at all
 69 | 			if (object instanceof adaptor.Backbone.Model || !(object instanceof Object)) {
 70 | 				return false;
 71 | 			}
 72 | 
 73 | 			// Otherwise if this is a POJO, reset the model
 74 | 			//Backbone 1.1.2 no longer has reset and just uses set
 75 | 			this.value.set(object);
 76 | 		}
 77 | 	};
 78 | 
 79 | 	function BackboneCollectionWrapper(ractive, collection, keypath) {
 80 | 		this.value = collection;
 81 | 
 82 | 		collection.on("add remove reset sort", this.changeHandler = function () {
 83 | 			// TODO smart merge. It should be possible, if awkward, to trigger smart
 84 | 			// updates instead of a blunderbuss .set() approach
 85 | 			var release = acquireLock(collection);
 86 | 			ractive.set(keypath, collection.models);
 87 | 			release();
 88 | 		});
 89 | 	}
 90 | 
 91 | 	BackboneCollectionWrapper.prototype = {
 92 | 		teardown: function teardown() {
 93 | 			this.value.off("add remove reset sort", this.changeHandler);
 94 | 		},
 95 | 		get: function get() {
 96 | 			return this.value.models;
 97 | 		},
 98 | 		reset: function reset(models) {
 99 | 			if (isLocked(this.value)) {
100 | 				return;
101 | 			}
102 | 
103 | 			// If the new object is a Backbone collection, assume this one is
104 | 			// being retired. Ditto if it's not a collection at all
105 | 			if (models instanceof adaptor.Backbone.Collection || Object.prototype.toString.call(models) !== "[object Array]") {
106 | 				return false;
107 | 			}
108 | 
109 | 			// Otherwise if this is a plain array, reset the collection
110 | 			this.value.reset(models);
111 | 		}
112 | 	};
113 | 
114 | 	var ractive_adaptors_backbone = adaptor;
115 | 
116 | 	return ractive_adaptors_backbone;
117 | 
118 | }));


--------------------------------------------------------------------------------
/dist/ractive-adaptors-backbone.min.js:
--------------------------------------------------------------------------------
1 | (function(e,n){typeof exports==="object"&&typeof module!=="undefined"?module.exports=n():typeof define==="function"&&define.amd?define(n):e.Ractive.adaptors.Backbone=n()})(this,function(){"use strict";var e="_ractiveAdaptorsBackboneLock";function n(n){n[e]=(n[e]||0)+1;return function t(){n[e]-=1;if(!n[e]){delete n[e]}}}function t(n){return!!n[e]}var o={Backbone:typeof window!=="undefined"&&window.Backbone||null,filter:function c(e){if(!o.Backbone){throw new Error("Could not find Backbone. You must call adaptor.init(Backbone) - see http://TKTKTK.com for more information")}return e instanceof o.Backbone.Model||e instanceof o.Backbone.Collection},wrap:function f(e,n,t,r){if(n instanceof o.Backbone.Model){return new i(e,n,t,r)}return new a(e,n,t,r)}};function i(e,t,o,i){this.value=t;t.on("change",this.modelChangeHandler=function(){var o=n(t);e.set(i(t.changed));o()})}i.prototype={teardown:function u(){this.value.off("change",this.modelChangeHandler)},get:function s(){return this.value.toJSON()},set:function l(e,n){if(!t(this.value)&&e.indexOf(".")===-1){this.value.set(e,n)}},reset:function d(e){if(e instanceof o.Backbone.Model||!(e instanceof Object)){return false}this.value.set(e)}};function a(e,t,o){this.value=t;t.on("add remove reset sort",this.changeHandler=function(){var i=n(t);e.set(o,t.models);i()})}a.prototype={teardown:function h(){this.value.off("add remove reset sort",this.changeHandler)},get:function v(){return this.value.models},reset:function p(e){if(t(this.value)){return}if(e instanceof o.Backbone.Collection||Object.prototype.toString.call(e)!=="[object Array]"){return false}this.value.reset(e)}};var r=o;return r});


--------------------------------------------------------------------------------
/gobblefile.js:
--------------------------------------------------------------------------------
 1 | var gobble = require( 'gobble' );
 2 | 
 3 | gobble.cwd( __dirname );
 4 | 
 5 | module.exports = gobble( 'src' )
 6 | .transform( 'babel', {
 7 | 	blacklist: [ 'es6.modules', 'useStrict' ],
 8 | 	sourceMap: false
 9 | })
10 | .transform( 'esperanto-bundle', {
11 | 	entry: 'ractive-adaptors-backbone',
12 | 	type: 'umd',
13 | 	name: 'Ractive.adaptors.Backbone',
14 | 	sourceMap: false
15 | });


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ractive-adaptors-backbone",
 3 |   "description": "Backbone adaptor for Ractive.js",
 4 |   "version": "0.3.0",
 5 |   "homepage": "http://ractivejs.org",
 6 |   "main": "dist/ractive-adaptors-backbone.js",
 7 |   "jsnext:main": "src/ractive-adaptors-backbone.js",
 8 |   "author": {
 9 |     "name": "Rich Harris"
10 |   },
11 |   "licenses": [
12 |     {
13 |       "type": "MIT"
14 |     }
15 |   ],
16 |   "repository": {
17 |     "type": "git",
18 |     "url": "https://github.com/ractivejs/ractive-adaptors-backbone.git"
19 |   },
20 |   "scripts": {
21 |     "build": "rm -rf dist; gobble build dist",
22 |     "test": "jshint src/ractive-adaptors-backbone.js && mocha",
23 |     "coverage": "(cp rdist/active-adaptors-backbone.js dist/ractive-adaptors-backbone.js~; jscoverage rdist/active-adaptors-backbone.js; mv dist/ractive-adaptors-backbone-cov.js dist/ractive-adaptors-backbone.js; mocha -R html-cov > coverage.html); mv dist/ractive-adaptors-backbone.js~ dist/ractive-adaptors-backbone.js",
24 |     "prepublish": "npm run build; uglifyjs -m < dist/ractive-adaptors-backbone.js > dist/ractive-adaptors-backbone.min.js"
25 |   },
26 |   "devDependencies": {
27 |     "backbone": ">= 1.0.0",
28 |     "chai": "^1.9.2",
29 |     "gobble": "^0.7.8",
30 |     "gobble-babel": "^4.0.1",
31 |     "gobble-cli": "^0.3.5",
32 |     "gobble-esperanto-bundle": "^0.1.7",
33 |     "jshint": "^2.5.6",
34 |     "mocha": "^1.21.4",
35 |     "mocha-clean": "^0.2.1",
36 |     "mocha-repeat": "^0.1.0",
37 |     "proxyquire": "^1.0.1",
38 |     "ractive": ">= 0.3.9",
39 |     "uglify-js": "^2.4.15",
40 |     "underscore": "^1.7.0"
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/ractive-adaptors-backbone.js:
--------------------------------------------------------------------------------
  1 | const lockProperty = '_ractiveAdaptorsBackboneLock';
  2 | 
  3 | function acquireLock( key ) {
  4 | 	key[lockProperty] = ( key[lockProperty] || 0 ) + 1;
  5 | 	return function release() {
  6 | 		key[lockProperty] -= 1;
  7 | 		if ( !key[lockProperty] ) {
  8 | 			delete key[lockProperty];
  9 | 		}
 10 | 	};
 11 | }
 12 | 
 13 | function isLocked( key ) {
 14 | 	return !!key[lockProperty];
 15 | }
 16 | 
 17 | const adaptor = {
 18 | 	// self-init, if being used as a <script> tag
 19 | 	Backbone: ( typeof window !== 'undefined' && window.Backbone ) || null,
 20 | 
 21 | 	filter ( object ) {
 22 | 		if ( !adaptor.Backbone ) {
 23 | 			throw new Error( 'Could not find Backbone. You must do `adaptor.Backbone = Backbone` - see https://github.com/ractivejs/ractive-adaptors-backbone#installation for more information' );
 24 | 		}
 25 | 		return object instanceof adaptor.Backbone.Model || object instanceof adaptor.Backbone.Collection;
 26 | 	},
 27 | 	wrap ( ractive, object, keypath, prefix ) {
 28 | 		if ( object instanceof adaptor.Backbone.Model ) {
 29 | 			return new BackboneModelWrapper( ractive, object, keypath, prefix );
 30 | 		}
 31 | 
 32 | 		return new BackboneCollectionWrapper( ractive, object, keypath, prefix );
 33 | 	}
 34 | };
 35 | 
 36 | function BackboneModelWrapper ( ractive, model, keypath, prefix ) {
 37 | 	this.value = model;
 38 | 
 39 | 	model.on( 'change', this.modelChangeHandler = function () {
 40 | 		const release = acquireLock( model );
 41 | 		ractive.set( prefix( model.changed ) );
 42 | 		release();
 43 | 	});
 44 | }
 45 | 
 46 | BackboneModelWrapper.prototype = {
 47 | 	teardown () {
 48 | 		this.value.off( 'change', this.modelChangeHandler );
 49 | 	},
 50 | 	get () {
 51 | 		return this.value.toJSON();
 52 | 	},
 53 | 	set ( keypath, value ) {
 54 | 		// Only set if the model didn't originate the change itself, and
 55 | 		// only if it's an immediate child property
 56 | 		if ( !isLocked( this.value ) && keypath.indexOf( '.' ) === -1 ) {
 57 | 			this.value.set( keypath, value );
 58 | 		}
 59 | 	},
 60 | 	reset ( object ) {
 61 | 		// If the new object is a Backbone model, assume this one is
 62 | 		// being retired. Ditto if it's not a model at all
 63 | 		if ( object instanceof adaptor.Backbone.Model || !(object instanceof Object) ) {
 64 | 			return false;
 65 | 		}
 66 | 
 67 | 		// Otherwise if this is a POJO, reset the model
 68 | 		//Backbone 1.1.2 no longer has reset and just uses set
 69 | 		this.value.set( object );
 70 | 	}
 71 | };
 72 | 
 73 | function BackboneCollectionWrapper ( ractive, collection, keypath ) {
 74 | 	this.value = collection;
 75 | 
 76 | 	collection.on( 'add remove reset sort', this.changeHandler = function () {
 77 | 		// TODO smart merge. It should be possible, if awkward, to trigger smart
 78 | 		// updates instead of a blunderbuss .set() approach
 79 | 		const release = acquireLock( collection );
 80 | 		ractive.set( keypath, collection.models );
 81 | 		release();
 82 | 	});
 83 | }
 84 | 
 85 | BackboneCollectionWrapper.prototype = {
 86 | 	teardown () {
 87 | 		this.value.off( 'add remove reset sort', this.changeHandler );
 88 | 	},
 89 | 	get () {
 90 | 		return this.value.models;
 91 | 	},
 92 | 	reset ( models ) {
 93 | 		if ( isLocked( this.value ) ) {
 94 | 			return;
 95 | 		}
 96 | 
 97 | 		// If the new object is a Backbone collection, assume this one is
 98 | 		// being retired. Ditto if it's not a collection at all
 99 | 		if ( models instanceof adaptor.Backbone.Collection || Object.prototype.toString.call( models ) !== '[object Array]' ) {
100 | 			return false;
101 | 		}
102 | 
103 | 		// Otherwise if this is a plain array, reset the collection
104 | 		this.value.reset( models );
105 | 	}
106 | };
107 | 
108 | export default adaptor;


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
  1 | /* jshint expr: true */
  2 | require( 'mocha-clean/brief' );
  3 | var mdescribe = require( 'mocha-repeat' );
  4 | var expect    = require( 'chai' ).expect;
  5 | var proxy     = require( 'proxyquire' );
  6 | 
  7 | var libs = {
  8 | 	ractive: {
  9 | 		'0.7.2': require( '../vendor/ractive/ractive-0.7.2.js' ),
 10 | 		'0.6.0': require( '../vendor/ractive/ractive-0.6.0.js' ),
 11 | 		'0.5.8': require( '../vendor/ractive/ractive-0.5.8.js' ),
 12 | 		'0.5.0': require( '../vendor/ractive/ractive-0.5.0.js' ),
 13 | 		'0.4.0': require( '../vendor/ractive/ractive-0.4.0.js' ),
 14 | 	},
 15 | 	backbone: {
 16 | 		'1.1.2': require( '../vendor/backbone/backbone-1.1.2.js' ),
 17 | 		'1.0.0': require( '../vendor/backbone/backbone-1.0.0.js' ),
 18 | 	}
 19 | };
 20 | 
 21 | function tests( name, fn ) {
 22 | 	mdescribe( 'Ractive', libs.ractive, function ( Ractive, version ) {
 23 | 		mdescribe( 'Backbone', libs.backbone, function ( Backbone, version ) {
 24 | 			describe( name, function () {
 25 | 				fn( Ractive, Backbone );
 26 | 			});
 27 | 		});
 28 | 	});
 29 | }
 30 | 
 31 | tests( 'Ractive-adaptors-backbone', function ( Ractive, Backbone ) {
 32 | 	var Adaptor, model, ractive, collection;
 33 | 
 34 | 	/*
 35 | 	 * Load the library
 36 | 	 */
 37 | 
 38 | 	before(function () {
 39 | 		Adaptor = proxy( '../dist/ractive-adaptors-backbone.js', {
 40 | 			ractive: Ractive,
 41 | 			backbone: Backbone
 42 | 		});
 43 | 
 44 | 		Adaptor.Backbone = Backbone;
 45 | 
 46 | 		Ractive.adaptors.Backbone = Adaptor;
 47 | 		Ractive.defaults.adapt.push( 'Backbone' );
 48 | 	});
 49 | 
 50 | 	/*
 51 | 	 * Basic sanity tests
 52 | 	 */
 53 | 
 54 | 	describe( 'Sanity tests', function () {
 55 | 
 56 | 		it( 'adaptor exists and is an object', function () {
 57 | 			expect( Ractive.adaptors.Backbone ).is.a( 'object' );
 58 | 		});
 59 | 
 60 | 		it( 'Backbone exists', function () {
 61 | 			expect( Backbone ).is.a( 'object' );
 62 | 			expect( Backbone.Model ).is.a( 'function' );
 63 | 		});
 64 | 
 65 | 	});
 66 | 
 67 | 	/*
 68 | 	 * Adaptor filter
 69 | 	 */
 70 | 
 71 | 	describe( 'filter', function () {
 72 | 		it( 'detects models', function () {
 73 | 			var model = new Backbone.Model();
 74 | 			expect( Adaptor.filter(model) ).true;
 75 | 		});
 76 | 
 77 | 		it( 'detects collections', function () {
 78 | 			var collection = new Backbone.Collection();
 79 | 			expect( Adaptor.filter(collection) ).true;
 80 | 		});
 81 | 
 82 | 		it( 'returns false on plain objects', function () {
 83 | 			var object = {};
 84 | 			expect( Adaptor.filter(object) ).false;
 85 | 		});
 86 | 	});
 87 | 
 88 | 	/*
 89 | 	 * Models
 90 | 	 */
 91 | 
 92 | 	describe( 'models', function () {
 93 | 		beforeEach(function () {
 94 | 			model = new Backbone.Model();
 95 | 		});
 96 | 
 97 | 		beforeEach(function () {
 98 | 			if (Ractive.VERSION === '0.4.0')
 99 | 				ractive = new Ractive({ adaptor: '' });
100 | 			else
101 | 				ractive = new Ractive();
102 | 		});
103 | 
104 | 		it( 'works', function () {
105 | 			ractive.set( 'model', model );
106 | 			model.set( 'message', 'hello' );
107 | 
108 | 			expect( ractive.get('model.message') ).eql( 'hello' );
109 | 		});
110 | 
111 | 		it( 'sees model values before', function () {
112 | 			model = new Backbone.Model({ message: 'hello' });
113 | 			ractive.set( 'model', model );
114 | 
115 | 			expect( ractive.get('model.message') ).eql( 'hello' );
116 | 		});
117 | 
118 | 		it( 'propagates changes back to the model', function () {
119 | 			ractive.set( 'model', model );
120 | 			ractive.set( 'model.message', 'hello' );
121 | 
122 | 			expect( ractive.get('model.message') ).eql( 'hello' );
123 | 		});
124 | 
125 | 		it( 'accounts for model listeners', function (next) {
126 | 			model.on( 'change:message', function ( m, a, b ) {
127 | 				next();
128 | 			});
129 | 
130 | 			ractive.set( 'model', model );
131 | 			ractive.set( 'model.message', 'hello' );
132 | 		});
133 | 
134 | 		// See: https://github.com/ractivejs/ractive-adaptors-backbone/pull/12
135 | 		it( 'works with POJO reset', function () {
136 | 			ractive.set( 'model', model );
137 | 			ractive.set( 'model', { message: 'hello' } );
138 | 
139 | 			expect( model.get('message') ).eql( 'hello' );
140 | 		});
141 | 
142 | 		it( 'uses .toJSON() to fetch model attributes', function(next) {
143 | 			var Model = Backbone.Model.extend({
144 | 				toJSON: function() {
145 | 					return {
146 | 						fullname: this.attributes.firstname + ' ' + this.attributes.lastname
147 | 					}
148 | 				}
149 | 			});
150 | 
151 | 			model = new Model({ firstname: 'Joe', lastname: 'Doe' });
152 | 
153 | 			ractive.set( 'model', model );
154 | 
155 | 			expect( ractive.get('model.fullname') ).eql( 'Joe Doe' );
156 | 
157 | 			next();
158 | 		});
159 | 	});
160 | 
161 | 	/*
162 | 	 * Model reset
163 | 	 */
164 | 
165 | 	describe( 'resetting to new models', function () {
166 | 		var newModel;
167 | 
168 | 		beforeEach(function () {
169 | 			ractive = new Ractive({ template: "{{#model}}{{name}}{{/model}}" });
170 | 			model = new Backbone.Model({ name: "Louie" });
171 | 			newModel = new Backbone.Model({ name: "Miles" });
172 | 
173 | 			ractive.set( 'model', model );
174 | 			ractive.set( 'model', newModel );
175 | 		});
176 | 
177 | 		it( 'handles resetting to new models', function () {
178 | 			expect( ractive.get('model').cid ).eql( newModel.cid );
179 | 		});
180 | 
181 | 		it( 'stops listening to old model', function () {
182 | 			model.set( 'name', 'Ella' );
183 | 			expect( ractive.toHTML() ).eql( 'Miles' );
184 | 		});
185 | 
186 | 		it( 'listens to the new model', function () {
187 | 			newModel.set( 'name', 'Frank' );
188 | 			expect( ractive.toHTML() ).eql( 'Frank' );
189 | 		});
190 | 	});
191 | 
192 | 	/*
193 | 	 * Collections
194 | 	 */
195 | 
196 | 	describe( 'collections', function () {
197 | 		var MyModel, MyCollection, list;
198 | 
199 | 		beforeEach(function () {
200 | 			MyModel = Backbone.Model.extend();
201 | 			MyCollection = Backbone.Collection.extend({
202 | 				model: MyModel
203 | 			});
204 | 		});
205 | 
206 | 		beforeEach(function () {
207 | 			list = new MyCollection();
208 | 			ractive = new Ractive({
209 | 				template: '{{#list}}{{name}}{{/list}}'
210 | 			});
211 | 			ractive.set('list', list);
212 | 			list.reset( [ { name: 'Moe' }, { name: 'Larry' }, { name: 'Curly' } ] );
213 | 		});
214 | 
215 | 		it( 'works', function () {
216 | 			expect( ractive.toHTML() ).eql( 'MoeLarryCurly' );
217 | 		});
218 | 
219 | 		it( 'responds to model changes', function () {
220 | 			var moe = list.at( 0 );
221 | 			moe.set( 'name', 'Joe' );
222 | 			expect( ractive.toHTML() ).eql( 'JoeLarryCurly' );
223 | 		});
224 | 
225 | 		it( 'responds to deletions', function () {
226 | 			var moe = list.at( 0 );
227 | 			list.remove( moe );
228 | 			expect( ractive.toHTML() ).eql( 'LarryCurly' );
229 | 		});
230 | 
231 | 		it( 'responds to additions', function () {
232 | 			list.push({ name: 'Susy' });
233 | 			expect( ractive.toHTML() ).eql( 'MoeLarryCurlySusy' );
234 | 		});
235 | 
236 | 		it( 'handles resets to array', function () {
237 | 			ractive.set('list', [ { name: 'Homer' }, { name: 'Bart' } ] );
238 | 			expect( ractive.toHTML() ).eql( 'HomerBart' );
239 | 		});
240 | 
241 | 		it( 'handles resets to another collection', function () {
242 | 			var newCollection = new MyCollection([
243 | 				{ name: 'George' }, { name: 'Ringo' }
244 | 			]);
245 | 
246 | 			ractive.set('list', newCollection);
247 | 			expect( ractive.toHTML() ).eql( 'GeorgeRingo' );
248 | 		});
249 | 	});
250 | 
251 | 	/*
252 | 	 * Nested collections
253 | 	 */
254 | 
255 | 	describe( 'nested collections', function () {
256 | 		var submodel, sublist, model, list;
257 | 
258 | 		beforeEach(function () {
259 | 			submodel = new Backbone.Model({ message: 'hello' });
260 | 			sublist = new Backbone.Collection( [ submodel ] );
261 | 			model = new Backbone.Model({ sublist: sublist });
262 | 			list = new Backbone.Collection( [ model ] );
263 | 
264 | 			ractive = new Ractive({
265 | 				template: '{{#list}}{{heading}}{{#sublist}}{{message}}{{/sublist}}{{/list}}'
266 | 			});
267 | 
268 | 			ractive.set('list', list);
269 | 		});
270 | 
271 | 		it( 'works', function () {
272 | 			expect( ractive.get( 'list.0.sublist.0.message' ) ).eql( 'hello' );
273 | 		});
274 | 
275 | 		it( 'renders HTML', function () {
276 | 			expect( ractive.toHTML() ).eql( 'hello' );
277 | 		});
278 | 
279 | 		it( 'responds to changes in submodel', function () {
280 | 			submodel.set( 'message', 'hola' );
281 | 			expect( ractive.toHTML() ).eql( 'hola' );
282 | 		});
283 | 
284 | 		it( 'responds to sublist additions', function () {
285 | 			sublist.push( new Backbone.Model({ message: 'howdy' }) );
286 | 			expect( ractive.toHTML() ).eql( 'hellohowdy' );
287 | 		});
288 | 
289 | 		it( 'responds to sublist deletions', function () {
290 | 			var m = new Backbone.Model({ message: 'howdy' });
291 | 			sublist.push(m);
292 | 			sublist.remove(m);
293 | 			expect( ractive.toHTML() ).eql( 'hello' );
294 | 		});
295 | 	});
296 | 
297 | });
298 | 


--------------------------------------------------------------------------------
/vendor/backbone/backbone-1.0.0.js:
--------------------------------------------------------------------------------
   1 | //     Backbone.js 1.0.0
   2 | 
   3 | //     (c) 2010-2013 Jeremy Ashkenas, DocumentCloud Inc.
   4 | //     Backbone may be freely distributed under the MIT license.
   5 | //     For all details and documentation:
   6 | //     http://backbonejs.org
   7 | 
   8 | (function(){
   9 | 
  10 |   // Initial Setup
  11 |   // -------------
  12 | 
  13 |   // Save a reference to the global object (`window` in the browser, `exports`
  14 |   // on the server).
  15 |   var root = this;
  16 | 
  17 |   // Save the previous value of the `Backbone` variable, so that it can be
  18 |   // restored later on, if `noConflict` is used.
  19 |   var previousBackbone = root.Backbone;
  20 | 
  21 |   // Create local references to array methods we'll want to use later.
  22 |   var array = [];
  23 |   var push = array.push;
  24 |   var slice = array.slice;
  25 |   var splice = array.splice;
  26 | 
  27 |   // The top-level namespace. All public Backbone classes and modules will
  28 |   // be attached to this. Exported for both the browser and the server.
  29 |   var Backbone;
  30 |   if (typeof exports !== 'undefined') {
  31 |     Backbone = exports;
  32 |   } else {
  33 |     Backbone = root.Backbone = {};
  34 |   }
  35 | 
  36 |   // Current version of the library. Keep in sync with `package.json`.
  37 |   Backbone.VERSION = '1.0.0';
  38 | 
  39 |   // Require Underscore, if we're on the server, and it's not already present.
  40 |   var _ = root._;
  41 |   if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
  42 | 
  43 |   // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
  44 |   // the `$` variable.
  45 |   Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
  46 | 
  47 |   // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
  48 |   // to its previous owner. Returns a reference to this Backbone object.
  49 |   Backbone.noConflict = function() {
  50 |     root.Backbone = previousBackbone;
  51 |     return this;
  52 |   };
  53 | 
  54 |   // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
  55 |   // will fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and
  56 |   // set a `X-Http-Method-Override` header.
  57 |   Backbone.emulateHTTP = false;
  58 | 
  59 |   // Turn on `emulateJSON` to support legacy servers that can't deal with direct
  60 |   // `application/json` requests ... will encode the body as
  61 |   // `application/x-www-form-urlencoded` instead and will send the model in a
  62 |   // form param named `model`.
  63 |   Backbone.emulateJSON = false;
  64 | 
  65 |   // Backbone.Events
  66 |   // ---------------
  67 | 
  68 |   // A module that can be mixed in to *any object* in order to provide it with
  69 |   // custom events. You may bind with `on` or remove with `off` callback
  70 |   // functions to an event; `trigger`-ing an event fires all callbacks in
  71 |   // succession.
  72 |   //
  73 |   //     var object = {};
  74 |   //     _.extend(object, Backbone.Events);
  75 |   //     object.on('expand', function(){ alert('expanded'); });
  76 |   //     object.trigger('expand');
  77 |   //
  78 |   var Events = Backbone.Events = {
  79 | 
  80 |     // Bind an event to a `callback` function. Passing `"all"` will bind
  81 |     // the callback to all events fired.
  82 |     on: function(name, callback, context) {
  83 |       if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
  84 |       this._events || (this._events = {});
  85 |       var events = this._events[name] || (this._events[name] = []);
  86 |       events.push({callback: callback, context: context, ctx: context || this});
  87 |       return this;
  88 |     },
  89 | 
  90 |     // Bind an event to only be triggered a single time. After the first time
  91 |     // the callback is invoked, it will be removed.
  92 |     once: function(name, callback, context) {
  93 |       if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
  94 |       var self = this;
  95 |       var once = _.once(function() {
  96 |         self.off(name, once);
  97 |         callback.apply(this, arguments);
  98 |       });
  99 |       once._callback = callback;
 100 |       return this.on(name, once, context);
 101 |     },
 102 | 
 103 |     // Remove one or many callbacks. If `context` is null, removes all
 104 |     // callbacks with that function. If `callback` is null, removes all
 105 |     // callbacks for the event. If `name` is null, removes all bound
 106 |     // callbacks for all events.
 107 |     off: function(name, callback, context) {
 108 |       var retain, ev, events, names, i, l, j, k;
 109 |       if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
 110 |       if (!name && !callback && !context) {
 111 |         this._events = {};
 112 |         return this;
 113 |       }
 114 | 
 115 |       names = name ? [name] : _.keys(this._events);
 116 |       for (i = 0, l = names.length; i < l; i++) {
 117 |         name = names[i];
 118 |         if (events = this._events[name]) {
 119 |           this._events[name] = retain = [];
 120 |           if (callback || context) {
 121 |             for (j = 0, k = events.length; j < k; j++) {
 122 |               ev = events[j];
 123 |               if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
 124 |                   (context && context !== ev.context)) {
 125 |                 retain.push(ev);
 126 |               }
 127 |             }
 128 |           }
 129 |           if (!retain.length) delete this._events[name];
 130 |         }
 131 |       }
 132 | 
 133 |       return this;
 134 |     },
 135 | 
 136 |     // Trigger one or many events, firing all bound callbacks. Callbacks are
 137 |     // passed the same arguments as `trigger` is, apart from the event name
 138 |     // (unless you're listening on `"all"`, which will cause your callback to
 139 |     // receive the true name of the event as the first argument).
 140 |     trigger: function(name) {
 141 |       if (!this._events) return this;
 142 |       var args = slice.call(arguments, 1);
 143 |       if (!eventsApi(this, 'trigger', name, args)) return this;
 144 |       var events = this._events[name];
 145 |       var allEvents = this._events.all;
 146 |       if (events) triggerEvents(events, args);
 147 |       if (allEvents) triggerEvents(allEvents, arguments);
 148 |       return this;
 149 |     },
 150 | 
 151 |     // Tell this object to stop listening to either specific events ... or
 152 |     // to every object it's currently listening to.
 153 |     stopListening: function(obj, name, callback) {
 154 |       var listeners = this._listeners;
 155 |       if (!listeners) return this;
 156 |       var deleteListener = !name && !callback;
 157 |       if (typeof name === 'object') callback = this;
 158 |       if (obj) (listeners = {})[obj._listenerId] = obj;
 159 |       for (var id in listeners) {
 160 |         listeners[id].off(name, callback, this);
 161 |         if (deleteListener) delete this._listeners[id];
 162 |       }
 163 |       return this;
 164 |     }
 165 | 
 166 |   };
 167 | 
 168 |   // Regular expression used to split event strings.
 169 |   var eventSplitter = /\s+/;
 170 | 
 171 |   // Implement fancy features of the Events API such as multiple event
 172 |   // names `"change blur"` and jQuery-style event maps `{change: action}`
 173 |   // in terms of the existing API.
 174 |   var eventsApi = function(obj, action, name, rest) {
 175 |     if (!name) return true;
 176 | 
 177 |     // Handle event maps.
 178 |     if (typeof name === 'object') {
 179 |       for (var key in name) {
 180 |         obj[action].apply(obj, [key, name[key]].concat(rest));
 181 |       }
 182 |       return false;
 183 |     }
 184 | 
 185 |     // Handle space separated event names.
 186 |     if (eventSplitter.test(name)) {
 187 |       var names = name.split(eventSplitter);
 188 |       for (var i = 0, l = names.length; i < l; i++) {
 189 |         obj[action].apply(obj, [names[i]].concat(rest));
 190 |       }
 191 |       return false;
 192 |     }
 193 | 
 194 |     return true;
 195 |   };
 196 | 
 197 |   // A difficult-to-believe, but optimized internal dispatch function for
 198 |   // triggering events. Tries to keep the usual cases speedy (most internal
 199 |   // Backbone events have 3 arguments).
 200 |   var triggerEvents = function(events, args) {
 201 |     var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
 202 |     switch (args.length) {
 203 |       case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
 204 |       case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
 205 |       case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
 206 |       case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
 207 |       default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
 208 |     }
 209 |   };
 210 | 
 211 |   var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
 212 | 
 213 |   // Inversion-of-control versions of `on` and `once`. Tell *this* object to
 214 |   // listen to an event in another object ... keeping track of what it's
 215 |   // listening to.
 216 |   _.each(listenMethods, function(implementation, method) {
 217 |     Events[method] = function(obj, name, callback) {
 218 |       var listeners = this._listeners || (this._listeners = {});
 219 |       var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
 220 |       listeners[id] = obj;
 221 |       if (typeof name === 'object') callback = this;
 222 |       obj[implementation](name, callback, this);
 223 |       return this;
 224 |     };
 225 |   });
 226 | 
 227 |   // Aliases for backwards compatibility.
 228 |   Events.bind   = Events.on;
 229 |   Events.unbind = Events.off;
 230 | 
 231 |   // Allow the `Backbone` object to serve as a global event bus, for folks who
 232 |   // want global "pubsub" in a convenient place.
 233 |   _.extend(Backbone, Events);
 234 | 
 235 |   // Backbone.Model
 236 |   // --------------
 237 | 
 238 |   // Backbone **Models** are the basic data object in the framework --
 239 |   // frequently representing a row in a table in a database on your server.
 240 |   // A discrete chunk of data and a bunch of useful, related methods for
 241 |   // performing computations and transformations on that data.
 242 | 
 243 |   // Create a new model with the specified attributes. A client id (`cid`)
 244 |   // is automatically generated and assigned for you.
 245 |   var Model = Backbone.Model = function(attributes, options) {
 246 |     var defaults;
 247 |     var attrs = attributes || {};
 248 |     options || (options = {});
 249 |     this.cid = _.uniqueId('c');
 250 |     this.attributes = {};
 251 |     _.extend(this, _.pick(options, modelOptions));
 252 |     if (options.parse) attrs = this.parse(attrs, options) || {};
 253 |     if (defaults = _.result(this, 'defaults')) {
 254 |       attrs = _.defaults({}, attrs, defaults);
 255 |     }
 256 |     this.set(attrs, options);
 257 |     this.changed = {};
 258 |     this.initialize.apply(this, arguments);
 259 |   };
 260 | 
 261 |   // A list of options to be attached directly to the model, if provided.
 262 |   var modelOptions = ['url', 'urlRoot', 'collection'];
 263 | 
 264 |   // Attach all inheritable methods to the Model prototype.
 265 |   _.extend(Model.prototype, Events, {
 266 | 
 267 |     // A hash of attributes whose current and previous value differ.
 268 |     changed: null,
 269 | 
 270 |     // The value returned during the last failed validation.
 271 |     validationError: null,
 272 | 
 273 |     // The default name for the JSON `id` attribute is `"id"`. MongoDB and
 274 |     // CouchDB users may want to set this to `"_id"`.
 275 |     idAttribute: 'id',
 276 | 
 277 |     // Initialize is an empty function by default. Override it with your own
 278 |     // initialization logic.
 279 |     initialize: function(){},
 280 | 
 281 |     // Return a copy of the model's `attributes` object.
 282 |     toJSON: function(options) {
 283 |       return _.clone(this.attributes);
 284 |     },
 285 | 
 286 |     // Proxy `Backbone.sync` by default -- but override this if you need
 287 |     // custom syncing semantics for *this* particular model.
 288 |     sync: function() {
 289 |       return Backbone.sync.apply(this, arguments);
 290 |     },
 291 | 
 292 |     // Get the value of an attribute.
 293 |     get: function(attr) {
 294 |       return this.attributes[attr];
 295 |     },
 296 | 
 297 |     // Get the HTML-escaped value of an attribute.
 298 |     escape: function(attr) {
 299 |       return _.escape(this.get(attr));
 300 |     },
 301 | 
 302 |     // Returns `true` if the attribute contains a value that is not null
 303 |     // or undefined.
 304 |     has: function(attr) {
 305 |       return this.get(attr) != null;
 306 |     },
 307 | 
 308 |     // Set a hash of model attributes on the object, firing `"change"`. This is
 309 |     // the core primitive operation of a model, updating the data and notifying
 310 |     // anyone who needs to know about the change in state. The heart of the beast.
 311 |     set: function(key, val, options) {
 312 |       var attr, attrs, unset, changes, silent, changing, prev, current;
 313 |       if (key == null) return this;
 314 | 
 315 |       // Handle both `"key", value` and `{key: value}` -style arguments.
 316 |       if (typeof key === 'object') {
 317 |         attrs = key;
 318 |         options = val;
 319 |       } else {
 320 |         (attrs = {})[key] = val;
 321 |       }
 322 | 
 323 |       options || (options = {});
 324 | 
 325 |       // Run validation.
 326 |       if (!this._validate(attrs, options)) return false;
 327 | 
 328 |       // Extract attributes and options.
 329 |       unset           = options.unset;
 330 |       silent          = options.silent;
 331 |       changes         = [];
 332 |       changing        = this._changing;
 333 |       this._changing  = true;
 334 | 
 335 |       if (!changing) {
 336 |         this._previousAttributes = _.clone(this.attributes);
 337 |         this.changed = {};
 338 |       }
 339 |       current = this.attributes, prev = this._previousAttributes;
 340 | 
 341 |       // Check for changes of `id`.
 342 |       if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
 343 | 
 344 |       // For each `set` attribute, update or delete the current value.
 345 |       for (attr in attrs) {
 346 |         val = attrs[attr];
 347 |         if (!_.isEqual(current[attr], val)) changes.push(attr);
 348 |         if (!_.isEqual(prev[attr], val)) {
 349 |           this.changed[attr] = val;
 350 |         } else {
 351 |           delete this.changed[attr];
 352 |         }
 353 |         unset ? delete current[attr] : current[attr] = val;
 354 |       }
 355 | 
 356 |       // Trigger all relevant attribute changes.
 357 |       if (!silent) {
 358 |         if (changes.length) this._pending = true;
 359 |         for (var i = 0, l = changes.length; i < l; i++) {
 360 |           this.trigger('change:' + changes[i], this, current[changes[i]], options);
 361 |         }
 362 |       }
 363 | 
 364 |       // You might be wondering why there's a `while` loop here. Changes can
 365 |       // be recursively nested within `"change"` events.
 366 |       if (changing) return this;
 367 |       if (!silent) {
 368 |         while (this._pending) {
 369 |           this._pending = false;
 370 |           this.trigger('change', this, options);
 371 |         }
 372 |       }
 373 |       this._pending = false;
 374 |       this._changing = false;
 375 |       return this;
 376 |     },
 377 | 
 378 |     // Remove an attribute from the model, firing `"change"`. `unset` is a noop
 379 |     // if the attribute doesn't exist.
 380 |     unset: function(attr, options) {
 381 |       return this.set(attr, void 0, _.extend({}, options, {unset: true}));
 382 |     },
 383 | 
 384 |     // Clear all attributes on the model, firing `"change"`.
 385 |     clear: function(options) {
 386 |       var attrs = {};
 387 |       for (var key in this.attributes) attrs[key] = void 0;
 388 |       return this.set(attrs, _.extend({}, options, {unset: true}));
 389 |     },
 390 | 
 391 |     // Determine if the model has changed since the last `"change"` event.
 392 |     // If you specify an attribute name, determine if that attribute has changed.
 393 |     hasChanged: function(attr) {
 394 |       if (attr == null) return !_.isEmpty(this.changed);
 395 |       return _.has(this.changed, attr);
 396 |     },
 397 | 
 398 |     // Return an object containing all the attributes that have changed, or
 399 |     // false if there are no changed attributes. Useful for determining what
 400 |     // parts of a view need to be updated and/or what attributes need to be
 401 |     // persisted to the server. Unset attributes will be set to undefined.
 402 |     // You can also pass an attributes object to diff against the model,
 403 |     // determining if there *would be* a change.
 404 |     changedAttributes: function(diff) {
 405 |       if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
 406 |       var val, changed = false;
 407 |       var old = this._changing ? this._previousAttributes : this.attributes;
 408 |       for (var attr in diff) {
 409 |         if (_.isEqual(old[attr], (val = diff[attr]))) continue;
 410 |         (changed || (changed = {}))[attr] = val;
 411 |       }
 412 |       return changed;
 413 |     },
 414 | 
 415 |     // Get the previous value of an attribute, recorded at the time the last
 416 |     // `"change"` event was fired.
 417 |     previous: function(attr) {
 418 |       if (attr == null || !this._previousAttributes) return null;
 419 |       return this._previousAttributes[attr];
 420 |     },
 421 | 
 422 |     // Get all of the attributes of the model at the time of the previous
 423 |     // `"change"` event.
 424 |     previousAttributes: function() {
 425 |       return _.clone(this._previousAttributes);
 426 |     },
 427 | 
 428 |     // Fetch the model from the server. If the server's representation of the
 429 |     // model differs from its current attributes, they will be overridden,
 430 |     // triggering a `"change"` event.
 431 |     fetch: function(options) {
 432 |       options = options ? _.clone(options) : {};
 433 |       if (options.parse === void 0) options.parse = true;
 434 |       var model = this;
 435 |       var success = options.success;
 436 |       options.success = function(resp) {
 437 |         if (!model.set(model.parse(resp, options), options)) return false;
 438 |         if (success) success(model, resp, options);
 439 |         model.trigger('sync', model, resp, options);
 440 |       };
 441 |       wrapError(this, options);
 442 |       return this.sync('read', this, options);
 443 |     },
 444 | 
 445 |     // Set a hash of model attributes, and sync the model to the server.
 446 |     // If the server returns an attributes hash that differs, the model's
 447 |     // state will be `set` again.
 448 |     save: function(key, val, options) {
 449 |       var attrs, method, xhr, attributes = this.attributes;
 450 | 
 451 |       // Handle both `"key", value` and `{key: value}` -style arguments.
 452 |       if (key == null || typeof key === 'object') {
 453 |         attrs = key;
 454 |         options = val;
 455 |       } else {
 456 |         (attrs = {})[key] = val;
 457 |       }
 458 | 
 459 |       // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
 460 |       if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
 461 | 
 462 |       options = _.extend({validate: true}, options);
 463 | 
 464 |       // Do not persist invalid models.
 465 |       if (!this._validate(attrs, options)) return false;
 466 | 
 467 |       // Set temporary attributes if `{wait: true}`.
 468 |       if (attrs && options.wait) {
 469 |         this.attributes = _.extend({}, attributes, attrs);
 470 |       }
 471 | 
 472 |       // After a successful server-side save, the client is (optionally)
 473 |       // updated with the server-side state.
 474 |       if (options.parse === void 0) options.parse = true;
 475 |       var model = this;
 476 |       var success = options.success;
 477 |       options.success = function(resp) {
 478 |         // Ensure attributes are restored during synchronous saves.
 479 |         model.attributes = attributes;
 480 |         var serverAttrs = model.parse(resp, options);
 481 |         if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
 482 |         if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
 483 |           return false;
 484 |         }
 485 |         if (success) success(model, resp, options);
 486 |         model.trigger('sync', model, resp, options);
 487 |       };
 488 |       wrapError(this, options);
 489 | 
 490 |       method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
 491 |       if (method === 'patch') options.attrs = attrs;
 492 |       xhr = this.sync(method, this, options);
 493 | 
 494 |       // Restore attributes.
 495 |       if (attrs && options.wait) this.attributes = attributes;
 496 | 
 497 |       return xhr;
 498 |     },
 499 | 
 500 |     // Destroy this model on the server if it was already persisted.
 501 |     // Optimistically removes the model from its collection, if it has one.
 502 |     // If `wait: true` is passed, waits for the server to respond before removal.
 503 |     destroy: function(options) {
 504 |       options = options ? _.clone(options) : {};
 505 |       var model = this;
 506 |       var success = options.success;
 507 | 
 508 |       var destroy = function() {
 509 |         model.trigger('destroy', model, model.collection, options);
 510 |       };
 511 | 
 512 |       options.success = function(resp) {
 513 |         if (options.wait || model.isNew()) destroy();
 514 |         if (success) success(model, resp, options);
 515 |         if (!model.isNew()) model.trigger('sync', model, resp, options);
 516 |       };
 517 | 
 518 |       if (this.isNew()) {
 519 |         options.success();
 520 |         return false;
 521 |       }
 522 |       wrapError(this, options);
 523 | 
 524 |       var xhr = this.sync('delete', this, options);
 525 |       if (!options.wait) destroy();
 526 |       return xhr;
 527 |     },
 528 | 
 529 |     // Default URL for the model's representation on the server -- if you're
 530 |     // using Backbone's restful methods, override this to change the endpoint
 531 |     // that will be called.
 532 |     url: function() {
 533 |       var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
 534 |       if (this.isNew()) return base;
 535 |       return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
 536 |     },
 537 | 
 538 |     // **parse** converts a response into the hash of attributes to be `set` on
 539 |     // the model. The default implementation is just to pass the response along.
 540 |     parse: function(resp, options) {
 541 |       return resp;
 542 |     },
 543 | 
 544 |     // Create a new model with identical attributes to this one.
 545 |     clone: function() {
 546 |       return new this.constructor(this.attributes);
 547 |     },
 548 | 
 549 |     // A model is new if it has never been saved to the server, and lacks an id.
 550 |     isNew: function() {
 551 |       return this.id == null;
 552 |     },
 553 | 
 554 |     // Check if the model is currently in a valid state.
 555 |     isValid: function(options) {
 556 |       return this._validate({}, _.extend(options || {}, { validate: true }));
 557 |     },
 558 | 
 559 |     // Run validation against the next complete set of model attributes,
 560 |     // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
 561 |     _validate: function(attrs, options) {
 562 |       if (!options.validate || !this.validate) return true;
 563 |       attrs = _.extend({}, this.attributes, attrs);
 564 |       var error = this.validationError = this.validate(attrs, options) || null;
 565 |       if (!error) return true;
 566 |       this.trigger('invalid', this, error, _.extend(options || {}, {validationError: error}));
 567 |       return false;
 568 |     }
 569 | 
 570 |   });
 571 | 
 572 |   // Underscore methods that we want to implement on the Model.
 573 |   var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
 574 | 
 575 |   // Mix in each Underscore method as a proxy to `Model#attributes`.
 576 |   _.each(modelMethods, function(method) {
 577 |     Model.prototype[method] = function() {
 578 |       var args = slice.call(arguments);
 579 |       args.unshift(this.attributes);
 580 |       return _[method].apply(_, args);
 581 |     };
 582 |   });
 583 | 
 584 |   // Backbone.Collection
 585 |   // -------------------
 586 | 
 587 |   // If models tend to represent a single row of data, a Backbone Collection is
 588 |   // more analagous to a table full of data ... or a small slice or page of that
 589 |   // table, or a collection of rows that belong together for a particular reason
 590 |   // -- all of the messages in this particular folder, all of the documents
 591 |   // belonging to this particular author, and so on. Collections maintain
 592 |   // indexes of their models, both in order, and for lookup by `id`.
 593 | 
 594 |   // Create a new **Collection**, perhaps to contain a specific type of `model`.
 595 |   // If a `comparator` is specified, the Collection will maintain
 596 |   // its models in sort order, as they're added and removed.
 597 |   var Collection = Backbone.Collection = function(models, options) {
 598 |     options || (options = {});
 599 |     if (options.url) this.url = options.url;
 600 |     if (options.model) this.model = options.model;
 601 |     if (options.comparator !== void 0) this.comparator = options.comparator;
 602 |     this._reset();
 603 |     this.initialize.apply(this, arguments);
 604 |     if (models) this.reset(models, _.extend({silent: true}, options));
 605 |   };
 606 | 
 607 |   // Default options for `Collection#set`.
 608 |   var setOptions = {add: true, remove: true, merge: true};
 609 |   var addOptions = {add: true, merge: false, remove: false};
 610 | 
 611 |   // Define the Collection's inheritable methods.
 612 |   _.extend(Collection.prototype, Events, {
 613 | 
 614 |     // The default model for a collection is just a **Backbone.Model**.
 615 |     // This should be overridden in most cases.
 616 |     model: Model,
 617 | 
 618 |     // Initialize is an empty function by default. Override it with your own
 619 |     // initialization logic.
 620 |     initialize: function(){},
 621 | 
 622 |     // The JSON representation of a Collection is an array of the
 623 |     // models' attributes.
 624 |     toJSON: function(options) {
 625 |       return this.map(function(model){ return model.toJSON(options); });
 626 |     },
 627 | 
 628 |     // Proxy `Backbone.sync` by default.
 629 |     sync: function() {
 630 |       return Backbone.sync.apply(this, arguments);
 631 |     },
 632 | 
 633 |     // Add a model, or list of models to the set.
 634 |     add: function(models, options) {
 635 |       return this.set(models, _.defaults(options || {}, addOptions));
 636 |     },
 637 | 
 638 |     // Remove a model, or a list of models from the set.
 639 |     remove: function(models, options) {
 640 |       models = _.isArray(models) ? models.slice() : [models];
 641 |       options || (options = {});
 642 |       var i, l, index, model;
 643 |       for (i = 0, l = models.length; i < l; i++) {
 644 |         model = this.get(models[i]);
 645 |         if (!model) continue;
 646 |         delete this._byId[model.id];
 647 |         delete this._byId[model.cid];
 648 |         index = this.indexOf(model);
 649 |         this.models.splice(index, 1);
 650 |         this.length--;
 651 |         if (!options.silent) {
 652 |           options.index = index;
 653 |           model.trigger('remove', model, this, options);
 654 |         }
 655 |         this._removeReference(model);
 656 |       }
 657 |       return this;
 658 |     },
 659 | 
 660 |     // Update a collection by `set`-ing a new list of models, adding new ones,
 661 |     // removing models that are no longer present, and merging models that
 662 |     // already exist in the collection, as necessary. Similar to **Model#set**,
 663 |     // the core operation for updating the data contained by the collection.
 664 |     set: function(models, options) {
 665 |       options = _.defaults(options || {}, setOptions);
 666 |       if (options.parse) models = this.parse(models, options);
 667 |       if (!_.isArray(models)) models = models ? [models] : [];
 668 |       var i, l, model, attrs, existing, sort;
 669 |       var at = options.at;
 670 |       var sortable = this.comparator && (at == null) && options.sort !== false;
 671 |       var sortAttr = _.isString(this.comparator) ? this.comparator : null;
 672 |       var toAdd = [], toRemove = [], modelMap = {};
 673 | 
 674 |       // Turn bare objects into model references, and prevent invalid models
 675 |       // from being added.
 676 |       for (i = 0, l = models.length; i < l; i++) {
 677 |         if (!(model = this._prepareModel(models[i], options))) continue;
 678 | 
 679 |         // If a duplicate is found, prevent it from being added and
 680 |         // optionally merge it into the existing model.
 681 |         if (existing = this.get(model)) {
 682 |           if (options.remove) modelMap[existing.cid] = true;
 683 |           if (options.merge) {
 684 |             existing.set(model.attributes, options);
 685 |             if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
 686 |           }
 687 | 
 688 |         // This is a new model, push it to the `toAdd` list.
 689 |         } else if (options.add) {
 690 |           toAdd.push(model);
 691 | 
 692 |           // Listen to added models' events, and index models for lookup by
 693 |           // `id` and by `cid`.
 694 |           model.on('all', this._onModelEvent, this);
 695 |           this._byId[model.cid] = model;
 696 |           if (model.id != null) this._byId[model.id] = model;
 697 |         }
 698 |       }
 699 | 
 700 |       // Remove nonexistent models if appropriate.
 701 |       if (options.remove) {
 702 |         for (i = 0, l = this.length; i < l; ++i) {
 703 |           if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
 704 |         }
 705 |         if (toRemove.length) this.remove(toRemove, options);
 706 |       }
 707 | 
 708 |       // See if sorting is needed, update `length` and splice in new models.
 709 |       if (toAdd.length) {
 710 |         if (sortable) sort = true;
 711 |         this.length += toAdd.length;
 712 |         if (at != null) {
 713 |           splice.apply(this.models, [at, 0].concat(toAdd));
 714 |         } else {
 715 |           push.apply(this.models, toAdd);
 716 |         }
 717 |       }
 718 | 
 719 |       // Silently sort the collection if appropriate.
 720 |       if (sort) this.sort({silent: true});
 721 | 
 722 |       if (options.silent) return this;
 723 | 
 724 |       // Trigger `add` events.
 725 |       for (i = 0, l = toAdd.length; i < l; i++) {
 726 |         (model = toAdd[i]).trigger('add', model, this, options);
 727 |       }
 728 | 
 729 |       // Trigger `sort` if the collection was sorted.
 730 |       if (sort) this.trigger('sort', this, options);
 731 |       return this;
 732 |     },
 733 | 
 734 |     // When you have more items than you want to add or remove individually,
 735 |     // you can reset the entire set with a new list of models, without firing
 736 |     // any granular `add` or `remove` events. Fires `reset` when finished.
 737 |     // Useful for bulk operations and optimizations.
 738 |     reset: function(models, options) {
 739 |       options || (options = {});
 740 |       for (var i = 0, l = this.models.length; i < l; i++) {
 741 |         this._removeReference(this.models[i]);
 742 |       }
 743 |       options.previousModels = this.models;
 744 |       this._reset();
 745 |       this.add(models, _.extend({silent: true}, options));
 746 |       if (!options.silent) this.trigger('reset', this, options);
 747 |       return this;
 748 |     },
 749 | 
 750 |     // Add a model to the end of the collection.
 751 |     push: function(model, options) {
 752 |       model = this._prepareModel(model, options);
 753 |       this.add(model, _.extend({at: this.length}, options));
 754 |       return model;
 755 |     },
 756 | 
 757 |     // Remove a model from the end of the collection.
 758 |     pop: function(options) {
 759 |       var model = this.at(this.length - 1);
 760 |       this.remove(model, options);
 761 |       return model;
 762 |     },
 763 | 
 764 |     // Add a model to the beginning of the collection.
 765 |     unshift: function(model, options) {
 766 |       model = this._prepareModel(model, options);
 767 |       this.add(model, _.extend({at: 0}, options));
 768 |       return model;
 769 |     },
 770 | 
 771 |     // Remove a model from the beginning of the collection.
 772 |     shift: function(options) {
 773 |       var model = this.at(0);
 774 |       this.remove(model, options);
 775 |       return model;
 776 |     },
 777 | 
 778 |     // Slice out a sub-array of models from the collection.
 779 |     slice: function(begin, end) {
 780 |       return this.models.slice(begin, end);
 781 |     },
 782 | 
 783 |     // Get a model from the set by id.
 784 |     get: function(obj) {
 785 |       if (obj == null) return void 0;
 786 |       return this._byId[obj.id != null ? obj.id : obj.cid || obj];
 787 |     },
 788 | 
 789 |     // Get the model at the given index.
 790 |     at: function(index) {
 791 |       return this.models[index];
 792 |     },
 793 | 
 794 |     // Return models with matching attributes. Useful for simple cases of
 795 |     // `filter`.
 796 |     where: function(attrs, first) {
 797 |       if (_.isEmpty(attrs)) return first ? void 0 : [];
 798 |       return this[first ? 'find' : 'filter'](function(model) {
 799 |         for (var key in attrs) {
 800 |           if (attrs[key] !== model.get(key)) return false;
 801 |         }
 802 |         return true;
 803 |       });
 804 |     },
 805 | 
 806 |     // Return the first model with matching attributes. Useful for simple cases
 807 |     // of `find`.
 808 |     findWhere: function(attrs) {
 809 |       return this.where(attrs, true);
 810 |     },
 811 | 
 812 |     // Force the collection to re-sort itself. You don't need to call this under
 813 |     // normal circumstances, as the set will maintain sort order as each item
 814 |     // is added.
 815 |     sort: function(options) {
 816 |       if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
 817 |       options || (options = {});
 818 | 
 819 |       // Run sort based on type of `comparator`.
 820 |       if (_.isString(this.comparator) || this.comparator.length === 1) {
 821 |         this.models = this.sortBy(this.comparator, this);
 822 |       } else {
 823 |         this.models.sort(_.bind(this.comparator, this));
 824 |       }
 825 | 
 826 |       if (!options.silent) this.trigger('sort', this, options);
 827 |       return this;
 828 |     },
 829 | 
 830 |     // Figure out the smallest index at which a model should be inserted so as
 831 |     // to maintain order.
 832 |     sortedIndex: function(model, value, context) {
 833 |       value || (value = this.comparator);
 834 |       var iterator = _.isFunction(value) ? value : function(model) {
 835 |         return model.get(value);
 836 |       };
 837 |       return _.sortedIndex(this.models, model, iterator, context);
 838 |     },
 839 | 
 840 |     // Pluck an attribute from each model in the collection.
 841 |     pluck: function(attr) {
 842 |       return _.invoke(this.models, 'get', attr);
 843 |     },
 844 | 
 845 |     // Fetch the default set of models for this collection, resetting the
 846 |     // collection when they arrive. If `reset: true` is passed, the response
 847 |     // data will be passed through the `reset` method instead of `set`.
 848 |     fetch: function(options) {
 849 |       options = options ? _.clone(options) : {};
 850 |       if (options.parse === void 0) options.parse = true;
 851 |       var success = options.success;
 852 |       var collection = this;
 853 |       options.success = function(resp) {
 854 |         var method = options.reset ? 'reset' : 'set';
 855 |         collection[method](resp, options);
 856 |         if (success) success(collection, resp, options);
 857 |         collection.trigger('sync', collection, resp, options);
 858 |       };
 859 |       wrapError(this, options);
 860 |       return this.sync('read', this, options);
 861 |     },
 862 | 
 863 |     // Create a new instance of a model in this collection. Add the model to the
 864 |     // collection immediately, unless `wait: true` is passed, in which case we
 865 |     // wait for the server to agree.
 866 |     create: function(model, options) {
 867 |       options = options ? _.clone(options) : {};
 868 |       if (!(model = this._prepareModel(model, options))) return false;
 869 |       if (!options.wait) this.add(model, options);
 870 |       var collection = this;
 871 |       var success = options.success;
 872 |       options.success = function(resp) {
 873 |         if (options.wait) collection.add(model, options);
 874 |         if (success) success(model, resp, options);
 875 |       };
 876 |       model.save(null, options);
 877 |       return model;
 878 |     },
 879 | 
 880 |     // **parse** converts a response into a list of models to be added to the
 881 |     // collection. The default implementation is just to pass it through.
 882 |     parse: function(resp, options) {
 883 |       return resp;
 884 |     },
 885 | 
 886 |     // Create a new collection with an identical list of models as this one.
 887 |     clone: function() {
 888 |       return new this.constructor(this.models);
 889 |     },
 890 | 
 891 |     // Private method to reset all internal state. Called when the collection
 892 |     // is first initialized or reset.
 893 |     _reset: function() {
 894 |       this.length = 0;
 895 |       this.models = [];
 896 |       this._byId  = {};
 897 |     },
 898 | 
 899 |     // Prepare a hash of attributes (or other model) to be added to this
 900 |     // collection.
 901 |     _prepareModel: function(attrs, options) {
 902 |       if (attrs instanceof Model) {
 903 |         if (!attrs.collection) attrs.collection = this;
 904 |         return attrs;
 905 |       }
 906 |       options || (options = {});
 907 |       options.collection = this;
 908 |       var model = new this.model(attrs, options);
 909 |       if (!model._validate(attrs, options)) {
 910 |         this.trigger('invalid', this, attrs, options);
 911 |         return false;
 912 |       }
 913 |       return model;
 914 |     },
 915 | 
 916 |     // Internal method to sever a model's ties to a collection.
 917 |     _removeReference: function(model) {
 918 |       if (this === model.collection) delete model.collection;
 919 |       model.off('all', this._onModelEvent, this);
 920 |     },
 921 | 
 922 |     // Internal method called every time a model in the set fires an event.
 923 |     // Sets need to update their indexes when models change ids. All other
 924 |     // events simply proxy through. "add" and "remove" events that originate
 925 |     // in other collections are ignored.
 926 |     _onModelEvent: function(event, model, collection, options) {
 927 |       if ((event === 'add' || event === 'remove') && collection !== this) return;
 928 |       if (event === 'destroy') this.remove(model, options);
 929 |       if (model && event === 'change:' + model.idAttribute) {
 930 |         delete this._byId[model.previous(model.idAttribute)];
 931 |         if (model.id != null) this._byId[model.id] = model;
 932 |       }
 933 |       this.trigger.apply(this, arguments);
 934 |     }
 935 | 
 936 |   });
 937 | 
 938 |   // Underscore methods that we want to implement on the Collection.
 939 |   // 90% of the core usefulness of Backbone Collections is actually implemented
 940 |   // right here:
 941 |   var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
 942 |     'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
 943 |     'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
 944 |     'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
 945 |     'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
 946 |     'isEmpty', 'chain'];
 947 | 
 948 |   // Mix in each Underscore method as a proxy to `Collection#models`.
 949 |   _.each(methods, function(method) {
 950 |     Collection.prototype[method] = function() {
 951 |       var args = slice.call(arguments);
 952 |       args.unshift(this.models);
 953 |       return _[method].apply(_, args);
 954 |     };
 955 |   });
 956 | 
 957 |   // Underscore methods that take a property name as an argument.
 958 |   var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
 959 | 
 960 |   // Use attributes instead of properties.
 961 |   _.each(attributeMethods, function(method) {
 962 |     Collection.prototype[method] = function(value, context) {
 963 |       var iterator = _.isFunction(value) ? value : function(model) {
 964 |         return model.get(value);
 965 |       };
 966 |       return _[method](this.models, iterator, context);
 967 |     };
 968 |   });
 969 | 
 970 |   // Backbone.View
 971 |   // -------------
 972 | 
 973 |   // Backbone Views are almost more convention than they are actual code. A View
 974 |   // is simply a JavaScript object that represents a logical chunk of UI in the
 975 |   // DOM. This might be a single item, an entire list, a sidebar or panel, or
 976 |   // even the surrounding frame which wraps your whole app. Defining a chunk of
 977 |   // UI as a **View** allows you to define your DOM events declaratively, without
 978 |   // having to worry about render order ... and makes it easy for the view to
 979 |   // react to specific changes in the state of your models.
 980 | 
 981 |   // Creating a Backbone.View creates its initial element outside of the DOM,
 982 |   // if an existing element is not provided...
 983 |   var View = Backbone.View = function(options) {
 984 |     this.cid = _.uniqueId('view');
 985 |     this._configure(options || {});
 986 |     this._ensureElement();
 987 |     this.initialize.apply(this, arguments);
 988 |     this.delegateEvents();
 989 |   };
 990 | 
 991 |   // Cached regex to split keys for `delegate`.
 992 |   var delegateEventSplitter = /^(\S+)\s*(.*)$/;
 993 | 
 994 |   // List of view options to be merged as properties.
 995 |   var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
 996 | 
 997 |   // Set up all inheritable **Backbone.View** properties and methods.
 998 |   _.extend(View.prototype, Events, {
 999 | 
1000 |     // The default `tagName` of a View's element is `"div"`.
1001 |     tagName: 'div',
1002 | 
1003 |     // jQuery delegate for element lookup, scoped to DOM elements within the
1004 |     // current view. This should be prefered to global lookups where possible.
1005 |     $: function(selector) {
1006 |       return this.$el.find(selector);
1007 |     },
1008 | 
1009 |     // Initialize is an empty function by default. Override it with your own
1010 |     // initialization logic.
1011 |     initialize: function(){},
1012 | 
1013 |     // **render** is the core function that your view should override, in order
1014 |     // to populate its element (`this.el`), with the appropriate HTML. The
1015 |     // convention is for **render** to always return `this`.
1016 |     render: function() {
1017 |       return this;
1018 |     },
1019 | 
1020 |     // Remove this view by taking the element out of the DOM, and removing any
1021 |     // applicable Backbone.Events listeners.
1022 |     remove: function() {
1023 |       this.$el.remove();
1024 |       this.stopListening();
1025 |       return this;
1026 |     },
1027 | 
1028 |     // Change the view's element (`this.el` property), including event
1029 |     // re-delegation.
1030 |     setElement: function(element, delegate) {
1031 |       if (this.$el) this.undelegateEvents();
1032 |       this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
1033 |       this.el = this.$el[0];
1034 |       if (delegate !== false) this.delegateEvents();
1035 |       return this;
1036 |     },
1037 | 
1038 |     // Set callbacks, where `this.events` is a hash of
1039 |     //
1040 |     // *{"event selector": "callback"}*
1041 |     //
1042 |     //     {
1043 |     //       'mousedown .title':  'edit',
1044 |     //       'click .button':     'save'
1045 |     //       'click .open':       function(e) { ... }
1046 |     //     }
1047 |     //
1048 |     // pairs. Callbacks will be bound to the view, with `this` set properly.
1049 |     // Uses event delegation for efficiency.
1050 |     // Omitting the selector binds the event to `this.el`.
1051 |     // This only works for delegate-able events: not `focus`, `blur`, and
1052 |     // not `change`, `submit`, and `reset` in Internet Explorer.
1053 |     delegateEvents: function(events) {
1054 |       if (!(events || (events = _.result(this, 'events')))) return this;
1055 |       this.undelegateEvents();
1056 |       for (var key in events) {
1057 |         var method = events[key];
1058 |         if (!_.isFunction(method)) method = this[events[key]];
1059 |         if (!method) continue;
1060 | 
1061 |         var match = key.match(delegateEventSplitter);
1062 |         var eventName = match[1], selector = match[2];
1063 |         method = _.bind(method, this);
1064 |         eventName += '.delegateEvents' + this.cid;
1065 |         if (selector === '') {
1066 |           this.$el.on(eventName, method);
1067 |         } else {
1068 |           this.$el.on(eventName, selector, method);
1069 |         }
1070 |       }
1071 |       return this;
1072 |     },
1073 | 
1074 |     // Clears all callbacks previously bound to the view with `delegateEvents`.
1075 |     // You usually don't need to use this, but may wish to if you have multiple
1076 |     // Backbone views attached to the same DOM element.
1077 |     undelegateEvents: function() {
1078 |       this.$el.off('.delegateEvents' + this.cid);
1079 |       return this;
1080 |     },
1081 | 
1082 |     // Performs the initial configuration of a View with a set of options.
1083 |     // Keys with special meaning *(e.g. model, collection, id, className)* are
1084 |     // attached directly to the view.  See `viewOptions` for an exhaustive
1085 |     // list.
1086 |     _configure: function(options) {
1087 |       if (this.options) options = _.extend({}, _.result(this, 'options'), options);
1088 |       _.extend(this, _.pick(options, viewOptions));
1089 |       this.options = options;
1090 |     },
1091 | 
1092 |     // Ensure that the View has a DOM element to render into.
1093 |     // If `this.el` is a string, pass it through `$()`, take the first
1094 |     // matching element, and re-assign it to `el`. Otherwise, create
1095 |     // an element from the `id`, `className` and `tagName` properties.
1096 |     _ensureElement: function() {
1097 |       if (!this.el) {
1098 |         var attrs = _.extend({}, _.result(this, 'attributes'));
1099 |         if (this.id) attrs.id = _.result(this, 'id');
1100 |         if (this.className) attrs['class'] = _.result(this, 'className');
1101 |         var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
1102 |         this.setElement($el, false);
1103 |       } else {
1104 |         this.setElement(_.result(this, 'el'), false);
1105 |       }
1106 |     }
1107 | 
1108 |   });
1109 | 
1110 |   // Backbone.sync
1111 |   // -------------
1112 | 
1113 |   // Override this function to change the manner in which Backbone persists
1114 |   // models to the server. You will be passed the type of request, and the
1115 |   // model in question. By default, makes a RESTful Ajax request
1116 |   // to the model's `url()`. Some possible customizations could be:
1117 |   //
1118 |   // * Use `setTimeout` to batch rapid-fire updates into a single request.
1119 |   // * Send up the models as XML instead of JSON.
1120 |   // * Persist models via WebSockets instead of Ajax.
1121 |   //
1122 |   // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
1123 |   // as `POST`, with a `_method` parameter containing the true HTTP method,
1124 |   // as well as all requests with the body as `application/x-www-form-urlencoded`
1125 |   // instead of `application/json` with the model in a param named `model`.
1126 |   // Useful when interfacing with server-side languages like **PHP** that make
1127 |   // it difficult to read the body of `PUT` requests.
1128 |   Backbone.sync = function(method, model, options) {
1129 |     var type = methodMap[method];
1130 | 
1131 |     // Default options, unless specified.
1132 |     _.defaults(options || (options = {}), {
1133 |       emulateHTTP: Backbone.emulateHTTP,
1134 |       emulateJSON: Backbone.emulateJSON
1135 |     });
1136 | 
1137 |     // Default JSON-request options.
1138 |     var params = {type: type, dataType: 'json'};
1139 | 
1140 |     // Ensure that we have a URL.
1141 |     if (!options.url) {
1142 |       params.url = _.result(model, 'url') || urlError();
1143 |     }
1144 | 
1145 |     // Ensure that we have the appropriate request data.
1146 |     if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
1147 |       params.contentType = 'application/json';
1148 |       params.data = JSON.stringify(options.attrs || model.toJSON(options));
1149 |     }
1150 | 
1151 |     // For older servers, emulate JSON by encoding the request into an HTML-form.
1152 |     if (options.emulateJSON) {
1153 |       params.contentType = 'application/x-www-form-urlencoded';
1154 |       params.data = params.data ? {model: params.data} : {};
1155 |     }
1156 | 
1157 |     // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
1158 |     // And an `X-HTTP-Method-Override` header.
1159 |     if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
1160 |       params.type = 'POST';
1161 |       if (options.emulateJSON) params.data._method = type;
1162 |       var beforeSend = options.beforeSend;
1163 |       options.beforeSend = function(xhr) {
1164 |         xhr.setRequestHeader('X-HTTP-Method-Override', type);
1165 |         if (beforeSend) return beforeSend.apply(this, arguments);
1166 |       };
1167 |     }
1168 | 
1169 |     // Don't process data on a non-GET request.
1170 |     if (params.type !== 'GET' && !options.emulateJSON) {
1171 |       params.processData = false;
1172 |     }
1173 | 
1174 |     // If we're sending a `PATCH` request, and we're in an old Internet Explorer
1175 |     // that still has ActiveX enabled by default, override jQuery to use that
1176 |     // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
1177 |     if (params.type === 'PATCH' && window.ActiveXObject &&
1178 |           !(window.external && window.external.msActiveXFilteringEnabled)) {
1179 |       params.xhr = function() {
1180 |         return new ActiveXObject("Microsoft.XMLHTTP");
1181 |       };
1182 |     }
1183 | 
1184 |     // Make the request, allowing the user to override any Ajax options.
1185 |     var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
1186 |     model.trigger('request', model, xhr, options);
1187 |     return xhr;
1188 |   };
1189 | 
1190 |   // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
1191 |   var methodMap = {
1192 |     'create': 'POST',
1193 |     'update': 'PUT',
1194 |     'patch':  'PATCH',
1195 |     'delete': 'DELETE',
1196 |     'read':   'GET'
1197 |   };
1198 | 
1199 |   // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
1200 |   // Override this if you'd like to use a different library.
1201 |   Backbone.ajax = function() {
1202 |     return Backbone.$.ajax.apply(Backbone.$, arguments);
1203 |   };
1204 | 
1205 |   // Backbone.Router
1206 |   // ---------------
1207 | 
1208 |   // Routers map faux-URLs to actions, and fire events when routes are
1209 |   // matched. Creating a new one sets its `routes` hash, if not set statically.
1210 |   var Router = Backbone.Router = function(options) {
1211 |     options || (options = {});
1212 |     if (options.routes) this.routes = options.routes;
1213 |     this._bindRoutes();
1214 |     this.initialize.apply(this, arguments);
1215 |   };
1216 | 
1217 |   // Cached regular expressions for matching named param parts and splatted
1218 |   // parts of route strings.
1219 |   var optionalParam = /\((.*?)\)/g;
1220 |   var namedParam    = /(\(\?)?:\w+/g;
1221 |   var splatParam    = /\*\w+/g;
1222 |   var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
1223 | 
1224 |   // Set up all inheritable **Backbone.Router** properties and methods.
1225 |   _.extend(Router.prototype, Events, {
1226 | 
1227 |     // Initialize is an empty function by default. Override it with your own
1228 |     // initialization logic.
1229 |     initialize: function(){},
1230 | 
1231 |     // Manually bind a single named route to a callback. For example:
1232 |     //
1233 |     //     this.route('search/:query/p:num', 'search', function(query, num) {
1234 |     //       ...
1235 |     //     });
1236 |     //
1237 |     route: function(route, name, callback) {
1238 |       if (!_.isRegExp(route)) route = this._routeToRegExp(route);
1239 |       if (_.isFunction(name)) {
1240 |         callback = name;
1241 |         name = '';
1242 |       }
1243 |       if (!callback) callback = this[name];
1244 |       var router = this;
1245 |       Backbone.history.route(route, function(fragment) {
1246 |         var args = router._extractParameters(route, fragment);
1247 |         callback && callback.apply(router, args);
1248 |         router.trigger.apply(router, ['route:' + name].concat(args));
1249 |         router.trigger('route', name, args);
1250 |         Backbone.history.trigger('route', router, name, args);
1251 |       });
1252 |       return this;
1253 |     },
1254 | 
1255 |     // Simple proxy to `Backbone.history` to save a fragment into the history.
1256 |     navigate: function(fragment, options) {
1257 |       Backbone.history.navigate(fragment, options);
1258 |       return this;
1259 |     },
1260 | 
1261 |     // Bind all defined routes to `Backbone.history`. We have to reverse the
1262 |     // order of the routes here to support behavior where the most general
1263 |     // routes can be defined at the bottom of the route map.
1264 |     _bindRoutes: function() {
1265 |       if (!this.routes) return;
1266 |       this.routes = _.result(this, 'routes');
1267 |       var route, routes = _.keys(this.routes);
1268 |       while ((route = routes.pop()) != null) {
1269 |         this.route(route, this.routes[route]);
1270 |       }
1271 |     },
1272 | 
1273 |     // Convert a route string into a regular expression, suitable for matching
1274 |     // against the current location hash.
1275 |     _routeToRegExp: function(route) {
1276 |       route = route.replace(escapeRegExp, '\\$&')
1277 |                    .replace(optionalParam, '(?:$1)?')
1278 |                    .replace(namedParam, function(match, optional){
1279 |                      return optional ? match : '([^\/]+)';
1280 |                    })
1281 |                    .replace(splatParam, '(.*?)');
1282 |       return new RegExp('^' + route + '$');
1283 |     },
1284 | 
1285 |     // Given a route, and a URL fragment that it matches, return the array of
1286 |     // extracted decoded parameters. Empty or unmatched parameters will be
1287 |     // treated as `null` to normalize cross-browser behavior.
1288 |     _extractParameters: function(route, fragment) {
1289 |       var params = route.exec(fragment).slice(1);
1290 |       return _.map(params, function(param) {
1291 |         return param ? decodeURIComponent(param) : null;
1292 |       });
1293 |     }
1294 | 
1295 |   });
1296 | 
1297 |   // Backbone.History
1298 |   // ----------------
1299 | 
1300 |   // Handles cross-browser history management, based on either
1301 |   // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
1302 |   // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
1303 |   // and URL fragments. If the browser supports neither (old IE, natch),
1304 |   // falls back to polling.
1305 |   var History = Backbone.History = function() {
1306 |     this.handlers = [];
1307 |     _.bindAll(this, 'checkUrl');
1308 | 
1309 |     // Ensure that `History` can be used outside of the browser.
1310 |     if (typeof window !== 'undefined') {
1311 |       this.location = window.location;
1312 |       this.history = window.history;
1313 |     }
1314 |   };
1315 | 
1316 |   // Cached regex for stripping a leading hash/slash and trailing space.
1317 |   var routeStripper = /^[#\/]|\s+$/g;
1318 | 
1319 |   // Cached regex for stripping leading and trailing slashes.
1320 |   var rootStripper = /^\/+|\/+$/g;
1321 | 
1322 |   // Cached regex for detecting MSIE.
1323 |   var isExplorer = /msie [\w.]+/;
1324 | 
1325 |   // Cached regex for removing a trailing slash.
1326 |   var trailingSlash = /\/$/;
1327 | 
1328 |   // Has the history handling already been started?
1329 |   History.started = false;
1330 | 
1331 |   // Set up all inheritable **Backbone.History** properties and methods.
1332 |   _.extend(History.prototype, Events, {
1333 | 
1334 |     // The default interval to poll for hash changes, if necessary, is
1335 |     // twenty times a second.
1336 |     interval: 50,
1337 | 
1338 |     // Gets the true hash value. Cannot use location.hash directly due to bug
1339 |     // in Firefox where location.hash will always be decoded.
1340 |     getHash: function(window) {
1341 |       var match = (window || this).location.href.match(/#(.*)$/);
1342 |       return match ? match[1] : '';
1343 |     },
1344 | 
1345 |     // Get the cross-browser normalized URL fragment, either from the URL,
1346 |     // the hash, or the override.
1347 |     getFragment: function(fragment, forcePushState) {
1348 |       if (fragment == null) {
1349 |         if (this._hasPushState || !this._wantsHashChange || forcePushState) {
1350 |           fragment = this.location.pathname;
1351 |           var root = this.root.replace(trailingSlash, '');
1352 |           if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
1353 |         } else {
1354 |           fragment = this.getHash();
1355 |         }
1356 |       }
1357 |       return fragment.replace(routeStripper, '');
1358 |     },
1359 | 
1360 |     // Start the hash change handling, returning `true` if the current URL matches
1361 |     // an existing route, and `false` otherwise.
1362 |     start: function(options) {
1363 |       if (History.started) throw new Error("Backbone.history has already been started");
1364 |       History.started = true;
1365 | 
1366 |       // Figure out the initial configuration. Do we need an iframe?
1367 |       // Is pushState desired ... is it available?
1368 |       this.options          = _.extend({}, {root: '/'}, this.options, options);
1369 |       this.root             = this.options.root;
1370 |       this._wantsHashChange = this.options.hashChange !== false;
1371 |       this._wantsPushState  = !!this.options.pushState;
1372 |       this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
1373 |       var fragment          = this.getFragment();
1374 |       var docMode           = document.documentMode;
1375 |       var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
1376 | 
1377 |       // Normalize root to always include a leading and trailing slash.
1378 |       this.root = ('/' + this.root + '/').replace(rootStripper, '/');
1379 | 
1380 |       if (oldIE && this._wantsHashChange) {
1381 |         this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
1382 |         this.navigate(fragment);
1383 |       }
1384 | 
1385 |       // Depending on whether we're using pushState or hashes, and whether
1386 |       // 'onhashchange' is supported, determine how we check the URL state.
1387 |       if (this._hasPushState) {
1388 |         Backbone.$(window).on('popstate', this.checkUrl);
1389 |       } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
1390 |         Backbone.$(window).on('hashchange', this.checkUrl);
1391 |       } else if (this._wantsHashChange) {
1392 |         this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
1393 |       }
1394 | 
1395 |       // Determine if we need to change the base url, for a pushState link
1396 |       // opened by a non-pushState browser.
1397 |       this.fragment = fragment;
1398 |       var loc = this.location;
1399 |       var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
1400 | 
1401 |       // If we've started off with a route from a `pushState`-enabled browser,
1402 |       // but we're currently in a browser that doesn't support it...
1403 |       if (this._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) {
1404 |         this.fragment = this.getFragment(null, true);
1405 |         this.location.replace(this.root + this.location.search + '#' + this.fragment);
1406 |         // Return immediately as browser will do redirect to new url
1407 |         return true;
1408 | 
1409 |       // Or if we've started out with a hash-based route, but we're currently
1410 |       // in a browser where it could be `pushState`-based instead...
1411 |       } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
1412 |         this.fragment = this.getHash().replace(routeStripper, '');
1413 |         this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
1414 |       }
1415 | 
1416 |       if (!this.options.silent) return this.loadUrl();
1417 |     },
1418 | 
1419 |     // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
1420 |     // but possibly useful for unit testing Routers.
1421 |     stop: function() {
1422 |       Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
1423 |       clearInterval(this._checkUrlInterval);
1424 |       History.started = false;
1425 |     },
1426 | 
1427 |     // Add a route to be tested when the fragment changes. Routes added later
1428 |     // may override previous routes.
1429 |     route: function(route, callback) {
1430 |       this.handlers.unshift({route: route, callback: callback});
1431 |     },
1432 | 
1433 |     // Checks the current URL to see if it has changed, and if it has,
1434 |     // calls `loadUrl`, normalizing across the hidden iframe.
1435 |     checkUrl: function(e) {
1436 |       var current = this.getFragment();
1437 |       if (current === this.fragment && this.iframe) {
1438 |         current = this.getFragment(this.getHash(this.iframe));
1439 |       }
1440 |       if (current === this.fragment) return false;
1441 |       if (this.iframe) this.navigate(current);
1442 |       this.loadUrl() || this.loadUrl(this.getHash());
1443 |     },
1444 | 
1445 |     // Attempt to load the current URL fragment. If a route succeeds with a
1446 |     // match, returns `true`. If no defined routes matches the fragment,
1447 |     // returns `false`.
1448 |     loadUrl: function(fragmentOverride) {
1449 |       var fragment = this.fragment = this.getFragment(fragmentOverride);
1450 |       var matched = _.any(this.handlers, function(handler) {
1451 |         if (handler.route.test(fragment)) {
1452 |           handler.callback(fragment);
1453 |           return true;
1454 |         }
1455 |       });
1456 |       return matched;
1457 |     },
1458 | 
1459 |     // Save a fragment into the hash history, or replace the URL state if the
1460 |     // 'replace' option is passed. You are responsible for properly URL-encoding
1461 |     // the fragment in advance.
1462 |     //
1463 |     // The options object can contain `trigger: true` if you wish to have the
1464 |     // route callback be fired (not usually desirable), or `replace: true`, if
1465 |     // you wish to modify the current URL without adding an entry to the history.
1466 |     navigate: function(fragment, options) {
1467 |       if (!History.started) return false;
1468 |       if (!options || options === true) options = {trigger: options};
1469 |       fragment = this.getFragment(fragment || '');
1470 |       if (this.fragment === fragment) return;
1471 |       this.fragment = fragment;
1472 |       var url = this.root + fragment;
1473 | 
1474 |       // If pushState is available, we use it to set the fragment as a real URL.
1475 |       if (this._hasPushState) {
1476 |         this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
1477 | 
1478 |       // If hash changes haven't been explicitly disabled, update the hash
1479 |       // fragment to store history.
1480 |       } else if (this._wantsHashChange) {
1481 |         this._updateHash(this.location, fragment, options.replace);
1482 |         if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
1483 |           // Opening and closing the iframe tricks IE7 and earlier to push a
1484 |           // history entry on hash-tag change.  When replace is true, we don't
1485 |           // want this.
1486 |           if(!options.replace) this.iframe.document.open().close();
1487 |           this._updateHash(this.iframe.location, fragment, options.replace);
1488 |         }
1489 | 
1490 |       // If you've told us that you explicitly don't want fallback hashchange-
1491 |       // based history, then `navigate` becomes a page refresh.
1492 |       } else {
1493 |         return this.location.assign(url);
1494 |       }
1495 |       if (options.trigger) this.loadUrl(fragment);
1496 |     },
1497 | 
1498 |     // Update the hash location, either replacing the current entry, or adding
1499 |     // a new one to the browser history.
1500 |     _updateHash: function(location, fragment, replace) {
1501 |       if (replace) {
1502 |         var href = location.href.replace(/(javascript:|#).*$/, '');
1503 |         location.replace(href + '#' + fragment);
1504 |       } else {
1505 |         // Some browsers require that `hash` contains a leading #.
1506 |         location.hash = '#' + fragment;
1507 |       }
1508 |     }
1509 | 
1510 |   });
1511 | 
1512 |   // Create the default Backbone.history.
1513 |   Backbone.history = new History;
1514 | 
1515 |   // Helpers
1516 |   // -------
1517 | 
1518 |   // Helper function to correctly set up the prototype chain, for subclasses.
1519 |   // Similar to `goog.inherits`, but uses a hash of prototype properties and
1520 |   // class properties to be extended.
1521 |   var extend = function(protoProps, staticProps) {
1522 |     var parent = this;
1523 |     var child;
1524 | 
1525 |     // The constructor function for the new subclass is either defined by you
1526 |     // (the "constructor" property in your `extend` definition), or defaulted
1527 |     // by us to simply call the parent's constructor.
1528 |     if (protoProps && _.has(protoProps, 'constructor')) {
1529 |       child = protoProps.constructor;
1530 |     } else {
1531 |       child = function(){ return parent.apply(this, arguments); };
1532 |     }
1533 | 
1534 |     // Add static properties to the constructor function, if supplied.
1535 |     _.extend(child, parent, staticProps);
1536 | 
1537 |     // Set the prototype chain to inherit from `parent`, without calling
1538 |     // `parent`'s constructor function.
1539 |     var Surrogate = function(){ this.constructor = child; };
1540 |     Surrogate.prototype = parent.prototype;
1541 |     child.prototype = new Surrogate;
1542 | 
1543 |     // Add prototype properties (instance properties) to the subclass,
1544 |     // if supplied.
1545 |     if (protoProps) _.extend(child.prototype, protoProps);
1546 | 
1547 |     // Set a convenience property in case the parent's prototype is needed
1548 |     // later.
1549 |     child.__super__ = parent.prototype;
1550 | 
1551 |     return child;
1552 |   };
1553 | 
1554 |   // Set up inheritance for the model, collection, router, view and history.
1555 |   Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
1556 | 
1557 |   // Throw an error when a URL is needed, and none is supplied.
1558 |   var urlError = function() {
1559 |     throw new Error('A "url" property or function must be specified');
1560 |   };
1561 | 
1562 |   // Wrap an optional error callback with a fallback error event.
1563 |   var wrapError = function (model, options) {
1564 |     var error = options.error;
1565 |     options.error = function(resp) {
1566 |       if (error) error(model, resp, options);
1567 |       model.trigger('error', model, resp, options);
1568 |     };
1569 |   };
1570 | 
1571 | }).call(this);
1572 | 


--------------------------------------------------------------------------------
/vendor/backbone/backbone-1.1.2.js:
--------------------------------------------------------------------------------
   1 | //     Backbone.js 1.1.2
   2 | 
   3 | //     (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   4 | //     Backbone may be freely distributed under the MIT license.
   5 | //     For all details and documentation:
   6 | //     http://backbonejs.org
   7 | 
   8 | (function(root, factory) {
   9 | 
  10 |   // Set up Backbone appropriately for the environment. Start with AMD.
  11 |   if (typeof define === 'function' && define.amd) {
  12 |     define(['underscore', 'jquery', 'exports'], function(_, $, exports) {
  13 |       // Export global even in AMD case in case this script is loaded with
  14 |       // others that may still expect a global Backbone.
  15 |       root.Backbone = factory(root, exports, _, $);
  16 |     });
  17 | 
  18 |   // Next for Node.js or CommonJS. jQuery may not be needed as a module.
  19 |   } else if (typeof exports !== 'undefined') {
  20 |     var _ = require('underscore');
  21 |     factory(root, exports, _);
  22 | 
  23 |   // Finally, as a browser global.
  24 |   } else {
  25 |     root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));
  26 |   }
  27 | 
  28 | }(this, function(root, Backbone, _, $) {
  29 | 
  30 |   // Initial Setup
  31 |   // -------------
  32 | 
  33 |   // Save the previous value of the `Backbone` variable, so that it can be
  34 |   // restored later on, if `noConflict` is used.
  35 |   var previousBackbone = root.Backbone;
  36 | 
  37 |   // Create local references to array methods we'll want to use later.
  38 |   var array = [];
  39 |   var push = array.push;
  40 |   var slice = array.slice;
  41 |   var splice = array.splice;
  42 | 
  43 |   // Current version of the library. Keep in sync with `package.json`.
  44 |   Backbone.VERSION = '1.1.2';
  45 | 
  46 |   // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
  47 |   // the `$` variable.
  48 |   Backbone.$ = $;
  49 | 
  50 |   // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
  51 |   // to its previous owner. Returns a reference to this Backbone object.
  52 |   Backbone.noConflict = function() {
  53 |     root.Backbone = previousBackbone;
  54 |     return this;
  55 |   };
  56 | 
  57 |   // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
  58 |   // will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter and
  59 |   // set a `X-Http-Method-Override` header.
  60 |   Backbone.emulateHTTP = false;
  61 | 
  62 |   // Turn on `emulateJSON` to support legacy servers that can't deal with direct
  63 |   // `application/json` requests ... will encode the body as
  64 |   // `application/x-www-form-urlencoded` instead and will send the model in a
  65 |   // form param named `model`.
  66 |   Backbone.emulateJSON = false;
  67 | 
  68 |   // Backbone.Events
  69 |   // ---------------
  70 | 
  71 |   // A module that can be mixed in to *any object* in order to provide it with
  72 |   // custom events. You may bind with `on` or remove with `off` callback
  73 |   // functions to an event; `trigger`-ing an event fires all callbacks in
  74 |   // succession.
  75 |   //
  76 |   //     var object = {};
  77 |   //     _.extend(object, Backbone.Events);
  78 |   //     object.on('expand', function(){ alert('expanded'); });
  79 |   //     object.trigger('expand');
  80 |   //
  81 |   var Events = Backbone.Events = {
  82 | 
  83 |     // Bind an event to a `callback` function. Passing `"all"` will bind
  84 |     // the callback to all events fired.
  85 |     on: function(name, callback, context) {
  86 |       if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
  87 |       this._events || (this._events = {});
  88 |       var events = this._events[name] || (this._events[name] = []);
  89 |       events.push({callback: callback, context: context, ctx: context || this});
  90 |       return this;
  91 |     },
  92 | 
  93 |     // Bind an event to only be triggered a single time. After the first time
  94 |     // the callback is invoked, it will be removed.
  95 |     once: function(name, callback, context) {
  96 |       if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
  97 |       var self = this;
  98 |       var once = _.once(function() {
  99 |         self.off(name, once);
 100 |         callback.apply(this, arguments);
 101 |       });
 102 |       once._callback = callback;
 103 |       return this.on(name, once, context);
 104 |     },
 105 | 
 106 |     // Remove one or many callbacks. If `context` is null, removes all
 107 |     // callbacks with that function. If `callback` is null, removes all
 108 |     // callbacks for the event. If `name` is null, removes all bound
 109 |     // callbacks for all events.
 110 |     off: function(name, callback, context) {
 111 |       var retain, ev, events, names, i, l, j, k;
 112 |       if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
 113 |       if (!name && !callback && !context) {
 114 |         this._events = void 0;
 115 |         return this;
 116 |       }
 117 |       names = name ? [name] : _.keys(this._events);
 118 |       for (i = 0, l = names.length; i < l; i++) {
 119 |         name = names[i];
 120 |         if (events = this._events[name]) {
 121 |           this._events[name] = retain = [];
 122 |           if (callback || context) {
 123 |             for (j = 0, k = events.length; j < k; j++) {
 124 |               ev = events[j];
 125 |               if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
 126 |                   (context && context !== ev.context)) {
 127 |                 retain.push(ev);
 128 |               }
 129 |             }
 130 |           }
 131 |           if (!retain.length) delete this._events[name];
 132 |         }
 133 |       }
 134 | 
 135 |       return this;
 136 |     },
 137 | 
 138 |     // Trigger one or many events, firing all bound callbacks. Callbacks are
 139 |     // passed the same arguments as `trigger` is, apart from the event name
 140 |     // (unless you're listening on `"all"`, which will cause your callback to
 141 |     // receive the true name of the event as the first argument).
 142 |     trigger: function(name) {
 143 |       if (!this._events) return this;
 144 |       var args = slice.call(arguments, 1);
 145 |       if (!eventsApi(this, 'trigger', name, args)) return this;
 146 |       var events = this._events[name];
 147 |       var allEvents = this._events.all;
 148 |       if (events) triggerEvents(events, args);
 149 |       if (allEvents) triggerEvents(allEvents, arguments);
 150 |       return this;
 151 |     },
 152 | 
 153 |     // Tell this object to stop listening to either specific events ... or
 154 |     // to every object it's currently listening to.
 155 |     stopListening: function(obj, name, callback) {
 156 |       var listeningTo = this._listeningTo;
 157 |       if (!listeningTo) return this;
 158 |       var remove = !name && !callback;
 159 |       if (!callback && typeof name === 'object') callback = this;
 160 |       if (obj) (listeningTo = {})[obj._listenId] = obj;
 161 |       for (var id in listeningTo) {
 162 |         obj = listeningTo[id];
 163 |         obj.off(name, callback, this);
 164 |         if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
 165 |       }
 166 |       return this;
 167 |     }
 168 | 
 169 |   };
 170 | 
 171 |   // Regular expression used to split event strings.
 172 |   var eventSplitter = /\s+/;
 173 | 
 174 |   // Implement fancy features of the Events API such as multiple event
 175 |   // names `"change blur"` and jQuery-style event maps `{change: action}`
 176 |   // in terms of the existing API.
 177 |   var eventsApi = function(obj, action, name, rest) {
 178 |     if (!name) return true;
 179 | 
 180 |     // Handle event maps.
 181 |     if (typeof name === 'object') {
 182 |       for (var key in name) {
 183 |         obj[action].apply(obj, [key, name[key]].concat(rest));
 184 |       }
 185 |       return false;
 186 |     }
 187 | 
 188 |     // Handle space separated event names.
 189 |     if (eventSplitter.test(name)) {
 190 |       var names = name.split(eventSplitter);
 191 |       for (var i = 0, l = names.length; i < l; i++) {
 192 |         obj[action].apply(obj, [names[i]].concat(rest));
 193 |       }
 194 |       return false;
 195 |     }
 196 | 
 197 |     return true;
 198 |   };
 199 | 
 200 |   // A difficult-to-believe, but optimized internal dispatch function for
 201 |   // triggering events. Tries to keep the usual cases speedy (most internal
 202 |   // Backbone events have 3 arguments).
 203 |   var triggerEvents = function(events, args) {
 204 |     var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
 205 |     switch (args.length) {
 206 |       case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
 207 |       case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
 208 |       case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
 209 |       case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
 210 |       default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;
 211 |     }
 212 |   };
 213 | 
 214 |   var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
 215 | 
 216 |   // Inversion-of-control versions of `on` and `once`. Tell *this* object to
 217 |   // listen to an event in another object ... keeping track of what it's
 218 |   // listening to.
 219 |   _.each(listenMethods, function(implementation, method) {
 220 |     Events[method] = function(obj, name, callback) {
 221 |       var listeningTo = this._listeningTo || (this._listeningTo = {});
 222 |       var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
 223 |       listeningTo[id] = obj;
 224 |       if (!callback && typeof name === 'object') callback = this;
 225 |       obj[implementation](name, callback, this);
 226 |       return this;
 227 |     };
 228 |   });
 229 | 
 230 |   // Aliases for backwards compatibility.
 231 |   Events.bind   = Events.on;
 232 |   Events.unbind = Events.off;
 233 | 
 234 |   // Allow the `Backbone` object to serve as a global event bus, for folks who
 235 |   // want global "pubsub" in a convenient place.
 236 |   _.extend(Backbone, Events);
 237 | 
 238 |   // Backbone.Model
 239 |   // --------------
 240 | 
 241 |   // Backbone **Models** are the basic data object in the framework --
 242 |   // frequently representing a row in a table in a database on your server.
 243 |   // A discrete chunk of data and a bunch of useful, related methods for
 244 |   // performing computations and transformations on that data.
 245 | 
 246 |   // Create a new model with the specified attributes. A client id (`cid`)
 247 |   // is automatically generated and assigned for you.
 248 |   var Model = Backbone.Model = function(attributes, options) {
 249 |     var attrs = attributes || {};
 250 |     options || (options = {});
 251 |     this.cid = _.uniqueId('c');
 252 |     this.attributes = {};
 253 |     if (options.collection) this.collection = options.collection;
 254 |     if (options.parse) attrs = this.parse(attrs, options) || {};
 255 |     attrs = _.defaults({}, attrs, _.result(this, 'defaults'));
 256 |     this.set(attrs, options);
 257 |     this.changed = {};
 258 |     this.initialize.apply(this, arguments);
 259 |   };
 260 | 
 261 |   // Attach all inheritable methods to the Model prototype.
 262 |   _.extend(Model.prototype, Events, {
 263 | 
 264 |     // A hash of attributes whose current and previous value differ.
 265 |     changed: null,
 266 | 
 267 |     // The value returned during the last failed validation.
 268 |     validationError: null,
 269 | 
 270 |     // The default name for the JSON `id` attribute is `"id"`. MongoDB and
 271 |     // CouchDB users may want to set this to `"_id"`.
 272 |     idAttribute: 'id',
 273 | 
 274 |     // Initialize is an empty function by default. Override it with your own
 275 |     // initialization logic.
 276 |     initialize: function(){},
 277 | 
 278 |     // Return a copy of the model's `attributes` object.
 279 |     toJSON: function(options) {
 280 |       return _.clone(this.attributes);
 281 |     },
 282 | 
 283 |     // Proxy `Backbone.sync` by default -- but override this if you need
 284 |     // custom syncing semantics for *this* particular model.
 285 |     sync: function() {
 286 |       return Backbone.sync.apply(this, arguments);
 287 |     },
 288 | 
 289 |     // Get the value of an attribute.
 290 |     get: function(attr) {
 291 |       return this.attributes[attr];
 292 |     },
 293 | 
 294 |     // Get the HTML-escaped value of an attribute.
 295 |     escape: function(attr) {
 296 |       return _.escape(this.get(attr));
 297 |     },
 298 | 
 299 |     // Returns `true` if the attribute contains a value that is not null
 300 |     // or undefined.
 301 |     has: function(attr) {
 302 |       return this.get(attr) != null;
 303 |     },
 304 | 
 305 |     // Set a hash of model attributes on the object, firing `"change"`. This is
 306 |     // the core primitive operation of a model, updating the data and notifying
 307 |     // anyone who needs to know about the change in state. The heart of the beast.
 308 |     set: function(key, val, options) {
 309 |       var attr, attrs, unset, changes, silent, changing, prev, current;
 310 |       if (key == null) return this;
 311 | 
 312 |       // Handle both `"key", value` and `{key: value}` -style arguments.
 313 |       if (typeof key === 'object') {
 314 |         attrs = key;
 315 |         options = val;
 316 |       } else {
 317 |         (attrs = {})[key] = val;
 318 |       }
 319 | 
 320 |       options || (options = {});
 321 | 
 322 |       // Run validation.
 323 |       if (!this._validate(attrs, options)) return false;
 324 | 
 325 |       // Extract attributes and options.
 326 |       unset           = options.unset;
 327 |       silent          = options.silent;
 328 |       changes         = [];
 329 |       changing        = this._changing;
 330 |       this._changing  = true;
 331 | 
 332 |       if (!changing) {
 333 |         this._previousAttributes = _.clone(this.attributes);
 334 |         this.changed = {};
 335 |       }
 336 |       current = this.attributes, prev = this._previousAttributes;
 337 | 
 338 |       // Check for changes of `id`.
 339 |       if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
 340 | 
 341 |       // For each `set` attribute, update or delete the current value.
 342 |       for (attr in attrs) {
 343 |         val = attrs[attr];
 344 |         if (!_.isEqual(current[attr], val)) changes.push(attr);
 345 |         if (!_.isEqual(prev[attr], val)) {
 346 |           this.changed[attr] = val;
 347 |         } else {
 348 |           delete this.changed[attr];
 349 |         }
 350 |         unset ? delete current[attr] : current[attr] = val;
 351 |       }
 352 | 
 353 |       // Trigger all relevant attribute changes.
 354 |       if (!silent) {
 355 |         if (changes.length) this._pending = options;
 356 |         for (var i = 0, l = changes.length; i < l; i++) {
 357 |           this.trigger('change:' + changes[i], this, current[changes[i]], options);
 358 |         }
 359 |       }
 360 | 
 361 |       // You might be wondering why there's a `while` loop here. Changes can
 362 |       // be recursively nested within `"change"` events.
 363 |       if (changing) return this;
 364 |       if (!silent) {
 365 |         while (this._pending) {
 366 |           options = this._pending;
 367 |           this._pending = false;
 368 |           this.trigger('change', this, options);
 369 |         }
 370 |       }
 371 |       this._pending = false;
 372 |       this._changing = false;
 373 |       return this;
 374 |     },
 375 | 
 376 |     // Remove an attribute from the model, firing `"change"`. `unset` is a noop
 377 |     // if the attribute doesn't exist.
 378 |     unset: function(attr, options) {
 379 |       return this.set(attr, void 0, _.extend({}, options, {unset: true}));
 380 |     },
 381 | 
 382 |     // Clear all attributes on the model, firing `"change"`.
 383 |     clear: function(options) {
 384 |       var attrs = {};
 385 |       for (var key in this.attributes) attrs[key] = void 0;
 386 |       return this.set(attrs, _.extend({}, options, {unset: true}));
 387 |     },
 388 | 
 389 |     // Determine if the model has changed since the last `"change"` event.
 390 |     // If you specify an attribute name, determine if that attribute has changed.
 391 |     hasChanged: function(attr) {
 392 |       if (attr == null) return !_.isEmpty(this.changed);
 393 |       return _.has(this.changed, attr);
 394 |     },
 395 | 
 396 |     // Return an object containing all the attributes that have changed, or
 397 |     // false if there are no changed attributes. Useful for determining what
 398 |     // parts of a view need to be updated and/or what attributes need to be
 399 |     // persisted to the server. Unset attributes will be set to undefined.
 400 |     // You can also pass an attributes object to diff against the model,
 401 |     // determining if there *would be* a change.
 402 |     changedAttributes: function(diff) {
 403 |       if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
 404 |       var val, changed = false;
 405 |       var old = this._changing ? this._previousAttributes : this.attributes;
 406 |       for (var attr in diff) {
 407 |         if (_.isEqual(old[attr], (val = diff[attr]))) continue;
 408 |         (changed || (changed = {}))[attr] = val;
 409 |       }
 410 |       return changed;
 411 |     },
 412 | 
 413 |     // Get the previous value of an attribute, recorded at the time the last
 414 |     // `"change"` event was fired.
 415 |     previous: function(attr) {
 416 |       if (attr == null || !this._previousAttributes) return null;
 417 |       return this._previousAttributes[attr];
 418 |     },
 419 | 
 420 |     // Get all of the attributes of the model at the time of the previous
 421 |     // `"change"` event.
 422 |     previousAttributes: function() {
 423 |       return _.clone(this._previousAttributes);
 424 |     },
 425 | 
 426 |     // Fetch the model from the server. If the server's representation of the
 427 |     // model differs from its current attributes, they will be overridden,
 428 |     // triggering a `"change"` event.
 429 |     fetch: function(options) {
 430 |       options = options ? _.clone(options) : {};
 431 |       if (options.parse === void 0) options.parse = true;
 432 |       var model = this;
 433 |       var success = options.success;
 434 |       options.success = function(resp) {
 435 |         if (!model.set(model.parse(resp, options), options)) return false;
 436 |         if (success) success(model, resp, options);
 437 |         model.trigger('sync', model, resp, options);
 438 |       };
 439 |       wrapError(this, options);
 440 |       return this.sync('read', this, options);
 441 |     },
 442 | 
 443 |     // Set a hash of model attributes, and sync the model to the server.
 444 |     // If the server returns an attributes hash that differs, the model's
 445 |     // state will be `set` again.
 446 |     save: function(key, val, options) {
 447 |       var attrs, method, xhr, attributes = this.attributes;
 448 | 
 449 |       // Handle both `"key", value` and `{key: value}` -style arguments.
 450 |       if (key == null || typeof key === 'object') {
 451 |         attrs = key;
 452 |         options = val;
 453 |       } else {
 454 |         (attrs = {})[key] = val;
 455 |       }
 456 | 
 457 |       options = _.extend({validate: true}, options);
 458 | 
 459 |       // If we're not waiting and attributes exist, save acts as
 460 |       // `set(attr).save(null, opts)` with validation. Otherwise, check if
 461 |       // the model will be valid when the attributes, if any, are set.
 462 |       if (attrs && !options.wait) {
 463 |         if (!this.set(attrs, options)) return false;
 464 |       } else {
 465 |         if (!this._validate(attrs, options)) return false;
 466 |       }
 467 | 
 468 |       // Set temporary attributes if `{wait: true}`.
 469 |       if (attrs && options.wait) {
 470 |         this.attributes = _.extend({}, attributes, attrs);
 471 |       }
 472 | 
 473 |       // After a successful server-side save, the client is (optionally)
 474 |       // updated with the server-side state.
 475 |       if (options.parse === void 0) options.parse = true;
 476 |       var model = this;
 477 |       var success = options.success;
 478 |       options.success = function(resp) {
 479 |         // Ensure attributes are restored during synchronous saves.
 480 |         model.attributes = attributes;
 481 |         var serverAttrs = model.parse(resp, options);
 482 |         if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
 483 |         if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
 484 |           return false;
 485 |         }
 486 |         if (success) success(model, resp, options);
 487 |         model.trigger('sync', model, resp, options);
 488 |       };
 489 |       wrapError(this, options);
 490 | 
 491 |       method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
 492 |       if (method === 'patch') options.attrs = attrs;
 493 |       xhr = this.sync(method, this, options);
 494 | 
 495 |       // Restore attributes.
 496 |       if (attrs && options.wait) this.attributes = attributes;
 497 | 
 498 |       return xhr;
 499 |     },
 500 | 
 501 |     // Destroy this model on the server if it was already persisted.
 502 |     // Optimistically removes the model from its collection, if it has one.
 503 |     // If `wait: true` is passed, waits for the server to respond before removal.
 504 |     destroy: function(options) {
 505 |       options = options ? _.clone(options) : {};
 506 |       var model = this;
 507 |       var success = options.success;
 508 | 
 509 |       var destroy = function() {
 510 |         model.trigger('destroy', model, model.collection, options);
 511 |       };
 512 | 
 513 |       options.success = function(resp) {
 514 |         if (options.wait || model.isNew()) destroy();
 515 |         if (success) success(model, resp, options);
 516 |         if (!model.isNew()) model.trigger('sync', model, resp, options);
 517 |       };
 518 | 
 519 |       if (this.isNew()) {
 520 |         options.success();
 521 |         return false;
 522 |       }
 523 |       wrapError(this, options);
 524 | 
 525 |       var xhr = this.sync('delete', this, options);
 526 |       if (!options.wait) destroy();
 527 |       return xhr;
 528 |     },
 529 | 
 530 |     // Default URL for the model's representation on the server -- if you're
 531 |     // using Backbone's restful methods, override this to change the endpoint
 532 |     // that will be called.
 533 |     url: function() {
 534 |       var base =
 535 |         _.result(this, 'urlRoot') ||
 536 |         _.result(this.collection, 'url') ||
 537 |         urlError();
 538 |       if (this.isNew()) return base;
 539 |       return base.replace(/([^\/])$/, '$1/') + encodeURIComponent(this.id);
 540 |     },
 541 | 
 542 |     // **parse** converts a response into the hash of attributes to be `set` on
 543 |     // the model. The default implementation is just to pass the response along.
 544 |     parse: function(resp, options) {
 545 |       return resp;
 546 |     },
 547 | 
 548 |     // Create a new model with identical attributes to this one.
 549 |     clone: function() {
 550 |       return new this.constructor(this.attributes);
 551 |     },
 552 | 
 553 |     // A model is new if it has never been saved to the server, and lacks an id.
 554 |     isNew: function() {
 555 |       return !this.has(this.idAttribute);
 556 |     },
 557 | 
 558 |     // Check if the model is currently in a valid state.
 559 |     isValid: function(options) {
 560 |       return this._validate({}, _.extend(options || {}, { validate: true }));
 561 |     },
 562 | 
 563 |     // Run validation against the next complete set of model attributes,
 564 |     // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
 565 |     _validate: function(attrs, options) {
 566 |       if (!options.validate || !this.validate) return true;
 567 |       attrs = _.extend({}, this.attributes, attrs);
 568 |       var error = this.validationError = this.validate(attrs, options) || null;
 569 |       if (!error) return true;
 570 |       this.trigger('invalid', this, error, _.extend(options, {validationError: error}));
 571 |       return false;
 572 |     }
 573 | 
 574 |   });
 575 | 
 576 |   // Underscore methods that we want to implement on the Model.
 577 |   var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
 578 | 
 579 |   // Mix in each Underscore method as a proxy to `Model#attributes`.
 580 |   _.each(modelMethods, function(method) {
 581 |     Model.prototype[method] = function() {
 582 |       var args = slice.call(arguments);
 583 |       args.unshift(this.attributes);
 584 |       return _[method].apply(_, args);
 585 |     };
 586 |   });
 587 | 
 588 |   // Backbone.Collection
 589 |   // -------------------
 590 | 
 591 |   // If models tend to represent a single row of data, a Backbone Collection is
 592 |   // more analagous to a table full of data ... or a small slice or page of that
 593 |   // table, or a collection of rows that belong together for a particular reason
 594 |   // -- all of the messages in this particular folder, all of the documents
 595 |   // belonging to this particular author, and so on. Collections maintain
 596 |   // indexes of their models, both in order, and for lookup by `id`.
 597 | 
 598 |   // Create a new **Collection**, perhaps to contain a specific type of `model`.
 599 |   // If a `comparator` is specified, the Collection will maintain
 600 |   // its models in sort order, as they're added and removed.
 601 |   var Collection = Backbone.Collection = function(models, options) {
 602 |     options || (options = {});
 603 |     if (options.model) this.model = options.model;
 604 |     if (options.comparator !== void 0) this.comparator = options.comparator;
 605 |     this._reset();
 606 |     this.initialize.apply(this, arguments);
 607 |     if (models) this.reset(models, _.extend({silent: true}, options));
 608 |   };
 609 | 
 610 |   // Default options for `Collection#set`.
 611 |   var setOptions = {add: true, remove: true, merge: true};
 612 |   var addOptions = {add: true, remove: false};
 613 | 
 614 |   // Define the Collection's inheritable methods.
 615 |   _.extend(Collection.prototype, Events, {
 616 | 
 617 |     // The default model for a collection is just a **Backbone.Model**.
 618 |     // This should be overridden in most cases.
 619 |     model: Model,
 620 | 
 621 |     // Initialize is an empty function by default. Override it with your own
 622 |     // initialization logic.
 623 |     initialize: function(){},
 624 | 
 625 |     // The JSON representation of a Collection is an array of the
 626 |     // models' attributes.
 627 |     toJSON: function(options) {
 628 |       return this.map(function(model){ return model.toJSON(options); });
 629 |     },
 630 | 
 631 |     // Proxy `Backbone.sync` by default.
 632 |     sync: function() {
 633 |       return Backbone.sync.apply(this, arguments);
 634 |     },
 635 | 
 636 |     // Add a model, or list of models to the set.
 637 |     add: function(models, options) {
 638 |       return this.set(models, _.extend({merge: false}, options, addOptions));
 639 |     },
 640 | 
 641 |     // Remove a model, or a list of models from the set.
 642 |     remove: function(models, options) {
 643 |       var singular = !_.isArray(models);
 644 |       models = singular ? [models] : _.clone(models);
 645 |       options || (options = {});
 646 |       var i, l, index, model;
 647 |       for (i = 0, l = models.length; i < l; i++) {
 648 |         model = models[i] = this.get(models[i]);
 649 |         if (!model) continue;
 650 |         delete this._byId[model.id];
 651 |         delete this._byId[model.cid];
 652 |         index = this.indexOf(model);
 653 |         this.models.splice(index, 1);
 654 |         this.length--;
 655 |         if (!options.silent) {
 656 |           options.index = index;
 657 |           model.trigger('remove', model, this, options);
 658 |         }
 659 |         this._removeReference(model, options);
 660 |       }
 661 |       return singular ? models[0] : models;
 662 |     },
 663 | 
 664 |     // Update a collection by `set`-ing a new list of models, adding new ones,
 665 |     // removing models that are no longer present, and merging models that
 666 |     // already exist in the collection, as necessary. Similar to **Model#set**,
 667 |     // the core operation for updating the data contained by the collection.
 668 |     set: function(models, options) {
 669 |       options = _.defaults({}, options, setOptions);
 670 |       if (options.parse) models = this.parse(models, options);
 671 |       var singular = !_.isArray(models);
 672 |       models = singular ? (models ? [models] : []) : _.clone(models);
 673 |       var i, l, id, model, attrs, existing, sort;
 674 |       var at = options.at;
 675 |       var targetModel = this.model;
 676 |       var sortable = this.comparator && (at == null) && options.sort !== false;
 677 |       var sortAttr = _.isString(this.comparator) ? this.comparator : null;
 678 |       var toAdd = [], toRemove = [], modelMap = {};
 679 |       var add = options.add, merge = options.merge, remove = options.remove;
 680 |       var order = !sortable && add && remove ? [] : false;
 681 | 
 682 |       // Turn bare objects into model references, and prevent invalid models
 683 |       // from being added.
 684 |       for (i = 0, l = models.length; i < l; i++) {
 685 |         attrs = models[i] || {};
 686 |         if (attrs instanceof Model) {
 687 |           id = model = attrs;
 688 |         } else {
 689 |           id = attrs[targetModel.prototype.idAttribute || 'id'];
 690 |         }
 691 | 
 692 |         // If a duplicate is found, prevent it from being added and
 693 |         // optionally merge it into the existing model.
 694 |         if (existing = this.get(id)) {
 695 |           if (remove) modelMap[existing.cid] = true;
 696 |           if (merge) {
 697 |             attrs = attrs === model ? model.attributes : attrs;
 698 |             if (options.parse) attrs = existing.parse(attrs, options);
 699 |             existing.set(attrs, options);
 700 |             if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
 701 |           }
 702 |           models[i] = existing;
 703 | 
 704 |         // If this is a new, valid model, push it to the `toAdd` list.
 705 |         } else if (add) {
 706 |           model = models[i] = this._prepareModel(attrs, options);
 707 |           if (!model) continue;
 708 |           toAdd.push(model);
 709 |           this._addReference(model, options);
 710 |         }
 711 | 
 712 |         // Do not add multiple models with the same `id`.
 713 |         model = existing || model;
 714 |         if (order && (model.isNew() || !modelMap[model.id])) order.push(model);
 715 |         modelMap[model.id] = true;
 716 |       }
 717 | 
 718 |       // Remove nonexistent models if appropriate.
 719 |       if (remove) {
 720 |         for (i = 0, l = this.length; i < l; ++i) {
 721 |           if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
 722 |         }
 723 |         if (toRemove.length) this.remove(toRemove, options);
 724 |       }
 725 | 
 726 |       // See if sorting is needed, update `length` and splice in new models.
 727 |       if (toAdd.length || (order && order.length)) {
 728 |         if (sortable) sort = true;
 729 |         this.length += toAdd.length;
 730 |         if (at != null) {
 731 |           for (i = 0, l = toAdd.length; i < l; i++) {
 732 |             this.models.splice(at + i, 0, toAdd[i]);
 733 |           }
 734 |         } else {
 735 |           if (order) this.models.length = 0;
 736 |           var orderedModels = order || toAdd;
 737 |           for (i = 0, l = orderedModels.length; i < l; i++) {
 738 |             this.models.push(orderedModels[i]);
 739 |           }
 740 |         }
 741 |       }
 742 | 
 743 |       // Silently sort the collection if appropriate.
 744 |       if (sort) this.sort({silent: true});
 745 | 
 746 |       // Unless silenced, it's time to fire all appropriate add/sort events.
 747 |       if (!options.silent) {
 748 |         for (i = 0, l = toAdd.length; i < l; i++) {
 749 |           (model = toAdd[i]).trigger('add', model, this, options);
 750 |         }
 751 |         if (sort || (order && order.length)) this.trigger('sort', this, options);
 752 |       }
 753 | 
 754 |       // Return the added (or merged) model (or models).
 755 |       return singular ? models[0] : models;
 756 |     },
 757 | 
 758 |     // When you have more items than you want to add or remove individually,
 759 |     // you can reset the entire set with a new list of models, without firing
 760 |     // any granular `add` or `remove` events. Fires `reset` when finished.
 761 |     // Useful for bulk operations and optimizations.
 762 |     reset: function(models, options) {
 763 |       options || (options = {});
 764 |       for (var i = 0, l = this.models.length; i < l; i++) {
 765 |         this._removeReference(this.models[i], options);
 766 |       }
 767 |       options.previousModels = this.models;
 768 |       this._reset();
 769 |       models = this.add(models, _.extend({silent: true}, options));
 770 |       if (!options.silent) this.trigger('reset', this, options);
 771 |       return models;
 772 |     },
 773 | 
 774 |     // Add a model to the end of the collection.
 775 |     push: function(model, options) {
 776 |       return this.add(model, _.extend({at: this.length}, options));
 777 |     },
 778 | 
 779 |     // Remove a model from the end of the collection.
 780 |     pop: function(options) {
 781 |       var model = this.at(this.length - 1);
 782 |       this.remove(model, options);
 783 |       return model;
 784 |     },
 785 | 
 786 |     // Add a model to the beginning of the collection.
 787 |     unshift: function(model, options) {
 788 |       return this.add(model, _.extend({at: 0}, options));
 789 |     },
 790 | 
 791 |     // Remove a model from the beginning of the collection.
 792 |     shift: function(options) {
 793 |       var model = this.at(0);
 794 |       this.remove(model, options);
 795 |       return model;
 796 |     },
 797 | 
 798 |     // Slice out a sub-array of models from the collection.
 799 |     slice: function() {
 800 |       return slice.apply(this.models, arguments);
 801 |     },
 802 | 
 803 |     // Get a model from the set by id.
 804 |     get: function(obj) {
 805 |       if (obj == null) return void 0;
 806 |       return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];
 807 |     },
 808 | 
 809 |     // Get the model at the given index.
 810 |     at: function(index) {
 811 |       return this.models[index];
 812 |     },
 813 | 
 814 |     // Return models with matching attributes. Useful for simple cases of
 815 |     // `filter`.
 816 |     where: function(attrs, first) {
 817 |       if (_.isEmpty(attrs)) return first ? void 0 : [];
 818 |       return this[first ? 'find' : 'filter'](function(model) {
 819 |         for (var key in attrs) {
 820 |           if (attrs[key] !== model.get(key)) return false;
 821 |         }
 822 |         return true;
 823 |       });
 824 |     },
 825 | 
 826 |     // Return the first model with matching attributes. Useful for simple cases
 827 |     // of `find`.
 828 |     findWhere: function(attrs) {
 829 |       return this.where(attrs, true);
 830 |     },
 831 | 
 832 |     // Force the collection to re-sort itself. You don't need to call this under
 833 |     // normal circumstances, as the set will maintain sort order as each item
 834 |     // is added.
 835 |     sort: function(options) {
 836 |       if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
 837 |       options || (options = {});
 838 | 
 839 |       // Run sort based on type of `comparator`.
 840 |       if (_.isString(this.comparator) || this.comparator.length === 1) {
 841 |         this.models = this.sortBy(this.comparator, this);
 842 |       } else {
 843 |         this.models.sort(_.bind(this.comparator, this));
 844 |       }
 845 | 
 846 |       if (!options.silent) this.trigger('sort', this, options);
 847 |       return this;
 848 |     },
 849 | 
 850 |     // Pluck an attribute from each model in the collection.
 851 |     pluck: function(attr) {
 852 |       return _.invoke(this.models, 'get', attr);
 853 |     },
 854 | 
 855 |     // Fetch the default set of models for this collection, resetting the
 856 |     // collection when they arrive. If `reset: true` is passed, the response
 857 |     // data will be passed through the `reset` method instead of `set`.
 858 |     fetch: function(options) {
 859 |       options = options ? _.clone(options) : {};
 860 |       if (options.parse === void 0) options.parse = true;
 861 |       var success = options.success;
 862 |       var collection = this;
 863 |       options.success = function(resp) {
 864 |         var method = options.reset ? 'reset' : 'set';
 865 |         collection[method](resp, options);
 866 |         if (success) success(collection, resp, options);
 867 |         collection.trigger('sync', collection, resp, options);
 868 |       };
 869 |       wrapError(this, options);
 870 |       return this.sync('read', this, options);
 871 |     },
 872 | 
 873 |     // Create a new instance of a model in this collection. Add the model to the
 874 |     // collection immediately, unless `wait: true` is passed, in which case we
 875 |     // wait for the server to agree.
 876 |     create: function(model, options) {
 877 |       options = options ? _.clone(options) : {};
 878 |       if (!(model = this._prepareModel(model, options))) return false;
 879 |       if (!options.wait) this.add(model, options);
 880 |       var collection = this;
 881 |       var success = options.success;
 882 |       options.success = function(model, resp) {
 883 |         if (options.wait) collection.add(model, options);
 884 |         if (success) success(model, resp, options);
 885 |       };
 886 |       model.save(null, options);
 887 |       return model;
 888 |     },
 889 | 
 890 |     // **parse** converts a response into a list of models to be added to the
 891 |     // collection. The default implementation is just to pass it through.
 892 |     parse: function(resp, options) {
 893 |       return resp;
 894 |     },
 895 | 
 896 |     // Create a new collection with an identical list of models as this one.
 897 |     clone: function() {
 898 |       return new this.constructor(this.models);
 899 |     },
 900 | 
 901 |     // Private method to reset all internal state. Called when the collection
 902 |     // is first initialized or reset.
 903 |     _reset: function() {
 904 |       this.length = 0;
 905 |       this.models = [];
 906 |       this._byId  = {};
 907 |     },
 908 | 
 909 |     // Prepare a hash of attributes (or other model) to be added to this
 910 |     // collection.
 911 |     _prepareModel: function(attrs, options) {
 912 |       if (attrs instanceof Model) return attrs;
 913 |       options = options ? _.clone(options) : {};
 914 |       options.collection = this;
 915 |       var model = new this.model(attrs, options);
 916 |       if (!model.validationError) return model;
 917 |       this.trigger('invalid', this, model.validationError, options);
 918 |       return false;
 919 |     },
 920 | 
 921 |     // Internal method to create a model's ties to a collection.
 922 |     _addReference: function(model, options) {
 923 |       this._byId[model.cid] = model;
 924 |       if (model.id != null) this._byId[model.id] = model;
 925 |       if (!model.collection) model.collection = this;
 926 |       model.on('all', this._onModelEvent, this);
 927 |     },
 928 | 
 929 |     // Internal method to sever a model's ties to a collection.
 930 |     _removeReference: function(model, options) {
 931 |       if (this === model.collection) delete model.collection;
 932 |       model.off('all', this._onModelEvent, this);
 933 |     },
 934 | 
 935 |     // Internal method called every time a model in the set fires an event.
 936 |     // Sets need to update their indexes when models change ids. All other
 937 |     // events simply proxy through. "add" and "remove" events that originate
 938 |     // in other collections are ignored.
 939 |     _onModelEvent: function(event, model, collection, options) {
 940 |       if ((event === 'add' || event === 'remove') && collection !== this) return;
 941 |       if (event === 'destroy') this.remove(model, options);
 942 |       if (model && event === 'change:' + model.idAttribute) {
 943 |         delete this._byId[model.previous(model.idAttribute)];
 944 |         if (model.id != null) this._byId[model.id] = model;
 945 |       }
 946 |       this.trigger.apply(this, arguments);
 947 |     }
 948 | 
 949 |   });
 950 | 
 951 |   // Underscore methods that we want to implement on the Collection.
 952 |   // 90% of the core usefulness of Backbone Collections is actually implemented
 953 |   // right here:
 954 |   var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
 955 |     'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
 956 |     'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
 957 |     'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
 958 |     'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
 959 |     'lastIndexOf', 'isEmpty', 'chain', 'sample'];
 960 | 
 961 |   // Mix in each Underscore method as a proxy to `Collection#models`.
 962 |   _.each(methods, function(method) {
 963 |     Collection.prototype[method] = function() {
 964 |       var args = slice.call(arguments);
 965 |       args.unshift(this.models);
 966 |       return _[method].apply(_, args);
 967 |     };
 968 |   });
 969 | 
 970 |   // Underscore methods that take a property name as an argument.
 971 |   var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];
 972 | 
 973 |   // Use attributes instead of properties.
 974 |   _.each(attributeMethods, function(method) {
 975 |     Collection.prototype[method] = function(value, context) {
 976 |       var iterator = _.isFunction(value) ? value : function(model) {
 977 |         return model.get(value);
 978 |       };
 979 |       return _[method](this.models, iterator, context);
 980 |     };
 981 |   });
 982 | 
 983 |   // Backbone.View
 984 |   // -------------
 985 | 
 986 |   // Backbone Views are almost more convention than they are actual code. A View
 987 |   // is simply a JavaScript object that represents a logical chunk of UI in the
 988 |   // DOM. This might be a single item, an entire list, a sidebar or panel, or
 989 |   // even the surrounding frame which wraps your whole app. Defining a chunk of
 990 |   // UI as a **View** allows you to define your DOM events declaratively, without
 991 |   // having to worry about render order ... and makes it easy for the view to
 992 |   // react to specific changes in the state of your models.
 993 | 
 994 |   // Creating a Backbone.View creates its initial element outside of the DOM,
 995 |   // if an existing element is not provided...
 996 |   var View = Backbone.View = function(options) {
 997 |     this.cid = _.uniqueId('view');
 998 |     options || (options = {});
 999 |     _.extend(this, _.pick(options, viewOptions));
1000 |     this._ensureElement();
1001 |     this.initialize.apply(this, arguments);
1002 |     this.delegateEvents();
1003 |   };
1004 | 
1005 |   // Cached regex to split keys for `delegate`.
1006 |   var delegateEventSplitter = /^(\S+)\s*(.*)$/;
1007 | 
1008 |   // List of view options to be merged as properties.
1009 |   var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
1010 | 
1011 |   // Set up all inheritable **Backbone.View** properties and methods.
1012 |   _.extend(View.prototype, Events, {
1013 | 
1014 |     // The default `tagName` of a View's element is `"div"`.
1015 |     tagName: 'div',
1016 | 
1017 |     // jQuery delegate for element lookup, scoped to DOM elements within the
1018 |     // current view. This should be preferred to global lookups where possible.
1019 |     $: function(selector) {
1020 |       return this.$el.find(selector);
1021 |     },
1022 | 
1023 |     // Initialize is an empty function by default. Override it with your own
1024 |     // initialization logic.
1025 |     initialize: function(){},
1026 | 
1027 |     // **render** is the core function that your view should override, in order
1028 |     // to populate its element (`this.el`), with the appropriate HTML. The
1029 |     // convention is for **render** to always return `this`.
1030 |     render: function() {
1031 |       return this;
1032 |     },
1033 | 
1034 |     // Remove this view by taking the element out of the DOM, and removing any
1035 |     // applicable Backbone.Events listeners.
1036 |     remove: function() {
1037 |       this.$el.remove();
1038 |       this.stopListening();
1039 |       return this;
1040 |     },
1041 | 
1042 |     // Change the view's element (`this.el` property), including event
1043 |     // re-delegation.
1044 |     setElement: function(element, delegate) {
1045 |       if (this.$el) this.undelegateEvents();
1046 |       this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
1047 |       this.el = this.$el[0];
1048 |       if (delegate !== false) this.delegateEvents();
1049 |       return this;
1050 |     },
1051 | 
1052 |     // Set callbacks, where `this.events` is a hash of
1053 |     //
1054 |     // *{"event selector": "callback"}*
1055 |     //
1056 |     //     {
1057 |     //       'mousedown .title':  'edit',
1058 |     //       'click .button':     'save',
1059 |     //       'click .open':       function(e) { ... }
1060 |     //     }
1061 |     //
1062 |     // pairs. Callbacks will be bound to the view, with `this` set properly.
1063 |     // Uses event delegation for efficiency.
1064 |     // Omitting the selector binds the event to `this.el`.
1065 |     // This only works for delegate-able events: not `focus`, `blur`, and
1066 |     // not `change`, `submit`, and `reset` in Internet Explorer.
1067 |     delegateEvents: function(events) {
1068 |       if (!(events || (events = _.result(this, 'events')))) return this;
1069 |       this.undelegateEvents();
1070 |       for (var key in events) {
1071 |         var method = events[key];
1072 |         if (!_.isFunction(method)) method = this[events[key]];
1073 |         if (!method) continue;
1074 | 
1075 |         var match = key.match(delegateEventSplitter);
1076 |         var eventName = match[1], selector = match[2];
1077 |         method = _.bind(method, this);
1078 |         eventName += '.delegateEvents' + this.cid;
1079 |         if (selector === '') {
1080 |           this.$el.on(eventName, method);
1081 |         } else {
1082 |           this.$el.on(eventName, selector, method);
1083 |         }
1084 |       }
1085 |       return this;
1086 |     },
1087 | 
1088 |     // Clears all callbacks previously bound to the view with `delegateEvents`.
1089 |     // You usually don't need to use this, but may wish to if you have multiple
1090 |     // Backbone views attached to the same DOM element.
1091 |     undelegateEvents: function() {
1092 |       this.$el.off('.delegateEvents' + this.cid);
1093 |       return this;
1094 |     },
1095 | 
1096 |     // Ensure that the View has a DOM element to render into.
1097 |     // If `this.el` is a string, pass it through `$()`, take the first
1098 |     // matching element, and re-assign it to `el`. Otherwise, create
1099 |     // an element from the `id`, `className` and `tagName` properties.
1100 |     _ensureElement: function() {
1101 |       if (!this.el) {
1102 |         var attrs = _.extend({}, _.result(this, 'attributes'));
1103 |         if (this.id) attrs.id = _.result(this, 'id');
1104 |         if (this.className) attrs['class'] = _.result(this, 'className');
1105 |         var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
1106 |         this.setElement($el, false);
1107 |       } else {
1108 |         this.setElement(_.result(this, 'el'), false);
1109 |       }
1110 |     }
1111 | 
1112 |   });
1113 | 
1114 |   // Backbone.sync
1115 |   // -------------
1116 | 
1117 |   // Override this function to change the manner in which Backbone persists
1118 |   // models to the server. You will be passed the type of request, and the
1119 |   // model in question. By default, makes a RESTful Ajax request
1120 |   // to the model's `url()`. Some possible customizations could be:
1121 |   //
1122 |   // * Use `setTimeout` to batch rapid-fire updates into a single request.
1123 |   // * Send up the models as XML instead of JSON.
1124 |   // * Persist models via WebSockets instead of Ajax.
1125 |   //
1126 |   // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
1127 |   // as `POST`, with a `_method` parameter containing the true HTTP method,
1128 |   // as well as all requests with the body as `application/x-www-form-urlencoded`
1129 |   // instead of `application/json` with the model in a param named `model`.
1130 |   // Useful when interfacing with server-side languages like **PHP** that make
1131 |   // it difficult to read the body of `PUT` requests.
1132 |   Backbone.sync = function(method, model, options) {
1133 |     var type = methodMap[method];
1134 | 
1135 |     // Default options, unless specified.
1136 |     _.defaults(options || (options = {}), {
1137 |       emulateHTTP: Backbone.emulateHTTP,
1138 |       emulateJSON: Backbone.emulateJSON
1139 |     });
1140 | 
1141 |     // Default JSON-request options.
1142 |     var params = {type: type, dataType: 'json'};
1143 | 
1144 |     // Ensure that we have a URL.
1145 |     if (!options.url) {
1146 |       params.url = _.result(model, 'url') || urlError();
1147 |     }
1148 | 
1149 |     // Ensure that we have the appropriate request data.
1150 |     if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
1151 |       params.contentType = 'application/json';
1152 |       params.data = JSON.stringify(options.attrs || model.toJSON(options));
1153 |     }
1154 | 
1155 |     // For older servers, emulate JSON by encoding the request into an HTML-form.
1156 |     if (options.emulateJSON) {
1157 |       params.contentType = 'application/x-www-form-urlencoded';
1158 |       params.data = params.data ? {model: params.data} : {};
1159 |     }
1160 | 
1161 |     // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
1162 |     // And an `X-HTTP-Method-Override` header.
1163 |     if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
1164 |       params.type = 'POST';
1165 |       if (options.emulateJSON) params.data._method = type;
1166 |       var beforeSend = options.beforeSend;
1167 |       options.beforeSend = function(xhr) {
1168 |         xhr.setRequestHeader('X-HTTP-Method-Override', type);
1169 |         if (beforeSend) return beforeSend.apply(this, arguments);
1170 |       };
1171 |     }
1172 | 
1173 |     // Don't process data on a non-GET request.
1174 |     if (params.type !== 'GET' && !options.emulateJSON) {
1175 |       params.processData = false;
1176 |     }
1177 | 
1178 |     // If we're sending a `PATCH` request, and we're in an old Internet Explorer
1179 |     // that still has ActiveX enabled by default, override jQuery to use that
1180 |     // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
1181 |     if (params.type === 'PATCH' && noXhrPatch) {
1182 |       params.xhr = function() {
1183 |         return new ActiveXObject("Microsoft.XMLHTTP");
1184 |       };
1185 |     }
1186 | 
1187 |     // Make the request, allowing the user to override any Ajax options.
1188 |     var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
1189 |     model.trigger('request', model, xhr, options);
1190 |     return xhr;
1191 |   };
1192 | 
1193 |   var noXhrPatch =
1194 |     typeof window !== 'undefined' && !!window.ActiveXObject &&
1195 |       !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);
1196 | 
1197 |   // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
1198 |   var methodMap = {
1199 |     'create': 'POST',
1200 |     'update': 'PUT',
1201 |     'patch':  'PATCH',
1202 |     'delete': 'DELETE',
1203 |     'read':   'GET'
1204 |   };
1205 | 
1206 |   // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
1207 |   // Override this if you'd like to use a different library.
1208 |   Backbone.ajax = function() {
1209 |     return Backbone.$.ajax.apply(Backbone.$, arguments);
1210 |   };
1211 | 
1212 |   // Backbone.Router
1213 |   // ---------------
1214 | 
1215 |   // Routers map faux-URLs to actions, and fire events when routes are
1216 |   // matched. Creating a new one sets its `routes` hash, if not set statically.
1217 |   var Router = Backbone.Router = function(options) {
1218 |     options || (options = {});
1219 |     if (options.routes) this.routes = options.routes;
1220 |     this._bindRoutes();
1221 |     this.initialize.apply(this, arguments);
1222 |   };
1223 | 
1224 |   // Cached regular expressions for matching named param parts and splatted
1225 |   // parts of route strings.
1226 |   var optionalParam = /\((.*?)\)/g;
1227 |   var namedParam    = /(\(\?)?:\w+/g;
1228 |   var splatParam    = /\*\w+/g;
1229 |   var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
1230 | 
1231 |   // Set up all inheritable **Backbone.Router** properties and methods.
1232 |   _.extend(Router.prototype, Events, {
1233 | 
1234 |     // Initialize is an empty function by default. Override it with your own
1235 |     // initialization logic.
1236 |     initialize: function(){},
1237 | 
1238 |     // Manually bind a single named route to a callback. For example:
1239 |     //
1240 |     //     this.route('search/:query/p:num', 'search', function(query, num) {
1241 |     //       ...
1242 |     //     });
1243 |     //
1244 |     route: function(route, name, callback) {
1245 |       if (!_.isRegExp(route)) route = this._routeToRegExp(route);
1246 |       if (_.isFunction(name)) {
1247 |         callback = name;
1248 |         name = '';
1249 |       }
1250 |       if (!callback) callback = this[name];
1251 |       var router = this;
1252 |       Backbone.history.route(route, function(fragment) {
1253 |         var args = router._extractParameters(route, fragment);
1254 |         router.execute(callback, args);
1255 |         router.trigger.apply(router, ['route:' + name].concat(args));
1256 |         router.trigger('route', name, args);
1257 |         Backbone.history.trigger('route', router, name, args);
1258 |       });
1259 |       return this;
1260 |     },
1261 | 
1262 |     // Execute a route handler with the provided parameters.  This is an
1263 |     // excellent place to do pre-route setup or post-route cleanup.
1264 |     execute: function(callback, args) {
1265 |       if (callback) callback.apply(this, args);
1266 |     },
1267 | 
1268 |     // Simple proxy to `Backbone.history` to save a fragment into the history.
1269 |     navigate: function(fragment, options) {
1270 |       Backbone.history.navigate(fragment, options);
1271 |       return this;
1272 |     },
1273 | 
1274 |     // Bind all defined routes to `Backbone.history`. We have to reverse the
1275 |     // order of the routes here to support behavior where the most general
1276 |     // routes can be defined at the bottom of the route map.
1277 |     _bindRoutes: function() {
1278 |       if (!this.routes) return;
1279 |       this.routes = _.result(this, 'routes');
1280 |       var route, routes = _.keys(this.routes);
1281 |       while ((route = routes.pop()) != null) {
1282 |         this.route(route, this.routes[route]);
1283 |       }
1284 |     },
1285 | 
1286 |     // Convert a route string into a regular expression, suitable for matching
1287 |     // against the current location hash.
1288 |     _routeToRegExp: function(route) {
1289 |       route = route.replace(escapeRegExp, '\\$&')
1290 |                    .replace(optionalParam, '(?:$1)?')
1291 |                    .replace(namedParam, function(match, optional) {
1292 |                      return optional ? match : '([^/?]+)';
1293 |                    })
1294 |                    .replace(splatParam, '([^?]*?)');
1295 |       return new RegExp('^' + route + '(?:\\?([\\s\\S]*))?$');
1296 |     },
1297 | 
1298 |     // Given a route, and a URL fragment that it matches, return the array of
1299 |     // extracted decoded parameters. Empty or unmatched parameters will be
1300 |     // treated as `null` to normalize cross-browser behavior.
1301 |     _extractParameters: function(route, fragment) {
1302 |       var params = route.exec(fragment).slice(1);
1303 |       return _.map(params, function(param, i) {
1304 |         // Don't decode the search params.
1305 |         if (i === params.length - 1) return param || null;
1306 |         return param ? decodeURIComponent(param) : null;
1307 |       });
1308 |     }
1309 | 
1310 |   });
1311 | 
1312 |   // Backbone.History
1313 |   // ----------------
1314 | 
1315 |   // Handles cross-browser history management, based on either
1316 |   // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
1317 |   // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
1318 |   // and URL fragments. If the browser supports neither (old IE, natch),
1319 |   // falls back to polling.
1320 |   var History = Backbone.History = function() {
1321 |     this.handlers = [];
1322 |     _.bindAll(this, 'checkUrl');
1323 | 
1324 |     // Ensure that `History` can be used outside of the browser.
1325 |     if (typeof window !== 'undefined') {
1326 |       this.location = window.location;
1327 |       this.history = window.history;
1328 |     }
1329 |   };
1330 | 
1331 |   // Cached regex for stripping a leading hash/slash and trailing space.
1332 |   var routeStripper = /^[#\/]|\s+$/g;
1333 | 
1334 |   // Cached regex for stripping leading and trailing slashes.
1335 |   var rootStripper = /^\/+|\/+$/g;
1336 | 
1337 |   // Cached regex for detecting MSIE.
1338 |   var isExplorer = /msie [\w.]+/;
1339 | 
1340 |   // Cached regex for removing a trailing slash.
1341 |   var trailingSlash = /\/$/;
1342 | 
1343 |   // Cached regex for stripping urls of hash.
1344 |   var pathStripper = /#.*$/;
1345 | 
1346 |   // Has the history handling already been started?
1347 |   History.started = false;
1348 | 
1349 |   // Set up all inheritable **Backbone.History** properties and methods.
1350 |   _.extend(History.prototype, Events, {
1351 | 
1352 |     // The default interval to poll for hash changes, if necessary, is
1353 |     // twenty times a second.
1354 |     interval: 50,
1355 | 
1356 |     // Are we at the app root?
1357 |     atRoot: function() {
1358 |       return this.location.pathname.replace(/[^\/]$/, '$&/') === this.root;
1359 |     },
1360 | 
1361 |     // Gets the true hash value. Cannot use location.hash directly due to bug
1362 |     // in Firefox where location.hash will always be decoded.
1363 |     getHash: function(window) {
1364 |       var match = (window || this).location.href.match(/#(.*)$/);
1365 |       return match ? match[1] : '';
1366 |     },
1367 | 
1368 |     // Get the cross-browser normalized URL fragment, either from the URL,
1369 |     // the hash, or the override.
1370 |     getFragment: function(fragment, forcePushState) {
1371 |       if (fragment == null) {
1372 |         if (this._hasPushState || !this._wantsHashChange || forcePushState) {
1373 |           fragment = decodeURI(this.location.pathname + this.location.search);
1374 |           var root = this.root.replace(trailingSlash, '');
1375 |           if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
1376 |         } else {
1377 |           fragment = this.getHash();
1378 |         }
1379 |       }
1380 |       return fragment.replace(routeStripper, '');
1381 |     },
1382 | 
1383 |     // Start the hash change handling, returning `true` if the current URL matches
1384 |     // an existing route, and `false` otherwise.
1385 |     start: function(options) {
1386 |       if (History.started) throw new Error("Backbone.history has already been started");
1387 |       History.started = true;
1388 | 
1389 |       // Figure out the initial configuration. Do we need an iframe?
1390 |       // Is pushState desired ... is it available?
1391 |       this.options          = _.extend({root: '/'}, this.options, options);
1392 |       this.root             = this.options.root;
1393 |       this._wantsHashChange = this.options.hashChange !== false;
1394 |       this._wantsPushState  = !!this.options.pushState;
1395 |       this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
1396 |       var fragment          = this.getFragment();
1397 |       var docMode           = document.documentMode;
1398 |       var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
1399 | 
1400 |       // Normalize root to always include a leading and trailing slash.
1401 |       this.root = ('/' + this.root + '/').replace(rootStripper, '/');
1402 | 
1403 |       if (oldIE && this._wantsHashChange) {
1404 |         var frame = Backbone.$('<iframe src="javascript:0" tabindex="-1">');
1405 |         this.iframe = frame.hide().appendTo('body')[0].contentWindow;
1406 |         this.navigate(fragment);
1407 |       }
1408 | 
1409 |       // Depending on whether we're using pushState or hashes, and whether
1410 |       // 'onhashchange' is supported, determine how we check the URL state.
1411 |       if (this._hasPushState) {
1412 |         Backbone.$(window).on('popstate', this.checkUrl);
1413 |       } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
1414 |         Backbone.$(window).on('hashchange', this.checkUrl);
1415 |       } else if (this._wantsHashChange) {
1416 |         this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
1417 |       }
1418 | 
1419 |       // Determine if we need to change the base url, for a pushState link
1420 |       // opened by a non-pushState browser.
1421 |       this.fragment = fragment;
1422 |       var loc = this.location;
1423 | 
1424 |       // Transition from hashChange to pushState or vice versa if both are
1425 |       // requested.
1426 |       if (this._wantsHashChange && this._wantsPushState) {
1427 | 
1428 |         // If we've started off with a route from a `pushState`-enabled
1429 |         // browser, but we're currently in a browser that doesn't support it...
1430 |         if (!this._hasPushState && !this.atRoot()) {
1431 |           this.fragment = this.getFragment(null, true);
1432 |           this.location.replace(this.root + '#' + this.fragment);
1433 |           // Return immediately as browser will do redirect to new url
1434 |           return true;
1435 | 
1436 |         // Or if we've started out with a hash-based route, but we're currently
1437 |         // in a browser where it could be `pushState`-based instead...
1438 |         } else if (this._hasPushState && this.atRoot() && loc.hash) {
1439 |           this.fragment = this.getHash().replace(routeStripper, '');
1440 |           this.history.replaceState({}, document.title, this.root + this.fragment);
1441 |         }
1442 | 
1443 |       }
1444 | 
1445 |       if (!this.options.silent) return this.loadUrl();
1446 |     },
1447 | 
1448 |     // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
1449 |     // but possibly useful for unit testing Routers.
1450 |     stop: function() {
1451 |       Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
1452 |       if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);
1453 |       History.started = false;
1454 |     },
1455 | 
1456 |     // Add a route to be tested when the fragment changes. Routes added later
1457 |     // may override previous routes.
1458 |     route: function(route, callback) {
1459 |       this.handlers.unshift({route: route, callback: callback});
1460 |     },
1461 | 
1462 |     // Checks the current URL to see if it has changed, and if it has,
1463 |     // calls `loadUrl`, normalizing across the hidden iframe.
1464 |     checkUrl: function(e) {
1465 |       var current = this.getFragment();
1466 |       if (current === this.fragment && this.iframe) {
1467 |         current = this.getFragment(this.getHash(this.iframe));
1468 |       }
1469 |       if (current === this.fragment) return false;
1470 |       if (this.iframe) this.navigate(current);
1471 |       this.loadUrl();
1472 |     },
1473 | 
1474 |     // Attempt to load the current URL fragment. If a route succeeds with a
1475 |     // match, returns `true`. If no defined routes matches the fragment,
1476 |     // returns `false`.
1477 |     loadUrl: function(fragment) {
1478 |       fragment = this.fragment = this.getFragment(fragment);
1479 |       return _.any(this.handlers, function(handler) {
1480 |         if (handler.route.test(fragment)) {
1481 |           handler.callback(fragment);
1482 |           return true;
1483 |         }
1484 |       });
1485 |     },
1486 | 
1487 |     // Save a fragment into the hash history, or replace the URL state if the
1488 |     // 'replace' option is passed. You are responsible for properly URL-encoding
1489 |     // the fragment in advance.
1490 |     //
1491 |     // The options object can contain `trigger: true` if you wish to have the
1492 |     // route callback be fired (not usually desirable), or `replace: true`, if
1493 |     // you wish to modify the current URL without adding an entry to the history.
1494 |     navigate: function(fragment, options) {
1495 |       if (!History.started) return false;
1496 |       if (!options || options === true) options = {trigger: !!options};
1497 | 
1498 |       var url = this.root + (fragment = this.getFragment(fragment || ''));
1499 | 
1500 |       // Strip the hash for matching.
1501 |       fragment = fragment.replace(pathStripper, '');
1502 | 
1503 |       if (this.fragment === fragment) return;
1504 |       this.fragment = fragment;
1505 | 
1506 |       // Don't include a trailing slash on the root.
1507 |       if (fragment === '' && url !== '/') url = url.slice(0, -1);
1508 | 
1509 |       // If pushState is available, we use it to set the fragment as a real URL.
1510 |       if (this._hasPushState) {
1511 |         this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
1512 | 
1513 |       // If hash changes haven't been explicitly disabled, update the hash
1514 |       // fragment to store history.
1515 |       } else if (this._wantsHashChange) {
1516 |         this._updateHash(this.location, fragment, options.replace);
1517 |         if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
1518 |           // Opening and closing the iframe tricks IE7 and earlier to push a
1519 |           // history entry on hash-tag change.  When replace is true, we don't
1520 |           // want this.
1521 |           if(!options.replace) this.iframe.document.open().close();
1522 |           this._updateHash(this.iframe.location, fragment, options.replace);
1523 |         }
1524 | 
1525 |       // If you've told us that you explicitly don't want fallback hashchange-
1526 |       // based history, then `navigate` becomes a page refresh.
1527 |       } else {
1528 |         return this.location.assign(url);
1529 |       }
1530 |       if (options.trigger) return this.loadUrl(fragment);
1531 |     },
1532 | 
1533 |     // Update the hash location, either replacing the current entry, or adding
1534 |     // a new one to the browser history.
1535 |     _updateHash: function(location, fragment, replace) {
1536 |       if (replace) {
1537 |         var href = location.href.replace(/(javascript:|#).*$/, '');
1538 |         location.replace(href + '#' + fragment);
1539 |       } else {
1540 |         // Some browsers require that `hash` contains a leading #.
1541 |         location.hash = '#' + fragment;
1542 |       }
1543 |     }
1544 | 
1545 |   });
1546 | 
1547 |   // Create the default Backbone.history.
1548 |   Backbone.history = new History;
1549 | 
1550 |   // Helpers
1551 |   // -------
1552 | 
1553 |   // Helper function to correctly set up the prototype chain, for subclasses.
1554 |   // Similar to `goog.inherits`, but uses a hash of prototype properties and
1555 |   // class properties to be extended.
1556 |   var extend = function(protoProps, staticProps) {
1557 |     var parent = this;
1558 |     var child;
1559 | 
1560 |     // The constructor function for the new subclass is either defined by you
1561 |     // (the "constructor" property in your `extend` definition), or defaulted
1562 |     // by us to simply call the parent's constructor.
1563 |     if (protoProps && _.has(protoProps, 'constructor')) {
1564 |       child = protoProps.constructor;
1565 |     } else {
1566 |       child = function(){ return parent.apply(this, arguments); };
1567 |     }
1568 | 
1569 |     // Add static properties to the constructor function, if supplied.
1570 |     _.extend(child, parent, staticProps);
1571 | 
1572 |     // Set the prototype chain to inherit from `parent`, without calling
1573 |     // `parent`'s constructor function.
1574 |     var Surrogate = function(){ this.constructor = child; };
1575 |     Surrogate.prototype = parent.prototype;
1576 |     child.prototype = new Surrogate;
1577 | 
1578 |     // Add prototype properties (instance properties) to the subclass,
1579 |     // if supplied.
1580 |     if (protoProps) _.extend(child.prototype, protoProps);
1581 | 
1582 |     // Set a convenience property in case the parent's prototype is needed
1583 |     // later.
1584 |     child.__super__ = parent.prototype;
1585 | 
1586 |     return child;
1587 |   };
1588 | 
1589 |   // Set up inheritance for the model, collection, router, view and history.
1590 |   Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
1591 | 
1592 |   // Throw an error when a URL is needed, and none is supplied.
1593 |   var urlError = function() {
1594 |     throw new Error('A "url" property or function must be specified');
1595 |   };
1596 | 
1597 |   // Wrap an optional error callback with a fallback error event.
1598 |   var wrapError = function(model, options) {
1599 |     var error = options.error;
1600 |     options.error = function(resp) {
1601 |       if (error) error(model, resp, options);
1602 |       model.trigger('error', model, resp, options);
1603 |     };
1604 |   };
1605 | 
1606 |   return Backbone;
1607 | 
1608 | }));
1609 | 


--------------------------------------------------------------------------------