batman-rails 0.15.4 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 827c6fe292b697c321c92b6ee0f3034720f0081c
-  data.tar.gz: ca9f83be4e3331e7b3dab5eb4cdc80ee0296ff7d
+  metadata.gz: 9c8deae7a6dad1d59f1cb67e92a798e50414598d
+  data.tar.gz: a7b266ed03e94f18b5db5b585e4de18138e9510a
 SHA512:
-  metadata.gz: a00bce8ce04bcdbac33a8ff75f6b32159613a1840555f4430341733c0933d32aed1789c26d9df0871a91e1979b37d0af5776b9f559e5a91b5cb2d2582e797956
-  data.tar.gz: 92998e811e228de5b19e0731b77c47b36af61328156109f8f4ce28aa137c81b6d45f423803932c637ebc92f4ea3ee7dfc6ec0caf21919f643f6b8cd605facb3a
+  metadata.gz: a69ac93e5f28fc771eae9177305d3cc7c821d8a8f15a01220785b1562930f16b0577187f62c54185739cbf82af8ce27b435bc381eee4d795a18c136f276e896e
+  data.tar.gz: 2bd249704f4a95b3dc1bf3fc4acf8e94a7d09788cf362ff4b01b833a4924a4b0cec9883d16707fa134c972226732413609077ae29d682da5ea2bee6e282f0991

data/README.md

@@ -1,6 +1,6 @@
 # Batman::Rails
 
-Easily setup and use batman.js (0.15) with Rails 4
+Easily setup and use batman.js (0.16) with Rails 4
 
 ## Installation
 
@@ -15,25 +15,32 @@ And then execute:
 
 ### Layout and namespacing
 
-Running `rails generate batman:app` will create the following directory structure under `app/assets/app_name/`:
+Running `rails generate batman:app` will:
 
-    models/
-    views/
-    controllers/
-    html/
-    lib/
+- create the following directory structure under `app/assets/batman/`:
+  
+  ``` 
+      - models/
+      - views/
+      - controllers/
+      - html/
+      - lib/
+      - app_name.coffee # initial setup & requires
+  ```
 
-It will also create a toplevel `app_name.coffee` file to setup namespacing and setup initial requires.
+- create a controller & route to server your batman.js app from `/` and serve HTML 
+- configure the asset pipeline to precompile `app_name.coffee`
 
 ## Generators
-Batman-Rails provides 3 simple generators to help get you started using Batman.js with Rails.
-The generators will only create client side code (CoffeeScript).
+
+Batman-Rails provides 3 simple generators to help get you started using batman.js with Rails.
+The generators will only create client-side code (CoffeeScript).
 
 ### Model Generator
 
     rails generate batman:model
 
-This generator creates a batman model inside `app/assets/app_name/models` to be used to talk to the Rails backend.
+This generator creates a batman model inside `app/assets/batman/models` to be used to talk to the Rails backend.
 
 ### Controllers
 
@@ -67,6 +74,22 @@ Install the gem and generate scaffolding.
 
 You now have installed the `batman-rails` gem, setup a default directory structure for your frontend batman code. Then you generated the usual Rails server side scaffolding and finally generated Batman.js code to provide a simple single page app.
 
+## Precompiling Views
+
+In production, you may want to send all your HTML templates with the first request rather than sending them as-needed. `batman-rails` includes a view helper to do this. Add it to your application layout:
+
+```erb
+    <%= batman_define_views %>
+```
+
+It will gather HTML from `app/assets/batman/html` and interpolate them into JS code to preload `Batman.View.store`. If your HTML is in another directory, pass that directory as an option:
+
+```erb
+  <%= batman_define_views(path_to_html: "app/assets/templates/">
+```
+
+Now it will gather HTML from `app/assets/templates`!
+
 ## Contributing
 
 1. Fork it

data/lib/batman-rails.rb

@@ -1,8 +1,14 @@
 require "batman-rails/version"
+require "batman-rails/helpers/define_view_helper"
 
 module Batman
   module Rails
     class Engine < ::Rails::Engine
+      initializer 'batman_rails.action_controller' do |app|
+        ActiveSupport.on_load :action_controller do
+          helper Batman::DefineViewHelper
+        end
+      end
     end
   end
 end

data/lib/batman-rails/helpers/define_view_helper.rb

@@ -0,0 +1,45 @@
+module Batman
+  module DefineViewHelper
+    def batman_define_views(options={})
+      content_tag :script do
+        template_js_string = BatmanView.all(self, options).map(&:inline_preload_javascript).join
+        raw %Q[(function(){#{template_js_string}})();]
+      end
+    end
+
+    class BatmanView
+      PATH_TO_HTML = "app/assets/batman/html/"
+
+      attr_accessor :pathname, :render_context, :path_to_html
+
+      def self.all(render_context, options={})
+        path_to_html = options[:path_to_html] || PATH_TO_HTML
+        glob_path = File.join(path_to_html, "**/*")
+        valid_files = Dir.glob(glob_path).select { |pathname| File.file?(pathname) }
+        valid_files.collect do |pathname|
+          new(pathname, render_context, path_to_html: path_to_html)
+        end
+      end
+
+      def initialize(pathname, render_context, options={})
+        @pathname = pathname
+        @render_context = render_context
+        @path_to_html = options[:path_to_html] || PATH_TO_HTML
+      end
+
+      def inline_preload_javascript
+        %Q{Batman.View.store.set(#{name.to_json}, #{content.to_json});}
+      end
+
+      private
+
+      def name
+        pathname.split(path_to_html).last.gsub(/\.html\.[a-z]+$/, '').to_s
+      end
+
+      def content
+        render_context.render(file: pathname)
+      end
+    end
+  end
+end

data/lib/batman-rails/version.rb

@@ -1,6 +1,6 @@
 module Batman
   module Rails
-    VERSION = "0.15.4"
-    BATMAN_VERSION = "0.15.0"
+    VERSION = "0.16.0"
+    BATMAN_VERSION = "0.16.0"
   end
 end

data/lib/generators/batman/app_generator.rb

@@ -26,6 +26,10 @@ module Batman
             inject_into_file "config/routes.rb", :after => "#{js_application_name}::Application.routes.draw do\n"  do
               route_catchall
             end
+
+            inject_into_file "config/application.rb", :after => "class Application < Rails::Application\n" do
+              precompile_app
+            end
           end
 
         end
@@ -72,6 +76,12 @@ module Batman
 CODE
       end
 
+      def precompile_app
+<<-CODE
+\n    config.assets.precompile += ['#{application_name}.js']\n
+CODE
+      end
+
       def es5_requires
 <<-CODE
 #= require batman/es5-shim\n

data/lib/generators/common.rb

@@ -51,7 +51,7 @@ module Batman
       module ClassMethods
         def requires_app_name
           class_option :app_name, :type => :string, :optional => true,
-                       :desc => "Name of the Batman app (defaults to the Rails app name"
+                       :desc => "Name of the Batman app (defaults to the Rails app name)"
         end
       end
     end

data/lib/templates/rails/controller.rb

@@ -1,7 +1,13 @@
 class <%= js_app_name %>Controller < ApplicationController
 
   def index
-    render nothing: true, layout: '<%= app_name %>'
+    if request.xhr?
+      prefix_length = Rails.application.config.assets.prefix.length + 1
+      path = request.path[prefix_length..-1]
+      render :text => Rails.application.assets[path]
+    else
+      render nothing: true, layout: '<%= app_name %>'
+    end
   end
 
 end

data/test/define_view_helper_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+require 'generators/batman/view_generator'
+
+class DefineViewHelperTest < ActionView::TestCase
+  include Batman::DefineViewHelper
+  tests Batman::DefineViewHelper
+
+  test "it defaults to looking in app/assets/batman/html" do
+    File.expects(:join).with("app/assets/batman/html/", "**/*").returns("app/assets/batman/html/**/*")
+    batman_define_views
+  end
+
+  test "it can be given override path" do
+    File.expects(:join).with("app/assets/batman/templates/", "**/*").returns("app/assets/batman/templates/**/*")
+    batman_define_views(path_to_html: "app/assets/batman/templates")
+  end
+
+end

data/vendor/assets/javascripts/batman/batman.i18n.js

@@ -0,0 +1,140 @@
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Batman.I18N = (function(_super) {
+    __extends(I18N, _super);
+
+    I18N.defaultLocale = "en";
+
+    I18N.useFallback = false;
+
+    I18N.classAccessor('locale', {
+      get: function() {
+        return this.locale || this.get('defaultLocale');
+      },
+      set: function(k, v) {
+        return this.locale = v;
+      },
+      unset: function() {
+        var x;
+        x = this.locale;
+        delete this.locale;
+        return x;
+      }
+    });
+
+    I18N.classAccessor('translations', function() {
+      return this.get("locales." + (this.get('locale')));
+    });
+
+    I18N.classAccessor('defaultTranslations', function() {
+      return this.get("locales." + this.defaultLocale);
+    });
+
+    I18N.translate = function(key, values) {
+      var translation;
+      translation = this.get("translations." + key);
+      if (this.useFallback) {
+        translation || (translation = this.get("defaultTranslations." + key));
+      }
+      if (translation == null) {
+        Batman.developer.warn("Warning, undefined translation " + key + " when in locale " + (this.get('locale')));
+        return "";
+      }
+      if (!values) {
+        return translation;
+      }
+      return Batman.helpers.interpolate(translation, values);
+    };
+
+    I18N.enable = function() {
+      var _this = this;
+      this._oldTranslation = Batman.translate;
+      this.locales.set('en', Batman.translate.messages);
+      return Batman.translate = function() {
+        return _this.translate.apply(_this, arguments);
+      };
+    };
+
+    I18N.disable = function() {
+      return Batman.translate = this._oldTranslation;
+    };
+
+    function I18N() {
+      Batman.developer.error("Can't instantiate i18n!");
+    }
+
+    return I18N;
+
+  })(Batman.Object);
+
+  Batman.I18N.LocalesStorage = (function(_super) {
+    __extends(LocalesStorage, _super);
+
+    function LocalesStorage() {
+      this.isStorage = true;
+      this._storage = {};
+      LocalesStorage.__super__.constructor.apply(this, arguments);
+    }
+
+    LocalesStorage.accessor({
+      get: function(k) {
+        var _this = this;
+        if (!this._storage[k]) {
+          this._storage[k] = {};
+          new Batman.Request({
+            url: "/locales/" + k + ".json",
+            success: function(data) {
+              return _this.set(k, data[k]);
+            },
+            error: function(xhr) {
+              throw new Error("Couldn't load locale file " + k + "!");
+            }
+          });
+        }
+        return this._storage[k];
+      },
+      set: function(k, v) {
+        return this._storage[k] = v;
+      },
+      unset: function(k) {
+        var x;
+        x = this._storage[k];
+        delete this._storage[k];
+        return x;
+      }
+    });
+
+    return LocalesStorage;
+
+  })(Batman.Object);
+
+  Batman.I18N.set('locales', new Batman.I18N.LocalesStorage);
+
+  Batman.Filters.t = Batman.Filters.translate = function(string, interpolationKeypaths, binding) {
+    var translated;
+    if (!binding) {
+      binding = interpolationKeypaths;
+      interpolationKeypaths = void 0;
+    }
+    if (string == null) {
+      return "";
+    }
+    if (!(binding.key && binding.key.substr(0, 2) === "t.")) {
+      translated = Batman.I18N.translate(string);
+      if (translated) {
+        string = translated;
+      }
+    }
+    return Batman.Filters.interpolate.call(this, string, interpolationKeypaths, binding);
+  };
+
+  Batman.config.translations = true;
+
+}).call(this);
+
+(function() {
+
+
+}).call(this);

data/vendor/assets/javascripts/batman/batman.js

@@ -12,7 +12,7 @@
     })(Batman.Object, mixins, function(){});
   };
 
-  Batman.version = '0.14.1';
+  Batman.version = '0.16.0';
 
   Batman.config = {
     pathToApp: '/',
@@ -433,6 +433,7 @@
     "<": "&lt;",
     ">": "&gt;",
     "\"": "&#34;",
+    "/": "&#47;",
     "'": "&#39;"
   };
 
@@ -624,11 +625,11 @@
 }).call(this);
 
 (function() {
-  var Inflector, camelize_rx, capitalize_rx, humanize_rx1, humanize_rx2, humanize_rx3, underscore_rx1, underscore_rx2;
+  var Inflector, camelize_rx, humanize_rx1, humanize_rx2, humanize_rx3, titleize_rx, underscore_rx1, underscore_rx2;
 
   camelize_rx = /(?:^|_|\-)(.)/g;
 
-  capitalize_rx = /(^|\s)([a-z])/g;
+  titleize_rx = /(^|\s)([a-z])/g;
 
   underscore_rx1 = /([A-Z]+)([A-Z][a-z])/g;
 
@@ -636,7 +637,7 @@
 
   humanize_rx1 = /_id$/;
 
-  humanize_rx2 = /_|-/g;
+  humanize_rx2 = /_|-|\./g;
 
   humanize_rx3 = /^\w/g;
 
@@ -675,11 +676,15 @@
     underscore: function(string) {
       return string.replace(underscore_rx1, '$1_$2').replace(underscore_rx2, '$1_$2').replace('-', '_').toLowerCase();
     },
-    capitalize: function(string) {
-      return string.replace(capitalize_rx, function(m, p1, p2) {
+    titleize: function(string) {
+      return string.replace(titleize_rx, function(m, p1, p2) {
         return p1 + p2.toUpperCase();
       });
     },
+    capitalize: function(string) {
+      Batman.developer.deprecated('capitalize', 'Renamed to titleize.');
+      return Batman.helpers.titleize(string);
+    },
     trim: function(string) {
       if (string) {
         return string.trim();
@@ -709,6 +714,17 @@
       return string.replace(humanize_rx1, '').replace(humanize_rx2, ' ').replace(humanize_rx3, function(match) {
         return match.toUpperCase();
       });
+    },
+    toSentence: function(array) {
+      var itemString, last;
+      if (array.length < 3) {
+        return array.join(' and ');
+      } else {
+        last = array.pop();
+        itemString = array.join(', ');
+        itemString += ", and " + last;
+        return itemString;
+      }
     }
   };
 
@@ -1050,7 +1066,7 @@
     };
 
     Event.prototype.allowAndFire = function() {
-      return this.allowAndFireWithContext(this.handlerContext, arguments);
+      return this.allowAndFireWithContext(this.handlerContext(), arguments);
     };
 
     Event.prototype.allowAndFireWithContext = function(context, args) {
@@ -1298,7 +1314,7 @@
       }
       result = true;
       this.forEach(function() {
-        return result = result && f.apply(ctx, arguments);
+        return result = result && !!f.apply(ctx, arguments);
       });
       return result;
     },
@@ -1309,7 +1325,7 @@
       }
       result = false;
       this.forEach(function() {
-        return result = result || f.apply(ctx, arguments);
+        return result = result || !!f.apply(ctx, arguments);
       });
       return result;
     },
@@ -1690,7 +1706,24 @@
       return obj;
     };
 
-    SimpleHash.prototype.toJSON = SimpleHash.prototype.toObject;
+    SimpleHash.prototype.toJSON = function() {
+      var key, obj, objectKey, value, values, _ref, _ref1, _ref2;
+      obj = {};
+      _ref = this._storage;
+      for (key in _ref) {
+        value = _ref[key];
+        obj[this.unprefixedKey(key)] = (value != null ? typeof value.toJSON === "function" ? value.toJSON() : void 0 : void 0) || value;
+      }
+      if (this._objectStorage) {
+        _ref1 = this._objectStorage;
+        for (key in _ref1) {
+          values = _ref1[key];
+          _ref2 = values[0], objectKey = _ref2[0], value = _ref2[1];
+          obj[key] = (value != null ? typeof value.toJSON === "function" ? value.toJSON() : void 0 : void 0) || value;
+        }
+      }
+      return obj;
+    };
 
     return SimpleHash;
 
@@ -1732,6 +1765,14 @@
       return this.get(label);
     };
 
