├── __init__.py
├── items
    ├── __init__.py
    ├── static
    │   ├── img
    │   │   └── destroy.png
    │   ├── js
    │   │   ├── todos.js
    │   │   ├── json2.js
    │   │   ├── underscore.js
    │   │   └── backbone.js
    │   └── css
    │   │   └── todos.css
    ├── models.py
    ├── tests.py
    └── views.py
├── .gitignore
├── README.md
├── urls.py
├── index.html
└── settings.py


/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/items/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | secret_key.py
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 | ## Backbone.js + Django (v 1.1.1)
3 | 


--------------------------------------------------------------------------------
/items/static/img/destroy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ccarpenterg/djangotodos/HEAD/items/static/img/destroy.png


--------------------------------------------------------------------------------
/urls.py:
--------------------------------------------------------------------------------
 1 | from django.conf.urls.defaults import *
 2 | from django.conf import settings
 3 | from django.contrib import admin
 4 | admin.autodiscover()
 5 | 
 6 | urlpatterns = patterns('',
 7 |     (r'^$', 'items.views.index'),
 8 |     (r'^todos\/?(?P<item_id>\d*)$', 'items.views.restful'),
 9 |     (r'^static/(?P<path>.*)$', 'django.views.static.serve', {'document_root': '/home/django/todos/items/static/'}),
10 |     (r'^admin/', include(admin.site.urls)),
11 | )
12 | 
13 | 


--------------------------------------------------------------------------------
/items/models.py:
--------------------------------------------------------------------------------
 1 | from django.db import models
 2 | 
 3 | # Create your models here.
 4 | 
 5 | class TodoList(models.Model):
 6 |     createdon = models.DateTimeField(auto_now_add=True)
 7 | 
 8 | class Todo(models.Model):
 9 |     todolist = models.ForeignKey(TodoList)
10 |     order    = models.IntegerField()
11 |     content  = models.CharField(max_length=256)
12 |     done     = models.BooleanField()
13 | 
14 |     def toDict(self):
15 | 	todo = {
16 | 	    'id': self.id,
17 | 	    'order': self.order,
18 | 	    'content': self.content,
19 | 	    'done': self.done
20 | 	    }
21 | 	return todo
22 | 


--------------------------------------------------------------------------------
/items/tests.py:
--------------------------------------------------------------------------------
 1 | """
 2 | This file demonstrates two different styles of tests (one doctest and one
 3 | unittest). These will both pass when you run "manage.py test".
 4 | 
 5 | Replace these with more appropriate tests for your application.
 6 | """
 7 | 
 8 | from django.test import TestCase
 9 | 
10 | class SimpleTest(TestCase):
11 |     def test_basic_addition(self):
12 |         """
13 |         Tests that 1 + 1 always equals 2.
14 |         """
15 |         self.failUnlessEqual(1 + 1, 2)
16 | 
17 | __test__ = {"doctest": """
18 | Another way to test that 1 + 1 is equal to 2.
19 | 
20 | >>> 1 + 1 == 2
21 | True
22 | """}
23 | 
24 | 


--------------------------------------------------------------------------------
/items/views.py:
--------------------------------------------------------------------------------
 1 | # Create your views here.
 2 | 
 3 | from items.models import TodoList, Todo
 4 | from django.http import HttpResponse, QueryDict, HttpResponseForbidden
 5 | from django.shortcuts import render_to_response
 6 | from django.template import loader, Context
 7 | import json, Cookie
 8 | 
 9 | from datetime import datetime
10 | 
11 | def get(request, item_id):
12 |     id = request.COOKIES['todos']
13 |     todos = []
14 |     for todo in Todo.objects.filter(todolist=id):
15 | 	todos.append(todo.toDict())
16 |     todos = json.dumps(todos)
17 |     response = HttpResponse()
18 |     #response['Content-Type'] = 'application/json'
19 |     response.write(todos)
20 |     return response
21 | 
22 | def post(request, item_id):
23 |     id = request.COOKIES['todos']
24 |     todolist = TodoList.objects.get(id=int(id))
25 |     todo = json.loads(request.raw_post_data)
26 |     todo = Todo(todolist = todolist,
27 | 		order    = int(todo['order']),
28 | 		content  = todo['content'],
29 | 		done     = todo['done'])
30 |     todo.save()
31 |     todo = json.dumps(todo.toDict())
32 |     response = HttpResponse()
33 |     response.write(todo)
34 |     return response
35 | 
36 | def put(request, item_id):
37 |     id = request.COOKIES['todos']
38 |     todolist = TodoList.objects.get(id=id)
39 |     todo = Todo.objects.get(id=item_id)
40 |     if todo.todolist == todolist:
41 | 	tmp = json.loads(request.raw_post_data)
42 | 	todo.content = tmp['content']
43 | 	todo.done    = tmp['done']
44 | 	todo.save()
45 | 	todo = json.dumps(todo.toDict())
46 | 	response = HttpResponse()
47 | 	response.write(todo)
48 | 	return response
49 |     else:
50 | 	return HttpResponseForbidden()
51 | 
52 | def delete(request, item_id):
53 |     id = request.COOKIES['todos']
54 |     todolist = TodoList.objects.get(id=id)
55 |     todo = Todo.objects.get(id=item_id)
56 |     if todo.todolist == todolist:
57 | 	todo.delete()
58 | 	return HttpResponse()
59 |     else:
60 | 	return HttpResponseForbidden()
61 | 
62 | methods = {
63 | 	'GET': get,
64 | 	'POST': post,
65 | 	'PUT': put,
66 | 	'DELETE': delete
67 | 	}
68 | 
69 | def restful(request, item_id):
70 |     return methods[request.method](request, item_id)
71 | 
72 | def index(request):
73 |     response = HttpResponse()
74 |     if 'todos' not in request.COOKIES:
75 | 	todolist = TodoList()
76 | 	todolist.save()
77 | 	cookie = Cookie.SimpleCookie()
78 | 	cookie['todos'] = todolist.id
79 | 	cookie['todos']['expires'] = datetime(2014, 1, 1).strftime('%a, %d %b %Y %H:%M:%S')
80 | 	cookie['todos']['path'] ='/'
81 | 	response['Set-Cookie'] = cookie['todos'].OutputString()
82 |     template = loader.get_template('index.html')
83 |     context = Context({'x': 'x'})
84 |     response.write(template.render(context))
85 |     return response
86 |     #return render_to_response('index.html')
87 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | 
 4 |   <head>
 5 |     <title>Backbone.js + Django | Todos example</title>
 6 |     <link href="/static/css/todos.css" media="all" rel="stylesheet" type="text/css"/>
 7 |     <script src="/static/js/json2.js" type="text/javascript"></script>
 8 |     <script src="/static/js/jquery-1.4.2.js" type="text/javascript"></script>
 9 |     <script src="/static/js/underscore.js" type="text/javascript"></script>
10 |     <script src="/static/js/backbone.js" type="text/javascript"></script>
11 |     <script src="/static/js/todos.js" type="text/javascript"></script>
12 |   </head>
13 | 
14 |   <body>
15 | 
16 |     <!-- Todo App Interface -->
17 | 
18 |     <div id="todoapp">
19 | 
20 |       <div class="title">
21 |         <h1>Todos</h1>
22 |       </div>
23 | 
24 |       <div class="content">
25 | 
26 |         <div id="create-todo">
27 |           <input id="new-todo" placeholder="What needs to be done?" type="text" />
28 |           <span class="ui-tooltip-top" style="display:none;">Press Enter to save this task</span>
29 |         </div>
30 | 
31 |         <div id="todos">
32 |           <ul id="todo-list"></ul>
33 |         </div>
34 | 
35 |         <div id="todo-stats"></div>
36 | 
37 |       </div>
38 | 
39 |     </div>
40 | 
41 |     <ul id="instructions">
42 |       <li>Double-click to edit a todo.</li>
43 |       <li><a href="https://github.com/ccarpenterg/djangotodos">View the source.</a></li>
44 |     </ul>
45 | 
46 |     <div id="credits">
47 |       UI (Backbone.js app and html/css) created by
48 |       <br />
49 |       <a href="http://jgn.me/">J&eacute;r&ocirc;me Gravel-Niquet</a>
50 |     </div>
51 | 
52 |     <div id="credits">
53 |       Django app created by
54 |       <br />
55 |       <a href="http://ccarpenterg.posterous.com">Cristian Carpenter</a>
56 |     </div>
57 | 
58 | 
59 |     <!-- Templates -->
60 | 
61 |     <script type="text/template" id="item-template">
62 |       <div class="todo <%= done ? 'done' : '' %>">
63 |         <div class="display">
64 |           <input class="check" type="checkbox" <%= done ? 'checked="checked"' : '' %> />
65 |           <div class="todo-content"></div>
66 |           <span class="todo-destroy"></span>
67 |         </div>
68 |         <div class="edit">
69 |           <input class="todo-input" type="text" value="" />
70 |         </div>
71 |       </div>
72 |     </script>
73 | 
74 |     <script type="text/template" id="stats-template">
75 |       <% if (total) { %>
76 |         <span class="todo-count">
77 |           <span class="number"><%= remaining %></span>
78 |           <span class="word"><%= remaining == 1 ? 'item' : 'items' %></span> left.
79 |         </span>
80 |       <% } %>
81 |       <% if (done) { %>
82 |         <span class="todo-clear">
83 |           <a href="#">
84 |             Clear <span class="number-done"><%= done %></span>
85 |             completed <span class="word-done"><%= done == 1 ? 'item' : 'items' %></span>
86 |           </a>
87 |         </span>
88 |       <% } %>
89 |     </script>
90 | 
91 |   </body>
92 | 
93 | </html>
94 | 
95 | 


--------------------------------------------------------------------------------
/settings.py:
--------------------------------------------------------------------------------
 1 | # Django settings for todos project.
 2 | 
 3 | from secret_key import *
 4 | 
 5 | DEBUG = True
 6 | TEMPLATE_DEBUG = DEBUG
 7 | 
 8 | ADMINS = (
 9 |     # ('Your Name', 'your_email@domain.com'),
10 | )
11 | 
12 | MANAGERS = ADMINS
13 | 
14 | DATABASE_ENGINE = 'django.db.backends.postgresql_psycopg2'           # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
15 | DATABASE_NAME = 'todos'             # Or path to database file if using sqlite3.
16 | DATABASE_USER = 'postgres'             # Not used with sqlite3.
17 | DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.
18 | DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.
19 | 
20 | # Local time zone for this installation. Choices can be found here:
21 | # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
22 | # although not all choices may be available on all operating systems.
23 | # If running in a Windows environment this must be set to the same as your
24 | # system time zone.
25 | TIME_ZONE = 'America/Chicago'
26 | 
27 | # Language code for this installation. All choices can be found here:
28 | # http://www.i18nguy.com/unicode/language-identifiers.html
29 | LANGUAGE_CODE = 'en-us'
30 | 
31 | SITE_ID = 1
32 | 
33 | # If you set this to False, Django will make some optimizations so as not
34 | # to load the internationalization machinery.
35 | USE_I18N = True
36 | 
37 | # Absolute path to the directory that holds media.
38 | # Example: "/home/media/media.lawrence.com/"
39 | MEDIA_ROOT = ''
40 | 
41 | # URL that handles the media served from MEDIA_ROOT. Make sure to use a
42 | # trailing slash if there is a path component (optional in other cases).
43 | # Examples: "http://media.lawrence.com", "http://example.com/media/"
44 | MEDIA_URL = ''
45 | 
46 | # URL prefix for admin media -- CSS, JavaScript and images. Make sure to use a
47 | # trailing slash.
48 | # Examples: "http://foo.com/media/", "/media/".
49 | ADMIN_MEDIA_PREFIX = '/media/'
50 | 
51 | # List of callables that know how to import templates from various sources.
52 | TEMPLATE_LOADERS = (
53 |     'django.template.loaders.filesystem.load_template_source',
54 |     'django.template.loaders.app_directories.load_template_source',
55 | #     'django.template.loaders.eggs.load_template_source',
56 | )
57 | 
58 | MIDDLEWARE_CLASSES = (
59 |     'django.middleware.common.CommonMiddleware',
60 |     'django.contrib.sessions.middleware.SessionMiddleware',
61 |     'django.contrib.auth.middleware.AuthenticationMiddleware',
62 | )
63 | 
64 | ROOT_URLCONF = 'todos.urls'
65 | 
66 | TEMPLATE_DIRS = (
67 |     '/home/django/todos/'
68 |     # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
69 |     # Always use forward slashes, even on Windows.
70 |     # Don't forget to use absolute paths, not relative paths.
71 | )
72 | 
73 | INSTALLED_APPS = (
74 |     'django.contrib.auth',
75 |     'django.contrib.contenttypes',
76 |     'django.contrib.sessions',
77 |     'django.contrib.sites',
78 |     'django.contrib.admin',
79 |     'items',
80 | )
81 | 


