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