+    AssociationCurator.prototype.getAll = function() {
+      var allAssociations, typeSets, _ref;
+      typeSets = this._byTypeStorage.map(function(label, typeSet) {
+        return typeSet;
+      });
+      return allAssociations = (_ref = new Batman.SimpleSet).merge.apply(_ref, typeSets);
+    };
+
     AssociationCurator.prototype.reset = function() {
       this.forEach(function(label, association) {
         return association.reset();
@@ -1921,6 +1962,14 @@
       return merged;
     };
 
+    SimpleSet.prototype.mappedTo = function(key) {
+      var _this = this;
+      this._mappings || (this._mappings = new Batman.SimpleHash);
+      return this._mappings.getOrSet(key, function() {
+        return new Batman.SetMapping(_this, key);
+      });
+    };
+
     SimpleSet.prototype.indexedBy = function(key) {
       this._indexes || (this._indexes = new Batman.SimpleHash);
       return this._indexes.get(key) || this._indexes.set(key, new Batman.SetIndex(this, key));
@@ -2100,6 +2149,8 @@
 
     Property.prototype.isDead = false;
 
+    Property.prototype.isBatchingChanges = false;
+
     Property.prototype.registerAsMutableSource = function() {
       return Batman.Property.registerSource(this);
     };
@@ -2241,7 +2292,9 @@
 
     Property.prototype.sourceChangeHandler = function() {
       var _this = this;
-      this._sourceChangeHandler || (this._sourceChangeHandler = this._handleSourceChange.bind(this));
+      this._sourceChangeHandler || (this._sourceChangeHandler = function() {
+        return _this._handleSourceChange();
+      });
       Batman.developer["do"](function() {
         return _this._sourceChangeHandler.property = _this;
       });
@@ -2256,7 +2309,7 @@
       } else if (!this.isFinal() && !this.hasObservers()) {
         this.cached = false;
         return this._removeHandlers();
-      } else {
+      } else if (!this.isBatchingChanges) {
         return this.refresh();
       }
     };
@@ -2750,6 +2803,10 @@
       definition.invert = true;
       return new Batman.DOM.InsertionBinding(definition);
     },
+    deferif: function(definition) {
+      definition.invert = true;
+      return new Batman.DOM.DeferredRenderBinding(definition);
+    },
     renderif: function(definition) {
       return new Batman.DOM.DeferredRenderBinding(definition);
     },
@@ -2827,9 +2884,9 @@
     __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
 
   Batman.DOM.events = {
-    click: function(node, callback, view, eventName, preventDefault) {
+    primaryInteractionEvent: function(node, callback, view, eventName, preventDefault) {
       if (eventName == null) {
-        eventName = 'click';
+        eventName = Batman.DOM.primaryInteractionEventName;
       }
       if (preventDefault == null) {
         preventDefault = true;
@@ -2853,6 +2910,15 @@
       }
       return node;
     },
+    click: function(node, callback, view, eventName, preventDefault) {
+      if (eventName == null) {
+        eventName = 'click';
+      }
+      if (preventDefault == null) {
+        preventDefault = true;
+      }
+      return Batman.DOM.events.primaryInteractionEvent(node, callback, view, eventName, preventDefault);
+    },
     doubleclick: function(node, callback, view) {
       return Batman.DOM.events.click(node, callback, view, 'dblclick');
     },
@@ -2943,6 +3009,8 @@
     return true;
   };
 
+  Batman.DOM.primaryInteractionEventName = 'click';
+
 }).call(this);
 
 (function() {
@@ -3001,6 +3069,13 @@
     event: function(definition) {
       return new Batman.DOM.EventBinding(definition);
     },
+    track: function(definition) {
+      if (definition.attr === 'view') {
+        return new Batman.DOM.ViewTrackingBinding(definition);
+      } else if (definition.attr === 'click') {
+        return new Batman.DOM.ClickTrackingBinding(definition);
+      }
+    },
     addclass: function(definition) {
       return new Batman.DOM.AddClassBinding(definition);
     },
@@ -3211,6 +3286,62 @@
       return this._batmanID();
     });
 
+    BatmanObject.delegate = function() {
+      var options, properties, _i,
+        _this = this;
+      properties = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), options = arguments[_i++];
+      if (options == null) {
+        options = {};
+      }
+      if (!options.to) {
+        Batman.developer.warn('delegate must include to option', this, properties);
+      }
+      return properties.forEach(function(property) {
+        return _this.accessor(property, {
+          get: function() {
+            var _ref;
+            return (_ref = this.get(options.to)) != null ? _ref.get(property) : void 0;
+          },
+          set: function(key, value) {
+            var _ref;
+            return (_ref = this.get(options.to)) != null ? _ref.set(property, value) : void 0;
+          },
+          unset: function() {
+            var _ref;
+            return (_ref = this.get(options.to)) != null ? _ref.unset(property) : void 0;
+          }
+        });
+      });
+    };
+
+    BatmanObject.classDelegate = function() {
+      var options, properties, _i,
+        _this = this;
+      properties = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), options = arguments[_i++];
+      if (options == null) {
+        options = {};
+      }
+      if (!options.to) {
+        Batman.developer.warn('delegate must include to option', this, properties);
+      }
+      return properties.forEach(function(property) {
+        return _this.classAccessor(property, {
+          get: function() {
+            var _ref;
+            return (_ref = this.get(options.to)) != null ? _ref.get(property) : void 0;
+          },
+          set: function(key, value) {
+            var _ref;
+            return (_ref = this.get(options.to)) != null ? _ref.set(property, value) : void 0;
+          },
+          unset: function() {
+            var _ref;
+            return (_ref = this.get(options.to)) != null ? _ref.unset(property) : void 0;
+          }
+        });
+      });
+    };
+
     function BatmanObject() {
       var mixins;
       mixins = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
@@ -3250,6 +3381,23 @@
       return obj;
     };
 
+    BatmanObject.prototype.batchAccessorChanges = function() {
+      var i, key, properties, property, result, wrappedFunction, _i, _j, _k, _len, _len1;
+      properties = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), wrappedFunction = arguments[_i++];
+      for (i = _j = 0, _len = properties.length; _j < _len; i = ++_j) {
+        key = properties[i];
+        property = properties[i] = this.property(key);
+        property.isBatchingChanges = true;
+      }
+      result = wrappedFunction.call(this);
+      for (_k = 0, _len1 = properties.length; _k < _len1; _k++) {
+        property = properties[_k];
+        property.isBatchingChanges = false;
+        property.refresh();
+      }
+      return result;
+    };
+
     return BatmanObject;
 
   })(Object);
@@ -3274,7 +3422,7 @@
       this.parseTree(this.node);
     }
 
-    bindingSortOrder = ["defineview", "foreach", "renderif", "view", "formfor", "context", "bind", "source", "target"];
+    bindingSortOrder = ["defineview", "foreach", "renderif", "view", "formfor", "context", "bind", "source", "target", "track", "event"];
 
     viewBackedBindings = ["foreach", "renderif", "formfor", "context"];
 
@@ -3407,7 +3555,7 @@
         });
       } else {
         return Batman.t('errors.format', {
-          attribute: Batman.helpers.humanize(this.attribute),
+          attribute: Batman.helpers.humanize(Batman.ValidationError.singularizeAssociated(this.attribute)),
           message: this.message
         });
       }
@@ -3420,6 +3568,15 @@
       });
     }
 
+    ValidationError.singularizeAssociated = function(attribute) {
+      var i, parts, _i, _ref;
+      parts = attribute.split(".");
+      for (i = _i = 0, _ref = parts.length - 1; _i < _ref; i = _i += 1) {
+        parts[i] = Batman.helpers.singularize(parts[i]);
+      }
+      return parts.join(" ");
+    };
+
     return ValidationError;
 
   })(Batman.Object);
@@ -3474,6 +3631,19 @@
 
     })(StorageAdapter.StorageError);
 
+    StorageAdapter.UnauthorizedError = (function(_super1) {
+      __extends(UnauthorizedError, _super1);
+
+      UnauthorizedError.prototype.name = 'UnauthorizedError';
+
+      function UnauthorizedError(message) {
+        UnauthorizedError.__super__.constructor.call(this, message || "Storage operation denied due to invalid credentials!");
+      }
+
+      return UnauthorizedError;
+
+    })(StorageAdapter.StorageError);
+
     StorageAdapter.NotAllowedError = (function(_super1) {
       __extends(NotAllowedError, _super1);
 
@@ -3500,6 +3670,19 @@
 
     })(StorageAdapter.StorageError);
 
+    StorageAdapter.EntityTooLargeError = (function(_super1) {
+      __extends(EntityTooLargeError, _super1);
+
+      EntityTooLargeError.prototype.name = "EntityTooLargeError";
+
+      function EntityTooLargeError(message) {
+        EntityTooLargeError.__super__.constructor.call(this, message || "Storage operation denied due to size constraints!");
+      }
+
+      return EntityTooLargeError;
+
+    })(StorageAdapter.StorageError);
+
     StorageAdapter.UnprocessableRecordError = (function(_super1) {
       __extends(UnprocessableRecordError, _super1);
 
@@ -3539,6 +3722,19 @@
 
     })(StorageAdapter.StorageError);
 