--------------------------------------------------------------------------------
/items/static/js/todos.js:
--------------------------------------------------------------------------------
  1 | // An example Backbone application contributed by
  2 | // [Jérôme Gravel-Niquet](http://jgn.me/). This demo uses a simple
  3 | // [LocalStorage adapter](backbone-localstorage.html)
  4 | // to persist Backbone models within your browser.
  5 | 
  6 | // Load the application once the DOM is ready, using `jQuery.ready`:
  7 | $(function(){
  8 | 
  9 |   // Todo Model
 10 |   // ----------
 11 | 
 12 |   // Our basic **Todo** model has `content`, `order`, and `done` attributes.
 13 |   window.Todo = Backbone.Model.extend({
 14 | 
 15 |     // If you don't provide a todo, one will be provided for you.
 16 |     EMPTY: "empty todo...",
 17 | 
 18 |     // Ensure that each todo created has `content`.
 19 |     initialize: function() {
 20 |       if (!this.get("content")) {
 21 |         this.set({"content": this.EMPTY});
 22 |       }
 23 |     },
 24 | 
 25 |     // Toggle the `done` state of this todo item.
 26 |     toggle: function() {
 27 |       this.save({done: !this.get("done")});
 28 |     },
 29 | 
 30 |     // Remove this Todo from *localStorage* and delete its view.
 31 |     clear: function() {
 32 |       this.destroy();
 33 |       this.view.remove();
 34 |     }
 35 | 
 36 |   });
 37 | 
 38 |   // Todo Collection
 39 |   // ---------------
 40 | 
 41 |   // The collection of todos is backed by *localStorage* instead of a remote
 42 |   // server.
 43 |   window.TodoList = Backbone.Collection.extend({
 44 | 
 45 |     // Reference to this collection's model.
 46 |     model: Todo,
 47 | 
 48 |     // Save all of the todo items under the `"todos"` namespace.
 49 |     //localStorage: new Store("todos"),
 50 | 
 51 |     //url: 'http://localhost:8080/todos',
 52 |     url: '/todos',
 53 | 
 54 |     // Filter down the list of all todo items that are finished.
 55 |     done: function() {
 56 |       return this.filter(function(todo){ return todo.get('done'); });
 57 |     },
 58 | 
 59 |     // Filter down the list to only todo items that are still not finished.
 60 |     remaining: function() {
 61 |       return this.without.apply(this, this.done());
 62 |     },
 63 | 
 64 |     // We keep the Todos in sequential order, despite being saved by unordered
 65 |     // GUID in the database. This generates the next order number for new items.
 66 |     nextOrder: function() {
 67 |       if (!this.length) return 1;
 68 |       return this.last().get('order') + 1;
 69 |     },
 70 | 
 71 |     // Todos are sorted by their original insertion order.
 72 |     comparator: function(todo) {
 73 |       return todo.get('order');
 74 |     }
 75 | 
 76 |   });
 77 | 
 78 |   // Create our global collection of **Todos**.
 79 |   window.Todos = new TodoList;
 80 | 
 81 |   // Todo Item View
 82 |   // --------------
 83 | 
 84 |   // The DOM element for a todo item...
 85 |   window.TodoView = Backbone.View.extend({
 86 | 
 87 |     //... is a list tag.
 88 |     tagName:  "li",
 89 | 
 90 |     // Cache the template function for a single item.
 91 |     template: _.template($('#item-template').html()),
 92 | 
 93 |     // The DOM events specific to an item.
 94 |     events: {
 95 |       "click .check"              : "toggleDone",
 96 |       "dblclick div.todo-content" : "edit",
 97 |       "click span.todo-destroy"   : "clear",
 98 |       "keypress .todo-input"      : "updateOnEnter"
 99 |     },
100 | 
101 |     // The TodoView listens for changes to its model, re-rendering. Since there's
102 |     // a one-to-one correspondence between a **Todo** and a **TodoView** in this
103 |     // app, we set a direct reference on the model for convenience.
104 |     initialize: function() {
105 |       _.bindAll(this, 'render', 'close');
106 |       this.model.bind('change', this.render);
107 |       this.model.view = this;
108 |     },
109 | 
110 |     // Re-render the contents of the todo item.
111 |     render: function() {
112 |       $(this.el).html(this.template(this.model.toJSON()));
113 |       this.setContent();
114 |       return this;
115 |     },
116 | 
117 |     // To avoid XSS (not that it would be harmful in this particular app),
118 |     // we use `jQuery.text` to set the contents of the todo item.
119 |     setContent: function() {
120 |       var content = this.model.get('content');
121 |       this.$('.todo-content').text(content);
122 |       this.input = this.$('.todo-input');
123 |       this.input.bind('blur', this.close);
124 |       this.input.val(content);
125 |     },
126 | 
127 |     // Toggle the `"done"` state of the model.
128 |     toggleDone: function() {
129 |       this.model.toggle();
130 |     },
131 | 
132 |     // Switch this view into `"editing"` mode, displaying the input field.
133 |     edit: function() {
134 |       $(this.el).addClass("editing");
135 |       this.input.focus();
136 |     },
137 | 
138 |     // Close the `"editing"` mode, saving changes to the todo.
139 |     close: function() {
140 |       this.model.save({content: this.input.val()});
141 |       $(this.el).removeClass("editing");
142 |     },
143 | 
144 |     // If you hit `enter`, we're through editing the item.
145 |     updateOnEnter: function(e) {
146 |       if (e.keyCode == 13) this.close();
147 |     },
148 | 
149 |     // Remove this view from the DOM.
150 |     remove: function() {
151 |       $(this.el).remove();
152 |     },
153 | 
154 |     // Remove the item, destroy the model.
155 |     clear: function() {
156 |       this.model.clear();
157 |     }
158 | 
159 |   });
160 | 
161 |   // The Application
162 |   // ---------------
163 | 
164 |   // Our overall **AppView** is the top-level piece of UI.
165 |   window.AppView = Backbone.View.extend({
166 | 
167 |     // Instead of generating a new element, bind to the existing skeleton of
168 |     // the App already present in the HTML.
169 |     el: $("#todoapp"),
170 | 
171 |     // Our template for the line of statistics at the bottom of the app.
172 |     statsTemplate: _.template($('#stats-template').html()),
173 | 
174 |     // Delegated events for creating new items, and clearing completed ones.
175 |     events: {
176 |       "keypress #new-todo":  "createOnEnter",
177 |       "keyup #new-todo":     "showTooltip",
178 |       "click .todo-clear a": "clearCompleted"
179 |     },
180 | 
181 |     // At initialization we bind to the relevant events on the `Todos`
182 |     // collection, when items are added or changed. Kick things off by
183 |     // loading any preexisting todos that might be saved in *localStorage*.
184 |     initialize: function() {
185 |       _.bindAll(this, 'addOne', 'addAll', 'render');
186 | 
187 |       this.input    = this.$("#new-todo");
188 | 
189 |       Todos.bind('add',     this.addOne);
190 |       Todos.bind('refresh', this.addAll);
191 |       Todos.bind('all',     this.render);
192 | 
193 |       Todos.fetch();
194 |     },
195 | 
196 |     // Re-rendering the App just means refreshing the statistics -- the rest
197 |     // of the app doesn't change.
198 |     render: function() {
199 |       var done = Todos.done().length;
200 |       this.$('#todo-stats').html(this.statsTemplate({
201 |         total:      Todos.length,
202 |         done:       Todos.done().length,
203 |         remaining:  Todos.remaining().length
204 |       }));
205 |     },
206 | 
207 |     // Add a single todo item to the list by creating a view for it, and
208 |     // appending its element to the `<ul>`.
209 |     addOne: function(todo) {
210 |       var view = new TodoView({model: todo});
211 |       this.$("#todo-list").append(view.render().el);
212 |     },
213 | 
214 |     // Add all items in the **Todos** collection at once.
215 |     addAll: function() {
216 |       Todos.each(this.addOne);
217 |     },
218 | 
219 |     // Generate the attributes for a new Todo item.
220 |     newAttributes: function() {
221 |       return {
222 |         content: this.input.val(),
223 |         order:   Todos.nextOrder(),
224 |         done:    false
225 |       };
226 |     },
227 | 
228 |     // If you hit return in the main input field, create new **Todo** model,
229 |     // persisting it to *localStorage*.
230 |     createOnEnter: function(e) {
231 |       if (e.keyCode != 13) return;
232 |       Todos.create(this.newAttributes());
233 |       this.input.val('');
234 |     },
235 | 
236 |     // Clear all done todo items, destroying their models.
237 |     clearCompleted: function() {
238 |       _.each(Todos.done(), function(todo){ todo.clear(); });
239 |       return false;
240 |     },
241 | 
242 |     // Lazily show the tooltip that tells you to press `enter` to save
243 |     // a new todo item, after one second.
244 |     showTooltip: function(e) {
245 |       var tooltip = this.$(".ui-tooltip-top");
246 |       var val = this.input.val();
247 |       tooltip.fadeOut();
248 |       if (this.tooltipTimeout) clearTimeout(this.tooltipTimeout);
249 |       if (val == '' || val == this.input.attr('placeholder')) return;
250 |       var show = function(){ tooltip.show().fadeIn(); };
251 |       this.tooltipTimeout = _.delay(show, 1000);
252 |     }
253 | 
254 |   });
255 | 
256 |   // Finally, we kick things off by creating the **App**.
257 |   window.App = new AppView;
258 | 
259 | });
260 | 


--------------------------------------------------------------------------------
/items/static/css/todos.css:
--------------------------------------------------------------------------------
  1 | html, body, div, span, applet, object, iframe,
  2 | h1, h2, h3, h4, h5, h6, p, blockquote, pre,
  3 | a, abbr, acronym, address, big, cite, code,
  4 | del, dfn, em, font, img, ins, kbd, q, s, samp,
  5 | small, strike, strong, sub, sup, tt, var,
  6 | dl, dt, dd, ol, ul, li,
  7 | fieldset, form, label, legend,
  8 | table, caption, tbody, tfoot, thead, tr, th, td {
  9 |   margin: 0;
 10 |   padding: 0;
 11 |   border: 0;
 12 |   outline: 0;
 13 |   font-weight: inherit;
 14 |   font-style: inherit;
 15 |   font-size: 100%;
 16 |   font-family: inherit;
 17 |   vertical-align: baseline;
 18 | }
 19 | body {
 20 |   line-height: 1;
 21 |   color: black;
 22 |   background: white;
 23 | }
 24 | ol, ul {
 25 |   list-style: none;
 26 | }
 27 | a img {
 28 |   border: none;
 29 | }
 30 | 
 31 | html {
 32 |   background: #eeeeee;
 33 | }
 34 |   body {
 35 |     font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
 36 |     font-size: 14px;
 37 |     line-height: 1.4em;
 38 |     background: #eeeeee;
 39 |     color: #333333;
 40 |   }
 41 | 
 42 | #todoapp {
 43 |   width: 480px;
 44 |   margin: 0 auto 40px;
 45 |   background: white;
 46 |   padding: 20px;
 47 |   -moz-box-shadow: rgba(0, 0, 0, 0.2) 0 5px 6px 0;
 48 |   -webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 5px 6px 0;
 49 |   -o-box-shadow: rgba(0, 0, 0, 0.2) 0 5px 6px 0;
 50 |   box-shadow: rgba(0, 0, 0, 0.2) 0 5px 6px 0;
 51 | }
 52 |   #todoapp h1 {
 53 |     font-size: 36px;
 54 |     font-weight: bold;
 55 |     text-align: center;
 56 |     padding: 20px 0 30px 0;
 57 |     line-height: 1;
 58 |   }
 59 | 
 60 | #create-todo {
 61 |   position: relative;
 62 | }
 63 |   #create-todo input {
 64 |     width: 466px;
 65 |     font-size: 24px;
 66 |     font-family: inherit;
 67 |     line-height: 1.4em;
 68 |     border: 0;
 69 |     outline: none;
 70 |     padding: 6px;
 71 |     border: 1px solid #999999;
 72 |     -moz-box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
 73 |     -webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
 74 |     -o-box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
 75 |     box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
 76 |   }
 77 |     #create-todo input::-webkit-input-placeholder {
 78 |       font-style: italic;
 79 |     }
 80 |   #create-todo span {
 81 |     position: absolute;
 82 |     z-index: 999;
 83 |     width: 170px;
 84 |     left: 50%;
 85 |     margin-left: -85px;
 86 |   }
 87 | 
 88 | #todo-list {
 89 |   margin-top: 10px;
 90 | }
 91 |   #todo-list li {
 92 |     padding: 12px 20px 11px 0;
 93 |     position: relative;
 94 |     font-size: 24px;
 95 |     line-height: 1.1em;
 96 |     border-bottom: 1px solid #cccccc;
 97 |   }
 98 |     #todo-list li:after {
 99 |       content: "\0020";
