├── .gitignore
├── Gruntfile.coffee
├── README.md
├── api
    ├── models
    │   └── todo.coffee
    └── routes
    │   └── todos.coffee
├── bashrc
├── package.json
├── server.coffee
└── web
    ├── app.coffee
    ├── main.coffee
    ├── models
        └── todo.coffee
    ├── public
        ├── css
        │   ├── style.css
        │   └── style.styl
        ├── index.html
        └── js
        │   ├── app.js
        │   ├── lib
        │       ├── backbone.babysitter.js
        │       ├── backbone.js
        │       ├── backbone.marionette.js
        │       ├── backbone.relational.js
        │       ├── backbone.wreqr.js
        │       ├── jquery.js
        │       ├── require.js
        │       └── underscore.js
        │   ├── main.js
        │   ├── models
        │       └── todo.js
        │   ├── router.js
        │   ├── templates
        │       ├── jade.js
        │       ├── template.js
        │       └── todo.js
        │   └── views
        │       ├── template.js
        │       ├── todo.js
        │       └── todolist.js
    ├── router.coffee
    ├── templates
        ├── template.jade
        └── todo.jade
    └── views
        ├── .template.coffee.swp
        ├── template.coffee
        ├── todo.coffee
        └── todolist.coffee


/.gitignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.seed
 3 | *.log
 4 | *.csv
 5 | *.dat
 6 | *.out
 7 | *.pid
 8 | *.gz
 9 | 
10 | pids
11 | logs
12 | results
13 | 
14 | npm-debug.log
15 | node_modules
16 | 
17 | *.swp
18 | 


--------------------------------------------------------------------------------
/Gruntfile.coffee:
--------------------------------------------------------------------------------
 1 | path = require('path')
 2 | 
 3 | module.exports = (grunt) ->
 4 |   grunt.initConfig({
 5 |     express: {
 6 |       server: {
 7 |         options: {
 8 |           bases: path.resolve('web/public')
 9 |           debug: true
10 |           server: path.resolve('./server.coffee')
11 |           monitor: {
12 |             command: 'coffee'
13 |           }
14 |         }
15 |       }
16 |     }
17 | 
18 |     coffee: {
19 |       compile: {
20 |         files: [
21 |           expand: true
22 |           cwd: 'web/'
23 |           src: '**/*.coffee'
24 |           dest: 'web/public/js/'
25 |           ext: '.js'
26 |         ]
27 |       }
28 |     }
29 | 
30 |     jade: {
31 |       compile: {
32 |         options: {
33 |           client: true
34 |           namespace: false
35 |           amd: true
36 |         }
37 |         files: [
38 |           expand: true
39 |           cwd: 'web/templates'
40 |           src: '**/*.jade'
41 |           dest: 'web/public/js/templates'
42 |           ext: '.js'
43 |         ]
44 |       }
45 |     }
46 | 
47 |     watch: {
48 |       coffee: {
49 |         files: 'web/**/*.coffee'
50 |         tasks: ['coffee']
51 |       }
52 |       jade: {
53 |         files: 'web/templates/*.jade'
54 |         tasks: ['jade']
55 |       }
56 |     }
57 | 
58 |   })
59 | 
60 |   grunt.loadNpmTasks('grunt-contrib-coffee')
61 |   grunt.loadNpmTasks('grunt-contrib-jade')
62 |   grunt.loadNpmTasks('grunt-contrib-requirejs')
63 |   grunt.loadNpmTasks('grunt-contrib-watch')
64 |   grunt.loadNpmTasks('grunt-express')
65 | 
66 |   grunt.registerTask('build', 'coffee jade stylus requirejs')
67 |   grunt.registerTask('build-dev', 'coffee jade')
68 |   grunt.registerTask('default', ['express', 'watch'])
69 | 
70 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Node / Backbone Web App Boilerplate
 2 | 
 3 | ## Description
 4 | Node/Backbone forms a powerful combination for building single page web applications that scale. Because of these two project's popularity, there are several great boilerplate projects out there, but all for either Node or Backbone seperately. This project aims to integrate these two worlds (Backend and Frontend) making it easy to start building next generation web applications.
 5 | 
 6 | The most prominent technologies are:
 7 | 
 8 | #### Backend: 
 9 | - Node.js