+    StorageAdapter.BadGatewayError = (function(_super1) {
+      __extends(BadGatewayError, _super1);
+
+      BadGatewayError.prototype.name = "BadGatewayError";
+
+      function BadGatewayError(message) {
+        BadGatewayError.__super__.constructor.call(this, message || "Storage operation failed due to unavailability of the backend!");
+      }
+
+      return BadGatewayError;
+
+    })(StorageAdapter.StorageError);
+
     function StorageAdapter(model) {
       var constructor;
       StorageAdapter.__super__.constructor.call(this, {
@@ -3555,6 +3751,25 @@
 
     StorageAdapter.prototype.isStorageAdapter = true;
 
+    StorageAdapter.prototype.onlyCertainAttributes = function(json, only) {
+      var key;
+      for (key in json) {
+        if (only.indexOf(key) < 0) {
+          delete json[key];
+        }
+      }
+      return json;
+    };
+
+    StorageAdapter.prototype.exceptCertainAttributes = function(json, except) {
+      var key, _i, _len;
+      for (_i = 0, _len = except.length; _i < _len; _i++) {
+        key = except[_i];
+        delete json[key];
+      }
+      return json;
+    };
+
     StorageAdapter.prototype.storageKey = function(record) {
       var model;
       model = (record != null ? record.constructor : void 0) || this.model;
@@ -3565,14 +3780,14 @@
       if (constructor == null) {
         constructor = this.model;
       }
-      return constructor._makeOrFindRecordFromData(attributes);
+      return constructor.createFromJSON(attributes);
     };
 
     StorageAdapter.prototype.getRecordsFromData = function(attributeSet, constructor) {
       if (constructor == null) {
         constructor = this.model;
       }
-      return constructor._makeOrFindRecordsFromData(attributeSet);
+      return constructor.createMultipleFromJSON(attributeSet);
     };
 
     StorageAdapter.skipIfError = function(f) {
@@ -3744,7 +3959,7 @@
         }
         this.url = function(options) {
           var childSegment, parentID, plural;
-          childSegment = Batman.helpers.pluralize(this.get('resourceName').toLowerCase());
+          childSegment = this.storageKey || Batman.helpers.pluralize(this.get('resourceName').toLowerCase());
           for (key in parents) {
             plural = parents[key];
             parentID = options.data[key];
@@ -3757,7 +3972,7 @@
         };
         return this.prototype.url = function() {
           var childSegment, id, parentID, plural, url;
-          childSegment = Batman.helpers.pluralize(this.constructor.get('resourceName').toLowerCase());
+          childSegment = this.constructor.storageKey || Batman.helpers.pluralize(this.constructor.get('resourceName').toLowerCase());
           for (key in parents) {
             plural = parents[key];
             parentID = this.get('dirtyKeys').get(key);
@@ -3916,6 +4131,12 @@
     RestStorage.prototype.before('create', 'update', RestStorage.skipIfError(function(env, next) {
       var data, json, namespace;
       json = env.subject.toJSON();
+      if (env.options.only) {
+        json = this.onlyCertainAttributes(json, env.options.only);
+      }
+      if (env.options.except) {
+        json = this.exceptCertainAttributes(json, env.options.except);
+      }
       if (namespace = this.recordJsonNamespace(env.subject)) {
         data = {};
         data[namespace] = json;
@@ -4033,13 +4254,16 @@
 
     RestStorage._statusCodeErrors = {
       '0': RestStorage.CommunicationError,
+      '401': RestStorage.UnauthorizedError,
       '403': RestStorage.NotAllowedError,
       '404': RestStorage.NotFoundError,
       '406': RestStorage.NotAcceptableError,
       '409': RestStorage.RecordExistsError,
+      '413': RestStorage.EntityTooLargeError,
       '422': RestStorage.UnprocessableRecordError,
       '500': RestStorage.InternalStorageError,
-      '501': RestStorage.NotImplementedError
+      '501': RestStorage.NotImplementedError,
+      '502': RestStorage.BadGatewayError
     };
 
     RestStorage.prototype._errorFor = function(error, env) {
@@ -4151,7 +4375,15 @@
     }));
 
     LocalStorage.prototype.before('create', 'update', LocalStorage.skipIfError(function(env, next) {
-      env.recordAttributes = JSON.stringify(env.subject);
+      var json;
+      json = env.subject.toJSON();
+      if (env.options.only) {
+        json = this.onlyCertainAttributes(json, env.options.only);
+      }
+      if (env.options.except) {
+        json = this.exceptCertainAttributes(json, env.options.except);
+      }
+      env.recordAttributes = JSON.stringify(json);
       return next();
     }));
 
@@ -4516,7 +4748,7 @@
           return {
             controller: resourceNameFromModel(argument.constructor),
             action: 'show',
-            id: argument.get('id')
+            id: (typeof argument.toParam === "function" ? argument.toParam() : void 0) || argument.get('id')
           };
         } else {
           return {};
@@ -4542,7 +4774,7 @@
       ControllerDirectory.accessor('__app', Batman.Property.defaultAccessor);
 
       ControllerDirectory.accessor(function(key) {
-        return this.get("__app." + (Batman.helpers.capitalize(key)) + "Controller.sharedController");
+        return this.get("__app." + (Batman.helpers.titleize(key)) + "Controller.sharedController");
       });
 
       return ControllerDirectory;
@@ -4689,7 +4921,9 @@
       for (index = _i = 0, _len = matches.length; _i < _len; index = ++_i) {
         match = matches[index];
         name = namedArguments[index];
-        params[name] = match;
+        if (match != null) {
+          params[name] = decodeURIComponent(match);
+        }
       }
       return Batman.extend(params, uri.queryParams);
     };
@@ -4791,9 +5025,13 @@
 
     function ControllerActionRoute(templatePath, options) {
       this.callback = __bind(this.callback, this);
-      var action, controller, _ref;
+      var action, controller, _ref, _ref1;
       if (options.signature) {
-        _ref = options.signature.split('#'), controller = _ref[0], action = _ref[1];
+        if (Batman.typeOf(options.signature) === 'String') {
+          _ref = options.signature.split('#'), controller = _ref[0], action = _ref[1];
+        } else {
+          _ref1 = options.signature, controller = _ref1.controller, action = _ref1.action;
+        }
         action || (action = 'index');
         options.controller = controller;
         options.action = action;
@@ -5279,6 +5517,9 @@
               _results = [];
               for (_i = 0, _len = value.length; _i < _len; _i++) {
                 handler = value[_i];
+                if (typeof handler === 'string') {
+                  handler = _this[handler];
+                }
                 _results.push(handler.call(_this, error));
               }
               return _results;
@@ -5379,16 +5620,14 @@
         }
       } else {
         if (Batman.typeOf(url) === 'Object') {
-          if (!url.controller) {
-            url.controller = this;
-          }
+          url.controller || (url.controller = this.get('routingKey'));
         }
         return Batman.redirect(url);
       }
     };
 
     Controller.prototype.render = function(options) {
-      var action, frame, view, yieldContentView, yieldName, _ref, _ref1, _ref2, _ref3;
+      var action, frame, view, yieldContentView, yieldName, _ref, _ref1, _ref2, _ref3, _ref4;
       if (options == null) {
         options = {};
       }
@@ -5404,7 +5643,7 @@
         options.view = null;
       } else {
         options.viewClass || (options.viewClass = this._viewClassForAction(action));
-        options.source || (options.source = Batman.helpers.underscore(this.get('routingKey') + '/' + action));
+        options.source || (options.source = ((_ref1 = options.viewClass) != null ? _ref1.prototype.source : void 0) || Batman.helpers.underscore(this.get('routingKey') + '/' + action));
         view = this.renderCache.viewForOptions(options);
       }
       if (view) {
@@ -5421,10 +5660,10 @@
           view.set('contentFor', yieldName);
         }
         view.set('controller', this);
-        if ((_ref1 = Batman.currentApp) != null) {
-          if ((_ref2 = _ref1.layout) != null) {
-            if ((_ref3 = _ref2.subviews) != null) {
-              _ref3.add(view);
+        if ((_ref2 = Batman.currentApp) != null) {
+          if ((_ref3 = _ref2.layout) != null) {
+            if ((_ref4 = _ref3.subviews) != null) {
+              _ref4.add(view);
             }
           }
         }
@@ -5526,7 +5765,7 @@
 
     Set._applySetAccessors(Set);
 
-    _ref = ['indexedBy', 'indexedByUnique', 'sortedBy', 'equality', '_indexOfItem'];
+    _ref = ['indexedBy', 'indexedByUnique', 'sortedBy', 'equality', '_indexOfItem', 'mappedTo'];
     for (_i = 0, _len = _ref.length; _i < _len; _i++) {
       k = _ref[_i];
       Set.prototype[k] = Batman.SimpleSet.prototype[k];
@@ -5544,7 +5783,11 @@
       _fn(k);
     }
 
-    Set.prototype.toJSON = Set.prototype.toArray;
+    Set.prototype.toJSON = function() {
+      return this.map(function(value) {
+        return (typeof value.toJSON === "function" ? value.toJSON() : void 0) || value;
+      });
+    };
 
     Set.prototype.add = Set.mutation(function() {
       var addedItems;
@@ -6005,7 +6248,7 @@
       predicateKeys = [];
       definePredicate = function(state) {
         var key;
-        key = "is" + (Batman.helpers.capitalize(state));
+        key = "is" + (Batman.helpers.titleize(state));
         if (_this.prototype[key] != null) {
           return;
         }
@@ -6259,7 +6502,9 @@
           if ((matches = validatorClass.matches(optionsOrFunction))) {
             validators.push({
               keys: keys,
-              validator: new validatorClass(matches)
+              validator: new validatorClass(matches),
+              "if": optionsOrFunction["if"],
+              unless: optionsOrFunction.unless
             });
           }
         }
@@ -6333,16 +6578,25 @@
     };
 
     Model.findWithOptions = function(id, options, callback) {
-      var record;
+      var record,
+        _this = this;
       if (options == null) {
         options = {};
       }
       Batman.developer.assert(callback, "Must call find with a callback!");
-      record = new this;
-      record._withoutDirtyTracking(function() {
-        return this.set('id', id);
+      this._pending || (this._pending = {});
+      record = this._loadIdentity(id) || this._pending[id];
+      if (record == null) {
+        record = new this;
+        record._withoutDirtyTracking(function() {
+          return this.set('id', id);
+        });
+        this._pending[id] = record;
+      }
+      record.loadWithOptions(options, function() {
+        delete _this._pending[id];
+        return callback.apply(_this, arguments);
       });
-      record.loadWithOptions(options, callback);
       return record;
     };
 
@@ -6400,6 +6654,10 @@
       return this._makeOrFindRecordFromData(json);
     };
 
+    Model.createMultipleFromJSON = function(array) {
+      return this._makeOrFindRecordsFromData(array);
+    };
+
     Model._loadIdentity = function(id) {
       return this.get('loaded.indexedByUnique.id').get(id);
     };
@@ -6625,10 +6883,7 @@
           }
         },
         set: function(key, value) {
-          var parsedValue, primaryKey;
-          if ((typeof value === "string") && (value.match(/[^0-9]/) === null) && (("" + (parsedValue = parseInt(value, 10))) === value)) {
-            value = parsedValue;
-          }
+          var primaryKey;
           primaryKey = this.constructor.primaryKey;
           if (primaryKey === 'id') {
             this._willSet(key);
@@ -6664,22 +6919,20 @@
     Model.prototype.toJSON = function() {
       var encoders, obj,
         _this = this;
-      obj = {};
       encoders = this._batman.get('encoders');
-      if (!(!encoders || encoders.isEmpty())) {
-        encoders.forEach(function(key, encoder) {
-          var encodedVal, val;
-          if (encoder.encode) {
-            val = _this.get(key);
-            if (typeof val !== 'undefined') {
-              encodedVal = encoder.encode(val, key, obj, _this);
-              if (typeof encodedVal !== 'undefined') {
-                return obj[encoder.as] = encodedVal;
-              }
-            }
-          }
-        });
+      if (!encoders || encoders.isEmpty()) {
+        return {};
       }
+      obj = {};
+      encoders.forEach(function(key, encoder) {
+        var encodedVal, val, _ref2;
+        if (!encoder.encode || (val = _this.get(key)) === void 0) {
+          return;
+        }
+        if ((encodedVal = encoder.encode(val, key, obj, _this)) !== void 0) {
+          return obj[(_ref2 = typeof encoder.as === "function" ? encoder.as(key, val, obj, _this) : void 0) != null ? _ref2 : encoder.as] = encodedVal;
+        }
+      });
       return obj;
     };
 
@@ -6697,9 +6950,16 @@
         }
       } else {
         encoders.forEach(function(key, encoder) {
-          if (encoder.decode && typeof data[encoder.as] !== 'undefined') {
-            return obj[key] = encoder.decode(data[encoder.as], encoder.as, data, obj, _this);
+          var as, _ref2;
+          if (!encoder.decode) {
+            return;
+          }
+          as = (_ref2 = typeof encoder.as === "function" ? encoder.as(key, data[key], obj, _this) : void 0) != null ? _ref2 : encoder.as;
+          value = data[as];
+          if (value === void 0 || (value === null && (_this._associationForAttribute(as) != null))) {
+            return;
           }
+          return obj[key] = encoder.decode(value, as, data, obj, _this);
         });
       }
       if (this.constructor.primaryKey !== 'id') {
@@ -6785,11 +7045,12 @@
       _ref3 = isNew ? ['create', 'create', 'created'] : ['save', 'update', 'saved'], startState = _ref3[0], storageOperation = _ref3[1], endState = _ref3[2];
       if (this.get('lifecycle').startTransition(startState)) {
         return this.validate(function(error, errors) {
-          var associations;
+          var associations, payload;
           if (error || errors.length) {
             _this.get('lifecycle').failedValidation();
             return typeof callback === "function" ? callback(error || errors, _this) : void 0;
           }
+          _this.fire('validated');
           associations = _this.constructor._batman.get('associations');
           _this._withoutDirtyTracking(function() {
             var _ref4,
@@ -6798,9 +7059,10 @@
               return association.apply(_this);
             }) : void 0 : void 0;
           });
-          return _this._doStorageOperation(storageOperation, {
+          payload = Batman.extend({}, options, {
             data: options
-          }, function(err, record, env) {
+          });
+          return _this._doStorageOperation(storageOperation, payload, function(err, record, env) {
             if (!err) {
               _this.get('dirtyKeys').clear();
               _this.get('_dirtiedKeys').clear();
@@ -6858,7 +7120,7 @@
     };
 
     Model.prototype.validate = function(callback) {
-      var args, count, e, errors, finishedValidation, key, validator, validators, _j, _k, _len1, _len2, _ref2;
+      var args, condition, count, e, errors, finishedValidation, key, validator, validators, _j, _k, _len1, _len2, _ref2;
       errors = this.get('errors');
       errors.clear();
       validators = this._batman.get('validators') || [];
@@ -6878,6 +7140,20 @@
       };
       for (_j = 0, _len1 = validators.length; _j < _len1; _j++) {
         validator = validators[_j];
+        if (validator["if"]) {
+          condition = typeof validator["if"] === 'string' ? this.get(validator["if"]) : validator["if"].call(this, errors, this, key);
+          if (!condition) {
+            finishedValidation();
+            continue;
+          }
+        }
+        if (validator.unless) {
+          condition = typeof validator.unless === 'string' ? this.get(validator.unless) : validator.unless.call(this, errors, this, key);
+          if (condition) {
+            finishedValidation();
+            continue;
+          }
+        }
         _ref2 = validator.keys;
         for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
           key = _ref2[_k];
@@ -6921,6 +7197,11 @@
       }
     };
 
+    Model.prototype._associationForAttribute = function(attribute) {
+      var _ref2;
+      return (_ref2 = this.constructor._batman.get('associations')) != null ? _ref2.get(attribute) : void 0;
+    };
+
     Model.prototype._doStorageOperation = function(operation, options, callback) {
       var adapter,
         _this = this;
@@ -6948,6 +7229,74 @@
       Model.prototype[functionName] = Batman.Property.wrapTrackingPrevention(Model.prototype[functionName]);
     }
 
+    Model.prototype.reflectOnAllAssociations = function(associationType) {
+      var associations;
+      associations = this.constructor._batman.get('associations');
+      if (associationType != null) {
+        return associations != null ? associations.getByType(associationType) : void 0;
+      } else {
+        return associations != null ? associations.getAll() : void 0;
+      }
+    };
+
+    Model.prototype.reflectOnAssociation = function(associationLabel) {
+      var _ref3;
+      return (_ref3 = this.constructor._batman.get('associations')) != null ? _ref3.getByLabel(associationLabel) : void 0;
+    };
+
+    Model.prototype.transaction = function() {
+      return this._transaction([], []);
+    };
+
+    Model.prototype._transaction = function(visited, stack) {
+      var attributes, hasManys, index, key, label, newValues, transaction, value, _k, _len2, _ref3, _ref4;
+      index = visited.indexOf(this);
+      if (index !== -1) {
+        return stack[index];
+      }
+      visited.push(this);
+      stack.push(transaction = new this.constructor);
+      if (hasManys = this.reflectOnAllAssociations('hasMany')) {
+        hasManys = hasManys.filter(function(association) {
+          return association.options.includeInTransaction;
+        });
+        _ref3 = hasManys.mapToProperty('label');
+        for (_k = 0, _len2 = _ref3.length; _k < _len2; _k++) {
+          label = _ref3[_k];
+          this.get(label);
+        }
+      }
+      attributes = this.get('attributes').toObject();
+      for (key in attributes) {
+        if (!__hasProp.call(attributes, key)) continue;
+        value = attributes[key];
+        if (value instanceof Batman.Model && !value.isTransaction) {
+          attributes[key] = value._transaction(visited, stack);
+        } else if (value instanceof Batman.AssociationSet && !value.isTransaction) {
+          newValues = new Batman.TransactionAssociationSet(value, visited, stack);
+          attributes[key] = newValues;
+        } else if (Batman.typeOf(value) === 'Object') {
+          Batman.developer.warn("You're passing a mutable object (" + key + ", " + value.constructor.name + ") in a " + this.constructor.name + " transaction:", value);
+        }
+      }
+      transaction._withoutDirtyTracking(function() {
+        return transaction.updateAttributes(attributes);
+      });
+      transaction._batman.base = this;
+      _ref4 = Batman.Transaction;
+      for (key in _ref4) {
+        value = _ref4[key];
+        transaction[key] = value;
+      }
+      transaction.accessor('isTransaction', function() {
+        return this.isTransaction;
+      });
+      transaction.accessor('base', function() {
+        return this.base();
+      });
+      return transaction;
+    };
+
     return Model;
 
   }).call(this, Batman.Object);
@@ -6964,7 +7313,7 @@
       var collection, _base;
       Batman.initializeObject(this);
       collection = (_base = this._batman).associations || (_base.associations = new Batman.AssociationCurator(this));
-      return collection.add(new Batman["" + (Batman.helpers.capitalize(k)) + "Association"](this, label, scope));
+      return collection.add(new Batman["" + (Batman.helpers.titleize(k)) + "Association"](this, label, scope));
     };
   };
   for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -7131,11 +7480,8 @@
         loadOptions.urlContext = this.model;
       }
       return this.association.getRelatedModel().loadWithOptions(loadOptions, function(error, loadedRecords) {
-        if (error) {
-          throw error;
-        }
         if (!loadedRecords || loadedRecords.length <= 0) {
-          return callback(new Error("Couldn't find related record!"), void 0);
+          return callback(error || new Error("Couldn't find related record!"), void 0);
         } else {
           return callback(void 0, loadedRecords[0]);
         }
@@ -7170,18 +7516,12 @@
     };
 
     BelongsToProxy.prototype.fetchFromRemote = function(callback) {
-      var loadOptions,
-        _this = this;
+      var loadOptions;
       loadOptions = {};
       if (this.association.options.url) {
         loadOptions.recordUrl = this.association.options.url;
       }
-      return this.association.getRelatedModel().findWithOptions(this.get('foreignValue'), loadOptions, function(error, loadedRecord) {
-        if (error) {
-          throw error;
-        }
-        return callback(void 0, loadedRecord);
-      });
+      return this.association.getRelatedModel().findWithOptions(this.get('foreignValue'), loadOptions, callback);
     };
 
     return BelongsToProxy;
@@ -7212,18 +7552,12 @@
     };
 
     PolymorphicBelongsToProxy.prototype.fetchFromRemote = function(callback) {
-      var loadOptions,
-        _this = this;
+      var loadOptions;
       loadOptions = {};
       if (this.association.options.url) {
         loadOptions.recordUrl = this.association.options.url;
       }
-      return this.association.getRelatedModelForType(this.get('foreignTypeValue')).findWithOptions(this.get('foreignValue'), loadOptions, function(error, loadedRecord) {
-        if (error) {
-          throw error;
-        }
-        return callback(void 0, loadedRecord);
-      });
+      return this.association.getRelatedModelForType(this.get('foreignTypeValue')).findWithOptions(this.get('foreignValue'), loadOptions, callback);
     };
 
     return PolymorphicBelongsToProxy;
@@ -7599,10 +7933,24 @@
       }
     }
 
-    Request.prototype.send = function() {
-      return Batman.developer.error("Please source a dependency file for a request implementation");
+    Request.prototype.send = function(data) {
+      return Batman.developer.error("You must add a platform library to implement Batman.Request (for example, batman.jquery)");
     };
 
+    Request.set('pendingRequestCount', 0);
+
+    Request.classAccessor('requestIsPending', function() {
+      return this.get('pendingRequestCount') > 0;
+    });
+
+    Request.prototype.on('loading', function() {
+      return Batman.Request.set('pendingRequestCount', Batman.Request.get('pendingRequestCount') + 1);
+    });
+
+    Request.prototype.on('loaded', function() {
+      return Batman.Request.set('pendingRequestCount', Batman.Request.get('pendingRequestCount') - 1);
+    });
+
     return Request;
 
   })(Batman.Object);
@@ -7675,7 +8023,7 @@
 
     SetObserver.prototype._manageObserversForItem = function(item, method) {
       var key, _i, _len, _ref;
-      if (item.isObservable) {
+      if (item != null ? item.isObservable : void 0) {
         _ref = this.observedItemKeys;
         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
           key = _ref[_i];
@@ -8003,16 +8351,23 @@
 
     AssociationSet.accessor('loaded', Batman.Property.defaultAccessor);
 
-    AssociationSet.prototype.load = function(callback) {
-      var _this = this;
+    AssociationSet.prototype.load = function(options, callback) {
+      var loadOptions,
+        _this = this;
+      loadOptions = this._getLoadOptions();
+      if (!callback) {
+        callback = options;
+      } else {
+        loadOptions.data = Batman.extend(loadOptions.data, options);
+      }
       if (this.foreignKeyValue == null) {
         return callback(void 0, this);
       }
-      return this.association.getRelatedModel().loadWithOptions(this._getLoadOptions(), function(err, records) {
+      return this.association.getRelatedModel().loadWithOptions(loadOptions, function(err, records, env) {
         if (!err) {
           _this.markAsLoaded();
         }
-        return callback(err, _this);
+        return callback(err, _this, env);
       });
     };
 
@@ -8034,6 +8389,35 @@
       return this.fire('loaded');
     };
 
+    AssociationSet.accessor('parentRecord', function() {
+      var parentClass, parentPrimaryKey, parentPrimaryKeyValue, query;
+      parentClass = this.get('association.model');
+      parentPrimaryKey = parentClass.get('primaryKey');
+      parentPrimaryKeyValue = this.get('foreignKeyValue');
+      query = {};
+      query[parentPrimaryKey] = parentPrimaryKeyValue;
+      return parentClass.createFromJSON(query);
+    });
+
+    AssociationSet.prototype.build = function(attrs) {
+      var associatedClass, initParams, mixedAttrs, newObj, options, scope;
+      if (attrs == null) {
+        attrs = {};
+      }
+      initParams = {};
+      initParams[this.get('association.foreignKey')] = this.get('foreignKeyValue');
+      options = this.get('association.options');
+      if (options.inverseOf != null) {
+        initParams[options.inverseOf] = this.get('parentRecord');
+      }
+      scope = options.namespace || Batman.currentApp;
+      associatedClass = scope[options.name];
+      mixedAttrs = Batman.extend(attrs, initParams);
+      newObj = new associatedClass(mixedAttrs);
+      this.add(newObj);
+      return newObj;
+    };
+
     return AssociationSet;
 
   })(Batman.SetSort);
@@ -8074,6 +8458,107 @@
 
 }).call(this);
 
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Batman.SetMapping = (function(_super) {
+    __extends(SetMapping, _super);
+
+    function SetMapping(base, key) {
+      var initialValues,
+        _this = this;
+      this.base = base;
+      this.key = key;
+      initialValues = this.base.mapToProperty(this.key);
+      this._counter = new this.constructor.PresenceCounter(initialValues);
+      SetMapping.__super__.constructor.apply(this, initialValues);
+      this._setObserver = new Batman.SetObserver(this.base);
+      this._setObserver.observedItemKeys = [this.key];
+      this._setObserver.observerForItemAndKey = function(item) {
+        return function(newValue, oldValue) {
+          return _this._handleItemModified(item, newValue, oldValue);
+        };
+      };
+      this._setObserver.on('itemsWereAdded', this._handleItemsAdded.bind(this));
+      this._setObserver.on('itemsWereRemoved', this._handleItemsRemoved.bind(this));
+      this._setObserver.startObserving();
+    }
+
+    SetMapping.prototype._handleItemsAdded = function(items, indexes) {
+      var item, _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = items.length; _i < _len; _i++) {
+        item = items[_i];
+        _results.push(this._addValueInstance(item.get(this.key)));
+      }
+      return _results;
+    };
+
+    SetMapping.prototype._handleItemsRemoved = function(items, indexes) {
+      var item, _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = items.length; _i < _len; _i++) {
+        item = items[_i];
+        _results.push(this._removeValueInstance(item.get(this.key)));
+      }
+      return _results;
+    };
+
+    SetMapping.prototype._handleItemModified = function(item, newValue, oldValue) {
+      this._removeValueInstance(oldValue);
+      return this._addValueInstance(newValue);
+    };
+
+    SetMapping.prototype._addValueInstance = function(mappedValue) {
+      this._counter.increment(mappedValue);
+      return this.add(mappedValue);
+    };
+
+    SetMapping.prototype._removeValueInstance = function(mappedValue) {
+      var remaining;
+      remaining = this._counter.decrement(mappedValue);
+      if (remaining === 0) {
+        return this.remove(mappedValue);
+      }
+    };
+
+    return SetMapping;
+
+  })(Batman.Set);
+
+  Batman.SetMapping.PresenceCounter = (function() {
+    function PresenceCounter(initialValues) {
+      var value, _i, _len;
+      this._storage = new Batman.SimpleHash;
+      for (_i = 0, _len = initialValues.length; _i < _len; _i++) {
+        value = initialValues[_i];
+        this.increment(value);
+      }
+    }
+
+    PresenceCounter.prototype.increment = function(value) {
+      var count;
+      count = this._storage.get(value);
+      if (!count) {
+        return this._storage.set(value, 1);
+      } else {
+        return this._storage.set(value, count + 1);
+      }
+    };
+
+    PresenceCounter.prototype.decrement = function(value) {
+      var count;
+      count = this._storage.get(value);
+      return this._storage.set(value, count - 1);
+    };
+
+    return PresenceCounter;
+
+  })();
+
+}).call(this);
+
 (function() {
   var __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
@@ -8944,6 +9429,9 @@
     };
 
     RouteMapBuilder.prototype.root = function(signature, options) {
+      if (options == null) {
+        options = {};
+      }
       return this.route('/', signature, options);
     };
 
@@ -9018,7 +9506,10 @@
       klass = options.callback ? Batman.CallbackActionRoute : Batman.ControllerActionRoute;
       options.app = this.app;
       route = new klass(path, options);
-      return this.routeMap.addRoute(name, route);
+      this.routeMap.addRoute(name, route);
+      if (name === '') {
+        return this.routeMap.addRoute('root', route);
+      }
     };
 
     RouteMapBuilder.prototype._nameFromPath = function(path) {
@@ -9248,9 +9739,10 @@
     Association.prototype.isPolymorphic = false;
 
     Association.prototype.defaultOptions = {
-      saveInline: true,
+      saveInline: false,
       autoload: true,
-      nestUrl: false
+      nestUrl: false,
+      includeInTransaction: true
     };
 
     function Association(model, label, options) {
@@ -9626,7 +10118,7 @@
       }
       Batman.developer["do"](function() {
         if ((Batman.currentApp != null) && !relatedModel) {
-          return Batman.developer.warn("Related model " + type + " for polymorphic association not found.");
+          return Batman.developer.warn("Related model " + type + " for hasMany polymorphic association " + this.label + " not found.");
         }
       });
       return relatedModel;
@@ -9729,21 +10221,13 @@
     SingularAssociation.prototype.isSingular = true;
 
     SingularAssociation.prototype.getAccessor = function(association, model, label) {
-      var proxy, record, recordInAttributes,
-        _this = this;
+      var proxy, record, recordInAttributes;
       if (recordInAttributes = association.getFromAttributes(this)) {
         return recordInAttributes;
       }
       if (association.getRelatedModel()) {
         proxy = this.associationProxy(association);
         record = false;
-        if (proxy._loadSetter == null) {
-          proxy._loadSetter = proxy.once('loaded', function(child) {
-            return _this._withoutDirtyTracking(function() {
-              return this.set(association.label, child);
-            });
-          });
-        }
         if (!Batman.Property.withoutTracking(function() {
           return proxy.get('loaded');
         })) {
@@ -9935,7 +10419,7 @@
       if (this.options.encodeForeignTypeKey) {
         this.model.encode(this.foreignTypeKey);
       }
-      this.typeIndicies = {};
+      this.typeIndices = {};
     }
 
     PolymorphicBelongsToAssociation.prototype.getRelatedModel = false;
@@ -9990,7 +10474,7 @@
       }
       Batman.developer["do"](function() {
         if ((Batman.currentApp != null) && !relatedModel) {
-          return Batman.developer.warn("Related model " + type + " for polymorphic association not found.");
+          return Batman.developer.warn("Related model " + type + " for belongsTo polymorphic association " + this.label + " not found.");
         }
       });
       return relatedModel;
@@ -9998,8 +10482,8 @@
 
     PolymorphicBelongsToAssociation.prototype.setIndexForType = function(type) {
       var _base;
-      (_base = this.typeIndicies)[type] || (_base[type] = new Batman.PolymorphicUniqueAssociationSetIndex(this, type, this.primaryKey));
-      return this.typeIndicies[type];
+      (_base = this.typeIndices)[type] || (_base[type] = new Batman.PolymorphicUniqueAssociationSetIndex(this, type, this.primaryKey));
+      return this.typeIndices[type];
     };
 
     PolymorphicBelongsToAssociation.prototype.inverseForType = function(type) {
@@ -10049,9 +10533,193 @@
 }).call(this);
 
 (function() {
-  var __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
-    __slice = [].slice;
+  var __hasProp = {}.hasOwnProperty;
+
+  Batman.Transaction = {
+    isTransaction: true,
+    base: function() {
+      return this._batman.base;
+    },
+    applyChanges: function(visited) {
+      var attributes, base, key, updatedAssociationSet, value, _ref;
+      if (visited == null) {
+        visited = [];
+      }
+      if (visited.indexOf(this) !== -1) {
+        return this.base();
+      }
+      visited.push(this);
+      attributes = this.get('attributes').toObject();
+      for (key in attributes) {
+        if (!__hasProp.call(attributes, key)) continue;
+        value = attributes[key];
+        if (value instanceof Batman.Model && value.isTransaction) {
+          value.applyChanges(visited);
+          delete attributes[key];
+        } else if (value instanceof Batman.TransactionAssociationSet) {
+          updatedAssociationSet = value.applyChanges(visited);
+          attributes[key] = updatedAssociationSet;
+        }
+      }
+      base = this.base();
+      base.mixin(attributes);
+      return (_ref = typeof base.applyChanges === "function" ? base.applyChanges() : void 0) != null ? _ref : base;
+    },
+    save: function(options, callback) {
+      var finish, validated, _ref,
+        _this = this;
+      if (!callback) {
+        _ref = [{}, options], options = _ref[0], callback = _ref[1];
+      }
+      this.once('validated', validated = function() {
+        return _this.applyChanges();
+      });
+      finish = function() {
+        _this.off('validated', validated);
+        return typeof callback === "function" ? callback.apply(null, arguments) : void 0;
+      };
+      return this.constructor.prototype.save.call(this, options, function(err, result) {
+        if (!err) {
+          result = _this.base();
+          result.get('dirtyKeys').clear();
+          result.get('_dirtiedKeys').clear();
+          result.get('lifecycle').startTransition('save');
+          result.get('lifecycle').startTransition('saved');
+        }
+        return finish(err, result);
+      });
+    }
+  };
+
+}).call(this);
+
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
+
+  Batman.TransactionAssociationSet = (function(_super) {
+    __extends(TransactionAssociationSet, _super);
+
+    TransactionAssociationSet.prototype.isTransaction = true;
+
+    function TransactionAssociationSet(associationSet, visited, stack) {
+      this.set('associationSet', associationSet);
+      this._loader = this._addFromAssociationSet.bind(this);
+      associationSet.on('itemsWereAdded', this._loader);
+      this._visited = visited;
+      this._stack = stack;
+      this._storage = [];
+      this._originalStorage = [];
+      this._removedStorage = [];
+      this.add.apply(this, associationSet.toArray());
+    }
+
+    TransactionAssociationSet.delegate('association', 'foreignKeyValue', {
+      to: 'associationSet'
+    });
+
+    TransactionAssociationSet.prototype._addFromAssociationSet = function(items, indexes) {
+      return this.add.apply(this, items);
+    };
+
+    TransactionAssociationSet.prototype.add = TransactionAssociationSet.mutation(function() {
+      var addedTransactions, item, items, originalIndex, removedIndex, transactionItem, _i, _len;
+      items = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      addedTransactions = [];
+      for (_i = 0, _len = items.length; _i < _len; _i++) {
+        item = items[_i];
+        if (!(item instanceof Batman.Model && !item.isTransaction)) {
+          Batman.developer.warn("You tried to add a " + item.constructor.name + " to a TransactionAssociationSet (" + (this.get('association.label')) + ")", item);
+          continue;
+        }
+        transactionItem = item._transaction(this._visited, this._stack);
+        this._storage.push(transactionItem);
+        addedTransactions.push(transactionItem);
+        originalIndex = this._originalStorage.indexOf(item);
+        if (originalIndex === -1) {
+          this._originalStorage.push(item);
+        }
+        removedIndex = this._removedStorage.indexOf(item);
+        if (removedIndex > -1) {
+          this._removedStorage.splice(removedIndex, 1);
+        }
+      }
+      this.length = this._storage.length;
+      if (addedTransactions.length) {
+        this.fire('itemsWereAdded', addedTransactions);
+      }
+      return addedTransactions;
+    });
+
+    TransactionAssociationSet.prototype.remove = TransactionAssociationSet.mutation(function() {
+      var item, originalIndex, removedTransactions, transactionIndex, transactionItem, transactions, _i, _len;
+      transactions = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      removedTransactions = [];
+      for (_i = 0, _len = transactions.length; _i < _len; _i++) {
+        transactionItem = transactions[_i];
+        if (!transactionItem.isTransaction) {
+          throw "Tried to remove real item from transaction set: " + (t.toJSON());
+        }
+        transactionIndex = this._storage.indexOf(transactionItem);
+        if (transactionIndex > -1) {
+          this._storage.splice(transactionIndex, 1);
+          removedTransactions.push(transactionItem);
+        }
+        item = transactionItem.base();
+        originalIndex = this._originalStorage.indexOf(item);
+        if (originalIndex > -1) {
+          this._removedStorage.push(item);
+          this._originalStorage.splice(originalIndex, 1);
+        }
+      }
+      this.length = this._storage.length;
+      if (removedTransactions.length) {
+        this.fire('itemsWereRemoved', removedTransactions);
+      }
+      return removedTransactions;
+    });
+
+    TransactionAssociationSet.prototype.applyChanges = function(visited) {
+      var originals, target, transactionItem, _i, _len, _ref;
+      _ref = this._storage;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        transactionItem = _ref[_i];
+        transactionItem.applyChanges(visited);
+      }
+      originals = (function(func, args, ctor) {
+        ctor.prototype = func.prototype;
+        var child = new ctor, result = func.apply(child, args);
+        return Object(result) === result ? result : child;
+      })(Batman.Set, this._originalStorage, function(){});
+      target = this.get('associationSet');
+      target.off('itemsWereAdded', this._loader);
+      target.replace(originals);
+      target.set('removedItems', (function(func, args, ctor) {
+        ctor.prototype = func.prototype;
+        var child = new ctor, result = func.apply(child, args);
+        return Object(result) === result ? result : child;
+      })(Batman.Set, this._removedStorage, function(){}));
+      return target;
+    };
+
+    TransactionAssociationSet.accessor('length', function() {
+      this.registerAsMutableSource();
+      return this.length;
+    });
+
+    TransactionAssociationSet.prototype.build = Batman.AssociationSet.prototype.build;
+
+    return TransactionAssociationSet;
+
+  })(Batman.Set);
+
+}).call(this);
+
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __slice = [].slice;
 
   Batman.Validator = (function(_super) {
     __extends(Validator, _super);
@@ -10102,12 +10770,20 @@
       Validator.__super__.constructor.apply(this, mixins);
     }
 
-    Validator.prototype.validate = function(record) {
-      return Batman.developer.error("You must override validate in Batman.Validator subclasses.");
+    Validator.prototype.validateEach = function(record) {
+      return Batman.developer.error("You must override validateEach in Batman.Validator subclasses.");
     };
 
-    Validator.prototype.format = function(key, messageKey, interpolations) {
-      return Batman.t("errors.messages." + messageKey, interpolations);
+    Validator.prototype.format = function(attr, messageKey, interpolations, record) {
+      if (this.options.message) {
+        if (typeof this.options.message === 'function') {
+          return this.options.message.call(record, attr, messageKey);
+        } else {
+          return this.options.message;
+        }
+      } else {
+        return Batman.t("errors.messages." + messageKey, interpolations);
+      }
     };
 
     Validator.prototype.handleBlank = function(value) {
@@ -10142,10 +10818,13 @@
         equal_to: "must be equal to %{count}",
         less_than: "must be less than %{count}",
         less_than_or_equal_to: "must be less than or equal to %{count}",
+        not_an_integer: "must be an integer",
         not_matching: "is not valid",
         invalid_association: "is not valid",
         not_included_in_list: "is not included in the list",
-        included_in_list: "is included in the list"
+        included_in_list: "is included in the list",
+        not_an_email: "is not a valid email address",
+        confirmation_does_not_match: 'and confirmation do not match'
       }
     }
   });
@@ -10176,7 +10855,7 @@
         return callback();
       }
       if ((value == null) || value === '' || !this.regexp.test(value)) {
-        errors.add(key, this.format(key, 'not_matching'));
+        errors.add(key, this.format(key, 'not_matching', {}, record));
       }
       return callback();
     };
@@ -10208,7 +10887,7 @@
       var value;
       value = record.get(key);
       if (!this.isPresent(value)) {
-        errors.add(key, this.format(key, 'blank'));
+        errors.add(key, this.format(key, 'blank', {}, record));
       }
       return callback();
     };