100 |       display: block;
101 |       height: 0;
102 |       clear: both;
103 |       overflow: hidden;
104 |       visibility: hidden;
105 |     }
106 |     #todo-list li.editing {
107 |       padding: 0;
108 |       border-bottom: 0;
109 |     }
110 |   #todo-list .editing .display,
111 |   #todo-list .edit {
112 |     display: none;
113 |   }
114 |     #todo-list .editing .edit {
115 |       display: block;
116 |     }
117 |     #todo-list .editing input {
118 |       width: 444px;
119 |       font-size: 24px;
120 |       font-family: inherit;
121 |       margin: 0;
122 |       line-height: 1.6em;
123 |       border: 0;
124 |       outline: none;
125 |       padding: 10px 7px 0px 27px;
126 |       border: 1px solid #999999;
127 |       -moz-box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
128 |       -webkit-box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
129 |       -o-box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
130 |       box-shadow: rgba(0, 0, 0, 0.2) 0 1px 2px 0 inset;
131 |     }
132 |   #todo-list .check {
133 |     position: relative;
134 |     top: 9px;
135 |     margin: 0 10px 0 7px;
136 |     float: left;
137 |   }
138 |   #todo-list .done .todo-content {
139 |     text-decoration: line-through;
140 |     color: #777777;
141 |   }
142 |   #todo-list .todo-destroy {
143 |     position: absolute;
144 |     right: 5px;
145 |     top: 14px;
146 |     display: none;
147 |     cursor: pointer;
148 |     width: 20px;
149 |     height: 20px;
150 |     background: url(/static/img/destroy.png) no-repeat 0 0;
151 |   }
152 |     #todo-list li:hover .todo-destroy {
153 |       display: block;
154 |     }
155 |     #todo-list .todo-destroy:hover {
156 |       background-position: 0 -20px;
157 |     }
158 | 
159 | #todo-stats {
160 |   *zoom: 1;
161 |   margin-top: 10px;
162 |   color: #777777;
163 | }
164 |   #todo-stats:after {
165 |     content: "\0020";
166 |     display: block;
167 |     height: 0;
168 |     clear: both;
169 |     overflow: hidden;
170 |     visibility: hidden;
171 |   }
172 |   #todo-stats .todo-count {
173 |     float: left;
174 |   }
175 |     #todo-stats .todo-count .number {
176 |       font-weight: bold;
177 |       color: #333333;
178 |     }
179 |   #todo-stats .todo-clear {
180 |     float: right;
181 |   }
182 |     #todo-stats .todo-clear a {
183 |       color: #777777;
184 |       font-size: 12px;
185 |     }
186 |       #todo-stats .todo-clear a:visited {
187 |         color: #777777;
188 |       }
189 |       #todo-stats .todo-clear a:hover {
190 |         color: #336699;
191 |       }
192 | 
193 | #instructions {
194 |   width: 520px;
195 |   margin: 10px auto;
196 |   color: #777777;
197 |   text-shadow: rgba(255, 255, 255, 0.8) 0 1px 0;
198 |   text-align: center;
199 | }
200 |   #instructions a {
201 |     color: #336699;
202 |   }
203 | 
204 | #credits {
205 |   width: 520px;
206 |   margin: 30px auto;
207 |   color: #999;
208 |   text-shadow: rgba(255, 255, 255, 0.8) 0 1px 0;
209 |   text-align: center;
210 | }
211 |   #credits a {
212 |     color: #888;
213 |   }
214 | 
215 | 
216 | /*
217 |  *  François 'cahnory' Germain
218 |  */
219 | .ui-tooltip, .ui-tooltip-top, .ui-tooltip-right, .ui-tooltip-bottom, .ui-tooltip-left {
220 |   color:#ffffff;
221 |   cursor:normal;
222 |   display:-moz-inline-stack;
223 |   display:inline-block;
224 |   font-size:12px;
225 |   font-family:arial;
226 |   padding:.5em 1em;
227 |   position:relative;
228 |   text-align:center;
229 |   text-shadow:0 -1px 1px #111111;
230 |   -webkit-border-top-left-radius:4px ;
231 |   -webkit-border-top-right-radius:4px ;
232 |   -webkit-border-bottom-right-radius:4px ;
233 |   -webkit-border-bottom-left-radius:4px ;
234 |   -khtml-border-top-left-radius:4px ;
235 |   -khtml-border-top-right-radius:4px ;
236 |   -khtml-border-bottom-right-radius:4px ;
237 |   -khtml-border-bottom-left-radius:4px ;
238 |   -moz-border-radius-topleft:4px ;
239 |   -moz-border-radius-topright:4px ;
240 |   -moz-border-radius-bottomright:4px ;
241 |   -moz-border-radius-bottomleft:4px ;
242 |   border-top-left-radius:4px ;
243 |   border-top-right-radius:4px ;
244 |   border-bottom-right-radius:4px ;
245 |   border-bottom-left-radius:4px ;
246 |   -o-box-shadow:0 1px 2px #000000, inset 0 0 0 1px #222222, inset 0 2px #666666, inset 0 -2px 2px #444444;
247 |   -moz-box-shadow:0 1px 2px #000000, inset 0 0 0 1px #222222, inset 0 2px #666666, inset 0 -2px 2px #444444;
248 |   -khtml-box-shadow:0 1px 2px #000000, inset 0 0 0 1px #222222, inset 0 2px #666666, inset 0 -2px 2px #444444;
249 |   -webkit-box-shadow:0 1px 2px #000000, inset 0 0 0 1px #222222, inset 0 2px #666666, inset 0 -2px 2px #444444;
250 |   box-shadow:0 1px 2px #000000, inset 0 0 0 1px #222222, inset 0 2px #666666, inset 0 -2px 2px #444444;
251 |   background-color:#3b3b3b;
252 |   background-image:-moz-linear-gradient(top,#555555,#222222);
253 |   background-image:-webkit-gradient(linear,left top,left bottom,color-stop(0,#555555),color-stop(1,#222222));
254 |   filter:progid:DXImageTransform.Microsoft.gradient(startColorStr=#555555,EndColorStr=#222222);
255 |   -ms-filter:progid:DXImageTransform.Microsoft.gradient(startColorStr=#555555,EndColorStr=#222222);
256 | }
257 | .ui-tooltip:after, .ui-tooltip-top:after, .ui-tooltip-right:after, .ui-tooltip-bottom:after, .ui-tooltip-left:after {
258 |   content:"\25B8";
259 |   display:block;
260 |   font-size:2em;
261 |   height:0;
262 |   line-height:0;
263 |   position:absolute;
264 | }
265 | .ui-tooltip:after, .ui-tooltip-bottom:after {
266 |   color:#2a2a2a;
267 |   bottom:0;
268 |   left:1px;
269 |   text-align:center;
270 |   text-shadow:1px 0 2px #000000;
271 |   -o-transform:rotate(90deg);
272 |   -moz-transform:rotate(90deg);
273 |   -khtml-transform:rotate(90deg);
274 |   -webkit-transform:rotate(90deg);
275 |   width:100%;
276 | }
277 | .ui-tooltip-top:after {
278 |   bottom:auto;
279 |   color:#4f4f4f;
280 |   left:-2px;
281 |   top:0;
282 |   text-align:center;
283 |   text-shadow:none;
284 |   -o-transform:rotate(-90deg);
285 |   -moz-transform:rotate(-90deg);
286 |   -khtml-transform:rotate(-90deg);
287 |   -webkit-transform:rotate(-90deg);
288 |   width:100%;
289 | }
290 | .ui-tooltip-right:after {
291 |   color:#222222;
292 |   right:-0.375em;
293 |   top:50%;
294 |   margin-top:-.05em;
295 |   text-shadow:0 1px 2px #000000;
296 |   -o-transform:rotate(0);
297 |   -moz-transform:rotate(0);
298 |   -khtml-transform:rotate(0);
299 |   -webkit-transform:rotate(0);
300 | }
301 | .ui-tooltip-left:after {
302 |   color:#222222;
303 |   left:-0.375em;
304 |   top:50%;
305 |   margin-top:.1em;
306 |   text-shadow:0 -1px 2px #000000;
307 |   -o-transform:rotate(180deg);
308 |   -moz-transform:rotate(180deg);
309 |   -khtml-transform:rotate(180deg);
310 |   -webkit-transform:rotate(180deg);
311 | }
312 | 


--------------------------------------------------------------------------------
/items/static/js/json2.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |     http://www.JSON.org/json2.js
  3 |     2011-02-23
  4 | 
  5 |     Public Domain.
  6 | 
  7 |     NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
  8 | 
  9 |     See http://www.JSON.org/js.html
 10 | 
 11 | 
 12 |     This code should be minified before deployment.
 13 |     See http://javascript.crockford.com/jsmin.html
 14 | 
 15 |     USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
 16 |     NOT CONTROL.
 17 | 
 18 | 
 19 |     This file creates a global JSON object containing two methods: stringify
 20 |     and parse.
 21 | 
 22 |         JSON.stringify(value, replacer, space)
 23 |             value       any JavaScript value, usually an object or array.
 24 | 
 25 |             replacer    an optional parameter that determines how object
 26 |                         values are stringified for objects. It can be a
 27 |                         function or an array of strings.
 28 | 
 29 |             space       an optional parameter that specifies the indentation
 30 |                         of nested structures. If it is omitted, the text will
 31 |                         be packed without extra whitespace. If it is a number,
 32 |                         it will specify the number of spaces to indent at each
 33 |                         level. If it is a string (such as '\t' or '&nbsp;'),
 34 |                         it contains the characters used to indent at each level.
 35 | 
 36 |             This method produces a JSON text from a JavaScript value.
 37 | 
 38 |             When an object value is found, if the object contains a toJSON
 39 |             method, its toJSON method will be called and the result will be
 40 |             stringified. A toJSON method does not serialize: it returns the
 41 |             value represented by the name/value pair that should be serialized,
 42 |             or undefined if nothing should be serialized. The toJSON method
 43 |             will be passed the key associated with the value, and this will be
 44 |             bound to the value
 45 | 
 46 |             For example, this would serialize Dates as ISO strings.
 47 | 
 48 |                 Date.prototype.toJSON = function (key) {
 49 |                     function f(n) {
 50 |                         // Format integers to have at least two digits.
 51 |                         return n < 10 ? '0' + n : n;
 52 |                     }
 53 | 
 54 |                     return this.getUTCFullYear()   + '-' +
 55 |                          f(this.getUTCMonth() + 1) + '-' +
 56 |                          f(this.getUTCDate())      + 'T' +
 57 |                          f(this.getUTCHours())     + ':' +
 58 |                          f(this.getUTCMinutes())   + ':' +
 59 |                          f(this.getUTCSeconds())   + 'Z';
 60 |                 };
 61 | 
 62 |             You can provide an optional replacer method. It will be passed the
 63 |             key and value of each member, with this bound to the containing
 64 |             object. The value that is returned from your method will be
 65 |             serialized. If your method returns undefined, then the member will
 66 |             be excluded from the serialization.
 67 | 
 68 |             If the replacer parameter is an array of strings, then it will be
 69 |             used to select the members to be serialized. It filters the results
 70 |             such that only members with keys listed in the replacer array are
 71 |             stringified.
 72 | 
 73 |             Values that do not have JSON representations, such as undefined or
 74 |             functions, will not be serialized. Such values in objects will be
 75 |             dropped; in arrays they will be replaced with null. You can use
 76 |             a replacer function to replace those with JSON values.
 77 |             JSON.stringify(undefined) returns undefined.
 78 | 
 79 |             The optional space parameter produces a stringification of the
 80 |             value that is filled with line breaks and indentation to make it
 81 |             easier to read.
 82 | 
 83 |             If the space parameter is a non-empty string, then that string will
 84 |             be used for indentation. If the space parameter is a number, then
 85 |             the indentation will be that many spaces.
 86 | 
 87 |             Example:
 88 | 
 89 |             text = JSON.stringify(['e', {pluribus: 'unum'}]);
 90 |             // text is '["e",{"pluribus":"unum"}]'
 91 | 
 92 | 
 93 |             text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
 94 |             // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
 95 | 
 96 |             text = JSON.stringify([new Date()], function (key, value) {
 97 |                 return this[key] instanceof Date ?
 98 |                     'Date(' + this[key] + ')' : value;
 99 |             });
100 |             // text is '["Date(---current time---)"]'
101 | 
102 | 
103 |         JSON.parse(text, reviver)
104 |             This method parses a JSON text to produce an object or array.
105 |             It can throw a SyntaxError exception.
106 | 
107 |             The optional reviver parameter is a function that can filter and
108 |             transform the results. It receives each of the keys and values,
109 |             and its return value is used instead of the original value.
110 |             If it returns what it received, then the structure is not modified.
111 |             If it returns undefined then the member is deleted.
112 | 
113 |             Example:
114 | 
115 |             // Parse the text. Values that look like ISO date strings will
116 |             // be converted to Date objects.
117 | 
118 |             myData = JSON.parse(text, function (key, value) {
119 |                 var a;
120 |                 if (typeof value === 'string') {
121 |                     a =
122 | /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
123 |                     if (a) {
124 |                         return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
125 |                             +a[5], +a[6]));
126 |                     }
127 |                 }
128 |                 return value;
129 |             });
130 | 
131 |             myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
132 |                 var d;
133 |                 if (typeof value === 'string' &&
134 |                         value.slice(0, 5) === 'Date(' &&
135 |                         value.slice(-1) === ')') {
136 |                     d = new Date(value.slice(5, -1));
137 |                     if (d) {
138 |                         return d;
139 |                     }
140 |                 }
141 |                 return value;
142 |             });
143 | 
144 | 
145 |     This is a reference implementation. You are free to copy, modify, or
146 |     redistribute.
147 | */
148 | 
149 | /*jslint evil: true, strict: false, regexp: false */
150 | 
151 | /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
152 |     call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
153 |     getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
154 |     lastIndex, length, parse, prototype, push, replace, slice, stringify,
155 |     test, toJSON, toString, valueOf
156 | */
157 | 
158 | 
159 | // Create a JSON object only if one does not already exist. We create the
160 | // methods in a closure to avoid creating global variables.
161 | 
162 | var JSON;
163 | if (!JSON) {
164 |     JSON = {};
165 | }
166 | 
167 | (function () {
168 |     "use strict";
169 | 
170 |     function f(n) {
171 |         // Format integers to have at least two digits.
172 |         return n < 10 ? '0' + n : n;
173 |     }
174 | 
175 |     if (typeof Date.prototype.toJSON !== 'function') {
176 | 
177 |         Date.prototype.toJSON = function (key) {
178 | 
179 |             return isFinite(this.valueOf()) ?
180 |                 this.getUTCFullYear()     + '-' +
181 |                 f(this.getUTCMonth() + 1) + '-' +
182 |                 f(this.getUTCDate())      + 'T' +
183 |                 f(this.getUTCHours())     + ':' +
184 |                 f(this.getUTCMinutes())   + ':' +
185 |                 f(this.getUTCSeconds())   + 'Z' : null;
186 |         };
187 | 
188 |         String.prototype.toJSON      =
189 |             Number.prototype.toJSON  =
190 |             Boolean.prototype.toJSON = function (key) {
191 |                 return this.valueOf();
192 |             };
193 |     }
194 | 
195 |     var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
196 |         escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
197 |         gap,
198 |         indent,
199 |         meta = {    // table of character substitutions
200 |             '\b': '\\b',
201 |             '\t': '\\t',
202 |             '\n': '\\n',
203 |             '\f': '\\f',
204 |             '\r': '\\r',
205 |             '"' : '\\"',
206 |             '\\': '\\\\'
207 |         },
208 |         rep;
209 | 
210 | 
211 |     function quote(string) {
212 | 
213 | // If the string contains no control characters, no quote characters, and no
214 | // backslash characters, then we can safely slap some quotes around it.
215 | // Otherwise we must also replace the offending characters with safe escape
216 | // sequences.
217 | 
218 |         escapable.lastIndex = 0;
219 |         return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
220 |             var c = meta[a];
221 |             return typeof c === 'string' ? c :
222 |                 '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
223 |         }) + '"' : '"' + string + '"';
224 |     }
225 | 
226 | 
227 |     function str(key, holder) {
228 | 
229 | // Produce a string from holder[key].
230 | 
231 |         var i,          // The loop counter.
232 |             k,          // The member key.
233 |             v,          // The member value.
234 |             length,
235 |             mind = gap,
236 |             partial,
237 |             value = holder[key];
238 | 
239 | // If the value has a toJSON method, call it to obtain a replacement value.
240 | 
241 |         if (value && typeof value === 'object' &&
242 |                 typeof value.toJSON === 'function') {
243 |             value = value.toJSON(key);
244 |         }
245 | 
246 | // If we were called with a replacer function, then call the replacer to
247 | // obtain a replacement value.
248 | 
249 |         if (typeof rep === 'function') {
250 |             value = rep.call(holder, key, value);
251 |         }
252 | 
253 | // What happens next depends on the value's type.
254 | 
255 |         switch (typeof value) {
256 |         case 'string':
257 |             return quote(value);
258 | 
259 |         case 'number':
260 | 
261 | // JSON numbers must be finite. Encode non-finite numbers as null.
262 | 
263 |             return isFinite(value) ? String(value) : 'null';
264 | 
265 |         case 'boolean':
266 |         case 'null':
267 | 
268 | // If the value is a boolean or null, convert it to a string. Note:
269 | // typeof null does not produce 'null'. The case is included here in
270 | // the remote chance that this gets fixed someday.
271 | 
272 |             return String(value);
273 | 
274 | // If the type is 'object', we might be dealing with an object or an array or
275 | // null.
276 | 
277 |         case 'object':
278 | 
279 | // Due to a specification blunder in ECMAScript, typeof null is 'object',
280 | // so watch out for that case.
281 | 
282 |             if (!value) {
283 |                 return 'null';
284 |             }
285 | 
286 | // Make an array to hold the partial results of stringifying this object value.
287 | 
288 |             gap += indent;
289 |             partial = [];
290 | 
291 | // Is the value an array?
292 | 
293 |             if (Object.prototype.toString.apply(value) === '[object Array]') {
294 | 
295 | // The value is an array. Stringify every element. Use null as a placeholder
296 | // for non-JSON values.
297 | 
298 |                 length = value.length;
299 |                 for (i = 0; i < length; i += 1) {
300 |                     partial[i] = str(i, value) || 'null';
301 |                 }
302 | 
303 | // Join all of the elements together, separated with commas, and wrap them in
304 | // brackets.
305 | 
306 |                 v = partial.length === 0 ? '[]' : gap ?
307 |                     '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
308 |                     '[' + partial.join(',') + ']';
309 |                 gap = mind;
310 |                 return v;
311 |             }
312 | 
313 | // If the replacer is an array, use it to select the members to be stringified.
314 | 
315 |             if (rep && typeof rep === 'object') {
316 |                 length = rep.length;
317 |                 for (i = 0; i < length; i += 1) {
318 |                     if (typeof rep[i] === 'string') {
319 |                         k = rep[i];
320 |                         v = str(k, value);
321 |                         if (v) {
322 |                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
323 |                         }
324 |                     }
325 |                 }
326 |             } else {
327 | 
328 | // Otherwise, iterate through all of the keys in the object.
329 | 
330 |                 for (k in value) {
331 |                     if (Object.prototype.hasOwnProperty.call(value, k)) {
332 |                         v = str(k, value);
333 |                         if (v) {
334 |                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
335 |                         }
336 |                     }
337 |                 }
338 |             }
339 | 
340 | // Join all of the member texts together, separated with commas,
341 | // and wrap them in braces.
342 | 
343 |             v = partial.length === 0 ? '{}' : gap ?
344 |                 '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
345 |                 '{' + partial.join(',') + '}';
346 |             gap = mind;
347 |             return v;
348 |         }
349 |     }
350 | 
351 | // If the JSON object does not yet have a stringify method, give it one.
352 | 
353 |     if (typeof JSON.stringify !== 'function') {
354 |         JSON.stringify = function (value, replacer, space) {
355 | 
356 | // The stringify method takes a value and an optional replacer, and an optional
357 | // space parameter, and returns a JSON text. The replacer can be a function
358 | // that can replace values, or an array of strings that will select the keys.
359 | // A default replacer method can be provided. Use of the space parameter can
360 | // produce text that is more easily readable.
361 | 
362 |             var i;
363 |             gap = '';
364 |             indent = '';
365 | 
366 | // If the space parameter is a number, make an indent string containing that
367 | // many spaces.
368 | 
369 |             if (typeof space === 'number') {
370 |                 for (i = 0; i < space; i += 1) {
371 |                     indent += ' ';
372 |                 }
373 | 
374 | // If the space parameter is a string, it will be used as the indent string.
375 | 
376 |             } else if (typeof space === 'string') {
377 |                 indent = space;
378 |             }
379 | 
380 | // If there is a replacer, it must be a function or an array.
381 | // Otherwise, throw an error.
382 | 
383 |             rep = replacer;
384 |             if (replacer && typeof replacer !== 'function' &&
385 |                     (typeof replacer !== 'object' ||
386 |                     typeof replacer.length !== 'number')) {
387 |                 throw new Error('JSON.stringify');
388 |             }
389 | 
390 | // Make a fake root object containing our value under the key of ''.
391 | // Return the result of stringifying the value.
392 | 
393 |             return str('', {'': value});
394 |         };
395 |     }
396 | 
397 | 
398 | // If the JSON object does not yet have a parse method, give it one.
399 | 
400 |     if (typeof JSON.parse !== 'function') {
401 |         JSON.parse = function (text, reviver) {
402 | 
403 | // The parse method takes a text and an optional reviver function, and returns
404 | // a JavaScript value if the text is a valid JSON text.
405 | 
406 |             var j;
407 | 
408 |             function walk(holder, key) {
409 | 
410 | // The walk method is used to recursively walk the resulting structure so
411 | // that modifications can be made.
412 | 
413 |                 var k, v, value = holder[key];
414 |                 if (value && typeof value === 'object') {
415 |                     for (k in value) {
416 |                         if (Object.prototype.hasOwnProperty.call(value, k)) {
417 |                             v = walk(value, k);
418 |                             if (v !== undefined) {
419 |                                 value[k] = v;
420 |                             } else {
421 |                                 delete value[k];
422 |                             }
423 |                         }
424 |                     }
425 |                 }
426 |                 return reviver.call(holder, key, value);
427 |             }
428 | 
429 | 
430 | // Parsing happens in four stages. In the first stage, we replace certain
431 | // Unicode characters with escape sequences. JavaScript handles many characters
432 | // incorrectly, either silently deleting them, or treating them as line endings.
433 | 
434 |             text = String(text);
435 |             cx.lastIndex = 0;
436 |             if (cx.test(text)) {
437 |                 text = text.replace(cx, function (a) {
438 |                     return '\\u' +
439 |                         ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
440 |                 });
441 |             }
442 | 
443 | // In the second stage, we run the text against regular expressions that look
444 | // for non-JSON patterns. We are especially concerned with '()' and 'new'
445 | // because they can cause invocation, and '=' because it can cause mutation.
446 | // But just to be safe, we want to reject all unexpected forms.
447 | 
448 | // We split the second stage into 4 regexp operations in order to work around
449 | // crippling inefficiencies in IE's and Safari's regexp engines. First we
450 | // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
451 | // replace all simple value tokens with ']' characters. Third, we delete all
452 | // open brackets that follow a colon or comma or that begin the text. Finally,
453 | // we look to see that the remaining characters are only whitespace or ']' or
454 | // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
455 | 
456 |             if (/^[\],:{}\s]*$/
457 |                     .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
458 |                         .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
459 |                         .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
460 | 
461 | // In the third stage we use the eval function to compile the text into a
462 | // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
463 | // in JavaScript: it can begin a block or an object literal. We wrap the text
464 | // in parens to eliminate the ambiguity.
465 | 
466 |                 j = eval('(' + text + ')');
467 | 
468 | // In the optional fourth stage, we recursively walk the new structure, passing
469 | // each name/value pair to a reviver function for possible transformation.
470 | 
471 |                 return typeof reviver === 'function' ?
472 |                     walk({'': j}, '') : j;
473 |             }
474 | 
475 | // If the text is not JSON parseable, then a SyntaxError is thrown.
476 | 
477 |             throw new SyntaxError('JSON.parse');
478 |         };
479 |     }
480 | }());
481 | 