10 | - Express.js
11 | - Mongoose.js / MongoDB
12 | 
13 | #### Frontend: 
14 |  - Backbone.js
15 |  - Marionette.js
16 |  - Require.js
17 |  - Jade Templates
18 |  - Stylus CSS Preprocessor
19 | 
20 | ### Other
21 |  - CoffeeScript
22 |  - Grunt based development environment
23 |  
24 | Although it should already provide a solid starting point, this project is still a work in progress (See Todo's below).
25 | 
26 | ## Getting started
27 | 
28 | 1. In an Ubuntu 12.10 terminal, run the following command to install the required dependencies. (Or use your distribution's instructions to install Git, Node v0.8, NPM and MongoDB.)
29 | 
30 |         sudo apt-get install git nodejs npm mongodb-server
31 | 
32 | 2. Get the project source code from GitHub
33 | 
34 |         git clone git@github.com:skaapgif/webapp-boilerplate.git webapp
35 |         cd webapp
36 | 
37 | 3. Optionally run these commands to set up the node package manager to install node packages in your home folder (useful if you don't have sudo rights, like at a university lab)
38 | 
39 |         cat npmrc >> ~/.npmrc
40 |         cat bashrc >> ~/.bashrc
41 |         source ~/.bashrc
42 | 
43 | 4. Finally, install node package dependencies and start the server
44 | 
45 |         npm install
46 |         npm install -g grunt-cli
47 |         npm start
48 | 
49 | 5. Point your browser to localhost:3000 and start hacking! Any changes to source files will cause grunt to recompile/reload.
50 | 
51 | ## Todo
52 |  - Mocha BDD api tests
53 |  - Mocha BDD frontend tests using WebDriver
54 |  - Introduction to folder layout & files, links to relevant tutorials
55 |  - Example stylus css
56 |  - MongoDB sessions
57 |  - Production hardening (Cluster, error handling, monitoring)
58 |  - Heroku Procfile and instructions for super easy heroku deployments
59 | 


--------------------------------------------------------------------------------
/api/models/todo.coffee:
--------------------------------------------------------------------------------
 1 | mongoose = require('mongoose')
 2 | Schema = mongoose.Schema
 3 | 
 4 | TodoSchema = new Schema({
 5 |   title: String
 6 |   done: Boolean
 7 | })
 8 | 
 9 | return mongoose.model('Todo', TodoSchema)
10 | 


--------------------------------------------------------------------------------
/api/routes/todos.coffee:
--------------------------------------------------------------------------------
 1 | 
 2 | Todo = require('../models/todo')
 3 | 
 4 | # List todos
 5 | exports.list = (req, res) ->
 6 |   res.json([{title: 'First todo'}])
 7 | 
 8 | exports.post = (req, res) ->
 9 |   todo = new Todo({title: 'hello'})
10 |   todo.save((err) ->
11 |     if err? then next(err)
12 |     res.json(todo)
13 |   )
14 | 
15 | exports.put = (req, res) ->
16 |   res.send(404, 'Implement')
17 | 


--------------------------------------------------------------------------------
/bashrc:
--------------------------------------------------------------------------------
1 | ### Add globally install node package binaries to path
2 | export PATH="$HOME/.npm/bin:$PATH"
3 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "application-name",
 3 |   "version": "0.0.1",
 4 |   "private": true,
 5 |   "scripts": {
 6 |     "start": "grunt"
 7 |   },
 8 |   "dependencies": {
 9 |     "express": "3.0.x",
10 |     "jade": "0.28.x",
11 |     "stylus": "0.32.x",
12 |     "grunt": "0.4.x",
13 |     "grunt-contrib-jade": "0.5.x",
14 |     "grunt-contrib-coffee": "0.6.x",
15 |     "grunt-contrib-watch": "~0.3.1",
16 |     "grunt-express": "~0.3.0",
17 |     "mongoose": "~3.5.9",
18 |     "grunt-contrib-requirejs": "~0.4.0"
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/server.coffee:
--------------------------------------------------------------------------------
 1 | http = require("http")
 2 | express = require("express")
 3 | todos = require("./api/routes/todos")
 4 | mongoose = require('mongoose')
 5 | #http = require("http")
 6 | path = require("path")
 7 | 
 8 | mongoose.connect('localhost', 'test')
 9 | 
10 | app = express()
11 | app.configure(() ->
12 |   app.set("port", process.env.PORT or 3000)
13 |   app.use(express.favicon())
14 |   app.use(express.logger("dev"))
15 |   app.use(express.bodyParser())
16 |   app.use(app.router)
17 |   app.use(express.static(path.join(__dirname, "/web/public")))
18 | )
19 | 
20 | app.configure("development", () ->
21 |   app.use(express.errorHandler())
22 | )
23 | 
24 | #app.get("/", routes.index)
25 | app.get("/todos", todos.list)
26 | app.put("/todos", todos.post)
27 | app.put("/todos/:id", todos.put)
28 | 
29 | module.exports = app
30 | 
31 | ### Handled by grunt-express
32 | http.createServer(app).listen(app.get("port"), () ->
33 |   console.log "Express server listening on port " + app.get("port")
34 | )
35 | ###
36 | 


--------------------------------------------------------------------------------
/web/app.coffee:
--------------------------------------------------------------------------------
 1 | define((require) ->
 2 |   $ = require('jquery')
 3 |   Backbone = require('backbone')
 4 |   Marionette = require('marionette')
 5 |   router = require('router')
 6 | 
 7 |   app = new Marionette.Application()
 8 |   app.router = router
 9 | 
10 |   app.addInitializer((options) ->
11 |     Backbone.history.start()
12 |   )
13 | 
14 |   app.addRegions({
15 |     content: '#content'
16 |   })
17 |  
18 |   return app
19 | )
20 | 


--------------------------------------------------------------------------------
/web/main.coffee:
--------------------------------------------------------------------------------
 1 | requirejs.config({
 2 |   baseUrl: 'js'
 3 |   paths: {
 4 |     'backbone': 'lib/backbone'
 5 |     'backbone.babysitter': 'lib/backbone.babysitter'
 6 |     'backbone.wreqr': 'lib/backbone.wreqr'
 7 |     'jade': 'templates/jade'
 8 |     'jquery': 'lib/jquery'
 9 |     'marionette': 'lib/backbone.marionette'
10 |     'underscore': 'lib/underscore'
11 |   }
12 |   shim: {
13 |   }
14 | })
15 | 
16 | require(['app'], (app) ->
17 | 
18 |   app.start()
19 |   
20 | )
21 | 


--------------------------------------------------------------------------------
/web/models/todo.coffee:
--------------------------------------------------------------------------------
1 | define((require) ->
2 |   
3 |   Backbone = require('backbone')
4 | 
5 |   return Backbone.Model.extend({
6 |     urlRoot: '/todos/'
7 |   })
8 | )
9 | 


--------------------------------------------------------------------------------
/web/public/css/style.css:
--------------------------------------------------------------------------------
1 | body {
2 |   padding: 50px;
3 |   font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
4 | }
5 | a {
6 |   color: #00b7ff;
7 | }
8 | 


--------------------------------------------------------------------------------
/web/public/css/style.styl:
--------------------------------------------------------------------------------
1 | body
2 |   padding: 50px
3 |   font: 14px "Lucida Grande", Helvetica, Arial, sans-serif
4 | a
5 |   color: #00B7FF


--------------------------------------------------------------------------------
/web/public/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8" />
 5 |     <title>
 6 |       Todo List
 7 |     </title>
 8 |     <link rel="stylesheet" type="text/css" href="/css/main.css" />
 9 |     <script data-main="js/main" type="text/javascript" src="/js/lib/require.js">
10 |     </script>
11 |   </head>
12 |   <body>
13 |     <div id="top">
14 |     </div>
15 |     <div id="content">
16 |     </div>
17 |   </body>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/web/public/js/app.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   define(function(require) {
 4 |     var $, Backbone, Marionette, app, router;
 5 |     $ = require('jquery');
 6 |     Backbone = require('backbone');
 7 |     Marionette = require('marionette');
 8 |     router = require('router');
 9 |     app = new Marionette.Application();
10 |     app.router = router;
11 |     app.addInitializer(function(options) {
12 |       return Backbone.history.start();
13 |     });
14 |     app.addRegions({
15 |       content: '#content'
16 |     });
17 |     return app;
18 |   });
19 | 
20 | }).call(this);
21 | 


--------------------------------------------------------------------------------
/web/public/js/lib/backbone.babysitter.js:
--------------------------------------------------------------------------------
  1 | // Backbone.BabySitter, v0.0.4
  2 | // Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
  3 | // Distributed under MIT license
  4 | // http://github.com/marionettejs/backbone.babysitter
  5 | (function (root, factory) {
  6 |   if (typeof exports === 'object') {
  7 | 
  8 |     var underscore = require('underscore');
  9 |     var backbone = require('backbone');
 10 | 
 11 |     module.exports = factory(underscore, backbone);
 12 | 
 13 |   } else if (typeof define === 'function' && define.amd) {
 14 | 
 15 |     define(['underscore', 'backbone'], factory);
 16 | 
 17 |   } 
 18 | }(this, function (_, Backbone) {
 19 |   "option strict";
 20 | 
 21 |   // Backbone.ChildViewContainer
 22 |   // ---------------------------
 23 |   //
 24 |   // Provide a container to store, retrieve and
 25 |   // shut down child views.
 26 |   
 27 |   Backbone.ChildViewContainer = (function(Backbone, _){
 28 |     
 29 |     // Container Constructor
 30 |     // ---------------------
 31 |   
 32 |     var Container = function(initialViews){
 33 |       this._views = {};
 34 |       this._indexByModel = {};
 35 |       this._indexByCollection = {};
 36 |       this._indexByCustom = {};
 37 |       this._updateLength();
 38 |   
 39 |       this._addInitialViews(initialViews);
 40 |     };
 41 |   
 42 |     // Container Methods
 43 |     // -----------------
 44 |   
 45 |     _.extend(Container.prototype, {
 46 |   
 47 |       // Add a view to this container. Stores the view
 48 |       // by `cid` and makes it searchable by the model
 49 |       // and/or collection of the view. Optionally specify
 50 |       // a custom key to store an retrieve the view.
 51 |       add: function(view, customIndex){
 52 |         var viewCid = view.cid;
 53 |   
 54 |         // store the view
 55 |         this._views[viewCid] = view;
 56 |   
 57 |         // index it by model
 58 |         if (view.model){
 59 |           this._indexByModel[view.model.cid] = viewCid;
 60 |         }
 61 |   
 62 |         // index it by collection
 63 |         if (view.collection){
 64 |           this._indexByCollection[view.collection.cid] = viewCid;
 65 |         }
 66 |   
 67 |         // index by custom
 68 |         if (customIndex){
 69 |           this._indexByCustom[customIndex] = viewCid;
 70 |         }
 71 |   
 72 |         this._updateLength();
 73 |       },
 74 |   
 75 |       // Find a view by the model that was attached to
 76 |       // it. Uses the model's `cid` to find it, and
 77 |       // retrieves the view by it's `cid` from the result
 78 |       findByModel: function(model){
 79 |         var viewCid = this._indexByModel[model.cid];
 80 |         return this.findByCid(viewCid);
 81 |       },
 82 |   
 83 |       // Find a view by the collection that was attached to
 84 |       // it. Uses the collection's `cid` to find it, and
 85 |       // retrieves the view by it's `cid` from the result
 86 |       findByCollection: function(col){
 87 |         var viewCid = this._indexByCollection[col.cid];
 88 |         return this.findByCid(viewCid);
 89 |       },
 90 |   
 91 |       // Find a view by a custom indexer.
 92 |       findByCustom: function(index){
 93 |         var viewCid = this._indexByCustom[index];
 94 |         return this.findByCid(viewCid);
 95 |       },
 96 |   
 97 |       // Find by index. This is not guaranteed to be a
 98 |       // stable index.
 99 |       findByIndex: function(index){
100 |         return _.values(this._views)[index];
101 |       },
102 |   
103 |       // retrieve a view by it's `cid` directly
104 |       findByCid: function(cid){
105 |         return this._views[cid];
106 |       },
107 |   
108 |       // Remove a view
109 |       remove: function(view){
110 |         var viewCid = view.cid;
111 |   
112 |         // delete model index
113 |         if (view.model){
114 |           delete this._indexByModel[view.model.cid];
115 |         }
116 |   
117 |         // delete collection index
118 |         if (view.collection){
119 |           delete this._indexByCollection[view.collection.cid];
120 |         }
121 |   
122 |         // delete custom index
123 |         var cust;
124 |   
125 |         for (var key in this._indexByCustom){
126 |           if (this._indexByCustom.hasOwnProperty(key)){
127 |             if (this._indexByCustom[key] === viewCid){
128 |               cust = key;
129 |               break;
130 |             }
131 |           }
132 |         }
133 |   
134 |         if (cust){
135 |           delete this._indexByCustom[cust];
136 |         }
137 |   
138 |         // remove the view from the container
139 |         delete this._views[viewCid];
140 |   
141 |         // update the length
142 |         this._updateLength();
143 |       },
144 |   
145 |       // Call a method on every view in the container,
146 |       // passing parameters to the call method one at a
147 |       // time, like `function.call`.
148 |       call: function(method, args){
149 |         args = Array.prototype.slice.call(arguments, 1);
150 |         this.apply(method, args);
151 |       },
152 |   
153 |       // Apply a method on every view in the container,
154 |       // passing parameters to the call method one at a
155 |       // time, like `function.apply`.
156 |       apply: function(method, args){
157 |         var view;
158 |   
159 |         // fix for IE < 9
160 |         args = args || [];
161 |   
162 |         _.each(this._views, function(view, key){
163 |           if (_.isFunction(view[method])){
164 |             view[method].apply(view, args);
165 |           }
166 |         });
167 |   
168 |       },
169 |   
170 |       // Update the `.length` attribute on this container
171 |       _updateLength: function(){
172 |         this.length = _.size(this._views);
173 |       },
174 |   
175 |       // set up an initial list of views
176 |       _addInitialViews: function(views){
177 |         if (!views){ return; }
178 |   
179 |         var view, i,
180 |             length = views.length;
181 |   
182 |         for (i=0; i<length; i++){
183 |           view = views[i];
184 |           this.add(view);
185 |         }
186 |       }
187 |     });
188 |   
189 |     // Borrowing this code from Backbone.Collection:
190 |     // http://backbonejs.org/docs/backbone.html#section-106
191 |     //
192 |     // Mix in methods from Underscore, for iteration, and other
193 |     // collection related features.
194 |     var methods = ['forEach', 'each', 'map', 'find', 'detect', 'filter', 
195 |       'select', 'reject', 'every', 'all', 'some', 'any', 'include', 
196 |       'contains', 'invoke', 'toArray', 'first', 'initial', 'rest', 
197 |       'last', 'without', 'isEmpty', 'pluck'];
198 |   
199 |     _.each(methods, function(method) {
200 |       Container.prototype[method] = function() {
201 |         var views = _.values(this._views);
202 |         var args = [views].concat(_.toArray(arguments));
203 |         return _[method].apply(_, args);
204 |       };
205 |     });
206 |   
207 |     // return the public API
208 |     return Container;
209 |   })(Backbone, _);
210 |   
211 |   return Backbone.ChildViewContainer; 
212 | 
213 | }));
214 | 


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


--------------------------------------------------------------------------------
/web/public/js/lib/backbone.marionette.js:
--------------------------------------------------------------------------------
   1 |  // Backbone.Marionette, v1.0.0-rc5
   2 |  // Copyright (c)2013 Derick Bailey, Muted Solutions, LLC.
   3 |  // Distributed under MIT license
   4 |  // http://github.com/marionettejs/backbone.marionette
   5 | 
   6 | (function (root, factory) {
   7 |   if (typeof exports === 'object') {
   8 | 
   9 |     var jquery = require('jquery');
  10 |     var underscore = require('underscore');
  11 |     var backbone = require('backbone');
  12 |     var wreqr = require('backbone.wreqr');
  13 |     var babysitter = require('backbone.babysitter');
  14 | 
  15 |     module.exports = factory(jquery, underscore, backbone, wreqr, babysitter);
  16 | 
  17 |   } else if (typeof define === 'function' && define.amd) {
  18 | 
  19 |     define(['jquery', 'underscore', 'backbone', 'backbone.wreqr', 'backbone.babysitter'], factory);
  20 | 
  21 |   } 
  22 | }(this, function ($, _, Backbone) {
  23 | 
  24 |   var Marionette = (function(Backbone, _, $){
  25 |     "use strict";
  26 |   
  27 |     var Marionette = {};
  28 |     Backbone.Marionette = Marionette;
  29 |   
  30 |   // Helpers
  31 |   // -------
  32 |   
  33 |   // For slicing `arguments` in functions
  34 |   var slice = Array.prototype.slice;
  35 |   
  36 |   // Marionette.extend
  37 |   // -----------------
  38 |   
  39 |   // Borrow the Backbone `extend` method so we can use it as needed
  40 |   Marionette.extend = Backbone.Model.extend;
  41 |   
  42 |   // Marionette.getOption
  43 |   // --------------------
  44 |   
  45 |   // Retrieve an object, function or other value from a target
  46 |   // object or it's `options`, with `options` taking precedence.
  47 |   Marionette.getOption = function(target, optionName){
  48 |     if (!target || !optionName){ return; }
  49 |     var value;
  50 |   
  51 |     if (target.options && (optionName in target.options) && (target.options[optionName] !== undefined)){
  52 |       value = target.options[optionName];
  53 |     } else {
  54 |       value = target[optionName];
  55 |     }
  56 |   
  57 |     return value;
  58 |   };
  59 |   
  60 |   // Mairionette.createObject
  61 |   // ------------------------
  62 |   
  63 |   // A wrapper / shim for `Object.create`. Uses native `Object.create`
  64 |   // if available, otherwise shims it in place for Marionette to use.
  65 |   Marionette.createObject = (function(){
  66 |     var createObject;
  67 |     
  68 |     // Define this once, and just replace the .prototype on it as needed,
  69 |     // to improve performance in older / less optimized JS engines
  70 |     function F() {}
  71 |   
  72 |   
  73 |     // Check for existing native / shimmed Object.create
  74 |     if (typeof Object.create === "function"){
  75 |   
  76 |       // found native/shim, so use it
  77 |       createObject = Object.create;
  78 |   
  79 |     } else {
  80 |   
  81 |       // An implementation of the Boodman/Crockford delegation 
  82 |       // w/ Cornford optimization, as suggested by @unscriptable
  83 |       // https://gist.github.com/3959151
  84 |   
  85 |       // native/shim not found, so shim it ourself
  86 |       createObject = function (o) {
  87 |   
  88 |         // set the prototype of the function
  89 |         // so we will get `o` as the prototype
  90 |         // of the new object instance
  91 |         F.prototype = o;
  92 |   
  93 |         // create a new object that inherits from
  94 |         // the `o` parameter
  95 |         var child = new F();
  96 |         
  97 |         // clean up just in case o is really large
  98 |         F.prototype = null; 
  99 |   
 100 |         // send it back
 101 |         return child;
 102 |       };
 103 |   
 104 |     }
 105 |   
 106 |     return createObject;
 107 |   })();
 108 |   
 109 |   // Trigger an event and a corresponding method name. Examples:
 110 |   //
 111 |   // `this.triggerMethod("foo")` will trigger the "foo" event and
 112 |   // call the "onFoo" method. 
 113 |   //
 114 |   // `this.triggerMethod("foo:bar") will trigger the "foo:bar" event and
 115 |   // call the "onFooBar" method.
 116 |   Marionette.triggerMethod = function(){
 117 |     var args = Array.prototype.slice.apply(arguments);
 118 |     var eventName = args[0];
 119 |     var segments = eventName.split(":");
 120 |     var segment, capLetter, methodName = "on";
 121 |   
 122 |     for (var i = 0; i < segments.length; i++){
 123 |       segment = segments[i];
 124 |       capLetter = segment.charAt(0).toUpperCase();
 125 |       methodName += capLetter + segment.slice(1);
 126 |     }
 127 |   
 128 |     this.trigger.apply(this, args);
 129 |   
 130 |     if (_.isFunction(this[methodName])){
 131 |       args.shift();
 132 |       return this[methodName].apply(this, args);
 133 |     }
 134 |   };
 135 |   
 136 |   // DOMRefresh
 137 |   // ----------
 138 |   //
 139 |   // Monitor a view's state, and after it has been rendered and shown
 140 |   // in the DOM, trigger a "dom:refresh" event every time it is
 141 |   // re-rendered.
 142 |   
 143 |   Marionette.MonitorDOMRefresh = (function(){
 144 |     // track when the view has been rendered
 145 |     function handleShow(view){
 146 |       view._isShown = true;
 147 |       triggerDOMRefresh(view);
 148 |     }
 149 |   
 150 |     // track when the view has been shown in the DOM,
 151 |     // using a Marionette.Region (or by other means of triggering "show")
 152 |     function handleRender(view){
 153 |       view._isRendered = true;
 154 |       triggerDOMRefresh(view);
 155 |     }
 156 |   
 157 |     // Trigger the "dom:refresh" event and corresponding "onDomRefresh" method
 158 |     function triggerDOMRefresh(view){
 159 |       if (view._isShown && view._isRendered){
 160 |         if (_.isFunction(view.triggerMethod)){
 161 |           view.triggerMethod("dom:refresh");
 162 |         }
 163 |       }
 164 |     }
 165 |   
 166 |     // Export public API
 167 |     return function(view){
 168 |       view.listenTo(view, "show", function(){
 169 |         handleShow(view);
 170 |       });
 171 |   
 172 |       view.listenTo(view, "render", function(){
 173 |         handleRender(view);
 174 |       });
 175 |     };
 176 |   })();
 177 |   
 178 |   
 179 |   // Marionette.bindEntityEvents & unbindEntityEvents
 180 |   // ---------------------------
 181 |   //
 182 |   // These methods are used to bind/unbind a backbone "entity" (collection/model) 
 183 |   // to methods on a target object. 
 184 |   //
 185 |   // The first paremter, `target`, must have a `listenTo` method from the
 186 |   // EventBinder object.
 187 |   //
 188 |   // The second parameter is the entity (Backbone.Model or Backbone.Collection)
 189 |   // to bind the events from.
 190 |   //
 191 |   // The third parameter is a hash of { "event:name": "eventHandler" }
 192 |   // configuration. Multiple handlers can be separated by a space. A
 193 |   // function can be supplied instead of a string handler name. 
 194 |   
 195 |   (function(Marionette){
 196 |     "use strict";
 197 |   
 198 |     // Bind the event to handlers specified as a string of
 199 |     // handler names on the target object
 200 |     function bindFromStrings(target, entity, evt, methods){
 201 |       var methodNames = methods.split(/\s+/);
 202 |   
 203 |       _.each(methodNames,function(methodName) {
 204 |   
 205 |         var method = target[methodName];
 206 |         if(!method) {
 207 |           throw new Error("Method '"+ methodName +"' was configured as an event handler, but does not exist.");
 208 |         }
 209 |   
 210 |         target.listenTo(entity, evt, method, target);
 211 |       });
 212 |     }
 213 |   
 214 |     // Bind the event to a supplied callback function
 215 |     function bindToFunction(target, entity, evt, method){
 216 |         target.listenTo(entity, evt, method, target);
 217 |     }
 218 |   
 219 |     // Bind the event to handlers specified as a string of
 220 |     // handler names on the target object
 221 |     function unbindFromStrings(target, entity, evt, methods){
 222 |       var methodNames = methods.split(/\s+/);
 223 |   
 224 |       _.each(methodNames,function(methodName) {
 225 |         var method = target[method];
 226 |         target.stopListening(entity, evt, method, target);
 227 |       });
 228 |     }
 229 |   
 230 |     // Bind the event to a supplied callback function
 231 |     function unbindToFunction(target, entity, evt, method){
 232 |         target.stopListening(entity, evt, method, target);
 233 |     }
 234 |   
 235 |     
 236 |     // generic looping function
 237 |     function iterateEvents(target, entity, bindings, functionCallback, stringCallback){
 238 |       if (!entity || !bindings) { return; }
 239 |   
 240 |       // allow the bindings to be a function
 241 |       if (_.isFunction(bindings)){
 242 |         bindings = bindings.call(target);
 243 |       }
 244 |   
 245 |       // iterate the bindings and bind them
 246 |       _.each(bindings, function(methods, evt){
 247 |   
 248 |         // allow for a function as the handler, 
 249 |         // or a list of event names as a string
 250 |         if (_.isFunction(methods)){
 251 |           functionCallback(target, entity, evt, methods);
 252 |         } else {
 253 |           stringCallback(target, entity, evt, methods);
 254 |         }
 255 |   
 256 |       });
 257 |     }
 258 |    
 259 |     // Export Public API
 260 |     Marionette.bindEntityEvents = function(target, entity, bindings){
 261 |       iterateEvents(target, entity, bindings, bindToFunction, bindFromStrings);
 262 |     };
 263 |   
 264 |     Marionette.unbindEntityEvents = function(target, entity, bindings){
 265 |       iterateEvents(target, entity, bindings, unbindToFunction, unbindFromStrings);
 266 |     };
 267 |   
 268 |   })(Marionette);
 269 |   
 270 |     
 271 |   // Callbacks
 272 |   // ---------
 273 |   
 274 |   // A simple way of managing a collection of callbacks
 275 |   // and executing them at a later point in time, using jQuery's
 276 |   // `Deferred` object.
 277 |   Marionette.Callbacks = function(){
 278 |     this._deferred = $.Deferred();
 279 |     this._callbacks = [];
 280 |   };
 281 |   
 282 |   _.extend(Marionette.Callbacks.prototype, {
 283 |   
 284 |     // Add a callback to be executed. Callbacks added here are
 285 |     // guaranteed to execute, even if they are added after the 
 286 |     // `run` method is called.
 287 |     add: function(callback, contextOverride){
 288 |       this._callbacks.push({cb: callback, ctx: contextOverride});
 289 |   
 290 |       this._deferred.done(function(context, options){
 291 |         if (contextOverride){ context = contextOverride; }
 292 |         callback.call(context, options);
 293 |       });
 294 |     },
 295 |   
 296 |     // Run all registered callbacks with the context specified. 
 297 |     // Additional callbacks can be added after this has been run 
 298 |     // and they will still be executed.
 299 |     run: function(options, context){
 300 |       this._deferred.resolve(context, options);
 301 |     },
 302 |   
 303 |     // Resets the list of callbacks to be run, allowing the same list
 304 |     // to be run multiple times - whenever the `run` method is called.
 305 |     reset: function(){
 306 |       var that = this;
 307 |       var callbacks = this._callbacks;
 308 |       this._deferred = $.Deferred();
 309 |       this._callbacks = [];
 310 |       _.each(callbacks, function(cb){
 311 |         that.add(cb.cb, cb.ctx);
 312 |       });
 313 |     }
 314 |   });
 315 |   
 316 |   
 317 |   // Marionette Controller
 318 |   // ---------------------
 319 |   //
 320 |   // A multi-purpose object to use as a controller for
 321 |   // modules and routers, and as a mediator for workflow
 322 |   // and coordination of other objects, views, and more.
 323 |   Marionette.Controller = function(options){
 324 |     this.triggerMethod = Marionette.triggerMethod;
 325 |     this.options = options || {};
 326 |   
 327 |     if (_.isFunction(this.initialize)){
 328 |       this.initialize(this.options);
 329 |     }
 330 |   };
 331 |   
 332 |   Marionette.Controller.extend = Marionette.extend;
 333 |   
 334 |   // Controller Methods
 335 |   // --------------
 336 |   
 337 |   // Ensure it can trigger events with Backbone.Events
 338 |   _.extend(Marionette.Controller.prototype, Backbone.Events, {
 339 |     close: function(){
 340 |       this.stopListening();
 341 |       this.triggerMethod("close");
 342 |       this.unbind();
 343 |     }
 344 |   });
 345 |   
 346 |   // Region 
 347 |   // ------
 348 |   //
 349 |   // Manage the visual regions of your composite application. See
 350 |   // http://lostechies.com/derickbailey/2011/12/12/composite-js-apps-regions-and-region-managers/
 351 |   
 352 |   Marionette.Region = function(options){
 353 |     this.options = options || {};
 354 |   
 355 |     this.el = Marionette.getOption(this, "el");
 356 |   
 357 |     if (!this.el){
 358 |       var err = new Error("An 'el' must be specified for a region.");
 359 |       err.name = "NoElError";
 360 |       throw err;
 361 |     }
 362 |   
 363 |     if (this.initialize){
 364 |       var args = Array.prototype.slice.apply(arguments);
 365 |       this.initialize.apply(this, args);
 366 |     }
 367 |   };
 368 |   
 369 |   
 370 |   // Region Type methods
 371 |   // -------------------
 372 |   
 373 |   _.extend(Marionette.Region, {
 374 |   
 375 |     // Build an instance of a region by passing in a configuration object
 376 |     // and a default region type to use if none is specified in the config.
 377 |     //
 378 |     // The config object should either be a string as a jQuery DOM selector,
 379 |     // a Region type directly, or an object literal that specifies both
 380 |     // a selector and regionType:
 381 |     //
 382 |     // ```js
 383 |     // {
 384 |     //   selector: "#foo",
 385 |     //   regionType: MyCustomRegion
 386 |     // }
 387 |     // ```
 388 |     //
 389 |     buildRegion: function(regionConfig, defaultRegionType){
 390 |       var regionIsString = (typeof regionConfig === "string");
 391 |       var regionSelectorIsString = (typeof regionConfig.selector === "string");
 392 |       var regionTypeIsUndefined = (typeof regionConfig.regionType === "undefined");
 393 |       var regionIsType = (typeof regionConfig === "function");
 394 |   
 395 |       if (!regionIsType && !regionIsString && !regionSelectorIsString) {
 396 |         throw new Error("Region must be specified as a Region type, a selector string or an object with selector property");
 397 |       }
 398 |   
 399 |       var selector, RegionType;
 400 |      
 401 |       // get the selector for the region
 402 |       
 403 |       if (regionIsString) {
 404 |         selector = regionConfig;
 405 |       } 
 406 |   
 407 |       if (regionConfig.selector) {
 408 |         selector = regionConfig.selector;
 409 |       }
 410 |   
 411 |       // get the type for the region
 412 |       
 413 |       if (regionIsType){
 414 |         RegionType = regionConfig;
 415 |       }
 416 |   
 417 |       if (!regionIsType && regionTypeIsUndefined) {
 418 |         RegionType = defaultRegionType;
 419 |       }
 420 |   
 421 |       if (regionConfig.regionType) {
 422 |         RegionType = regionConfig.regionType;
 423 |       }
 424 |       
 425 |       // build the region instance
 426 |   
 427 |       var regionManager = new RegionType({
 428 |         el: selector
 429 |       });
 430 |   
 431 |       return regionManager;
 432 |     }
 433 |   
 434 |   });
 435 |   
 436 |   // Region Instance Methods
 437 |   // -----------------------
 438 |   
 439 |   _.extend(Marionette.Region.prototype, Backbone.Events, {
 440 |   
 441 |     // Displays a backbone view instance inside of the region.
 442 |     // Handles calling the `render` method for you. Reads content
 443 |     // directly from the `el` attribute. Also calls an optional
 444 |     // `onShow` and `close` method on your view, just after showing
 445 |     // or just before closing the view, respectively.
 446 |     show: function(view){
 447 |   
 448 |       this.ensureEl();
 449 |       this.close();
 450 |   
 451 |       view.render();
 452 |       this.open(view);
 453 |   
 454 |       Marionette.triggerMethod.call(view, "show");
 455 |       Marionette.triggerMethod.call(this, "show", view);
 456 |   
 457 |       this.currentView = view;
 458 |     },
 459 |   
 460 |     ensureEl: function(){
 461 |       if (!this.$el || this.$el.length === 0){
 462 |         this.$el = this.getEl(this.el);
 463 |       }
 464 |     },
 465 |   
 466 |     // Override this method to change how the region finds the
 467 |     // DOM element that it manages. Return a jQuery selector object.
 468 |     getEl: function(selector){
 469 |       return $(selector);
 470 |     },
 471 |   
 472 |     // Override this method to change how the new view is
 473 |     // appended to the `$el` that the region is managing
 474 |     open: function(view){
 475 |       this.$el.empty().append(view.el);
 476 |     },
 477 |   
 478 |     // Close the current view, if there is one. If there is no
 479 |     // current view, it does nothing and returns immediately.
 480 |     close: function(){
 481 |       var view = this.currentView;
 482 |       if (!view || view.isClosed){ return; }
 483 |   
 484 |       if (view.close) { view.close(); }
 485 |       Marionette.triggerMethod.call(this, "close");
 486 |   
 487 |       delete this.currentView;
 488 |     },
 489 |   
 490 |     // Attach an existing view to the region. This 
 491 |     // will not call `render` or `onShow` for the new view, 
 492 |     // and will not replace the current HTML for the `el`
 493 |     // of the region.
 494 |     attachView: function(view){
 495 |       this.currentView = view;
 496 |     },
 497 |   
 498 |     // Reset the region by closing any existing view and
 499 |     // clearing out the cached `$el`. The next time a view
 500 |     // is shown via this region, the region will re-query the
 501 |     // DOM for the region's `el`.
 502 |     reset: function(){
 503 |       this.close();
 504 |       delete this.$el;
 505 |     }
 506 |   });
 507 |   
 508 |   // Copy the `extend` function used by Backbone's classes
 509 |   Marionette.Region.extend = Marionette.extend;
 510 |   
 511 |   
 512 |   // Template Cache
 513 |   // --------------
 514 |   
 515 |   // Manage templates stored in `<script>` blocks,
 516 |   // caching them for faster access.
 517 |   Marionette.TemplateCache = function(templateId){
 518 |     this.templateId = templateId;
 519 |   };
 520 |   
 521 |   // TemplateCache object-level methods. Manage the template
 522 |   // caches from these method calls instead of creating 
 523 |   // your own TemplateCache instances
 524 |   _.extend(Marionette.TemplateCache, {
 525 |     templateCaches: {},
 526 |   
 527 |     // Get the specified template by id. Either
 528 |     // retrieves the cached version, or loads it
 529 |     // from the DOM.
 530 |     get: function(templateId){
 531 |       var that = this;
 532 |       var cachedTemplate = this.templateCaches[templateId];
 533 |   
 534 |       if (!cachedTemplate){
 535 |         cachedTemplate = new Marionette.TemplateCache(templateId);
 536 |         this.templateCaches[templateId] = cachedTemplate;
 537 |       }
 538 |   
 539 |       return cachedTemplate.load();
 540 |     },
 541 |   
 542 |     // Clear templates from the cache. If no arguments
 543 |     // are specified, clears all templates:
 544 |     // `clear()`
 545 |     //
 546 |     // If arguments are specified, clears each of the 
 547 |     // specified templates from the cache:
 548 |     // `clear("#t1", "#t2", "...")`
 549 |     clear: function(){
 550 |       var i;
 551 |       var args = Array.prototype.slice.apply(arguments);
 552 |       var length = args.length;
 553 |   
 554 |       if (length > 0){
 555 |         for(i=0; i<length; i++){
 556 |           delete this.templateCaches[args[i]];
 557 |         }
 558 |       } else {
 559 |         this.templateCaches = {};
 560 |       }
 561 |     }
 562 |   });
 563 |   
 564 |   // TemplateCache instance methods, allowing each
 565 |   // template cache object to manage it's own state
 566 |   // and know whether or not it has been loaded
 567 |   _.extend(Marionette.TemplateCache.prototype, {
 568 |   
 569 |     // Internal method to load the template
 570 |     load: function(){
 571 |       var that = this;
 572 |   
 573 |       // Guard clause to prevent loading this template more than once
 574 |       if (this.compiledTemplate){
 575 |         return this.compiledTemplate;
 576 |       }
 577 |   
 578 |       // Load the template and compile it
 579 |       var template = this.loadTemplate(this.templateId);
 580 |       this.compiledTemplate = this.compileTemplate(template);
 581 |   
 582 |       return this.compiledTemplate;
 583 |     },
 584 |   
 585 |     // Load a template from the DOM, by default. Override
 586 |     // this method to provide your own template retrieval
 587 |     // For asynchronous loading with AMD/RequireJS, consider
 588 |     // using a template-loader plugin as described here: 
 589 |     // https://github.com/marionettejs/backbone.marionette/wiki/Using-marionette-with-requirejs
 590 |     loadTemplate: function(templateId){
 591 |       var template = $(templateId).html();
 592 |   
 593 |       if (!template || template.length === 0){
 594 |         var msg = "Could not find template: '" + templateId + "'";
 595 |         var err = new Error(msg);
 596 |         err.name = "NoTemplateError";
 597 |         throw err;
 598 |       }
 599 |   
 600 |       return template;
 601 |     },
 602 |   
 603 |     // Pre-compile the template before caching it. Override
 604 |     // this method if you do not need to pre-compile a template
 605 |     // (JST / RequireJS for example) or if you want to change
 606 |     // the template engine used (Handebars, etc).
 607 |     compileTemplate: function(rawTemplate){
 608 |       return _.template(rawTemplate);
 609 |     }
 610 |   });
 611 |   
 612 |   
 613 |   // Renderer
 614 |   // --------
 615 |   
 616 |   // Render a template with data by passing in the template
 617 |   // selector and the data to render.
 618 |   Marionette.Renderer = {
 619 |   
 620 |     // Render a template with data. The `template` parameter is
 621 |     // passed to the `TemplateCache` object to retrieve the
 622 |     // template function. Override this method to provide your own
 623 |     // custom rendering and template handling for all of Marionette.
 624 |     render: function(template, data){
 625 |       var templateFunc = typeof template === 'function' ? template : Marionette.TemplateCache.get(template);
 626 |       var html = templateFunc(data);
 627 |       return html;
 628 |     }
 629 |   };
 630 |   
 631 |   
 632 |   
 633 |   // Marionette.View
 634 |   // ---------------
 635 |   
 636 |   // The core view type that other Marionette views extend from.
 637 |   Marionette.View = Backbone.View.extend({
 638 |   
 639 |     constructor: function(){
 640 |       _.bindAll(this, "render");
 641 |   
 642 |       var args = Array.prototype.slice.apply(arguments);
 643 |       Backbone.View.prototype.constructor.apply(this, args);
 644 |   
 645 |       Marionette.MonitorDOMRefresh(this);
 646 |       this.listenTo(this, "show", this.onShowCalled, this);
 647 |     },
 648 |   
 649 |     // import the "triggerMethod" to trigger events with corresponding
 650 |     // methods if the method exists 
 651 |     triggerMethod: Marionette.triggerMethod,
 652 |   
 653 |     // Get the template for this view
 654 |     // instance. You can set a `template` attribute in the view
 655 |     // definition or pass a `template: "whatever"` parameter in
 656 |     // to the constructor options.
 657 |     getTemplate: function(){
 658 |       return Marionette.getOption(this, "template");
 659 |     },
 660 |   
 661 |     // Mix in template helper methods. Looks for a
 662 |     // `templateHelpers` attribute, which can either be an
 663 |     // object literal, or a function that returns an object
 664 |     // literal. All methods and attributes from this object
 665 |     // are copies to the object passed in.
 666 |     mixinTemplateHelpers: function(target){
 667 |       target = target || {};
 668 |       var templateHelpers = this.templateHelpers;
 669 |       if (_.isFunction(templateHelpers)){
 670 |         templateHelpers = templateHelpers.call(this);
 671 |       }
 672 |       return _.extend(target, templateHelpers);
 673 |     },
 674 |   
 675 |     // Configure `triggers` to forward DOM events to view
 676 |     // events. `triggers: {"click .foo": "do:foo"}`
 677 |     configureTriggers: function(){
 678 |       if (!this.triggers) { return; }
 679 |   
 680 |       var that = this;
 681 |       var triggerEvents = {};
 682 |   
 683 |       // Allow `triggers` to be configured as a function
 684 |       var triggers = _.result(this, "triggers");
 685 |   
 686 |       // Configure the triggers, prevent default
 687 |       // action and stop propagation of DOM events
 688 |       _.each(triggers, function(value, key){
 689 |   
 690 |         // build the event handler function for the DOM event
 691 |         triggerEvents[key] = function(e){
 692 |   
 693 |           // stop the event in it's tracks
 694 |           if (e && e.preventDefault){ e.preventDefault(); }
 695 |           if (e && e.stopPropagation){ e.stopPropagation(); }
 696 |   
 697 |           // buil the args for the event
 698 |           var args = {
 699 |             view: this,
 700 |             model: this.model,
 701 |             collection: this.collection
 702 |           };
 703 |   
 704 |           // trigger the event
 705 |           that.triggerMethod(value, args);
 706 |         };
 707 |   
 708 |       });
 709 |   
 710 |       return triggerEvents;
 711 |     },
 712 |   
 713 |     // Overriding Backbone.View's delegateEvents to handle 
 714 |     // the `triggers`, `modelEvents`, and `collectionEvents` configuration
 715 |     delegateEvents: function(events){
 716 |       this._delegateDOMEvents(events);
 717 |       Marionette.bindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
 718 |       Marionette.bindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
 719 |     },
 720 |   
 721 |     // internal method to delegate DOM events and triggers
 722 |     _delegateDOMEvents: function(events){
 723 |       events = events || this.events;
 724 |       if (_.isFunction(events)){ events = events.call(this); }
 725 |   
 726 |       var combinedEvents = {};
 727 |       var triggers = this.configureTriggers();
 728 |       _.extend(combinedEvents, events, triggers);
 729 |   
 730 |       Backbone.View.prototype.delegateEvents.call(this, combinedEvents);
 731 |     },
 732 |   
 733 |     // Overriding Backbone.View's undelegateEvents to handle unbinding
 734 |     // the `triggers`, `modelEvents`, and `collectionEvents` config
 735 |     undelegateEvents: function(){
 736 |       var args = Array.prototype.slice.call(arguments);
 737 |       Backbone.View.prototype.undelegateEvents.apply(this, args);
 738 |   
 739 |       Marionette.unbindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
 740 |       Marionette.unbindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
 741 |     },
 742 |   
 743 |     // Internal method, handles the `show` event.
 744 |     onShowCalled: function(){},
 745 |   
 746 |     // Default `close` implementation, for removing a view from the
 747 |     // DOM and unbinding it. Regions will call this method
 748 |     // for you. You can specify an `onClose` method in your view to
 749 |     // add custom code that is called after the view is closed.
 750 |     close: function(){
 751 |       if (this.isClosed) { return; }
 752 |   
 753 |       // allow the close to be stopped by returning `false`
 754 |       // from the `onBeforeClose` method
 755 |       var shouldClose = this.triggerMethod("before:close");
 756 |       if (shouldClose === false){
 757 |         return;
 758 |       }
 759 |   
 760 |       // mark as closed before doing the actual close, to
 761 |       // prevent infinite loops within "close" event handlers
 762 |       // that are trying to close other views
 763 |       this.isClosed = true;
 764 |       this.triggerMethod("close");
 765 |   
 766 |       this.remove();
 767 |     },
 768 |   
 769 |     // This method binds the elements specified in the "ui" hash inside the view's code with
 770 |     // the associated jQuery selectors.
 771 |     bindUIElements: function(){
 772 |       if (!this.ui) { return; }
 773 |   
 774 |       var that = this;
 775 |   
 776 |       if (!this.uiBindings) {
 777 |         // We want to store the ui hash in uiBindings, since afterwards the values in the ui hash
 778 |         // will be overridden with jQuery selectors.
 779 |         this.uiBindings = _.result(this, "ui");
 780 |       }
 781 |   
 782 |       // refreshing the associated selectors since they should point to the newly rendered elements.
 783 |       this.ui = {};
 784 |       _.each(_.keys(this.uiBindings), function(key) {
 785 |         var selector = that.uiBindings[key];
 786 |         that.ui[key] = that.$(selector);
 787 |       });
 788 |     }
 789 |   });
 790 |   
 791 |   // Item View
 792 |   // ---------
 793 |   
 794 |   // A single item view implementation that contains code for rendering
 795 |   // with underscore.js templates, serializing the view's model or collection,
 796 |   // and calling several methods on extended views, such as `onRender`.
 797 |   Marionette.ItemView =  Marionette.View.extend({
 798 |     constructor: function(){
 799 |       var args = Array.prototype.slice.apply(arguments);
 800 |       Marionette.View.prototype.constructor.apply(this, args);
 801 |     },
 802 |   
 803 |     // Serialize the model or collection for the view. If a model is
 804 |     // found, `.toJSON()` is called. If a collection is found, `.toJSON()`
 805 |     // is also called, but is used to populate an `items` array in the
 806 |     // resulting data. If both are found, defaults to the model.
 807 |     // You can override the `serializeData` method in your own view
 808 |     // definition, to provide custom serialization for your view's data.
 809 |     serializeData: function(){
 810 |       var data = {};
 811 |   
 812 |       if (this.model) {
 813 |         data = this.model.toJSON();
 814 |       }
 815 |       else if (this.collection) {
 816 |         data = { items: this.collection.toJSON() };
 817 |       }
 818 |   
 819 |       return data;
 820 |     },
 821 |   
 822 |     // Render the view, defaulting to underscore.js templates.
 823 |     // You can override this in your view definition to provide
 824 |     // a very specific rendering for your view. In general, though,
 825 |     // you should override the `Marionette.Renderer` object to
 826 |     // change how Marionette renders views.
 827 |     render: function(){
 828 |       this.isClosed = false;
 829 |   
 830 |       this.triggerMethod("before:render", this);
 831 |       this.triggerMethod("item:before:render", this);
 832 |   
 833 |       var data = this.serializeData();
 834 |       data = this.mixinTemplateHelpers(data);
 835 |   
 836 |       var template = this.getTemplate();
 837 |       var html = Marionette.Renderer.render(template, data);
 838 |       this.$el.html(html);
 839 |       this.bindUIElements();
 840 |   
 841 |       this.triggerMethod("render", this);
 842 |       this.triggerMethod("item:rendered", this);
 843 |   
 844 |       return this;
 845 |     },
 846 |   
 847 |     // Override the default close event to add a few
 848 |     // more events that are triggered.
 849 |     close: function(){
 850 |       if (this.isClosed){ return; }
 851 |   
 852 |       this.triggerMethod('item:before:close');
 853 |   
 854 |       var args = Array.prototype.slice.apply(arguments);
 855 |       Marionette.View.prototype.close.apply(this, args);
 856 |   
 857 |       this.triggerMethod('item:closed');
 858 |     }
 859 |   });
 860 |   
 861 |   // Collection View
 862 |   // ---------------
 863 |   
 864 |   // A view that iterates over a Backbone.Collection
 865 |   // and renders an individual ItemView for each model.
 866 |   Marionette.CollectionView = Marionette.View.extend({
 867 |     // used as the prefix for item view events
 868 |     // that are forwarded through the collectionview
 869 |     itemViewEventPrefix: "itemview",
 870 |   
 871 |     // constructor
 872 |     constructor: function(options){
 873 |       this._initChildViewStorage();
 874 |   
 875 |       var args = Array.prototype.slice.apply(arguments);
 876 |       Marionette.View.prototype.constructor.apply(this, args);
 877 |   
 878 |       this._initialEvents();
 879 |     },
 880 |   
 881 |     // Configured the initial events that the collection view
 882 |     // binds to. Override this method to prevent the initial
 883 |     // events, or to add your own initial events.
 884 |     _initialEvents: function(){
 885 |       if (this.collection){
 886 |         this.listenTo(this.collection, "add", this.addChildView, this);
 887 |         this.listenTo(this.collection, "remove", this.removeItemView, this);
 888 |         this.listenTo(this.collection, "reset", this.render, this);
 889 |       }
 890 |     },
 891 |   
 892 |     // Handle a child item added to the collection
 893 |     addChildView: function(item, collection, options){
 894 |       this.closeEmptyView();
 895 |       var ItemView = this.getItemView(item);
 896 |       var index = this.collection.indexOf(item);
 897 |       this.addItemView(item, ItemView, index);
 898 |     },
 899 |   
 900 |     // Override from `Marionette.View` to guarantee the `onShow` method
 901 |     // of child views is called.
 902 |     onShowCalled: function(){
 903 |       this.children.each(function(child){
 904 |         Marionette.triggerMethod.call(child, "show");
 905 |       });
 906 |     },
 907 |   
 908 |     // Internal method to trigger the before render callbacks
 909 |     // and events
 910 |     triggerBeforeRender: function(){
 911 |       this.triggerMethod("before:render", this);
 912 |       this.triggerMethod("collection:before:render", this);
 913 |     },
 914 |   
 915 |     // Internal method to trigger the rendered callbacks and
 916 |     // events
 917 |     triggerRendered: function(){
 918 |       this.triggerMethod("render", this);
 919 |       this.triggerMethod("collection:rendered", this);
 920 |     },
 921 |   
 922 |     // Render the collection of items. Override this method to
 923 |     // provide your own implementation of a render function for
 924 |     // the collection view.
 925 |     render: function(){
 926 |       this.isClosed = false;
 927 |   
 928 |       this.triggerBeforeRender();
 929 |       this.closeEmptyView();
 930 |       this.closeChildren();
 931 |   
 932 |       if (this.collection && this.collection.length > 0) {
 933 |         this.showCollection();
 934 |       } else {
 935 |         this.showEmptyView();
 936 |       }
 937 |   
 938 |       this.triggerRendered();
 939 |       return this;
 940 |     },
 941 |   
 942 |     // Internal method to loop through each item in the
 943 |     // collection view and show it
 944 |     showCollection: function(){
 945 |       var that = this;
 946 |       var ItemView;
 947 |       this.collection.each(function(item, index){
 948 |         ItemView = that.getItemView(item);
 949 |         that.addItemView(item, ItemView, index);
 950 |       });
 951 |     },
 952 |   
 953 |     // Internal method to show an empty view in place of
 954 |     // a collection of item views, when the collection is
 955 |     // empty
 956 |     showEmptyView: function(){
 957 |       var EmptyView = Marionette.getOption(this, "emptyView");
 958 |   
 959 |       if (EmptyView && !this._showingEmptyView){
 960 |         this._showingEmptyView = true;
 961 |         var model = new Backbone.Model();
 962 |         this.addItemView(model, EmptyView, 0);
 963 |       }
 964 |     },
 965 |   
 966 |     // Internal method to close an existing emptyView instance
 967 |     // if one exists. Called when a collection view has been
 968 |     // rendered empty, and then an item is added to the collection.
 969 |     closeEmptyView: function(){
 970 |       if (this._showingEmptyView){
 971 |         this.closeChildren();
 972 |         delete this._showingEmptyView;
 973 |       }
 974 |     },
 975 |   
 976 |     // Retrieve the itemView type, either from `this.options.itemView`
 977 |     // or from the `itemView` in the object definition. The "options"
 978 |     // takes precedence.
 979 |     getItemView: function(item){
 980 |       var itemView = Marionette.getOption(this, "itemView");
 981 |   
 982 |       if (!itemView){
 983 |         var err = new Error("An `itemView` must be specified");
 984 |         err.name = "NoItemViewError";
 985 |         throw err;
 986 |       }
 987 |   
 988 |       return itemView;
 989 |     },
 990 |   
 991 |     // Render the child item's view and add it to the
 992 |     // HTML for the collection view.
 993 |     addItemView: function(item, ItemView, index){
 994 |       var that = this;
 995 |   
 996 |       // get the itemViewOptions if any were specified
 997 |       var itemViewOptions = Marionette.getOption(this, "itemViewOptions");
 998 |       if (_.isFunction(itemViewOptions)){
 999 |         itemViewOptions = itemViewOptions.call(this, item);
1000 |       }
1001 |   
1002 |       // build the view 
1003 |       var view = this.buildItemView(item, ItemView, itemViewOptions);
1004 |       
1005 |       // set up the child view event forwarding
1006 |       this.addChildViewEventForwarding(view);
1007 |   
1008 |       // this view is about to be added
1009 |       this.triggerMethod("before:item:added", view);
1010 |   
1011 |       // Store the child view itself so we can properly
1012 |       // remove and/or close it later
1013 |       this.children.add(view);
1014 |   
1015 |       // Render it and show it
1016 |       this.renderItemView(view, index);
1017 |   
1018 |       // call the "show" method if the collection view
1019 |       // has already been shown
1020 |       if (this._isShown){
1021 |         Marionette.triggerMethod.call(view, "show");
1022 |       }
1023 |   
1024 |       // this view was added
1025 |       this.triggerMethod("after:item:added", view);
1026 |     },
1027 |   
1028 |     // Set up the child view event forwarding. Uses an "itemview:"
1029 |     // prefix in front of all forwarded events.
1030 |     addChildViewEventForwarding: function(view){
1031 |       var prefix = Marionette.getOption(this, "itemViewEventPrefix");
1032 |   
1033 |       // Forward all child item view events through the parent,
1034 |       // prepending "itemview:" to the event name
1035 |       this.listenTo(view, "all", function(){
1036 |         var args = slice.call(arguments);
1037 |         args[0] = prefix + ":" + args[0];
1038 |         args.splice(1, 0, view);
1039 |   
1040 |         Marionette.triggerMethod.apply(this, args);
1041 |       }, this);
1042 |     },
1043 |   
1044 |     // render the item view
1045 |     renderItemView: function(view, index) {
1046 |       view.render();
1047 |       this.appendHtml(this, view, index);
1048 |     },
1049 |   
1050 |     // Build an `itemView` for every model in the collection.
1051 |     buildItemView: function(item, ItemViewType, itemViewOptions){
1052 |       var options = _.extend({model: item}, itemViewOptions);
1053 |       var view = new ItemViewType(options);
1054 |       return view;
1055 |     },
1056 |   
1057 |     // get the child view by item it holds, and remove it
1058 |     removeItemView: function(item){
1059 |       var view = this.children.findByModel(item);
1060 |       this.removeChildView(view);
1061 |       this.checkEmpty();
1062 |     },
1063 |   
1064 |     // Remove the child view and close it
1065 |     removeChildView: function(view){
1066 |   
1067 |       // shut down the child view properly,
1068 |       // including events that the collection has from it
1069 |       if (view){
1070 |         this.stopListening(view);
1071 |   
1072 |         if (view.close){
1073 |           view.close();
1074 |         }
1075 |   
1076 |         this.children.remove(view);
1077 |       }
1078 |   
1079 |       this.triggerMethod("item:removed", view);
1080 |     },
1081 |   
1082 |     // helper to show the empty view if the collection is empty
1083 |     checkEmpty: function() {
1084 |       // check if we're empty now, and if we are, show the
1085 |       // empty view
1086 |       if (!this.collection || this.collection.length === 0){
1087 |         this.showEmptyView();
1088 |       }
1089 |     },
1090 |   
1091 |     // Append the HTML to the collection's `el`.
1092 |     // Override this method to do something other
1093 |     // then `.append`.
1094 |     appendHtml: function(collectionView, itemView, index){
1095 |       collectionView.$el.append(itemView.el);
1096 |     },
1097 |   
1098 |     // Internal method to set up the `children` object for
1099 |     // storing all of the child views
1100 |     _initChildViewStorage: function(){
1101 |       this.children = new Backbone.ChildViewContainer();
1102 |     },
1103 |   
1104 |     // Handle cleanup and other closing needs for
1105 |     // the collection of views.
1106 |     close: function(){
1107 |       if (this.isClosed){ return; }
1108 |   
1109 |       this.triggerMethod("collection:before:close");
1110 |       this.closeChildren();
1111 |       this.triggerMethod("collection:closed");
1112 |   
1113 |       var args = Array.prototype.slice.apply(arguments);
1114 |       Marionette.View.prototype.close.apply(this, args);
1115 |     },
1116 |   
1117 |     // Close the child views that this collection view
1118 |     // is holding on to, if any
1119 |     closeChildren: function(){
1120 |       this.children.each(function(child){
1121 |         this.removeChildView(child);
1122 |       }, this);
1123 |       this.checkEmpty();
1124 |     }
1125 |   });
1126 |   
1127 |   
1128 |   // Composite View
1129 |   // --------------
1130 |   
1131 |   // Used for rendering a branch-leaf, hierarchical structure.
1132 |   // Extends directly from CollectionView and also renders an
1133 |   // an item view as `modelView`, for the top leaf
1134 |   Marionette.CompositeView = Marionette.CollectionView.extend({
1135 |     constructor: function(options){
1136 |       var args = Array.prototype.slice.apply(arguments);
1137 |       Marionette.CollectionView.apply(this, args);
1138 |   
1139 |       this.itemView = this.getItemView();
1140 |     },
1141 |   
1142 |     // Configured the initial events that the composite view
1143 |     // binds to. Override this method to prevent the initial
1144 |     // events, or to add your own initial events.
1145 |     _initialEvents: function(){
1146 |       if (this.collection){
1147 |         this.listenTo(this.collection, "add", this.addChildView, this);
1148 |         this.listenTo(this.collection, "remove", this.removeItemView, this);
1149 |         this.listenTo(this.collection, "reset", this.renderCollection, this);
1150 |       }
1151 |     },
1152 |   
1153 |     // Retrieve the `itemView` to be used when rendering each of
1154 |     // the items in the collection. The default is to return
1155 |     // `this.itemView` or Marionette.CompositeView if no `itemView`
1156 |     // has been defined
1157 |     getItemView: function(item){
1158 |       var itemView = Marionette.getOption(this, "itemView") || this.constructor;
1159 |   
1160 |       if (!itemView){
1161 |         var err = new Error("An `itemView` must be specified");
1162 |         err.name = "NoItemViewError";
1163 |         throw err;
1164 |       }
1165 |   
1166 |       return itemView;
1167 |     },
1168 |   
1169 |     // Serialize the collection for the view. 
1170 |     // You can override the `serializeData` method in your own view
1171 |     // definition, to provide custom serialization for your view's data.
1172 |     serializeData: function(){
1173 |       var data = {};
1174 |   
1175 |       if (this.model){
1176 |         data = this.model.toJSON();
1177 |       }
1178 |   
1179 |       return data;
1180 |     },
1181 |   
1182 |     // Renders the model once, and the collection once. Calling
1183 |     // this again will tell the model's view to re-render itself
1184 |     // but the collection will not re-render.
1185 |     render: function(){
1186 |       this.isClosed = false;
1187 |   
1188 |       this.resetItemViewContainer();
1189 |   
1190 |       var html = this.renderModel();
1191 |       this.$el.html(html);
1192 |   
1193 |       // the ui bindings is done here and not at the end of render since they 
1194 |       // will not be available until after the model is rendered, but should be
1195 |       // available before the collection is rendered.
1196 |       this.bindUIElements();
1197 |   
1198 |       this.triggerMethod("composite:model:rendered");
1199 |   
1200 |       this.renderCollection();
1201 |       this.triggerMethod("composite:rendered");
1202 |       return this;
1203 |     },
1204 |   
1205 |     // Render the collection for the composite view
1206 |     renderCollection: function(){
1207 |       var args = Array.prototype.slice.apply(arguments);
1208 |       Marionette.CollectionView.prototype.render.apply(this, args);
1209 |   
1210 |       this.triggerMethod("composite:collection:rendered");
1211 |     },
1212 |   
1213 |     // Render an individual model, if we have one, as
1214 |     // part of a composite view (branch / leaf). For example:
1215 |     // a treeview.
1216 |     renderModel: function(){
1217 |       var data = {};
1218 |       data = this.serializeData();
1219 |       data = this.mixinTemplateHelpers(data);
1220 |   
1221 |       var template = this.getTemplate();
1222 |       return Marionette.Renderer.render(template, data);
1223 |     },
1224 |   
1225 |     // Appends the `el` of itemView instances to the specified
1226 |     // `itemViewContainer` (a jQuery selector). Override this method to
1227 |     // provide custom logic of how the child item view instances have their
1228 |     // HTML appended to the composite view instance.
1229 |     appendHtml: function(cv, iv){
1230 |       var $container = this.getItemViewContainer(cv);
1231 |       $container.append(iv.el);
1232 |     },
1233 |   
1234 |     // Internal method to ensure an `$itemViewContainer` exists, for the
1235 |     // `appendHtml` method to use.
1236 |     getItemViewContainer: function(containerView){
1237 |       if ("$itemViewContainer" in containerView){
1238 |         return containerView.$itemViewContainer;
1239 |       }
1240 |   
1241 |       var container;
1242 |       if (containerView.itemViewContainer){
1243 |   
1244 |         var selector = _.result(containerView, "itemViewContainer");
1245 |         container = containerView.$(selector);
1246 |         if (container.length <= 0) {
1247 |           var err = new Error("The specified `itemViewContainer` was not found: " + containerView.itemViewContainer);
1248 |           err.name = "ItemViewContainerMissingError";
1249 |           throw err;
1250 |         }
1251 |   
1252 |       } else {
1253 |         container = containerView.$el;
1254 |       }
1255 |   
1256 |       containerView.$itemViewContainer = container;
1257 |       return container;
1258 |     },
1259 |   
1260 |     // Internal method to reset the `$itemViewContainer` on render
1261 |     resetItemViewContainer: function(){
1262 |       if (this.$itemViewContainer){
1263 |         delete this.$itemViewContainer;
1264 |       }
1265 |     }
1266 |   });
1267 |   
1268 |   
1269 |   // Layout
1270 |   // ------
1271 |   
1272 |   // Used for managing application layouts, nested layouts and
1273 |   // multiple regions within an application or sub-application.
1274 |   //
1275 |   // A specialized view type that renders an area of HTML and then
1276 |   // attaches `Region` instances to the specified `regions`.
1277 |   // Used for composite view management and sub-application areas.
1278 |   Marionette.Layout = Marionette.ItemView.extend({
1279 |     regionType: Marionette.Region,
1280 |     
1281 |     // Ensure the regions are avialable when the `initialize` method
1282 |     // is called.
1283 |     constructor: function () {
1284 |       this._firstRender = true;
1285 |       this.initializeRegions();
1286 |   
1287 |       var args = Array.prototype.slice.apply(arguments);
1288 |       Marionette.ItemView.apply(this, args);
1289 |     },
1290 |   
1291 |     // Layout's render will use the existing region objects the
1292 |     // first time it is called. Subsequent calls will close the
1293 |     // views that the regions are showing and then reset the `el`
1294 |     // for the regions to the newly rendered DOM elements.
1295 |     render: function(){
1296 |   
1297 |       if (this._firstRender){
1298 |         // if this is the first render, don't do anything to
1299 |         // reset the regions
1300 |         this._firstRender = false;
1301 |       } else {
1302 |         // If this is not the first render call, then we need to 
1303 |         // re-initializing the `el` for each region
1304 |         this.closeRegions();
1305 |         this.reInitializeRegions();
1306 |       }
1307 |   
1308 |       var args = Array.prototype.slice.apply(arguments);
1309 |       var result = Marionette.ItemView.prototype.render.apply(this, args);
1310 |   
1311 |       return result;
1312 |     },
1313 |   
1314 |     // Handle closing regions, and then close the view itself.
1315 |     close: function () {
1316 |       if (this.isClosed){ return; }
1317 |   
1318 |       this.closeRegions();
1319 |       this.destroyRegions();
1320 |   
1321 |       var args = Array.prototype.slice.apply(arguments);
1322 |       Marionette.ItemView.prototype.close.apply(this, args);
1323 |     },
1324 |   
1325 |     // Initialize the regions that have been defined in a
1326 |     // `regions` attribute on this layout. The key of the
1327 |     // hash becomes an attribute on the layout object directly.
1328 |     // For example: `regions: { menu: ".menu-container" }`
1329 |     // will product a `layout.menu` object which is a region
1330 |     // that controls the `.menu-container` DOM element.
1331 |     initializeRegions: function () {
1332 |       if (!this.regionManagers){
1333 |         this.regionManagers = {};
1334 |       }
1335 |   
1336 |       var that = this;
1337 |       var regions = this.regions || {};
1338 |       _.each(regions, function (region, name) {
1339 |   
1340 |         var regionManager = Marionette.Region.buildRegion(region, that.regionType);
1341 |         regionManager.getEl = function(selector){
1342 |           return that.$(selector);
1343 |         };
1344 |   
1345 |         that.regionManagers[name] = regionManager;
1346 |         that[name] = regionManager;
1347 |       });
1348 |   
1349 |     },
1350 |   
1351 |     // Re-initialize all of the regions by updating the `el` that
1352 |     // they point to
1353 |     reInitializeRegions: function(){
1354 |       if (this.regionManagers && _.size(this.regionManagers)===0){
1355 |         this.initializeRegions();
1356 |       } else {
1357 |         _.each(this.regionManagers, function(region){
1358 |           region.reset();
1359 |         });
1360 |       }
1361 |     },
1362 |   
1363 |     // Close all of the regions that have been opened by
1364 |     // this layout. This method is called when the layout
1365 |     // itself is closed.
1366 |     closeRegions: function () {
1367 |       var that = this;
1368 |       _.each(this.regionManagers, function (manager, name) {
1369 |         manager.close();
1370 |       });
1371 |     },
1372 |   
1373 |     // Destroys all of the regions by removing references
1374 |     // from the Layout
1375 |     destroyRegions: function(){
1376 |       var that = this;
1377 |       _.each(this.regionManagers, function (manager, name) {
1378 |         delete that[name];
1379 |       });
1380 |       this.regionManagers = {};
1381 |     }
1382 |   });
1383 |   
1384 |   
1385 |   
1386 |   // AppRouter
1387 |   // ---------
1388 |   
1389 |   // Reduce the boilerplate code of handling route events
1390 |   // and then calling a single method on another object.
1391 |   // Have your routers configured to call the method on
1392 |   // your object, directly.
1393 |   //
1394 |   // Configure an AppRouter with `appRoutes`.
1395 |   //
1396 |   // App routers can only take one `controller` object. 
1397 |   // It is recommended that you divide your controller
1398 |   // objects in to smaller peices of related functionality
1399 |   // and have multiple routers / controllers, instead of
1400 |   // just one giant router and controller.
1401 |   //
1402 |   // You can also add standard routes to an AppRouter.
1403 |   
1404 |   Marionette.AppRouter = Backbone.Router.extend({
1405 |   
1406 |     constructor: function(options){
1407 |       var args = Array.prototype.slice.apply(arguments);
1408 |       Backbone.Router.prototype.constructor.apply(this, args);
1409 |   
1410 |       this.options = options;
1411 |   
1412 |       if (this.appRoutes){
1413 |         var controller = Marionette.getOption(this, "controller");
1414 |         this.processAppRoutes(controller, this.appRoutes);
1415 |       }
1416 |     },
1417 |   
1418 |     // Internal method to process the `appRoutes` for the
1419 |     // router, and turn them in to routes that trigger the
1420 |     // specified method on the specified `controller`.
1421 |     processAppRoutes: function(controller, appRoutes){
1422 |       var method, methodName;
1423 |       var route, routesLength, i;
1424 |       var routes = [];
1425 |       var router = this;
1426 |   
1427 |       for(route in appRoutes){
1428 |         if (appRoutes.hasOwnProperty(route)){
1429 |           routes.unshift([route, appRoutes[route]]);
1430 |         }
1431 |       }
1432 |   
1433 |       routesLength = routes.length;
1434 |       for (i = 0; i < routesLength; i++){
1435 |         route = routes[i][0];
1436 |         methodName = routes[i][1];
1437 |         method = controller[methodName];
1438 |   
1439 |         if (!method){
1440 |           var msg = "Method '" + methodName + "' was not found on the controller";
1441 |           var err = new Error(msg);
1442 |           err.name = "NoMethodError";
1443 |           throw err;
1444 |         }
1445 |   
1446 |         method = _.bind(method, controller);
1447 |         router.route(route, methodName, method);
1448 |       }
1449 |     }
1450 |   });
1451 |   
1452 |   
1453 |   // Application
1454 |   // -----------
1455 |   
1456 |   // Contain and manage the composite application as a whole.
1457 |   // Stores and starts up `Region` objects, includes an
1458 |   // event aggregator as `app.vent`
1459 |   Marionette.Application = function(options){
1460 |     this.initCallbacks = new Marionette.Callbacks();
1461 |     this.vent = new Backbone.Wreqr.EventAggregator();
1462 |     this.commands = new Backbone.Wreqr.Commands();
1463 |     this.reqres = new Backbone.Wreqr.RequestResponse();
1464 |     this.submodules = {};
1465 |   
1466 |     _.extend(this, options);
1467 |   
1468 |     this.triggerMethod = Marionette.triggerMethod;
1469 |   };
1470 |   
1471 |   _.extend(Marionette.Application.prototype, Backbone.Events, {
1472 |     // Command execution, facilitated by Backbone.Wreqr.Commands
1473 |     execute: function(){
1474 |       var args = Array.prototype.slice.apply(arguments);
1475 |       this.commands.execute.apply(this.commands, args);
1476 |     },
1477 |   
1478 |     // Request/response, facilitated by Backbone.Wreqr.RequestResponse
1479 |     request: function(){
1480 |       var args = Array.prototype.slice.apply(arguments);
1481 |       return this.reqres.request.apply(this.reqres, args);
1482 |     },
1483 |   
1484 |     // Add an initializer that is either run at when the `start`
1485 |     // method is called, or run immediately if added after `start`
1486 |     // has already been called.
1487 |     addInitializer: function(initializer){
1488 |       this.initCallbacks.add(initializer);
1489 |     },
1490 |   
1491 |     // kick off all of the application's processes.
1492 |     // initializes all of the regions that have been added
1493 |     // to the app, and runs all of the initializer functions
1494 |     start: function(options){
1495 |       this.triggerMethod("initialize:before", options);
1496 |       this.initCallbacks.run(options, this);
1497 |       this.triggerMethod("initialize:after", options);
1498 |   
1499 |       this.triggerMethod("start", options);
1500 |     },
1501 |   
1502 |     // Add regions to your app. 
1503 |     // Accepts a hash of named strings or Region objects
1504 |     // addRegions({something: "#someRegion"})
1505 |     // addRegions{{something: Region.extend({el: "#someRegion"}) });
1506 |     addRegions: function(regions){
1507 |       var that = this;
1508 |       _.each(regions, function (region, name) {
1509 |         var regionManager = Marionette.Region.buildRegion(region, Marionette.Region);
1510 |         that[name] = regionManager;
1511 |       });
1512 |     },
1513 |   
1514 |     // Removes a region from your app.
1515 |     // Accepts the regions name
1516 |     // removeRegion('myRegion')
1517 |     removeRegion: function(region) {
1518 |       this[region].close();
1519 |       delete this[region];
1520 |     },
1521 |   
1522 |     // Create a module, attached to the application
1523 |     module: function(moduleNames, moduleDefinition){
1524 |       // slice the args, and add this application object as the
1525 |       // first argument of the array
1526 |       var args = slice.call(arguments);
1527 |       args.unshift(this);
1528 |   
1529 |       // see the Marionette.Module object for more information
1530 |       return Marionette.Module.create.apply(Marionette.Module, args);
1531 |     }
1532 |   });
1533 |   
1534 |   // Copy the `extend` function used by Backbone's classes
1535 |   Marionette.Application.extend = Marionette.extend;
1536 |   
1537 |   // Module
1538 |   // ------
1539 |   
1540 |   // A simple module system, used to create privacy and encapsulation in
1541 |   // Marionette applications
1542 |   Marionette.Module = function(moduleName, app){
1543 |     this.moduleName = moduleName;
1544 |   
1545 |     // store sub-modules
1546 |     this.submodules = {};
1547 |   
1548 |     this._setupInitializersAndFinalizers();
1549 |   
1550 |     // store the configuration for this module
1551 |     this.app = app;
1552 |     this.startWithParent = true;
1553 |   
1554 |     this.triggerMethod = Marionette.triggerMethod;
1555 |   };
1556 |   
1557 |   // Extend the Module prototype with events / listenTo, so that the module
1558 |   // can be used as an event aggregator or pub/sub.
1559 |   _.extend(Marionette.Module.prototype, Backbone.Events, {
1560 |   
1561 |     // Initializer for a specific module. Initializers are run when the
1562 |     // module's `start` method is called.
1563 |     addInitializer: function(callback){
1564 |       this._initializerCallbacks.add(callback);
1565 |     },
1566 |   
1567 |     // Finalizers are run when a module is stopped. They are used to teardown
1568 |     // and finalize any variables, references, events and other code that the
1569 |     // module had set up.
1570 |     addFinalizer: function(callback){
1571 |       this._finalizerCallbacks.add(callback);
1572 |     },
1573 |   
1574 |     // Start the module, and run all of it's initializers
1575 |     start: function(options){
1576 |       // Prevent re-starting a module that is already started
1577 |       if (this._isInitialized){ return; }
1578 |   
1579 |       // start the sub-modules (depth-first hierarchy)
1580 |       _.each(this.submodules, function(mod){
1581 |         // check to see if we should start the sub-module with this parent
1582 |         var startWithParent = true;
1583 |         startWithParent = mod.startWithParent;
1584 |   
1585 |         // start the sub-module
1586 |         if (startWithParent){
1587 |           mod.start(options);
1588 |         }
1589 |       });
1590 |   
1591 |       // run the callbacks to "start" the current module
1592 |       this.triggerMethod("before:start", options);
1593 |   
1594 |       this._initializerCallbacks.run(options, this);
1595 |       this._isInitialized = true;
1596 |   
1597 |       this.triggerMethod("start", options);
1598 |     },
1599 |   
1600 |     // Stop this module by running its finalizers and then stop all of
1601 |     // the sub-modules for this module
1602 |     stop: function(){
1603 |       // if we are not initialized, don't bother finalizing
1604 |       if (!this._isInitialized){ return; }
1605 |       this._isInitialized = false;
1606 |   
1607 |       Marionette.triggerMethod.call(this, "before:stop");
1608 |   
1609 |       // stop the sub-modules; depth-first, to make sure the
1610 |       // sub-modules are stopped / finalized before parents
1611 |       _.each(this.submodules, function(mod){ mod.stop(); });
1612 |   
1613 |       // run the finalizers
1614 |       this._finalizerCallbacks.run(undefined,this);
1615 |   
1616 |       // reset the initializers and finalizers
1617 |       this._initializerCallbacks.reset();
1618 |       this._finalizerCallbacks.reset();
1619 |   
1620 |       Marionette.triggerMethod.call(this, "stop");
1621 |     },
1622 |   
1623 |     // Configure the module with a definition function and any custom args
1624 |     // that are to be passed in to the definition function
1625 |     addDefinition: function(moduleDefinition, customArgs){
1626 |       this._runModuleDefinition(moduleDefinition, customArgs);
1627 |     },
1628 |   
1629 |     // Internal method: run the module definition function with the correct
1630 |     // arguments
1631 |     _runModuleDefinition: function(definition, customArgs){
1632 |       if (!definition){ return; }
1633 |   
1634 |       // build the correct list of arguments for the module definition
1635 |       var args = _.flatten([
1636 |         this,
1637 |         this.app,
1638 |         Backbone,
1639 |         Marionette,
1640 |         $, _,
1641 |         customArgs
1642 |       ]);
1643 |   
1644 |       definition.apply(this, args);
1645 |     },
1646 |   
1647 |     // Internal method: set up new copies of initializers and finalizers.
1648 |     // Calling this method will wipe out all existing initializers and
1649 |     // finalizers.
1650 |     _setupInitializersAndFinalizers: function(){
1651 |       this._initializerCallbacks = new Marionette.Callbacks();
1652 |       this._finalizerCallbacks = new Marionette.Callbacks();
1653 |     }
1654 |   });
1655 |   
1656 |   // Type methods to create modules
1657 |   _.extend(Marionette.Module, {
1658 |   
1659 |     // Create a module, hanging off the app parameter as the parent object.
1660 |     create: function(app, moduleNames, moduleDefinition){
1661 |       var that = this;
1662 |       var module = app;
1663 |   
1664 |       // get the custom args passed in after the module definition and
1665 |       // get rid of the module name and definition function
1666 |       var customArgs = slice.apply(arguments);
1667 |       customArgs.splice(0, 3);
1668 |   
1669 |       // split the module names and get the length
1670 |       moduleNames = moduleNames.split(".");
1671 |       var length = moduleNames.length;
1672 |   
1673 |       // store the module definition for the last module in the chain
1674 |       var moduleDefinitions = [];
1675 |       moduleDefinitions[length-1] = moduleDefinition;
1676 |   
1677 |       // Loop through all the parts of the module definition
1678 |       _.each(moduleNames, function(moduleName, i){
1679 |         var parentModule = module;
1680 |         module = that._getModule(parentModule, moduleName, app);
1681 |         that._addModuleDefinition(parentModule, module, moduleDefinitions[i], customArgs);
1682 |       });
1683 |   
1684 |       // Return the last module in the definition chain
1685 |       return module;
1686 |     },
1687 |   
1688 |     _getModule: function(parentModule, moduleName, app, def, args){
1689 |       // Get an existing module of this name if we have one
1690 |       var module = parentModule[moduleName];
1691 |   
1692 |       if (!module){
1693 |         // Create a new module if we don't have one
1694 |         module = new Marionette.Module(moduleName, app);
1695 |         parentModule[moduleName] = module;
1696 |         // store the module on the parent
1697 |         parentModule.submodules[moduleName] = module;
1698 |       }
1699 |   
1700 |       return module;
1701 |     },
1702 |   
1703 |     _addModuleDefinition: function(parentModule, module, def, args){
1704 |       var fn; 
1705 |       var startWithParent;
1706 |   
1707 |       if (_.isFunction(def)){
1708 |         // if a function is supplied for the module definition
1709 |         fn = def;
1710 |         startWithParent = true;
1711 |   
1712 |       } else if (_.isObject(def)){
1713 |         // if an object is supplied
1714 |         fn = def.define;
1715 |         startWithParent = def.startWithParent;
1716 |         
1717 |       } else {
1718 |         // if nothing is supplied
1719 |         startWithParent = true;
1720 |       }
1721 |   
1722 |       // add module definition if needed
1723 |       if (fn){
1724 |         module.addDefinition(fn, args);
1725 |       }
1726 |   
1727 |       // `and` the two together, ensuring a single `false` will prevent it
1728 |       // from starting with the parent
1729 |       var tmp = module.startWithParent;
1730 |       module.startWithParent = module.startWithParent && startWithParent;
1731 |   
1732 |       // setup auto-start if needed
1733 |       if (module.startWithParent && !module.startWithParentIsConfigured){
1734 |   
1735 |         // only configure this once
1736 |         module.startWithParentIsConfigured = true;
1737 |   
1738 |         // add the module initializer config
1739 |         parentModule.addInitializer(function(options){
1740 |           if (module.startWithParent){
1741 |             module.start(options);
1742 |           }
1743 |         });
1744 |   
1745 |       }
1746 |   
1747 |     }
1748 |   });
1749 |   
1750 |   
1751 |   
1752 |     return Marionette;
1753 |   })(Backbone, _, $ || window.jQuery || window.Zepto || window.ender);
1754 |   
1755 |   return Backbone.Marionette; 
1756 | 
1757 | }));


--------------------------------------------------------------------------------
/web/public/js/lib/backbone.wreqr.js:
--------------------------------------------------------------------------------
  1 | // Backbone.Wreqr, v0.1.1
  2 | // Copyright (c)2013 Derick Bailey, Muted Solutions, LLC.
  3 | // Distributed under MIT license
  4 | // http://github.com/marionettejs/backbone.wreqr
  5 | (function (root, factory) {
  6 |   if (typeof exports === 'object') {
  7 | 
  8 |     var underscore = require('underscore');
  9 |     var backbone = require('backbone');
 10 | 
 11 |     module.exports = factory(underscore, backbone);
 12 | 
 13 |   } else if (typeof define === 'function' && define.amd) {
 14 | 
 15 |     define(['underscore', 'backbone'], factory);
 16 | 
 17 |   } 
 18 | }(this, function (_, Backbone) {
 19 |   "use strict";
 20 | 
 21 |   Backbone.Wreqr = (function(Backbone, Marionette, _){
 22 |     "use strict";
 23 |     var Wreqr = {};
 24 |   
 25 |     // Handlers
 26 |     // --------
 27 |     // A registry of functions to call, given a name
 28 |     
 29 |     Wreqr.Handlers = (function(Backbone, _){
 30 |       "use strict";
 31 |       
 32 |       // Constructor
 33 |       // -----------
 34 |     
 35 |       var Handlers = function(){
 36 |         this._handlers = {};
 37 |       };
 38 |     
 39 |       Handlers.extend = Backbone.Model.extend;
 40 |     
 41 |       // Instance Members
 42 |       // ----------------
 43 |     
 44 |       _.extend(Handlers.prototype, {
 45 |     
 46 |         // Add a handler for the given name, with an
 47 |         // optional context to run the handler within
 48 |         addHandler: function(name, handler, context){
 49 |           var config = {
 50 |             callback: handler,
 51 |             context: context
 52 |           };
 53 |     
 54 |           this._handlers[name] = config;
 55 |         },
 56 |     
 57 |         // Get the currently registered handler for
 58 |         // the specified name. Throws an exception if
 59 |         // no handler is found.
 60 |         getHandler: function(name){
 61 |           var config = this._handlers[name];
 62 |     
 63 |           if (!config){
 64 |             throw new Error("Handler not found for '" + name + "'");
 65 |           }
 66 |     
 67 |           return function(){
 68 |             var args = Array.prototype.slice.apply(arguments);
 69 |             return config.callback.apply(config.context, args);
 70 |           };
 71 |         },
 72 |     
 73 |         // Remove a handler for the specified name
 74 |         removeHandler: function(name){
 75 |           delete this._handlers[name];
 76 |         },
 77 |     
 78 |         // Remove all handlers from this registry
 79 |         removeAllHandlers: function(){
 80 |           this._handlers = {};
 81 |         }
 82 |       });
 83 |     
 84 |       return Handlers;
 85 |     })(Backbone, _);
 86 |     
 87 |     // Wreqr.Commands
 88 |     // --------------
 89 |     //
 90 |     // A simple command pattern implementation. Register a command
 91 |     // handler and execute it.
 92 |     Wreqr.Commands = (function(Wreqr){
 93 |       "use strict";
 94 |     
 95 |       return Wreqr.Handlers.extend({
 96 |         execute: function(){
 97 |           var name = arguments[0];
 98 |           var args = Array.prototype.slice.call(arguments, 1);
 99 |     
100 |           this.getHandler(name).apply(this, args);
101 |         }
102 |       });
103 |     
104 |     })(Wreqr);
105 |     
106 |     // Wreqr.RequestResponse
107 |     // ---------------------
108 |     //
109 |     // A simple request/response implementation. Register a
110 |     // request handler, and return a response from it
111 |     Wreqr.RequestResponse = (function(Wreqr){
112 |       "use strict";
113 |     
114 |       return Wreqr.Handlers.extend({
115 |         request: function(){
116 |           var name = arguments[0];
117 |           var args = Array.prototype.slice.call(arguments, 1);
118 |     
119 |           return this.getHandler(name).apply(this, args);
120 |         }
121 |       });
122 |     
123 |     })(Wreqr);
124 |     
125 |     // Event Aggregator
126 |     // ----------------
127 |     // A pub-sub object that can be used to decouple various parts
128 |     // of an application through event-driven architecture.
129 |     
130 |     Wreqr.EventAggregator = (function(Backbone, _){
131 |       "use strict";
132 |       var EA = function(){};
133 |     
134 |       // Copy the `extend` function used by Backbone's classes
135 |       EA.extend = Backbone.Model.extend;
136 |     
137 |       // Copy the basic Backbone.Events on to the event aggregator
138 |       _.extend(EA.prototype, Backbone.Events);
139 |     
140 |       return EA;
141 |     })(Backbone, _);
142 |     
143 |   
144 |     return Wreqr;
145 |   })(Backbone, Backbone.Marionette, _);
146 |   
147 |   return Backbone.Wreqr; 
148 | 
149 | }));
150 | 


--------------------------------------------------------------------------------
/web/public/js/lib/require.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  RequireJS 2.1.5 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
 3 |  Available via the MIT or new BSD license.
 4 |  see: http://github.com/jrburke/requirejs for details
 5 | */
 6 | var requirejs,require,define;
 7 | (function(aa){function I(b){return"[object Function]"===L.call(b)}function J(b){return"[object Array]"===L.call(b)}function y(b,c){if(b){var d;for(d=0;d<b.length&&(!b[d]||!c(b[d],d,b));d+=1);}}function M(b,c){if(b){var d;for(d=b.length-1;-1<d&&(!b[d]||!c(b[d],d,b));d-=1);}}function s(b,c){return ga.call(b,c)}function m(b,c){return s(b,c)&&b[c]}function G(b,c){for(var d in b)if(s(b,d)&&c(b[d],d))break}function R(b,c,d,m){c&&G(c,function(c,j){if(d||!s(b,j))m&&"string"!==typeof c?(b[j]||(b[j]={}),R(b[j],
 8 | c,d,m)):b[j]=c});return b}function u(b,c){return function(){return c.apply(b,arguments)}}function ba(b){if(!b)return b;var c=aa;y(b.split("."),function(b){c=c[b]});return c}function B(b,c,d,m){c=Error(c+"\nhttp://requirejs.org/docs/errors.html#"+b);c.requireType=b;c.requireModules=m;d&&(c.originalError=d);return c}function ha(b){function c(a,f,b){var e,n,c,g,d,S,i,h=f&&f.split("/");e=h;var j=k.map,l=j&&j["*"];if(a&&"."===a.charAt(0))if(f){e=m(k.pkgs,f)?h=[f]:h.slice(0,h.length-1);f=a=e.concat(a.split("/"));
 9 | for(e=0;f[e];e+=1)if(n=f[e],"."===n)f.splice(e,1),e-=1;else if(".."===n)if(1===e&&(".."===f[2]||".."===f[0]))break;else 0<e&&(f.splice(e-1,2),e-=2);e=m(k.pkgs,f=a[0]);a=a.join("/");e&&a===f+"/"+e.main&&(a=f)}else 0===a.indexOf("./")&&(a=a.substring(2));if(b&&j&&(h||l)){f=a.split("/");for(e=f.length;0<e;e-=1){c=f.slice(0,e).join("/");if(h)for(n=h.length;0<n;n-=1)if(b=m(j,h.slice(0,n).join("/")))if(b=m(b,c)){g=b;d=e;break}if(g)break;!S&&(l&&m(l,c))&&(S=m(l,c),i=e)}!g&&S&&(g=S,d=i);g&&(f.splice(0,d,
10 | g),a=f.join("/"))}return a}function d(a){A&&y(document.getElementsByTagName("script"),function(f){if(f.getAttribute("data-requiremodule")===a&&f.getAttribute("data-requirecontext")===i.contextName)return f.parentNode.removeChild(f),!0})}function z(a){var f=m(k.paths,a);if(f&&J(f)&&1<f.length)return d(a),f.shift(),i.require.undef(a),i.require([a]),!0}function h(a){var f,b=a?a.indexOf("!"):-1;-1<b&&(f=a.substring(0,b),a=a.substring(b+1,a.length));return[f,a]}function j(a,f,b,e){var n,C,g=null,d=f?f.name:
11 | null,j=a,l=!0,k="";a||(l=!1,a="_@r"+(M+=1));a=h(a);g=a[0];a=a[1];g&&(g=c(g,d,e),C=m(q,g));a&&(g?k=C&&C.normalize?C.normalize(a,function(a){return c(a,d,e)}):c(a,d,e):(k=c(a,d,e),a=h(k),g=a[0],k=a[1],b=!0,n=i.nameToUrl(k)));b=g&&!C&&!b?"_unnormalized"+(Q+=1):"";return{prefix:g,name:k,parentMap:f,unnormalized:!!b,url:n,originalName:j,isDefine:l,id:(g?g+"!"+k:k)+b}}function r(a){var f=a.id,b=m(p,f);b||(b=p[f]=new i.Module(a));return b}function t(a,f,b){var e=a.id,n=m(p,e);if(s(q,e)&&(!n||n.defineEmitComplete))"defined"===
12 | f&&b(q[e]);else r(a).on(f,b)}function v(a,f){var b=a.requireModules,e=!1;if(f)f(a);else if(y(b,function(f){if(f=m(p,f))f.error=a,f.events.error&&(e=!0,f.emit("error",a))}),!e)l.onError(a)}function w(){T.length&&(ia.apply(H,[H.length-1,0].concat(T)),T=[])}function x(a){delete p[a];delete V[a]}function F(a,f,b){var e=a.map.id;a.error?a.emit("error",a.error):(f[e]=!0,y(a.depMaps,function(e,c){var g=e.id,d=m(p,g);d&&(!a.depMatched[c]&&!b[g])&&(m(f,g)?(a.defineDep(c,q[g]),a.check()):F(d,f,b))}),b[e]=!0)}
13 | function D(){var a,f,b,e,n=(b=1E3*k.waitSeconds)&&i.startTime+b<(new Date).getTime(),c=[],g=[],h=!1,j=!0;if(!W){W=!0;G(V,function(b){a=b.map;f=a.id;if(b.enabled&&(a.isDefine||g.push(b),!b.error))if(!b.inited&&n)z(f)?h=e=!0:(c.push(f),d(f));else if(!b.inited&&(b.fetched&&a.isDefine)&&(h=!0,!a.prefix))return j=!1});if(n&&c.length)return b=B("timeout","Load timeout for modules: "+c,null,c),b.contextName=i.contextName,v(b);j&&y(g,function(a){F(a,{},{})});if((!n||e)&&h)if((A||da)&&!X)X=setTimeout(function(){X=
14 | 0;D()},50);W=!1}}function E(a){s(q,a[0])||r(j(a[0],null,!0)).init(a[1],a[2])}function K(a){var a=a.currentTarget||a.srcElement,b=i.onScriptLoad;a.detachEvent&&!Y?a.detachEvent("onreadystatechange",b):a.removeEventListener("load",b,!1);b=i.onScriptError;(!a.detachEvent||Y)&&a.removeEventListener("error",b,!1);return{node:a,id:a&&a.getAttribute("data-requiremodule")}}function L(){var a;for(w();H.length;){a=H.shift();if(null===a[0])return v(B("mismatch","Mismatched anonymous define() module: "+a[a.length-
15 | 1]));E(a)}}var W,Z,i,N,X,k={waitSeconds:7,baseUrl:"./",paths:{},pkgs:{},shim:{},config:{}},p={},V={},$={},H=[],q={},U={},M=1,Q=1;N={require:function(a){return a.require?a.require:a.require=i.makeRequire(a.map)},exports:function(a){a.usingExports=!0;if(a.map.isDefine)return a.exports?a.exports:a.exports=q[a.map.id]={}},module:function(a){return a.module?a.module:a.module={id:a.map.id,uri:a.map.url,config:function(){return k.config&&m(k.config,a.map.id)||{}},exports:q[a.map.id]}}};Z=function(a){this.events=
16 | m($,a.id)||{};this.map=a;this.shim=m(k.shim,a.id);this.depExports=[];this.depMaps=[];this.depMatched=[];this.pluginMaps={};this.depCount=0};Z.prototype={init:function(a,b,c,e){e=e||{};if(!this.inited){this.factory=b;if(c)this.on("error",c);else this.events.error&&(c=u(this,function(a){this.emit("error",a)}));this.depMaps=a&&a.slice(0);this.errback=c;this.inited=!0;this.ignore=e.ignore;e.enabled||this.enabled?this.enable():this.check()}},defineDep:function(a,b){this.depMatched[a]||(this.depMatched[a]=
17 | !0,this.depCount-=1,this.depExports[a]=b)},fetch:function(){if(!this.fetched){this.fetched=!0;i.startTime=(new Date).getTime();var a=this.map;if(this.shim)i.makeRequire(this.map,{enableBuildCallback:!0})(this.shim.deps||[],u(this,function(){return a.prefix?this.callPlugin():this.load()}));else return a.prefix?this.callPlugin():this.load()}},load:function(){var a=this.map.url;U[a]||(U[a]=!0,i.load(this.map.id,a))},check:function(){if(this.enabled&&!this.enabling){var a,b,c=this.map.id;b=this.depExports;
18 | var e=this.exports,n=this.factory;if(this.inited)if(this.error)this.emit("error",this.error);else{if(!this.defining){this.defining=!0;if(1>this.depCount&&!this.defined){if(I(n)){if(this.events.error)try{e=i.execCb(c,n,b,e)}catch(d){a=d}else e=i.execCb(c,n,b,e);this.map.isDefine&&((b=this.module)&&void 0!==b.exports&&b.exports!==this.exports?e=b.exports:void 0===e&&this.usingExports&&(e=this.exports));if(a)return a.requireMap=this.map,a.requireModules=[this.map.id],a.requireType="define",v(this.error=
19 | a)}else e=n;this.exports=e;if(this.map.isDefine&&!this.ignore&&(q[c]=e,l.onResourceLoad))l.onResourceLoad(i,this.map,this.depMaps);x(c);this.defined=!0}this.defining=!1;this.defined&&!this.defineEmitted&&(this.defineEmitted=!0,this.emit("defined",this.exports),this.defineEmitComplete=!0)}}else this.fetch()}},callPlugin:function(){var a=this.map,b=a.id,d=j(a.prefix);this.depMaps.push(d);t(d,"defined",u(this,function(e){var n,d;d=this.map.name;var g=this.map.parentMap?this.map.parentMap.name:null,h=
20 | i.makeRequire(a.parentMap,{enableBuildCallback:!0});if(this.map.unnormalized){if(e.normalize&&(d=e.normalize(d,function(a){return c(a,g,!0)})||""),e=j(a.prefix+"!"+d,this.map.parentMap),t(e,"defined",u(this,function(a){this.init([],function(){return a},null,{enabled:!0,ignore:!0})})),d=m(p,e.id)){this.depMaps.push(e);if(this.events.error)d.on("error",u(this,function(a){this.emit("error",a)}));d.enable()}}else n=u(this,function(a){this.init([],function(){return a},null,{enabled:!0})}),n.error=u(this,
21 | function(a){this.inited=!0;this.error=a;a.requireModules=[b];G(p,function(a){0===a.map.id.indexOf(b+"_unnormalized")&&x(a.map.id)});v(a)}),n.fromText=u(this,function(e,c){var d=a.name,g=j(d),C=O;c&&(e=c);C&&(O=!1);r(g);s(k.config,b)&&(k.config[d]=k.config[b]);try{l.exec(e)}catch(ca){return v(B("fromtexteval","fromText eval for "+b+" failed: "+ca,ca,[b]))}C&&(O=!0);this.depMaps.push(g);i.completeLoad(d);h([d],n)}),e.load(a.name,h,n,k)}));i.enable(d,this);this.pluginMaps[d.id]=d},enable:function(){V[this.map.id]=
22 | this;this.enabling=this.enabled=!0;y(this.depMaps,u(this,function(a,b){var c,e;if("string"===typeof a){a=j(a,this.map.isDefine?this.map:this.map.parentMap,!1,!this.skipMap);this.depMaps[b]=a;if(c=m(N,a.id)){this.depExports[b]=c(this);return}this.depCount+=1;t(a,"defined",u(this,function(a){this.defineDep(b,a);this.check()}));this.errback&&t(a,"error",this.errback)}c=a.id;e=p[c];!s(N,c)&&(e&&!e.enabled)&&i.enable(a,this)}));G(this.pluginMaps,u(this,function(a){var b=m(p,a.id);b&&!b.enabled&&i.enable(a,
23 | this)}));this.enabling=!1;this.check()},on:function(a,b){var c=this.events[a];c||(c=this.events[a]=[]);c.push(b)},emit:function(a,b){y(this.events[a],function(a){a(b)});"error"===a&&delete this.events[a]}};i={config:k,contextName:b,registry:p,defined:q,urlFetched:U,defQueue:H,Module:Z,makeModuleMap:j,nextTick:l.nextTick,onError:v,configure:function(a){a.baseUrl&&"/"!==a.baseUrl.charAt(a.baseUrl.length-1)&&(a.baseUrl+="/");var b=k.pkgs,c=k.shim,e={paths:!0,config:!0,map:!0};G(a,function(a,b){e[b]?
24 | "map"===b?(k.map||(k.map={}),R(k[b],a,!0,!0)):R(k[b],a,!0):k[b]=a});a.shim&&(G(a.shim,function(a,b){J(a)&&(a={deps:a});if((a.exports||a.init)&&!a.exportsFn)a.exportsFn=i.makeShimExports(a);c[b]=a}),k.shim=c);a.packages&&(y(a.packages,function(a){a="string"===typeof a?{name:a}:a;b[a.name]={name:a.name,location:a.location||a.name,main:(a.main||"main").replace(ja,"").replace(ea,"")}}),k.pkgs=b);G(p,function(a,b){!a.inited&&!a.map.unnormalized&&(a.map=j(b))});if(a.deps||a.callback)i.require(a.deps||[],
25 | a.callback)},makeShimExports:function(a){return function(){var b;a.init&&(b=a.init.apply(aa,arguments));return b||a.exports&&ba(a.exports)}},makeRequire:function(a,f){function d(e,c,h){var g,k;f.enableBuildCallback&&(c&&I(c))&&(c.__requireJsBuild=!0);if("string"===typeof e){if(I(c))return v(B("requireargs","Invalid require call"),h);if(a&&s(N,e))return N[e](p[a.id]);if(l.get)return l.get(i,e,a,d);g=j(e,a,!1,!0);g=g.id;return!s(q,g)?v(B("notloaded",'Module name "'+g+'" has not been loaded yet for context: '+
26 | b+(a?"":". Use require([])"))):q[g]}L();i.nextTick(function(){L();k=r(j(null,a));k.skipMap=f.skipMap;k.init(e,c,h,{enabled:!0});D()});return d}f=f||{};R(d,{isBrowser:A,toUrl:function(b){var d,f=b.lastIndexOf("."),g=b.split("/")[0];if(-1!==f&&(!("."===g||".."===g)||1<f))d=b.substring(f,b.length),b=b.substring(0,f);return i.nameToUrl(c(b,a&&a.id,!0),d,!0)},defined:function(b){return s(q,j(b,a,!1,!0).id)},specified:function(b){b=j(b,a,!1,!0).id;return s(q,b)||s(p,b)}});a||(d.undef=function(b){w();var c=
27 | j(b,a,!0),d=m(p,b);delete q[b];delete U[c.url];delete $[b];d&&(d.events.defined&&($[b]=d.events),x(b))});return d},enable:function(a){m(p,a.id)&&r(a).enable()},completeLoad:function(a){var b,c,e=m(k.shim,a)||{},d=e.exports;for(w();H.length;){c=H.shift();if(null===c[0]){c[0]=a;if(b)break;b=!0}else c[0]===a&&(b=!0);E(c)}c=m(p,a);if(!b&&!s(q,a)&&c&&!c.inited){if(k.enforceDefine&&(!d||!ba(d)))return z(a)?void 0:v(B("nodefine","No define call for "+a,null,[a]));E([a,e.deps||[],e.exportsFn])}D()},nameToUrl:function(a,
28 | b,c){var e,d,h,g,j,i;if(l.jsExtRegExp.test(a))g=a+(b||"");else{e=k.paths;d=k.pkgs;g=a.split("/");for(j=g.length;0<j;j-=1)if(i=g.slice(0,j).join("/"),h=m(d,i),i=m(e,i)){J(i)&&(i=i[0]);g.splice(0,j,i);break}else if(h){a=a===h.name?h.location+"/"+h.main:h.location;g.splice(0,j,a);break}g=g.join("/");g+=b||(/\?/.test(g)||c?"":".js");g=("/"===g.charAt(0)||g.match(/^[\w\+\.\-]+:/)?"":k.baseUrl)+g}return k.urlArgs?g+((-1===g.indexOf("?")?"?":"&")+k.urlArgs):g},load:function(a,b){l.load(i,a,b)},execCb:function(a,
29 | b,c,d){return b.apply(d,c)},onScriptLoad:function(a){if("load"===a.type||ka.test((a.currentTarget||a.srcElement).readyState))P=null,a=K(a),i.completeLoad(a.id)},onScriptError:function(a){var b=K(a);if(!z(b.id))return v(B("scripterror","Script error",a,[b.id]))}};i.require=i.makeRequire();return i}var l,w,x,D,t,E,P,K,Q,fa,la=/(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,ma=/[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,ea=/\.js$/,ja=/^\.\//;w=Object.prototype;var L=w.toString,ga=w.hasOwnProperty,ia=
30 | Array.prototype.splice,A=!!("undefined"!==typeof window&&navigator&&document),da=!A&&"undefined"!==typeof importScripts,ka=A&&"PLAYSTATION 3"===navigator.platform?/^complete$/:/^(complete|loaded)$/,Y="undefined"!==typeof opera&&"[object Opera]"===opera.toString(),F={},r={},T=[],O=!1;if("undefined"===typeof define){if("undefined"!==typeof requirejs){if(I(requirejs))return;r=requirejs;requirejs=void 0}"undefined"!==typeof require&&!I(require)&&(r=require,require=void 0);l=requirejs=function(b,c,d,z){var h,
31 | j="_";!J(b)&&"string"!==typeof b&&(h=b,J(c)?(b=c,c=d,d=z):b=[]);h&&h.context&&(j=h.context);(z=m(F,j))||(z=F[j]=l.s.newContext(j));h&&z.configure(h);return z.require(b,c,d)};l.config=function(b){return l(b)};l.nextTick="undefined"!==typeof setTimeout?function(b){setTimeout(b,4)}:function(b){b()};require||(require=l);l.version="2.1.5";l.jsExtRegExp=/^\/|:|\?|\.js$/;l.isBrowser=A;w=l.s={contexts:F,newContext:ha};l({});y(["toUrl","undef","defined","specified"],function(b){l[b]=function(){var c=F._;return c.require[b].apply(c,
32 | arguments)}});if(A&&(x=w.head=document.getElementsByTagName("head")[0],D=document.getElementsByTagName("base")[0]))x=w.head=D.parentNode;l.onError=function(b){throw b;};l.load=function(b,c,d){var l=b&&b.config||{},h;if(A)return h=l.xhtml?document.createElementNS("http://www.w3.org/1999/xhtml","html:script"):document.createElement("script"),h.type=l.scriptType||"text/javascript",h.charset="utf-8",h.async=!0,h.setAttribute("data-requirecontext",b.contextName),h.setAttribute("data-requiremodule",c),
33 | h.attachEvent&&!(h.attachEvent.toString&&0>h.attachEvent.toString().indexOf("[native code"))&&!Y?(O=!0,h.attachEvent("onreadystatechange",b.onScriptLoad)):(h.addEventListener("load",b.onScriptLoad,!1),h.addEventListener("error",b.onScriptError,!1)),h.src=d,K=h,D?x.insertBefore(h,D):x.appendChild(h),K=null,h;if(da)try{importScripts(d),b.completeLoad(c)}catch(j){b.onError(B("importscripts","importScripts failed for "+c+" at "+d,j,[c]))}};A&&M(document.getElementsByTagName("script"),function(b){x||(x=
34 | b.parentNode);if(t=b.getAttribute("data-main"))return r.baseUrl||(E=t.split("/"),Q=E.pop(),fa=E.length?E.join("/")+"/":"./",r.baseUrl=fa,t=Q),t=t.replace(ea,""),r.deps=r.deps?r.deps.concat(t):[t],!0});define=function(b,c,d){var l,h;"string"!==typeof b&&(d=c,c=b,b=null);J(c)||(d=c,c=[]);!c.length&&I(d)&&d.length&&(d.toString().replace(la,"").replace(ma,function(b,d){c.push(d)}),c=(1===d.length?["require"]:["require","exports","module"]).concat(c));if(O){if(!(l=K))P&&"interactive"===P.readyState||M(document.getElementsByTagName("script"),
35 | function(b){if("interactive"===b.readyState)return P=b}),l=P;l&&(b||(b=l.getAttribute("data-requiremodule")),h=F[l.getAttribute("data-requirecontext")])}(h?h.defQueue:T).push([b,c,d])};define.amd={jQuery:!0};l.exec=function(b){return eval(b)};l(r)}})(this);
36 | 


--------------------------------------------------------------------------------
/web/public/js/lib/underscore.js:
--------------------------------------------------------------------------------
   1 | //     Underscore.js 1.4.4
   2 | //     http://underscorejs.org
   3 | //     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
   4 | //     Underscore may be freely distributed under the MIT license.
   5 | 
   6 | (function() {
   7 | 
   8 |   // Baseline setup
   9 |   // --------------
  10 | 
  11 |   // Establish the root object, `window` in the browser, or `global` on the server.
  12 |   var root = this;
  13 | 
  14 |   // Save the previous value of the `_` variable.
  15 |   var previousUnderscore = root._;
  16 | 
  17 |   // Establish the object that gets returned to break out of a loop iteration.
  18 |   var breaker = {};
  19 | 
  20 |   // Save bytes in the minified (but not gzipped) version:
  21 |   var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
  22 | 
  23 |   // Create quick reference variables for speed access to core prototypes.
  24 |   var push             = ArrayProto.push,
  25 |       slice            = ArrayProto.slice,
  26 |       concat           = ArrayProto.concat,
  27 |       toString         = ObjProto.toString,
  28 |       hasOwnProperty   = ObjProto.hasOwnProperty;
  29 | 
  30 |   // All **ECMAScript 5** native function implementations that we hope to use
  31 |   // are declared here.
  32 |   var
  33 |     nativeForEach      = ArrayProto.forEach,
  34 |     nativeMap          = ArrayProto.map,
  35 |     nativeReduce       = ArrayProto.reduce,
  36 |     nativeReduceRight  = ArrayProto.reduceRight,
  37 |     nativeFilter       = ArrayProto.filter,
  38 |     nativeEvery        = ArrayProto.every,
  39 |     nativeSome         = ArrayProto.some,
  40 |     nativeIndexOf      = ArrayProto.indexOf,
  41 |     nativeLastIndexOf  = ArrayProto.lastIndexOf,
  42 |     nativeIsArray      = Array.isArray,
  43 |     nativeKeys         = Object.keys,
  44 |     nativeBind         = FuncProto.bind;
  45 | 
  46 |   // Create a safe reference to the Underscore object for use below.
  47 |   var _ = function(obj) {
  48 |     if (obj instanceof _) return obj;
  49 |     if (!(this instanceof _)) return new _(obj);
  50 |     this._wrapped = obj;
  51 |   };
  52 | 
  53 |   // Export the Underscore object for **Node.js**, with
  54 |   // backwards-compatibility for the old `require()` API. If we're in
  55 |   // the browser, add `_` as a global object via a string identifier,
  56 |   // for Closure Compiler "advanced" mode.
  57 |   if (typeof exports !== 'undefined') {
  58 |     if (typeof module !== 'undefined' && module.exports) {
  59 |       exports = module.exports = _;
  60 |     }
  61 |     exports._ = _;
  62 |   } else {
  63 |     root._ = _;
  64 |   }
  65 | 
  66 |   // Current version.
  67 |   _.VERSION = '1.4.4';
  68 | 
  69 |   // Collection Functions
  70 |   // --------------------
  71 | 
  72 |   // The cornerstone, an `each` implementation, aka `forEach`.
  73 |   // Handles objects with the built-in `forEach`, arrays, and raw objects.
  74 |   // Delegates to **ECMAScript 5**'s native `forEach` if available.
  75 |   var each = _.each = _.forEach = function(obj, iterator, context) {
  76 |     if (obj == null) return;
  77 |     if (nativeForEach && obj.forEach === nativeForEach) {
  78 |       obj.forEach(iterator, context);
  79 |     } else if (obj.length === +obj.length) {
  80 |       for (var i = 0, l = obj.length; i < l; i++) {
  81 |         if (iterator.call(context, obj[i], i, obj) === breaker) return;
  82 |       }
  83 |     } else {
  84 |       for (var key in obj) {
  85 |         if (_.has(obj, key)) {
  86 |           if (iterator.call(context, obj[key], key, obj) === breaker) return;
  87 |         }
  88 |       }
  89 |     }
  90 |   };
  91 | 
  92 |   // Return the results of applying the iterator to each element.
  93 |   // Delegates to **ECMAScript 5**'s native `map` if available.
  94 |   _.map = _.collect = function(obj, iterator, context) {
  95 |     var results = [];
  96 |     if (obj == null) return results;
  97 |     if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
  98 |     each(obj, function(value, index, list) {
  99 |       results[results.length] = iterator.call(context, value, index, list);
 100 |     });
 101 |     return results;
 102 |   };
 103 | 
 104 |   var reduceError = 'Reduce of empty array with no initial value';
 105 | 
 106 |   // **Reduce** builds up a single result from a list of values, aka `inject`,
 107 |   // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
 108 |   _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
 109 |     var initial = arguments.length > 2;
 110 |     if (obj == null) obj = [];
 111 |     if (nativeReduce && obj.reduce === nativeReduce) {
 112 |       if (context) iterator = _.bind(iterator, context);
 113 |       return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
 114 |     }
 115 |     each(obj, function(value, index, list) {
 116 |       if (!initial) {
 117 |         memo = value;
 118 |         initial = true;
 119 |       } else {
 120 |         memo = iterator.call(context, memo, value, index, list);
 121 |       }
 122 |     });
 123 |     if (!initial) throw new TypeError(reduceError);
 124 |     return memo;
 125 |   };
 126 | 
 127 |   // The right-associative version of reduce, also known as `foldr`.
 128 |   // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
 129 |   _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
 130 |     var initial = arguments.length > 2;
 131 |     if (obj == null) obj = [];
 132 |     if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
 133 |       if (context) iterator = _.bind(iterator, context);
 134 |       return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
 135 |     }
 136 |     var length = obj.length;
 137 |     if (length !== +length) {
 138 |       var keys = _.keys(obj);
 139 |       length = keys.length;
 140 |     }
 141 |     each(obj, function(value, index, list) {
 142 |       index = keys ? keys[--length] : --length;
 143 |       if (!initial) {
 144 |         memo = obj[index];
 145 |         initial = true;
 146 |       } else {
 147 |         memo = iterator.call(context, memo, obj[index], index, list);
 148 |       }
 149 |     });
 150 |     if (!initial) throw new TypeError(reduceError);
 151 |     return memo;
 152 |   };
 153 | 
 154 |   // Return the first value which passes a truth test. Aliased as `detect`.
 155 |   _.find = _.detect = function(obj, iterator, context) {
 156 |     var result;
 157 |     any(obj, function(value, index, list) {
 158 |       if (iterator.call(context, value, index, list)) {
 159 |         result = value;
 160 |         return true;
 161 |       }
 162 |     });
 163 |     return result;
 164 |   };
 165 | 
 166 |   // Return all the elements that pass a truth test.
 167 |   // Delegates to **ECMAScript 5**'s native `filter` if available.
 168 |   // Aliased as `select`.
 169 |   _.filter = _.select = function(obj, iterator, context) {
 170 |     var results = [];
 171 |     if (obj == null) return results;
 172 |     if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
 173 |     each(obj, function(value, index, list) {
 174 |       if (iterator.call(context, value, index, list)) results[results.length] = value;
 175 |     });
 176 |     return results;
 177 |   };
 178 | 
 179 |   // Return all the elements for which a truth test fails.
 180 |   _.reject = function(obj, iterator, context) {
 181 |     return _.filter(obj, function(value, index, list) {
 182 |       return !iterator.call(context, value, index, list);
 183 |     }, context);
 184 |   };
 185 | 
 186 |   // Determine whether all of the elements match a truth test.
 187 |   // Delegates to **ECMAScript 5**'s native `every` if available.
 188 |   // Aliased as `all`.
 189 |   _.every = _.all = function(obj, iterator, context) {
 190 |     iterator || (iterator = _.identity);
 191 |     var result = true;
 192 |     if (obj == null) return result;
 193 |     if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
 194 |     each(obj, function(value, index, list) {
 195 |       if (!(result = result && iterator.call(context, value, index, list))) return breaker;
 196 |     });
 197 |     return !!result;
 198 |   };
 199 | 
 200 |   // Determine if at least one element in the object matches a truth test.
 201 |   // Delegates to **ECMAScript 5**'s native `some` if available.
 202 |   // Aliased as `any`.
 203 |   var any = _.some = _.any = function(obj, iterator, context) {
 204 |     iterator || (iterator = _.identity);
 205 |     var result = false;
 206 |     if (obj == null) return result;
 207 |     if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
 208 |     each(obj, function(value, index, list) {
 209 |       if (result || (result = iterator.call(context, value, index, list))) return breaker;
 210 |     });
 211 |     return !!result;
 212 |   };
 213 | 
 214 |   // Determine if the array or object contains a given value (using `===`).
 215 |   // Aliased as `include`.
 216 |   _.contains = _.include = function(obj, target) {
 217 |     if (obj == null) return false;
 218 |     if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
 219 |     return any(obj, function(value) {
 220 |       return value === target;
 221 |     });
 222 |   };
 223 | 
 224 |   // Invoke a method (with arguments) on every item in a collection.
 225 |   _.invoke = function(obj, method) {
 226 |     var args = slice.call(arguments, 2);
 227 |     var isFunc = _.isFunction(method);
 228 |     return _.map(obj, function(value) {
 229 |       return (isFunc ? method : value[method]).apply(value, args);
 230 |     });
 231 |   };
 232 | 
 233 |   // Convenience version of a common use case of `map`: fetching a property.
 234 |   _.pluck = function(obj, key) {
 235 |     return _.map(obj, function(value){ return value[key]; });
 236 |   };
 237 | 
 238 |   // Convenience version of a common use case of `filter`: selecting only objects
 239 |   // containing specific `key:value` pairs.
 240 |   _.where = function(obj, attrs, first) {
 241 |     if (_.isEmpty(attrs)) return first ? null : [];
 242 |     return _[first ? 'find' : 'filter'](obj, function(value) {
 243 |       for (var key in attrs) {
 244 |         if (attrs[key] !== value[key]) return false;
 245 |       }
 246 |       return true;
 247 |     });
 248 |   };
 249 | 
 250 |   // Convenience version of a common use case of `find`: getting the first object
 251 |   // containing specific `key:value` pairs.
 252 |   _.findWhere = function(obj, attrs) {
 253 |     return _.where(obj, attrs, true);
 254 |   };
 255 | 
 256 |   // Return the maximum element or (element-based computation).
 257 |   // Can't optimize arrays of integers longer than 65,535 elements.
 258 |   // See: https://bugs.webkit.org/show_bug.cgi?id=80797
 259 |   _.max = function(obj, iterator, context) {
 260 |     if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
 261 |       return Math.max.apply(Math, obj);
 262 |     }
 263 |     if (!iterator && _.isEmpty(obj)) return -Infinity;
 264 |     var result = {computed : -Infinity, value: -Infinity};
 265 |     each(obj, function(value, index, list) {
 266 |       var computed = iterator ? iterator.call(context, value, index, list) : value;
 267 |       computed >= result.computed && (result = {value : value, computed : computed});
 268 |     });
 269 |     return result.value;
 270 |   };
 271 | 
 272 |   // Return the minimum element (or element-based computation).
 273 |   _.min = function(obj, iterator, context) {
 274 |     if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
 275 |       return Math.min.apply(Math, obj);
 276 |     }
 277 |     if (!iterator && _.isEmpty(obj)) return Infinity;
 278 |     var result = {computed : Infinity, value: Infinity};
 279 |     each(obj, function(value, index, list) {
 280 |       var computed = iterator ? iterator.call(context, value, index, list) : value;
 281 |       computed < result.computed && (result = {value : value, computed : computed});
 282 |     });
 283 |     return result.value;
 284 |   };
 285 | 
 286 |   // Shuffle an array.
 287 |   _.shuffle = function(obj) {
 288 |     var rand;
 289 |     var index = 0;
 290 |     var shuffled = [];
 291 |     each(obj, function(value) {
 292 |       rand = _.random(index++);
 293 |       shuffled[index - 1] = shuffled[rand];
 294 |       shuffled[rand] = value;
 295 |     });
 296 |     return shuffled;
 297 |   };
 298 | 
 299 |   // An internal function to generate lookup iterators.
 300 |   var lookupIterator = function(value) {
 301 |     return _.isFunction(value) ? value : function(obj){ return obj[value]; };
 302 |   };
 303 | 
 304 |   // Sort the object's values by a criterion produced by an iterator.
 305 |   _.sortBy = function(obj, value, context) {
 306 |     var iterator = lookupIterator(value);
 307 |     return _.pluck(_.map(obj, function(value, index, list) {
 308 |       return {
 309 |         value : value,
 310 |         index : index,
 311 |         criteria : iterator.call(context, value, index, list)
 312 |       };
 313 |     }).sort(function(left, right) {
 314 |       var a = left.criteria;
 315 |       var b = right.criteria;
 316 |       if (a !== b) {
 317 |         if (a > b || a === void 0) return 1;
 318 |         if (a < b || b === void 0) return -1;
 319 |       }
 320 |       return left.index < right.index ? -1 : 1;
 321 |     }), 'value');
 322 |   };
 323 | 
 324 |   // An internal function used for aggregate "group by" operations.
 325 |   var group = function(obj, value, context, behavior) {
 326 |     var result = {};
 327 |     var iterator = lookupIterator(value || _.identity);
 328 |     each(obj, function(value, index) {
 329 |       var key = iterator.call(context, value, index, obj);
 330 |       behavior(result, key, value);
 331 |     });
 332 |     return result;
 333 |   };
 334 | 
 335 |   // Groups the object's values by a criterion. Pass either a string attribute
 336 |   // to group by, or a function that returns the criterion.
 337 |   _.groupBy = function(obj, value, context) {
 338 |     return group(obj, value, context, function(result, key, value) {
 339 |       (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
 340 |     });
 341 |   };
 342 | 
 343 |   // Counts instances of an object that group by a certain criterion. Pass
 344 |   // either a string attribute to count by, or a function that returns the
 345 |   // criterion.
 346 |   _.countBy = function(obj, value, context) {
 347 |     return group(obj, value, context, function(result, key) {
 348 |       if (!_.has(result, key)) result[key] = 0;
 349 |       result[key]++;
 350 |     });
 351 |   };
 352 | 
 353 |   // Use a comparator function to figure out the smallest index at which
 354 |   // an object should be inserted so as to maintain order. Uses binary search.
 355 |   _.sortedIndex = function(array, obj, iterator, context) {
 356 |     iterator = iterator == null ? _.identity : lookupIterator(iterator);
 357 |     var value = iterator.call(context, obj);
 358 |     var low = 0, high = array.length;
 359 |     while (low < high) {
 360 |       var mid = (low + high) >>> 1;
 361 |       iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
 362 |     }
 363 |     return low;
 364 |   };
 365 | 
 366 |   // Safely convert anything iterable into a real, live array.
 367 |   _.toArray = function(obj) {
 368 |     if (!obj) return [];
 369 |     if (_.isArray(obj)) return slice.call(obj);
 370 |     if (obj.length === +obj.length) return _.map(obj, _.identity);
 371 |     return _.values(obj);
 372 |   };
 373 | 
 374 |   // Return the number of elements in an object.
 375 |   _.size = function(obj) {
 376 |     if (obj == null) return 0;
 377 |     return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
 378 |   };
 379 | 
 380 |   // Array Functions
 381 |   // ---------------
 382 | 
 383 |   // Get the first element of an array. Passing **n** will return the first N
 384 |   // values in the array. Aliased as `head` and `take`. The **guard** check
 385 |   // allows it to work with `_.map`.
 386 |   _.first = _.head = _.take = function(array, n, guard) {
 387 |     if (array == null) return void 0;
 388 |     return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
 389 |   };
 390 | 
 391 |   // Returns everything but the last entry of the array. Especially useful on
 392 |   // the arguments object. Passing **n** will return all the values in
 393 |   // the array, excluding the last N. The **guard** check allows it to work with
 394 |   // `_.map`.
 395 |   _.initial = function(array, n, guard) {
 396 |     return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
 397 |   };
 398 | 
 399 |   // Get the last element of an array. Passing **n** will return the last N
 400 |   // values in the array. The **guard** check allows it to work with `_.map`.
 401 |   _.last = function(array, n, guard) {
 402 |     if (array == null) return void 0;
 403 |     if ((n != null) && !guard) {
 404 |       return slice.call(array, Math.max(array.length - n, 0));
 405 |     } else {
 406 |       return array[array.length - 1];
 407 |     }
 408 |   };
 409 | 
 410 |   // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
 411 |   // Especially useful on the arguments object. Passing an **n** will return
 412 |   // the rest N values in the array. The **guard**
 413 |   // check allows it to work with `_.map`.
 414 |   _.rest = _.tail = _.drop = function(array, n, guard) {
 415 |     return slice.call(array, (n == null) || guard ? 1 : n);
 416 |   };
 417 | 
 418 |   // Trim out all falsy values from an array.
 419 |   _.compact = function(array) {
 420 |     return _.filter(array, _.identity);
 421 |   };
 422 | 
 423 |   // Internal implementation of a recursive `flatten` function.
 424 |   var flatten = function(input, shallow, output) {
 425 |     each(input, function(value) {
 426 |       if (_.isArray(value)) {
 427 |         shallow ? push.apply(output, value) : flatten(value, shallow, output);
 428 |       } else {
 429 |         output.push(value);
 430 |       }
 431 |     });
 432 |     return output;
 433 |   };
 434 | 
 435 |   // Return a completely flattened version of an array.
 436 |   _.flatten = function(array, shallow) {
 437 |     return flatten(array, shallow, []);
 438 |   };
 439 | 
 440 |   // Return a version of the array that does not contain the specified value(s).
 441 |   _.without = function(array) {
 442 |     return _.difference(array, slice.call(arguments, 1));
 443 |   };
 444 | 
 445 |   // Produce a duplicate-free version of the array. If the array has already
 446 |   // been sorted, you have the option of using a faster algorithm.
 447 |   // Aliased as `unique`.
 448 |   _.uniq = _.unique = function(array, isSorted, iterator, context) {
 449 |     if (_.isFunction(isSorted)) {
 450 |       context = iterator;
 451 |       iterator = isSorted;
 452 |       isSorted = false;
 453 |     }
 454 |     var initial = iterator ? _.map(array, iterator, context) : array;
 455 |     var results = [];
 456 |     var seen = [];
 457 |     each(initial, function(value, index) {
 458 |       if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
 459 |         seen.push(value);
 460 |         results.push(array[index]);
 461 |       }
 462 |     });
 463 |     return results;
 464 |   };
 465 | 
 466 |   // Produce an array that contains the union: each distinct element from all of
 467 |   // the passed-in arrays.
 468 |   _.union = function() {
 469 |     return _.uniq(concat.apply(ArrayProto, arguments));
 470 |   };
 471 | 
 472 |   // Produce an array that contains every item shared between all the
 473 |   // passed-in arrays.
 474 |   _.intersection = function(array) {
 475 |     var rest = slice.call(arguments, 1);
 476 |     return _.filter(_.uniq(array), function(item) {
 477 |       return _.every(rest, function(other) {
 478 |         return _.indexOf(other, item) >= 0;
 479 |       });
 480 |     });
 481 |   };
 482 | 
 483 |   // Take the difference between one array and a number of other arrays.
 484 |   // Only the elements present in just the first array will remain.
 485 |   _.difference = function(array) {
 486 |     var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
 487 |     return _.filter(array, function(value){ return !_.contains(rest, value); });
 488 |   };
 489 | 
 490 |   // Zip together multiple lists into a single array -- elements that share
 491 |   // an index go together.
 492 |   _.zip = function() {
 493 |     var args = slice.call(arguments);
 494 |     var length = _.max(_.pluck(args, 'length'));
 495 |     var results = new Array(length);
 496 |     for (var i = 0; i < length; i++) {
 497 |       results[i] = _.pluck(args, "" + i);
 498 |     }
 499 |     return results;
 500 |   };
 501 | 
 502 |   // Converts lists into objects. Pass either a single array of `[key, value]`
 503 |   // pairs, or two parallel arrays of the same length -- one of keys, and one of
 504 |   // the corresponding values.
 505 |   _.object = function(list, values) {
 506 |     if (list == null) return {};
 507 |     var result = {};
 508 |     for (var i = 0, l = list.length; i < l; i++) {
 509 |       if (values) {
 510 |         result[list[i]] = values[i];
 511 |       } else {
 512 |         result[list[i][0]] = list[i][1];
 513 |       }
 514 |     }
 515 |     return result;
 516 |   };
 517 | 
 518 |   // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
 519 |   // we need this function. Return the position of the first occurrence of an
 520 |   // item in an array, or -1 if the item is not included in the array.
 521 |   // Delegates to **ECMAScript 5**'s native `indexOf` if available.
 522 |   // If the array is large and already in sort order, pass `true`
 523 |   // for **isSorted** to use binary search.
 524 |   _.indexOf = function(array, item, isSorted) {
 525 |     if (array == null) return -1;
 526 |     var i = 0, l = array.length;
 527 |     if (isSorted) {
 528 |       if (typeof isSorted == 'number') {
 529 |         i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
 530 |       } else {
 531 |         i = _.sortedIndex(array, item);
 532 |         return array[i] === item ? i : -1;
 533 |       }
 534 |     }
 535 |     if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
 536 |     for (; i < l; i++) if (array[i] === item) return i;
 537 |     return -1;
 538 |   };
 539 | 
 540 |   // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
 541 |   _.lastIndexOf = function(array, item, from) {
 542 |     if (array == null) return -1;
 543 |     var hasIndex = from != null;
 544 |     if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
 545 |       return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
 546 |     }
 547 |     var i = (hasIndex ? from : array.length);
 548 |     while (i--) if (array[i] === item) return i;
 549 |     return -1;
 550 |   };
 551 | 
 552 |   // Generate an integer Array containing an arithmetic progression. A port of
 553 |   // the native Python `range()` function. See
 554 |   // [the Python documentation](http://docs.python.org/library/functions.html#range).
 555 |   _.range = function(start, stop, step) {
 556 |     if (arguments.length <= 1) {
 557 |       stop = start || 0;
 558 |       start = 0;
 559 |     }
 560 |     step = arguments[2] || 1;
 561 | 
 562 |     var len = Math.max(Math.ceil((stop - start) / step), 0);
 563 |     var idx = 0;
 564 |     var range = new Array(len);
 565 | 
 566 |     while(idx < len) {
 567 |       range[idx++] = start;
 568 |       start += step;
 569 |     }
 570 | 
 571 |     return range;
 572 |   };
 573 | 
 574 |   // Function (ahem) Functions
 575 |   // ------------------
 576 | 
 577 |   // Create a function bound to a given object (assigning `this`, and arguments,
 578 |   // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
 579 |   // available.
 580 |   _.bind = function(func, context) {
 581 |     if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
 582 |     var args = slice.call(arguments, 2);
 583 |     return function() {
 584 |       return func.apply(context, args.concat(slice.call(arguments)));
 585 |     };
 586 |   };
 587 | 
 588 |   // Partially apply a function by creating a version that has had some of its
 589 |   // arguments pre-filled, without changing its dynamic `this` context.
 590 |   _.partial = function(func) {
 591 |     var args = slice.call(arguments, 1);
 592 |     return function() {
 593 |       return func.apply(this, args.concat(slice.call(arguments)));
 594 |     };
 595 |   };
 596 | 
 597 |   // Bind all of an object's methods to that object. Useful for ensuring that
 598 |   // all callbacks defined on an object belong to it.
 599 |   _.bindAll = function(obj) {
 600 |     var funcs = slice.call(arguments, 1);
 601 |     if (funcs.length === 0) funcs = _.functions(obj);
 602 |     each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
 603 |     return obj;
 604 |   };
 605 | 
 606 |   // Memoize an expensive function by storing its results.
 607 |   _.memoize = function(func, hasher) {
 608 |     var memo = {};
 609 |     hasher || (hasher = _.identity);
 610 |     return function() {
 611 |       var key = hasher.apply(this, arguments);
 612 |       return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
 613 |     };
 614 |   };
 615 | 
 616 |   // Delays a function for the given number of milliseconds, and then calls
 617 |   // it with the arguments supplied.
 618 |   _.delay = function(func, wait) {
 619 |     var args = slice.call(arguments, 2);
 620 |     return setTimeout(function(){ return func.apply(null, args); }, wait);
 621 |   };
 622 | 
 623 |   // Defers a function, scheduling it to run after the current call stack has
 624 |   // cleared.
 625 |   _.defer = function(func) {
 626 |     return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
 627 |   };
 628 | 
 629 |   // Returns a function, that, when invoked, will only be triggered at most once
 630 |   // during a given window of time.
 631 |   _.throttle = function(func, wait) {
 632 |     var context, args, timeout, result;
 633 |     var previous = 0;
 634 |     var later = function() {
 635 |       previous = new Date;
 636 |       timeout = null;
 637 |       result = func.apply(context, args);
 638 |     };
 639 |     return function() {
 640 |       var now = new Date;
 641 |       var remaining = wait - (now - previous);
 642 |       context = this;
 643 |       args = arguments;
 644 |       if (remaining <= 0) {
 645 |         clearTimeout(timeout);
 646 |         timeout = null;
 647 |         previous = now;
 648 |         result = func.apply(context, args);
 649 |       } else if (!timeout) {
 650 |         timeout = setTimeout(later, remaining);
 651 |       }
 652 |       return result;
 653 |     };
 654 |   };
 655 | 
 656 |   // Returns a function, that, as long as it continues to be invoked, will not
 657 |   // be triggered. The function will be called after it stops being called for
 658 |   // N milliseconds. If `immediate` is passed, trigger the function on the
 659 |   // leading edge, instead of the trailing.
 660 |   _.debounce = function(func, wait, immediate) {
 661 |     var timeout, result;
 662 |     return function() {
 663 |       var context = this, args = arguments;
 664 |       var later = function() {
 665 |         timeout = null;
 666 |         if (!immediate) result = func.apply(context, args);
 667 |       };
 668 |       var callNow = immediate && !timeout;
 669 |       clearTimeout(timeout);
 670 |       timeout = setTimeout(later, wait);
 671 |       if (callNow) result = func.apply(context, args);
 672 |       return result;
 673 |     };
 674 |   };
 675 | 
 676 |   // Returns a function that will be executed at most one time, no matter how
 677 |   // often you call it. Useful for lazy initialization.
 678 |   _.once = function(func) {
 679 |     var ran = false, memo;
 680 |     return function() {
 681 |       if (ran) return memo;
 682 |       ran = true;
 683 |       memo = func.apply(this, arguments);
 684 |       func = null;
 685 |       return memo;
 686 |     };
 687 |   };
 688 | 
 689 |   // Returns the first function passed as an argument to the second,
 690 |   // allowing you to adjust arguments, run code before and after, and
 691 |   // conditionally execute the original function.
 692 |   _.wrap = function(func, wrapper) {
 693 |     return function() {
 694 |       var args = [func];
 695 |       push.apply(args, arguments);
 696 |       return wrapper.apply(this, args);
 697 |     };
 698 |   };
 699 | 
 700 |   // Returns a function that is the composition of a list of functions, each
 701 |   // consuming the return value of the function that follows.
 702 |   _.compose = function() {
 703 |     var funcs = arguments;
 704 |     return function() {
 705 |       var args = arguments;
 706 |       for (var i = funcs.length - 1; i >= 0; i--) {
 707 |         args = [funcs[i].apply(this, args)];
 708 |       }
 709 |       return args[0];
 710 |     };
 711 |   };
 712 | 
 713 |   // Returns a function that will only be executed after being called N times.
 714 |   _.after = function(times, func) {
 715 |     if (times <= 0) return func();
 716 |     return function() {
 717 |       if (--times < 1) {
 718 |         return func.apply(this, arguments);
 719 |       }
 720 |     };
 721 |   };
 722 | 
 723 |   // Object Functions
 724 |   // ----------------
 725 | 
 726 |   // Retrieve the names of an object's properties.
 727 |   // Delegates to **ECMAScript 5**'s native `Object.keys`
 728 |   _.keys = nativeKeys || function(obj) {
 729 |     if (obj !== Object(obj)) throw new TypeError('Invalid object');
 730 |     var keys = [];
 731 |     for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
 732 |     return keys;
 733 |   };
 734 | 
 735 |   // Retrieve the values of an object's properties.
 736 |   _.values = function(obj) {
 737 |     var values = [];
 738 |     for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
 739 |     return values;
 740 |   };
 741 | 
 742 |   // Convert an object into a list of `[key, value]` pairs.
 743 |   _.pairs = function(obj) {
 744 |     var pairs = [];
 745 |     for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
 746 |     return pairs;
 747 |   };
 748 | 
 749 |   // Invert the keys and values of an object. The values must be serializable.
 750 |   _.invert = function(obj) {
 751 |     var result = {};
 752 |     for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
 753 |     return result;
 754 |   };
 755 | 
 756 |   // Return a sorted list of the function names available on the object.
 757 |   // Aliased as `methods`
 758 |   _.functions = _.methods = function(obj) {
 759 |     var names = [];
 760 |     for (var key in obj) {
 761 |       if (_.isFunction(obj[key])) names.push(key);
 762 |     }
 763 |     return names.sort();
 764 |   };
 765 | 
 766 |   // Extend a given object with all the properties in passed-in object(s).
 767 |   _.extend = function(obj) {
 768 |     each(slice.call(arguments, 1), function(source) {
 769 |       if (source) {
 770 |         for (var prop in source) {
 771 |           obj[prop] = source[prop];
 772 |         }
 773 |       }
 774 |     });
 775 |     return obj;
 776 |   };
 777 | 
 778 |   // Return a copy of the object only containing the whitelisted properties.
 779 |   _.pick = function(obj) {
 780 |     var copy = {};
 781 |     var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
 782 |     each(keys, function(key) {
 783 |       if (key in obj) copy[key] = obj[key];
 784 |     });
 785 |     return copy;
 786 |   };
 787 | 
 788 |    // Return a copy of the object without the blacklisted properties.
 789 |   _.omit = function(obj) {
 790 |     var copy = {};
 791 |     var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
 792 |     for (var key in obj) {
 793 |       if (!_.contains(keys, key)) copy[key] = obj[key];
 794 |     }
 795 |     return copy;
 796 |   };
 797 | 
 798 |   // Fill in a given object with default properties.
 799 |   _.defaults = function(obj) {
 800 |     each(slice.call(arguments, 1), function(source) {
 801 |       if (source) {
 802 |         for (var prop in source) {
 803 |           if (obj[prop] == null) obj[prop] = source[prop];
 804 |         }
 805 |       }
 806 |     });
 807 |     return obj;
 808 |   };
 809 | 
 810 |   // Create a (shallow-cloned) duplicate of an object.
 811 |   _.clone = function(obj) {
 812 |     if (!_.isObject(obj)) return obj;
 813 |     return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
 814 |   };
 815 | 
 816 |   // Invokes interceptor with the obj, and then returns obj.
 817 |   // The primary purpose of this method is to "tap into" a method chain, in
 818 |   // order to perform operations on intermediate results within the chain.
 819 |   _.tap = function(obj, interceptor) {
 820 |     interceptor(obj);
 821 |     return obj;
 822 |   };
 823 | 
 824 |   // Internal recursive comparison function for `isEqual`.
 825 |   var eq = function(a, b, aStack, bStack) {
 826 |     // Identical objects are equal. `0 === -0`, but they aren't identical.
 827 |     // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
 828 |     if (a === b) return a !== 0 || 1 / a == 1 / b;
 829 |     // A strict comparison is necessary because `null == undefined`.
 830 |     if (a == null || b == null) return a === b;
 831 |     // Unwrap any wrapped objects.
 832 |     if (a instanceof _) a = a._wrapped;
 833 |     if (b instanceof _) b = b._wrapped;
 834 |     // Compare `[[Class]]` names.
 835 |     var className = toString.call(a);
 836 |     if (className != toString.call(b)) return false;
 837 |     switch (className) {
 838 |       // Strings, numbers, dates, and booleans are compared by value.
 839 |       case '[object String]':
 840 |         // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
 841 |         // equivalent to `new String("5")`.
 842 |         return a == String(b);
 843 |       case '[object Number]':
 844 |         // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
 845 |         // other numeric values.
 846 |         return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
 847 |       case '[object Date]':
 848 |       case '[object Boolean]':
 849 |         // Coerce dates and booleans to numeric primitive values. Dates are compared by their
 850 |         // millisecond representations. Note that invalid dates with millisecond representations
 851 |         // of `NaN` are not equivalent.
 852 |         return +a == +b;
 853 |       // RegExps are compared by their source patterns and flags.
 854 |       case '[object RegExp]':
 855 |         return a.source == b.source &&
 856 |                a.global == b.global &&
 857 |                a.multiline == b.multiline &&
 858 |                a.ignoreCase == b.ignoreCase;
 859 |     }
 860 |     if (typeof a != 'object' || typeof b != 'object') return false;
 861 |     // Assume equality for cyclic structures. The algorithm for detecting cyclic
 862 |     // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
 863 |     var length = aStack.length;
 864 |     while (length--) {
 865 |       // Linear search. Performance is inversely proportional to the number of
 866 |       // unique nested structures.
 867 |       if (aStack[length] == a) return bStack[length] == b;
 868 |     }
 869 |     // Add the first object to the stack of traversed objects.
 870 |     aStack.push(a);
 871 |     bStack.push(b);
 872 |     var size = 0, result = true;
 873 |     // Recursively compare objects and arrays.
 874 |     if (className == '[object Array]') {
 875 |       // Compare array lengths to determine if a deep comparison is necessary.
 876 |       size = a.length;
 877 |       result = size == b.length;
 878 |       if (result) {
 879 |         // Deep compare the contents, ignoring non-numeric properties.
 880 |         while (size--) {
 881 |           if (!(result = eq(a[size], b[size], aStack, bStack))) break;
 882 |         }
 883 |       }
 884 |     } else {
 885 |       // Objects with different constructors are not equivalent, but `Object`s
 886 |       // from different frames are.
 887 |       var aCtor = a.constructor, bCtor = b.constructor;
 888 |       if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
 889 |                                _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
 890 |         return false;
 891 |       }
 892 |       // Deep compare objects.
 893 |       for (var key in a) {
 894 |         if (_.has(a, key)) {
 895 |           // Count the expected number of properties.
 896 |           size++;
 897 |           // Deep compare each member.
 898 |           if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
 899 |         }
 900 |       }
 901 |       // Ensure that both objects contain the same number of properties.
 902 |       if (result) {
 903 |         for (key in b) {
 904 |           if (_.has(b, key) && !(size--)) break;
 905 |         }
 906 |         result = !size;
 907 |       }
 908 |     }
 909 |     // Remove the first object from the stack of traversed objects.
 910 |     aStack.pop();
 911 |     bStack.pop();
 912 |     return result;
 913 |   };
 914 | 
 915 |   // Perform a deep comparison to check if two objects are equal.
 916 |   _.isEqual = function(a, b) {
 917 |     return eq(a, b, [], []);
 918 |   };
 919 | 
 920 |   // Is a given array, string, or object empty?
 921 |   // An "empty" object has no enumerable own-properties.
 922 |   _.isEmpty = function(obj) {
 923 |     if (obj == null) return true;
 924 |     if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
 925 |     for (var key in obj) if (_.has(obj, key)) return false;
 926 |     return true;
 927 |   };
 928 | 
 929 |   // Is a given value a DOM element?
 930 |   _.isElement = function(obj) {
 931 |     return !!(obj && obj.nodeType === 1);
 932 |   };
 933 | 
 934 |   // Is a given value an array?
 935 |   // Delegates to ECMA5's native Array.isArray
 936 |   _.isArray = nativeIsArray || function(obj) {
 937 |     return toString.call(obj) == '[object Array]';
 938 |   };
 939 | 
 940 |   // Is a given variable an object?
 941 |   _.isObject = function(obj) {
 942 |     return obj === Object(obj);
 943 |   };
 944 | 
 945 |   // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
 946 |   each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
 947 |     _['is' + name] = function(obj) {
 948 |       return toString.call(obj) == '[object ' + name + ']';
 949 |     };
 950 |   });
 951 | 
 952 |   // Define a fallback version of the method in browsers (ahem, IE), where
 953 |   // there isn't any inspectable "Arguments" type.
 954 |   if (!_.isArguments(arguments)) {
 955 |     _.isArguments = function(obj) {
 956 |       return !!(obj && _.has(obj, 'callee'));
 957 |     };
 958 |   }
 959 | 
 960 |   // Optimize `isFunction` if appropriate.
 961 |   if (typeof (/./) !== 'function') {
 962 |     _.isFunction = function(obj) {
 963 |       return typeof obj === 'function';
 964 |     };
 965 |   }
 966 | 
 967 |   // Is a given object a finite number?
 968 |   _.isFinite = function(obj) {
 969 |     return isFinite(obj) && !isNaN(parseFloat(obj));
 970 |   };
 971 | 
 972 |   // Is the given value `NaN`? (NaN is the only number which does not equal itself).
 973 |   _.isNaN = function(obj) {
 974 |     return _.isNumber(obj) && obj != +obj;
 975 |   };
 976 | 
 977 |   // Is a given value a boolean?
 978 |   _.isBoolean = function(obj) {
 979 |     return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
 980 |   };
 981 | 
 982 |   // Is a given value equal to null?
 983 |   _.isNull = function(obj) {
 984 |     return obj === null;
 985 |   };
 986 | 
 987 |   // Is a given variable undefined?
 988 |   _.isUndefined = function(obj) {
 989 |     return obj === void 0;
 990 |   };
 991 | 
 992 |   // Shortcut function for checking if an object has a given property directly
 993 |   // on itself (in other words, not on a prototype).
 994 |   _.has = function(obj, key) {
 995 |     return hasOwnProperty.call(obj, key);
 996 |   };
 997 | 
 998 |   // Utility Functions
 999 |   // -----------------