@@ -10238,7 +10917,7 @@
       return _ref;
     }
 
-    NumericValidator.triggers('numeric', 'greaterThan', 'greaterThanOrEqualTo', 'equalTo', 'lessThan', 'lessThanOrEqualTo');
+    NumericValidator.triggers('numeric', 'greaterThan', 'greaterThanOrEqualTo', 'equalTo', 'lessThan', 'lessThanOrEqualTo', 'onlyInteger');
 
     NumericValidator.options('allowBlank');
 
@@ -10250,32 +10929,34 @@
         return callback();
       }
       if ((value == null) || !(this.isNumeric(value) || this.canCoerceToNumeric(value))) {
-        errors.add(key, this.format(key, 'not_numeric'));
+        errors.add(key, this.format(key, 'not_numeric', {}, record));
+      } else if (options.onlyInteger && !this.isInteger(value)) {
+        errors.add(key, this.format(key, 'not_an_integer', {}, record));
       } else {
         if ((options.greaterThan != null) && value <= options.greaterThan) {
           errors.add(key, this.format(key, 'greater_than', {
             count: options.greaterThan
-          }));
+          }, record));
         }
         if ((options.greaterThanOrEqualTo != null) && value < options.greaterThanOrEqualTo) {
           errors.add(key, this.format(key, 'greater_than_or_equal_to', {
             count: options.greaterThanOrEqualTo
-          }));
+          }, record));
         }
         if ((options.equalTo != null) && value !== options.equalTo) {
           errors.add(key, this.format(key, 'equal_to', {
             count: options.equalTo
-          }));
+          }, record));
         }
         if ((options.lessThan != null) && value >= options.lessThan) {
           errors.add(key, this.format(key, 'less_than', {
             count: options.lessThan
-          }));
+          }, record));
         }
         if ((options.lessThanOrEqualTo != null) && value > options.lessThanOrEqualTo) {
           errors.add(key, this.format(key, 'less_than_or_equal_to', {
             count: options.lessThanOrEqualTo
-          }));
+          }, record));
         }
       }
       return callback();
@@ -10285,6 +10966,10 @@
       return !isNaN(parseFloat(value)) && isFinite(value);
     };
 
+    NumericValidator.prototype.isInteger = function(value) {
+      return parseFloat(value) === (value | 0);
+    };
+
     NumericValidator.prototype.canCoerceToNumeric = function(value) {
       return (value - 0) == value && value.length > 0;
     };
@@ -10323,7 +11008,7 @@
       var options, value;
       options = this.options;
       value = record.get(key);
-      if (value !== '' && this.handleBlank(value)) {
+      if (this.handleBlank(value)) {
         return callback();
       }
       if (value == null) {
@@ -10332,17 +11017,17 @@
       if (options.minLength && value.length < options.minLength) {
         errors.add(key, this.format(key, 'too_short', {
           count: options.minLength
-        }));
+        }, record));
       }
       if (options.maxLength && value.length > options.maxLength) {
         errors.add(key, this.format(key, 'too_long', {
           count: options.maxLength
-        }));
+        }, record));
       }
       if (options.length && value.length !== options.length) {
         errors.add(key, this.format(key, 'wrong_length', {
           count: options.length
-        }));
+        }, record));
       }
       return callback();
     };
@@ -10364,14 +11049,18 @@
 
     InclusionValidator.triggers('inclusion');
 
+    InclusionValidator.options('allowBlank');
+
     function InclusionValidator(options) {
       this.acceptableValues = options.inclusion["in"];
       InclusionValidator.__super__.constructor.apply(this, arguments);
     }
 
     InclusionValidator.prototype.validateEach = function(errors, record, key, callback) {
-      if (this.acceptableValues.indexOf(record.get(key)) === -1) {
-        errors.add(key, this.format(key, 'not_included_in_list'));
+      var value;
+      value = record.get(key);
+      if (!this.handleBlank(value) && this.acceptableValues.indexOf(value) === -1) {
+        errors.add(key, this.format(key, 'not_included_in_list', {}, record));
       }
       return callback();
     };
@@ -10400,7 +11089,7 @@
 
     ExclusionValidator.prototype.validateEach = function(errors, record, key, callback) {
       if (this.unacceptableValues.indexOf(record.get(key)) >= 0) {
-        errors.add(key, this.format(key, 'included_in_list'));
+        errors.add(key, this.format(key, 'included_in_list', {}, record));
       }
       return callback();
     };
@@ -10413,6 +11102,82 @@
 
 }).call(this);
 