--------------------------------------------------------------------------------
/items/static/js/underscore.js:
--------------------------------------------------------------------------------
  1 | //     Underscore.js 1.1.6
  2 | //     (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.
  3 | //     Underscore is freely distributable under the MIT license.
  4 | //     Portions of Underscore are inspired or borrowed from Prototype,
  5 | //     Oliver Steele's Functional, and John Resig's Micro-Templating.
  6 | //     For all details and documentation:
  7 | //     http://documentcloud.github.com/underscore
  8 | 
  9 | (function() {
 10 | 
 11 |   // Baseline setup
 12 |   // --------------
 13 | 
 14 |   // Establish the root object, `window` in the browser, or `global` on the server.
 15 |   var root = this;
 16 | 
 17 |   // Save the previous value of the `_` variable.
 18 |   var previousUnderscore = root._;
 19 | 
 20 |   // Establish the object that gets returned to break out of a loop iteration.
 21 |   var breaker = {};
 22 | 
 23 |   // Save bytes in the minified (but not gzipped) version:
 24 |   var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
 25 | 
 26 |   // Create quick reference variables for speed access to core prototypes.
 27 |   var slice            = ArrayProto.slice,
 28 |       unshift          = ArrayProto.unshift,
 29 |       toString         = ObjProto.toString,
 30 |       hasOwnProperty   = ObjProto.hasOwnProperty;
 31 | 
 32 |   // All **ECMAScript 5** native function implementations that we hope to use
 33 |   // are declared here.
 34 |   var
 35 |     nativeForEach      = ArrayProto.forEach,
 36 |     nativeMap          = ArrayProto.map,
 37 |     nativeReduce       = ArrayProto.reduce,
 38 |     nativeReduceRight  = ArrayProto.reduceRight,
 39 |     nativeFilter       = ArrayProto.filter,
 40 |     nativeEvery        = ArrayProto.every,
 41 |     nativeSome         = ArrayProto.some,
 42 |     nativeIndexOf      = ArrayProto.indexOf,
 43 |     nativeLastIndexOf  = ArrayProto.lastIndexOf,
 44 |     nativeIsArray      = Array.isArray,
 45 |     nativeKeys         = Object.keys,
 46 |     nativeBind         = FuncProto.bind;
 47 | 
 48 |   // Create a safe reference to the Underscore object for use below.
 49 |   var _ = function(obj) { return new wrapper(obj); };
 50 | 
 51 |   // Export the Underscore object for **CommonJS**, with backwards-compatibility
 52 |   // for the old `require()` API. If we're not in CommonJS, add `_` to the
 53 |   // global object.
 54 |   if (typeof module !== 'undefined' && module.exports) {
 55 |     module.exports = _;
 56 |     _._ = _;
 57 |   } else {
 58 |     root._ = _;
 59 |   }
 60 | 
 61 |   // Current version.
 62 |   _.VERSION = '1.1.6';
 63 | 
 64 |   // Collection Functions
 65 |   // --------------------
 66 | 
 67 |   // The cornerstone, an `each` implementation, aka `forEach`.
 68 |   // Handles objects implementing `forEach`, arrays, and raw objects.
 69 |   // Delegates to **ECMAScript 5**'s native `forEach` if available.
 70 |   var each = _.each = _.forEach = function(obj, iterator, context) {
 71 |     if (obj == null) return;
 72 |     if (nativeForEach && obj.forEach === nativeForEach) {
 73 |       obj.forEach(iterator, context);
 74 |     } else if (_.isNumber(obj.length)) {
 75 |       for (var i = 0, l = obj.length; i < l; i++) {
 76 |         if (iterator.call(context, obj[i], i, obj) === breaker) return;
 77 |       }
 78 |     } else {
 79 |       for (var key in obj) {
 80 |         if (hasOwnProperty.call(obj, key)) {
 81 |           if (iterator.call(context, obj[key], key, obj) === breaker) return;
 82 |         }
 83 |       }
 84 |     }
 85 |   };
 86 | 
 87 |   // Return the results of applying the iterator to each element.
 88 |   // Delegates to **ECMAScript 5**'s native `map` if available.
 89 |   _.map = function(obj, iterator, context) {
 90 |     var results = [];
 91 |     if (obj == null) return results;
 92 |     if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
 93 |     each(obj, function(value, index, list) {
 94 |       results[results.length] = iterator.call(context, value, index, list);
 95 |     });
 96 |     return results;
 97 |   };
 98 | 
 99 |   // **Reduce** builds up a single result from a list of values, aka `inject`,
100 |   // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
101 |   _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
102 |     var initial = memo !== void 0;
103 |     if (obj == null) obj = [];
104 |     if (nativeReduce && obj.reduce === nativeReduce) {
105 |       if (context) iterator = _.bind(iterator, context);
106 |       return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
107 |     }
108 |     each(obj, function(value, index, list) {
109 |       if (!initial && index === 0) {
110 |         memo = value;
111 |         initial = true;
112 |       } else {
113 |         memo = iterator.call(context, memo, value, index, list);
114 |       }
115 |     });
116 |     if (!initial) throw new TypeError("Reduce of empty array with no initial value");
117 |     return memo;
118 |   };
119 | 
120 |   // The right-associative version of reduce, also known as `foldr`.
121 |   // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
122 |   _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
123 |     if (obj == null) obj = [];
124 |     if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
125 |       if (context) iterator = _.bind(iterator, context);
126 |       return memo !== void 0 ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
127 |     }
128 |     var reversed = (_.isArray(obj) ? obj.slice() : _.toArray(obj)).reverse();
129 |     return _.reduce(reversed, iterator, memo, context);
130 |   };
131 | 
132 |   // Return the first value which passes a truth test. Aliased as `detect`.
133 |   _.find = _.detect = function(obj, iterator, context) {
134 |     var result;
135 |     any(obj, function(value, index, list) {
136 |       if (iterator.call(context, value, index, list)) {
137 |         result = value;
138 |         return true;
139 |       }
140 |     });
141 |     return result;
142 |   };
143 | 
144 |   // Return all the elements that pass a truth test.
145 |   // Delegates to **ECMAScript 5**'s native `filter` if available.
146 |   // Aliased as `select`.
147 |   _.filter = _.select = function(obj, iterator, context) {
148 |     var results = [];
149 |     if (obj == null) return results;
150 |     if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
151 |     each(obj, function(value, index, list) {
152 |       if (iterator.call(context, value, index, list)) results[results.length] = value;
153 |     });
154 |     return results;
155 |   };
156 | 
157 |   // Return all the elements for which a truth test fails.
158 |   _.reject = function(obj, iterator, context) {
159 |     var results = [];
160 |     if (obj == null) return results;
161 |     each(obj, function(value, index, list) {
162 |       if (!iterator.call(context, value, index, list)) results[results.length] = value;
163 |     });
164 |     return results;
165 |   };
166 | 
167 |   // Determine whether all of the elements match a truth test.
168 |   // Delegates to **ECMAScript 5**'s native `every` if available.
169 |   // Aliased as `all`.
170 |   _.every = _.all = function(obj, iterator, context) {
171 |     var result = true;
172 |     if (obj == null) return result;
173 |     if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
174 |     each(obj, function(value, index, list) {
175 |       if (!(result = result && iterator.call(context, value, index, list))) return breaker;
176 |     });
177 |     return result;
178 |   };
179 | 
180 |   // Determine if at least one element in the object matches a truth test.
181 |   // Delegates to **ECMAScript 5**'s native `some` if available.
182 |   // Aliased as `any`.
183 |   var any = _.some = _.any = function(obj, iterator, context) {
184 |     iterator || (iterator = _.identity);
185 |     var result = false;
186 |     if (obj == null) return result;
187 |     if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
188 |     each(obj, function(value, index, list) {
189 |       if (result = iterator.call(context, value, index, list)) return breaker;
190 |     });
191 |     return result;
192 |   };
193 | 
194 |   // Determine if a given value is included in the array or object using `===`.
195 |   // Aliased as `contains`.
196 |   _.include = _.contains = function(obj, target) {
197 |     var found = false;
198 |     if (obj == null) return found;
199 |     if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
200 |     any(obj, function(value) {
201 |       if (found = value === target) return true;
202 |     });
203 |     return found;
204 |   };
205 | 
206 |   // Invoke a method (with arguments) on every item in a collection.
207 |   _.invoke = function(obj, method) {
208 |     var args = slice.call(arguments, 2);
209 |     return _.map(obj, function(value) {
210 |       return (method.call ? method || value : value[method]).apply(value, args);
211 |     });
212 |   };
213 | 
214 |   // Convenience version of a common use case of `map`: fetching a property.
215 |   _.pluck = function(obj, key) {
216 |     return _.map(obj, function(value){ return value[key]; });
217 |   };
218 | 
219 |   // Return the maximum element or (element-based computation).
220 |   _.max = function(obj, iterator, context) {
221 |     if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
222 |     var result = {computed : -Infinity};
223 |     each(obj, function(value, index, list) {
224 |       var computed = iterator ? iterator.call(context, value, index, list) : value;
225 |       computed >= result.computed && (result = {value : value, computed : computed});
226 |     });
227 |     return result.value;
228 |   };
229 | 
230 |   // Return the minimum element (or element-based computation).
231 |   _.min = function(obj, iterator, context) {
232 |     if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
233 |     var result = {computed : Infinity};
234 |     each(obj, function(value, index, list) {
235 |       var computed = iterator ? iterator.call(context, value, index, list) : value;
236 |       computed < result.computed && (result = {value : value, computed : computed});
237 |     });
238 |     return result.value;
239 |   };
240 | 
241 |   // Sort the object's values by a criterion produced by an iterator.
242 |   _.sortBy = function(obj, iterator, context) {
243 |     return _.pluck(_.map(obj, function(value, index, list) {
244 |       return {
245 |         value : value,
246 |         criteria : iterator.call(context, value, index, list)
247 |       };
248 |     }).sort(function(left, right) {
249 |       var a = left.criteria, b = right.criteria;
250 |       return a < b ? -1 : a > b ? 1 : 0;
251 |     }), 'value');
252 |   };
253 | 
254 |   // Use a comparator function to figure out at what index an object should
255 |   // be inserted so as to maintain order. Uses binary search.
256 |   _.sortedIndex = function(array, obj, iterator) {
257 |     iterator || (iterator = _.identity);
258 |     var low = 0, high = array.length;
259 |     while (low < high) {
260 |       var mid = (low + high) >> 1;
261 |       iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
262 |     }
263 |     return low;
264 |   };
265 | 
266 |   // Safely convert anything iterable into a real, live array.
267 |   _.toArray = function(iterable) {
268 |     if (!iterable)                return [];
269 |     if (iterable.toArray)         return iterable.toArray();
270 |     if (_.isArray(iterable))      return iterable;
271 |     if (_.isArguments(iterable))  return slice.call(iterable);
272 |     return _.values(iterable);
273 |   };
274 | 
275 |   // Return the number of elements in an object.
276 |   _.size = function(obj) {
277 |     return _.toArray(obj).length;
278 |   };
279 | 
280 |   // Array Functions
281 |   // ---------------
282 | 
283 |   // Get the first element of an array. Passing **n** will return the first N
284 |   // values in the array. Aliased as `head`. The **guard** check allows it to work
285 |   // with `_.map`.
286 |   _.first = _.head = function(array, n, guard) {
287 |     return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
288 |   };
289 | 
290 |   // Returns everything but the first entry of the array. Aliased as `tail`.
291 |   // Especially useful on the arguments object. Passing an **index** will return
292 |   // the rest of the values in the array from that index onward. The **guard**
293 |   // check allows it to work with `_.map`.
294 |   _.rest = _.tail = function(array, index, guard) {
295 |     return slice.call(array, (index == null) || guard ? 1 : index);
296 |   };
297 | 
298 |   // Get the last element of an array.
299 |   _.last = function(array) {
300 |     return array[array.length - 1];
301 |   };
302 | 
303 |   // Trim out all falsy values from an array.
304 |   _.compact = function(array) {
305 |     return _.filter(array, function(value){ return !!value; });
306 |   };
307 | 
308 |   // Return a completely flattened version of an array.
309 |   _.flatten = function(array) {
310 |     return _.reduce(array, function(memo, value) {
311 |       if (_.isArray(value)) return memo.concat(_.flatten(value));
312 |       memo[memo.length] = value;
313 |       return memo;
314 |     }, []);
315 |   };
316 | 
317 |   // Return a version of the array that does not contain the specified value(s).
318 |   _.without = function(array) {
319 |     var values = slice.call(arguments, 1);
320 |     return _.filter(array, function(value){ return !_.include(values, value); });
321 |   };
322 | 
323 |   // Produce a duplicate-free version of the array. If the array has already
324 |   // been sorted, you have the option of using a faster algorithm.
325 |   // Aliased as `unique`.
326 |   _.uniq = _.unique = function(array, isSorted) {
327 |     return _.reduce(array, function(memo, el, i) {
328 |       if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) memo[memo.length] = el;
329 |       return memo;
330 |     }, []);
331 |   };
332 | 
333 |   // Produce an array that contains every item shared between all the
334 |   // passed-in arrays.
335 |   _.intersect = function(array) {
336 |     var rest = slice.call(arguments, 1);
337 |     return _.filter(_.uniq(array), function(item) {
338 |       return _.every(rest, function(other) {
339 |         return _.indexOf(other, item) >= 0;
340 |       });
341 |     });
342 |   };
343 | 
344 |   // Zip together multiple lists into a single array -- elements that share
345 |   // an index go together.
346 |   _.zip = function() {
347 |     var args = slice.call(arguments);
348 |     var length = _.max(_.pluck(args, 'length'));
349 |     var results = new Array(length);
350 |     for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
351 |     return results;
352 |   };
353 | 
354 |   // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
355 |   // we need this function. Return the position of the first occurrence of an
356 |   // item in an array, or -1 if the item is not included in the array.
357 |   // Delegates to **ECMAScript 5**'s native `indexOf` if available.
358 |   // If the array is large and already in sort order, pass `true`
359 |   // for **isSorted** to use binary search.
360 |   _.indexOf = function(array, item, isSorted) {
361 |     if (array == null) return -1;
362 |     var i, l;
363 |     if (isSorted) {
364 |       i = _.sortedIndex(array, item);
365 |       return array[i] === item ? i : -1;
366 |     }
367 |     if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
368 |     for (i = 0, l = array.length; i < l; i++) if (array[i] === item) return i;
369 |     return -1;
370 |   };
371 | 
372 | 
373 |   // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
374 |   _.lastIndexOf = function(array, item) {
375 |     if (array == null) return -1;
376 |     if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
377 |     var i = array.length;
378 |     while (i--) if (array[i] === item) return i;
379 |     return -1;
380 |   };
381 | 
382 |   // Generate an integer Array containing an arithmetic progression. A port of
383 |   // the native Python `range()` function. See
384 |   // [the Python documentation](http://docs.python.org/library/functions.html#range).
385 |   _.range = function(start, stop, step) {
386 |     if (arguments.length <= 1) {
387 |       stop = start || 0;
388 |       start = 0;
389 |     }
390 |     step = arguments[2] || 1;
391 | 
392 |     var len = Math.max(Math.ceil((stop - start) / step), 0);
393 |     var idx = 0;
394 |     var range = new Array(len);
395 | 
396 |     while(idx < len) {
397 |       range[idx++] = start;
398 |       start += step;
399 |     }
400 | 
401 |     return range;
402 |   };
403 | 
404 |   // Function (ahem) Functions
405 |   // ------------------
406 | 
407 |   // Create a function bound to a given object (assigning `this`, and arguments,
408 |   // optionally). Binding with arguments is also known as `curry`.
409 |   // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
410 |   // We check for `func.bind` first, to fail fast when `func` is undefined.
411 |   _.bind = function(func, obj) {
412 |     if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
413 |     var args = slice.call(arguments, 2);
414 |     return function() {
415 |       return func.apply(obj, args.concat(slice.call(arguments)));
416 |     };
417 |   };
418 | 
419 |   // Bind all of an object's methods to that object. Useful for ensuring that
420 |   // all callbacks defined on an object belong to it.
421 |   _.bindAll = function(obj) {
422 |     var funcs = slice.call(arguments, 1);
423 |     if (funcs.length == 0) funcs = _.functions(obj);
424 |     each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
425 |     return obj;
426 |   };
427 | 
428 |   // Memoize an expensive function by storing its results.
429 |   _.memoize = function(func, hasher) {
430 |     var memo = {};
431 |     hasher || (hasher = _.identity);
432 |     return function() {
433 |       var key = hasher.apply(this, arguments);
434 |       return hasOwnProperty.call(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
435 |     };
436 |   };
437 | 
438 |   // Delays a function for the given number of milliseconds, and then calls
439 |   // it with the arguments supplied.
440 |   _.delay = function(func, wait) {
441 |     var args = slice.call(arguments, 2);
442 |     return setTimeout(function(){ return func.apply(func, args); }, wait);
443 |   };
444 | 
445 |   // Defers a function, scheduling it to run after the current call stack has
446 |   // cleared.
447 |   _.defer = function(func) {
448 |     return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
449 |   };
450 | 
451 |   // Internal function used to implement `_.throttle` and `_.debounce`.
452 |   var limit = function(func, wait, debounce) {
453 |     var timeout;
454 |     return function() {
455 |       var context = this, args = arguments;
456 |       var throttler = function() {
457 |         timeout = null;
458 |         func.apply(context, args);
459 |       };
460 |       if (debounce) clearTimeout(timeout);
461 |       if (debounce || !timeout) timeout = setTimeout(throttler, wait);
462 |     };
463 |   };
464 | 
465 |   // Returns a function, that, when invoked, will only be triggered at most once
466 |   // during a given window of time.
467 |   _.throttle = function(func, wait) {
468 |     return limit(func, wait, false);
469 |   };
470 | 
471 |   // Returns a function, that, as long as it continues to be invoked, will not
472 |   // be triggered. The function will be called after it stops being called for
473 |   // N milliseconds.
474 |   _.debounce = function(func, wait) {
475 |     return limit(func, wait, true);
476 |   };
477 | 
478 |   // Returns a function that will be executed at most one time, no matter how
479 |   // often you call it. Useful for lazy initialization.
480 |   _.once = function(func) {
481 |     var ran = false, memo;
482 |     return function() {
483 |       if (ran) return memo;
484 |       ran = true;
485 |       return memo = func.apply(this, arguments);
486 |     };
487 |   };
488 | 
489 |   // Returns the first function passed as an argument to the second,
490 |   // allowing you to adjust arguments, run code before and after, and
491 |   // conditionally execute the original function.
492 |   _.wrap = function(func, wrapper) {
493 |     return function() {
494 |       var args = [func].concat(slice.call(arguments));
495 |       return wrapper.apply(this, args);
496 |     };
497 |   };
498 | 
499 |   // Returns a function that is the composition of a list of functions, each
500 |   // consuming the return value of the function that follows.
501 |   _.compose = function() {
502 |     var funcs = slice.call(arguments);
503 |     return function() {
504 |       var args = slice.call(arguments);
505 |       for (var i=funcs.length-1; i >= 0; i--) {
506 |         args = [funcs[i].apply(this, args)];
507 |       }
508 |       return args[0];
509 |     };
510 |   };
511 | 
512 |   // Returns a function that will only be executed after being called N times.
513 |   _.after = function(times, func) {
514 |     return function() {
515 |       if (--times < 1) { return func.apply(this, arguments); }
516 |     };
517 |   };
518 | 
519 | 
520 |   // Object Functions
521 |   // ----------------
522 | 
523 |   // Retrieve the names of an object's properties.
524 |   // Delegates to **ECMAScript 5**'s native `Object.keys`
525 |   _.keys = nativeKeys || function(obj) {
526 |     if (obj !== Object(obj)) throw new TypeError('Invalid object');
527 |     var keys = [];
528 |     for (var key in obj) if (hasOwnProperty.call(obj, key)) keys[keys.length] = key;
529 |     return keys;
530 |   };
531 | 
532 |   // Retrieve the values of an object's properties.
533 |   _.values = function(obj) {
534 |     return _.map(obj, _.identity);
535 |   };
536 | 
537 |   // Return a sorted list of the function names available on the object.
538 |   // Aliased as `methods`
539 |   _.functions = _.methods = function(obj) {
540 |     return _.filter(_.keys(obj), function(key){ return _.isFunction(obj[key]); }).sort();
541 |   };
542 | 
543 |   // Extend a given object with all the properties in passed-in object(s).
544 |   _.extend = function(obj) {
545 |     each(slice.call(arguments, 1), function(source) {
546 |       for (var prop in source) {
547 |         if (source[prop] !== void 0) obj[prop] = source[prop];
548 |       }
549 |     });
550 |     return obj;
551 |   };
552 | 
553 |   // Fill in a given object with default properties.
554 |   _.defaults = function(obj) {
555 |     each(slice.call(arguments, 1), function(source) {
556 |       for (var prop in source) {
557 |         if (obj[prop] == null) obj[prop] = source[prop];
558 |       }
559 |     });
560 |     return obj;
561 |   };
562 | 
563 |   // Create a (shallow-cloned) duplicate of an object.
564 |   _.clone = function(obj) {
565 |     return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
566 |   };
567 | 
568 |   // Invokes interceptor with the obj, and then returns obj.
569 |   // The primary purpose of this method is to "tap into" a method chain, in
570 |   // order to perform operations on intermediate results within the chain.
571 |   _.tap = function(obj, interceptor) {
572 |     interceptor(obj);
573 |     return obj;
574 |   };
575 | 
576 |   // Perform a deep comparison to check if two objects are equal.
577 |   _.isEqual = function(a, b) {
578 |     // Check object identity.
579 |     if (a === b) return true;
580 |     // Different types?
581 |     var atype = typeof(a), btype = typeof(b);
582 |     if (atype != btype) return false;
583 |     // Basic equality test (watch out for coercions).
584 |     if (a == b) return true;
585 |     // One is falsy and the other truthy.
586 |     if ((!a && b) || (a && !b)) return false;
587 |     // Unwrap any wrapped objects.
588 |     if (a._chain) a = a._wrapped;
589 |     if (b._chain) b = b._wrapped;
590 |     // One of them implements an isEqual()?
591 |     if (a.isEqual) return a.isEqual(b);
592 |     // Check dates' integer values.
593 |     if (_.isDate(a) && _.isDate(b)) return a.getTime() === b.getTime();
594 |     // Both are NaN?
595 |     if (_.isNaN(a) && _.isNaN(b)) return false;
596 |     // Compare regular expressions.
597 |     if (_.isRegExp(a) && _.isRegExp(b))
598 |       return a.source     === b.source &&
599 |              a.global     === b.global &&
600 |              a.ignoreCase === b.ignoreCase &&
601 |              a.multiline  === b.multiline;
602 |     // If a is not an object by this point, we can't handle it.
603 |     if (atype !== 'object') return false;
604 |     // Check for different array lengths before comparing contents.
605 |     if (a.length && (a.length !== b.length)) return false;
606 |     // Nothing else worked, deep compare the contents.
607 |     var aKeys = _.keys(a), bKeys = _.keys(b);
608 |     // Different object sizes?
609 |     if (aKeys.length != bKeys.length) return false;
610 |     // Recursive comparison of contents.
611 |     for (var key in a) if (!(key in b) || !_.isEqual(a[key], b[key])) return false;
612 |     return true;
613 |   };
614 | 
615 |   // Is a given array or object empty?
616 |   _.isEmpty = function(obj) {
617 |     if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
618 |     for (var key in obj) if (hasOwnProperty.call(obj, key)) return false;
619 |     return true;
620 |   };
621 | 
622 |   // Is a given value a DOM element?
623 |   _.isElement = function(obj) {
624 |     return !!(obj && obj.nodeType == 1);
625 |   };
626 | 
627 |   // Is a given value an array?
628 |   // Delegates to ECMA5's native Array.isArray
629 |   _.isArray = nativeIsArray || function(obj) {
630 |     return toString.call(obj) === '[object Array]';
631 |   };
632 | 
633 |   // Is a given variable an arguments object?
634 |   _.isArguments = function(obj) {
635 |     return !!(obj && hasOwnProperty.call(obj, 'callee'));
636 |   };
637 | 
638 |   // Is a given value a function?
639 |   _.isFunction = function(obj) {
640 |     return !!(obj && obj.constructor && obj.call && obj.apply);
641 |   };
642 | 
643 |   // Is a given value a string?
644 |   _.isString = function(obj) {
645 |     return !!(obj === '' || (obj && obj.charCodeAt && obj.substr));
646 |   };
647 | 
648 |   // Is a given value a number?
649 |   _.isNumber = function(obj) {
650 |     return !!(obj === 0 || (obj && obj.toExponential && obj.toFixed));
651 |   };
652 | 
653 |   // Is the given value `NaN`? `NaN` happens to be the only value in JavaScript
654 |   // that does not equal itself.
655 |   _.isNaN = function(obj) {
656 |     return obj !== obj;
657 |   };
658 | 
659 |   // Is a given value a boolean?
660 |   _.isBoolean = function(obj) {
661 |     return obj === true || obj === false;
662 |   };
663 | 
664 |   // Is a given value a date?
665 |   _.isDate = function(obj) {
666 |     return !!(obj && obj.getTimezoneOffset && obj.setUTCFullYear);
667 |   };
668 | 
669 |   // Is the given value a regular expression?
670 |   _.isRegExp = function(obj) {
671 |     return !!(obj && obj.test && obj.exec && (obj.ignoreCase || obj.ignoreCase === false));
672 |   };
673 | 
674 |   // Is a given value equal to null?
675 |   _.isNull = function(obj) {
676 |     return obj === null;
677 |   };
678 | 
679 |   // Is a given variable undefined?
680 |   _.isUndefined = function(obj) {
681 |     return obj === void 0;
682 |   };
683 | 
684 |   // Utility Functions
685 |   // -----------------
686 | 
687 |   // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
688 |   // previous owner. Returns a reference to the Underscore object.
689 |   _.noConflict = function() {
690 |     root._ = previousUnderscore;
691 |     return this;
692 |   };
693 | 
694 |   // Keep the identity function around for default iterators.
695 |   _.identity = function(value) {
696 |     return value;
697 |   };
698 | 
699 |   // Run a function **n** times.
700 |   _.times = function (n, iterator, context) {
701 |     for (var i = 0; i < n; i++) iterator.call(context, i);
702 |   };
703 | 
704 |   // Add your own custom functions to the Underscore object, ensuring that
705 |   // they're correctly added to the OOP wrapper as well.
706 |   _.mixin = function(obj) {
707 |     each(_.functions(obj), function(name){
708 |       addToWrapper(name, _[name] = obj[name]);
709 |     });
710 |   };
711 | 
712 |   // Generate a unique integer id (unique within the entire client session).
713 |   // Useful for temporary DOM ids.
714 |   var idCounter = 0;
715 |   _.uniqueId = function(prefix) {
716 |     var id = idCounter++;
717 |     return prefix ? prefix + id : id;
718 |   };
719 | 
720 |   // By default, Underscore uses ERB-style template delimiters, change the
721 |   // following template settings to use alternative delimiters.
722 |   _.templateSettings = {
723 |     evaluate    : /<%([\s\S]+?)%>/g,
724 |     interpolate : /<%=([\s\S]+?)%>/g
725 |   };
726 | 
727 |   // JavaScript micro-templating, similar to John Resig's implementation.
728 |   // Underscore templating handles arbitrary delimiters, preserves whitespace,
729 |   // and correctly escapes quotes within interpolated code.
730 |   _.template = function(str, data) {
731 |     var c  = _.templateSettings;
732 |     var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
733 |       'with(obj||{}){__p.push(\'' +
734 |       str.replace(/\\/g, '\\\\')
735 |          .replace(/'/g, "\\'")
736 |          .replace(c.interpolate, function(match, code) {
737 |            return "'," + code.replace(/\\'/g, "'") + ",'";
738 |          })
739 |          .replace(c.evaluate || null, function(match, code) {
740 |            return "');" + code.replace(/\\'/g, "'")
741 |                               .replace(/[\r\n\t]/g, ' ') + "__p.push('";
742 |          })
743 |          .replace(/\r/g, '\\r')
744 |          .replace(/\n/g, '\\n')
745 |          .replace(/\t/g, '\\t')
746 |          + "');}return __p.join('');";
747 |     var func = new Function('obj', tmpl);
748 |     return data ? func(data) : func;
749 |   };
750 | 
751 |   // The OOP Wrapper
752 |   // ---------------
753 | 
754 |   // If Underscore is called as a function, it returns a wrapped object that
755 |   // can be used OO-style. This wrapper holds altered versions of all the
756 |   // underscore functions. Wrapped objects may be chained.
757 |   var wrapper = function(obj) { this._wrapped = obj; };
758 | 
759 |   // Expose `wrapper.prototype` as `_.prototype`
760 |   _.prototype = wrapper.prototype;
761 | 
762 |   // Helper function to continue chaining intermediate results.
763 |   var result = function(obj, chain) {
764 |     return chain ? _(obj).chain() : obj;
765 |   };
766 | 
767 |   // A method to easily add functions to the OOP wrapper.
768 |   var addToWrapper = function(name, func) {
769 |     wrapper.prototype[name] = function() {
770 |       var args = slice.call(arguments);
771 |       unshift.call(args, this._wrapped);
772 |       return result(func.apply(_, args), this._chain);
773 |     };
774 |   };
775 | 
776 |   // Add all of the Underscore functions to the wrapper object.
777 |   _.mixin(_);
778 | 
779 |   // Add all mutator Array functions to the wrapper.
780 |   each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
781 |     var method = ArrayProto[name];
782 |     wrapper.prototype[name] = function() {
783 |       method.apply(this._wrapped, arguments);
784 |       return result(this._wrapped, this._chain);
785 |     };
786 |   });
787 | 
788 |   // Add all accessor Array functions to the wrapper.
789 |   each(['concat', 'join', 'slice'], function(name) {
790 |     var method = ArrayProto[name];
791 |     wrapper.prototype[name] = function() {
792 |       return result(method.apply(this._wrapped, arguments), this._chain);
793 |     };
794 |   });
795 | 
796 |   // Start chaining a wrapped Underscore object.
797 |   wrapper.prototype.chain = function() {
798 |     this._chain = true;
799 |     return this;
800 |   };
801 | 
802 |   // Extracts the result from a wrapped and chained object.
803 |   wrapper.prototype.value = function() {
804 |     return this._wrapped;
805 |   };
806 | 
807 | })();
808 | 