1000 | 
1001 |   // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
1002 |   // previous owner. Returns a reference to the Underscore object.
1003 |   _.noConflict = function() {
1004 |     root._ = previousUnderscore;
1005 |     return this;
1006 |   };
1007 | 
1008 |   // Keep the identity function around for default iterators.
1009 |   _.identity = function(value) {
1010 |     return value;
1011 |   };
1012 | 
1013 |   // Run a function **n** times.
1014 |   _.times = function(n, iterator, context) {
1015 |     var accum = Array(n);
1016 |     for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
1017 |     return accum;
1018 |   };
1019 | 
1020 |   // Return a random integer between min and max (inclusive).
1021 |   _.random = function(min, max) {
1022 |     if (max == null) {
1023 |       max = min;
1024 |       min = 0;
1025 |     }
1026 |     return min + Math.floor(Math.random() * (max - min + 1));
1027 |   };
1028 | 
1029 |   // List of HTML entities for escaping.
1030 |   var entityMap = {
1031 |     escape: {
1032 |       '&': '&amp;',
1033 |       '<': '&lt;',
1034 |       '>': '&gt;',
1035 |       '"': '&quot;',
1036 |       "'": '&#x27;',
1037 |       '/': '&#x2F;'
1038 |     }
1039 |   };
1040 |   entityMap.unescape = _.invert(entityMap.escape);
1041 | 
1042 |   // Regexes containing the keys and values listed immediately above.
1043 |   var entityRegexes = {
1044 |     escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
1045 |     unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
1046 |   };
1047 | 
1048 |   // Functions for escaping and unescaping strings to/from HTML interpolation.
1049 |   _.each(['escape', 'unescape'], function(method) {
1050 |     _[method] = function(string) {
1051 |       if (string == null) return '';
1052 |       return ('' + string).replace(entityRegexes[method], function(match) {
1053 |         return entityMap[method][match];
1054 |       });
1055 |     };
1056 |   });
1057 | 
1058 |   // If the value of the named property is a function then invoke it;
1059 |   // otherwise, return it.
1060 |   _.result = function(object, property) {
1061 |     if (object == null) return null;
1062 |     var value = object[property];
1063 |     return _.isFunction(value) ? value.call(object) : value;
1064 |   };
1065 | 
1066 |   // Add your own custom functions to the Underscore object.
1067 |   _.mixin = function(obj) {
1068 |     each(_.functions(obj), function(name){
1069 |       var func = _[name] = obj[name];
1070 |       _.prototype[name] = function() {
1071 |         var args = [this._wrapped];
1072 |         push.apply(args, arguments);
1073 |         return result.call(this, func.apply(_, args));
1074 |       };
1075 |     });
1076 |   };
1077 | 
1078 |   // Generate a unique integer id (unique within the entire client session).
1079 |   // Useful for temporary DOM ids.
1080 |   var idCounter = 0;
1081 |   _.uniqueId = function(prefix) {
1082 |     var id = ++idCounter + '';
1083 |     return prefix ? prefix + id : id;
1084 |   };
1085 | 
1086 |   // By default, Underscore uses ERB-style template delimiters, change the
1087 |   // following template settings to use alternative delimiters.
1088 |   _.templateSettings = {
1089 |     evaluate    : /<%([\s\S]+?)%>/g,
1090 |     interpolate : /<%=([\s\S]+?)%>/g,
1091 |     escape      : /<%-([\s\S]+?)%>/g
1092 |   };
1093 | 
1094 |   // When customizing `templateSettings`, if you don't want to define an
1095 |   // interpolation, evaluation or escaping regex, we need one that is
1096 |   // guaranteed not to match.
1097 |   var noMatch = /(.)^/;
1098 | 
1099 |   // Certain characters need to be escaped so that they can be put into a
1100 |   // string literal.
1101 |   var escapes = {
1102 |     "'":      "'",
1103 |     '\\':     '\\',
1104 |     '\r':     'r',
1105 |     '\n':     'n',
1106 |     '\t':     't',
1107 |     '\u2028': 'u2028',
1108 |     '\u2029': 'u2029'
1109 |   };
1110 | 
1111 |   var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
1112 | 
1113 |   // JavaScript micro-templating, similar to John Resig's implementation.
1114 |   // Underscore templating handles arbitrary delimiters, preserves whitespace,
1115 |   // and correctly escapes quotes within interpolated code.
1116 |   _.template = function(text, data, settings) {
1117 |     var render;
1118 |     settings = _.defaults({}, settings, _.templateSettings);
1119 | 
1120 |     // Combine delimiters into one regular expression via alternation.
1121 |     var matcher = new RegExp([
1122 |       (settings.escape || noMatch).source,
1123 |       (settings.interpolate || noMatch).source,
1124 |       (settings.evaluate || noMatch).source
1125 |     ].join('|') + '|$', 'g');
1126 | 
1127 |     // Compile the template source, escaping string literals appropriately.
1128 |     var index = 0;
1129 |     var source = "__p+='";
1130 |     text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
1131 |       source += text.slice(index, offset)
1132 |         .replace(escaper, function(match) { return '\\' + escapes[match]; });
1133 | 
1134 |       if (escape) {
1135 |         source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
1136 |       }
1137 |       if (interpolate) {
1138 |         source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
1139 |       }
1140 |       if (evaluate) {
1141 |         source += "';\n" + evaluate + "\n__p+='";
1142 |       }
1143 |       index = offset + match.length;
1144 |       return match;
1145 |     });
1146 |     source += "';\n";
1147 | 
1148 |     // If a variable is not specified, place data values in local scope.
1149 |     if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
1150 | 
1151 |     source = "var __t,__p='',__j=Array.prototype.join," +
1152 |       "print=function(){__p+=__j.call(arguments,'');};\n" +
1153 |       source + "return __p;\n";
1154 | 
1155 |     try {
1156 |       render = new Function(settings.variable || 'obj', '_', source);
1157 |     } catch (e) {
1158 |       e.source = source;
1159 |       throw e;
1160 |     }
1161 | 
1162 |     if (data) return render(data, _);
1163 |     var template = function(data) {
1164 |       return render.call(this, data, _);
1165 |     };
1166 | 
1167 |     // Provide the compiled function source as a convenience for precompilation.
1168 |     template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
1169 | 
1170 |     return template;
1171 |   };
1172 | 
1173 |   // Add a "chain" function, which will delegate to the wrapper.
1174 |   _.chain = function(obj) {
1175 |     return _(obj).chain();
1176 |   };
1177 | 
1178 |   // OOP
1179 |   // ---------------
1180 |   // If Underscore is called as a function, it returns a wrapped object that
1181 |   // can be used OO-style. This wrapper holds altered versions of all the
1182 |   // underscore functions. Wrapped objects may be chained.
1183 | 
1184 |   // Helper function to continue chaining intermediate results.
1185 |   var result = function(obj) {
1186 |     return this._chain ? _(obj).chain() : obj;
1187 |   };
1188 | 
1189 |   // Add all of the Underscore functions to the wrapper object.
1190 |   _.mixin(_);
1191 | 
1192 |   // Add all mutator Array functions to the wrapper.
1193 |   each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
1194 |     var method = ArrayProto[name];
1195 |     _.prototype[name] = function() {
1196 |       var obj = this._wrapped;
1197 |       method.apply(obj, arguments);
1198 |       if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
1199 |       return result.call(this, obj);
1200 |     };
1201 |   });
1202 | 
1203 |   // Add all accessor Array functions to the wrapper.
1204 |   each(['concat', 'join', 'slice'], function(name) {
1205 |     var method = ArrayProto[name];
1206 |     _.prototype[name] = function() {
1207 |       return result.call(this, method.apply(this._wrapped, arguments));
1208 |     };
1209 |   });
1210 | 
1211 |   _.extend(_.prototype, {
1212 | 
1213 |     // Start chaining a wrapped Underscore object.
1214 |     chain: function() {
1215 |       this._chain = true;
1216 |       return this;
1217 |     },
1218 | 
1219 |     // Extracts the result from a wrapped and chained object.
1220 |     value: function() {
1221 |       return this._wrapped;
1222 |     }
1223 | 
1224 |   });
1225 | 
1226 |   // AMD define happens at the end for compatibility with AMD loaders
1227 |   // that don't enforce next-turn semantics on modules.
1228 |   if (typeof define === 'function' && define.amd) {
1229 |     define('underscore', function() {
1230 |       return _;
1231 |     });
1232 |   }
1233 | 
1234 | }).call(this);
1235 | 