+(function() {
+  var _ref,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Batman.EmailValidator = (function(_super) {
+    __extends(EmailValidator, _super);
+
+    function EmailValidator() {
+      _ref = EmailValidator.__super__.constructor.apply(this, arguments);
+      return _ref;
+    }
+
+    EmailValidator.triggers('email');
+
+    EmailValidator.prototype.emailRegexp = /[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9-]+(\.[a-z0-9-]+)*/;
+
+    EmailValidator.prototype.validateEach = function(errors, record, key, callback) {
+      var value;
+      value = record.get(key);
+      if ((value == null) || value === '' || !this.emailRegexp.test(value)) {
+        errors.add(key, this.format(key, 'not_an_email', {}, record));
+      }
+      return callback();
+    };
+
+    return EmailValidator;
+
+  })(Batman.Validator);
+
+  Batman.Validators.push(Batman.EmailValidator);
+
+}).call(this);
+
+(function() {
+  var _ref,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Batman.ConfirmationValidator = (function(_super) {
+    __extends(ConfirmationValidator, _super);
+
+    function ConfirmationValidator() {
+      _ref = ConfirmationValidator.__super__.constructor.apply(this, arguments);
+      return _ref;
+    }
+
+    ConfirmationValidator.triggers('confirmation');
+
+    ConfirmationValidator.prototype.validateEach = function(errors, record, key, callback) {
+      var confirmation_key, confirmation_value, options, value;
+      options = this.options;
+      if (!options.confirmation) {
+        return;
+      }
+      if (Batman.typeOf(this.options.confirmation) === "String") {
+        confirmation_key = this.options.confirmation;
+      } else {
+        confirmation_key = key + "_confirmation";
+      }
+      value = record.get(key);
+      confirmation_value = record.get(confirmation_key);
+      if (value !== confirmation_value) {
+        errors.add(key, this.format(key, 'confirmation_does_not_match', {}, record));
+      }
+      return callback();
+    };
+
+    return ConfirmationValidator;
+
+  })(Batman.Validator);
+
+  Batman.Validators.push(Batman.ConfirmationValidator);
+
+}).call(this);
+
 (function() {
   var _ref,
     __hasProp = {}.hasOwnProperty,
@@ -10439,7 +11204,7 @@
         count = 1;
         childFinished = function(err, childErrors) {
           if (childErrors.length > 0) {
-            errors.add(key, _this.format(key, 'invalid_association'));
+            errors.add(key, _this.format(key, 'invalid_association', {}, record));
           }
           if (--count === 0) {
             return callback();
@@ -10468,6 +11233,63 @@
 
 }).call(this);
 
+(function() {
+  var _ref,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Batman.AssociatedFieldValidator = (function(_super) {
+    __extends(AssociatedFieldValidator, _super);
+
+    function AssociatedFieldValidator() {
+      _ref = AssociatedFieldValidator.__super__.constructor.apply(this, arguments);
+      return _ref;
+    }
+
+    AssociatedFieldValidator.triggers('associatedFields');
+
+    AssociatedFieldValidator.prototype.validateEach = function(errors, record, key, callback) {
+      var childFinished, count, value,
+        _this = this;
+      value = record.get(key);
+      if (value != null) {
+        if (value instanceof Batman.AssociationProxy) {
+          value = typeof value.get === "function" ? value.get('target') : void 0;
+        }
+        count = 1;
+        childFinished = function(err, childErrors) {
+          if (childErrors != null) {
+            childErrors.forEach(function(validationError) {
+              return errors.add(validationError.get('attribute'), validationError.get('message'));
+            });
+          }
+          if (--count === 0) {
+            return callback();
+          }
+        };
+        if ((value != null ? value.forEach : void 0) != null) {
+          value.forEach(function(record) {
+            count += 1;
+            return record.validate(childFinished);
+          });
+        } else if ((value != null ? value.validate : void 0) != null) {
+          count += 1;
+          value.validate(childFinished);
+        }
+        return childFinished(null, []);
+      } else {
+        return callback();
+      }
+    };
+
+    return AssociatedFieldValidator;
+
+  })(Batman.Validator);
+
+  Batman.Validators.push(Batman.AssociatedFieldValidator);
+
+}).call(this);
+
 (function() {
   var __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
@@ -10629,6 +11451,14 @@
       return this._batman.set('options', keys);
     };
 
+    View.filter = function(key, filter) {
+      var filters;
+      Batman.initializeObject(this.prototype);
+      filters = this.prototype._batman.filters || {};
+      filters[key] = filter;
+      return this.prototype._batman.set('filters', filters);
+    };
+
     View.viewForNode = function(node, climbTree) {
       var view;
       if (climbTree == null) {
@@ -10702,16 +11532,19 @@
     };
 
     View.prototype._addSubview = function(subview) {
-      var subviewController, yieldName, yieldObject;
+      var filters, subviewController, yieldName, yieldObject;
       subviewController = subview.controller;
       subview.removeFromSuperview();
       subview.set('controller', subviewController || this.controller);
       subview.set('superview', this);
-      subview.fire('viewDidMoveToSuperview');
+      subview.fireAndCall('viewDidMoveToSuperview');
       if ((yieldName = subview.contentFor) && !subview.parentNode) {
         yieldObject = Batman.DOM.Yield.withName(yieldName);
         yieldObject.set('contentView', subview);
       }
+      if (filters = this._batman.get('filters')) {
+        subview._batman.set('filters', Batman.mixin({}, filters, subview._batman.get('filters')));
+      }
       this.get('node');
       subview.get('node');
       this.observe('node', subview._nodesChanged);
@@ -10725,7 +11558,7 @@
       if (!this.superview) {
         return;
       }
-      this.fire('viewWillRemoveFromSuperview');
+      this.fireAndCall('viewWillRemoveFromSuperview');
       this.forget('node', this._nodesChanged);
       this.forget('parentNode', this._nodesChanged);
       this.superview.forget('node', this._nodesChanged);
@@ -10806,10 +11639,7 @@
       if (value != null) {
         this.set(eventName, value);
       } else {
-        this.fire(eventName);
-        if (typeof this[eventName] === "function") {
-          this[eventName]();
-        }
+        this.fireAndCall(eventName);
       }
       _ref = this.subviews._storage;
       _results = [];
@@ -10874,7 +11704,7 @@
           if (node) {
             this.set('node', node);
           }
-          this.fire('viewDidLoad');
+          this.fireAndCall('viewDidLoad');
         }
         return this.node;
       },
@@ -10910,8 +11740,7 @@
       }
       new Batman.BindingParser(this);
       this.set('isBound', true);
-      this.fire('ready');
-      return typeof this.ready === "function" ? this.ready() : void 0;
+      return this.fireAndCall('ready');
     };
 
     View.prototype.destroyBindings = function() {
@@ -10945,11 +11774,14 @@
         Batman.developer.warn("Tried to die() a view more than once.");
         return;
       }
-      this.fire('destroy');
+      this.fireAndCall('destroy');
+      this.destroyBindings();
+      this.destroySubviews();
       if (this.node) {
         this.wasInDOM = Batman.DOM.containsNode(this.node);
         Batman.DOM.destroyNode(this.node);
       }
+      this.removeFromSuperview();
       this.forget();
       if ((_ref = this._batman.properties) != null) {
         _ref.forEach(function(key, property) {
@@ -10963,9 +11795,6 @@
           event.clearHandlers();
         }
       }
-      this.destroyBindings();
-      this.destroySubviews();
-      this.removeFromSuperview();
       this.node = null;
       this.parentNode = null;
       this.subviews = null;
@@ -10987,22 +11816,19 @@
     };
 
     View.prototype.targetForKeypath = function(keypath, forceTarget) {
-      var controller, lookupNode, nearestNonBackingView, proxiedObject;
-      proxiedObject = this.get('proxiedObject');
-      lookupNode = proxiedObject || this;
+      var controller, lookupNode, nearestNonBackingView, target;
+      lookupNode = this;
       while (lookupNode) {
-        if (typeof Batman.get(lookupNode, keypath) !== 'undefined') {
-          return lookupNode;
+        if (target = this._testTargetForKeypath(lookupNode, keypath)) {
+          return target;
         }
         if (forceTarget && !nearestNonBackingView && !lookupNode.isBackingView) {
-          nearestNonBackingView = lookupNode;
+          nearestNonBackingView = Batman.get(lookupNode, 'proxiedObject') || lookupNode;
         }
         if (!controller && lookupNode.isView && lookupNode.controller) {
           controller = lookupNode.controller;
         }
-        if (proxiedObject && lookupNode === proxiedObject) {
-          lookupNode = this;
-        } else if (lookupNode.isView && lookupNode.superview) {
+        if (lookupNode.isView && lookupNode.superview) {
           lookupNode = lookupNode.superview;
         } else if (controller) {
           lookupNode = controller;
@@ -11022,6 +11848,18 @@
       return nearestNonBackingView;
     };
 
+    View.prototype._testTargetForKeypath = function(object, keypath) {
+      var proxiedObject;
+      if (proxiedObject = Batman.get(object, 'proxiedObject')) {
+        if (typeof Batman.get(proxiedObject, keypath) !== 'undefined') {
+          return proxiedObject;
+        }
+      }
+      if (typeof Batman.get(object, keypath) !== 'undefined') {
+        return object;
+      }
+    };
+
     View.prototype.lookupKeypath = function(keypath) {
       var base, target;
       base = this.baseForKeypath(keypath);
@@ -11041,6 +11879,11 @@
       return (_ref = Batman.Property.forBaseAndKey(target, keypath)) != null ? _ref.setValue(value) : void 0;
     };
 
+    View.prototype.fireAndCall = function(key) {
+      this.fire(key);
+      return typeof this[key] === "function" ? this[key]() : void 0;
+    };
+
     return View;
 
   })(Batman.Object);
@@ -11247,7 +12090,7 @@
     };
 
     AbstractBinding.prototype.parseFilter = function() {
-      var args, e, filter, filterName, filterString, filters, key, keyPath, orig, split;
+      var args, e, filter, filterName, filterString, filters, key, keyPath, orig, split, _ref, _ref1;
       this.filterFunctions = [];
       this.filterArguments = [];
       keyPath = this.keyPath;
@@ -11275,7 +12118,7 @@
           }
           filterName = filterString.substr(0, split);
           args = filterString.substr(split);
-          if (!(filter = Batman.Filters[filterName])) {
+          if (!(filter = ((_ref = this.view) != null ? (_ref1 = _ref._batman.get('filters')) != null ? _ref1[filterName] : void 0 : void 0) || Batman.Filters[filterName])) {
             return Batman.developer.error("Unrecognized filter '" + filterName + "' in key \"" + this.keyPath + "\"!");
           }
           this.filterFunctions.push(filter);
@@ -11433,7 +12276,7 @@
         if (_this.isDataChanging) {
           return;
         }
-        return _this.view.set(_this.keyPath, value);
+        return _this.view.setKeypath(_this.keyPath, value);
       });
     }
 
@@ -11509,16 +12352,16 @@
       view = Batman.View.viewForNode(this.node, false);
       if (!!value === !this.invert) {
         if (view != null) {
-          view.fire('viewWillShow');
+          view.fireAndCall('viewWillShow');
         }
         this.node.style.display = this.originalDisplay;
-        return view != null ? view.fire('viewDidShow') : void 0;
+        return view != null ? view.fireAndCall('viewDidShow') : void 0;
       } else {
         if (view != null) {
-          view.fire('viewWillHide');
+          view.fireAndCall('viewWillHide');
         }
         Batman.DOM.setStyleProperty(this.node, 'display', 'none', 'important');
-        return view != null ? view.fire('viewDidHide') : void 0;
+        return view != null ? view.fireAndCall('viewDidHide') : void 0;
       }
     };
 
