diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..1dfe31e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/log/*.log
+test/dummy/tmp/
+test/dummy/.sass-cache
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 0000000..c68498b
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Declare your gem's dependencies in chaplin-on-rails.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# jquery-rails is used by the dummy application
+gem "jquery-rails"
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'
diff --git a/Gemfile.lock b/Gemfile.lock
new file mode 100644
index 0000000..8ae2912
--- /dev/null
+++ b/Gemfile.lock
@@ -0,0 +1,115 @@
+PATH
+  remote: .
+  specs:
+    chaplin-on-rails (0.0.1)
+      coffee-rails
+      rails (>= 3.1)
+      requirejs-rails
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.11)
+      actionpack (= 3.2.11)
+      mail (~> 2.4.4)
+    actionpack (3.2.11)
+      activemodel (= 3.2.11)
+      activesupport (= 3.2.11)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.11)
+      activesupport (= 3.2.11)
+      builder (~> 3.0.0)
+    activerecord (3.2.11)
+      activemodel (= 3.2.11)
+      activesupport (= 3.2.11)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.11)
+      activemodel (= 3.2.11)
+      activesupport (= 3.2.11)
+    activesupport (3.2.11)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    ansi (1.4.3)
+    arel (3.0.2)
+    builder (3.0.4)
+    coffee-rails (3.2.2)
+      coffee-script (>= 2.2.0)
+      railties (~> 3.2.0)
+    coffee-script (2.2.0)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.4.0)
+    erubis (2.7.0)
+    execjs (1.4.0)
+      multi_json (~> 1.0)
+    hike (1.2.1)
+    i18n (0.6.1)
+    journey (1.0.4)
+    jquery-rails (2.1.4)
+      railties (>= 3.0, < 5.0)
+      thor (>= 0.14, < 2.0)
+    json (1.7.6)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.5.0)
+    polyglot (0.3.3)
+    rack (1.4.4)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.11)
+      actionmailer (= 3.2.11)
+      actionpack (= 3.2.11)
+      activerecord (= 3.2.11)
+      activeresource (= 3.2.11)
+      activesupport (= 3.2.11)
+      bundler (~> 1.0)
+      railties (= 3.2.11)
+    railties (3.2.11)
+      actionpack (= 3.2.11)
+      activesupport (= 3.2.11)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.0.3)
+    rdoc (3.12)
+      json (~> 1.4)
+    requirejs-rails (0.9.1)
+      railties (>= 3.1.1, < 3.3)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.7)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.12)
+      polyglot
+      polyglot (>= 0.3.1)
+    turn (0.9.6)
+      ansi
+    tzinfo (0.3.35)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  chaplin-on-rails!
+  jquery-rails
+  sqlite3
+  turn
diff --git a/MIT-LICENSE b/MIT-LICENSE
new file mode 100644
index 0000000..26afef2
--- /dev/null
+++ b/MIT-LICENSE
@@ -0,0 +1,20 @@
+Copyright 2013 aenaku
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..05d417d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,42 @@
+# ChaplinOnRails
+
+Gem for using [Chaplin.js](https://github.com/chaplinjs/chaplin) with Rails asset pipeline, based on
+[chaplin-rails](https://github.com/chaplinjs/chaplin-rails) boilerplate project.
+
+Since Chaplin requires module system this gem has
+[requirejs-rails](https://github.com/jwhitley/requirejs-rails) gem
+in dependecy. Those, you're forced to use `requirejs` for your project :)
+
+Gem already comes with `underscore.js` and `backbone.js`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chaplin-on-rails', git: 'git://github.com/eicaa/chaplin-on-rails.git'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Run
+
+    rails g chaplin:install
+
+It should create basic application structure with some basic files.
+To learn more about this see
+[chaplin-rails](https://github.com/chaplinjs/chaplin-rails).
+
+This gem generates new `application.js.coffee` for you, so you should
+migrate your old `application.js` to `requirejs` config file and remove
+`application.js` file.
+
+Also, there might be a problem with replacing `requirejs_include_tag`.
+Just follow for generator's output instructions.
+
+## TODO
+
+1. Write tests for install generator.
+2. Write generators for scaffold/resource/controller/model.
diff --git a/Rakefile b/Rakefile
new file mode 100644
index 0000000..17135a8
--- /dev/null
+++ b/Rakefile
@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ChaplinOnRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test
diff --git a/chaplin-on-rails.gemspec b/chaplin-on-rails.gemspec
new file mode 100644
index 0000000..eee808a
--- /dev/null
+++ b/chaplin-on-rails.gemspec
@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "chaplin-on-rails/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "chaplin-on-rails"
+  s.version     = ChaplinOnRails::VERSION
+  s.authors     = ["TODO: name"]
+  s.email       = ["TODO: email"]
+  s.homepage    = "TODO"
+  s.summary     = "TODO: Summary of ChaplinOnRails."
+  s.description = "TODO: Description of ChaplinOnRails."
+
+  s.files = Dir["{vendor,lib}/**/*"] + ["MIT-LICENSE", "Rakefile", "README.rdoc"]
+  s.test_files = Dir["test/**/*"]
+
+  s.add_dependency 'rails', '>= 3.1'
+  s.add_dependency 'coffee-rails'
+  s.add_dependency 'requirejs-rails'
+
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'turn'
+end
diff --git a/lib/chaplin-on-rails.rb b/lib/chaplin-on-rails.rb
new file mode 100644
index 0000000..bc56941
--- /dev/null
+++ b/lib/chaplin-on-rails.rb
@@ -0,0 +1,2 @@
+require "chaplin-on-rails/engine"
+require "chaplin-on-rails/version"
diff --git a/lib/chaplin-on-rails/engine.rb b/lib/chaplin-on-rails/engine.rb
new file mode 100644
index 0000000..149aa4d
--- /dev/null
+++ b/lib/chaplin-on-rails/engine.rb
@@ -0,0 +1,6 @@
+require 'requirejs-rails'
+
+module ChaplinOnRails
+  class Engine < Rails::Engine
+  end
+end
diff --git a/lib/chaplin-on-rails/version.rb b/lib/chaplin-on-rails/version.rb
new file mode 100644
index 0000000..9cb5747
--- /dev/null
+++ b/lib/chaplin-on-rails/version.rb
@@ -0,0 +1,3 @@
+module ChaplinOnRails
+  VERSION = "0.7.0-pre"
+end
diff --git a/lib/generators/chaplin/helpers.rb b/lib/generators/chaplin/helpers.rb
new file mode 100644
index 0000000..a462a29
--- /dev/null
+++ b/lib/generators/chaplin/helpers.rb
@@ -0,0 +1,94 @@
+module Chaplin
+  module Generators
+    module Helpers
+
+      def asset_path
+        File.join('app', 'assets')
+      end
+
+      def javascript_path
+        File.join(asset_path, 'javascripts')
+      end
+
+      def model_path
+        File.join(javascript_path, "models")
+      end
+
+      def view_path
+        File.join(javascript_path, "views")
+      end
+
+      def controller_path
+        File.join(javascript_path, "controllers")
+      end
+
+      def lib_path
+        File.join(javascript_path, "lib")
+      end
+
+      def base_path(path)
+        File.join(path, 'base')
+      end
+
+      def template_path
+        File.join(asset_path, "templates")
+      end
+
+      def singular_file_name
+        "#{file_name.singularize}#{@ext}"
+      end
+
+      def plural_file_name
+        "#{file_name.pluralize}#{@ext}"
+      end
+
+      def router_file_name
+        "#{file_name.pluralize}_router#{@ext}"
+      end
+
+      def view_file_name
+        "#{file_name.pluralize}_index#{@ext}"
+      end
+
+      def model_namespace
+        [app_name, "Models", file_name.singularize.camelize].join(".")
+      end
+
+      def collection_namespace
+        [app_name, "Collections", file_name.pluralize.camelize].join(".")
+      end
+
+      def router_namespace
+        [app_name, "Routers", file_name.pluralize.camelize].join(".")
+      end
+
+      def view_namespace
+        [app_name, "Views", "#{file_name.pluralize.camelize}Index"].join(".")
+      end
+
+      def template_namespace
+        File.join(file_path.pluralize, "index")
+      end
+
+      def app_name
+        rails_app_name.camelize
+      end
+
+      def app_filename
+        rails_app_name.underscore
+      end
+
+      def rails_app_name
+        Rails.application.class.name.split('::').first
+      end
+
+      def layout_path
+        Dir['app/views/layouts/application*'].first
+      end
+
+      def display(output, color = :green)
+        say(" - #{output}", color)
+      end
+    end
+  end
+end
diff --git a/lib/generators/chaplin/install/install_generator.rb b/lib/generators/chaplin/install/install_generator.rb
new file mode 100644
index 0000000..9470d80
--- /dev/null
+++ b/lib/generators/chaplin/install/install_generator.rb
@@ -0,0 +1,68 @@
+require 'generators/chaplin/helpers'
+
+module Chaplin
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Chaplin::Generators::Helpers
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Generates a Chaplin.js skeleton directory structure and manifest"
+
+      # TODO currently only coffee works
+      #class_option :javascript,
+                    #type: :boolean,
+                    #aliases: "-j",
+                    #default: false,
+                    #desc: "Generate JavaScript"
+
+      def copy_app_boilerplate
+        # it should remove empty directories during 'destroy' command
+        %w(controllers lib models views).each do |dir_name|
+          empty_directory File.join(javascript_path, dir_name)
+        end
+
+        # copy all /javascripts directory
+        directory 'javascripts', javascript_path
+
+        # create empty 'assets/templates' directory
+        empty_directory template_path
+      end
+
+      def generate_app_files
+        template "application.js.coffee", "#{javascript_path}/application.js.coffee"
+        template "app_template.js.coffee", "#{javascript_path}/#{app_filename}.js.coffee"
+      end
+
+      def apply_requirejs
+        # copy config file
+        copy_file 'requirejs.yml', 'config/requirejs.yml'
+
+        # check if we can find layout file
+        # TODO doesn't work during 'destroy' command
+        if layout_path
+          # inject requirejs tag
+          unless gsub_file(layout_path, /javascript_include_tag/, 'requirejs_include_tag')
+            display "Can't find a javascript_include_tag in '#{layout_path}'!"
+            display "You must add 'requirejs_include_tag' instead of 'javascript_include_tag'"
+            display "in your layout(s)."
+          end
+        else
+          display "Can't find a layout to inject requirejs tag!"
+          display "You must add 'requirejs_include_tag' instead of 'javascript_include_tag'"
+          display "in your layout(s)."
+        end
+      end
+
+
+      def post_install_messages
+        if File.exists?("#{javascript_path}/application.js")
+          display "You have 'application.js' file in your 'assets/' folder."
+          display "You should migrate all dependencies to the 'requirejs.yml' config file"
+          display "and remove 'application.js file."
+        end
+      end
+
+    end
+  end
+end
diff --git a/lib/generators/chaplin/install/templates/app_template.js.coffee b/lib/generators/chaplin/install/templates/app_template.js.coffee
new file mode 100644
index 0000000..173f330
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/app_template.js.coffee
@@ -0,0 +1,65 @@
+define [
+  'chaplin'
+  'views/layout'
+  'routes'
+  # Require base controllers manually because
+  # they aren’t compiled individually
+  # 'controllers/my_controller'
+], (Chaplin, Layout, routes) ->
+  'use strict'
+
+  # The application object
+  # Choose a meaningful name for your application
+  class <%= app_name %> extends Chaplin.Application
+
+    # Set your application name here so the document title is set to
+    # “Controller title – Site title” (see Layout#adjustTitle)
+    title: '<%= rails_app_name %>'
+
+    initialize: ->
+      super
+
+      # Initialize core components
+      @initDispatcher()
+      @initLayout()
+      @initMediator()
+
+      # Application-specific scaffold
+      @initControllers()
+
+      # Register all routes and start routing
+      @initRouter routes
+      # You might pass Router/History options as the second parameter.
+      # Chaplin enables pushState per default and Backbone uses / as
+      # the root per default. You might change that in the options
+      # if necessary:
+      # @initRouter routes, pushState: false, root: '/subdir/'
+
+      # Freeze the application instance to prevent further changes
+      Object.freeze? this
+
+    # Override standard layout initializer
+    # ------------------------------------
+    initLayout: ->
+      # Use an application-specific Layout class. Currently this adds
+      # no features to the standard Chaplin Layout, it’s an empty placeholder.
+      @layout = new Layout {@title}
+
+    # Instantiate common controllers
+    # ------------------------------
+    initControllers: ->
+      # These controllers are active during the whole application runtime.
+      # You don’t need to instantiate all controllers here, only special
+      # controllers which do not to respond to routes. They may govern models
+      # and views which are needed the whole time, for example header, footer
+      # or navigation views.
+      # e.g. new NavigationController()
+
+    # Create additional mediator properties
+    # -------------------------------------
+    initMediator: ->
+      # Create a user property
+      Chaplin.mediator.user = null
+      # Add additional application-specific properties and methods
+      # Seal the mediator
+      Chaplin.mediator.seal()
diff --git a/lib/generators/chaplin/install/templates/application.js.coffee b/lib/generators/chaplin/install/templates/application.js.coffee
new file mode 100644
index 0000000..764e4c0
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/application.js.coffee
@@ -0,0 +1,13 @@
+#
+# add '= require hamlcoffee' for hamlcoffee support
+#
+#= require_tree ../templates
+
+# Bootstrap the application
+require [
+  '<%= app_filename %>'
+], (<%= app_name %>) ->
+  'use strict'
+
+  app = new <%= app_name %>()
+  app.initialize()
diff --git a/lib/generators/chaplin/install/templates/javascripts/controllers/base/controller.js.coffee b/lib/generators/chaplin/install/templates/javascripts/controllers/base/controller.js.coffee
new file mode 100644
index 0000000..df7c385
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/controllers/base/controller.js.coffee
@@ -0,0 +1,8 @@
+define [
+  'chaplin'
+], (Chaplin) ->
+  'use strict'
+
+  class Controller extends Chaplin.Controller
+
+    # Place your application-specific controller features here
diff --git a/lib/generators/chaplin/install/templates/javascripts/lib/support.js.coffee b/lib/generators/chaplin/install/templates/javascripts/lib/support.js.coffee
new file mode 100644
index 0000000..46de5eb
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/lib/support.js.coffee
@@ -0,0 +1,19 @@
+define [
+  'underscore'
+  'lib/utils'
+  'chaplin'
+], (_, utils, Chaplin) ->
+
+  # Application-specific feature detection
+  # --------------------------------------
+
+  # Delegate to Chaplin’s support module
+  support = utils.beget Chaplin.support
+
+  # Add additional application-specific properties and methods
+
+  # _(support).extend
+  #   someProperty: 'foo'
+  #   someMethod: ->
+
+  support
diff --git a/lib/generators/chaplin/install/templates/javascripts/lib/utils.js.coffee b/lib/generators/chaplin/install/templates/javascripts/lib/utils.js.coffee
new file mode 100644
index 0000000..14060b8
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/lib/utils.js.coffee
@@ -0,0 +1,18 @@
+define [
+  'underscore'
+  'chaplin'
+], (_, Chaplin) ->
+
+  # Application-specific utilities
+  # ------------------------------
+
+  # Delegate to Chaplin’s utils module
+  utils = Chaplin.utils.beget Chaplin.utils
+
+  # Add additional application-specific properties and methods
+
+  # _(utils).extend
+  #   someProperty: 'foo'
+  #   someMethod: ->
+
+  utils
diff --git a/lib/generators/chaplin/install/templates/javascripts/lib/view_helper.js.coffee b/lib/generators/chaplin/install/templates/javascripts/lib/view_helper.js.coffee
new file mode 100644
index 0000000..769b49c
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/lib/view_helper.js.coffee
@@ -0,0 +1,16 @@
+define [
+  'chaplin'
+  'lib/utils'
+], (Handlebars, Chaplin, utils) ->
+  'use strict'
+
+  # View helpers (HAML Coffee in this case)
+  # ---------------------------------------
+
+  HAML.globals = ->
+    {
+      #someProperty: 'foo'
+      #someMethod: ->
+    }
+
+  null
diff --git a/lib/generators/chaplin/install/templates/javascripts/models/base/collection.js.coffee b/lib/generators/chaplin/install/templates/javascripts/models/base/collection.js.coffee
new file mode 100644
index 0000000..aecc8f1
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/models/base/collection.js.coffee
@@ -0,0 +1,9 @@
+define [
+  'chaplin'
+], (Chaplin) ->
+
+  class Collection extends Chaplin.Collection
+    # Mixin a synchronization state machine
+    # _(@prototype).extend Chaplin.SyncMachine
+
+    # Place your application-specific collection features here
diff --git a/lib/generators/chaplin/install/templates/javascripts/models/base/model.js.coffee b/lib/generators/chaplin/install/templates/javascripts/models/base/model.js.coffee
new file mode 100644
index 0000000..4da85b1
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/models/base/model.js.coffee
@@ -0,0 +1,9 @@
+define [
+  'chaplin'
+], (Chaplin) ->
+
+  class Model extends Chaplin.Model
+    # Mixin a synchronization state machine
+    # _(@prototype).extend Chaplin.SyncMachine
+
+    # Place your application-specific model features here
diff --git a/lib/generators/chaplin/install/templates/javascripts/routes.js.coffee b/lib/generators/chaplin/install/templates/javascripts/routes.js.coffee
new file mode 100644
index 0000000..7a6200f
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/routes.js.coffee
@@ -0,0 +1,9 @@
+define ->
+  'use strict'
+
+  # The routes for the application. This module returns a function.
+  # `match` is match method of the Router
+  (match) ->
+
+   #match '', 'pages#home'
+
diff --git a/lib/generators/chaplin/install/templates/javascripts/views/base/collection_view.coffee b/lib/generators/chaplin/install/templates/javascripts/views/base/collection_view.coffee
new file mode 100644
index 0000000..045d48e
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/views/base/collection_view.coffee
@@ -0,0 +1,11 @@
+define [
+  'chaplin',
+  'views/base/view'
+], (Chaplin, View) ->
+  'use strict'
+
+  class CollectionView extends Chaplin.CollectionView
+
+    # This class doesn’t inherit from the application-specific View class,
+    # so we need to borrow the method from the View prototype:
+    getTemplateFunction: View::getTemplateFunction
diff --git a/lib/generators/chaplin/install/templates/javascripts/views/base/view.coffee b/lib/generators/chaplin/install/templates/javascripts/views/base/view.coffee
new file mode 100644
index 0000000..dcf72ec
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/views/base/view.coffee
@@ -0,0 +1,15 @@
+define [
+  'chaplin'
+  'lib/view_helper' # Just load the view helpers, no return value
+], (Chaplin) ->
+  'use strict'
+
+  class View extends Chaplin.View
+
+    # change this method according to your templating system
+    getTemplateFunction: ->
+      templateFunction = JST[@templateName]
+      if typeof @templateName is 'string' and typeof templateFunction isnt 'function'
+        throw new Error "View template #{@templateName} not found"
+
+      templateFunction
diff --git a/lib/generators/chaplin/install/templates/javascripts/views/layout.js.coffee b/lib/generators/chaplin/install/templates/javascripts/views/layout.js.coffee
new file mode 100644
index 0000000..c38927c
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/javascripts/views/layout.js.coffee
@@ -0,0 +1,8 @@
+define [
+  'chaplin'
+], (Chaplin) ->
+  'use strict'
+
+  class Layout extends Chaplin.Layout
+
+    # Place your application-specific Layout features here
diff --git a/lib/generators/chaplin/install/templates/requirejs.yml b/lib/generators/chaplin/install/templates/requirejs.yml
new file mode 100644
index 0000000..0a9bfbc
--- /dev/null
+++ b/lib/generators/chaplin/install/templates/requirejs.yml
@@ -0,0 +1,6 @@
+shim:
+  'underscore':
+    exports: '_'
+  'backbone':
+    deps: ['underscore', 'jquery']
+    exports: 'Backbone'
diff --git a/test/chaplin-on-rails_test.rb b/test/chaplin-on-rails_test.rb
new file mode 100644
index 0000000..c3a8bc6
--- /dev/null
+++ b/test/chaplin-on-rails_test.rb
@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class ChaplinOnRailsTest < ActiveSupport::TestCase
+  def setup
+    @app = Dummy::Application
+  end
+  
+  test "backbone.js is found as an asset" do
+    assert_not_nil @app.assets["backbone"]
+  end
+  
+  test "underscore.js is found as an asset" do
+    assert_not_nil @app.assets["underscore"]
+  end
+
+  test "chaplin.js is found as an asset" do
+    assert_not_nil @app.assets["chaplin"]
+  end
+end
diff --git a/test/dummy/README.rdoc b/test/dummy/README.rdoc
new file mode 100644
index 0000000..7c36f23
--- /dev/null
+++ b/test/dummy/README.rdoc
@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.
diff --git a/test/dummy/Rakefile b/test/dummy/Rakefile
new file mode 100644
index 0000000..3645852
--- /dev/null
+++ b/test/dummy/Rakefile
@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks
diff --git a/test/dummy/app/assets/stylesheets/application.css b/test/dummy/app/assets/stylesheets/application.css
new file mode 100644
index 0000000..3192ec8
--- /dev/null
+++ b/test/dummy/app/assets/stylesheets/application.css
@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */
diff --git a/test/dummy/app/controllers/application_controller.rb b/test/dummy/app/controllers/application_controller.rb
new file mode 100644
index 0000000..e8065d9
--- /dev/null
+++ b/test/dummy/app/controllers/application_controller.rb
@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end
diff --git a/test/dummy/app/controllers/home_controller.rb b/test/dummy/app/controllers/home_controller.rb
new file mode 100644
index 0000000..3181ce6
--- /dev/null
+++ b/test/dummy/app/controllers/home_controller.rb
@@ -0,0 +1,5 @@
+class HomeController < ApplicationController
+  def index
+
+  end
+end
diff --git a/test/dummy/app/helpers/application_helper.rb b/test/dummy/app/helpers/application_helper.rb
new file mode 100644
index 0000000..de6be79
--- /dev/null
+++ b/test/dummy/app/helpers/application_helper.rb
@@ -0,0 +1,2 @@
+module ApplicationHelper
+end
diff --git a/test/dummy/app/helpers/home_helper.rb b/test/dummy/app/helpers/home_helper.rb
new file mode 100644
index 0000000..23de56a
--- /dev/null
+++ b/test/dummy/app/helpers/home_helper.rb
@@ -0,0 +1,2 @@
+module HomeHelper
+end
diff --git a/test/dummy/app/mailers/.gitkeep b/test/dummy/app/mailers/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/test/dummy/app/models/.gitkeep b/test/dummy/app/models/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/test/dummy/app/views/home/index.html.erb b/test/dummy/app/views/home/index.html.erb
new file mode 100644
index 0000000..fd932e9
--- /dev/null
+++ b/test/dummy/app/views/home/index.html.erb
@@ -0,0 +1 @@
+<div id="chaplin"></div>
diff --git a/test/dummy/app/views/layouts/application.html.erb b/test/dummy/app/views/layouts/application.html.erb
new file mode 100644
index 0000000..4cab268
--- /dev/null
+++ b/test/dummy/app/views/layouts/application.html.erb
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application", :media => "all" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>
diff --git a/test/dummy/config.ru b/test/dummy/config.ru
new file mode 100644
index 0000000..1989ed8
--- /dev/null
+++ b/test/dummy/config.ru
@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run Dummy::Application
diff --git a/test/dummy/config/application.rb b/test/dummy/config/application.rb
new file mode 100644
index 0000000..77ac926
--- /dev/null
+++ b/test/dummy/config/application.rb
@@ -0,0 +1,59 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require
+require "chaplin-on-rails"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable escaping HTML in JSON.
+    config.active_support.escape_html_entities_in_json = true
+
+    # Use SQL instead of Active Record's schema dumper when creating the database.
+    # This is necessary if your schema can't be completely dumped by the schema dumper,
+    # like if you have constraints or database-specific column types
+    # config.active_record.schema_format = :sql
+
+    # Enforce whitelist mode for mass assignment.
+    # This will create an empty whitelist of attributes available for mass-assignment for all models
+    # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
+    # parameters by using an attr_accessible or attr_protected declaration.
+    config.active_record.whitelist_attributes = true
+
+    # Enable the asset pipeline
+    config.assets.enabled = true
+
+    # Version of your assets, change this if you want to expire all your assets
+    config.assets.version = '1.0'
+  end
+end
+
diff --git a/test/dummy/config/boot.rb b/test/dummy/config/boot.rb
new file mode 100644
index 0000000..eba0681
--- /dev/null
+++ b/test/dummy/config/boot.rb
@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)
\ No newline at end of file
diff --git a/test/dummy/config/database.yml b/test/dummy/config/database.yml
new file mode 100644
index 0000000..51a4dd4
--- /dev/null
+++ b/test/dummy/config/database.yml
@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000
diff --git a/test/dummy/config/environment.rb b/test/dummy/config/environment.rb
new file mode 100644
index 0000000..3da5eb9
--- /dev/null
+++ b/test/dummy/config/environment.rb
@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!
diff --git a/test/dummy/config/environments/development.rb b/test/dummy/config/environments/development.rb
new file mode 100644
index 0000000..82c74d1
--- /dev/null
+++ b/test/dummy/config/environments/development.rb
@@ -0,0 +1,37 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Don't care if the mailer can't send
+  config.action_mailer.raise_delivery_errors = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Only use best-standards-support built into browsers
+  config.action_dispatch.best_standards_support = :builtin
+
+  # Raise exception on mass assignment protection for Active Record models
+  config.active_record.mass_assignment_sanitizer = :strict
+
+  # Log the query plan for queries taking more than this (works
+  # with SQLite, MySQL, and PostgreSQL)
+  config.active_record.auto_explain_threshold_in_seconds = 0.5
+
+  # Do not compress assets
+  config.assets.compress = false
+
+  # Expands the lines which load the assets
+  config.assets.debug = true
+end
diff --git a/test/dummy/config/environments/production.rb b/test/dummy/config/environments/production.rb
new file mode 100644
index 0000000..bdac56a
--- /dev/null
+++ b/test/dummy/config/environments/production.rb
@@ -0,0 +1,67 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # Code is not reloaded between requests
+  config.cache_classes = true
+
+  # Full error reports are disabled and caching is turned on
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Disable Rails's static asset server (Apache or nginx will already do this)
+  config.serve_static_assets = false
+
+  # Compress JavaScripts and CSS
+  config.assets.compress = true
+
+  # Don't fallback to assets pipeline if a precompiled asset is missed
+  config.assets.compile = false
+
+  # Generate digests for assets URLs
+  config.assets.digest = true
+
+  # Defaults to nil and saved in location specified by config.assets.prefix
+  # config.assets.manifest = YOUR_PATH
+
+  # Specifies the header that your server uses for sending files
+  # config.action_dispatch.x_sendfile_header = "X-Sendfile" # for apache
+  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # See everything in the log (default is :info)
+  # config.log_level = :debug
+
+  # Prepend all log lines with the following tags
+  # config.log_tags = [ :subdomain, :uuid ]
+
+  # Use a different logger for distributed setups
+  # config.logger = ActiveSupport::TaggedLogging.new(SyslogLogger.new)
+
+  # Use a different cache store in production
+  # config.cache_store = :mem_cache_store
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server
+  # config.action_controller.asset_host = "http://assets.example.com"
+
+  # Precompile additional assets (application.js, application.css, and all non-JS/CSS are already added)
+  # config.assets.precompile += %w( search.js )
+
+  # Disable delivery errors, bad email addresses will be ignored
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable threaded mode
+  # config.threadsafe!
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation can not be found)
+  config.i18n.fallbacks = true
+
+  # Send deprecation notices to registered listeners
+  config.active_support.deprecation = :notify
+
+  # Log the query plan for queries taking more than this (works
+  # with SQLite, MySQL, and PostgreSQL)
+  # config.active_record.auto_explain_threshold_in_seconds = 0.5
+end
diff --git a/test/dummy/config/environments/test.rb b/test/dummy/config/environments/test.rb
new file mode 100644
index 0000000..f1a4814
--- /dev/null
+++ b/test/dummy/config/environments/test.rb
@@ -0,0 +1,37 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # The test environment is used exclusively to run your application's
+  # test suite. You never need to work with it otherwise. Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs. Don't rely on the data there!
+  config.cache_classes = true
+
+  # Configure static asset server for tests with Cache-Control for performance
+  config.serve_static_assets = true
+  config.static_cache_control = "public, max-age=3600"
+
+  # Log error messages when you accidentally call methods on nil
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Raise exceptions instead of rendering exception templates
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment
+  config.action_controller.allow_forgery_protection    = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Raise exception on mass assignment protection for Active Record models
+  config.active_record.mass_assignment_sanitizer = :strict
+
+  # Print deprecation notices to the stderr
+  config.active_support.deprecation = :stderr
+end
diff --git a/test/dummy/config/initializers/backtrace_silencers.rb b/test/dummy/config/initializers/backtrace_silencers.rb
new file mode 100644
index 0000000..59385cd
--- /dev/null
+++ b/test/dummy/config/initializers/backtrace_silencers.rb
@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!
diff --git a/test/dummy/config/initializers/inflections.rb b/test/dummy/config/initializers/inflections.rb
new file mode 100644
index 0000000..5d8d9be
--- /dev/null
+++ b/test/dummy/config/initializers/inflections.rb
@@ -0,0 +1,15 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+#
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.acronym 'RESTful'
+# end
diff --git a/test/dummy/config/initializers/mime_types.rb b/test/dummy/config/initializers/mime_types.rb
new file mode 100644
index 0000000..72aca7e
--- /dev/null
+++ b/test/dummy/config/initializers/mime_types.rb
@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone
diff --git a/test/dummy/config/initializers/secret_token.rb b/test/dummy/config/initializers/secret_token.rb
new file mode 100644
index 0000000..933e729
--- /dev/null
+++ b/test/dummy/config/initializers/secret_token.rb
@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+Dummy::Application.config.secret_token = 'e5a6dc17a0525a29983af7ed73aa05875ed7271e9c850bf420a73c4564e358576e41dd8cccf04f6b2155d586b26b15dc90d27745c971127f890241c6c4c2c9e7'
diff --git a/test/dummy/config/initializers/session_store.rb b/test/dummy/config/initializers/session_store.rb
new file mode 100644
index 0000000..952473f
--- /dev/null
+++ b/test/dummy/config/initializers/session_store.rb
@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+Dummy::Application.config.session_store :cookie_store, key: '_dummy_session'
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rails generate session_migration")
+# Dummy::Application.config.session_store :active_record_store
diff --git a/test/dummy/config/initializers/wrap_parameters.rb b/test/dummy/config/initializers/wrap_parameters.rb
new file mode 100644
index 0000000..999df20
--- /dev/null
+++ b/test/dummy/config/initializers/wrap_parameters.rb
@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+#
+# This file contains settings for ActionController::ParamsWrapper which
+# is enabled by default.
+
+# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
+ActiveSupport.on_load(:action_controller) do
+  wrap_parameters format: [:json]
+end
+
+# Disable root element in JSON by default.
+ActiveSupport.on_load(:active_record) do
+  self.include_root_in_json = false
+end
diff --git a/test/dummy/config/locales/en.yml b/test/dummy/config/locales/en.yml
new file mode 100644
index 0000000..179c14c
--- /dev/null
+++ b/test/dummy/config/locales/en.yml
@@ -0,0 +1,5 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See https://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  hello: "Hello world"
diff --git a/test/dummy/config/routes.rb b/test/dummy/config/routes.rb
new file mode 100644
index 0000000..3e7d5ea
--- /dev/null
+++ b/test/dummy/config/routes.rb
@@ -0,0 +1,58 @@
+Dummy::Application.routes.draw do
+  # The priority is based upon order of creation:
+  # first created -> highest priority.
+
+  # Sample of regular route:
+  #   match 'products/:id' => 'catalog#view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # Sample resource route (maps HTTP verbs to controller actions automatically):
+  #   resources :products
+
+  # Sample resource route with options:
+  #   resources :products do
+  #     member do
+  #       get 'short'
+  #       post 'toggle'
+  #     end
+  #
+  #     collection do
+  #       get 'sold'
+  #     end
+  #   end
+
+  # Sample resource route with sub-resources:
+  #   resources :products do
+  #     resources :comments, :sales
+  #     resource :seller
+  #   end
+
+  # Sample resource route with more complex sub-resources
+  #   resources :products do
+  #     resources :comments
+  #     resources :sales do
+  #       get 'recent', :on => :collection
+  #     end
+  #   end
+
+  # Sample resource route within a namespace:
+  #   namespace :admin do
+  #     # Directs /admin/products/* to Admin::ProductsController
+  #     # (app/controllers/admin/products_controller.rb)
+  #     resources :products
+  #   end
+
+  # You can have the root of your site routed with "root"
+  # just remember to delete public/index.html.
+  root :to => 'home#index'
+
+  # See how all your routes lay out with "rake routes"
+
+  # This is a legacy wild controller route that's not recommended for RESTful applications.
+  # Note: This route will make all actions in every controller accessible via GET requests.
+  # match ':controller(/:action(/:id))(.:format)'
+end
diff --git a/test/dummy/log/.gitkeep b/test/dummy/log/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/test/dummy/public/404.html b/test/dummy/public/404.html
new file mode 100644
index 0000000..9a48320
--- /dev/null
+++ b/test/dummy/public/404.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <h1>The page you were looking for doesn't exist.</h1>
+    <p>You may have mistyped the address or the page may have moved.</p>
+  </div>
+</body>
+</html>
diff --git a/test/dummy/public/422.html b/test/dummy/public/422.html
new file mode 100644
index 0000000..83660ab
--- /dev/null
+++ b/test/dummy/public/422.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <h1>The change you wanted was rejected.</h1>
+    <p>Maybe you tried to change something you didn't have access to.</p>
+  </div>
+</body>
+</html>
diff --git a/test/dummy/public/500.html b/test/dummy/public/500.html
new file mode 100644
index 0000000..f3648a0
--- /dev/null
+++ b/test/dummy/public/500.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+  </div>
+</body>
+</html>
diff --git a/test/dummy/public/favicon.ico b/test/dummy/public/favicon.ico
new file mode 100644
index 0000000..e69de29
diff --git a/test/dummy/script/rails b/test/dummy/script/rails
new file mode 100755
index 0000000..f8da2cf
--- /dev/null
+++ b/test/dummy/script/rails
@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'
diff --git a/test/test_helper.rb b/test/test_helper.rb
new file mode 100644
index 0000000..d231467
--- /dev/null
+++ b/test/test_helper.rb
@@ -0,0 +1,7 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+
+Rails.backtrace_cleaner.remove_silencers!
diff --git a/vendor/assets/javascripts/backbone.js b/vendor/assets/javascripts/backbone.js
new file mode 100644
index 0000000..07ed747
--- /dev/null
+++ b/vendor/assets/javascripts/backbone.js
@@ -0,0 +1,1497 @@
+//     Backbone.js 0.9.9
+
+//     (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc.
+//     Backbone may be freely distributed under the MIT license.
+//     For all details and documentation:
+//     http://backbonejs.org
+
+(function(){
+
+  // Initial Setup
+  // -------------
+
+  // Save a reference to the global object (`window` in the browser, `exports`
+  // on the server).
+  var root = this;
+
+  // Save the previous value of the `Backbone` variable, so that it can be
+  // restored later on, if `noConflict` is used.
+  var previousBackbone = root.Backbone;
+
+  // Create a local reference to array methods.
+  var array = [];
+  var push = array.push;
+  var slice = array.slice;
+  var splice = array.splice;
+
+  // The top-level namespace. All public Backbone classes and modules will
+  // be attached to this. Exported for both CommonJS and the browser.
+  var Backbone;
+  if (typeof exports !== 'undefined') {
+    Backbone = exports;
+  } else {
+    Backbone = root.Backbone = {};
+  }
+
+  // Current version of the library. Keep in sync with `package.json`.
+  Backbone.VERSION = '0.9.9';
+
+  // Require Underscore, if we're on the server, and it's not already present.
+  var _ = root._;
+  if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
+
+  // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable.
+  Backbone.$ = root.jQuery || root.Zepto || root.ender;
+
+  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
+  // to its previous owner. Returns a reference to this Backbone object.
+  Backbone.noConflict = function() {
+    root.Backbone = previousBackbone;
+    return this;
+  };
+
+  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
+  // will fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and
+  // set a `X-Http-Method-Override` header.
+  Backbone.emulateHTTP = false;
+
+  // Turn on `emulateJSON` to support legacy servers that can't deal with direct
+  // `application/json` requests ... will encode the body as
+  // `application/x-www-form-urlencoded` instead and will send the model in a
+  // form param named `model`.
+  Backbone.emulateJSON = false;
+
+  // Backbone.Events
+  // ---------------
+
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Implement fancy features of the Events API such as multiple event
+  // names `"change blur"` and jQuery-style event maps `{change: action}`
+  // in terms of the existing API.
+  var eventsApi = function(obj, action, name, rest) {
+    if (!name) return true;
+    if (typeof name === 'object') {
+      for (var key in name) {
+        obj[action].apply(obj, [key, name[key]].concat(rest));
+      }
+    } else if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        obj[action].apply(obj, [names[i]].concat(rest));
+      }
+    } else {
+      return true;
+    }
+  };
+
+  // Optimized internal dispatch function for triggering events. Tries to
+  // keep the usual cases speedy (most Backbone events have 3 arguments).
+  var triggerEvents = function(obj, events, args) {
+    var ev, i = -1, l = events.length;
+    switch (args.length) {
+    case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx);
+    return;
+    case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]);
+    return;
+    case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);
+    return;
+    case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);
+    return;
+    default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+    }
+  };
+
+  // A module that can be mixed in to *any object* in order to provide it with
+  // custom events. You may bind with `on` or remove with `off` callback
+  // functions to an event; `trigger`-ing an event fires all callbacks in
+  // succession.
+  //
+  //     var object = {};
+  //     _.extend(object, Backbone.Events);
+  //     object.on('expand', function(){ alert('expanded'); });
+  //     object.trigger('expand');
+  //
+  var Events = Backbone.Events = {
+
+    // Bind one or more space separated events, or an events map,
+    // to a `callback` function. Passing `"all"` will bind the callback to
+    // all events fired.
+    on: function(name, callback, context) {
+      if (!(eventsApi(this, 'on', name, [callback, context]) && callback)) return this;
+      this._events || (this._events = {});
+      var list = this._events[name] || (this._events[name] = []);
+      list.push({callback: callback, context: context, ctx: context || this});
+      return this;
+    },
+
+    // Bind events to only be triggered a single time. After the first time
+    // the callback is invoked, it will be removed.
+    once: function(name, callback, context) {
+      if (!(eventsApi(this, 'once', name, [callback, context]) && callback)) return this;
+      var self = this;
+      var once = _.once(function() {
+        self.off(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+      this.on(name, once, context);
+      return this;
+    },
+
+    // Remove one or many callbacks. If `context` is null, removes all
+    // callbacks with that function. If `callback` is null, removes all
+    // callbacks for the event. If `name` is null, removes all bound
+    // callbacks for all events.
+    off: function(name, callback, context) {
+      var list, ev, events, names, i, l, j, k;
+      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+      if (!name && !callback && !context) {
+        this._events = {};
+        return this;
+      }
+
+      names = name ? [name] : _.keys(this._events);
+      for (i = 0, l = names.length; i < l; i++) {
+        name = names[i];
+        if (list = this._events[name]) {
+          events = [];
+          if (callback || context) {
+            for (j = 0, k = list.length; j < k; j++) {
+              ev = list[j];
+              if ((callback && callback !== ev.callback &&
+                               callback !== ev.callback._callback) ||
+                  (context && context !== ev.context)) {
+                events.push(ev);
+              }
+            }
+          }
+          this._events[name] = events;
+        }
+      }
+
+      return this;
+    },
+
+    // Trigger one or many events, firing all bound callbacks. Callbacks are
+    // passed the same arguments as `trigger` is, apart from the event name
+    // (unless you're listening on `"all"`, which will cause your callback to
+    // receive the true name of the event as the first argument).
+    trigger: function(name) {
+      if (!this._events) return this;
+      var args = slice.call(arguments, 1);
+      if (!eventsApi(this, 'trigger', name, args)) return this;
+      var events = this._events[name];
+      var allEvents = this._events.all;
+      if (events) triggerEvents(this, events, args);
+      if (allEvents) triggerEvents(this, allEvents, arguments);
+      return this;
+    },
+
+    // An inversion-of-control version of `on`. Tell *this* object to listen to
+    // an event in another object ... keeping track of what it's listening to.
+    listenTo: function(object, events, callback) {
+      var listeners = this._listeners || (this._listeners = {});
+      var id = object._listenerId || (object._listenerId = _.uniqueId('l'));
+      listeners[id] = object;
+      object.on(events, callback || this, this);
+      return this;
+    },
+
+    // Tell this object to stop listening to either specific events ... or
+    // to every object it's currently listening to.
+    stopListening: function(object, events, callback) {
+      var listeners = this._listeners;
+      if (!listeners) return;
+      if (object) {
+        object.off(events, callback, this);
+        if (!events && !callback) delete listeners[object._listenerId];
+      } else {
+        for (var id in listeners) {
+          listeners[id].off(null, null, this);
+        }
+        this._listeners = {};
+      }
+      return this;
+    }
+  };
+
+  // Aliases for backwards compatibility.
+  Events.bind   = Events.on;
+  Events.unbind = Events.off;
+
+  // Allow the `Backbone` object to serve as a global event bus, for folks who
+  // want global "pubsub" in a convenient place.
+  _.extend(Backbone, Events);
+
+  // Backbone.Model
+  // --------------
+
+  // Create a new model, with defined attributes. A client id (`cid`)
+  // is automatically generated and assigned for you.
+  var Model = Backbone.Model = function(attributes, options) {
+    var defaults;
+    var attrs = attributes || {};
+    this.cid = _.uniqueId('c');
+    this.attributes = {};
+    if (options && options.collection) this.collection = options.collection;
+    if (options && options.parse) attrs = this.parse(attrs, options) || {};
+    if (defaults = _.result(this, 'defaults')) {
+      attrs = _.defaults({}, attrs, defaults);
+    }
+    this.set(attrs, options);
+    this.changed = {};
+    this.initialize.apply(this, arguments);
+  };
+
+  // Attach all inheritable methods to the Model prototype.
+  _.extend(Model.prototype, Events, {
+
+    // A hash of attributes whose current and previous value differ.
+    changed: null,
+
+    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+    // CouchDB users may want to set this to `"_id"`.
+    idAttribute: 'id',
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Return a copy of the model's `attributes` object.
+    toJSON: function(options) {
+      return _.clone(this.attributes);
+    },
+
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Get the value of an attribute.
+    get: function(attr) {
+      return this.attributes[attr];
+    },
+
+    // Get the HTML-escaped value of an attribute.
+    escape: function(attr) {
+      return _.escape(this.get(attr));
+    },
+
+    // Returns `true` if the attribute contains a value that is not null
+    // or undefined.
+    has: function(attr) {
+      return this.get(attr) != null;
+    },
+
+    // ----------------------------------------------------------------------
+
+    // Set a hash of model attributes on the object, firing `"change"` unless
+    // you choose to silence it.
+    set: function(key, val, options) {
+      var attr, attrs, unset, changes, silent, changing, prev, current;
+      if (key == null) return this;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      options || (options = {});
+
+      // Run validation.
+      if (!this._validate(attrs, options)) return false;
+
+      // Extract attributes and options.
+      unset           = options.unset;
+      silent          = options.silent;
+      changes         = [];
+      changing        = this._changing;
+      this._changing  = true;
+
+      if (!changing) {
+        this._previousAttributes = _.clone(this.attributes);
+        this.changed = {};
+      }
+      current = this.attributes, prev = this._previousAttributes;
+
+      // Check for changes of `id`.
+      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+
+      // For each `set` attribute, update or delete the current value.
+      for (attr in attrs) {
+        val = attrs[attr];
+        if (!_.isEqual(current[attr], val)) changes.push(attr);
+        if (!_.isEqual(prev[attr], val)) {
+          this.changed[attr] = val;
+        } else {
+          delete this.changed[attr];
+        }
+        unset ? delete current[attr] : current[attr] = val;
+      }
+
+      // Trigger all relevant attribute changes.
+      if (!silent) {
+        if (changes.length) this._pending = true;
+        for (var i = 0, l = changes.length; i < l; i++) {
+          this.trigger('change:' + changes[i], this, current[changes[i]], options);
+        }
+      }
+
+      if (changing) return this;
+      if (!silent) {
+        while (this._pending) {
+          this._pending = false;
+          this.trigger('change', this, options);
+        }
+      }
+      this._pending = false;
+      this._changing = false;
+      return this;
+    },
+
+    // Remove an attribute from the model, firing `"change"` unless you choose
+    // to silence it. `unset` is a noop if the attribute doesn't exist.
+    unset: function(attr, options) {
+      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
+    },
+
+    // Clear all attributes on the model, firing `"change"` unless you choose
+    // to silence it.
+    clear: function(options) {
+      var attrs = {};
+      for (var key in this.attributes) attrs[key] = void 0;
+      return this.set(attrs, _.extend({}, options, {unset: true}));
+    },
+
+    // Determine if the model has changed since the last `"change"` event.
+    // If you specify an attribute name, determine if that attribute has changed.
+    hasChanged: function(attr) {
+      if (attr == null) return !_.isEmpty(this.changed);
+      return _.has(this.changed, attr);
+    },
+
+    // Return an object containing all the attributes that have changed, or
+    // false if there are no changed attributes. Useful for determining what
+    // parts of a view need to be updated and/or what attributes need to be
+    // persisted to the server. Unset attributes will be set to undefined.
+    // You can also pass an attributes object to diff against the model,
+    // determining if there *would be* a change.
+    changedAttributes: function(diff) {
+      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
+      var val, changed = false;
+      var old = this._changing ? this._previousAttributes : this.attributes;
+      for (var attr in diff) {
+        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
+        (changed || (changed = {}))[attr] = val;
+      }
+      return changed;
+    },
+
+    // Get the previous value of an attribute, recorded at the time the last
+    // `"change"` event was fired.
+    previous: function(attr) {
+      if (attr == null || !this._previousAttributes) return null;
+      return this._previousAttributes[attr];
+    },
+
+    // Get all of the attributes of the model at the time of the previous
+    // `"change"` event.
+    previousAttributes: function() {
+      return _.clone(this._previousAttributes);
+    },
+
+    // ---------------------------------------------------------------------
+
+    // Fetch the model from the server. If the server's representation of the
+    // model differs from its current attributes, they will be overriden,
+    // triggering a `"change"` event.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var success = options.success;
+      options.success = function(model, resp, options) {
+        if (!model.set(model.parse(resp, options), options)) return false;
+        if (success) success(model, resp, options);
+      };
+      return this.sync('read', this, options);
+    },
+
+    // Set a hash of model attributes, and sync the model to the server.
+    // If the server returns an attributes hash that differs, the model's
+    // state will be `set` again.
+    save: function(key, val, options) {
+      var attrs, success, method, xhr, attributes = this.attributes;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (key == null || typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
+      if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
+
+      options = _.extend({validate: true}, options);
+
+      // Do not persist invalid models.
+      if (!this._validate(attrs, options)) return false;
+
+      // Set temporary attributes if `{wait: true}`.
+      if (attrs && options.wait) {
+        this.attributes = _.extend({}, attributes, attrs);
+      }
+
+      // After a successful server-side save, the client is (optionally)
+      // updated with the server-side state.
+      if (options.parse === void 0) options.parse = true;
+      success = options.success;
+      options.success = function(model, resp, options) {
+        // Ensure attributes are restored during synchronous saves.
+        model.attributes = attributes;
+        var serverAttrs = model.parse(resp, options);
+        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
+        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
+          return false;
+        }
+        if (success) success(model, resp, options);
+      };
+
+      // Finish configuring and sending the Ajax request.
+      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+      if (method == 'patch') options.attrs = attrs;
+      xhr = this.sync(method, this, options);
+
+      // Restore attributes.
+      if (attrs && options.wait) this.attributes = attributes;
+
+      return xhr;
+    },
+
+    // Destroy this model on the server if it was already persisted.
+    // Optimistically removes the model from its collection, if it has one.
+    // If `wait: true` is passed, waits for the server to respond before removal.
+    destroy: function(options) {
+      options = options ? _.clone(options) : {};
+      var model = this;
+      var success = options.success;
+
+      var destroy = function() {
+        model.trigger('destroy', model, model.collection, options);
+      };
+
+      options.success = function(model, resp, options) {
+        if (options.wait || model.isNew()) destroy();
+        if (success) success(model, resp, options);
+      };
+
+      if (this.isNew()) {
+        options.success(this, null, options);
+        return false;
+      }
+
+      var xhr = this.sync('delete', this, options);
+      if (!options.wait) destroy();
+      return xhr;
+    },
+
+    // Default URL for the model's representation on the server -- if you're
+    // using Backbone's restful methods, override this to change the endpoint
+    // that will be called.
+    url: function() {
+      var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
+      if (this.isNew()) return base;
+      return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
+    },
+
+    // **parse** converts a response into the hash of attributes to be `set` on
+    // the model. The default implementation is just to pass the response along.
+    parse: function(resp, options) {
+      return resp;
+    },
+
+    // Create a new model with identical attributes to this one.
+    clone: function() {
+      return new this.constructor(this.attributes);
+    },
+
+    // A model is new if it has never been saved to the server, and lacks an id.
+    isNew: function() {
+      return this.id == null;
+    },
+
+    // Check if the model is currently in a valid state.
+    isValid: function(options) {
+      return !this.validate || !this.validate(this.attributes, options);
+    },
+
+    // Run validation against the next complete set of model attributes,
+    // returning `true` if all is well. Otherwise, fire a general
+    // `"error"` event and call the error callback, if specified.
+    _validate: function(attrs, options) {
+      if (!options.validate || !this.validate) return true;
+      attrs = _.extend({}, this.attributes, attrs);
+      var error = this.validationError = this.validate(attrs, options) || null;
+      if (!error) return true;
+      this.trigger('invalid', this, error, options || {});
+      return false;
+    }
+
+  });
+
+  // Backbone.Collection
+  // -------------------
+
+  // Provides a standard collection class for our sets of models, ordered
+  // or unordered. If a `comparator` is specified, the Collection will maintain
+  // its models in sort order, as they're added and removed.
+  var Collection = Backbone.Collection = function(models, options) {
+    options || (options = {});
+    if (options.model) this.model = options.model;
+    if (options.comparator !== void 0) this.comparator = options.comparator;
+    this.models = [];
+    this._reset();
+    this.initialize.apply(this, arguments);
+    if (models) this.reset(models, _.extend({silent: true}, options));
+  };
+
+  // Define the Collection's inheritable methods.
+  _.extend(Collection.prototype, Events, {
+
+    // The default model for a collection is just a **Backbone.Model**.
+    // This should be overridden in most cases.
+    model: Model,
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // The JSON representation of a Collection is an array of the
+    // models' attributes.
+    toJSON: function(options) {
+      return this.map(function(model){ return model.toJSON(options); });
+    },
+
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Add a model, or list of models to the set.
+    add: function(models, options) {
+      models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, model, attrs, existing, doSort, add, at, sort, sortAttr;
+      add = [];
+      at = options.at;
+      sort = this.comparator && (at == null) && options.sort != false;
+      sortAttr = _.isString(this.comparator) ? this.comparator : null;
+
+      // Turn bare objects into model references, and prevent invalid models
+      // from being added.
+      for (i = 0, l = models.length; i < l; i++) {
+        if (!(model = this._prepareModel(attrs = models[i], options))) {
+          this.trigger('invalid', this, attrs, options);
+          continue;
+        }
+
+        // If a duplicate is found, prevent it from being added and
+        // optionally merge it into the existing model.
+        if (existing = this.get(model)) {
+          if (options.merge) {
+            existing.set(attrs === model ? model.attributes : attrs, options);
+            if (sort && !doSort && existing.hasChanged(sortAttr)) doSort = true;
+          }
+          continue;
+        }
+
+        // This is a new model, push it to the `add` list.
+        add.push(model);
+
+        // Listen to added models' events, and index models for lookup by
+        // `id` and by `cid`.
+        model.on('all', this._onModelEvent, this);
+        this._byId[model.cid] = model;
+        if (model.id != null) this._byId[model.id] = model;
+      }
+
+      // See if sorting is needed, update `length` and splice in new models.
+      if (add.length) {
+        if (sort) doSort = true;
+        this.length += add.length;
+        if (at != null) {
+          splice.apply(this.models, [at, 0].concat(add));
+        } else {
+          push.apply(this.models, add);
+        }
+      }
+
+      // Silently sort the collection if appropriate.
+      if (doSort) this.sort({silent: true});
+
+      if (options.silent) return this;
+
+      // Trigger `add` events.
+      for (i = 0, l = add.length; i < l; i++) {
+        (model = add[i]).trigger('add', model, this, options);
+      }
+
+      // Trigger `sort` if the collection was sorted.
+      if (doSort) this.trigger('sort', this, options);
+
+      return this;
+    },
+
+    // Remove a model, or a list of models from the set.
+    remove: function(models, options) {
+      models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, index, model;
+      for (i = 0, l = models.length; i < l; i++) {
+        model = this.get(models[i]);
+        if (!model) continue;
+        delete this._byId[model.id];
+        delete this._byId[model.cid];
+        index = this.indexOf(model);
+        this.models.splice(index, 1);
+        this.length--;
+        if (!options.silent) {
+          options.index = index;
+          model.trigger('remove', model, this, options);
+        }
+        this._removeReference(model);
+      }
+      return this;
+    },
+
+    // Add a model to the end of the collection.
+    push: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: this.length}, options));
+      return model;
+    },
+
+    // Remove a model from the end of the collection.
+    pop: function(options) {
+      var model = this.at(this.length - 1);
+      this.remove(model, options);
+      return model;
+    },
+
+    // Add a model to the beginning of the collection.
+    unshift: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: 0}, options));
+      return model;
+    },
+
+    // Remove a model from the beginning of the collection.
+    shift: function(options) {
+      var model = this.at(0);
+      this.remove(model, options);
+      return model;
+    },
+
+    // Slice out a sub-array of models from the collection.
+    slice: function(begin, end) {
+      return this.models.slice(begin, end);
+    },
+
+    // Get a model from the set by id.
+    get: function(obj) {
+      if (obj == null) return void 0;
+      this._idAttr || (this._idAttr = this.model.prototype.idAttribute);
+      return this._byId[obj.id || obj.cid || obj[this._idAttr] || obj];
+    },
+
+    // Get the model at the given index.
+    at: function(index) {
+      return this.models[index];
+    },
+
+    // Return models with matching attributes. Useful for simple cases of `filter`.
+    where: function(attrs) {
+      if (_.isEmpty(attrs)) return [];
+      return this.filter(function(model) {
+        for (var key in attrs) {
+          if (attrs[key] !== model.get(key)) return false;
+        }
+        return true;
+      });
+    },
+
+    // Force the collection to re-sort itself. You don't need to call this under
+    // normal circumstances, as the set will maintain sort order as each item
+    // is added.
+    sort: function(options) {
+      if (!this.comparator) {
+        throw new Error('Cannot sort a set without a comparator');
+      }
+      options || (options = {});
+
+      // Run sort based on type of `comparator`.
+      if (_.isString(this.comparator) || this.comparator.length === 1) {
+        this.models = this.sortBy(this.comparator, this);
+      } else {
+        this.models.sort(_.bind(this.comparator, this));
+      }
+
+      if (!options.silent) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // Pluck an attribute from each model in the collection.
+    pluck: function(attr) {
+      return _.invoke(this.models, 'get', attr);
+    },
+
+    // Smartly update a collection with a change set of models, adding,
+    // removing, and merging as necessary.
+    update: function(models, options) {
+      options = _.extend({add: true, merge: true, remove: true}, options);
+      if (options.parse) models = this.parse(models, options);
+      var model, i, l, existing;
+      var add = [], remove = [], modelMap = {};
+
+      // Allow a single model (or no argument) to be passed.
+      if (!_.isArray(models)) models = models ? [models] : [];
+
+      // Proxy to `add` for this case, no need to iterate...
+      if (options.add && !options.remove) return this.add(models, options);
+
+      // Determine which models to add and merge, and which to remove.
+      for (i = 0, l = models.length; i < l; i++) {
+        model = models[i];
+        existing = this.get(model);
+        if (options.remove && existing) modelMap[existing.cid] = true;
+        if ((options.add && !existing) || (options.merge && existing)) {
+          add.push(model);
+        }
+      }
+      if (options.remove) {
+        for (i = 0, l = this.models.length; i < l; i++) {
+          model = this.models[i];
+          if (!modelMap[model.cid]) remove.push(model);
+        }
+      }
+
+      // Remove models (if applicable) before we add and merge the rest.
+      if (remove.length) this.remove(remove, options);
+      if (add.length) this.add(add, options);
+      return this;
+    },
+
+    // When you have more items than you want to add or remove individually,
+    // you can reset the entire set with a new list of models, without firing
+    // any `add` or `remove` events. Fires `reset` when finished.
+    reset: function(models, options) {
+      options || (options = {});
+      if (options.parse) models = this.parse(models, options);
+      for (var i = 0, l = this.models.length; i < l; i++) {
+        this._removeReference(this.models[i]);
+      }
+      options.previousModels = this.models.slice();
+      this._reset();
+      if (models) this.add(models, _.extend({silent: true}, options));
+      if (!options.silent) this.trigger('reset', this, options);
+      return this;
+    },
+
+    // Fetch the default set of models for this collection, resetting the
+    // collection when they arrive. If `update: true` is passed, the response
+    // data will be passed through the `update` method instead of `reset`.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var success = options.success;
+      options.success = function(collection, resp, options) {
+        var method = options.update ? 'update' : 'reset';
+        collection[method](resp, options);
+        if (success) success(collection, resp, options);
+      };
+      return this.sync('read', this, options);
+    },
+
+    // Create a new instance of a model in this collection. Add the model to the
+    // collection immediately, unless `wait: true` is passed, in which case we
+    // wait for the server to agree.
+    create: function(model, options) {
+      options = options ? _.clone(options) : {};
+      if (!(model = this._prepareModel(model, options))) return false;
+      if (!options.wait) this.add(model, options);
+      var collection = this;
+      var success = options.success;
+      options.success = function(model, resp, options) {
+        if (options.wait) collection.add(model, options);
+        if (success) success(model, resp, options);
+      };
+      model.save(null, options);
+      return model;
+    },
+
+    // **parse** converts a response into a list of models to be added to the
+    // collection. The default implementation is just to pass it through.
+    parse: function(resp, options) {
+      return resp;
+    },
+
+    // Create a new collection with an identical list of models as this one.
+    clone: function() {
+      return new this.constructor(this.models);
+    },
+
+    // Reset all internal state. Called when the collection is reset.
+    _reset: function() {
+      this.length = 0;
+      this.models.length = 0;
+      this._byId  = {};
+    },
+
+    // Prepare a model or hash of attributes to be added to this collection.
+    _prepareModel: function(attrs, options) {
+      if (attrs instanceof Model) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
+      options || (options = {});
+      options.collection = this;
+      var model = new this.model(attrs, options);
+      if (!model._validate(attrs, options)) return false;
+      return model;
+    },
+
+    // Internal method to remove a model's ties to a collection.
+    _removeReference: function(model) {
+      if (this === model.collection) delete model.collection;
+      model.off('all', this._onModelEvent, this);
+    },
+
+    // Internal method called every time a model in the set fires an event.
+    // Sets need to update their indexes when models change ids. All other
+    // events simply proxy through. "add" and "remove" events that originate
+    // in other collections are ignored.
+    _onModelEvent: function(event, model, collection, options) {
+      if ((event === 'add' || event === 'remove') && collection !== this) return;
+      if (event === 'destroy') this.remove(model, options);
+      if (model && event === 'change:' + model.idAttribute) {
+        delete this._byId[model.previous(model.idAttribute)];
+        if (model.id != null) this._byId[model.id] = model;
+      }
+      this.trigger.apply(this, arguments);
+    },
+
+    sortedIndex: function (model, value, context) {
+      value || (value = this.comparator);
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _.sortedIndex(this.models, model, iterator, context);
+    }
+
+  });
+
+  // Underscore methods that we want to implement on the Collection.
+  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
+    'isEmpty', 'chain'];
+
+  // Mix in each Underscore method as a proxy to `Collection#models`.
+  _.each(methods, function(method) {
+    Collection.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.models);
+      return _[method].apply(_, args);
+    };
+  });
+
+  // Underscore methods that take a property name as an argument.
+  var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+  // Use attributes instead of properties.
+  _.each(attributeMethods, function(method) {
+    Collection.prototype[method] = function(value, context) {
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _[method](this.models, iterator, context);
+    };
+  });
+
+  // Backbone.Router
+  // ---------------
+
+  // Routers map faux-URLs to actions, and fire events when routes are
+  // matched. Creating a new one sets its `routes` hash, if not set statically.
+  var Router = Backbone.Router = function(options) {
+    options || (options = {});
+    if (options.routes) this.routes = options.routes;
+    this._bindRoutes();
+    this.initialize.apply(this, arguments);
+  };
+
+  // Cached regular expressions for matching named param parts and splatted
+  // parts of route strings.
+  var optionalParam = /\((.*?)\)/g;
+  var namedParam    = /(\(\?)?:\w+/g;
+  var splatParam    = /\*\w+/g;
+  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+
+  // Set up all inheritable **Backbone.Router** properties and methods.
+  _.extend(Router.prototype, Events, {
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Manually bind a single named route to a callback. For example:
+    //
+    //     this.route('search/:query/p:num', 'search', function(query, num) {
+    //       ...
+    //     });
+    //
+    route: function(route, name, callback) {
+      if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+      if (!callback) callback = this[name];
+      Backbone.history.route(route, _.bind(function(fragment) {
+        var args = this._extractParameters(route, fragment);
+        callback && callback.apply(this, args);
+        this.trigger.apply(this, ['route:' + name].concat(args));
+        this.trigger('route', name, args);
+        Backbone.history.trigger('route', this, name, args);
+      }, this));
+      return this;
+    },
+
+    // Simple proxy to `Backbone.history` to save a fragment into the history.
+    navigate: function(fragment, options) {
+      Backbone.history.navigate(fragment, options);
+      return this;
+    },
+
+    // Bind all defined routes to `Backbone.history`. We have to reverse the
+    // order of the routes here to support behavior where the most general
+    // routes can be defined at the bottom of the route map.
+    _bindRoutes: function() {
+      if (!this.routes) return;
+      var route, routes = _.keys(this.routes);
+      while ((route = routes.pop()) != null) {
+        this.route(route, this.routes[route]);
+      }
+    },
+
+    // Convert a route string into a regular expression, suitable for matching
+    // against the current location hash.
+    _routeToRegExp: function(route) {
+      route = route.replace(escapeRegExp, '\\$&')
+                   .replace(optionalParam, '(?:$1)?')
+                   .replace(namedParam, function(match, optional){
+                     return optional ? match : '([^\/]+)';
+                   })
+                   .replace(splatParam, '(.*?)');
+      return new RegExp('^' + route + '$');
+    },
+
+    // Given a route, and a URL fragment that it matches, return the array of
+    // extracted parameters.
+    _extractParameters: function(route, fragment) {
+      return route.exec(fragment).slice(1);
+    }
+
+  });
+
+  // Backbone.History
+  // ----------------
+
+  // Handles cross-browser history management, based on URL fragments. If the
+  // browser does not support `onhashchange`, falls back to polling.
+  var History = Backbone.History = function() {
+    this.handlers = [];
+    _.bindAll(this, 'checkUrl');
+
+    // Ensure that `History` can be used outside of the browser.
+    if (typeof window !== 'undefined') {
+      this.location = window.location;
+      this.history = window.history;
+    }
+  };
+
+  // Cached regex for stripping a leading hash/slash and trailing space.
+  var routeStripper = /^[#\/]|\s+$/g;
+
+  // Cached regex for stripping leading and trailing slashes.
+  var rootStripper = /^\/+|\/+$/g;
+
+  // Cached regex for detecting MSIE.
+  var isExplorer = /msie [\w.]+/;
+
+  // Cached regex for removing a trailing slash.
+  var trailingSlash = /\/$/;
+
+  // Has the history handling already been started?
+  History.started = false;
+
+  // Set up all inheritable **Backbone.History** properties and methods.
+  _.extend(History.prototype, Events, {
+
+    // The default interval to poll for hash changes, if necessary, is
+    // twenty times a second.
+    interval: 50,
+
+    // Gets the true hash value. Cannot use location.hash directly due to bug
+    // in Firefox where location.hash will always be decoded.
+    getHash: function(window) {
+      var match = (window || this).location.href.match(/#(.*)$/);
+      return match ? match[1] : '';
+    },
+
+    // Get the cross-browser normalized URL fragment, either from the URL,
+    // the hash, or the override.
+    getFragment: function(fragment, forcePushState) {
+      if (fragment == null) {
+        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
+          fragment = this.location.pathname;
+          var root = this.root.replace(trailingSlash, '');
+          if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
+        } else {
+          fragment = this.getHash();
+        }
+      }
+      return fragment.replace(routeStripper, '');
+    },
+
+    // Start the hash change handling, returning `true` if the current URL matches
+    // an existing route, and `false` otherwise.
+    start: function(options) {
+      if (History.started) throw new Error("Backbone.history has already been started");
+      History.started = true;
+
+      // Figure out the initial configuration. Do we need an iframe?
+      // Is pushState desired ... is it available?
+      this.options          = _.extend({}, {root: '/'}, this.options, options);
+      this.root             = this.options.root;
+      this._wantsHashChange = this.options.hashChange !== false;
+      this._wantsPushState  = !!this.options.pushState;
+      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
+      var fragment          = this.getFragment();
+      var docMode           = document.documentMode;
+      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+
+      // Normalize root to always include a leading and trailing slash.
+      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
+
+      if (oldIE && this._wantsHashChange) {
+        this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+        this.navigate(fragment);
+      }
+
+      // Depending on whether we're using pushState or hashes, and whether
+      // 'onhashchange' is supported, determine how we check the URL state.
+      if (this._hasPushState) {
+        Backbone.$(window).on('popstate', this.checkUrl);
+      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
+        Backbone.$(window).on('hashchange', this.checkUrl);
+      } else if (this._wantsHashChange) {
+        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
+      }
+
+      // Determine if we need to change the base url, for a pushState link
+      // opened by a non-pushState browser.
+      this.fragment = fragment;
+      var loc = this.location;
+      var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
+
+      // If we've started off with a route from a `pushState`-enabled browser,
+      // but we're currently in a browser that doesn't support it...
+      if (this._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) {
+        this.fragment = this.getFragment(null, true);
+        this.location.replace(this.root + this.location.search + '#' + this.fragment);
+        // Return immediately as browser will do redirect to new url
+        return true;
+
+      // Or if we've started out with a hash-based route, but we're currently
+      // in a browser where it could be `pushState`-based instead...
+      } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
+        this.fragment = this.getHash().replace(routeStripper, '');
+        this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
+      }
+
+      if (!this.options.silent) return this.loadUrl();
+    },
+
+    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
+    // but possibly useful for unit testing Routers.
+    stop: function() {
+      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+      clearInterval(this._checkUrlInterval);
+      History.started = false;
+    },
+
+    // Add a route to be tested when the fragment changes. Routes added later
+    // may override previous routes.
+    route: function(route, callback) {
+      this.handlers.unshift({route: route, callback: callback});
+    },
+
+    // Checks the current URL to see if it has changed, and if it has,
+    // calls `loadUrl`, normalizing across the hidden iframe.
+    checkUrl: function(e) {
+      var current = this.getFragment();
+      if (current === this.fragment && this.iframe) {
+        current = this.getFragment(this.getHash(this.iframe));
+      }
+      if (current === this.fragment) return false;
+      if (this.iframe) this.navigate(current);
+      this.loadUrl() || this.loadUrl(this.getHash());
+    },
+
+    // Attempt to load the current URL fragment. If a route succeeds with a
+    // match, returns `true`. If no defined routes matches the fragment,
+    // returns `false`.
+    loadUrl: function(fragmentOverride) {
+      var fragment = this.fragment = this.getFragment(fragmentOverride);
+      var matched = _.any(this.handlers, function(handler) {
+        if (handler.route.test(fragment)) {
+          handler.callback(fragment);
+          return true;
+        }
+      });
+      return matched;
+    },
+
+    // Save a fragment into the hash history, or replace the URL state if the
+    // 'replace' option is passed. You are responsible for properly URL-encoding
+    // the fragment in advance.
+    //
+    // The options object can contain `trigger: true` if you wish to have the
+    // route callback be fired (not usually desirable), or `replace: true`, if
+    // you wish to modify the current URL without adding an entry to the history.
+    navigate: function(fragment, options) {
+      if (!History.started) return false;
+      if (!options || options === true) options = {trigger: options};
+      fragment = this.getFragment(fragment || '');
+      if (this.fragment === fragment) return;
+      this.fragment = fragment;
+      var url = this.root + fragment;
+
+      // If pushState is available, we use it to set the fragment as a real URL.
+      if (this._hasPushState) {
+        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
+
+      // If hash changes haven't been explicitly disabled, update the hash
+      // fragment to store history.
+      } else if (this._wantsHashChange) {
+        this._updateHash(this.location, fragment, options.replace);
+        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+          // Opening and closing the iframe tricks IE7 and earlier to push a
+          // history entry on hash-tag change.  When replace is true, we don't
+          // want this.
+          if(!options.replace) this.iframe.document.open().close();
+          this._updateHash(this.iframe.location, fragment, options.replace);
+        }
+
+      // If you've told us that you explicitly don't want fallback hashchange-
+      // based history, then `navigate` becomes a page refresh.
+      } else {
+        return this.location.assign(url);
+      }
+      if (options.trigger) this.loadUrl(fragment);
+    },
+
+    // Update the hash location, either replacing the current entry, or adding
+    // a new one to the browser history.
+    _updateHash: function(location, fragment, replace) {
+      if (replace) {
+        var href = location.href.replace(/(javascript:|#).*$/, '');
+        location.replace(href + '#' + fragment);
+      } else {
+        // Some browsers require that `hash` contains a leading #.
+        location.hash = '#' + fragment;
+      }
+    }
+
+  });
+
+  // Create the default Backbone.history.
+  Backbone.history = new History;
+
+  // Backbone.View
+  // -------------
+
+  // Creating a Backbone.View creates its initial element outside of the DOM,
+  // if an existing element is not provided...
+  var View = Backbone.View = function(options) {
+    this.cid = _.uniqueId('view');
+    this._configure(options || {});
+    this._ensureElement();
+    this.initialize.apply(this, arguments);
+    this.delegateEvents();
+  };
+
+  // Cached regex to split keys for `delegate`.
+  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+  // List of view options to be merged as properties.
+  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
+
+  // Set up all inheritable **Backbone.View** properties and methods.
+  _.extend(View.prototype, Events, {
+
+    // The default `tagName` of a View's element is `"div"`.
+    tagName: 'div',
+
+    // jQuery delegate for element lookup, scoped to DOM elements within the
+    // current view. This should be prefered to global lookups where possible.
+    $: function(selector) {
+      return this.$el.find(selector);
+    },
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // **render** is the core function that your view should override, in order
+    // to populate its element (`this.el`), with the appropriate HTML. The
+    // convention is for **render** to always return `this`.
+    render: function() {
+      return this;
+    },
+
+    // Remove this view by taking the element out of the DOM, and removing any
+    // applicable Backbone.Events listeners.
+    remove: function() {
+      this.$el.remove();
+      this.stopListening();
+      return this;
+    },
+
+    // Change the view's element (`this.el` property), including event
+    // re-delegation.
+    setElement: function(element, delegate) {
+      if (this.$el) this.undelegateEvents();
+      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
+      this.el = this.$el[0];
+      if (delegate !== false) this.delegateEvents();
+      return this;
+    },
+
+    // Set callbacks, where `this.events` is a hash of
+    //
+    // *{"event selector": "callback"}*
+    //
+    //     {
+    //       'mousedown .title':  'edit',
+    //       'click .button':     'save'
+    //       'click .open':       function(e) { ... }
+    //     }
+    //
+    // pairs. Callbacks will be bound to the view, with `this` set properly.
+    // Uses event delegation for efficiency.
+    // Omitting the selector binds the event to `this.el`.
+    // This only works for delegate-able events: not `focus`, `blur`, and
+    // not `change`, `submit`, and `reset` in Internet Explorer.
+    delegateEvents: function(events) {
+      if (!(events || (events = _.result(this, 'events')))) return;
+      this.undelegateEvents();
+      for (var key in events) {
+        var method = events[key];
+        if (!_.isFunction(method)) method = this[events[key]];
+        if (!method) throw new Error('Method "' + events[key] + '" does not exist');
+        var match = key.match(delegateEventSplitter);
+        var eventName = match[1], selector = match[2];
+        method = _.bind(method, this);
+        eventName += '.delegateEvents' + this.cid;
+        if (selector === '') {
+          this.$el.on(eventName, method);
+        } else {
+          this.$el.on(eventName, selector, method);
+        }
+      }
+    },
+
+    // Clears all callbacks previously bound to the view with `delegateEvents`.
+    // You usually don't need to use this, but may wish to if you have multiple
+    // Backbone views attached to the same DOM element.
+    undelegateEvents: function() {
+      this.$el.off('.delegateEvents' + this.cid);
+    },
+
+    // Performs the initial configuration of a View with a set of options.
+    // Keys with special meaning *(model, collection, id, className)*, are
+    // attached directly to the view.
+    _configure: function(options) {
+      if (this.options) options = _.extend({}, _.result(this, 'options'), options);
+      _.extend(this, _.pick(options, viewOptions));
+      this.options = options;
+    },
+
+    // Ensure that the View has a DOM element to render into.
+    // If `this.el` is a string, pass it through `$()`, take the first
+    // matching element, and re-assign it to `el`. Otherwise, create
+    // an element from the `id`, `className` and `tagName` properties.
+    _ensureElement: function() {
+      if (!this.el) {
+        var attrs = _.extend({}, _.result(this, 'attributes'));
+        if (this.id) attrs.id = _.result(this, 'id');
+        if (this.className) attrs['class'] = _.result(this, 'className');
+        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
+        this.setElement($el, false);
+      } else {
+        this.setElement(_.result(this, 'el'), false);
+      }
+    }
+
+  });
+
+  // Backbone.sync
+  // -------------
+
+  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+  var methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'patch':  'PATCH',
+    'delete': 'DELETE',
+    'read':   'GET'
+  };
+
+  // Override this function to change the manner in which Backbone persists
+  // models to the server. You will be passed the type of request, and the
+  // model in question. By default, makes a RESTful Ajax request
+  // to the model's `url()`. Some possible customizations could be:
+  //
+  // * Use `setTimeout` to batch rapid-fire updates into a single request.
+  // * Send up the models as XML instead of JSON.
+  // * Persist models via WebSockets instead of Ajax.
+  //
+  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
+  // as `POST`, with a `_method` parameter containing the true HTTP method,
+  // as well as all requests with the body as `application/x-www-form-urlencoded`
+  // instead of `application/json` with the model in a param named `model`.
+  // Useful when interfacing with server-side languages like **PHP** that make
+  // it difficult to read the body of `PUT` requests.
+  Backbone.sync = function(method, model, options) {
+    var type = methodMap[method];
+
+    // Default options, unless specified.
+    _.defaults(options || (options = {}), {
+      emulateHTTP: Backbone.emulateHTTP,
+      emulateJSON: Backbone.emulateJSON
+    });
+
+    // Default JSON-request options.
+    var params = {type: type, dataType: 'json'};
+
+    // Ensure that we have a URL.
+    if (!options.url) {
+      params.url = _.result(model, 'url') || urlError();
+    }
+
+    // Ensure that we have the appropriate request data.
+    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+      params.contentType = 'application/json';
+      params.data = JSON.stringify(options.attrs || model.toJSON(options));
+    }
+
+    // For older servers, emulate JSON by encoding the request into an HTML-form.
+    if (options.emulateJSON) {
+      params.contentType = 'application/x-www-form-urlencoded';
+      params.data = params.data ? {model: params.data} : {};
+    }
+
+    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
+    // And an `X-HTTP-Method-Override` header.
+    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
+      params.type = 'POST';
+      if (options.emulateJSON) params.data._method = type;
+      var beforeSend = options.beforeSend;
+      options.beforeSend = function(xhr) {
+        xhr.setRequestHeader('X-HTTP-Method-Override', type);
+        if (beforeSend) return beforeSend.apply(this, arguments);
+      };
+    }
+
+    // Don't process data on a non-GET request.
+    if (params.type !== 'GET' && !options.emulateJSON) {
+      params.processData = false;
+    }
+
+    var success = options.success;
+    options.success = function(resp) {
+      if (success) success(model, resp, options);
+      model.trigger('sync', model, resp, options);
+    };
+
+    var error = options.error;
+    options.error = function(xhr) {
+      if (error) error(model, xhr, options);
+      model.trigger('error', model, xhr, options);
+    };
+
+    // Make the request, allowing the user to override any Ajax options.
+    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
+    model.trigger('request', model, xhr, options);
+    return xhr;
+  };
+
+  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
+  Backbone.ajax = function() {
+    return Backbone.$.ajax.apply(Backbone.$, arguments);
+  };
+
+  // Helpers
+  // -------
+
+  // Helper function to correctly set up the prototype chain, for subclasses.
+  // Similar to `goog.inherits`, but uses a hash of prototype properties and
+  // class properties to be extended.
+  var extend = function(protoProps, staticProps) {
+    var parent = this;
+    var child;
+
+    // The constructor function for the new subclass is either defined by you
+    // (the "constructor" property in your `extend` definition), or defaulted
+    // by us to simply call the parent's constructor.
+    if (protoProps && _.has(protoProps, 'constructor')) {
+      child = protoProps.constructor;
+    } else {
+      child = function(){ return parent.apply(this, arguments); };
+    }
+
+    // Add static properties to the constructor function, if supplied.
+    _.extend(child, parent, staticProps);
+
+    // Set the prototype chain to inherit from `parent`, without calling
+    // `parent`'s constructor function.
+    var Surrogate = function(){ this.constructor = child; };
+    Surrogate.prototype = parent.prototype;
+    child.prototype = new Surrogate;
+
+    // Add prototype properties (instance properties) to the subclass,
+    // if supplied.
+    if (protoProps) _.extend(child.prototype, protoProps);
+
+    // Set a convenience property in case the parent's prototype is needed
+    // later.
+    child.__super__ = parent.prototype;
+
+    return child;
+  };
+
+  // Set up inheritance for the model, collection, router, view and history.
+  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
+
+  // Throw an error when a URL is needed, and none is supplied.
+  var urlError = function() {
+    throw new Error('A "url" property or function must be specified');
+  };
+
+}).call(this);
diff --git a/vendor/assets/javascripts/chaplin.js.coffee b/vendor/assets/javascripts/chaplin.js.coffee
new file mode 100644
index 0000000..41252fc
--- /dev/null
+++ b/vendor/assets/javascripts/chaplin.js.coffee
@@ -0,0 +1,2377 @@
+###
+Chaplin 0.7.0-pre.
+
+Chaplin may be freely distributed under the MIT license.
+For all details and documentation:
+http://chaplinjs.org
+###
+
+define 'chaplin/application', [
+  'backbone'
+  'chaplin/mediator'
+  'chaplin/dispatcher'
+  'chaplin/views/layout'
+  'chaplin/lib/router'
+  'chaplin/lib/event_broker'
+], (Backbone, mediator, Dispatcher, Layout, Router, EventBroker) ->
+  'use strict'
+
+  # The application bootstrapper
+  # ----------------------------
+
+  class Application
+
+    # Borrow the static extend method from Backbone
+    @extend = Backbone.Model.extend
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    # The site title used in the document title
+    title: ''
+
+    # The application instantiates these three core modules
+    dispatcher: null
+    layout: null
+    router: null
+
+    initialize: ->
+
+    initDispatcher: (options) ->
+      @dispatcher = new Dispatcher options
+
+    initLayout: (options = {}) ->
+      options.title ?= @title
+      @layout = new Layout options
+
+    # Instantiate the dispatcher
+    # --------------------------
+
+    # Pass the function typically returned by routes.coffee
+    initRouter: (routes, options) ->
+      # Save the reference for testing introspection only.
+      # Modules should communicate with each other via Pub/Sub.
+      @router = new Router options
+
+      # Register all routes declared in routes.coffee
+      routes? @router.match
+
+      # After registering the routes, start Backbone.history
+      @router.startHistory()
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      properties = ['dispatcher', 'layout', 'router']
+      for prop in properties when this[prop]?
+        this[prop].dispose()
+        delete this[prop]
+
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/mediator', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/support'
+  'chaplin/lib/utils'
+], (_, Backbone, support, utils) ->
+  'use strict'
+
+  # Mediator
+  # --------
+
+  # The mediator is a simple object all others modules use to communicate
+  # with each other. It implements the Publish/Subscribe pattern.
+  #
+  # Additionally, it holds objects which need to be shared between modules.
+  # In this case, a `user` property is created for getting the user object
+  # and a `setUser` method for setting the user.
+  #
+  # This module returns the singleton object. This is the
+  # application-wide mediator you might load into modules
+  # which need to talk to other modules using Publish/Subscribe.
+
+  # Start with a simple object
+  mediator = {}
+
+  # Publish / Subscribe
+  # -------------------
+
+  # Mixin event methods from Backbone.Events,
+  # create Publish/Subscribe aliases
+  mediator.subscribe   = Backbone.Events.on
+  mediator.unsubscribe = Backbone.Events.off
+  mediator.publish     = Backbone.Events.trigger
+
+  # Initialize an empty callback list so we might seal the mediator later
+  mediator._callbacks = null
+
+  # Make properties readonly
+  utils.readonly mediator, 'subscribe', 'unsubscribe', 'publish'
+
+  # Sealing the mediator
+  # --------------------
+
+  # After adding all needed properties, you should seal the mediator
+  # using this method
+  mediator.seal = ->
+    # Prevent extensions and make all properties non-configurable
+    if support.propertyDescriptors and Object.seal
+      Object.seal mediator
+
+  # Make the method readonly
+  utils.readonly mediator, 'seal'
+
+  # Return our creation
+  mediator
+
+define 'chaplin/dispatcher', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/utils'
+  'chaplin/lib/event_broker'
+], (_, Backbone, utils, EventBroker) ->
+  'use strict'
+
+  class Dispatcher
+
+    # Borrow the static extend method from Backbone
+    @extend = Backbone.Model.extend
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    # The previous controller name
+    previousControllerName: null
+
+    # The current controller, its name, main view and parameters
+    currentControllerName: null
+    currentController: null
+    currentAction: null
+    currentParams: null
+
+    # The current URL
+    url: null
+
+    constructor: ->
+      @initialize arguments...
+
+    initialize: (options = {}) ->
+      # Merge the options
+      @settings = _(options).defaults
+        controllerPath: 'controllers/'
+        controllerSuffix: '_controller'
+
+      # Listen to global events
+      @subscribeEvent 'matchRoute', @matchRoute
+
+    # Controller management
+    # Starting and disposing controllers
+    # ----------------------------------
+
+    # Handler for the global matchRoute event
+    matchRoute: (route, params, options) ->
+      @startupController route.controller, route.action, params, options
+
+    # The standard flow is:
+    #
+    #   1. Test if it’s a new controller/action with new params
+    #   1. Hide the previous view
+    #   2. Dispose the previous controller
+    #   3. Instantiate the new controller, call the controller action
+    #   4. Show the new view
+    #
+    startupController: (controllerName, action = 'index', params = {},
+                        options = {}) ->
+      # Set some routing options
+
+      # Whether to update the URL after controller startup
+      # Default to true unless explicitly set to false
+      if options.changeURL isnt false
+        options.changeURL = true
+
+      # Whether to force the controller startup even
+      # if current and new controllers and params match
+      # Default to false unless explicitly set to true
+      if options.forceStartup isnt true
+        options.forceStartup = false
+
+      # Stop if the desired controller/action is already active
+      # with the same params
+      return if not options.forceStartup and
+        @currentControllerName is controllerName and
+        @currentAction is action and
+        # Deep parameters check is not nice but the simplest way for now
+        (not @currentParams or _(params).isEqual(@currentParams))
+
+      # Fetch the new controller, then go on
+      @loadController controllerName, (ControllerConstructor) =>
+        @controllerLoaded controllerName, action, params, options,
+          ControllerConstructor
+
+    # Load the constructor for a given controller name.
+    # The default implementation uses require() from a AMD module loader
+    # like RequireJS to fetch the constructor.
+    loadController: (controllerName, handler) ->
+      fileName = utils.underscorize(controllerName) +
+        @settings.controllerSuffix
+      moduleName = @settings.controllerPath + fileName
+      if define?.amd
+        require [moduleName], handler
+      else
+        handler require moduleName
+
+    controllerLoaded: (controllerName, action, params, options,
+                       ControllerConstructor) ->
+      # Initialize the new controller
+      controller = new ControllerConstructor params, options
+
+      # Execute before actions if necessary
+      methodName = if controller.beforeAction
+        'executeBeforeActionChain'
+      else
+        'executeAction'
+      this[methodName](controller, controllerName, action, params, options)
+
+    # Handler for the controller lazy-loading
+    executeAction: (controller, controllerName, action, params, options) ->
+      # Shortcuts for the previous controller
+      currentControllerName   = @currentControllerName or null
+      currentController       = @currentController     or null
+
+      @previousControllerName = currentControllerName
+
+      # Dispose the previous controller
+      if currentController
+        # Notify the rest of the world beforehand
+        @publishEvent 'beforeControllerDispose', currentController
+        # Passing the params and the new controller name
+        currentController.dispose params, controllerName
+
+      # Add the previous controller name to the routing options
+      options.previousControllerName = currentControllerName
+
+      # Call the controller action with params and options
+      controller[action] params, options
+
+      # Stop if the action triggered a redirect
+      return if controller.redirected
+
+      # Save the new controller
+      @currentControllerName = controllerName
+      @currentController = controller
+      @currentAction = action
+      @currentParams = params
+
+      # Adjust the URL
+      @adjustURL params, options
+
+      # We're done! Spread the word!
+      @publishEvent 'startupController',
+        previousControllerName: @previousControllerName
+        controller: @currentController
+        controllerName: @currentControllerName
+        params: @currentParams
+        options: options
+
+    # Before actions with chained execution
+    executeBeforeActionChain: (controller, controllerName, action, params,
+                               options) ->
+      beforeActions = []
+      args = arguments
+
+      # Before actions can be extended by subclasses, so we need to check the
+      # whole prototype chain for matching before actions. Before actions in
+      # parent classes are executed before actions in child classes.
+      for acts in utils.getAllPropertyVersions controller, 'beforeAction'
+        # Iterate over the before actions in search for a matching
+        # name with the arguments’ action name
+        for name, beforeAction of acts
+          # Do not add this object more than once
+          if name is action or RegExp("^#{name}$").test(action)
+            if typeof beforeAction is 'string'
+              beforeAction = controller[beforeAction]
+            if typeof beforeAction isnt 'function'
+              throw new Error 'Controller#executeBeforeActionChain: ' +
+                "#{beforeAction} is not a valid beforeAction method for #{name}."
+            # Save the before action
+            beforeActions.push beforeAction
+
+      # Save returned value and also immediately return in case the value is false
+      next = (method, previous = null) =>
+        # Stop if the action triggered a redirect
+        return if controller.redirected
+
+        # End of chain, finally start the action
+        unless method
+          @executeAction args...
+          return
+
+        previous = method.call controller, params, options, previous
+
+        # Detect a CommonJS promise  in order to use pipelining below,
+        # otherwise execute next method directly
+        if previous and typeof previous.then is 'function'
+          previous.then (data) ->
+            next beforeActions.shift(), data
+        else
+          next beforeActions.shift(), previous
+
+      # Start beforeAction execution chain
+      next beforeActions.shift()
+
+    # Change the URL to the new controller using the router
+    adjustURL: (params, options) ->
+      return unless options.path?
+
+      url = options.path +
+        if options.queryString then "?#{options.queryString}" else ""
+
+      # Tell the router to actually change the current URL
+      @publishEvent '!router:changeURL', url, options if options.changeURL
+
+      # Save the URL
+      @url = url
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      @unsubscribeAllEvents()
+
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/controllers/controller', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/event_broker'
+], (_, Backbone, EventBroker) ->
+  'use strict'
+
+  class Controller
+
+    # Borrow the static extend method from Backbone
+    @extend = Backbone.Model.extend
+
+    # Mixin Backbone events and EventBroker.
+    _(@prototype).extend Backbone.Events
+    _(@prototype).extend EventBroker
+
+    view: null
+
+    # Internal flag which stores whether `redirectTo`
+    # was called in the current action
+    redirected: false
+
+    # You should set a `title` property on the derived controller. Like this:
+    # title: 'foo'
+
+    constructor: ->
+      @initialize arguments...
+
+    initialize: ->
+      # Empty per default
+
+    adjustTitle: (subtitle) ->
+      @publishEvent '!adjustTitle', subtitle
+
+    # Redirection
+    # -----------
+
+    # Redirect to URL.
+    redirectTo: (url, options = {}) ->
+      @redirected = true
+      @publishEvent '!router:route', url, options, (routed) ->
+        unless routed
+          throw new Error 'Controller#redirectTo: no route matched'
+
+    # Redirect to named route.
+    redirectToRoute: (name, params, options) ->
+      @redirected = true
+      @publishEvent '!router:routeByName', name, params, options, (routed) ->
+        unless routed
+          throw new Error 'Controller#redirectToRoute: no route matched'
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      # Dispose and delete all members which are disposable
+      for own prop of this
+        obj = this[prop]
+        if obj and typeof obj.dispose is 'function'
+          obj.dispose()
+          delete this[prop]
+
+      # Unbind handlers of global events
+      @unsubscribeAllEvents()
+
+      # Remove properties which are not disposable
+      properties = ['redirected']
+      delete this[prop] for prop in properties
+
+      # Finished
+      @disposed = true
+
+      # You're frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/models/collection', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/event_broker'
+  'chaplin/models/model'
+], (_, Backbone, EventBroker, Model) ->
+  'use strict'
+
+  # Abstract class which extends the standard Backbone collection
+  # in order to add some functionality
+  class Collection extends Backbone.Collection
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    # Use the Chaplin model per default, not Backbone.Model
+    model: Model
+
+    # Mixin a Deferred
+    initDeferred: ->
+      _(this).extend $.Deferred()
+
+    # Serializes collection
+    serialize: ->
+      for model in @models
+        if model instanceof Model
+          # Use optimized Chaplin serialization
+          model.serialize()
+        else
+          # Fall back to unoptimized Backbone stuff
+          model.toJSON()
+
+    # Adds a collection atomically, i.e. throws no event until
+    # all members have been added
+    addAtomic: (models, options = {}) ->
+      return unless models.length
+      options.silent = true
+      direction = if typeof options.at is 'number' then 'pop' else 'shift'
+      while model = models[direction]()
+        @add model, options
+      @trigger 'reset'
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      # Fire an event to notify associated views
+      @trigger 'dispose', this
+
+      # Empty the list silently, but do not dispose all models since
+      # they might be referenced elsewhere
+      @reset [], silent: true
+
+      # Unbind all global event handlers
+      @unsubscribeAllEvents()
+
+      # Remove all event handlers on this module
+      @off()
+
+      # If the model is a Deferred, reject it
+      # This does nothing if it was resolved before
+      @reject?()
+
+      # Remove model constructor reference, internal model lists
+      # and event handlers
+      properties = [
+        'model',
+        'models', '_byId', '_byCid',
+        '_callbacks'
+      ]
+      delete this[prop] for prop in properties
+
+      # Finished
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/models/model', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/utils'
+  'chaplin/lib/event_broker'
+], (_, Backbone, utils, EventBroker) ->
+  'use strict'
+
+  class Model extends Backbone.Model
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    # Mixin a Deferred
+    initDeferred: ->
+      _(this).extend $.Deferred()
+
+    # This method is used to get the attributes for the view template
+    # and might be overwritten by decorators which cannot create a
+    # proper `attributes` getter due to ECMAScript 3 limits.
+    getAttributes: ->
+      @attributes
+
+    # Private helper function for serializing attributes recursively,
+    # creating objects which delegate to the original attributes
+    # in order to protect them from changes.
+    serializeAttributes = (model, attributes, modelStack) ->
+      # Create a delegator object
+      delegator = utils.beget attributes
+
+      # Add model to stack
+      if modelStack
+        modelStack.push model
+      else
+        modelStack = [model]
+
+      # Map model/collection to their attributes. Create a property
+      # on the delegator that shadows the original attribute.
+      for key, value of attributes
+
+        # Handle models
+        if value instanceof Backbone.Model
+          delegator[key] = serializeModelAttributes value, model, modelStack
+
+        # Handle collections
+        else if value instanceof Backbone.Collection
+          serializedModels = []
+          for otherModel in value.models
+            serializedModels.push(
+              serializeModelAttributes(otherModel, model, modelStack)
+            )
+          delegator[key] = serializedModels
+
+      # Remove model from stack
+      modelStack.pop()
+
+      # Return the delegator
+      delegator
+
+    # Serialize the attributes of a given model
+    # in the context of a given tree
+    serializeModelAttributes = (model, currentModel, modelStack) ->
+      # Nullify circular references
+      if model is currentModel or model in modelStack
+        return null
+      # Serialize recursively
+      attributes = if typeof model.getAttributes is 'function'
+        # Chaplin models
+        model.getAttributes()
+      else
+        # Backbone models
+        model.attributes
+      serializeAttributes model, attributes, modelStack
+
+    # Return an object which delegates to the attributes
+    # (i.e. an object which has the attributes as prototype)
+    # so primitive values might be added and altered safely.
+    # Map models to their attributes, recursively.
+    serialize: ->
+      serializeAttributes this, @getAttributes()
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      # Fire an event to notify associated collections and views
+      @trigger 'dispose', this
+
+      # Unbind all global event handlers
+      @unsubscribeAllEvents()
+
+      # Remove all event handlers on this module
+      @off()
+
+      # If the model is a Deferred, reject it
+      # This does nothing if it was resolved before
+      @reject?()
+
+      # Remove the collection reference, internal attribute hashes
+      # and event handlers
+      properties = [
+        'collection',
+        'attributes', 'changed'
+        '_escapedAttributes', '_previousAttributes',
+        '_silent', '_pending',
+        '_callbacks'
+      ]
+      delete this[prop] for prop in properties
+
+      # Finished
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/views/layout', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/utils'
+  'chaplin/lib/event_broker'
+], (_, Backbone, utils, EventBroker) ->
+  'use strict'
+
+  # Shortcut to access the DOM manipulation library
+  $ = Backbone.$
+
+  class Layout # This class does not extend View
+
+    # Borrow the static extend method from Backbone
+    @extend = Backbone.Model.extend
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    # The site title used in the document title.
+    # This should be set in your app-specific Application class
+    # and passed as an option
+    title: ''
+
+    # An hash to register events, like in Backbone.View
+    # It is only meant for events that are app-wide
+    # independent from any view
+    events: {}
+
+    # Register @el, @$el and @cid for delegating events
+    el: document
+    $el: $(document)
+    cid: 'chaplin-layout'
+
+    constructor: ->
+      @initialize arguments...
+
+    initialize: (options = {}) ->
+      @title = options.title
+      @settings = _(options).defaults
+        titleTemplate: _.template("<%= subtitle %> \u2013 <%= title %>")
+        openExternalToBlank: false
+        routeLinks: 'a, .go-to'
+        skipRouting: '.noscript'
+        # Per default, jump to the top of the page
+        scrollTo: [0, 0]
+
+      @subscribeEvent 'beforeControllerDispose', @hideOldView
+      @subscribeEvent 'startupController', @showNewView
+      @subscribeEvent '!adjustTitle', @adjustTitle
+
+      # Set the app link routing
+      if @settings.routeLinks
+        @startLinkRouting()
+
+      # Set app wide event handlers
+      @delegateEvents()
+
+    # Take (un)delegateEvents from Backbone
+    # -------------------------------------
+    delegateEvents: Backbone.View::delegateEvents
+    undelegateEvents: Backbone.View::undelegateEvents
+
+    # Controller startup and disposal
+    # -------------------------------
+
+    # Handler for the global beforeControllerDispose event
+    hideOldView: (controller) ->
+      # Reset the scroll position
+      scrollTo = @settings.scrollTo
+      if scrollTo
+        window.scrollTo scrollTo[0], scrollTo[1]
+
+      # Hide the current view
+      view = controller.view
+      view.$el.hide() if view
+
+    # Handler for the global startupController event
+    # Show the new view
+    showNewView: (context) ->
+      view = context.controller.view
+      view.$el.show() if view
+
+    # Handler for the global startupController event
+    # Change the document title to match the new controller
+    # Get the title from the title property of the current controller
+    adjustTitle: (subtitle = '') ->
+      title = @settings.titleTemplate {@title, subtitle}
+
+      # Internet Explorer < 9 workaround
+      setTimeout (-> document.title = title), 50
+
+    # Automatic routing of internal links
+    # -----------------------------------
+
+    startLinkRouting: ->
+      if @settings.routeLinks
+        $(document).on 'click', @settings.routeLinks, @openLink
+
+    stopLinkRouting: ->
+      if @settings.routeLinks
+        $(document).off 'click', @settings.routeLinks
+
+    # Handle all clicks on A elements and try to route them internally
+    openLink: (event) =>
+      return if utils.modifierKeyPressed(event)
+
+      el = event.currentTarget
+      $el = $(el)
+      isAnchor = el.nodeName is 'A'
+
+      # Get the href and perform checks on it
+      href = $el.attr('href') or $el.data('href') or null
+
+      # Basic href checks
+      return if href is null or href is undefined or
+        # Technically an empty string is a valid relative URL
+        # but it doesn’t make sense to route it.
+        href is '' or
+        # Exclude fragment links
+        href.charAt(0) is '#'
+
+      # Checks for A elements
+      return if isAnchor and (
+        # Exclude links marked as external
+        $el.attr('target') is '_blank' or
+        $el.attr('rel') is 'external' or
+        # Exclude links to non-HTTP ressources
+        el.protocol not in ['http:', 'https:', 'file:']
+      )
+
+      # Apply skipRouting option
+      skipRouting = @settings.skipRouting
+      type = typeof skipRouting
+      return if type is 'function' and not skipRouting(href, el) or
+        type is 'string' and $el.is skipRouting
+
+      # Handle external links
+      internal = not isAnchor or el.hostname in [location.hostname, '']
+      unless internal
+        if @settings.openExternalToBlank
+          # Open external links normally in a new tab
+          event.preventDefault()
+          window.open el.href
+        return
+
+      if isAnchor
+        path = el.pathname
+        queryString = el.search.substring 1
+        # Append leading slash for IE8
+        path = "/#{path}" if path.charAt(0) isnt '/'
+      else
+        [path, queryString] = href.split '?'
+        queryString ?= ''
+
+      # Create routing options and callback
+      options = {queryString}
+      callback = (routed) ->
+        # Prevent default handling if the URL could be routed
+        if routed
+          event.preventDefault()
+        else unless isAnchor
+          location.href = path
+        return
+
+      # Pass to the router, try to route the path internally
+      @publishEvent '!router:route', path, options, callback
+
+      return
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      @stopLinkRouting()
+      @unsubscribeAllEvents()
+      @undelegateEvents()
+
+      delete @title
+
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/views/view', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/utils'
+  'chaplin/lib/event_broker'
+  'chaplin/models/model'
+  'chaplin/models/collection'
+], (_, Backbone, utils, EventBroker, Model, Collection) ->
+  'use strict'
+
+  # Shortcut to access the DOM manipulation library
+  $ = Backbone.$
+
+  class View extends Backbone.View
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    # Automatic rendering
+    # -------------------
+
+    # Flag whether to render the view automatically on initialization.
+    # As an alternative you might pass a `render` option to the constructor.
+    autoRender: false
+
+    # Automatic inserting into DOM
+    # ----------------------------
+
+    # View container element
+    # Set this property in a derived class to specify the container element.
+    # Normally this is a selector string but it might also be an element or
+    # jQuery object.
+    # The view is automatically inserted into the container when it’s rendered.
+    # As an alternative you might pass a `container` option to the constructor.
+    container: null
+
+    # Method which is used for adding the view to the DOM
+    # Like jQuery’s `html`, `prepend`, `append`, `after`, `before` etc.
+    containerMethod: 'append'
+
+    # Subviews
+    # --------
+
+    # List of subviews
+    subviews: null
+    subviewsByName: null
+
+    constructor: (options) ->
+      # Wrap `initialize` so `afterInitialize` is called afterwards
+      # Only wrap if there is an overriding method, otherwise we
+      # can call the `after-` method directly
+      unless @initialize is View::initialize
+        utils.wrapMethod this, 'initialize'
+
+      # Wrap `render` so `afterRender` is called afterwards
+      if @render is View::render
+        @render = _(@render).bind this
+      else
+        utils.wrapMethod this, 'render'
+
+      # Copy some options to instance properties
+      if options
+        _(this).extend _.pick options, ['autoRender', 'container', 'containerMethod']
+
+      # Call Backbone’s constructor
+      super
+
+    # Inheriting classes must call `super` in their `initialize` method to
+    # properly inflate subviews and set up options
+    initialize: (options) ->
+      # No super call here, Backbone’s `initialize` is a no-op
+
+      # Initialize subviews
+      @subviews = []
+      @subviewsByName = {}
+
+      # Listen for disposal of the model or collection.
+      # If the model is disposed, automatically dispose the associated view
+      @listenTo @model, 'dispose', @dispose if @model
+      @listenTo @collection, 'dispose', @dispose if @collection
+
+      # Call `afterInitialize` if `initialize` was not wrapped
+      unless @initializeIsWrapped
+        @afterInitialize()
+
+    # This method is called after a specific `initialize` of a derived class
+    afterInitialize: ->
+      # Render automatically if set by options or instance property
+      @render() if @autoRender
+
+    # User input event handling
+    # -------------------------
+
+    # Event handling using event delegation
+    # Register a handler for a specific event type
+    # For the whole view:
+    #   delegate(eventType, handler)
+    #   e.g.
+    #   @delegate('click', @clicked)
+    # For an element in the passing a selector:
+    #   delegate(eventType, selector, handler)
+    #   e.g.
+    #   @delegate('click', 'button.confirm', @confirm)
+    delegate: (eventType, second, third) ->
+      if typeof eventType isnt 'string'
+        throw new TypeError 'View#delegate: first argument must be a string'
+
+      if arguments.length is 2
+        handler = second
+      else if arguments.length is 3
+        selector = second
+        if typeof selector isnt 'string'
+          throw new TypeError 'View#delegate: ' +
+            'second argument must be a string'
+        handler = third
+      else
+        throw new TypeError 'View#delegate: ' +
+          'only two or three arguments are allowed'
+
+      if typeof handler isnt 'function'
+        throw new TypeError 'View#delegate: ' +
+          'handler argument must be function'
+
+      # Add an event namespace
+      list = ("#{event}.delegate#{@cid}" for event in eventType.split(' '))
+      events = list.join(' ')
+
+      # Bind the handler to the view
+      handler = _(handler).bind(this)
+
+      if selector
+        # Register handler
+        @$el.on events, selector, handler
+      else
+        # Register handler
+        @$el.on events, handler
+
+      # Return the bound handler
+      handler
+
+    # Copy of original backbone method without `undelegateEvents` call.
+    _delegateEvents: (events) ->
+      # Call Backbone.delegateEvents on all superclasses events.
+      return unless events or (events = getValue(this, 'events'))
+      for key of events
+        method = events[key]
+        method = this[method] unless _.isFunction(method)
+        unless method
+          throw new Error("Method '#{events[key]}' does not exist")
+        match = key.match(/^(\S+)\s*(.*)$/)
+        eventName = match[1]
+        selector = match[2]
+        method = _.bind(method, this)
+        eventName += ".delegateEvents#{@cid}"
+        if selector is ''
+          @$el.bind eventName, method
+        else
+          @$el.delegate selector, eventName, method
+
+    # Override Backbones method to combine the events
+    # of the parent view if it exists.
+    delegateEvents: ->
+      @undelegateEvents()
+      for events in utils.getAllPropertyVersions this, 'events'
+        @_delegateEvents events
+      return
+
+    # Remove all handlers registered with @delegate.
+    undelegate: ->
+      @$el.unbind ".delegate#{@cid}"
+
+    # Subviews
+    # --------
+
+    # Getting or adding a subview
+    subview: (name, view) ->
+      if name and view
+        # Add the subview, ensure it’s unique
+        @removeSubview name
+        @subviews.push view
+        @subviewsByName[name] = view
+        view
+      else if name
+        # Get and return the subview by the given name
+        @subviewsByName[name]
+
+    # Removing a subview
+    removeSubview: (nameOrView) ->
+      return unless nameOrView
+
+      if typeof nameOrView is 'string'
+        # Name given, search for a subview by name
+        name = nameOrView
+        view = @subviewsByName[name]
+      else
+        # View instance given, search for the corresponding name
+        view = nameOrView
+        for otherName, otherView of @subviewsByName
+          if view is otherView
+            name = otherName
+            break
+
+      # Break if no view and name were found
+      return unless name and view and view.dispose
+
+      # Dispose the view
+      view.dispose()
+
+      # Remove the subview from the lists
+      index = _(@subviews).indexOf(view)
+      if index > -1
+        @subviews.splice index, 1
+      delete @subviewsByName[name]
+
+    # Rendering
+    # ---------
+
+    # Get the model/collection data for the templating function
+    # Uses optimized Chaplin serialization if available.
+    getTemplateData: ->
+      templateData = if @model
+        if @model instanceof Model
+          @model.serialize()
+        else
+          utils.beget @model.attributes
+      else if @collection
+        # Collection: Serialize all models.
+        items = if @collection instanceof Collection
+          @collection.serialize()
+        else
+          @collection.map (model) ->
+            utils.beget model.attributes
+        {items}
+      else
+        # Empty object.
+        {}
+
+      modelOrCollection = @model or @collection
+      if modelOrCollection
+        # If the model/collection is a Deferred, add a `resolved` flag,
+        # but only if it’s not present yet
+        if typeof modelOrCollection.state is 'function' and
+          not ('resolved' of templateData)
+            templateData.resolved = modelOrCollection.state() is 'resolved'
+
+        # If the model/collection is a SyncMachine, add a `synced` flag,
+        # but only if it’s not present yet
+        if typeof modelOrCollection.isSynced is 'function' and
+          not ('synced' of templateData)
+            templateData.synced = modelOrCollection.isSynced()
+
+      templateData
+
+    # Returns the compiled template function
+    getTemplateFunction: ->
+      # Chaplin doesn’t define how you load and compile templates in order to
+      # render views. The example application uses Handlebars and RequireJS
+      # to load and compile templates on the client side. See the derived
+      # View class in the example application:
+      # https://github.com/chaplinjs/facebook-example/blob/master/coffee/views/base/view.coffee
+      #
+      # If you precompile templates to JavaScript functions on the server,
+      # you might just return a reference to that function.
+      # Several precompilers create a global `JST` hash which stores the
+      # template functions. You can get the function by the template name:
+      # JST[@templateName]
+
+      throw new Error 'View#getTemplateFunction must be overridden'
+
+    # Main render function
+    # This method is bound to the instance in the constructor (see above)
+    render: ->
+      # Do not render if the object was disposed
+      # (render might be called as an event handler which wasn’t
+      # removed correctly)
+      return false if @disposed
+
+      templateFunc = @getTemplateFunction()
+      if typeof templateFunc is 'function'
+
+        # Call the template function passing the template data
+        html = templateFunc @getTemplateData()
+
+        # Replace HTML
+        # ------------
+
+        # This is a workaround for an apparent issue with jQuery 1.7’s
+        # innerShiv feature. Using @$el.html(html) caused issues with
+        # HTML5-only tags in IE7 and IE8.
+        @$el.empty().append html
+
+      # Call `afterRender` if `render` was not wrapped
+      @afterRender() unless @renderIsWrapped
+
+      # Return the view
+      this
+
+    # This method is called after a specific `render` of a derived class
+    afterRender: ->
+      # Automatically append to DOM if the container element is set
+      if @container
+        # Append the view to the DOM
+        $(@container)[@containerMethod] @el
+        # Trigger an event
+        @trigger 'addedToDOM'
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      throw new Error('Your `initialize` method must include a super call to
+        Chaplin `initialize`') unless @subviews?
+
+      # Dispose subviews
+      subview.dispose() for subview in @subviews
+
+      # Unbind handlers of global events
+      @unsubscribeAllEvents()
+
+      # Unbind all referenced handlers
+      @stopListening()
+
+      # Remove all event handlers on this module
+      @off()
+
+      # Remove the topmost element from DOM. This also removes all event
+      # handlers from the element and all its children.
+      @$el.remove()
+
+      # Remove element references, options,
+      # model/collection references and subview lists
+      properties = [
+        'el', '$el',
+        'options', 'model', 'collection',
+        'subviews', 'subviewsByName',
+        '_callbacks'
+      ]
+      delete this[prop] for prop in properties
+
+      # Finished
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/views/collection_view', [
+  'backbone'
+  'underscore'
+  'chaplin/views/view'
+], (Backbone, _, View) ->
+  'use strict'
+
+  # Shortcut to access the DOM manipulation library
+  $ = Backbone.$
+
+  # General class for rendering Collections.
+  # Derive this class and declare at least `itemView` or override
+  # `getView`. `getView` gets an item model and should instantiate
+  # and return a corresponding item view.
+  class CollectionView extends View
+
+    # Configuration options
+    # ---------------------
+
+    # These options may be overwritten in derived classes.
+
+    # A class of item in collection.
+    # This property has to be overridden by a derived class.
+    itemView: null
+
+    # Automatic rendering
+
+    # Per default, render the view itself and all items on creation
+    autoRender: true
+    renderItems: true
+
+    # Animation
+
+    # When new items are added, their views are faded in.
+    # Animation duration in milliseconds (set to 0 to disable fade in)
+    animationDuration: 500
+
+    # By default, fading in is done by javascript function which can be
+    # slow on mobile devices. CSS animations are faster,
+    # but require user’s manual definitions.
+    # CSS classes used are: animated-item-view, animated-item-view-end.
+    useCssAnimation: false
+
+    # Selectors and Elements
+
+    # A collection view may have a template and use one of its child elements
+    # as the container of the item views. If you specify `listSelector`, the
+    # item views will be appended to this element. If empty, $el is used.
+    listSelector: null
+
+    # The actual element which is fetched using `listSelector`
+    $list: null
+
+    # Selector for a fallback element which is shown if the collection is empty.
+    fallbackSelector: null
+
+    # The actual element which is fetched using `fallbackSelector`
+    $fallback: null
+
+    # Selector for a loading indicator element which is shown
+    # while the collection is syncing.
+    loadingSelector: null
+
+    # The actual element which is fetched using `loadingSelector`
+    $loading: null
+
+    # Selector which identifies child elements belonging to collection
+    # If empty, all children of $list are considered
+    itemSelector: null
+
+    # Filtering
+
+    # The filter function, if any
+    filterer: null
+
+    # A function that will be executed after each filter.
+    # Hides excluded items by default.
+    filterCallback: (view, included) ->
+      view.$el.stop(true, true).toggle included
+
+    # View lists
+
+    # Track a list of the visible views
+    visibleItems: null
+
+    # Constructor
+    # -----------
+
+    constructor: (options) ->
+      # Apply options to view instance
+      if (options)
+        _(this).extend _.pick options, ['renderItems', 'itemView']
+
+      super
+
+    # Initialization
+    # --------------
+
+    initialize: (options = {}) ->
+      super
+
+      # Initialize list for visible items
+      @visibleItems = []
+
+      # Start observing the collection
+      @addCollectionListeners()
+
+      # Apply a filter if one provided
+      @filter options.filterer if options.filterer?
+
+    # Binding of collection listeners
+    addCollectionListeners: ->
+      @listenTo @collection, 'add',    @itemAdded
+      @listenTo @collection, 'remove', @itemRemoved
+      @listenTo @collection, 'reset sort',  @itemsResetted
+
+    # Rendering
+    # ---------
+
+    # Override View#getTemplateData, don’t serialize collection items here.
+    getTemplateData: ->
+      templateData = {length: @collection.length}
+
+      # If the collection is a Deferred, add a `resolved` flag
+      if typeof @collection.state is 'function'
+        templateData.resolved = @collection.state() is 'resolved'
+
+      # If the collection is a SyncMachine, add a `synced` flag
+      if typeof @collection.isSynced is 'function'
+        templateData.synced = @collection.isSynced()
+
+      templateData
+
+    # In contrast to normal views, a template is not mandatory
+    # for CollectionViews. Provide an empty `getTemplateFunction`.
+    getTemplateFunction: ->
+
+    # Main render method (should be called only once)
+    render: ->
+      super
+
+      # Set the $list property with the actual list container
+      @$list = if @listSelector then @$(@listSelector) else @$el
+
+      @initFallback()
+      @initLoadingIndicator()
+
+      # Render all items
+      @renderAllItems() if @renderItems
+
+    # Adding / Removing
+    # -----------------
+
+    # When an item is added, create a new view and insert it
+    itemAdded: (item, collection, options = {}) =>
+      @renderAndInsertItem item, options.index
+
+    # When an item is removed, remove the corresponding view from DOM and caches
+    itemRemoved: (item) =>
+      @removeViewForItem item
+
+    # When all items are resetted, render all anew
+    itemsResetted: =>
+      @renderAllItems()
+
+    # Fallback message when the collection is empty
+    # ---------------------------------------------
+
+    initFallback: ->
+      return unless @fallbackSelector
+
+      # Set the $fallback property
+      @$fallback = @$(@fallbackSelector)
+
+      # Listen for visible items changes
+      @on 'visibilityChange', @showHideFallback
+
+      # Listen for sync events on the collection
+      @listenTo @collection, 'syncStateChange', @showHideFallback
+
+      # Set visibility initially
+      @showHideFallback()
+
+    # Show fallback if no item is visible and the collection is synced
+    showHideFallback: =>
+      visible = @visibleItems.length is 0 and (
+        if typeof @collection.isSynced is 'function'
+          # Collection is a SyncMachine
+          @collection.isSynced()
+        else
+          # Assume it is synced
+          true
+      )
+      @$fallback.toggle visible
+
+    # Loading indicator
+    # -----------------
+
+    initLoadingIndicator: ->
+      # The loading indicator only works for Collections
+      # which are SyncMachines.
+      return unless @loadingSelector and
+        typeof @collection.isSyncing is 'function'
+
+      # Set the $loading property
+      @$loading = @$(@loadingSelector)
+
+      # Listen for sync events on the collection
+      @listenTo @collection, 'syncStateChange', @showHideLoadingIndicator
+
+      # Set visibility initially
+      @showHideLoadingIndicator()
+
+    showHideLoadingIndicator: ->
+      # Only show the loading indicator if the collection is empty.
+      # Otherwise loading more items in order to append them would
+      # show the loading indicator. If you want the indicator to
+      # show up in this case, you need to overwrite this method to
+      # disable the check.
+      visible = @collection.length is 0 and @collection.isSyncing()
+      @$loading.toggle visible
+
+    # Filtering
+    # ---------
+
+    # Filters only child item views from all current subviews.
+    getItemViews: ->
+      itemViews = {}
+      for name, view of @subviewsByName when name.slice(0, 9) is 'itemView:'
+        itemViews[name.slice(9)] = view
+      itemViews
+
+    # Applies a filter to the collection view.
+    # Expects an iterator function as first parameter
+    # which need to return true or false.
+    # Optional filter callback which is called to
+    # show/hide the view or mark it otherwise as filtered.
+    filter: (filterer, filterCallback) ->
+      # Save the filterer and filterCallback functions
+      @filterer = filterer
+      @filterCallback = filterCallback if filterCallback
+      filterCallback ?= @filterCallback
+
+      # Show/hide existing views
+      unless _(@getItemViews()).isEmpty()
+        for item, index in @collection.models
+
+          # Apply filter to the item
+          included = if typeof filterer is 'function'
+            filterer item, index
+          else
+            true
+
+          # Show/hide the view accordingly
+          view = @subview "itemView:#{item.cid}"
+          # A view has not been created for this item yet
+          unless view
+            throw new Error 'CollectionView#filter: ' +
+              "no view found for #{item.cid}"
+
+          # Show/hide or mark the view accordingly
+          @filterCallback view, included
+
+          # Update visibleItems list, but do not trigger an event immediately
+          @updateVisibleItems view.model, included, false
+
+      # Trigger a combined `visibilityChange` event
+      @trigger 'visibilityChange', @visibleItems
+
+    # Item view rendering
+    # -------------------
+
+    # Render and insert all items
+    renderAllItems: =>
+      items = @collection.models
+
+      # Reset visible items
+      @visibleItems = []
+
+      # Collect remaining views
+      remainingViewsByCid = {}
+      for item in items
+        view = @subview "itemView:#{item.cid}"
+        if view
+          # View remains
+          remainingViewsByCid[item.cid] = view
+
+      # Remove old views of items not longer in the list
+      for own cid, view of @getItemViews() when cid not of remainingViewsByCid
+        # Remove the view
+        @removeSubview "itemView:#{cid}"
+
+      # Re-insert remaining items; render and insert new items
+      for item, index in items
+        # Check if view was already created
+        view = @subview "itemView:#{item.cid}"
+        if view
+          # Re-insert the view
+          @insertView item, view, index, false
+        else
+          # Create a new view, render and insert it
+          @renderAndInsertItem item, index
+
+      # If no view was created, trigger `visibilityChange` event manually
+      unless items.length
+        @trigger 'visibilityChange', @visibleItems
+
+    # Render the view for an item
+    renderAndInsertItem: (item, index) ->
+      view = @renderItem item
+      @insertView item, view, index
+
+    # Instantiate and render an item using the `viewsByCid` hash as a cache
+    renderItem: (item) ->
+      # Get the existing view
+      view = @subview "itemView:#{item.cid}"
+
+      # Instantiate a new view if necessary
+      unless view
+        view = @getView item
+        # Save the view in the subviews
+        @subview "itemView:#{item.cid}", view
+
+      # Render in any case
+      view.render()
+
+      view
+
+    # Returns an instance of the view class. Override this
+    # method to use several item view constructors depending
+    # on the model type or data.
+    getView: (model) ->
+      if @itemView
+        new @itemView {model}
+      else
+        throw new Error 'The CollectionView#itemView property ' +
+          'must be defined or the getView() must be overridden.'
+
+    # Inserts a view into the list at the proper position
+    insertView: (item, view, index = null, enableAnimation = true) ->
+      # Get the insertion offset
+      position = if typeof index is 'number'
+        index
+      else
+        @collection.indexOf item
+
+      # Is the item included in the filter?
+      included = if typeof @filterer is 'function'
+        @filterer item, position
+      else
+        true
+
+      # Get the view’s top element
+      viewEl = view.el
+      $viewEl = view.$el
+
+      if included
+        # Make view transparent if animation is enabled
+        if enableAnimation
+          if @useCssAnimation
+            $viewEl.addClass 'animated-item-view'
+          else
+            $viewEl.css 'opacity', 0
+      else
+        # Hide the view if it’s filtered
+        @filterCallback view, included
+
+      # Insert the view into the list
+      $list = @$list
+
+      # Get the children which originate from item views
+      children = if @itemSelector
+        $list.children @itemSelector
+      else
+        $list.children()
+
+      # Check if it needs to be inserted
+      unless children.get(position) is viewEl
+        length = children.length
+        if length is 0 or position is length
+          # Insert at the end
+          $list.append viewEl
+        else
+          # Insert at the right position
+          if position is 0
+            $next = children.eq position
+            $next.before viewEl
+          else
+            $previous = children.eq position - 1
+            $previous.after viewEl
+
+      # Tell the view that it was added to its parent.
+      view.trigger 'addedToParent'
+
+      # Update the list of visible items, trigger a `visibilityChange` event
+      @updateVisibleItems item, included
+
+      # Fade the view in if it was made transparent before
+      if enableAnimation and included
+        if @useCssAnimation
+          # Wait for DOM state change.
+          setTimeout =>
+            $viewEl.addClass 'animated-item-view-end'
+          , 0
+        else
+          $viewEl.animate {opacity: 1}, @animationDuration
+
+      return
+
+    # Remove the view for an item
+    removeViewForItem: (item) ->
+      # Remove item from visibleItems list, trigger a `visibilityChange` event
+      @updateVisibleItems item, false
+      @removeSubview "itemView:#{item.cid}"
+
+    # List of visible items
+    # ---------------------
+
+    # Update visibleItems list and trigger a `visibilityChanged` event
+    # if an item changed its visibility
+    updateVisibleItems: (item, includedInFilter, triggerEvent = true) ->
+      visibilityChanged = false
+
+      visibleItemsIndex = _(@visibleItems).indexOf item
+      includedInVisibleItems = visibleItemsIndex > -1
+
+      if includedInFilter and not includedInVisibleItems
+        # Add item to the visible items list
+        @visibleItems.push item
+        visibilityChanged = true
+
+      else if not includedInFilter and includedInVisibleItems
+        # Remove item from the visible items list
+        @visibleItems.splice visibleItemsIndex, 1
+        visibilityChanged = true
+
+      # Trigger a `visibilityChange` event if the visible items changed
+      if visibilityChanged and triggerEvent
+        @trigger 'visibilityChange', @visibleItems
+
+      visibilityChanged
+
+    # Disposal
+    # --------
+
+    dispose: ->
+      return if @disposed
+
+      # Remove jQuery objects, item view cache and visible items list
+      properties = [
+        '$list', '$fallback', '$loading',
+        'visibleItems'
+      ]
+      delete this[prop] for prop in properties
+
+      # Self-disposal
+      super
+
+define 'chaplin/lib/route', [
+  'underscore'
+  'backbone'
+  'chaplin/lib/event_broker'
+  'chaplin/controllers/controller'
+], (_, Backbone, EventBroker, Controller) ->
+  'use strict'
+
+  class Route
+
+    # Borrow the static extend method from Backbone
+    @extend = Backbone.Model.extend
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    reservedParams = ['path', 'changeURL']
+    # Taken from Backbone.Router
+    escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g
+
+    queryStringFieldSeparator = '&'
+    queryStringValueSeparator = '='
+
+    # Create a route for a URL pattern and a controller action
+    # e.g. new Route '/users/:id', 'users#show'
+    constructor: (@pattern, @controller, @action, @options = {}) ->
+      # Store the name on the route if given
+      @name = @options.name if @options.name?
+
+      # Initialize list of :params which the route will use.
+      @paramNames = []
+
+      # Check if the action is a reserved name
+      if _(Controller.prototype).has @action
+        throw new Error 'Route: You should not use existing controller properties as action names'
+
+      @createRegExp()
+
+    reverse: (params) ->
+      url = @pattern
+      # TODO: add support for regular expressions in reverser.
+      return false if _.isRegExp url
+      notEnoughParams = 'Route#reverse: Not enough parameters to reverse'
+
+      if _.isArray params
+        # Ensure we have enough parameters
+        throw new Error notEnoughParams if params.length < @paramNames.length
+
+        index = 0
+        url = url.replace /[:*][^\/\?]+/g, (match) ->
+          result = params[index]
+          index += 1
+          result
+      else
+        # From a params hash; we need to be able to return
+        # the actual URL this route represents
+        # Iterate and attempt to replace params in pattern
+        for name in @paramNames
+          value = params[name]
+          throw new Error notEnoughParams if value is undefined
+          url = url.replace ///[:*]#{name}///g, value
+
+      # If the url tests out good; return the url; else, false
+      if @test url then url else false
+
+    createRegExp: ->
+      if _.isRegExp @pattern
+        @regExp = @pattern
+        @paramNames = @options.names if _.isArray @options.names
+        return
+
+      pattern = @pattern
+        # Escape magic characters
+        .replace(escapeRegExp, '\\$&')
+        # Replace named parameters, collecting their names
+        .replace(/(?::|\*)(\w+)/g, @addParamName)
+
+      # Create the actual regular expression
+      # Match until the end of the URL or the begin of query string
+      @regExp = ///^#{pattern}(?=\?|$)///
+
+    addParamName: (match, paramName) =>
+      # Test if parameter name is reserved
+      if _(reservedParams).include(paramName)
+        throw new Error "Route#addParamName: parameter name #{paramName} is reserved"
+      # Save parameter name
+      @paramNames.push paramName
+      # Replace with a character class
+      if match.charAt(0) is ':'
+        # Regexp for :foo
+        '([^\/\?]+)'
+      else
+        # Regexp for *foo
+        '(.*?)'
+
+    # Test if the route matches to a path (called by Backbone.History#loadUrl)
+    test: (path) ->
+      # Test the main RegExp
+      matched = @regExp.test path
+      return false unless matched
+
+      # Apply the parameter constraints
+      constraints = @options.constraints
+      if constraints
+        params = @extractParams path
+        for own name, constraint of constraints
+          unless constraint.test(params[name])
+            return false
+
+      return true
+
+    # The handler which is called by Backbone.History when the route matched.
+    # It is also called by Router#route which might pass options.
+    handler: (path, options = {}) =>
+      # If no query string was passed, use the current
+      queryString = options.queryString ? @getCurrentQueryString()
+
+      # Build params hash
+      params = @buildParams path, queryString
+
+      # Add a `path` routing option with the whole path match
+      options.path = path
+
+      # Publish a global matchRoute event passing the route and the params
+      # Original options hash forwarded to allow further forwarding to backbone
+      @publishEvent 'matchRoute', this, params, options
+
+    # Returns the query string for the current document
+    getCurrentQueryString: ->
+      location.search.substring 1
+
+    # Create a proper Rails-like params hash, not an array like Backbone
+    buildParams: (path, queryString) ->
+      _.extend {},
+        # Add params from query string
+        @extractQueryParams(queryString),
+        # Add named params from pattern matches
+        @extractParams(path),
+        # Add additional params from options
+        # (they might overwrite params extracted from URL)
+        @options.params
+
+    # Extract named parameters from the URL path
+    extractParams: (path) ->
+      params = {}
+
+      # Apply the regular expression
+      matches = @regExp.exec path
+
+      # Fill the hash using the paramNames and the matches
+      for match, index in matches.slice(1)
+        paramName = if @paramNames.length then @paramNames[index] else index
+        params[paramName] = match
+
+      params
+
+    # Extract parameters from the query string
+    extractQueryParams: (queryString) ->
+      params = {}
+      return params unless queryString
+      pairs = queryString.split queryStringFieldSeparator
+      for pair in pairs
+        continue unless pair.length
+        [field, value] = pair.split queryStringValueSeparator
+        continue unless field.length
+        field = decodeURIComponent field
+        value = decodeURIComponent value
+        current = params[field]
+        if current
+          # Handle multiple params with same name:
+          # Aggregate them in an array
+          if current.push
+            # Add the existing array
+            current.push value
+          else
+            # Create a new array
+            params[field] = [current, value]
+        else
+          params[field] = value
+
+      params
+
+define 'chaplin/lib/router', [
+  'underscore'
+  'backbone'
+  'chaplin/mediator'
+  'chaplin/lib/event_broker'
+  'chaplin/lib/route'
+], (_, Backbone, mediator, EventBroker, Route) ->
+  'use strict'
+
+  # The router which is a replacement for Backbone.Router.
+  # Like the standard router, it creates a Backbone.History
+  # instance and registers routes on it.
+
+  class Router # This class does not extend Backbone.Router
+
+    # Borrow the static extend method from Backbone
+    @extend = Backbone.Model.extend
+
+    # Mixin an EventBroker
+    _(@prototype).extend EventBroker
+
+    constructor: (@options = {}) ->
+      _(@options).defaults
+        pushState: true
+
+      @subscribeEvent '!router:route', @routeHandler
+      @subscribeEvent '!router:routeByName', @routeByNameHandler
+      @subscribeEvent '!router:reverse', @reverseHandler
+      @subscribeEvent '!router:changeURL', @changeURLHandler
+
+      @createHistory()
+
+    # Create a Backbone.History instance
+    createHistory: ->
+      Backbone.history or= new Backbone.History()
+
+    startHistory: ->
+      # Start the Backbone.History instance to start routing
+      # This should be called after all routes have been registered
+      Backbone.history.start @options
+
+    # Stop the current Backbone.History instance from observing URL changes
+    stopHistory: ->
+      Backbone.history.stop() if Backbone.History.started
+
+    # Connect an address with a controller action
+    # Creates a route on the Backbone.History instance
+    match: (pattern, target, options = {}) =>
+      if arguments.length is 2 and typeof target is 'object'
+        # Handles cases like `match 'url', controller: 'c', action: 'a'`.
+        options = target
+        {controller, action} = options
+        unless controller and action
+          throw new Error 'Router#match must receive either target or options.controller & options.action'
+      else
+        # Handles `match 'url', 'c#a'`.
+        {controller, action} = options
+        if controller or action
+          throw new Error 'Router#match cannot use both target and options.controller / action'
+        # Separate target into controller and controller action.
+        [controller, action] = target.split('#')
+
+      # Create the route
+      route = new Route pattern, controller, action, options
+      # Register the route at the Backbone.History instance.
+      # Don’t use Backbone.history.route here because it calls
+      # handlers.unshift, inserting the handler at the top of the list.
+      # Since we want routes to match in the order they were specified,
+      # we’re appending the route at the end.
+      Backbone.history.handlers.push {route, callback: route.handler}
+      route
+
+    # Route a given URL path manually, returns whether a route matched
+    # This looks quite like Backbone.History::loadUrl but it
+    # accepts an absolute URL with a leading slash (e.g. /foo)
+    # and passes the routing options to the callback function.
+    route: (path, options = {}) =>
+      _(options).defaults
+        # Update the URL programmatically after routing
+        changeURL: true
+
+      # Remove leading hash or slash
+      path = path.replace /^(\/#|\/)/, ''
+      for handler in Backbone.history.handlers
+        if handler.route.test(path)
+          handler.callback path, options
+          return true
+      false
+
+    reverseHandler: (name, params, callback) ->
+      callback @reverse name, params
+
+    # Find the URL for a given name using the registered routes and
+    # provided parameters.
+    reverse: (name, params) ->
+      # First filter the route handlers to those that are of the same
+      # name
+      for handler in Backbone.history.handlers when handler.route.name is name
+        # Attempt to reverse using the provided parameter hash
+        url = handler.route.reverse params
+
+        # Return the url if we got a valid one; else we continue on
+        return url if url isnt false
+
+      # We didn't get anything
+      false
+
+    # Handler for the global !router:route event
+    routeHandler: (path, options, callback) ->
+      # Support old signature: Assume only path and callback were passed
+      # if we only got two arguments
+      if arguments.length is 2 and typeof options is 'function'
+        callback = options
+        options = {}
+
+      routed = @route path, options
+      callback? routed
+
+    routeByNameHandler: (name, params, options, callback) ->
+      # Support old signature: Assume options wasn't passed
+      # if we only got three arguments
+      if arguments.length is 3 and typeof options is 'function'
+        callback = options
+        options = {}
+
+      path = @reverse name, params
+      return unless path
+      @routeHandler path, options, callback
+
+    # Change the current URL, add a history entry.
+    changeURL: (url, options = {}) ->
+      navigateOptions =
+        # Do not trigger or replace per default
+        trigger: options.trigger is true
+        replace: options.replace is true
+
+      # Navigate to the passed URL and forward options to Backbone
+      Backbone.history.navigate url, navigateOptions
+
+    # Handler for the global !router:changeURL event
+    # Accepts both the url and an options hash that is forwarded to Backbone
+    changeURLHandler: (url, options) ->
+      @changeURL url, options
+
+    # Disposal
+    # --------
+
+    disposed: false
+
+    dispose: ->
+      return if @disposed
+
+      # Stop Backbone.History instance and remove it
+      @stopHistory()
+      delete Backbone.history
+
+      @unsubscribeAllEvents()
+
+      # Finished
+      @disposed = true
+
+      # You’re frozen when your heart’s not open
+      Object.freeze? this
+
+define 'chaplin/lib/delayer', ->
+  'use strict'
+
+  # Delayer
+  # -------
+  #
+  # Add functionality to set unique, named timeouts and intervals
+  # so they can be cleared afterwards when disposing the object.
+  # This is especially useful in your custom View class which inherits
+  # from the standard Chaplin.View.
+  #
+  # Mixin this object to add the delayer capability to any object:
+  # _(object).extend Delayer
+  #
+  # Or to a prototype of a class:
+  # _(@prototype).extend Delayer
+  #
+  # In the dispose method, call `clearDelayed` to remove all pending
+  # timeouts and running intervals:
+  #
+  # dispose: ->
+  #   return if @disposed
+  #   @clearDelayed()
+  #   super
+
+  Delayer =
+
+    setTimeout: (name, time, handler) ->
+      @timeouts ?= {}
+      @clearTimeout name
+      wrappedHandler = =>
+        delete @timeouts[name]
+        handler()
+      handle = setTimeout wrappedHandler, time
+      @timeouts[name] = handle
+      handle
+
+    clearTimeout: (name) ->
+      return unless @timeouts and @timeouts[name]?
+      clearTimeout @timeouts[name]
+      delete @timeouts[name]
+      return
+
+    clearAllTimeouts: ->
+      return unless @timeouts
+      for name, handle of @timeouts
+        @clearTimeout name
+      return
+
+    setInterval: (name, time, handler) ->
+      @clearInterval name
+      @intervals ?= {}
+      handle = setInterval handler, time
+      @intervals[name] = handle
+      handle
+
+    clearInterval: (name) ->
+      return unless @intervals and @intervals[name]
+      clearInterval @intervals[name]
+      delete @intervals[name]
+      return
+
+    clearAllIntervals: ->
+      return unless @intervals
+      for name, handle of @intervals
+        @clearInterval name
+      return
+
+    clearDelayed: ->
+      @clearAllTimeouts()
+      @clearAllIntervals()
+      return
+
+  # You’re frozen when your heart’s not open
+  Object.freeze? Delayer
+
+  Delayer
+
+define 'chaplin/lib/event_broker', [
+  'chaplin/mediator'
+], (mediator) ->
+  'use strict'
+
+  # Add functionality to subscribe and publish to global
+  # Publish/Subscribe events so they can be removed afterwards
+  # when disposing the object.
+  #
+  # Mixin this object to add the subscriber capability to any object:
+  # _(object).extend EventBroker
+  # Or to a prototype of a class:
+  # _(@prototype).extend EventBroker
+  #
+  # Since Backbone 0.9.2 this abstraction just serves the purpose
+  # that a handler cannot be registered twice for the same event.
+
+  EventBroker =
+
+    subscribeEvent: (type, handler) ->
+      if typeof type isnt 'string'
+        throw new TypeError 'EventBroker#subscribeEvent: ' +
+          'type argument must be a string'
+      if typeof handler isnt 'function'
+        throw new TypeError 'EventBroker#subscribeEvent: ' +
+          'handler argument must be a function'
+
+      # Ensure that a handler isn’t registered twice
+      mediator.unsubscribe type, handler, this
+
+      # Register global handler, force context to the subscriber
+      mediator.subscribe type, handler, this
+
+    unsubscribeEvent: (type, handler) ->
+      if typeof type isnt 'string'
+        throw new TypeError 'EventBroker#unsubscribeEvent: ' +
+          'type argument must be a string'
+      if typeof handler isnt 'function'
+        throw new TypeError 'EventBroker#unsubscribeEvent: ' +
+          'handler argument must be a function'
+
+      # Remove global handler
+      mediator.unsubscribe type, handler
+
+    # Unbind all global handlers
+    unsubscribeAllEvents: ->
+      # Remove all handlers with a context of this subscriber
+      mediator.unsubscribe null, null, this
+
+    publishEvent: (type, args...) ->
+      if typeof type isnt 'string'
+        throw new TypeError 'EventBroker#publishEvent: ' +
+          'type argument must be a string'
+
+      # Publish global handler
+      mediator.publish type, args...
+
+  # You’re frozen when your heart’s not open
+  Object.freeze? EventBroker
+
+  EventBroker
+
+define 'chaplin/lib/support', ->
+  'use strict'
+
+  # Feature detection
+  # -----------------
+
+  support =
+
+    # Test for defineProperty support
+    # (IE 8 knows the method but will throw an exception)
+    propertyDescriptors: do ->
+      unless typeof Object.defineProperty is 'function' and
+        typeof Object.defineProperties is 'function'
+          return false
+      try
+        o = {}
+        Object.defineProperty o, 'foo', value: 'bar'
+        return o.foo is 'bar'
+      catch error
+        return false
+
+  support
+
+define 'chaplin/lib/sync_machine', ->
+  'use strict'
+
+  # Simple finite state machine for synchronization of models/collections
+  # Three states: unsynced, syncing and synced
+  # Several transitions between them
+  # Fires Backbone events on every transition
+  # (unsynced, syncing, synced; syncStateChange)
+  # Provides shortcut methods to call handlers when a given state is reached
+  # (named after the events above)
+
+  UNSYNCED = 'unsynced'
+  SYNCING  = 'syncing'
+  SYNCED   = 'synced'
+
+  STATE_CHANGE = 'syncStateChange'
+
+  SyncMachine =
+
+    _syncState: UNSYNCED
+    _previousSyncState: null
+
+    # Get the current state
+    # ---------------------
+
+    syncState: ->
+      @_syncState
+
+    isUnsynced: ->
+      @_syncState is UNSYNCED
+
+    isSynced: ->
+      @_syncState is SYNCED
+
+    isSyncing: ->
+      @_syncState is SYNCING
+
+    # Transitions
+    # -----------
+
+    unsync: ->
+      if @_syncState in [SYNCING, SYNCED]
+        @_previousSync = @_syncState
+        @_syncState = UNSYNCED
+        @trigger @_syncState, this, @_syncState
+        @trigger STATE_CHANGE, this, @_syncState
+      # when UNSYNCED do nothing
+      return
+
+    beginSync: ->
+      if @_syncState in [UNSYNCED, SYNCED]
+        @_previousSync = @_syncState
+        @_syncState = SYNCING
+        @trigger @_syncState, this, @_syncState
+        @trigger STATE_CHANGE, this, @_syncState
+      # when SYNCING do nothing
+      return
+
+    finishSync: ->
+      if @_syncState is SYNCING
+        @_previousSync = @_syncState
+        @_syncState = SYNCED
+        @trigger @_syncState, this, @_syncState
+        @trigger STATE_CHANGE, this, @_syncState
+      # when SYNCED, UNSYNCED do nothing
+      return
+
+    abortSync: ->
+      if @_syncState is SYNCING
+        @_syncState = @_previousSync
+        @_previousSync = @_syncState
+        @trigger @_syncState, this, @_syncState
+        @trigger STATE_CHANGE, this, @_syncState
+      # when UNSYNCED, SYNCED do nothing
+      return
+
+  # Create shortcut methods to bind a handler to a state change
+  # -----------------------------------------------------------
+
+  for event in [UNSYNCED, SYNCING, SYNCED, STATE_CHANGE]
+    do (event) ->
+      SyncMachine[event] = (callback, context = @) ->
+        @on event, callback, context
+        callback.call(context) if @_syncState is event
+
+  # You’re frozen when your heart’s not open
+  Object.freeze? SyncMachine
+
+  SyncMachine
+
+define 'chaplin/lib/utils', [
+  'chaplin/lib/support'
+], (support) ->
+  'use strict'
+
+  # Utilities
+  # ---------
+
+  utils =
+
+    # Object Helpers
+    # --------------
+
+    # Prototypal delegation. Create an object which delegates
+    # to another object.
+    beget: do ->
+      if typeof Object.create is 'function'
+        Object.create
+      else
+        ctor = ->
+        (obj) ->
+          ctor.prototype = obj
+          new ctor
+
+    # Make properties readonly and not configurable
+    # using ECMAScript 5 property descriptors
+    readonly: do ->
+      if support.propertyDescriptors
+        readonlyDescriptor =
+          writable: false
+          enumerable: true
+          configurable: false
+        (obj, properties...) ->
+          for prop in properties
+            readonlyDescriptor.value = obj[prop]
+            Object.defineProperty obj, prop, readonlyDescriptor
+          true
+      else
+        ->
+          false
+
+    # Get the whole chain of object prototypes.
+    getPrototypeChain: (object) ->
+      chain = [object.constructor.prototype]
+      chain.push object while object = object.constructor?.__super__
+      chain
+
+    # Get all property versions from object’s prototype chain.
+    # E.g. if object1 & object2 have `prop` and object2 inherits from
+    # object1, it will get [object1prop, object2prop].
+    getAllPropertyVersions: (object, property) ->
+      _(utils.getPrototypeChain object)
+        .chain()
+        .pluck(property)
+        .compact()
+        .uniq()
+        .value()
+        .reverse()
+
+    # Function Helpers
+    # ----------------
+
+    # Wrap a method in order to call the corresponding
+    # `after-` method automatically (e.g. `afterRender` or
+    # `afterInitialize`)
+    wrapMethod: (instance, name) ->
+      # Enclose the original function
+      func = instance[name]
+      # Set a flag
+      instance["#{name}IsWrapped"] = true
+      # Create the wrapper method
+      instance[name] = ->
+        # Stop if the instance was already disposed
+        return false if instance.disposed
+        # Call the original method
+        func.apply instance, arguments
+        # Call the corresponding `after-` method
+        instance["after#{utils.upcase(name)}"] arguments...
+        # Return the view
+        instance
+
+    # String Helpers
+    # --------------
+
+    # Upcase the first character
+    upcase: (str) ->
+      str.charAt(0).toUpperCase() + str.substring(1)
+
+    # underScoreHelper -> under_score_helper
+    underscorize: (string) ->
+      string.replace /[A-Z]/g, (char, index) ->
+        (if index isnt 0 then '_' else '') + char.toLowerCase()
+
+    # Event handling helpers
+    # ----------------------
+
+    # Returns whether a modifier key is pressed during a keypress or mouse click
+    modifierKeyPressed: (event) ->
+      event.shiftKey or event.altKey or event.ctrlKey or event.metaKey
+
+  # Finish
+  # ------
+
+  # Seal the utils object
+  Object.seal? utils
+
+  utils
+
+define 'chaplin', [
+  'chaplin/application'
+  'chaplin/mediator'
+  'chaplin/dispatcher'
+  'chaplin/controllers/controller'
+  'chaplin/models/collection'
+  'chaplin/models/model'
+  'chaplin/views/layout'
+  'chaplin/views/view'
+  'chaplin/views/collection_view'
+  'chaplin/lib/route'
+  'chaplin/lib/router'
+  'chaplin/lib/delayer'
+  'chaplin/lib/event_broker'
+  'chaplin/lib/support'
+  'chaplin/lib/sync_machine'
+  'chaplin/lib/utils'
+], (Application, mediator, Dispatcher, Controller, Collection, Model, Layout, View, CollectionView, Route, Router, Delayer, EventBroker, support, SyncMachine, utils) ->
+  {
+    Application,
+    mediator,
+    Dispatcher,
+    Controller,
+    Collection,
+    Model,
+    Layout,
+    View,
+    CollectionView,
+    Route,
+    Router,
+    Delayer,
+    EventBroker,
+    support,
+    SyncMachine,
+    utils
+  }
diff --git a/vendor/assets/javascripts/underscore.js b/vendor/assets/javascripts/underscore.js
new file mode 100644
index 0000000..ac28c6d
--- /dev/null
+++ b/vendor/assets/javascripts/underscore.js
@@ -0,0 +1,1222 @@
+//     Underscore.js 1.4.3
+//     http://underscorejs.org
+//     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+//     Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+  // Baseline setup
+  // --------------
+
+  // Establish the root object, `window` in the browser, or `global` on the server.
+  var root = this;
+
+  // Save the previous value of the `_` variable.
+  var previousUnderscore = root._;
+
+  // Establish the object that gets returned to break out of a loop iteration.
+  var breaker = {};
+
+  // Save bytes in the minified (but not gzipped) version:
+  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+  // Create quick reference variables for speed access to core prototypes.
+  var push             = ArrayProto.push,
+      slice            = ArrayProto.slice,
+      concat           = ArrayProto.concat,
+      toString         = ObjProto.toString,
+      hasOwnProperty   = ObjProto.hasOwnProperty;
+
+  // All **ECMAScript 5** native function implementations that we hope to use
+  // are declared here.
+  var
+    nativeForEach      = ArrayProto.forEach,
+    nativeMap          = ArrayProto.map,
+    nativeReduce       = ArrayProto.reduce,
+    nativeReduceRight  = ArrayProto.reduceRight,
+    nativeFilter       = ArrayProto.filter,
+    nativeEvery        = ArrayProto.every,
+    nativeSome         = ArrayProto.some,
+    nativeIndexOf      = ArrayProto.indexOf,
+    nativeLastIndexOf  = ArrayProto.lastIndexOf,
+    nativeIsArray      = Array.isArray,
+    nativeKeys         = Object.keys,
+    nativeBind         = FuncProto.bind;
+
+  // Create a safe reference to the Underscore object for use below.
+  var _ = function(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  };
+
+  // Export the Underscore object for **Node.js**, with
+  // backwards-compatibility for the old `require()` API. If we're in
+  // the browser, add `_` as a global object via a string identifier,
+  // for Closure Compiler "advanced" mode.
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = _;
+    }
+    exports._ = _;
+  } else {
+    root._ = _;
+  }
+
+  // Current version.
+  _.VERSION = '1.4.3';
+
+  // Collection Functions
+  // --------------------
+
+  // The cornerstone, an `each` implementation, aka `forEach`.
+  // Handles objects with the built-in `forEach`, arrays, and raw objects.
+  // Delegates to **ECMAScript 5**'s native `forEach` if available.
+  var each = _.each = _.forEach = function(obj, iterator, context) {
+    if (obj == null) return;
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+      for (var i = 0, l = obj.length; i < l; i++) {
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
+      }
+    } else {
+      for (var key in obj) {
+        if (_.has(obj, key)) {
+          if (iterator.call(context, obj[key], key, obj) === breaker) return;
+        }
+      }
+    }
+  };
+
+  // Return the results of applying the iterator to each element.
+  // Delegates to **ECMAScript 5**'s native `map` if available.
+  _.map = _.collect = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+    each(obj, function(value, index, list) {
+      results[results.length] = iterator.call(context, value, index, list);
+    });
+    return results;
+  };
+
+  var reduceError = 'Reduce of empty array with no initial value';
+
+  // **Reduce** builds up a single result from a list of values, aka `inject`,
+  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduce && obj.reduce === nativeReduce) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+    }
+    each(obj, function(value, index, list) {
+      if (!initial) {
+        memo = value;
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, value, index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // The right-associative version of reduce, also known as `foldr`.
+  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+    }
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // Return the first value which passes a truth test. Aliased as `detect`.
+  _.find = _.detect = function(obj, iterator, context) {
+    var result;
+    any(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) {
+        result = value;
+        return true;
+      }
+    });
+    return result;
+  };
+
+  // Return all the elements that pass a truth test.
+  // Delegates to **ECMAScript 5**'s native `filter` if available.
+  // Aliased as `select`.
+  _.filter = _.select = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+    each(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) results[results.length] = value;
+    });
+    return results;
+  };
+
+  // Return all the elements for which a truth test fails.
+  _.reject = function(obj, iterator, context) {
+    return _.filter(obj, function(value, index, list) {
+      return !iterator.call(context, value, index, list);
+    }, context);
+  };
+
+  // Determine whether all of the elements match a truth test.
+  // Delegates to **ECMAScript 5**'s native `every` if available.
+  // Aliased as `all`.
+  _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = true;
+    if (obj == null) return result;
+    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+    each(obj, function(value, index, list) {
+      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if at least one element in the object matches a truth test.
+  // Delegates to **ECMAScript 5**'s native `some` if available.
+  // Aliased as `any`.
+  var any = _.some = _.any = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = false;
+    if (obj == null) return result;
+    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+    each(obj, function(value, index, list) {
+      if (result || (result = iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if the array or object contains a given value (using `===`).
+  // Aliased as `include`.
+  _.contains = _.include = function(obj, target) {
+    if (obj == null) return false;
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+    return any(obj, function(value) {
+      return value === target;
+    });
+  };
+
+  // Invoke a method (with arguments) on every item in a collection.
+  _.invoke = function(obj, method) {
+    var args = slice.call(arguments, 2);
+    return _.map(obj, function(value) {
+      return (_.isFunction(method) ? method : value[method]).apply(value, args);
+    });
+  };
+
+  // Convenience version of a common use case of `map`: fetching a property.
+  _.pluck = function(obj, key) {
+    return _.map(obj, function(value){ return value[key]; });
+  };
+
+  // Convenience version of a common use case of `filter`: selecting only objects
+  // with specific `key:value` pairs.
+  _.where = function(obj, attrs) {
+    if (_.isEmpty(attrs)) return [];
+    return _.filter(obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
+
+  // Return the maximum element or (element-based computation).
+  // Can't optimize arrays of integers longer than 65,535 elements.
+  // See: https://bugs.webkit.org/show_bug.cgi?id=80797
+  _.max = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return -Infinity;
+    var result = {computed : -Infinity, value: -Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed >= result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Return the minimum element (or element-based computation).
+  _.min = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return Infinity;
+    var result = {computed : Infinity, value: Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed < result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Shuffle an array.
+  _.shuffle = function(obj) {
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
+      shuffled[rand] = value;
+    });
+    return shuffled;
+  };
+
+  // An internal function to generate lookup iterators.
+  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
+
+  // Sort the object's values by a criterion produced by an iterator.
+  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
+    return _.pluck(_.map(obj, function(value, index, list) {
+      return {
+        value : value,
+        index : index,
+        criteria : iterator.call(context, value, index, list)
+      };
+    }).sort(function(left, right) {
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index < right.index ? -1 : 1;
+    }), 'value');
+  };
+
+  // An internal function used for aggregate "group by" operations.
+  var group = function(obj, value, context, behavior) {
+    var result = {};
+    var iterator = lookupIterator(value || _.identity);
+    each(obj, function(value, index) {
+      var key = iterator.call(context, value, index, obj);
+      behavior(result, key, value);
+    });
+    return result;
+  };
+
+  // Groups the object's values by a criterion. Pass either a string attribute
+  // to group by, or a function that returns the criterion.
+  _.groupBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+    });
+  };
+
+  // Counts instances of an object that group by a certain criterion. Pass
+  // either a string attribute to count by, or a function that returns the
+  // criterion.
+  _.countBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key) {
+      if (!_.has(result, key)) result[key] = 0;
+      result[key]++;
+    });
+  };
+
+  // Use a comparator function to figure out the smallest index at which
+  // an object should be inserted so as to maintain order. Uses binary search.
+  _.sortedIndex = function(array, obj, iterator, context) {
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
+    var low = 0, high = array.length;
+    while (low < high) {
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+    }
+    return low;
+  };
+
+  // Safely convert anything iterable into a real, live array.
+  _.toArray = function(obj) {
+    if (!obj) return [];
+    if (_.isArray(obj)) return slice.call(obj);
+    if (obj.length === +obj.length) return _.map(obj, _.identity);
+    return _.values(obj);
+  };
+
+  // Return the number of elements in an object.
+  _.size = function(obj) {
+    if (obj == null) return 0;
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+  };
+
+  // Array Functions
+  // ---------------
+
+  // Get the first element of an array. Passing **n** will return the first N
+  // values in the array. Aliased as `head` and `take`. The **guard** check
+  // allows it to work with `_.map`.
+  _.first = _.head = _.take = function(array, n, guard) {
+    if (array == null) return void 0;
+    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+  };
+
+  // Returns everything but the last entry of the array. Especially useful on
+  // the arguments object. Passing **n** will return all the values in
+  // the array, excluding the last N. The **guard** check allows it to work with
+  // `_.map`.
+  _.initial = function(array, n, guard) {
+    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+  };
+
+  // Get the last element of an array. Passing **n** will return the last N
+  // values in the array. The **guard** check allows it to work with `_.map`.
+  _.last = function(array, n, guard) {
+    if (array == null) return void 0;
+    if ((n != null) && !guard) {
+      return slice.call(array, Math.max(array.length - n, 0));
+    } else {
+      return array[array.length - 1];
+    }
+  };
+
+  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+  // Especially useful on the arguments object. Passing an **n** will return
+  // the rest N values in the array. The **guard**
+  // check allows it to work with `_.map`.
+  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
+  };
+
+  // Trim out all falsy values from an array.
+  _.compact = function(array) {
+    return _.filter(array, _.identity);
+  };
+
+  // Internal implementation of a recursive `flatten` function.
+  var flatten = function(input, shallow, output) {
+    each(input, function(value) {
+      if (_.isArray(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
+  };
+
+  // Return a completely flattened version of an array.
+  _.flatten = function(array, shallow) {
+    return flatten(array, shallow, []);
+  };
+
+  // Return a version of the array that does not contain the specified value(s).
+  _.without = function(array) {
+    return _.difference(array, slice.call(arguments, 1));
+  };
+
+  // Produce a duplicate-free version of the array. If the array has already
+  // been sorted, you have the option of using a faster algorithm.
+  // Aliased as `unique`.
+  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    if (_.isFunction(isSorted)) {
+      context = iterator;
+      iterator = isSorted;
+      isSorted = false;
+    }
+    var initial = iterator ? _.map(array, iterator, context) : array;
+    var results = [];
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
+        results.push(array[index]);
+      }
+    });
+    return results;
+  };
+
+  // Produce an array that contains the union: each distinct element from all of
+  // the passed-in arrays.
+  _.union = function() {
+    return _.uniq(concat.apply(ArrayProto, arguments));
+  };
+
+  // Produce an array that contains every item shared between all the
+  // passed-in arrays.
+  _.intersection = function(array) {
+    var rest = slice.call(arguments, 1);
+    return _.filter(_.uniq(array), function(item) {
+      return _.every(rest, function(other) {
+        return _.indexOf(other, item) >= 0;
+      });
+    });
+  };
+
+  // Take the difference between one array and a number of other arrays.
+  // Only the elements present in just the first array will remain.
+  _.difference = function(array) {
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
+  };
+
+  // Zip together multiple lists into a single array -- elements that share
+  // an index go together.
+  _.zip = function() {
+    var args = slice.call(arguments);
+    var length = _.max(_.pluck(args, 'length'));
+    var results = new Array(length);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(args, "" + i);
+    }
+    return results;
+  };
+
+  // Converts lists into objects. Pass either a single array of `[key, value]`
+  // pairs, or two parallel arrays of the same length -- one of keys, and one of
+  // the corresponding values.
+  _.object = function(list, values) {
+    if (list == null) return {};
+    var result = {};
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
+
+  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+  // we need this function. Return the position of the first occurrence of an
+  // item in an array, or -1 if the item is not included in the array.
+  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+  // If the array is large and already in sort order, pass `true`
+  // for **isSorted** to use binary search.
+  _.indexOf = function(array, item, isSorted) {
+    if (array == null) return -1;
+    var i = 0, l = array.length;
+    if (isSorted) {
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
+    }
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < l; i++) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+  _.lastIndexOf = function(array, item, from) {
+    if (array == null) return -1;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Generate an integer Array containing an arithmetic progression. A port of
+  // the native Python `range()` function. See
+  // [the Python documentation](http://docs.python.org/library/functions.html#range).
+  _.range = function(start, stop, step) {
+    if (arguments.length <= 1) {
+      stop = start || 0;
+      start = 0;
+    }
+    step = arguments[2] || 1;
+
+    var len = Math.max(Math.ceil((stop - start) / step), 0);
+    var idx = 0;
+    var range = new Array(len);
+
+    while(idx < len) {
+      range[idx++] = start;
+      start += step;
+    }
+
+    return range;
+  };
+
+  // Function (ahem) Functions
+  // ------------------
+
+  // Reusable constructor function for prototype setting.
+  var ctor = function(){};
+
+  // Create a function bound to a given object (assigning `this`, and arguments,
+  // optionally). Binding with arguments is also known as `curry`.
+  // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
+  // We check for `func.bind` first, to fail fast when `func` is undefined.
+  _.bind = function(func, context) {
+    var args, bound;
+    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+    if (!_.isFunction(func)) throw new TypeError;
+    args = slice.call(arguments, 2);
+    return bound = function() {
+      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+      ctor.prototype = func.prototype;
+      var self = new ctor;
+      ctor.prototype = null;
+      var result = func.apply(self, args.concat(slice.call(arguments)));
+      if (Object(result) === result) return result;
+      return self;
+    };
+  };
+
+  // Bind all of an object's methods to that object. Useful for ensuring that
+  // all callbacks defined on an object belong to it.
+  _.bindAll = function(obj) {
+    var funcs = slice.call(arguments, 1);
+    if (funcs.length === 0) funcs = _.functions(obj);
+    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+    return obj;
+  };
+
+  // Memoize an expensive function by storing its results.
+  _.memoize = function(func, hasher) {
+    var memo = {};
+    hasher || (hasher = _.identity);
+    return function() {
+      var key = hasher.apply(this, arguments);
+      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+    };
+  };
+
+  // Delays a function for the given number of milliseconds, and then calls
+  // it with the arguments supplied.
+  _.delay = function(func, wait) {
+    var args = slice.call(arguments, 2);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
+  };
+
+  // Defers a function, scheduling it to run after the current call stack has
+  // cleared.
+  _.defer = function(func) {
+    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+  };
+
+  // Returns a function, that, when invoked, will only be triggered at most once
+  // during a given window of time.
+  _.throttle = function(func, wait) {
+    var context, args, timeout, result;
+    var previous = 0;
+    var later = function() {
+      previous = new Date;
+      timeout = null;
+      result = func.apply(context, args);
+    };
+    return function() {
+      var now = new Date;
+      var remaining = wait - (now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0) {
+        clearTimeout(timeout);
+        timeout = null;
+        previous = now;
+        result = func.apply(context, args);
+      } else if (!timeout) {
+        timeout = setTimeout(later, remaining);
+      }
+      return result;
+    };
+  };
+
+  // Returns a function, that, as long as it continues to be invoked, will not
+  // be triggered. The function will be called after it stops being called for
+  // N milliseconds. If `immediate` is passed, trigger the function on the
+  // leading edge, instead of the trailing.
+  _.debounce = function(func, wait, immediate) {
+    var timeout, result;
+    return function() {
+      var context = this, args = arguments;
+      var later = function() {
+        timeout = null;
+        if (!immediate) result = func.apply(context, args);
+      };
+      var callNow = immediate && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+      if (callNow) result = func.apply(context, args);
+      return result;
+    };
+  };
+
+  // Returns a function that will be executed at most one time, no matter how
+  // often you call it. Useful for lazy initialization.
+  _.once = function(func) {
+    var ran = false, memo;
+    return function() {
+      if (ran) return memo;
+      ran = true;
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
+    };
+  };
+
+  // Returns the first function passed as an argument to the second,
+  // allowing you to adjust arguments, run code before and after, and
+  // conditionally execute the original function.
+  _.wrap = function(func, wrapper) {
+    return function() {
+      var args = [func];
+      push.apply(args, arguments);
+      return wrapper.apply(this, args);
+    };
+  };
+
+  // Returns a function that is the composition of a list of functions, each
+  // consuming the return value of the function that follows.
+  _.compose = function() {
+    var funcs = arguments;
+    return function() {
+      var args = arguments;
+      for (var i = funcs.length - 1; i >= 0; i--) {
+        args = [funcs[i].apply(this, args)];
+      }
+      return args[0];
+    };
+  };
+
+  // Returns a function that will only be executed after being called N times.
+  _.after = function(times, func) {
+    if (times <= 0) return func();
+    return function() {
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
+    };
+  };
+
+  // Object Functions
+  // ----------------
+
+  // Retrieve the names of an object's properties.
+  // Delegates to **ECMAScript 5**'s native `Object.keys`
+  _.keys = nativeKeys || function(obj) {
+    if (obj !== Object(obj)) throw new TypeError('Invalid object');
+    var keys = [];
+    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+    return keys;
+  };
+
+  // Retrieve the values of an object's properties.
+  _.values = function(obj) {
+    var values = [];
+    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+    return values;
+  };
+
+  // Convert an object into a list of `[key, value]` pairs.
+  _.pairs = function(obj) {
+    var pairs = [];
+    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+    return pairs;
+  };
+
+  // Invert the keys and values of an object. The values must be serializable.
+  _.invert = function(obj) {
+    var result = {};
+    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+    return result;
+  };
+
+  // Return a sorted list of the function names available on the object.
+  // Aliased as `methods`
+  _.functions = _.methods = function(obj) {
+    var names = [];
+    for (var key in obj) {
+      if (_.isFunction(obj[key])) names.push(key);
+    }
+    return names.sort();
+  };
+
+  // Extend a given object with all the properties in passed-in object(s).
+  _.extend = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Return a copy of the object only containing the whitelisted properties.
+  _.pick = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
+    });
+    return copy;
+  };
+
+   // Return a copy of the object without the blacklisted properties.
+  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
+  };
+
+  // Fill in a given object with default properties.
+  _.defaults = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          if (obj[prop] == null) obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Create a (shallow-cloned) duplicate of an object.
+  _.clone = function(obj) {
+    if (!_.isObject(obj)) return obj;
+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+  };
+
+  // Invokes interceptor with the obj, and then returns obj.
+  // The primary purpose of this method is to "tap into" a method chain, in
+  // order to perform operations on intermediate results within the chain.
+  _.tap = function(obj, interceptor) {
+    interceptor(obj);
+    return obj;
+  };
+
+  // Internal recursive comparison function for `isEqual`.
+  var eq = function(a, b, aStack, bStack) {
+    // Identical objects are equal. `0 === -0`, but they aren't identical.
+    // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
+    if (a === b) return a !== 0 || 1 / a == 1 / b;
+    // A strict comparison is necessary because `null == undefined`.
+    if (a == null || b == null) return a === b;
+    // Unwrap any wrapped objects.
+    if (a instanceof _) a = a._wrapped;
+    if (b instanceof _) b = b._wrapped;
+    // Compare `[[Class]]` names.
+    var className = toString.call(a);
+    if (className != toString.call(b)) return false;
+    switch (className) {
+      // Strings, numbers, dates, and booleans are compared by value.
+      case '[object String]':
+        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+        // equivalent to `new String("5")`.
+        return a == String(b);
+      case '[object Number]':
+        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+        // other numeric values.
+        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+      case '[object Date]':
+      case '[object Boolean]':
+        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+        // millisecond representations. Note that invalid dates with millisecond representations
+        // of `NaN` are not equivalent.
+        return +a == +b;
+      // RegExps are compared by their source patterns and flags.
+      case '[object RegExp]':
+        return a.source == b.source &&
+               a.global == b.global &&
+               a.multiline == b.multiline &&
+               a.ignoreCase == b.ignoreCase;
+    }
+    if (typeof a != 'object' || typeof b != 'object') return false;
+    // Assume equality for cyclic structures. The algorithm for detecting cyclic
+    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+    var length = aStack.length;
+    while (length--) {
+      // Linear search. Performance is inversely proportional to the number of
+      // unique nested structures.
+      if (aStack[length] == a) return bStack[length] == b;
+    }
+    // Add the first object to the stack of traversed objects.
+    aStack.push(a);
+    bStack.push(b);
+    var size = 0, result = true;
+    // Recursively compare objects and arrays.
+    if (className == '[object Array]') {
+      // Compare array lengths to determine if a deep comparison is necessary.
+      size = a.length;
+      result = size == b.length;
+      if (result) {
+        // Deep compare the contents, ignoring non-numeric properties.
+        while (size--) {
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+        }
+      }
+    } else {
+      // Objects with different constructors are not equivalent, but `Object`s
+      // from different frames are.
+      var aCtor = a.constructor, bCtor = b.constructor;
+      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+                               _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+        return false;
+      }
+      // Deep compare objects.
+      for (var key in a) {
+        if (_.has(a, key)) {
+          // Count the expected number of properties.
+          size++;
+          // Deep compare each member.
+          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+        }
+      }
+      // Ensure that both objects contain the same number of properties.
+      if (result) {
+        for (key in b) {
+          if (_.has(b, key) && !(size--)) break;
+        }
+        result = !size;
+      }
+    }
+    // Remove the first object from the stack of traversed objects.
+    aStack.pop();
+    bStack.pop();
+    return result;
+  };
+
+  // Perform a deep comparison to check if two objects are equal.
+  _.isEqual = function(a, b) {
+    return eq(a, b, [], []);
+  };
+
+  // Is a given array, string, or object empty?
+  // An "empty" object has no enumerable own-properties.
+  _.isEmpty = function(obj) {
+    if (obj == null) return true;
+    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+    for (var key in obj) if (_.has(obj, key)) return false;
+    return true;
+  };
+
+  // Is a given value a DOM element?
+  _.isElement = function(obj) {
+    return !!(obj && obj.nodeType === 1);
+  };
+
+  // Is a given value an array?
+  // Delegates to ECMA5's native Array.isArray
+  _.isArray = nativeIsArray || function(obj) {
+    return toString.call(obj) == '[object Array]';
+  };
+
+  // Is a given variable an object?
+  _.isObject = function(obj) {
+    return obj === Object(obj);
+  };
+
+  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
+
+  // Define a fallback version of the method in browsers (ahem, IE), where
+  // there isn't any inspectable "Arguments" type.
+  if (!_.isArguments(arguments)) {
+    _.isArguments = function(obj) {
+      return !!(obj && _.has(obj, 'callee'));
+    };
+  }
+
+  // Optimize `isFunction` if appropriate.
+  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
+
+  // Is a given object a finite number?
+  _.isFinite = function(obj) {
+    return isFinite(obj) && !isNaN(parseFloat(obj));
+  };
+
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+  _.isNaN = function(obj) {
+    return _.isNumber(obj) && obj != +obj;
+  };
+
+  // Is a given value a boolean?
+  _.isBoolean = function(obj) {
+    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+  };
+
+  // Is a given value equal to null?
+  _.isNull = function(obj) {
+    return obj === null;
+  };
+
+  // Is a given variable undefined?
+  _.isUndefined = function(obj) {
+    return obj === void 0;
+  };
+
+  // Shortcut function for checking if an object has a given property directly
+  // on itself (in other words, not on a prototype).
+  _.has = function(obj, key) {
+    return hasOwnProperty.call(obj, key);
+  };
+
+  // Utility Functions
+  // -----------------
+
+  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+  // previous owner. Returns a reference to the Underscore object.
+  _.noConflict = function() {
+    root._ = previousUnderscore;
+    return this;
+  };
+
+  // Keep the identity function around for default iterators.
+  _.identity = function(value) {
+    return value;
+  };
+
+  // Run a function **n** times.
+  _.times = function(n, iterator, context) {
+    var accum = Array(n);
+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+    return accum;
+  };
+
+  // Return a random integer between min and max (inclusive).
+  _.random = function(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + (0 | Math.random() * (max - min + 1));
+  };
+
+  // List of HTML entities for escaping.
+  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '/': '&#x2F;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
+
+  // Regexes containing the keys and values listed immediately above.
+  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+  };
+
+  // Functions for escaping and unescaping strings to/from HTML interpolation.
+  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
+
+  // If the value of the named property is a function then invoke it;
+  // otherwise, return it.
+  _.result = function(object, property) {
+    if (object == null) return null;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
+
+  // Add your own custom functions to the Underscore object.
+  _.mixin = function(obj) {
+    each(_.functions(obj), function(name){
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
+    });
+  };
+
+  // Generate a unique integer id (unique within the entire client session).
+  // Useful for temporary DOM ids.
+  var idCounter = 0;
+  _.uniqueId = function(prefix) {
+    var id = '' + (++idCounter);
+    return prefix ? prefix + id : id;
+  };
+
+  // By default, Underscore uses ERB-style template delimiters, change the
+  // following template settings to use alternative delimiters.
+  _.templateSettings = {
+    evaluate    : /<%([\s\S]+?)%>/g,
+    interpolate : /<%=([\s\S]+?)%>/g,
+    escape      : /<%-([\s\S]+?)%>/g
+  };
+
+  // When customizing `templateSettings`, if you don't want to define an
+  // interpolation, evaluation or escaping regex, we need one that is
+  // guaranteed not to match.
+  var noMatch = /(.)^/;
+
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
+  // JavaScript micro-templating, similar to John Resig's implementation.
+  // Underscore templating handles arbitrary delimiters, preserves whitespace,
+  // and correctly escapes quotes within interpolated code.
+  _.template = function(text, data, settings) {
+    var render;
+    settings = _.defaults({}, settings, _.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      }
+      if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      }
+      if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+      index = offset + match.length;
+      return match;
+    });
+    source += "';\n";
+
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + "return __p;\n";
+
+    try {
+      render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
+    };
+
+    // Provide the compiled function source as a convenience for precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+    return template;
+  };
+
+  // Add a "chain" function, which will delegate to the wrapper.
+  _.chain = function(obj) {
+    return _(obj).chain();
+  };
+
+  // OOP
+  // ---------------
+  // If Underscore is called as a function, it returns a wrapped object that
+  // can be used OO-style. This wrapper holds altered versions of all the
+  // underscore functions. Wrapped objects may be chained.
+
+  // Helper function to continue chaining intermediate results.
+  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
+  };
+
+  // Add all of the Underscore functions to the wrapper object.
+  _.mixin(_);
+
+  // Add all mutator Array functions to the wrapper.
+  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
+    };
+  });
+
+  // Add all accessor Array functions to the wrapper.
+  each(['concat', 'join', 'slice'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
+    };
+  });
+
+  _.extend(_.prototype, {
+
+    // Start chaining a wrapped Underscore object.
+    chain: function() {
+      this._chain = true;
+      return this;
+    },
+
+    // Extracts the result from a wrapped and chained object.
+    value: function() {
+      return this._wrapped;
+    }
+
+  });
+
+}).call(this);