--------------------------------------------------------------------------------
/web/public/js/main.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   requirejs.config({
 4 |     baseUrl: 'js',
 5 |     paths: {
 6 |       'backbone': 'lib/backbone',
 7 |       'backbone.babysitter': 'lib/backbone.babysitter',
 8 |       'backbone.wreqr': 'lib/backbone.wreqr',
 9 |       'jade': 'templates/jade',
10 |       'jquery': 'lib/jquery',
11 |       'marionette': 'lib/backbone.marionette',
12 |       'underscore': 'lib/underscore'
13 |     },
14 |     shim: {}
15 |   });
16 | 
17 |   require(['app'], function(app) {
18 |     return app.start();
19 |   });
20 | 
21 | }).call(this);
22 | 


--------------------------------------------------------------------------------
/web/public/js/models/todo.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   define(function(require) {
 4 |     var Backbone;
 5 |     Backbone = require('backbone');
 6 |     return Backbone.Model.extend({
 7 |       urlRoot: '/todos/'
 8 |     });
 9 |   });
10 | 
11 | }).call(this);
12 | 


--------------------------------------------------------------------------------
/web/public/js/router.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   define(function(require) {
 4 |     var Marionette, Router, TodoListView;
 5 |     Marionette = require('marionette');
 6 |     TodoListView = require('views/todolist');
 7 |     Router = Marionette.AppRouter.extend({
 8 |       routes: {
 9 |         '': 'index'
10 |       },
11 |       index: function() {
12 |         var app;
13 |         app = require('app');
14 |         return app.content.show(new TodoListView());
15 |       }
16 |     });
17 |     return new Router();
18 |   });
19 | 
20 | }).call(this);
21 | 