@@ -11692,20 +12535,13 @@
 }).call(this);
 
 (function() {
-  var _ref,
-    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
     __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
   Batman.DOM.RouteBinding = (function(_super) {
     __extends(RouteBinding, _super);
 
-    function RouteBinding() {
-      this.routeClick = __bind(this.routeClick, this);
-      _ref = RouteBinding.__super__.constructor.apply(this, arguments);
-      return _ref;
-    }
-
     RouteBinding.prototype.onAnchorTag = false;
 
     RouteBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.Data;
@@ -11714,34 +12550,44 @@
       return this.view.lookupKeypath('dispatcher') || Batman.App.get('current.dispatcher');
     });
 
+    function RouteBinding() {
+      this.routeClick = __bind(this.routeClick, this);
+      var definition, paramKeypath;
+      RouteBinding.__super__.constructor.apply(this, arguments);
+      if (paramKeypath = this.node.getAttribute('data-route-params')) {
+        definition = new Batman.DOM.ReaderBindingDefinition(this.node, paramKeypath, this.view);
+        this.set('queryParams', new Batman.DOM.RouteParamsBinding(definition, this));
+      }
+    }
+
     RouteBinding.prototype.bind = function() {
-      var _ref1;
-      if ((_ref1 = this.node.nodeName) === 'a' || _ref1 === 'A') {
+      var _ref;
+      if ((_ref = this.node.nodeName) === 'a' || _ref === 'A') {
         this.onAnchorTag = true;
       }
       RouteBinding.__super__.bind.apply(this, arguments);
       if (this.onAnchorTag && this.node.getAttribute('target')) {
         return;
       }
-      return Batman.DOM.events.click(this.node, this.routeClick);
+      return Batman.DOM.events.primaryInteractionEvent(this.node, this.routeClick);
     };
 
     RouteBinding.prototype.routeClick = function(node, event) {
-      var params;
+      var path;
       if (event.__batmanActionTaken) {
         return;
       }
       event.__batmanActionTaken = true;
-      params = this.pathFromValue(this.get('filteredValue'));
-      if (params != null) {
-        return Batman.redirect(params);
+      path = this.generatePath(this.get('filteredValue'), this.get('queryParams.filteredValue'));
+      if (path != null) {
+        return Batman.redirect(path);
       }
     };
 
-    RouteBinding.prototype.dataChange = function(value) {
+    RouteBinding.prototype.dataChange = function(value, node, queryParams) {
       var path;
       if (value) {
-        path = this.pathFromValue(value);
+        path = this.generatePath(value, queryParams || this.get('queryParams.filteredValue'));
       }
       if (this.onAnchorTag) {
         if (path && Batman.navigator) {
@@ -11753,21 +12599,46 @@
       }
     };
 
-    RouteBinding.prototype.pathFromValue = function(value) {
-      var _ref1;
-      if (value) {
-        if (value.isNamedRouteQuery) {
-          return value.get('path');
-        } else {
-          return (_ref1 = this.get('dispatcher')) != null ? _ref1.pathFromParams(value) : void 0;
+    RouteBinding.prototype.generatePath = function(value, params) {
+      var path, uri, _ref;
+      path = (value != null ? value.isNamedRouteQuery : void 0) ? value.get('path') : (_ref = this.get('dispatcher')) != null ? _ref.pathFromParams(value) : void 0;
+      if (!params || !path) {
+        return path;
+      }
+      if (Batman.typeOf(params) === 'Object') {
+        if (params.toObject != null) {
+          params = params.toObject();
         }
+      } else {
+        params = Batman.URI.paramsFromQuery(params);
       }
+      uri = new Batman.URI(path);
+      uri.queryParams = params;
+      return uri.toString();
     };
 
     return RouteBinding;
 
   })(Batman.DOM.AbstractBinding);
 
+  Batman.DOM.RouteParamsBinding = (function(_super) {
+    __extends(RouteParamsBinding, _super);
+
+    RouteParamsBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.Data;
+
+    function RouteParamsBinding(definition, routeBinding) {
+      this.routeBinding = routeBinding;
+      RouteParamsBinding.__super__.constructor.call(this, definition);
+    }
+
+    RouteParamsBinding.prototype.dataChange = function(value) {
+      return this.routeBinding.dataChange(this.routeBinding.get('filteredValue'), this.node, value);
+    };
+
+    return RouteParamsBinding;
+
+  })(Batman.DOM.AbstractBinding);
+
 }).call(this);
 
 (function() {
@@ -11846,7 +12717,7 @@
 }).call(this);
 
 (function() {
-  var _ref, _ref1,
+  var _ref,
     __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
@@ -11867,20 +12738,21 @@
   Batman.DOM.DeferredRenderBinding = (function(_super) {
     __extends(DeferredRenderBinding, _super);
 
-    function DeferredRenderBinding() {
-      _ref1 = DeferredRenderBinding.__super__.constructor.apply(this, arguments);
-      return _ref1;
-    }
-
     DeferredRenderBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.Data;
 
     DeferredRenderBinding.prototype.backWithView = Batman.DeferredRenderView;
 
     DeferredRenderBinding.prototype.skipChildren = true;
 
+    function DeferredRenderBinding(definition) {
+      this.invert = definition.invert;
+      this.attributeName = this.invert ? 'data-deferif' : 'data-renderif';
+      DeferredRenderBinding.__super__.constructor.apply(this, arguments);
+    }
+
     DeferredRenderBinding.prototype.dataChange = function(value) {
-      if (value && !this.backingView.isBound) {
-        this.node.removeAttribute('data-renderif');
+      if (!!value === !this.invert && !this.backingView.isBound) {
+        this.node.removeAttribute(this.attributeName);
         return this.backingView.initializeBindings();
       }
     };
@@ -11937,22 +12809,79 @@
   var __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
-  Batman.DOM.EventBinding = (function(_super) {
-    __extends(EventBinding, _super);
+  Batman.Tracking = {
+    loadTracker: function() {
+      if (Batman.Tracking.tracker) {
+        return Batman.Tracking.tracker;
+      }
+      Batman.Tracking.tracker = Batman.currentApp.EventTracker ? new Batman.currentApp.EventTracker : (Batman.developer.warn("Define " + Batman.currentApp.name + ".EventTracker to use data-track"), {
+        track: function() {}
+      });
+      return Batman.Tracking.tracker;
+    },
+    trackEvent: function(type, data, node) {
+      return Batman.Tracking.loadTracker().track(type, data, node);
+    }
+  };
 
-    EventBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.Data;
+  Batman.DOM.ClickTrackingBinding = (function(_super) {
+    __extends(ClickTrackingBinding, _super);
 
-    EventBinding.prototype.bindImmediately = false;
+    ClickTrackingBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.None;
 
-    function EventBinding() {
-      var attacher, callback,
+    ClickTrackingBinding.prototype.bindImmediately = false;
+
+    function ClickTrackingBinding() {
+      var callback,
         _this = this;
-      EventBinding.__super__.constructor.apply(this, arguments);
+      ClickTrackingBinding.__super__.constructor.apply(this, arguments);
       callback = function() {
-        var func, target;
-        func = _this.get('filteredValue');
-        target = _this.view.targetForKeypath(_this.functionPath || _this.unfilteredKey);
-        if (target && _this.functionPath) {
+        return Batman.Tracking.trackEvent('click', _this.get('filteredValue'), _this.node);
+      };
+      Batman.DOM.events.click(this.node, callback, this.view, 'click', false);
+      this.bind();
+    }
+
+    return ClickTrackingBinding;
+
+  })(Batman.DOM.AbstractAttributeBinding);
+
+  Batman.DOM.ViewTrackingBinding = (function(_super) {
+    __extends(ViewTrackingBinding, _super);
+
+    ViewTrackingBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.None;
+
+    function ViewTrackingBinding() {
+      ViewTrackingBinding.__super__.constructor.apply(this, arguments);
+      Batman.Tracking.trackEvent('view', this.get('filteredValue'), this.node);
+    }
+
+    return ViewTrackingBinding;
+
+  })(Batman.DOM.AbstractAttributeBinding);
+
+}).call(this);
+
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  Batman.DOM.EventBinding = (function(_super) {
+    __extends(EventBinding, _super);
+
+    EventBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.None;
+
+    EventBinding.prototype.bindImmediately = false;
+
+    function EventBinding() {
+      var attacher, callback,
+        _this = this;
+      EventBinding.__super__.constructor.apply(this, arguments);
+      callback = function() {
+        var func, target;
+        func = _this.get('filteredValue');
+        target = _this.view.targetForKeypath(_this.functionPath || _this.unfilteredKey);
+        if (target && _this.functionPath) {
           target = Batman.get(target, _this.functionPath);
         }
         return func != null ? func.apply(target, arguments) : void 0;
@@ -11962,7 +12891,7 @@
       } else {
         Batman.DOM.events.other(this.node, this.attributeName, callback, this.view);
       }
-      this.view.bindings.push(this);
+      this.bind();
     }
 
     EventBinding.prototype._unfilteredValue = function(key) {
@@ -11999,20 +12928,31 @@
 
     ContextBinding.prototype.bindingName = 'context';
 
-    function ContextBinding() {
-      var contextAttribute;
+    function ContextBinding(definition) {
+      var contextAttribute,
+        _this = this;
+      this.contextKeypath = definition.attr || 'proxiedObject';
       ContextBinding.__super__.constructor.apply(this, arguments);
       contextAttribute = this.attributeName ? "data-" + this.bindingName + "-" + this.attributeName : "data-" + this.bindingName;
       this.node.removeAttribute(contextAttribute);
       this.node.insertBefore(document.createComment("batman-" + contextAttribute + "=\"" + this.keyPath + "\""), this.node.firstChild);
+      this.backingView.observe(this.contextKeypath, this._updateValue = function(value) {
+        if (_this.isDataChanging) {
+          return;
+        }
+        return _this.view.setKeypath(_this.keyPath, value);
+      });
     }
 
     ContextBinding.prototype.dataChange = function(proxiedObject) {
-      return this.backingView.set(this.attributeName || 'proxiedObject', proxiedObject);
+      this.isDataChanging = true;
+      this.backingView.set(this.contextKeypath, proxiedObject);
+      return this.isDataChanging = false;
     };
 
     ContextBinding.prototype.die = function() {
-      this.backingView.unset(this.attributeName || 'proxiedObject');
+      this.backingView.forget(this.contextKeypath, this._updateValue);
+      this.backingView.unset(this.contextKeypath);
       return ContextBinding.__super__.die.apply(this, arguments);
     };
 
@@ -12250,6 +13190,22 @@
       return _ref;
     }
 
+    AbstractCollectionBinding.prototype.dataChange = function(collection) {
+      var items, _items;
+      if (collection != null) {
+        if (!this.bindCollection(collection)) {
+          items = (collection != null ? collection.forEach : void 0) ? (_items = [], collection.forEach(function(item) {
+            return _items.push(item);
+          }), _items) : Object.keys(collection);
+          this.handleArrayChanged(items);
+        }
+      } else {
+        this.unbindCollection();
+        this.collection = [];
+        this.handleArrayChanged([]);
+      }
+    };
+
     AbstractCollectionBinding.prototype.bindCollection = function(newCollection) {
       var _ref1;
       if (newCollection instanceof Batman.Hash) {
@@ -12368,6 +13324,9 @@
 
     StyleBinding.prototype.setStyle = function(key, value) {
       key = Batman.helpers.camelize(key.trim(), true);
+      if (key === "") {
+        return false;
+      }
       if (this.oldStyles[key] == null) {
         this.oldStyles[key] = this.node.style[key] || "";
       }
@@ -12435,27 +13394,28 @@
 }).call(this);
 
 (function() {
-  var _ref,
-    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
     __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
   Batman.DOM.ClassBinding = (function(_super) {
     __extends(ClassBinding, _super);
 
+    ClassBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.Data;
+
     function ClassBinding() {
       this.handleArrayChanged = __bind(this.handleArrayChanged, this);
-      _ref = ClassBinding.__super__.constructor.apply(this, arguments);
-      return _ref;
+      this.existingClasses = arguments[0].node.className.split(' ');
+      ClassBinding.__super__.constructor.apply(this, arguments);
     }
 
-    ClassBinding.prototype.onlyObserve = Batman.BindingDefinitionOnlyObserve.Data;
-
     ClassBinding.prototype.dataChange = function(value) {
+      var newClasses;
       if (value != null) {
         this.unbindCollection();
         if (typeof value === 'string') {
-          return this.node.className = value;
+          newClasses = [value].concat(this.existingClasses);
+          return this.node.className = newClasses.join(' ').trim();
         } else {
           this.bindCollection(value);
           return this.updateFromCollection();
@@ -12464,17 +13424,17 @@
     };
 
     ClassBinding.prototype.updateFromCollection = function() {
-      var array, k, v;
+      var array, existingClasses, k, newClasses, v;
       if (this.collection) {
         array = this.collection.map ? this.collection.map(function(x) {
           return x;
         }) : (function() {
-          var _ref1, _results;
-          _ref1 = this.collection;
+          var _ref, _results;
+          _ref = this.collection;
           _results = [];
-          for (k in _ref1) {
-            if (!__hasProp.call(_ref1, k)) continue;
-            v = _ref1[k];
+          for (k in _ref) {
+            if (!__hasProp.call(_ref, k)) continue;
+            v = _ref[k];
             _results.push(k);
           }
           return _results;
@@ -12482,7 +13442,11 @@
         if (array.toArray != null) {
           array = array.toArray();
         }
-        return this.node.className = array.join(' ');
+        existingClasses = this.existingClasses.slice(0);
+        newClasses = array.filter(function(val) {
+          return existingClasses.indexOf(val) === -1;
+        });
+        return this.node.className = existingClasses.concat(newClasses).join(' ').trim();
       }
     };
 
@@ -12523,22 +13487,22 @@
       parentNode = this.placeholderNode.parentNode || this.node.parentNode;
       if (!!value === !this.invert) {
         if (view != null) {
-          view.fire('viewWillShow');
+          view.fireAndCall('viewWillShow');
         }
         if (this.node.parentNode == null) {
           parentNode.insertBefore(this.node, this.placeholderNode);
           parentNode.removeChild(this.placeholderNode);
         }
-        return view != null ? view.fire('viewDidShow') : void 0;
+        return view != null ? view.fireAndCall('viewDidShow') : void 0;
       } else {
         if (view != null) {
-          view.fire('viewWillHide');
+          view.fireAndCall('viewWillHide');
         }
         if (this.node.parentNode != null) {
           parentNode.insertBefore(this.placeholderNode, this.node);
           parentNode.removeChild(this.node);
         }
-        return view != null ? view.fire('viewDidHide') : void 0;
+        return view != null ? view.fireAndCall('viewDidHide') : void 0;
       }
     };
 
@@ -12747,8 +13711,12 @@
       IteratorBinding.__super__.constructor.apply(this, arguments);
       this.backingView.set('attributeName', this.attributeName);
       this.view.prevent('ready');
-      Batman.setImmediate(function() {
+      this._handle = Batman.setImmediate(function() {
         var parentNode;
+        if (_this.backingView.isDead) {
+          Batman.developer.warn("IteratorBinding (data-foreach-" + _this.iteratorName + "='" + _this.keyPath + "') trying to insert dead backing view into DOM (" + _this.view.constructor.name + ")");
+          return;
+        }
         parentNode = _this.prototypeNode.parentNode;
         parentNode.insertBefore(_this.backingView.get('node'), _this.prototypeNode);
         parentNode.removeChild(_this.prototypeNode);
@@ -12757,22 +13725,6 @@
       });
     }
 
-    IteratorBinding.prototype.dataChange = function(collection) {
-      var items, _items;
-      if (collection != null) {
-        if (!this.bindCollection(collection)) {
-          items = (collection != null ? collection.forEach : void 0) ? (_items = [], collection.forEach(function(item) {
-            return _items.push(item);
-          }), _items) : Object.keys(collection);
-          this.handleArrayChanged(items);
-        }
-      } else {
-        this.unbindCollection();
-        this.collection = [];
-        this.handleArrayChanged([]);
-      }
-    };
-
     IteratorBinding.prototype.handleArrayChanged = function(newItems) {
       if (!this.backingView.isDead) {
         this.backingView.destroySubviews();
@@ -12806,6 +13758,9 @@
     };
 
     IteratorBinding.prototype.die = function() {
+      if (this._handle) {
+        Batman.clearImmediate(this._handle);
+      }
       this.prototypeNode = null;
       return IteratorBinding.__super__.die.apply(this, arguments);
     };
@@ -13074,6 +14029,24 @@
     equals: buntUndefined(function(lhs, rhs, binding) {
       return lhs === rhs;
     }),
+    eq: function(lhs, rhs) {
+      return lhs === rhs;
+    },
+    neq: function(lhs, rhs) {
+      return lhs !== rhs;
+    },
+    lt: buntUndefined(function(lhs, rhs) {
+      return lhs < rhs;
+    }),
+    gt: buntUndefined(function(lhs, rhs) {
+      return lhs > rhs;
+    }),
+    lteq: buntUndefined(function(lhs, rhs) {
+      return lhs <= rhs;
+    }),
+    gteq: buntUndefined(function(lhs, rhs) {
+      return lhs >= rhs;
+    }),
     and: function(lhs, rhs) {
       return lhs && rhs;
     },
@@ -13083,6 +14056,27 @@
     not: function(value, binding) {
       return !value;
     },
+    ceil: function(value) {
+      return Math.ceil(value);
+    },
+    floor: function(value) {
+      return Math.floor(value);
+    },
+    round: function(value) {
+      return Math.round(value);
+    },
+    precision: function(value, p) {
+      return parseFloat(value).toPrecision(p);
+    },
+    fixed: function(value, f) {
+      return parseFloat(value).toFixed(f);
+    },
+    delimitNumber: function(value) {
+      value = value.toString();
+      return value.replace(/(^|[^\w.])(\d{4,})/g, function($0, $1, $2) {
+        return $1 + $2.replace(/\d(?=(?:\d\d\d)+(?!\d))/g, "$&,");
+      });
+    },
     trim: buntUndefined(function(value, binding) {
       return value.trim();
     }),
@@ -13193,7 +14187,7 @@
       values = {};
       for (k in interpolationKeypaths) {
         v = interpolationKeypaths[k];
-        values[k] = this.get(v);
+        values[k] = this.lookupKeypath(v);
         if (values[k] == null) {
           Batman.developer.warn("Warning! Undefined interpolation key " + k + " for interpolation", string);
           values[k] = '';
@@ -13207,18 +14201,14 @@
       if (!block) {
         return;
       }
-      return function() {
-        var regularArgs;
-        regularArgs = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
-        return block.call.apply(block, [this].concat(__slice.call(curryArgs), __slice.call(regularArgs)));
-      };
+      if (typeof block === "function") {
+        return function() {
+          return block.call.apply(block, [this].concat(__slice.call(curryArgs), __slice.call(arguments)));
+        };
+      } else if (typeof block.get === "function") {
+        return block.get.apply(block, curryArgs);
+      }
     },
-    routeToAction: buntUndefined(function(model, action) {
-      var params;
-      params = Batman.Dispatcher.paramsFromArgument(model);
-      params.action = action;
-      return params;
-    }),
     escape: buntUndefined(Batman.escapeHTML)
   };
 
@@ -13240,4 +14230,1455 @@
 (function() {
 
 
+}).call(this);
+
+/**
+ * Zest (https://github.com/chjj/zest)
+ * A css selector engine.
+ * Copyright (c) 2011-2012, Christopher Jeffrey. (MIT Licensed)
+ */
+
+// TODO
+// - Recognize the TR subject selector when parsing.
+// - Pass context to scope.
+// - Add :column pseudo-classes.
+
+;(function() {
+
+/**
+ * Shared
+ */
+
+var window = this
+  , document = this.document
+  , old = this.zest;
+
+/**
+ * Helpers
+ */
+
+var compareDocumentPosition = (function() {
+  if (document.compareDocumentPosition) {
+    return function(a, b) {
+      return a.compareDocumentPosition(b);
+    };
+  }
+  return function(a, b) {
+    var el = a.ownerDocument.getElementsByTagName('*')
+      , i = el.length;
+
+    while (i--) {
+      if (el[i] === a) return 2;
+      if (el[i] === b) return 4;
+    }
+
+    return 1;
+  };
+})();
+
+var order = function(a, b) {
+  return compareDocumentPosition(a, b) & 2 ? 1 : -1;
+};
+
+var next = function(el) {
+  while ((el = el.nextSibling)
+         && el.nodeType !== 1);
+  return el;
+};
+
+var prev = function(el) {
+  while ((el = el.previousSibling)
+         && el.nodeType !== 1);
+  return el;
+};
+
+var child = function(el) {
+  if (el = el.firstChild) {
+    while (el.nodeType !== 1
+           && (el = el.nextSibling));
+  }
+  return el;
+};
+
+var lastChild = function(el) {
+  if (el = el.lastChild) {
+    while (el.nodeType !== 1
+           && (el = el.previousSibling));
+  }
+  return el;
+};
+
+var unquote = function(str) {
+  if (!str) return str;
+  var ch = str[0];
+  return ch === '"' || ch === '\''
+    ? str.slice(1, -1)
+    : str;
+};
+
+var indexOf = (function() {
+  if (Array.prototype.indexOf) {
+    return Array.prototype.indexOf;
+  }
+  return function(obj, item) {
+    var i = this.length;
+    while (i--) {
+      if (this[i] === item) return i;
+    }
+    return -1;
+  };
+})();
+
+var makeInside = function(start, end) {
+  var regex = rules.inside.source
+    .replace(/</g, start)
+    .replace(/>/g, end);
+
+  return new RegExp(regex);
+};
+
+var replace = function(regex, name, val) {
+  regex = regex.source;
+  regex = regex.replace(name, val.source || val);
+  return new RegExp(regex);
+};
+
+var truncateUrl = function(url, num) {
+  return url
+    .replace(/^(?:\w+:\/\/|\/+)/, '')
+    .replace(/(?:\/+|\/*#.*?)$/, '')
+    .split('/', num)
+    .join('/');
+};
+
+/**
+ * Handle `nth` Selectors
+ */
+
+var parseNth = function(param, test) {
+  var param = param.replace(/\s+/g, '')
+    , cap;
+
+  if (param === 'even') {
+    param = '2n+0';
+  } else if (param === 'odd') {
+    param = '2n+1';
+  } else if (!~param.indexOf('n')) {
+    param = '0n' + param;
+  }
+
+  cap = /^([+-])?(\d+)?n([+-])?(\d+)?$/.exec(param);
+
+  return {
+    group: cap[1] === '-'
+      ? -(cap[2] || 1)
+      : +(cap[2] || 1),
+    offset: cap[4]
+      ? (cap[3] === '-' ? -cap[4] : +cap[4])
+      : 0
+  };
+};
+
+var nth = function(param, test, last) {
+  var param = parseNth(param)
+    , group = param.group
+    , offset = param.offset
+    , find = !last ? child : lastChild
+    , advance = !last ? next : prev;
+
+  return function(el) {
+    if (el.parentNode.nodeType !== 1) return;
+
+    var rel = find(el.parentNode)
+      , pos = 0;
+
+    while (rel) {
+      if (test(rel, el)) pos++;
+      if (rel === el) {
+        pos -= offset;
+        return group && pos
+          ? !(pos % group) && (pos < 0 === group < 0)
+          : !pos;
+      }
+      rel = advance(rel);
+    }
+  };
+};
+
+/**
+ * Simple Selectors
+ */
+
+var selectors = {
+  '*': (function() {
+    if (function() {
+      var el = document.createElement('div');
+      el.appendChild(document.createComment(''));
+      return !!el.getElementsByTagName('*')[0];
+    }()) {
+      return function(el) {
+        if (el.nodeType === 1) return true;
+      };
+    }
+    return function() {
+      return true;
+    };
+  })(),
+  'type': function(type) {
+    type = type.toLowerCase();
+    return function(el) {
+      return el.nodeName.toLowerCase() === type;
+    };
+  },
+  'attr': function(key, op, val, i) {
+    op = operators[op];
+    return function(el) {
+      var attr;
+      switch (key) {
+        case 'for':
+          attr = el.htmlFor;
+          break;
+        case 'class':
+          // className is '' when non-existent
+          // getAttribute('class') is null
+          attr = el.className;
+          if (attr === '' && el.getAttribute('class') == null) {
+            attr = null;
+          }
+          break;
+        case 'href':
+          attr = el.getAttribute('href', 2);
+          break;
+        case 'title':
+          // getAttribute('title') can be '' when non-existent sometimes?
+          attr = el.getAttribute('title') || null;
+          break;
+        case 'id':
+          if (el.getAttribute) {
+            attr = el.getAttribute('id');
+            break;
+          }
+        default:
+          attr = el[key] != null
+            ? el[key]
+            : el.getAttribute && el.getAttribute(key);
+          break;
+      }
+      if (attr == null) return;
+      attr = attr + '';
+      if (i) {
+        attr = attr.toLowerCase();
+        val = val.toLowerCase();
+      }
+      return op(attr, val);
+    };
+  },
+  ':first-child': function(el) {
+    return !prev(el) && el.parentNode.nodeType === 1;
+  },
+  ':last-child': function(el) {
+    return !next(el) && el.parentNode.nodeType === 1;
+  },
+  ':only-child': function(el) {
+    return !prev(el) && !next(el)
+      && el.parentNode.nodeType === 1;
+  },
+  ':nth-child': function(param, last) {
+    return nth(param, function() {
+      return true;
+    }, last);
+  },
+  ':nth-last-child': function(param) {
+    return selectors[':nth-child'](param, true);
+  },
+  ':root': function(el) {
+    return el.ownerDocument.documentElement === el;
+  },
+  ':empty': function(el) {
+    return !el.firstChild;
+  },
+  ':not': function(sel) {
+    var test = compileGroup(sel);
+    return function(el) {
+      return !test(el);
+    };
+  },
+  ':first-of-type': function(el) {
+    if (el.parentNode.nodeType !== 1) return;
+    var type = el.nodeName;
+    while (el = prev(el)) {
+      if (el.nodeName === type) return;
+    }
+    return true;
+  },
+  ':last-of-type': function(el) {
+    if (el.parentNode.nodeType !== 1) return;
+    var type = el.nodeName;
+    while (el = next(el)) {
+      if (el.nodeName === type) return;
+    }
+    return true;
+  },
+  ':only-of-type': function(el) {
+    return selectors[':first-of-type'](el)
+        && selectors[':last-of-type'](el);
+  },
+  ':nth-of-type': function(param, last) {
+    return nth(param, function(rel, el) {
+      return rel.nodeName === el.nodeName;
+    }, last);
+  },
+  ':nth-last-of-type': function(param) {
+    return selectors[':nth-of-type'](param, true);
+  },
+  ':checked': function(el) {
+    return !!(el.checked || el.selected);
+  },
+  ':indeterminate': function(el) {
+    return !selectors[':checked'](el);
+  },
+  ':enabled': function(el) {
+    return !el.disabled && el.type !== 'hidden';
+  },
+  ':disabled': function(el) {
+    return !!el.disabled;
+  },
+  ':target': function(el) {
+    return el.id === window.location.hash.substring(1);
+  },
+  ':focus': function(el) {
+    return el === el.ownerDocument.activeElement;
+  },
+  ':matches': function(sel) {
+    return compileGroup(sel);
+  },
+  ':nth-match': function(param, last) {
+    var args = param.split(/\s*,\s*/)
+      , arg = args.shift()
+      , test = compileGroup(args.join(','));
+
+    return nth(arg, test, last);
+  },
+  ':nth-last-match': function(param) {
+    return selectors[':nth-match'](param, true);
+  },
+  ':links-here': function(el) {
+    return el + '' === window.location + '';
+  },
+  ':lang': function(param) {
+    return function(el) {
+      while (el) {
+        if (el.lang) return el.lang.indexOf(param) === 0;
+        el = el.parentNode;
+      }
+    };
+  },
+  ':dir': function(param) {
+    return function(el) {
+      while (el) {
+        if (el.dir) return el.dir === param;
+        el = el.parentNode;
+      }
+    };
+  },
+  ':scope': function(el, con) {
+    var context = con || el.ownerDocument;
+    if (context.nodeType === 9) {
+      return el === context.documentElement;
+    }
+    return el === context;
+  },
+  ':any-link': function(el) {
+    return typeof el.href === 'string';
+  },
+  ':local-link': function(el) {
+    if (el.nodeName) {
+      return el.href && el.host === window.location.host;
+    }
+    var param = +el + 1;
+    return function(el) {
+      if (!el.href) return;
+
+      var url = window.location + ''
+        , href = el + '';
+
+      return truncateUrl(url, param) === truncateUrl(href, param);
+    };
+  },
+  ':default': function(el) {
+    return !!el.defaultSelected;
+  },
+  ':valid': function(el) {
+    return el.willValidate || (el.validity && el.validity.valid);
+  },
+  ':invalid': function(el) {
+    return !selectors[':valid'](el);
+  },
+  ':in-range': function(el) {
+    return el.value > el.min && el.value <= el.max;
+  },
+  ':out-of-range': function(el) {
+    return !selectors[':in-range'](el);
+  },
+  ':required': function(el) {
+    return !!el.required;
+  },
+  ':optional': function(el) {
+    return !el.required;
+  },
+  ':read-only': function(el) {
+    if (el.readOnly) return true;
+
+    var attr = el.getAttribute('contenteditable')
+      , prop = el.contentEditable
+      , name = el.nodeName.toLowerCase();
+
+    name = name !== 'input' && name !== 'textarea';
+
+    return (name || el.disabled) && attr == null && prop !== 'true';
+  },
+  ':read-write': function(el) {
+    return !selectors[':read-only'](el);
+  },
+  ':hover': function() {
+    throw new Error(':hover is not supported.');
+  },
+  ':active': function() {
+    throw new Error(':active is not supported.');
+  },
+  ':link': function() {
+    throw new Error(':link is not supported.');
+  },
+  ':visited': function() {
+    throw new Error(':visited is not supported.');
+  },
+  ':column': function() {
+    throw new Error(':column is not supported.');
+  },
+  ':nth-column': function() {
+    throw new Error(':nth-column is not supported.');
+  },
+  ':nth-last-column': function() {
+    throw new Error(':nth-last-column is not supported.');
+  },
+  ':current': function() {
+    throw new Error(':current is not supported.');
+  },
+  ':past': function() {
+    throw new Error(':past is not supported.');
+  },
+  ':future': function() {
+    throw new Error(':future is not supported.');
+  },
+  // Non-standard, for compatibility purposes.
+  ':contains': function(param) {
+    return function(el) {
+      var text = el.innerText || el.textContent || el.value || '';
+      return !!~text.indexOf(param);
+    };
+  },
+  ':has': function(param) {
+    return function(el) {
+      return zest(param, el).length > 0;
+    };
+  }
+  // Potentially add more pseudo selectors for
+  // compatibility with sizzle and most other
+  // selector engines (?).
+};
+
+/**
+ * Attribute Operators
+ */
+
+var operators = {
+  '-': function() {
+    return true;
+  },
+  '=': function(attr, val) {
+    return attr === val;
+  },
+  '*=': function(attr, val) {
+    return attr.indexOf(val) !== -1;
+  },
+  '~=': function(attr, val) {
+    var i = attr.indexOf(val)
+      , f
+      , l;
+
+    if (i === -1) return;
+    f = attr[i - 1];
+    l = attr[i + val.length];
+
+    return (!f || f === ' ') && (!l || l === ' ');
+  },
+  '|=': function(attr, val) {
+    var i = attr.indexOf(val)
+      , l;
+
+    if (i !== 0) return;
+    l = attr[i + val.length];
+
+    return l === '-' || !l;
+  },
+  '^=': function(attr, val) {
+    return attr.indexOf(val) === 0;
+  },
+  '$=': function(attr, val) {
+    return attr.indexOf(val) + val.length === attr.length;
+  },
+  // non-standard
+  '!=': function(attr, val) {
+    return attr !== val;
+  }
+};
+
+/**
+ * Combinator Logic
+ */
+
+var combinators = {
+  ' ': function(test) {
+    return function(el) {
+      while (el = el.parentNode) {
+        if (test(el)) return el;
+      }
+    };
+  },
+  '>': function(test) {
+    return function(el) {
+      return test(el = el.parentNode) && el;
+    };
+  },
+  '+': function(test) {
+    return function(el) {
+      return test(el = prev(el)) && el;
+    };
+  },
+  '~': function(test) {
+    return function(el) {
+      while (el = prev(el)) {
+        if (test(el)) return el;
+      }
+    };
+  },
+  'noop': function(test) {
+    return function(el) {
+      return test(el) && el;
+    };
+  },
+  'ref': function(test, name) {
+    var node;
+
+    function ref(el) {
+      var doc = el.ownerDocument
+        , nodes = doc.getElementsByTagName('*')
+        , i = nodes.length;
+
+      while (i--) {
+        node = nodes[i];
+        if (ref.test(el)) {
+          node = null;
+          return true;
+        }
+      }
+
+      node = null;
+    }
+
+    ref.combinator = function(el) {
+      if (!node || !node.getAttribute) return;
+
+      var attr = node.getAttribute(name) || '';
+      if (attr[0] === '#') attr = attr.substring(1);
+
+      if (attr === el.id && test(node)) {
+        return node;
+      }
+    };
+
+    return ref;
+  }
+};
+
+/**
+ * Grammar
+ */
+
+var rules = {
+  qname: /^ *([\w\-]+|\*)/,
+  simple: /^(?:([.#][\w\-]+)|pseudo|attr)/,
+  ref: /^ *\/([\w\-]+)\/ */,
+  combinator: /^(?: +([^ \w*]) +|( )+|([^ \w*]))(?! *$)/,
+  attr: /^\[([\w\-]+)(?:([^\w]?=)(inside))?\]/,
+  pseudo: /^(:[\w\-]+)(?:\((inside)\))?/,
+  inside: /(?:"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|<[^"'>]*>|\\["'>]|[^"'>])*/
+};
+
+rules.inside = replace(rules.inside, '[^"\'>]*', rules.inside);
+rules.attr = replace(rules.attr, 'inside', makeInside('\\[', '\\]'));
+rules.pseudo = replace(rules.pseudo, 'inside', makeInside('\\(', '\\)'));
+rules.simple = replace(rules.simple, 'pseudo', rules.pseudo);
+rules.simple = replace(rules.simple, 'attr', rules.attr);
+
+/**
+ * Compiling
+ */
+
+var compile = function(sel) {
+  var sel = sel.replace(/^\s+|\s+$/g, '')
+    , test
+    , filter = []
+    , buff = []
+    , subject
+    , qname
+    , cap
+    , op
+    , ref;
+
+  while (sel) {
+    if (cap = rules.qname.exec(sel)) {
+      sel = sel.substring(cap[0].length);
+      qname = cap[1];
+      buff.push(tok(qname, true));
+    } else if (cap = rules.simple.exec(sel)) {
+      sel = sel.substring(cap[0].length);
+      qname = '*';
+      buff.push(tok(qname, true));
+      buff.push(tok(cap));
+    } else {
+      throw new Error('Invalid selector.');
+    }
+
+    while (cap = rules.simple.exec(sel)) {
+      sel = sel.substring(cap[0].length);
+      buff.push(tok(cap));
+    }
+
+    if (sel[0] === '!') {
+      sel = sel.substring(1);
+      subject = makeSubject();
+      subject.qname = qname;
+      buff.push(subject.simple);
+    }
+
+    if (cap = rules.ref.exec(sel)) {
+      sel = sel.substring(cap[0].length);
+      ref = combinators.ref(makeSimple(buff), cap[1]);
+      filter.push(ref.combinator);
+      buff = [];
+      continue;
+    }
+
+    if (cap = rules.combinator.exec(sel)) {
+      sel = sel.substring(cap[0].length);
+      op = cap[1] || cap[2] || cap[3];
+      if (op === ',') {
+        filter.push(combinators.noop(makeSimple(buff)));
+        break;
+      }
+    } else {
+      op = 'noop';
+    }
+
+    filter.push(combinators[op](makeSimple(buff)));
+    buff = [];
+  }
+
+  test = makeTest(filter);
+  test.qname = qname;
+  test.sel = sel;
+
+  if (subject) {
+    subject.lname = test.qname;
+
+    subject.test = test;
+    subject.qname = subject.qname;
+    subject.sel = test.sel;
+    test = subject;
+  }
+
+  if (ref) {
+    ref.test = test;
+    ref.qname = test.qname;
+    ref.sel = test.sel;
+    test = ref;
+  }
+
+  return test;
+};
+
+var tok = function(cap, qname) {
+  // qname
+  if (qname) {
+    return cap === '*'
+      ? selectors['*']
+      : selectors.type(cap);
+  }
+
+  // class/id
+  if (cap[1]) {
+    return cap[1][0] === '.'
+      ? selectors.attr('class', '~=', cap[1].substring(1))
+      : selectors.attr('id', '=', cap[1].substring(1));
+  }
+
+  // pseudo-name
+  // inside-pseudo
+  if (cap[2]) {
+    return cap[3]
+      ? selectors[cap[2]](unquote(cap[3]))
+      : selectors[cap[2]];
+  }
+
+  // attr name
+  // attr op
+  // attr value
+  if (cap[4]) {
+    var i;
+    if (cap[6]) {
+      i = cap[6].length;
+      cap[6] = cap[6].replace(/ +i$/, '');
+      i = i > cap[6].length;
+    }
+    return selectors.attr(cap[4], cap[5] || '-', unquote(cap[6]), i);
+  }
+
+  throw new Error('Unknown Selector.');
+};
+
+var makeSimple = function(func) {
+  var l = func.length
+    , i;
+
+  // Potentially make sure
+  // `el` is truthy.
+  if (l < 2) return func[0];
+
+  return function(el) {
+    if (!el) return;
+    for (i = 0; i < l; i++) {
+      if (!func[i](el)) return;
+    }
+    return true;
+  };
+};
+
+var makeTest = function(func) {
+  if (func.length < 2) {
+    return function(el) {
+      return !!func[0](el);
+    };
+  }
+  return function(el) {
+    var i = func.length;
+    while (i--) {
+      if (!(el = func[i](el))) return;
+    }
+    return true;
+  };
+};
+
+var makeSubject = function() {
+  var target;
+
+  function subject(el) {
+    var node = el.ownerDocument
+      , scope = node.getElementsByTagName(subject.lname)
+      , i = scope.length;
+
+    while (i--) {
+      if (subject.test(scope[i]) && target === el) {
+        target = null;
+        return true;
+      }
+    }
+
+    target = null;
+  }
+
+  subject.simple = function(el) {
+    target = el;
+    return true;
+  };
+
+  return subject;
+};
+
+var compileGroup = function(sel) {
+  var test = compile(sel)
+    , tests = [ test ];
+
+  while (test.sel) {
+    test = compile(test.sel);
+    tests.push(test);
+  }
+
+  if (tests.length < 2) return test;
+
+  return function(el) {
+    var l = tests.length
+      , i = 0;
+
+    for (; i < l; i++) {
+      if (tests[i](el)) return true;
+    }
+  };
+};
+
+/**
+ * Selection
+ */
+
+var find = function(sel, node) {
+  var results = []
+    , test = compile(sel)
+    , scope = node.getElementsByTagName(test.qname)
+    , i = 0
+    , el;
+
+  while (el = scope[i++]) {
+    if (test(el)) results.push(el);
+  }
+
+  if (test.sel) {
+    while (test.sel) {
+      test = compile(test.sel);
+      scope = node.getElementsByTagName(test.qname);
+      i = 0;
+      while (el = scope[i++]) {
+        if (test(el) && !~indexOf.call(results, el)) {
+          results.push(el);
+        }
+      }
+    }
+    results.sort(order);
+  }
+
+  return results;
+};
+
+/**
+ * Native
+ */
+
+var select = (function() {
+  var slice = (function() {
+    try {
+      Array.prototype.slice.call(document.getElementsByTagName('zest'));
+      return Array.prototype.slice;
+    } catch(e) {
+      e = null;
+      return function() {
+        var a = [], i = 0, l = this.length;
+        for (; i < l; i++) a.push(this[i]);
+        return a;
+      };
+    }
+  })();
+
+  if (document.querySelectorAll) {
+    return function(sel, node) {
+      try {
+        return slice.call(node.querySelectorAll(sel));
+      } catch(e) {
+        return find(sel, node);
+      }
+    };
+  }
+
+  return function(sel, node) {
+    try {
+      if (sel[0] === '#' && /^#[\w\-]+$/.test(sel)) {
+        return [node.getElementById(sel.substring(1))];
+      }
+      if (sel[0] === '.' && /^\.[\w\-]+$/.test(sel)) {
+        sel = node.getElementsByClassName(sel.substring(1));
+        return slice.call(sel);
+      }
+      if (/^[\w\-]+$/.test(sel)) {
+        return slice.call(node.getElementsByTagName(sel));
+      }
+    } catch(e) {
+      ;
+    }
+    return find(sel, node);
+  };
+})();
+
+/**
+ * Zest
+ */
+
+var zest = function(sel, node) {
+  try {
+    sel = select(sel, node || document);
+  } catch(e) {
+    if (window.ZEST_DEBUG) {
+      console.log(e.stack || e + '');
+    }
+    sel = [];
+  }
+  return sel;
+};
+
+/**
+ * Expose
+ */
+
+zest.selectors = selectors;
+zest.operators = operators;
+zest.combinators = combinators;
+zest.compile = compileGroup;
+
+zest.matches = function(el, sel) {
+  return !!compileGroup(sel)(el);
+};
+
+zest.cache = function() {
+  if (compile.raw) return;
+
+  var raw = compile
+    , cache = {};
+
+  compile = function(sel) {
+    return cache[sel]
+      || (cache[sel] = raw(sel));
+  };
+
+  compile.raw = raw;
+  zest._cache = cache;
+};
+
+zest.noCache = function() {
+  if (!compile.raw) return;
+  compile = compile.raw;
+  delete zest._cache;
+};
+
+zest.noConflict = function() {
+  window.zest = old;
+  return zest;
+};
+
+zest.noNative = function() {
+  select = find;
+};
+
+if (typeof module !== 'undefined') {
+  module.exports = zest;
+} else {
+  this.zest = zest;
+}
+
+if (window.ZEST_DEBUG) {
+  zest.noNative();
+} else {
+  zest.cache();
+}
+
+}).call(function() {
+  return this || (typeof window !== 'undefined' ? window : global);
+}());
+
+/*!
+  * Reqwest! A general purpose XHR connection manager
+  * (c) Dustin Diaz 2011
+  * https://github.com/ded/reqwest
+  * license MIT
+  */
+!function (name, definition) {
+  if (typeof module != 'undefined') module.exports = definition()
+  else if (typeof define == 'function' && define.amd) define(name, definition)
+  else this[name] = definition()
+}('reqwest', function () {
+
+  var context = this
+    , win = window
+    , doc = document
+    , old = context.reqwest
+    , twoHundo = /^20\d$/
+    , byTag = 'getElementsByTagName'
+    , readyState = 'readyState'
+    , contentType = 'Content-Type'
+    , requestedWith = 'X-Requested-With'
+    , head = doc[byTag]('head')[0]
+    , uniqid = 0
+    , lastValue // data stored by the most recent JSONP callback
+    , xmlHttpRequest = 'XMLHttpRequest'
+    , isArray = typeof Array.isArray == 'function' ? Array.isArray : function (a) {
+        return a instanceof Array
+      }
+    , defaultHeaders = {
+          contentType: 'application/x-www-form-urlencoded'
+        , accept: {
+              '*':  'text/javascript, text/html, application/xml, text/xml, */*'
+            , xml:  'application/xml, text/xml'
+            , html: 'text/html'
+            , text: 'text/plain'
+            , json: 'application/json, text/javascript'
+            , js:   'application/javascript, text/javascript'
+          }
+        , requestedWith: xmlHttpRequest
+      }
+    , xhr = win[xmlHttpRequest] ?
+        function () {
+          return new XMLHttpRequest()
+        } :
+        function () {
+          return new ActiveXObject('Microsoft.XMLHTTP')
+        }
+
+  function handleReadyState(o, success, error) {
+    return function () {
+      if (o && o[readyState] == 4) {
+        if (twoHundo.test(o.status)) {
+          success(o)
+        } else {
+          error(o)
+        }
+      }
+    }
+  }
+
+  function setHeaders(http, o) {
+    var headers = o.headers || {}, h
+    headers.Accept = headers.Accept || defaultHeaders.accept[o.type] || defaultHeaders.accept['*']
+    // breaks cross-origin requests with legacy browsers
+    if (!o.crossOrigin && !headers[requestedWith]) headers[requestedWith] = defaultHeaders.requestedWith
+    if (!headers[contentType]) headers[contentType] = o.contentType || defaultHeaders.contentType
+    for (h in headers) {
+      headers.hasOwnProperty(h) && http.setRequestHeader(h, headers[h])
+    }
+  }
+
+  function generalCallback(data) {
+    lastValue = data
+  }
+
+  function urlappend(url, s) {
+    return url + (/\?/.test(url) ? '&' : '?') + s
+  }
+
+  function handleJsonp(o, fn, err, url) {
+    var reqId = uniqid++
+      , cbkey = o.jsonpCallback || 'callback' // the 'callback' key
+      , cbval = o.jsonpCallbackName || ('reqwest_' + reqId) // the 'callback' value
+      , cbreg = new RegExp('((^|\\?|&)' + cbkey + ')=([^&]+)')
+      , match = url.match(cbreg)
+      , script = doc.createElement('script')
+      , loaded = 0
+
+    if (match) {
+      if (match[3] === '?') {
+        url = url.replace(cbreg, '$1=' + cbval) // wildcard callback func name
+      } else {
+        cbval = match[3] // provided callback func name
+      }
+    } else {
+      url = urlappend(url, cbkey + '=' + cbval) // no callback details, add 'em
+    }
+
+    win[cbval] = generalCallback
+
+    script.type = 'text/javascript'
+    script.src = url
+    script.async = true
+    if (typeof script.onreadystatechange !== 'undefined') {
+        // need this for IE due to out-of-order onreadystatechange(), binding script
+        // execution to an event listener gives us control over when the script
+        // is executed. See http://jaubourg.net/2010/07/loading-script-as-onclick-handler-of.html
+        script.event = 'onclick'
+        script.htmlFor = script.id = '_reqwest_' + reqId
+    }
+
+    script.onload = script.onreadystatechange = function () {
+      if ((script[readyState] && script[readyState] !== 'complete' && script[readyState] !== 'loaded') || loaded) {
+        return false
+      }
+      script.onload = script.onreadystatechange = null
+      script.onclick && script.onclick()
+      // Call the user callback with the last value stored and clean up values and scripts.
+      o.success && o.success(lastValue)
+      lastValue = undefined
+      head.removeChild(script)
+      loaded = 1
+    }
+
+    // Add the script to the DOM head
+    head.appendChild(script)
+  }
+
+  function getRequest(o, fn, err) {
+    var method = (o.method || 'GET').toUpperCase()
+      , url = typeof o === 'string' ? o : o.url
+      // convert non-string objects to query-string form unless o.processData is false
+      , data = (o.processData !== false && o.data && typeof o.data !== 'string')
+        ? reqwest.toQueryString(o.data)
+        : (o.data || null)
+      , http
+
+    // if we're working on a GET request and we have data then we should append
+    // query string to end of URL and not post data
+    if ((o.type == 'jsonp' || method == 'GET') && data) {
+      url = urlappend(url, data)
+      data = null
+    }
+
+    if (o.type == 'jsonp') return handleJsonp(o, fn, err, url)
+
+    http = xhr()
+    http.open(method, url, true)
+    setHeaders(http, o)
+    http.onreadystatechange = handleReadyState(http, fn, err)
+    o.before && o.before(http)
+    http.send(data)
+    return http
+  }
+
+  function Reqwest(o, fn) {
+    this.o = o
+    this.fn = fn
+    init.apply(this, arguments)
+  }
+
+  function setType(url) {
+    var m = url.match(/\.(json|jsonp|html|xml)(\?|$)/)
+    return m ? m[1] : 'js'
+  }
+
+  function init(o, fn) {
+    this.url = typeof o == 'string' ? o : o.url
+    this.timeout = null
+    var type = o.type || setType(this.url)
+      , self = this
+    fn = fn || function () {}
+
+    if (o.timeout) {
+      this.timeout = setTimeout(function () {
+        self.abort()
+      }, o.timeout)
+    }
+
+    function complete(resp) {
+      o.timeout && clearTimeout(self.timeout)
+      self.timeout = null
+      o.complete && o.complete(resp)
+    }
+
+    function success(resp) {
+      var r = resp.responseText
+      if (r) {
+        switch (type) {
+        case 'json':
+          try {
+            resp = win.JSON ? win.JSON.parse(r) : eval('(' + r + ')')
+          } catch (err) {
+            return error(resp, 'Could not parse JSON in response', err)
+          }
+          break;
+        case 'js':
+          resp = eval(r)
+          break;
+        case 'html':
+          resp = r
+          break;
+        }
+      }
+
+      fn(resp)
+      o.success && o.success(resp)
+
+      complete(resp)
+    }
+
+    function error(resp, msg, t) {
+      o.error && o.error(resp, msg, t)
+      complete(resp)
+    }
+
+    this.request = getRequest(o, success, error)
+  }
+
+  Reqwest.prototype = {
+    abort: function () {
+      this.request.abort()
+    }
+
+  , retry: function () {
+      init.call(this, this.o, this.fn)
+    }
+  }
+
+  function reqwest(o, fn) {
+    return new Reqwest(o, fn)
+  }
+
+  // normalize newline variants according to spec -> CRLF
+  function normalize(s) {
+    return s ? s.replace(/\r?\n/g, '\r\n') : ''
+  }
+
+  function serial(el, cb) {
+    var n = el.name
+      , t = el.tagName.toLowerCase()
+      , optCb = function(o) {
+          // IE gives value="" even where there is no value attribute
+          // 'specified' ref: http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-862529273
+          if (o && !o.disabled)
+            cb(n, normalize(o.attributes.value && o.attributes.value.specified ? o.value : o.text))
+        }
+
+    // don't serialize elements that are disabled or without a name
+    if (el.disabled || !n) return;
+
+    switch (t) {
+    case 'input':
+      if (!/reset|button|image|file/i.test(el.type)) {
+        var ch = /checkbox/i.test(el.type)
+          , ra = /radio/i.test(el.type)
+          , val = el.value;
+        // WebKit gives us "" instead of "on" if a checkbox has no value, so correct it here
+        (!(ch || ra) || el.checked) && cb(n, normalize(ch && val === '' ? 'on' : val))
+      }
+      break;
+    case 'textarea':
+      cb(n, normalize(el.value))
+      break;
+    case 'select':
+      if (el.type.toLowerCase() === 'select-one') {
+        optCb(el.selectedIndex >= 0 ? el.options[el.selectedIndex] : null)
+      } else {
+        for (var i = 0; el.length && i < el.length; i++) {
+          el.options[i].selected && optCb(el.options[i])
+        }
+      }
+      break;
+    }
+  }
+
+  // collect up all form elements found from the passed argument elements all
+  // the way down to child elements; pass a '<form>' or form fields.
+  // called with 'this'=callback to use for serial() on each element
+  function eachFormElement() {
+    var cb = this
+      , e, i, j
+      , serializeSubtags = function(e, tags) {
+        for (var i = 0; i < tags.length; i++) {
+          var fa = e[byTag](tags[i])
+          for (j = 0; j < fa.length; j++) serial(fa[j], cb)
+        }
+      }
+
+    for (i = 0; i < arguments.length; i++) {
+      e = arguments[i]
+      if (/input|select|textarea/i.test(e.tagName)) serial(e, cb)
+      serializeSubtags(e, [ 'input', 'select', 'textarea' ])
+    }
+  }
+
+  // standard query string style serialization
+  function serializeQueryString() {
+    return reqwest.toQueryString(reqwest.serializeArray.apply(null, arguments))
+  }
+
+  // { 'name': 'value', ... } style serialization
+  function serializeHash() {
+    var hash = {}
+    eachFormElement.apply(function (name, value) {
+      if (name in hash) {
+        hash[name] && !isArray(hash[name]) && (hash[name] = [hash[name]])
+        hash[name].push(value)
+      } else hash[name] = value
+    }, arguments)
+    return hash
+  }
+
+  // [ { name: 'name', value: 'value' }, ... ] style serialization
+  reqwest.serializeArray = function () {
+    var arr = []
+    eachFormElement.apply(function(name, value) {
+      arr.push({name: name, value: value})
+    }, arguments)
+    return arr
+  }
+
+  reqwest.serialize = function () {
+    if (arguments.length === 0) return ''
+    var opt, fn
+      , args = Array.prototype.slice.call(arguments, 0)
+
+    opt = args.pop()
+    opt && opt.nodeType && args.push(opt) && (opt = null)
+    opt && (opt = opt.type)
+
+    if (opt == 'map') fn = serializeHash
+    else if (opt == 'array') fn = reqwest.serializeArray
+    else fn = serializeQueryString
+
+    return fn.apply(null, args)
+  }
+
+  reqwest.toQueryString = function (o) {
+    var qs = '', i
+      , enc = encodeURIComponent
+      , push = function (k, v) {
+          qs += enc(k) + '=' + enc(v) + '&'
+        }
+
+    if (isArray(o)) {
+      for (i = 0; o && i < o.length; i++) push(o[i].name, o[i].value)
+    } else {
+      for (var k in o) {
+        if (!Object.hasOwnProperty.call(o, k)) continue;
+        var v = o[k]
+        if (isArray(v)) {
+          for (i = 0; i < v.length; i++) push(k, v[i])
+        } else push(k, o[k])
+      }
+    }
+
+    // spaces should be + according to spec
+    return qs.replace(/&$/, '').replace(/%20/g,'+')
+  }
+
+  // jQuery and Zepto compatibility, differences can be remapped here so you can call
+  // .ajax.compat(options, callback)
+  reqwest.compat = function (o, fn) {
+    if (o) {
+      o.type && (o.method = o.type) && delete o.type
+      o.dataType && (o.type = o.dataType)
+      o.jsonpCallback && (o.jsonpCallbackName = o.jsonpCallback) && delete o.jsonpCallback
+      o.jsonp && (o.jsonpCallback = o.jsonp)
+    }
+    return new Reqwest(o, fn)
+  }
+
+  return reqwest
+});
+
+(function() {
+  var SAFARI_CONTAINS_IS_BROKEN, version;
+
+  if (/Safari/.test(navigator.userAgent)) {
+    version = /WebKit\/(\S+)/.exec(navigator.userAgent);
+    if (version && parseFloat(version) < 540) {
+      SAFARI_CONTAINS_IS_BROKEN = true;
+    }
+  }
+
+  (typeof window !== "undefined" && window !== null ? window : global).containsNode = function(parent, child) {
+    if (parent === child) {
+      return true;
+    }
+    if (parent.contains && !SAFARI_CONTAINS_IS_BROKEN) {
+      return parent.contains(child);
+    }
+    if (parent.compareDocumentPosition) {
+      return !!(parent.compareDocumentPosition(child) & 16);
+    }
+    while (child && parent !== child) {
+      child = child.parentNode;
+    }
+    return child === parent;
+  };
+
+}).call(this);
+
+(function() {
+  Batman.extend(Batman.DOM, {
+    querySelectorAll: function(node, selector) {
+      return zest(selector, node);
+    },
+    querySelector: function(node, selector) {
+      return zest(selector, node)[0];
+    },
+    setInnerHTML: function(node, html) {
+      return node != null ? node.innerHTML = html : void 0;
+    },
+    containsNode: function(parent, child) {
+      if (!child) {
+        child = parent;
+        parent = document.body;
+      }
+      return window.containsNode(parent, child);
+    },
+    textContent: function(node) {
+      var _ref;
+      return (_ref = node.textContent) != null ? _ref : node.innerText;
+    },
+    destroyNode: function(node) {
+      var _ref;
+      Batman.DOM.cleanupNode(node);
+      return node != null ? (_ref = node.parentNode) != null ? _ref.removeChild(node) : void 0 : void 0;
+    }
+  });
+
+  Batman.extend(Batman.Request.prototype, {
+    _parseResponseHeaders: function(xhr) {
+      var headers;
+      return headers = xhr.getAllResponseHeaders().split('\n').reduce(function(acc, header) {
+        var key, matches, value;
+        if (matches = header.match(/([^:]*):\s*(.*)/)) {
+          key = matches[1];
+          value = matches[2];
+          acc[key] = value;
+        }
+        return acc;
+      }, {});
+    },
+    send: function(data) {
+      var options, xhr, _ref,
+        _this = this;
+      if (data == null) {
+        data = this.get('data');
+      }
+      this.fire('loading');
+      options = {
+        url: this.get('url'),
+        method: this.get('method'),
+        type: this.get('type'),
+        headers: this.get('headers'),
+        success: function(response) {
+          _this.mixin({
+            xhr: xhr,
+            response: response,
+            status: typeof xhr !== "undefined" && xhr !== null ? xhr.status : void 0,
+            responseHeaders: _this._parseResponseHeaders(xhr)
+          });
+          return _this.fire('success', response);
+        },
+        error: function(xhr) {
+          _this.mixin({
+            xhr: xhr,
+            response: xhr.responseText || xhr.content,
+            status: xhr.status,
+            responseHeaders: _this._parseResponseHeaders(xhr)
+          });
+          xhr.request = _this;
+          return _this.fire('error', xhr);
+        },
+        complete: function() {
+          return _this.fire('loaded');
+        }
+      };
+      if ((_ref = options.method) === 'PUT' || _ref === 'POST') {
+        if (this.hasFileUploads()) {
+          options.data = this.constructor.objectToFormData(data);
+        } else {
+          options.contentType = this.get('contentType');
+          options.data = Batman.URI.queryFromParams(data);
+        }
+      } else {
+        options.data = data;
+      }
+      return xhr = (reqwest(options)).request;
+    }
+  });
+
+}).call(this);
+
+(function() {
+
+
 }).call(this);