--------------------------------------------------------------------------------
/items/static/js/backbone.js:
--------------------------------------------------------------------------------
   1 | //     Backbone.js 0.3.3
   2 | //     (c) 2010 Jeremy Ashkenas, DocumentCloud Inc.
   3 | //     Backbone may be freely distributed under the MIT license.
   4 | //     For all details and documentation:
   5 | //     http://documentcloud.github.com/backbone
   6 | 
   7 | (function(){
   8 | 
   9 |   // Initial Setup
  10 |   // -------------
  11 | 
  12 |   // The top-level namespace. All public Backbone classes and modules will
  13 |   // be attached to this. Exported for both CommonJS and the browser.
  14 |   var Backbone;
  15 |   if (typeof exports !== 'undefined') {
  16 |     Backbone = exports;
  17 |   } else {
  18 |     Backbone = this.Backbone = {};
  19 |   }
  20 | 
  21 |   // Current version of the library. Keep in sync with `package.json`.
  22 |   Backbone.VERSION = '0.3.3';
  23 | 
  24 |   // Require Underscore, if we're on the server, and it's not already present.
  25 |   var _ = this._;
  26 |   if (!_ && (typeof require !== 'undefined')) _ = require("underscore")._;
  27 | 
  28 |   // For Backbone's purposes, either jQuery or Zepto owns the `$` variable.
  29 |   var $ = this.jQuery || this.Zepto;
  30 | 
  31 |   // Turn on `emulateHTTP` to use support legacy HTTP servers. Setting this option will
  32 |   // fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and set a
  33 |   // `X-Http-Method-Override` header.
  34 |   Backbone.emulateHTTP = false;
  35 | 
  36 |   // Turn on `emulateJSON` to support legacy servers that can't deal with direct
  37 |   // `application/json` requests ... will encode the body as
  38 |   // `application/x-www-form-urlencoded` instead and will send the model in a
  39 |   // form param named `model`.
  40 |   Backbone.emulateJSON = false;
  41 | 
  42 |   // Backbone.Events
  43 |   // -----------------
  44 | 
  45 |   // A module that can be mixed in to *any object* in order to provide it with
  46 |   // custom events. You may `bind` or `unbind` a callback function to an event;
  47 |   // `trigger`-ing an event fires all callbacks in succession.
  48 |   //
  49 |   //     var object = {};
  50 |   //     _.extend(object, Backbone.Events);
  51 |   //     object.bind('expand', function(){ alert('expanded'); });
  52 |   //     object.trigger('expand');
  53 |   //
  54 |   Backbone.Events = {
  55 | 
  56 |     // Bind an event, specified by a string name, `ev`, to a `callback` function.
  57 |     // Passing `"all"` will bind the callback to all events fired.
  58 |     bind : function(ev, callback) {
  59 |       var calls = this._callbacks || (this._callbacks = {});
  60 |       var list  = this._callbacks[ev] || (this._callbacks[ev] = []);
  61 |       list.push(callback);
  62 |       return this;
  63 |     },
  64 | 
  65 |     // Remove one or many callbacks. If `callback` is null, removes all
  66 |     // callbacks for the event. If `ev` is null, removes all bound callbacks
  67 |     // for all events.
  68 |     unbind : function(ev, callback) {
  69 |       var calls;
  70 |       if (!ev) {
  71 |         this._callbacks = {};
  72 |       } else if (calls = this._callbacks) {
  73 |         if (!callback) {
  74 |           calls[ev] = [];
  75 |         } else {
  76 |           var list = calls[ev];
  77 |           if (!list) return this;
  78 |           for (var i = 0, l = list.length; i < l; i++) {
  79 |             if (callback === list[i]) {
  80 |               list.splice(i, 1);
  81 |               break;
  82 |             }
  83 |           }
  84 |         }
  85 |       }
  86 |       return this;
  87 |     },
  88 | 
  89 |     // Trigger an event, firing all bound callbacks. Callbacks are passed the
  90 |     // same arguments as `trigger` is, apart from the event name.
  91 |     // Listening for `"all"` passes the true event name as the first argument.
  92 |     trigger : function(ev) {
  93 |       var list, calls, i, l;
  94 |       if (!(calls = this._callbacks)) return this;
  95 |       if (list = calls[ev]) {
  96 |         for (i = 0, l = list.length; i < l; i++) {
  97 |           list[i].apply(this, Array.prototype.slice.call(arguments, 1));
  98 |         }
  99 |       }
 100 |       if (list = calls['all']) {
 101 |         for (i = 0, l = list.length; i < l; i++) {
 102 |           list[i].apply(this, arguments);
 103 |         }
 104 |       }
 105 |       return this;
 106 |     }
 107 | 
 108 |   };
 109 | 
 110 |   // Backbone.Model
 111 |   // --------------
 112 | 
 113 |   // Create a new model, with defined attributes. A client id (`cid`)
 114 |   // is automatically generated and assigned for you.
 115 |   Backbone.Model = function(attributes, options) {
 116 |     attributes || (attributes = {});
 117 |     if (this.defaults) attributes = _.extend({}, this.defaults, attributes);
 118 |     this.attributes = {};
 119 |     this._escapedAttributes = {};
 120 |     this.cid = _.uniqueId('c');
 121 |     this.set(attributes, {silent : true});
 122 |     this._previousAttributes = _.clone(this.attributes);
 123 |     if (options && options.collection) this.collection = options.collection;
 124 |     this.initialize(attributes, options);
 125 |   };
 126 | 
 127 |   // Attach all inheritable methods to the Model prototype.
 128 |   _.extend(Backbone.Model.prototype, Backbone.Events, {
 129 | 
 130 |     // A snapshot of the model's previous attributes, taken immediately
 131 |     // after the last `"change"` event was fired.
 132 |     _previousAttributes : null,
 133 | 
 134 |     // Has the item been changed since the last `"change"` event?
 135 |     _changed : false,
 136 | 
 137 |     // Initialize is an empty function by default. Override it with your own
 138 |     // initialization logic.
 139 |     initialize : function(){},
 140 | 
 141 |     // Return a copy of the model's `attributes` object.
 142 |     toJSON : function() {
 143 |       return _.clone(this.attributes);
 144 |     },
 145 | 
 146 |     // Get the value of an attribute.
 147 |     get : function(attr) {
 148 |       return this.attributes[attr];
 149 |     },
 150 | 
 151 |     // Get the HTML-escaped value of an attribute.
 152 |     escape : function(attr) {
 153 |       var html;
 154 |       if (html = this._escapedAttributes[attr]) return html;
 155 |       var val = this.attributes[attr];
 156 |       return this._escapedAttributes[attr] = escapeHTML(val == null ? '' : val);
 157 |     },
 158 | 
 159 |     // Set a hash of model attributes on the object, firing `"change"` unless you
 160 |     // choose to silence it.
 161 |     set : function(attrs, options) {
 162 | 
 163 |       // Extract attributes and options.
 164 |       options || (options = {});
 165 |       if (!attrs) return this;
 166 |       if (attrs.attributes) attrs = attrs.attributes;
 167 |       var now = this.attributes, escaped = this._escapedAttributes;
 168 | 
 169 |       // Run validation.
 170 |       if (!options.silent && this.validate && !this._performValidation(attrs, options)) return false;
 171 | 
 172 |       // Check for changes of `id`.
 173 |       if ('id' in attrs) this.id = attrs.id;
 174 | 
 175 |       // Update attributes.
 176 |       for (var attr in attrs) {
 177 |         var val = attrs[attr];
 178 |         if (!_.isEqual(now[attr], val)) {
 179 |           now[attr] = val;
 180 |           delete escaped[attr];
 181 |           if (!options.silent) {
 182 |             this._changed = true;
 183 |             this.trigger('change:' + attr, this, val, options);
 184 |           }
 185 |         }
 186 |       }
 187 | 
 188 |       // Fire the `"change"` event, if the model has been changed.
 189 |       if (!options.silent && this._changed) this.change(options);
 190 |       return this;
 191 |     },
 192 | 
 193 |     // Remove an attribute from the model, firing `"change"` unless you choose
 194 |     // to silence it.
 195 |     unset : function(attr, options) {
 196 |       options || (options = {});
 197 |       var value = this.attributes[attr];
 198 | 
 199 |       // Run validation.
 200 |       var validObj = {};
 201 |       validObj[attr] = void 0;
 202 |       if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;
 203 | 
 204 |       // Remove the attribute.
 205 |       delete this.attributes[attr];
 206 |       delete this._escapedAttributes[attr];
 207 |       if (!options.silent) {
 208 |         this._changed = true;
 209 |         this.trigger('change:' + attr, this, void 0, options);
 210 |         this.change(options);
 211 |       }
 212 |       return this;
 213 |     },
 214 | 
 215 |     // Clear all attributes on the model, firing `"change"` unless you choose
 216 |     // to silence it.
 217 |     clear : function(options) {
 218 |       options || (options = {});
 219 |       var old = this.attributes;
 220 | 
 221 |       // Run validation.
 222 |       var validObj = {};
 223 |       for (attr in old) validObj[attr] = void 0;
 224 |       if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;
 225 | 
 226 |       this.attributes = {};
 227 |       this._escapedAttributes = {};
 228 |       if (!options.silent) {
 229 |         this._changed = true;
 230 |         for (attr in old) {
 231 |           this.trigger('change:' + attr, this, void 0, options);
 232 |         }
 233 |         this.change(options);
 234 |       }
 235 |       return this;
 236 |     },
 237 | 
 238 |     // Fetch the model from the server. If the server's representation of the
 239 |     // model differs from its current attributes, they will be overriden,
 240 |     // triggering a `"change"` event.
 241 |     fetch : function(options) {
 242 |       options || (options = {});
 243 |       var model = this;
 244 |       var success = function(resp) {
 245 |         if (!model.set(model.parse(resp), options)) return false;
 246 |         if (options.success) options.success(model, resp);
 247 |       };
 248 |       var error = wrapError(options.error, model, options);
 249 |       (this.sync || Backbone.sync)('read', this, success, error);
 250 |       return this;
 251 |     },
 252 | 
 253 |     // Set a hash of model attributes, and sync the model to the server.
 254 |     // If the server returns an attributes hash that differs, the model's
 255 |     // state will be `set` again.
 256 |     save : function(attrs, options) {
 257 |       options || (options = {});
 258 |       if (attrs && !this.set(attrs, options)) return false;
 259 |       var model = this;
 260 |       var success = function(resp) {
 261 |         if (!model.set(model.parse(resp), options)) return false;
 262 |         if (options.success) options.success(model, resp);
 263 |       };
 264 |       var error = wrapError(options.error, model, options);
 265 |       var method = this.isNew() ? 'create' : 'update';
 266 |       (this.sync || Backbone.sync)(method, this, success, error);
 267 |       return this;
 268 |     },
 269 | 
 270 |     // Destroy this model on the server. Upon success, the model is removed
 271 |     // from its collection, if it has one.
 272 |     destroy : function(options) {
 273 |       options || (options = {});
 274 |       var model = this;
 275 |       var success = function(resp) {
 276 |         if (model.collection) model.collection.remove(model);
 277 |         if (options.success) options.success(model, resp);
 278 |       };
 279 |       var error = wrapError(options.error, model, options);
 280 |       (this.sync || Backbone.sync)('delete', this, success, error);
 281 |       return this;
 282 |     },
 283 | 
 284 |     // Default URL for the model's representation on the server -- if you're
 285 |     // using Backbone's restful methods, override this to change the endpoint
 286 |     // that will be called.
 287 |     url : function() {
 288 |       var base = getUrl(this.collection);
 289 |       if (this.isNew()) return base;
 290 |       return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + this.id;
 291 |     },
 292 | 
 293 |     // **parse** converts a response into the hash of attributes to be `set` on
 294 |     // the model. The default implementation is just to pass the response along.
 295 |     parse : function(resp) {
 296 |       return resp;
 297 |     },
 298 | 
 299 |     // Create a new model with identical attributes to this one.
 300 |     clone : function() {
 301 |       return new this.constructor(this);
 302 |     },
 303 | 
 304 |     // A model is new if it has never been saved to the server, and has a negative
 305 |     // ID.
 306 |     isNew : function() {
 307 |       return !this.id;
 308 |     },
 309 | 
 310 |     // Call this method to manually fire a `change` event for this model.
 311 |     // Calling this will cause all objects observing the model to update.
 312 |     change : function(options) {
 313 |       this.trigger('change', this, options);
 314 |       this._previousAttributes = _.clone(this.attributes);
 315 |       this._changed = false;
 316 |     },
 317 | 
 318 |     // Determine if the model has changed since the last `"change"` event.
 319 |     // If you specify an attribute name, determine if that attribute has changed.
 320 |     hasChanged : function(attr) {
 321 |       if (attr) return this._previousAttributes[attr] != this.attributes[attr];
 322 |       return this._changed;
 323 |     },
 324 | 
 325 |     // Return an object containing all the attributes that have changed, or false
 326 |     // if there are no changed attributes. Useful for determining what parts of a
 327 |     // view need to be updated and/or what attributes need to be persisted to
 328 |     // the server.
 329 |     changedAttributes : function(now) {
 330 |       now || (now = this.attributes);
 331 |       var old = this._previousAttributes;
 332 |       var changed = false;
 333 |       for (var attr in now) {
 334 |         if (!_.isEqual(old[attr], now[attr])) {
 335 |           changed = changed || {};
 336 |           changed[attr] = now[attr];
 337 |         }
 338 |       }
 339 |       return changed;
 340 |     },
 341 | 
 342 |     // Get the previous value of an attribute, recorded at the time the last
 343 |     // `"change"` event was fired.
 344 |     previous : function(attr) {
 345 |       if (!attr || !this._previousAttributes) return null;
 346 |       return this._previousAttributes[attr];
 347 |     },
 348 | 
 349 |     // Get all of the attributes of the model at the time of the previous
 350 |     // `"change"` event.
 351 |     previousAttributes : function() {
 352 |       return _.clone(this._previousAttributes);
 353 |     },
 354 | 
 355 |     // Run validation against a set of incoming attributes, returning `true`
 356 |     // if all is well. If a specific `error` callback has been passed,
 357 |     // call that instead of firing the general `"error"` event.
 358 |     _performValidation : function(attrs, options) {
 359 |       var error = this.validate(attrs);
 360 |       if (error) {
 361 |         if (options.error) {
 362 |           options.error(this, error);
 363 |         } else {
 364 |           this.trigger('error', this, error, options);
 365 |         }
 366 |         return false;
 367 |       }
 368 |       return true;
 369 |     }
 370 | 
 371 |   });
 372 | 
 373 |   // Backbone.Collection
 374 |   // -------------------
 375 | 
 376 |   // Provides a standard collection class for our sets of models, ordered
 377 |   // or unordered. If a `comparator` is specified, the Collection will maintain
 378 |   // its models in sort order, as they're added and removed.
 379 |   Backbone.Collection = function(models, options) {
 380 |     options || (options = {});
 381 |     if (options.comparator) {
 382 |       this.comparator = options.comparator;
 383 |       delete options.comparator;
 384 |     }
 385 |     this._boundOnModelEvent = _.bind(this._onModelEvent, this);
 386 |     this._reset();
 387 |     if (models) this.refresh(models, {silent: true});
 388 |     this.initialize(models, options);
 389 |   };
 390 | 
 391 |   // Define the Collection's inheritable methods.
 392 |   _.extend(Backbone.Collection.prototype, Backbone.Events, {
 393 | 
 394 |     // The default model for a collection is just a **Backbone.Model**.
 395 |     // This should be overridden in most cases.
 396 |     model : Backbone.Model,
 397 | 
 398 |     // Initialize is an empty function by default. Override it with your own
 399 |     // initialization logic.
 400 |     initialize : function(){},
 401 | 
 402 |     // The JSON representation of a Collection is an array of the
 403 |     // models' attributes.
 404 |     toJSON : function() {
 405 |       return this.map(function(model){ return model.toJSON(); });
 406 |     },
 407 | 
 408 |     // Add a model, or list of models to the set. Pass **silent** to avoid
 409 |     // firing the `added` event for every new model.
 410 |     add : function(models, options) {
 411 |       if (_.isArray(models)) {
 412 |         for (var i = 0, l = models.length; i < l; i++) {
 413 |           this._add(models[i], options);
 414 |         }
 415 |       } else {
 416 |         this._add(models, options);
 417 |       }
 418 |       return this;
 419 |     },
 420 | 
 421 |     // Remove a model, or a list of models from the set. Pass silent to avoid
 422 |     // firing the `removed` event for every model removed.
 423 |     remove : function(models, options) {
 424 |       if (_.isArray(models)) {
 425 |         for (var i = 0, l = models.length; i < l; i++) {
 426 |           this._remove(models[i], options);
 427 |         }
 428 |       } else {
 429 |         this._remove(models, options);
 430 |       }
 431 |       return this;
 432 |     },
 433 | 
 434 |     // Get a model from the set by id.
 435 |     get : function(id) {
 436 |       if (id == null) return null;
 437 |       return this._byId[id.id != null ? id.id : id];
 438 |     },
 439 | 
 440 |     // Get a model from the set by client id.
 441 |     getByCid : function(cid) {
 442 |       return cid && this._byCid[cid.cid || cid];
 443 |     },
 444 | 
 445 |     // Get the model at the given index.
 446 |     at: function(index) {
 447 |       return this.models[index];
 448 |     },
 449 | 
 450 |     // Force the collection to re-sort itself. You don't need to call this under normal
 451 |     // circumstances, as the set will maintain sort order as each item is added.
 452 |     sort : function(options) {
 453 |       options || (options = {});
 454 |       if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
 455 |       this.models = this.sortBy(this.comparator);
 456 |       if (!options.silent) this.trigger('refresh', this, options);
 457 |       return this;
 458 |     },
 459 | 
 460 |     // Pluck an attribute from each model in the collection.
 461 |     pluck : function(attr) {
 462 |       return _.map(this.models, function(model){ return model.get(attr); });
 463 |     },
 464 | 
 465 |     // When you have more items than you want to add or remove individually,
 466 |     // you can refresh the entire set with a new list of models, without firing
 467 |     // any `added` or `removed` events. Fires `refresh` when finished.
 468 |     refresh : function(models, options) {
 469 |       models  || (models = []);
 470 |       options || (options = {});
 471 |       this._reset();
 472 |       this.add(models, {silent: true});
 473 |       if (!options.silent) this.trigger('refresh', this, options);
 474 |       return this;
 475 |     },
 476 | 
 477 |     // Fetch the default set of models for this collection, refreshing the
 478 |     // collection when they arrive.
 479 |     fetch : function(options) {
 480 |       options || (options = {});
 481 |       var collection = this;
 482 |       var success = function(resp) {
 483 |         collection.refresh(collection.parse(resp));
 484 |         if (options.success) options.success(collection, resp);
 485 |       };
 486 |       var error = wrapError(options.error, collection, options);
 487 |       (this.sync || Backbone.sync)('read', this, success, error);
 488 |       return this;
 489 |     },
 490 | 
 491 |     // Create a new instance of a model in this collection. After the model
 492 |     // has been created on the server, it will be added to the collection.
 493 |     create : function(model, options) {
 494 |       var coll = this;
 495 |       options || (options = {});
 496 |       if (!(model instanceof Backbone.Model)) {
 497 |         model = new this.model(model, {collection: coll});
 498 |       } else {
 499 |         model.collection = coll;
 500 |       }
 501 |       var success = function(nextModel, resp) {
 502 |         coll.add(nextModel);
 503 |         if (options.success) options.success(nextModel, resp);
 504 |       };
 505 |       return model.save(null, {success : success, error : options.error});
 506 |     },
 507 | 
 508 |     // **parse** converts a response into a list of models to be added to the
 509 |     // collection. The default implementation is just to pass it through.
 510 |     parse : function(resp) {
 511 |       return resp;
 512 |     },
 513 | 
 514 |     // Proxy to _'s chain. Can't be proxied the same way the rest of the
 515 |     // underscore methods are proxied because it relies on the underscore
 516 |     // constructor.
 517 |     chain: function () {
 518 |       return _(this.models).chain();
 519 |     },
 520 | 
 521 |     // Reset all internal state. Called when the collection is refreshed.
 522 |     _reset : function(options) {
 523 |       this.length = 0;
 524 |       this.models = [];
 525 |       this._byId  = {};
 526 |       this._byCid = {};
 527 |     },
 528 | 
 529 |     // Internal implementation of adding a single model to the set, updating
 530 |     // hash indexes for `id` and `cid` lookups.
 531 |     _add : function(model, options) {
 532 |       options || (options = {});
 533 |       if (!(model instanceof Backbone.Model)) {
 534 |         model = new this.model(model, {collection: this});
 535 |       }
 536 |       var already = this.getByCid(model);
 537 |       if (already) throw new Error(["Can't add the same model to a set twice", already.id]);
 538 |       this._byId[model.id] = model;
 539 |       this._byCid[model.cid] = model;
 540 |       model.collection = this;
 541 |       var index = this.comparator ? this.sortedIndex(model, this.comparator) : this.length;
 542 |       this.models.splice(index, 0, model);
 543 |       model.bind('all', this._boundOnModelEvent);
 544 |       this.length++;
 545 |       if (!options.silent) model.trigger('add', model, this, options);
 546 |       return model;
 547 |     },
 548 | 
 549 |     // Internal implementation of removing a single model from the set, updating
 550 |     // hash indexes for `id` and `cid` lookups.
 551 |     _remove : function(model, options) {
 552 |       options || (options = {});
 553 |       model = this.getByCid(model) || this.get(model);
 554 |       if (!model) return null;
 555 |       delete this._byId[model.id];
 556 |       delete this._byCid[model.cid];
 557 |       delete model.collection;
 558 |       this.models.splice(this.indexOf(model), 1);
 559 |       this.length--;
 560 |       if (!options.silent) model.trigger('remove', model, this, options);
 561 |       model.unbind('all', this._boundOnModelEvent);
 562 |       return model;
 563 |     },
 564 | 
 565 |     // Internal method called every time a model in the set fires an event.
 566 |     // Sets need to update their indexes when models change ids. All other
 567 |     // events simply proxy through.
 568 |     _onModelEvent : function(ev, model) {
 569 |       if (ev === 'change:id') {
 570 |         delete this._byId[model.previous('id')];
 571 |         this._byId[model.id] = model;
 572 |       }
 573 |       this.trigger.apply(this, arguments);
 574 |     }
 575 | 
 576 |   });
 577 | 
 578 |   // Underscore methods that we want to implement on the Collection.
 579 |   var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', 'detect',
 580 |     'filter', 'select', 'reject', 'every', 'all', 'some', 'any', 'include',
 581 |     'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size',
 582 |     'first', 'rest', 'last', 'without', 'indexOf', 'lastIndexOf', 'isEmpty'];
 583 | 
 584 |   // Mix in each Underscore method as a proxy to `Collection#models`.
 585 |   _.each(methods, function(method) {
 586 |     Backbone.Collection.prototype[method] = function() {
 587 |       return _[method].apply(_, [this.models].concat(_.toArray(arguments)));
 588 |     };
 589 |   });
 590 | 
 591 |   // Backbone.Controller
 592 |   // -------------------
 593 | 
 594 |   // Controllers map faux-URLs to actions, and fire events when routes are
 595 |   // matched. Creating a new one sets its `routes` hash, if not set statically.
 596 |   Backbone.Controller = function(options) {
 597 |     options || (options = {});
 598 |     if (options.routes) this.routes = options.routes;
 599 |     this._bindRoutes();
 600 |     this.initialize(options);
 601 |   };
 602 | 
 603 |   // Cached regular expressions for matching named param parts and splatted
 604 |   // parts of route strings.
 605 |   var namedParam = /:([\w\d]+)/g;
 606 |   var splatParam = /\*([\w\d]+)/g;
 607 | 
 608 |   // Set up all inheritable **Backbone.Controller** properties and methods.
 609 |   _.extend(Backbone.Controller.prototype, Backbone.Events, {
 610 | 
 611 |     // Initialize is an empty function by default. Override it with your own
 612 |     // initialization logic.
 613 |     initialize : function(){},
 614 | 
 615 |     // Manually bind a single named route to a callback. For example:
 616 |     //
 617 |     //     this.route('search/:query/p:num', 'search', function(query, num) {
 618 |     //       ...
 619 |     //     });
 620 |     //
 621 |     route : function(route, name, callback) {
 622 |       Backbone.history || (Backbone.history = new Backbone.History);
 623 |       if (!_.isRegExp(route)) route = this._routeToRegExp(route);
 624 |       Backbone.history.route(route, _.bind(function(fragment) {
 625 |         var args = this._extractParameters(route, fragment);
 626 |         callback.apply(this, args);
 627 |         this.trigger.apply(this, ['route:' + name].concat(args));
 628 |       }, this));
 629 |     },
 630 | 
 631 |     // Simple proxy to `Backbone.history` to save a fragment into the history,
 632 |     // without triggering routes.
 633 |     saveLocation : function(fragment) {
 634 |       Backbone.history.saveLocation(fragment);
 635 |     },
 636 | 
 637 |     // Bind all defined routes to `Backbone.history`.
 638 |     _bindRoutes : function() {
 639 |       if (!this.routes) return;
 640 |       for (var route in this.routes) {
 641 |         var name = this.routes[route];
 642 |         this.route(route, name, this[name]);
 643 |       }
 644 |     },
 645 | 
 646 |     // Convert a route string into a regular expression, suitable for matching
 647 |     // against the current location fragment.
 648 |     _routeToRegExp : function(route) {
 649 |       route = route.replace(namedParam, "([^\/]*)").replace(splatParam, "(.*?)");
 650 |       return new RegExp('^' + route + '$');
 651 |     },
 652 | 
 653 |     // Given a route, and a URL fragment that it matches, return the array of
 654 |     // extracted parameters.
 655 |     _extractParameters : function(route, fragment) {
 656 |       return route.exec(fragment).slice(1);
 657 |     }
 658 | 
 659 |   });
 660 | 
 661 |   // Backbone.History
 662 |   // ----------------
 663 | 
 664 |   // Handles cross-browser history management, based on URL hashes. If the
 665 |   // browser does not support `onhashchange`, falls back to polling.
 666 |   Backbone.History = function() {
 667 |     this.handlers = [];
 668 |     this.fragment = this.getFragment();
 669 |     _.bindAll(this, 'checkUrl');
 670 |   };
 671 | 
 672 |   // Cached regex for cleaning hashes.
 673 |   var hashStrip = /^#*/;
 674 | 
 675 |   // Set up all inheritable **Backbone.History** properties and methods.
 676 |   _.extend(Backbone.History.prototype, {
 677 | 
 678 |     // The default interval to poll for hash changes, if necessary, is
 679 |     // twenty times a second.
 680 |     interval: 50,
 681 | 
 682 |     // Get the cross-browser normalized URL fragment.
 683 |     getFragment : function(loc) {
 684 |       return (loc || window.location).hash.replace(hashStrip, '');
 685 |     },
 686 | 
 687 |     // Start the hash change handling, returning `true` if the current URL matches
 688 |     // an existing route, and `false` otherwise.
 689 |     start : function() {
 690 |       var docMode = document.documentMode;
 691 |       var oldIE = ($.browser.msie && (!docMode || docMode <= 7));
 692 |       if (oldIE) {
 693 |         this.iframe = $('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
 694 |       }
 695 |       if ('onhashchange' in window && !oldIE) {
 696 |         $(window).bind('hashchange', this.checkUrl);
 697 |       } else {
 698 |         setInterval(this.checkUrl, this.interval);
 699 |       }
 700 |       return this.loadUrl();
 701 |     },
 702 | 
 703 |     // Add a route to be tested when the hash changes. Routes are matched in the
 704 |     // order they are added.
 705 |     route : function(route, callback) {
 706 |       this.handlers.push({route : route, callback : callback});
 707 |     },
 708 | 
 709 |     // Checks the current URL to see if it has changed, and if it has,
 710 |     // calls `loadUrl`, normalizing across the hidden iframe.
 711 |     checkUrl : function() {
 712 |       var current = this.getFragment();
 713 |       if (current == this.fragment && this.iframe) {
 714 |         current = this.getFragment(this.iframe.location);
 715 |       }
 716 |       if (current == this.fragment ||
 717 |           current == decodeURIComponent(this.fragment)) return false;
 718 |       if (this.iframe) {
 719 |         window.location.hash = this.iframe.location.hash = current;
 720 |       }
 721 |       this.loadUrl();
 722 |     },
 723 | 
 724 |     // Attempt to load the current URL fragment. If a route succeeds with a
 725 |     // match, returns `true`. If no defined routes matches the fragment,
 726 |     // returns `false`.
 727 |     loadUrl : function() {
 728 |       var fragment = this.fragment = this.getFragment();
 729 |       var matched = _.any(this.handlers, function(handler) {
 730 |         if (handler.route.test(fragment)) {
 731 |           handler.callback(fragment);
 732 |           return true;
 733 |         }
 734 |       });
 735 |       return matched;
 736 |     },
 737 | 
 738 |     // Save a fragment into the hash history. You are responsible for properly
 739 |     // URL-encoding the fragment in advance. This does not trigger
 740 |     // a `hashchange` event.
 741 |     saveLocation : function(fragment) {
 742 |       fragment = (fragment || '').replace(hashStrip, '');
 743 |       if (this.fragment == fragment) return;
 744 |       window.location.hash = this.fragment = fragment;
 745 |       if (this.iframe && (fragment != this.getFragment(this.iframe.location))) {
 746 |         this.iframe.document.open().close();
 747 |         this.iframe.location.hash = fragment;
 748 |       }
 749 |     }
 750 | 
 751 |   });
 752 | 
 753 |   // Backbone.View
 754 |   // -------------
 755 | 
 756 |   // Creating a Backbone.View creates its initial element outside of the DOM,
 757 |   // if an existing element is not provided...
 758 |   Backbone.View = function(options) {
 759 |     this._configure(options || {});
 760 |     this._ensureElement();
 761 |     this.delegateEvents();
 762 |     this.initialize(options);
 763 |   };
 764 | 
 765 |   // Element lookup, scoped to DOM elements within the current view.
 766 |   // This should be prefered to global lookups, if you're dealing with
 767 |   // a specific view.
 768 |   var selectorDelegate = function(selector) {
 769 |     return $(selector, this.el);
 770 |   };
 771 | 
 772 |   // Cached regex to split keys for `delegate`.
 773 |   var eventSplitter = /^(\w+)\s*(.*)$/;
 774 | 
 775 |   // Set up all inheritable **Backbone.View** properties and methods.
 776 |   _.extend(Backbone.View.prototype, Backbone.Events, {
 777 | 
 778 |     // The default `tagName` of a View's element is `"div"`.
 779 |     tagName : 'div',
 780 | 
 781 |     // Attach the `selectorDelegate` function as the `$` property.
 782 |     $       : selectorDelegate,
 783 | 
 784 |     // Initialize is an empty function by default. Override it with your own
 785 |     // initialization logic.
 786 |     initialize : function(){},
 787 | 
 788 |     // **render** is the core function that your view should override, in order
 789 |     // to populate its element (`this.el`), with the appropriate HTML. The
 790 |     // convention is for **render** to always return `this`.
 791 |     render : function() {
 792 |       return this;
 793 |     },
 794 | 
 795 |     // Remove this view from the DOM. Note that the view isn't present in the
 796 |     // DOM by default, so calling this method may be a no-op.
 797 |     remove : function() {
 798 |       $(this.el).remove();
 799 |       return this;
 800 |     },
 801 | 
 802 |     // For small amounts of DOM Elements, where a full-blown template isn't
 803 |     // needed, use **make** to manufacture elements, one at a time.
 804 |     //
 805 |     //     var el = this.make('li', {'class': 'row'}, this.model.get('title'));
 806 |     //
 807 |     make : function(tagName, attributes, content) {
 808 |       var el = document.createElement(tagName);
 809 |       if (attributes) $(el).attr(attributes);
 810 |       if (content) $(el).html(content);
 811 |       return el;
 812 |     },
 813 | 
 814 |     // Set callbacks, where `this.callbacks` is a hash of
 815 |     //
 816 |     // *{"event selector": "callback"}*
 817 |     //
 818 |     //     {
 819 |     //       'mousedown .title':  'edit',
 820 |     //       'click .button':     'save'
 821 |     //     }
 822 |     //
 823 |     // pairs. Callbacks will be bound to the view, with `this` set properly.
 824 |     // Uses event delegation for efficiency.
 825 |     // Omitting the selector binds the event to `this.el`.
 826 |     // This only works for delegate-able events: not `focus`, `blur`, and
 827 |     // not `change`, `submit`, and `reset` in Internet Explorer.
 828 |     delegateEvents : function(events) {
 829 |       if (!(events || (events = this.events))) return;
 830 |       $(this.el).unbind();
 831 |       for (var key in events) {
 832 |         var methodName = events[key];
 833 |         var match = key.match(eventSplitter);
 834 |         var eventName = match[1], selector = match[2];
 835 |         var method = _.bind(this[methodName], this);
 836 |         if (selector === '') {
 837 |           $(this.el).bind(eventName, method);
 838 |         } else {
 839 |           $(this.el).delegate(selector, eventName, method);
 840 |         }
 841 |       }
 842 |     },
 843 | 
 844 |     // Performs the initial configuration of a View with a set of options.
 845 |     // Keys with special meaning *(model, collection, id, className)*, are
 846 |     // attached directly to the view.
 847 |     _configure : function(options) {
 848 |       if (this.options) options = _.extend({}, this.options, options);
 849 |       if (options.model)      this.model      = options.model;
 850 |       if (options.collection) this.collection = options.collection;
 851 |       if (options.el)         this.el         = options.el;
 852 |       if (options.id)         this.id         = options.id;
 853 |       if (options.className)  this.className  = options.className;
 854 |       if (options.tagName)    this.tagName    = options.tagName;
 855 |       this.options = options;
 856 |     },
 857 | 
 858 |     // Ensure that the View has a DOM element to render into.
 859 |     _ensureElement : function() {
 860 |       if (this.el) return;
 861 |       var attrs = {};
 862 |       if (this.id) attrs.id = this.id;
 863 |       if (this.className) attrs["class"] = this.className;
 864 |       this.el = this.make(this.tagName, attrs);
 865 |     }
 866 | 
 867 |   });
 868 | 
 869 |   // The self-propagating extend function that Backbone classes use.
 870 |   var extend = function (protoProps, classProps) {
 871 |     var child = inherits(this, protoProps, classProps);
 872 |     child.extend = extend;
 873 |     return child;
 874 |   };
 875 | 
 876 |   // Set up inheritance for the model, collection, and view.
 877 |   Backbone.Model.extend = Backbone.Collection.extend =
 878 |     Backbone.Controller.extend = Backbone.View.extend = extend;
 879 | 
 880 |   // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
 881 |   var methodMap = {
 882 |     'create': 'POST',
 883 |     'update': 'PUT',
 884 |     'delete': 'DELETE',
 885 |     'read'  : 'GET'
 886 |   };
 887 | 
 888 |   // Backbone.sync
 889 |   // -------------
 890 | 
 891 |   // Override this function to change the manner in which Backbone persists
 892 |   // models to the server. You will be passed the type of request, and the
 893 |   // model in question. By default, uses makes a RESTful Ajax request
 894 |   // to the model's `url()`. Some possible customizations could be:
 895 |   //
 896 |   // * Use `setTimeout` to batch rapid-fire updates into a single request.
 897 |   // * Send up the models as XML instead of JSON.
 898 |   // * Persist models via WebSockets instead of Ajax.
 899 |   //
 900 |   // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
 901 |   // as `POST`, with a `_method` parameter containing the true HTTP method,
 902 |   // as well as all requests with the body as `application/x-www-form-urlencoded` instead of
 903 |   // `application/json` with the model in a param named `model`.
 904 |   // Useful when interfacing with server-side languages like **PHP** that make
 905 |   // it difficult to read the body of `PUT` requests.
 906 |   Backbone.sync = function(method, model, success, error) {
 907 |     var type = methodMap[method];
 908 |     var modelJSON = (method === 'create' || method === 'update') ?
 909 |                     JSON.stringify(model.toJSON()) : null;
 910 | 
 911 |     // Default JSON-request options.
 912 |     var params = {
 913 |       url:          getUrl(model),
 914 |       type:         type,
 915 |       contentType:  'application/json',
 916 |       data:         modelJSON,
 917 |       dataType:     'json',
 918 |       processData:  false,
 919 |       success:      success,
 920 |       error:        error
 921 |     };
 922 | 
 923 |     // For older servers, emulate JSON by encoding the request into an HTML-form.
 924 |     if (Backbone.emulateJSON) {
 925 |       params.contentType = 'application/x-www-form-urlencoded';
 926 |       params.processData = true;
 927 |       params.data        = modelJSON ? {model : modelJSON} : {};
 928 |     }
 929 | 
 930 |     // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
 931 |     // And an `X-HTTP-Method-Override` header.
 932 |     if (Backbone.emulateHTTP) {
 933 |       if (type === 'PUT' || type === 'DELETE') {
 934 |         if (Backbone.emulateJSON) params.data._method = type;
 935 |         params.type = 'POST';
 936 |         params.beforeSend = function(xhr) {
 937 |           xhr.setRequestHeader("X-HTTP-Method-Override", type);
 938 |         };
 939 |       }
 940 |     }
 941 | 
 942 |     // Make the request.
 943 |     $.ajax(params);
 944 |   };
 945 | 
 946 |   // Helpers
 947 |   // -------
 948 | 
 949 |   // Shared empty constructor function to aid in prototype-chain creation.
 950 |   var ctor = function(){};
 951 | 
 952 |   // Helper function to correctly set up the prototype chain, for subclasses.
 953 |   // Similar to `goog.inherits`, but uses a hash of prototype properties and
 954 |   // class properties to be extended.
 955 |   var inherits = function(parent, protoProps, staticProps) {
 956 |     var child;
 957 | 
 958 |     // The constructor function for the new subclass is either defined by you
 959 |     // (the "constructor" property in your `extend` definition), or defaulted
 960 |     // by us to simply call `super()`.
 961 |     if (protoProps && protoProps.hasOwnProperty('constructor')) {
 962 |       child = protoProps.constructor;
 963 |     } else {
 964 |       child = function(){ return parent.apply(this, arguments); };
 965 |     }
 966 | 
 967 |     // Set the prototype chain to inherit from `parent`, without calling
 968 |     // `parent`'s constructor function.
 969 |     ctor.prototype = parent.prototype;
 970 |     child.prototype = new ctor();
 971 | 
 972 |     // Add prototype properties (instance properties) to the subclass,
 973 |     // if supplied.
 974 |     if (protoProps) _.extend(child.prototype, protoProps);
 975 | 
 976 |     // Add static properties to the constructor function, if supplied.
 977 |     if (staticProps) _.extend(child, staticProps);
 978 | 
 979 |     // Correctly set child's `prototype.constructor`, for `instanceof`.
 980 |     child.prototype.constructor = child;
 981 | 
 982 |     // Set a convenience property in case the parent's prototype is needed later.
 983 |     child.__super__ = parent.prototype;
 984 | 
 985 |     return child;
 986 |   };
 987 | 
 988 |   // Helper function to get a URL from a Model or Collection as a property
 989 |   // or as a function.
 990 |   var getUrl = function(object) {
 991 |     if (!(object && object.url)) throw new Error("A 'url' property or function must be specified");
 992 |     return _.isFunction(object.url) ? object.url() : object.url;
 993 |   };
 994 | 
 995 |   // Wrap an optional error callback with a fallback error event.
 996 |   var wrapError = function(onError, model, options) {
 997 |     return function(resp) {
 998 |       if (onError) {
 999 |         onError(model, resp);
1000 |       } else {
1001 |         model.trigger('error', model, resp, options);
1002 |       }
1003 |     };
1004 |   };
1005 | 
1006 |   // Helper function to escape a string for HTML rendering.
1007 |   var escapeHTML = function(string) {
1008 |     return string.replace(/&(?!\w+;)/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
1009 |   };
1010 | 
1011 | })();
1012 | 


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