--------------------------------------------------------------------------------
/web/public/js/templates/jade.js:
--------------------------------------------------------------------------------
  1 | define([], function(){
  2 |   var exports = {};
  3 |   
  4 | /*!
  5 |  * Jade - runtime
  6 |  * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
  7 |  * MIT Licensed
  8 |  */
  9 | 
 10 | /**
 11 |  * Lame Array.isArray() polyfill for now.
 12 |  */
 13 | 
 14 | if (!Array.isArray) {
 15 |   Array.isArray = function(arr){
 16 |     return '[object Array]' == Object.prototype.toString.call(arr);
 17 |   };
 18 | }
 19 | 
 20 | /**
 21 |  * Lame Object.keys() polyfill for now.
 22 |  */
 23 | 
 24 | if (!Object.keys) {
 25 |   Object.keys = function(obj){
 26 |     var arr = [];
 27 |     for (var key in obj) {
 28 |       if (obj.hasOwnProperty(key)) {
 29 |         arr.push(key);
 30 |       }
 31 |     }
 32 |     return arr;
 33 |   }
 34 | }
 35 | 
 36 | /**
 37 |  * Merge two attribute objects giving precedence
 38 |  * to values in object `b`. Classes are special-cased
 39 |  * allowing for arrays and merging/joining appropriately
 40 |  * resulting in a string.
 41 |  *
 42 |  * @param {Object} a
 43 |  * @param {Object} b
 44 |  * @return {Object} a
 45 |  * @api private
 46 |  */
 47 | 
 48 | exports.merge = function merge(a, b) {
 49 |   var ac = a['class'];
 50 |   var bc = b['class'];
 51 | 
 52 |   if (ac || bc) {
 53 |     ac = ac || [];
 54 |     bc = bc || [];
 55 |     if (!Array.isArray(ac)) ac = [ac];
 56 |     if (!Array.isArray(bc)) bc = [bc];
 57 |     ac = ac.filter(nulls);
 58 |     bc = bc.filter(nulls);
 59 |     a['class'] = ac.concat(bc).join(' ');
 60 |   }
 61 | 
 62 |   for (var key in b) {
 63 |     if (key != 'class') {
 64 |       a[key] = b[key];
 65 |     }
 66 |   }
 67 | 
 68 |   return a;
 69 | };
 70 | 
 71 | /**
 72 |  * Filter null `val`s.
 73 |  *
 74 |  * @param {Mixed} val
 75 |  * @return {Mixed}
 76 |  * @api private
 77 |  */
 78 | 
 79 | function nulls(val) {
 80 |   return val != null;
 81 | }
 82 | 
 83 | /**
 84 |  * Render the given attributes object.
 85 |  *
 86 |  * @param {Object} obj
 87 |  * @param {Object} escaped
 88 |  * @return {String}
 89 |  * @api private
 90 |  */
 91 | 
 92 | exports.attrs = function attrs(obj, escaped){
 93 |   var buf = []
 94 |     , terse = obj.terse;
 95 | 
 96 |   delete obj.terse;
 97 |   var keys = Object.keys(obj)
 98 |     , len = keys.length;
 99 | 
100 |   if (len) {
101 |     buf.push('');
102 |     for (var i = 0; i < len; ++i) {
103 |       var key = keys[i]
104 |         , val = obj[key];
105 | 
106 |       if ('boolean' == typeof val || null == val) {
107 |         if (val) {
108 |           terse
109 |             ? buf.push(key)
110 |             : buf.push(key + '="' + key + '"');
111 |         }
112 |       } else if (0 == key.indexOf('data') && 'string' != typeof val) {
113 |         buf.push(key + "='" + JSON.stringify(val) + "'");
114 |       } else if ('class' == key && Array.isArray(val)) {
115 |         buf.push(key + '="' + exports.escape(val.join(' ')) + '"');
116 |       } else if (escaped && escaped[key]) {
117 |         buf.push(key + '="' + exports.escape(val) + '"');
118 |       } else {
119 |         buf.push(key + '="' + val + '"');
120 |       }
121 |     }
122 |   }
123 | 
124 |   return buf.join(' ');
125 | };
126 | 
127 | /**
128 |  * Escape the given string of `html`.
129 |  *
130 |  * @param {String} html
131 |  * @return {String}
132 |  * @api private
133 |  */
134 | 
135 | exports.escape = function escape(html){
136 |   return String(html)
137 |     .replace(/&(?!(\w+|\#\d+);)/g, '&amp;')
138 |     .replace(/</g, '&lt;')
139 |     .replace(/>/g, '&gt;')
140 |     .replace(/"/g, '&quot;');
141 | };
142 | 
143 | /**
144 |  * Re-throw the given `err` in context to the
145 |  * the jade in `filename` at the given `lineno`.
146 |  *
147 |  * @param {Error} err
148 |  * @param {String} filename
149 |  * @param {String} lineno
150 |  * @api private
151 |  */
152 | 
153 | exports.rethrow = function rethrow(err, filename, lineno){
154 |   if (!filename) throw err;
155 | 
156 |   var context = 3
157 |     , str = require('fs').readFileSync(filename, 'utf8')
158 |     , lines = str.split('\n')
159 |     , start = Math.max(lineno - context, 0)
160 |     , end = Math.min(lines.length, lineno + context);
161 | 
162 |   // Error context
163 |   var context = lines.slice(start, end).map(function(line, i){
164 |     var curr = i + start + 1;
165 |     return (curr == lineno ? '  > ' : '    ')
166 |       + curr
167 |       + '| '
168 |       + line;
169 |   }).join('\n');
170 | 
171 |   // Alter exception message
172 |   err.path = filename;
173 |   err.message = (filename || 'Jade') + ':' + lineno
174 |     + '\n' + context + '\n\n' + err.message;
175 |   throw err;
176 | };
177 | 
178 |   return exports;
179 | });


--------------------------------------------------------------------------------
/web/public/js/templates/template.js:
--------------------------------------------------------------------------------
 1 | define(['jade'], function(jade) { if(jade && jade['runtime'] !== undefined) { jade = jade.runtime; }
 2 | 
 3 | return function anonymous(locals, attrs, escape, rethrow, merge) {
 4 | attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
 5 | var __jade = [{ lineno: 1, filename: "web/templates/template.jade" }];
 6 | try {
 7 | var buf = [];
 8 | with (locals || {}) {
 9 | var interp;
10 | __jade.unshift({ lineno: 1, filename: __jade[0].filename });
11 | __jade.unshift({ lineno: 1, filename: __jade[0].filename });
12 | buf.push('<p>');
13 | __jade.unshift({ lineno: undefined, filename: __jade[0].filename });
14 | __jade.unshift({ lineno: 1, filename: __jade[0].filename });
15 | buf.push('Welcome to TodoList');
16 | __jade.shift();
17 | __jade.shift();
18 | buf.push('</p>');
19 | __jade.shift();
20 | __jade.shift();
21 | }
22 | return buf.join("");
23 | } catch (err) {
24 |   rethrow(err, __jade[0].filename, __jade[0].lineno);
25 | }
26 | }
27 | 
28 | });


--------------------------------------------------------------------------------
/web/public/js/templates/todo.js:
--------------------------------------------------------------------------------
 1 | define(['jade'], function(jade) { if(jade && jade['runtime'] !== undefined) { jade = jade.runtime; }
 2 | 
 3 | return function anonymous(locals, attrs, escape, rethrow, merge) {
 4 | attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
 5 | var __jade = [{ lineno: 1, filename: "web/templates/todo.jade" }];
 6 | try {
 7 | var buf = [];
 8 | with (locals || {}) {
 9 | var interp;
10 | __jade.unshift({ lineno: 1, filename: __jade[0].filename });
11 | __jade.unshift({ lineno: 1, filename: __jade[0].filename });
12 | buf.push('<p>');
13 | var __val__ = title
14 | buf.push(escape(null == __val__ ? "" : __val__));
15 | __jade.unshift({ lineno: undefined, filename: __jade[0].filename });
16 | __jade.shift();
17 | buf.push('</p>');
18 | __jade.shift();
19 | __jade.shift();
20 | }
21 | return buf.join("");
22 | } catch (err) {
23 |   rethrow(err, __jade[0].filename, __jade[0].lineno);
24 | }
25 | }
26 | 
27 | });


--------------------------------------------------------------------------------
/web/public/js/views/template.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   define(function(require) {
 4 |     var $, Marionette;
 5 |     $ = require('jquery');
 6 |     Marionette = require('marionette');
 7 |     return Marionette.ItemView.extend({
 8 |       template: require('templates/template')
 9 |     });
10 |   });
11 | 
12 | }).call(this);
13 | 


--------------------------------------------------------------------------------
/web/public/js/views/todo.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   define(function(require) {
 4 |     var $, Marionette;
 5 |     $ = require('jquery');
 6 |     Marionette = require('marionette');
 7 |     return Marionette.ItemView.extend({
 8 |       template: require('templates/todo')
 9 |     });
10 |   });
11 | 
12 | }).call(this);
13 | 


--------------------------------------------------------------------------------
/web/public/js/views/todolist.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 | 
 3 |   define(function(require) {
 4 |     var $, Backbone, Marionette, TodoCollection, TodoModel, TodoView;
 5 |     $ = require('jquery');
 6 |     Backbone = require('backbone');
 7 |     Marionette = require('marionette');
 8 |     TodoModel = require('models/todo');
 9 |     TodoView = require('views/todo');
10 |     TodoCollection = Backbone.Collection.extend({
11 |       model: TodoModel,
12 |       url: '/todos/'
13 |     });
14 |     return Marionette.CollectionView.extend({
15 |       itemView: TodoView,
16 |       template: require('templates/todo'),
17 |       collection: new TodoCollection(),
18 |       initialize: function() {
19 |         return this.collection.fetch();
20 |       }
21 |     });
22 |   });
23 | 
24 | }).call(this);
25 | 


--------------------------------------------------------------------------------
/web/router.coffee:
--------------------------------------------------------------------------------
 1 | define((require) ->
 2 |   Marionette = require('marionette')
 3 |   TodoListView = require('views/todolist')
 4 |   
 5 |   Router = Marionette.AppRouter.extend({
 6 |     routes: {
 7 |       '': 'index'
 8 |     }
 9 |     index: () ->
10 |       app = require('app')
11 |       app.content.show(new TodoListView())
12 |   })
13 | 
14 |   return new Router()
15 | )
16 | 


--------------------------------------------------------------------------------
/web/templates/template.jade:
--------------------------------------------------------------------------------
1 | p Welcome to TodoList
2 | 


--------------------------------------------------------------------------------
/web/templates/todo.jade:
--------------------------------------------------------------------------------
1 | p= title
2 | 


--------------------------------------------------------------------------------
/web/views/.template.coffee.swp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rudolf/webapp-boilerplate/cb7ba9a88511539a447618b01fd1986fe1bd2028/web/views/.template.coffee.swp


--------------------------------------------------------------------------------
/web/views/template.coffee:
--------------------------------------------------------------------------------
1 | define((require) ->
2 |   $ = require('jquery')
3 |   Marionette = require('marionette')
4 | 
5 |   return Marionette.ItemView.extend({
6 |     template: require('templates/template')
7 |   })
8 | )
9 | 


--------------------------------------------------------------------------------
/web/views/todo.coffee:
--------------------------------------------------------------------------------
1 | define((require) ->
2 |   $ = require('jquery')
3 |   Marionette = require('marionette')
4 | 
5 |   return Marionette.ItemView.extend({
6 |     template: require('templates/todo')
7 |   })
8 | )
9 | 


--------------------------------------------------------------------------------
/web/views/todolist.coffee:
--------------------------------------------------------------------------------
 1 | define((require) ->
 2 |   $ = require('jquery')
 3 |   Backbone = require('backbone')
 4 |   Marionette = require('marionette')
 5 |   TodoModel = require('models/todo')
 6 |   TodoView = require('views/todo')
 7 | 
 8 |   TodoCollection = Backbone.Collection.extend({
 9 |     model: TodoModel
10 |     url: '/todos/'
11 |   })
12 | 
13 |   return Marionette.CollectionView.extend({
14 |     itemView: TodoView
15 |     template: require('templates/todo')
16 |     collection: new TodoCollection()
17 |     initialize: () ->
18 |       @.collection.fetch()
19 |   })
20 | )
21 | 


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