batman-rails 0.0.8 → 0.0.9

data/lib/batman/rails/version.rb

@@ -1,6 +1,6 @@
 module Batman
   module Rails
-    VERSION = "0.0.8"
-    BATMAN_VERSION = "0.12.0"
+    VERSION = "0.0.9"
+    BATMAN_VERSION = "0.13.1"
   end
 end

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

@@ -1,5 +1,57 @@
 (function() {
 
+  Batman.extend(Batman.DOM, {
+    querySelectorAll: function(node, selector) {
+      return jQuery(selector, node);
+    },
+    querySelector: function(node, selector) {
+      return jQuery(selector, node)[0];
+    },
+    setInnerHTML: function(node, html) {
+      var child, childNodes, result, _i, _j, _len, _len1;
+      childNodes = (function() {
+        var _i, _len, _ref, _results;
+        _ref = node.childNodes;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          child = _ref[_i];
+          _results.push(child);
+        }
+        return _results;
+      })();
+      for (_i = 0, _len = childNodes.length; _i < _len; _i++) {
+        child = childNodes[_i];
+        Batman.DOM.willRemoveNode(child);
+      }
+      result = jQuery(node).html(html);
+      for (_j = 0, _len1 = childNodes.length; _j < _len1; _j++) {
+        child = childNodes[_j];
+        Batman.DOM.didRemoveNode(child);
+      }
+      return result;
+    },
+    removeNode: function(node) {
+      var _ref;
+      Batman.DOM.willRemoveNode(node);
+      if ((_ref = node.parentNode) != null) {
+        _ref.removeChild(node);
+      }
+      return Batman.DOM.didRemoveNode(node);
+    },
+    destroyNode: function(node) {
+      Batman.DOM.willDestroyNode(node);
+      Batman.DOM.willRemoveNode(node);
+      jQuery(node).remove();
+      Batman.DOM.didRemoveNode(node);
+      return Batman.DOM.didDestroyNode(node);
+    },
+    appendChild: function(parent, child) {
+      Batman.DOM.willInsertNode(child);
+      jQuery(parent).append(child);
+      return Batman.DOM.didInsertNode(child);
+    }
+  });
+
   Batman.Request.prototype._parseResponseHeaders = function(xhr) {
     var headers;
     return headers = xhr.getAllResponseHeaders().split('\n').reduce(function(acc, header) {

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

@@ -12,7 +12,7 @@
     })(Batman.Object, mixins, function(){});
   };
 
-  Batman.version = '0.10.0';
+  Batman.version = '0.13.0';
 
   Batman.config = {
     pathPrefix: '/',
@@ -2269,20 +2269,6 @@
       var _ref;
       return (_ref = document.getElementById(elementID)) != null ? typeof _ref.scrollIntoView === "function" ? _ref.scrollIntoView() : void 0 : void 0;
     },
-    querySelectorAll: (typeof window !== "undefined" && window !== null ? window.jQuery : void 0) != null ? function(node, selector) {
-      return jQuery(selector, node);
-    } : (typeof document !== "undefined" && document !== null ? document.querySelectorAll : void 0) != null ? function(node, selector) {
-      return node.querySelectorAll(selector);
-    } : function() {
-      return Batman.developer.error("Please include either jQuery or a querySelectorAll polyfill, or set Batman.DOM.querySelectorAll to return an empty array.");
-    },
-    querySelector: (typeof window !== "undefined" && window !== null ? window.jQuery : void 0) != null ? function(node, selector) {
-      return jQuery(selector, node)[0];
-    } : (typeof document !== "undefined" && document !== null ? document.querySelector : void 0) != null ? function(node, selector) {
-      return node.querySelector(selector);
-    } : function() {
-      return Batman.developer.error("Please include either jQuery or a querySelector polyfill, or set Batman.DOM.querySelector to an empty function.");
-    },
     partial: function(container, path, context, renderer) {
       var view;
       renderer.prevent('rendered');
@@ -2291,12 +2277,12 @@
         context: context
       });
       return view.on('ready', function() {
-        Batman.setInnerHTML(container, '');
-        Batman.appendChild(container, view.get('node'));
+        Batman.DOM.setInnerHTML(container, '');
+        Batman.DOM.appendChild(container, view.get('node'));
         return renderer.allowAndFire('rendered');
       });
     },
-    propagateBindingEvent: Batman.propagateBindingEvent = function(binding, node) {
+    propagateBindingEvent: function(binding, node) {
       var current, parentBinding, parentBindings, _i, _len;
       while ((current = (current || node).parentNode)) {
         parentBindings = Batman._data(current, 'bindings');
@@ -2310,21 +2296,21 @@
         }
       }
     },
-    propagateBindingEvents: Batman.propagateBindingEvents = function(newNode) {
+    propagateBindingEvents: function(newNode) {
       var binding, bindings, child, _i, _j, _len, _len1, _ref;
       _ref = newNode.childNodes;
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         child = _ref[_i];
-        Batman.propagateBindingEvents(child);
+        Batman.DOM.propagateBindingEvents(child);
       }
       if (bindings = Batman._data(newNode, 'bindings')) {
         for (_j = 0, _len1 = bindings.length; _j < _len1; _j++) {
           binding = bindings[_j];
-          Batman.propagateBindingEvent(binding, newNode);
+          Batman.DOM.propagateBindingEvent(binding, newNode);
         }
       }
     },
-    trackBinding: Batman.trackBinding = function(binding, node) {
+    trackBinding: function(binding, node) {
       var bindings;
       if (bindings = Batman._data(node, 'bindings')) {
         bindings.push(binding);
@@ -2332,10 +2318,10 @@
         Batman._data(node, 'bindings', [binding]);
       }
       Batman.DOM.fire('bindingAdded', binding);
-      Batman.propagateBindingEvent(binding, node);
+      Batman.DOM.propagateBindingEvent(binding, node);
       return true;
     },
-    onParseExit: Batman.onParseExit = function(node, callback) {
+    onParseExit: function(node, callback) {
       var set;
       set = Batman._data(node, 'onParseExit') || Batman._data(node, 'onParseExit', new Batman.SimpleSet);
       if (callback != null) {
@@ -2343,7 +2329,7 @@
       }
       return set;
     },
-    forgetParseExit: Batman.forgetParseExit = function(node, callback) {
+    forgetParseExit: function(node, callback) {
       return Batman.removeData(node, 'onParseExit', true);
     },
     defineView: function(name, node) {
@@ -2352,55 +2338,14 @@
       Batman.View.store.set(Batman.Navigator.normalizePath(name), contents);
       return contents;
     },
-    setInnerHTML: Batman.setInnerHTML = function(node, html) {
-      var child, childNodes, result, _i, _j, _len, _len1;
-      childNodes = (function() {
-        var _i, _len, _ref, _results;
-        _ref = node.childNodes;
-        _results = [];
-        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-          child = _ref[_i];
-          _results.push(child);
-        }
-        return _results;
-      })();
-      for (_i = 0, _len = childNodes.length; _i < _len; _i++) {
-        child = childNodes[_i];
-        Batman.DOM.willRemoveNode(child);
-      }
-      result = node.innerHTML = html;
-      for (_j = 0, _len1 = childNodes.length; _j < _len1; _j++) {
-        child = childNodes[_j];
-        Batman.DOM.didRemoveNode(child);
-      }
-      return result;
-    },
-    setStyleProperty: Batman.setStyleProperty = function(node, property, value, importance) {
+    setStyleProperty: function(node, property, value, importance) {
       if (node.style.setAttribute) {
         return node.style.setAttribute(property, value, importance);
       } else {
         return node.style.setProperty(property, value, importance);
       }
     },
-    removeNode: Batman.removeNode = function(node) {
-      var _ref;
-      Batman.DOM.willRemoveNode(node);
-      if ((_ref = node.parentNode) != null) {
-        _ref.removeChild(node);
-      }
-      return Batman.DOM.didRemoveNode(node);
-    },
-    destroyNode: Batman.destroyNode = function(node) {
-      Batman.DOM.willDestroyNode(node);
-      Batman.removeNode(node);
-      return Batman.DOM.didDestroyNode(node);
-    },
-    appendChild: Batman.appendChild = function(parent, child) {
-      Batman.DOM.willInsertNode(child);
-      parent.appendChild(child);
-      return Batman.DOM.didInsertNode(child);
-    },
-    removeOrDestroyNode: Batman.removeOrDestroyNode = function(node) {
+    removeOrDestroyNode: function(node) {
       var view;
       view = Batman._data(node, 'view');
       view || (view = Batman._data(node, 'yielder'));
@@ -2410,12 +2355,12 @@
         return Batman.DOM.destroyNode(node);
       }
     },
-    insertBefore: Batman.insertBefore = function(parentNode, newNode, referenceNode) {
+    insertBefore: function(parentNode, newNode, referenceNode) {
       if (referenceNode == null) {
         referenceNode = null;
       }
       if (!referenceNode || parentNode.childNodes.length <= 0) {
-        return Batman.appendChild(parentNode, newNode);
+        return Batman.DOM.appendChild(parentNode, newNode);
       } else {
         Batman.DOM.willInsertNode(newNode);
         parentNode.insertBefore(newNode, referenceNode);
@@ -2447,7 +2392,7 @@
           break;
         default:
           if (isSetting) {
-            return Batman.setInnerHTML(node, escapeValue ? Batman.escapeHTML(value) : value);
+            return Batman.DOM.setInnerHTML(node, escapeValue ? Batman.escapeHTML(value) : value);
           } else {
             return node.innerHTML;
           }
@@ -2457,7 +2402,7 @@
       var _ref;
       return (_ref = node.nodeName.toUpperCase()) === 'INPUT' || _ref === 'TEXTAREA' || _ref === 'SELECT';
     },
-    addEventListener: Batman.addEventListener = function(node, eventName, callback) {
+    addEventListener: function(node, eventName, callback) {
       var listeners;
       if (!(listeners = Batman._data(node, 'listeners'))) {
         listeners = Batman._data(node, 'listeners', {});
@@ -2466,13 +2411,13 @@
         listeners[eventName] = [];
       }
       listeners[eventName].push(callback);
-      if (Batman.hasAddEventListener) {
+      if (Batman.DOM.hasAddEventListener) {
         return node.addEventListener(eventName, callback, false);
       } else {
         return node.attachEvent("on" + eventName, callback);
       }
     },
-    removeEventListener: Batman.removeEventListener = function(node, eventName, callback) {
+    removeEventListener: function(node, eventName, callback) {
       var eventListeners, index, listeners;
       if (listeners = Batman._data(node, 'listeners')) {
         if (eventListeners = listeners[eventName]) {
@@ -2482,21 +2427,21 @@
           }
         }
       }
-      if (Batman.hasAddEventListener) {
+      if (Batman.DOM.hasAddEventListener) {
         return node.removeEventListener(eventName, callback, false);
       } else {
         return node.detachEvent('on' + eventName, callback);
       }
     },
-    hasAddEventListener: Batman.hasAddEventListener = !!(typeof window !== "undefined" && window !== null ? window.addEventListener : void 0),
-    preventDefault: Batman.preventDefault = function(e) {
+    hasAddEventListener: !!(typeof window !== "undefined" && window !== null ? window.addEventListener : void 0),
+    preventDefault: function(e) {
       if (typeof e.preventDefault === "function") {
         return e.preventDefault();
       } else {
         return e.returnValue = false;
       }
     },
-    stopPropagation: Batman.stopPropagation = function(e) {
+    stopPropagation: function(e) {
       if (e.stopPropagation) {
         return e.stopPropagation();
       } else {
@@ -2609,7 +2554,7 @@
         for (eventName in listeners) {
           eventListeners = listeners[eventName];
           eventListeners.forEach(function(listener) {
-            return Batman.removeEventListener(node, eventName, listener);
+            return Batman.DOM.removeEventListener(node, eventName, listener);
           });
         }
       }
@@ -2713,7 +2658,7 @@
       return true;
     },
     defineview: function(node, name, context, renderer) {
-      Batman.onParseExit(node, function() {
+      Batman.DOM.onParseExit(node, function() {
         var _ref;
         return (_ref = node.parentNode) != null ? _ref.removeChild(node) : void 0;
       });
@@ -2725,7 +2670,7 @@
       return false;
     },
     "yield": function(node, key) {
-      Batman.onParseExit(node, function() {
+      Batman.DOM.onParseExit(node, function() {
         return Batman.DOM.Yield.withName(key).set('containerNode', node);
       });
       return true;
@@ -2734,7 +2679,7 @@
       if (action == null) {
         action = 'append';
       }
-      Batman.onParseExit(node, function() {
+      Batman.DOM.onParseExit(node, function() {
         var _ref;
         if ((_ref = node.parentNode) != null) {
           _ref.removeChild(node);
@@ -2760,11 +2705,14 @@
       if (eventName == null) {
         eventName = 'click';
       }
-      Batman.addEventListener(node, eventName, function() {
-        var args;
-        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
-        callback.apply(null, [node].concat(__slice.call(args), [context]));
-        return Batman.preventDefault(args[0]);
+      Batman.DOM.addEventListener(node, eventName, function() {
+        var args, event;
+        event = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+        if (event.metaKey || event.ctrlKey) {
+          return;
+        }
+        callback.apply(null, [node, event].concat(__slice.call(args), [context]));
+        return Batman.DOM.preventDefault(event);
       });
       if (node.nodeName.toUpperCase() === 'A' && !node.href) {
         node.href = '#';
@@ -2802,7 +2750,7 @@
       _results = [];
       for (_i = 0, _len = eventNames.length; _i < _len; _i++) {
         eventName = eventNames[_i];
-        _results.push(Batman.addEventListener(node, eventName, function() {
+        _results.push(Batman.DOM.addEventListener(node, eventName, function() {
           var args;
           args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
           return callback.apply(null, [node].concat(__slice.call(args), [context]));
@@ -2816,36 +2764,36 @@
     },
     submit: function(node, callback, context) {
       if (Batman.DOM.nodeIsEditable(node)) {
-        Batman.addEventListener(node, 'keydown', function() {
+        Batman.DOM.addEventListener(node, 'keydown', function() {
           var args;
           args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
           if (Batman.DOM.events.isEnter(args[0])) {
             return Batman.DOM._keyCapturingNode = node;
           }
         });
-        Batman.addEventListener(node, 'keyup', function() {
+        Batman.DOM.addEventListener(node, 'keyup', function() {
           var args;
           args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
           if (Batman.DOM.events.isEnter(args[0])) {
             if (Batman.DOM._keyCapturingNode === node) {
-              Batman.preventDefault(args[0]);
+              Batman.DOM.preventDefault(args[0]);
               callback.apply(null, [node].concat(__slice.call(args), [context]));
             }
             return Batman.DOM._keyCapturingNode = null;
           }
         });
       } else {
-        Batman.addEventListener(node, 'submit', function() {
+        Batman.DOM.addEventListener(node, 'submit', function() {
           var args;
           args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
-          Batman.preventDefault(args[0]);
+          Batman.DOM.preventDefault(args[0]);
           return callback.apply(null, [node].concat(__slice.call(args), [context]));
         });
       }
       return node;
     },
     other: function(node, eventName, callback, context) {
-      return Batman.addEventListener(node, eventName, function() {
+      return Batman.DOM.addEventListener(node, eventName, function() {
         var args;
         args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
         return callback.apply(null, [node].concat(__slice.call(args), [context]));
@@ -3016,25 +2964,31 @@
     };
 
     promiseWrapper = function(fetcher) {
-      return function(core) {
+      return function(defaultAccessor) {
         return {
           get: function(key) {
-            var deliver, returned, val,
+            var asyncDeliver, existingValue, newValue, _base, _name, _ref,
               _this = this;
-            val = core.get.apply(this, arguments);
-            if (typeof val !== 'undefined') {
-              return val;
+            if ((existingValue = defaultAccessor.get.apply(this, arguments)) != null) {
+              return existingValue;
             }
-            returned = false;
-            deliver = function(err, result) {
-              if (returned) {
-                _this.set(key, result);
-              }
-              return val = result;
-            };
-            fetcher.call(this, deliver, key);
-            returned = true;
-            return val;
+            asyncDeliver = false;
+            newValue = void 0;
+            if ((_ref = (_base = this._batman)[_name = "promise" + key + "Fetched"]) == null) {
+              _base[_name] = (function() {
+                var deliver;
+                deliver = function(err, result) {
+                  if (asyncDeliver) {
+                    _this.set(key, result);
+                  }
+                  return newValue = result;
+                };
+                fetcher.call(_this, deliver, key);
+                return true;
+              })();
+            }
+            asyncDeliver = true;
+            return newValue;
           },
           cache: true
         };
@@ -3272,7 +3226,7 @@
           } else if (result instanceof Batman.RenderContext) {
             oldContext = this.context;
             this.context = result;
-            Batman.onParseExit(node, function() {
+            Batman.DOM.onParseExit(node, function() {
               return _this.context = oldContext;
             });
           }
@@ -3294,12 +3248,12 @@
         }
       }
       sibling = node.nextSibling;
-      if ((_ref1 = Batman.onParseExit(node)) != null) {
+      if ((_ref1 = Batman.DOM.onParseExit(node)) != null) {
         _ref1.forEach(function(callback) {
           return callback();
         });
       }
-      Batman.forgetParseExit(node);
+      Batman.DOM.forgetParseExit(node);
       if (this.node === node) {
         return;
       }
@@ -3309,12 +3263,12 @@
       nextParent = node;
       while (nextParent = nextParent.parentNode) {
         parentSibling = nextParent.nextSibling;
-        if ((_ref2 = Batman.onParseExit(nextParent)) != null) {
+        if ((_ref2 = Batman.DOM.onParseExit(nextParent)) != null) {
           _ref2.forEach(function(callback) {
             return callback();
           });
         }
-        Batman.forgetParseExit(nextParent);
+        Batman.DOM.forgetParseExit(nextParent);
         if (this.node === nextParent) {
           return;
         }
@@ -3643,7 +3597,7 @@
         if (typeof (hide = Batman.data(this.node, 'hide')) === 'function') {
           hide.call(this.node);
         } else {
-          Batman.setStyleProperty(this.node, 'display', 'none', 'important');
+          Batman.DOM.setStyleProperty(this.node, 'display', 'none', 'important');
         }
         return view != null ? view.fire('disappear', this.node) : void 0;
       }
@@ -4054,7 +4008,7 @@
       this.contextName = contextName;
       delete this.attributeName;
       Batman.DOM.events.submit(this.get('node'), function(node, e) {
-        return Batman.preventDefault(e);
+        return Batman.DOM.preventDefault(e);
       });
       this.setupErrorsList();
     }
@@ -4072,7 +4026,7 @@
 
     FormBinding.prototype.setupErrorsList = function() {
       if (this.errorsListNode = Batman.DOM.querySelector(this.get('node'), this.get('errorsListSelector'))) {
-        Batman.setInnerHTML(this.errorsListNode, this.errorsListHTML());
+        Batman.DOM.setInnerHTML(this.errorsListNode, this.errorsListHTML());
         if (!this.errorsListNode.getAttribute('data-showif')) {
           return this.errorsListNode.setAttribute('data-showif', "" + this.contextName + ".errors.length");
         }
@@ -4139,8 +4093,8 @@
             if (keys.length > 1) {
               functionKey = keys.pop();
               keyContext = Batman.getPath(this, ['keyContext'].concat(keys));
+              keyContext = Batman.RenderContext.deProxy(keyContext);
               if (keyContext != null) {
-                keyContext = Batman.RenderContext.deProxy(keyContext);
                 return keyContext[functionKey];
               }
             }
@@ -4513,11 +4467,11 @@
       if (Batman.canDeleteExpando) {
         delete sourceNode[Batman.expando];
       }
-      Batman.insertBefore(sourceNode.parentNode, this.startNode, previousSiblingNode);
-      Batman.insertBefore(sourceNode.parentNode, this.endNode, previousSiblingNode);
+      Batman.DOM.insertBefore(sourceNode.parentNode, this.startNode, previousSiblingNode);
+      Batman.DOM.insertBefore(sourceNode.parentNode, this.endNode, previousSiblingNode);
       this.parentRenderer.prevent('rendered');
       Batman.DOM.onParseExit(sourceNode.parentNode, function() {
-        Batman.destroyNode(sourceNode);
+        Batman.DOM.destroyNode(sourceNode);
         _this.bind();
         return _this.parentRenderer.allowAndFire('rendered');
       });
@@ -4553,15 +4507,17 @@
       parentNode = this.parentNode();
       startIndex = this._getStartNodeIndex() + 1;
       unseenNodeMap = this.nodeMap.merge();
-      for (index = _i = 0, _len = newItems.length; _i < _len; index = ++_i) {
-        newItem = newItems[index];
-        nodeAtIndex = parentNode.childNodes[startIndex + index];
-        if ((nodeAtIndex != null) && this._itemForNode(nodeAtIndex) === newItem) {
-          unseenNodeMap.unset(newItem);
-          continue;
-        } else {
-          node = (existingNode = this.nodeMap.get(newItem)) ? (unseenNodeMap.unset(newItem), existingNode) : this._newNodeForItem(newItem);
-          Batman.insertBefore(this.parentNode(), node, nodeAtIndex);
+      if (newItems != null) {
+        for (index = _i = 0, _len = newItems.length; _i < _len; index = ++_i) {
+          newItem = newItems[index];
+          nodeAtIndex = parentNode.childNodes[startIndex + index];
+          if ((nodeAtIndex != null) && this._itemForNode(nodeAtIndex) === newItem) {
+            unseenNodeMap.unset(newItem);
+            continue;
+          } else {
+            node = (existingNode = this.nodeMap.get(newItem)) ? (unseenNodeMap.unset(newItem), existingNode) : this._newNodeForItem(newItem);
+            Batman.DOM.insertBefore(this.parentNode(), node, nodeAtIndex);
+          }
         }
       }
       unseenNodeMap.forEach(function(item, node) {
@@ -4582,7 +4538,7 @@
       this.parentRenderer.prevent('rendered');
       renderer = new Batman.Renderer(newNode, this.renderContext.descend(newItem, this.iteratorName), this.parentRenderer.view);
       renderer.on('rendered', function() {
-        Batman.propagateBindingEvents(newNode);
+        Batman.DOM.propagateBindingEvents(newNode);
         _this.fire('nodeAdded', newNode, newItem);
         return _this.parentRenderer.allowAndFire('rendered');
       });
@@ -4604,7 +4560,7 @@
     IteratorBinding.prototype._removeItem = function(item) {
       var node;
       node = this.nodeMap.unset(item);
-      Batman.destroyNode(node);
+      Batman.DOM.destroyNode(node);
       return this.fire('nodeRemoved', node, item);
     };
 
@@ -4753,6 +4709,76 @@
 
     })(StorageAdapter.StorageError);
 
+    StorageAdapter.NotAllowedError = (function(_super1) {
+
+      __extends(NotAllowedError, _super1);
+
+      NotAllowedError.prototype.name = "NotAllowedError";
+
+      function NotAllowedError(message) {
+        NotAllowedError.__super__.constructor.call(this, message || "Storage operation denied access to the operation!");
+      }
+
+      return NotAllowedError;
+
+    })(StorageAdapter.StorageError);
+
+    StorageAdapter.NotAcceptableError = (function(_super1) {
+
+      __extends(NotAcceptableError, _super1);
+
+      NotAcceptableError.prototype.name = "NotAcceptableError";
+
+      function NotAcceptableError(message) {
+        NotAcceptableError.__super__.constructor.call(this, message || "Storage operation permitted but the request was malformed!");
+      }
+
+      return NotAcceptableError;
+
+    })(StorageAdapter.StorageError);
+
+    StorageAdapter.UnprocessableRecordError = (function(_super1) {
+
+      __extends(UnprocessableRecordError, _super1);
+
+      UnprocessableRecordError.prototype.name = "UnprocessableRecordError";
+
+      function UnprocessableRecordError(message) {
+        UnprocessableRecordError.__super__.constructor.call(this, message || "Storage adapter could not process the record!");
+      }
+
+      return UnprocessableRecordError;
+
+    })(StorageAdapter.StorageError);
+
+    StorageAdapter.InternalStorageError = (function(_super1) {
+
+      __extends(InternalStorageError, _super1);
+
+      InternalStorageError.prototype.name = "InternalStorageError";
+
+      function InternalStorageError(message) {
+        InternalStorageError.__super__.constructor.call(this, message || "An error occured during the storage operation!");
+      }
+
+      return InternalStorageError;
+
+    })(StorageAdapter.StorageError);
+
+    StorageAdapter.NotImplementedError = (function(_super1) {
+
+      __extends(NotImplementedError, _super1);
+
+      NotImplementedError.prototype.name = "NotImplementedError";
+
+      function NotImplementedError(message) {
+        NotImplementedError.__super__.constructor.call(this, message || "This operation is not implemented by the storage adpater!");
+      }
+
+      return NotImplementedError;
+
+    })(StorageAdapter.StorageError);
+
     function StorageAdapter(model) {
       var constructor;
       StorageAdapter.__super__.constructor.call(this, {
@@ -4921,6 +4947,20 @@
 
     __extends(RestStorage, _super);
 
+    RestStorage.CommunicationError = (function(_super1) {
+
+      __extends(CommunicationError, _super1);
+
+      CommunicationError.prototype.name = 'CommunicationError';
+
+      function CommunicationError(message) {
+        CommunicationError.__super__.constructor.call(this, message || "A communication error has occurred!");
+      }
+
+      return CommunicationError;
+
+    })(RestStorage.StorageError);
+
     RestStorage.JSONContentType = 'application/json';
 
     RestStorage.PostBodyContentType = 'application/x-www-form-urlencoded';
@@ -5230,6 +5270,37 @@
       _fn(key);
     }
 
+    RestStorage.prototype.after('all', function(env, next) {
+      if (env.error) {
+        env.error = this._errorFor(env.error, env);
+      }
+      return next();
+    });
+
+    RestStorage._statusCodeErrors = {
+      '0': RestStorage.CommunicationError,
+      '403': RestStorage.NotAllowedError,
+      '404': RestStorage.NotFoundError,
+      '406': RestStorage.NotAcceptableError,
+      '422': RestStorage.UnprocessableRecordError,
+      '500': RestStorage.InternalStorageError,
+      '501': RestStorage.NotImplementedError
+    };
+
+    RestStorage.prototype._errorFor = function(error, env) {
+      var errorClass, request;
+      if (error instanceof Error || !(error.request != null)) {
+        return error;
+      }
+      if (errorClass = this.constructor._statusCodeErrors[error.request.status]) {
+        request = error.request;
+        error = new errorClass;
+        error.request = request;
+        error.env = env;
+      }
+      return error;
+    };
+
     return RestStorage;
 
   }).call(this, Batman.StorageAdapter);
@@ -5835,6 +5906,7 @@
       }
       pattern = templatePath.replace(regexps.escapeRegExp, '\\$&');
       regexp = RegExp("^" + (pattern.replace(regexps.openOptParam, '(?:').replace(regexps.closeOptParam, ')?').replace(regexps.namedParam, '([^\/]+)').replace(regexps.splatParam, '(.*?)')) + regexps.queryParam + "$");
+      regexps.namedOrSplat.lastIndex = 0;
       namedArguments = ((function() {
         var _results;
         _results = [];
@@ -6312,6 +6384,7 @@
   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; },
+    __slice = [].slice,
     __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.Controller = (function(_super) {
@@ -6384,8 +6457,71 @@
       }
     });
 
+    Controller.catchError = function() {
+      var currentHandlers, error, errors, handlers, options, _base, _i, _j, _len, _results;
+      errors = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), options = arguments[_i++];
+      Batman.initializeObject(this);
+      (_base = this._batman).errorHandlers || (_base.errorHandlers = new Batman.SimpleHash);
+      handlers = Batman.typeOf(options["with"]) === 'Array' ? options["with"] : [options["with"]];
+      _results = [];
+      for (_j = 0, _len = errors.length; _j < _len; _j++) {
+        error = errors[_j];
+        currentHandlers = this._batman.errorHandlers.get(error) || [];
+        _results.push(this._batman.errorHandlers.set(error, currentHandlers.concat(handlers)));
+      }
+      return _results;
+    };
+
+    Controller.prototype.errorHandler = function(callback) {
+      var errorFrame, _ref,
+        _this = this;
+      errorFrame = (_ref = this._actionFrames) != null ? _ref[this._actionFrames.length - 1] : void 0;
+      return function(err, result, env) {
+        if (err) {
+          if (errorFrame != null ? errorFrame.error : void 0) {
+            return;
+          }
+          if (errorFrame != null) {
+            errorFrame.error = err;
+          }
+          if (!_this.handleError(err)) {
+            throw err;
+          }
+        } else {
+          return typeof callback === "function" ? callback(result, env) : void 0;
+        }
+      };
+    };
+
+    Controller.prototype.handleError = function(error) {
+      var handled, _ref,
+        _this = this;
+      handled = false;
+      if ((_ref = this.constructor._batman.getAll('errorHandlers')) != null) {
+        _ref.forEach(function(hash) {
+          return hash.forEach(function(key, value) {
+            var handler, _i, _len, _results;
+            if (error instanceof key) {
+              handled = true;
+              _results = [];
+              for (_i = 0, _len = value.length; _i < _len; _i++) {
+                handler = value[_i];
+                _results.push(handler.call(_this, error));
+              }
+              return _results;
+            }
+          });
+        });
+      }
+      return handled;
+    };
+
     function Controller() {
       this.redirect = __bind(this.redirect, this);
+
+      this.handleError = __bind(this.handleError, this);
+
+      this.errorHandler = __bind(this.errorHandler, this);
       Controller.__super__.constructor.apply(this, arguments);
       this._resetActionFrames();
     }
@@ -7178,11 +7314,13 @@
 
     Model.primaryKey = 'id';
 
-    Model.persist = function(mechanism, options) {
+    Model.persist = function() {
+      var mechanism, options;
+      mechanism = arguments[0], options = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
       Batman.initializeObject(this.prototype);
       mechanism = mechanism.isStorageAdapter ? mechanism : new mechanism(this);
-      if (options) {
-        Batman.mixin(mechanism, options);
+      if (options.length > 0) {
+        Batman.mixin.apply(Batman, [mechanism].concat(__slice.call(options)));
       }
       this.prototype._batman.storage = mechanism;
       return mechanism;
@@ -7266,38 +7404,6 @@
       }
     };
 
-    Model.LifecycleStateMachine = (function(_super1) {
-
-      __extends(LifecycleStateMachine, _super1);
-
-      function LifecycleStateMachine() {
-        return LifecycleStateMachine.__super__.constructor.apply(this, arguments);
-      }
-
-      LifecycleStateMachine.transitions({
-        load: {
-          empty: 'loading',
-          loaded: 'loading',
-          loading: 'loading'
-        },
-        loaded: {
-          loading: 'loaded'
-        },
-        error: {
-          loading: 'error'
-        }
-      });
-
-      return LifecycleStateMachine;
-
-    })(Batman.DelegatingStateMachine);
-
-    Model.classAccessor('lifecycle', function() {
-      var _base;
-      this._batman.check(this);
-      return (_base = this._batman).lifecycle || (_base.lifecycle = new this.LifecycleStateMachine('empty', this));
-    });
-
     Model.classAccessor('resourceName', {
       get: function() {
         if (this.resourceName != null) {
@@ -7366,38 +7472,34 @@
     };
 
     Model.load = function(options, callback) {
-      var lifecycle, _ref,
+      var _ref,
         _this = this;
       if ((_ref = typeof options) === 'function' || _ref === 'undefined') {
         callback = options;
         options = {};
       }
-      lifecycle = this.get('lifecycle');
-      if (lifecycle.load()) {
-        return this._doStorageOperation('readAll', {
-          data: options
-        }, function(err, records, env) {
-          var mappedRecords, record;
-          if (err != null) {
-            lifecycle.error();
-            return typeof callback === "function" ? callback(err, []) : void 0;
-          } else {
-            mappedRecords = (function() {
-              var _i, _len, _results;
-              _results = [];
-              for (_i = 0, _len = records.length; _i < _len; _i++) {
-                record = records[_i];
-                _results.push(this._mapIdentity(record));
-              }
-              return _results;
-            }).call(_this);
-            lifecycle.loaded();
-            return typeof callback === "function" ? callback(err, mappedRecords, env) : void 0;
-          }
-        });
-      } else {
-        return callback(new Batman.StateMachine.InvalidTransitionError("Can't load while in state " + (lifecycle.get('state'))));
-      }
+      this.fire('loading', options);
+      return this._doStorageOperation('readAll', {
+        data: options
+      }, function(err, records, env) {
+        var mappedRecords, record;
+        if (err != null) {
+          _this.fire('error', err);
+          return typeof callback === "function" ? callback(err, []) : void 0;
+        } else {
+          mappedRecords = (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = records.length; _i < _len; _i++) {
+              record = records[_i];
+              _results.push(this._mapIdentity(record));
+            }
+            return _results;
+          }).call(_this);
+          _this.fire('loaded', mappedRecords, env);
+          return typeof callback === "function" ? callback(err, mappedRecords, env) : void 0;
+        }
+      });
     };
 
     Model.create = function(attrs, callback) {
@@ -7561,6 +7663,10 @@
       return this.isNew();
     });
 
+    Model.accessor('isDirty', function() {
+      return this.isDirty();
+    });
+
     Model.accessor(Model.defaultAccessor = {
       get: function(k) {
         return Batman.getPath(this, ['attributes', k]);
@@ -7608,6 +7714,10 @@
       return typeof this.get('id') === 'undefined';
     };
 
+    Model.prototype.isDirty = function() {
+      return this.get('lifecycle.state') === 'dirty';
+    };
+
     Model.prototype.updateAttributes = function(attrs) {
       this.mixin(attrs);
       return this;
@@ -7990,17 +8100,27 @@
       var _this = this;
       this.fetch(function(err, proxiedRecord) {
         if (!err) {
-          _this.set('loaded', true);
-          _this.set('target', proxiedRecord);
+          _this._setTarget(proxiedRecord);
         }
         return typeof callback === "function" ? callback(err, proxiedRecord) : void 0;
       });
       return this.get('target');
     };
 
+    AssociationProxy.prototype.loadFromLocal = function() {
+      var target;
+      if (!this._canLoad()) {
+        return;
+      }
+      if (target = this.fetchFromLocal()) {
+        this._setTarget(target);
+      }
+      return target;
+    };
+
     AssociationProxy.prototype.fetch = function(callback) {
       var record;
-      if ((this.get('foreignValue') || this.get('primaryValue')) == null) {
+      if (!this._canLoad()) {
         return callback(void 0, void 0);
       }
       record = this.fetchFromLocal();
@@ -8022,6 +8142,16 @@
       }
     });
 
+    AssociationProxy.prototype._canLoad = function() {
+      return (this.get('foreignValue') || this.get('primaryValue')) != null;
+    };
+
+    AssociationProxy.prototype._setTarget = function(target) {
+      this.set('target', target);
+      this.set('loaded', true);
+      return this.fire('loaded', target);
+    };
+
     return AssociationProxy;
 
   })(Batman.Proxy);
@@ -8408,6 +8538,9 @@
         if (first == null) {
           first = false;
         }
+        if (object instanceof Batman.container.File) {
+          return [[key, object]];
+        }
         return list = (function() {
           switch (Batman.typeOf(object)) {
             case 'Object':
@@ -9016,14 +9149,27 @@
     }
 
     AssociationSetIndex.prototype._resultSetForKey = function(key) {
+      return this.association.setForKey(key);
+    };
+
+    AssociationSetIndex.prototype.forEach = function(iterator, ctx) {
       var _this = this;
-      return this._storage.getOrSet(key, function() {
-        return new _this.association.proxyClass(key, _this.association);
+      return this.association.proxies.forEach(function(record, set) {
+        var key;
+        key = _this.association.indexValueForRecord(record);
+        if (set.get('length') > 0) {
+          return iterator.call(ctx, key, set, _this);
+        }
       });
     };
 
-    AssociationSetIndex.prototype._setResultSet = function(key, set) {
-      return this._storage.set(key, set);
+    AssociationSetIndex.prototype.toArray = function() {
+      var results;
+      results = [];
+      this.forEach(function(key) {
+        return results.push(key);
+      });
+      return results;
     };
 
     return AssociationSetIndex;
@@ -9250,11 +9396,11 @@
     };
 
     PushStateNavigator.prototype.startWatching = function() {
-      return Batman.addEventListener(window, 'popstate', this.handleCurrentLocation);
+      return Batman.DOM.addEventListener(window, 'popstate', this.handleCurrentLocation);
     };
 
     PushStateNavigator.prototype.stopWatching = function() {
-      return Batman.removeEventListener(window, 'popstate', this.handleCurrentLocation);
+      return Batman.DOM.removeEventListener(window, 'popstate', this.handleCurrentLocation);
     };
 
     PushStateNavigator.prototype.pushState = function(stateObject, title, path) {
@@ -9308,10 +9454,10 @@
 
     if ((typeof window !== "undefined" && window !== null) && 'onhashchange' in window) {
       HashbangNavigator.prototype.startWatching = function() {
-        return Batman.addEventListener(window, 'hashchange', this.handleCurrentLocation);
+        return Batman.DOM.addEventListener(window, 'hashchange', this.handleCurrentLocation);
       };
       HashbangNavigator.prototype.stopWatching = function() {
-        return Batman.removeEventListener(window, 'hashchange', this.handleCurrentLocation);
+        return Batman.DOM.removeEventListener(window, 'hashchange', this.handleCurrentLocation);
       };
     } else {
       HashbangNavigator.prototype.startWatching = function() {
@@ -9635,7 +9781,7 @@
       options = Batman.extend({}, this.baseOptions, options);
       options[cardinality] = true;
       routeTemplate = this.constructor.ROUTES[cardinality];
-      resourceRoot = options.controller;
+      resourceRoot = Batman.helpers.underscore(options.controller);
       for (_j = 0, _len = names.length; _j < _len; _j++) {
         name = names[_j];
         routeOptions = Batman.extend({
@@ -10025,21 +10171,62 @@
 
     __extends(PluralAssociation, _super);
 
-    function PluralAssociation() {
-      return PluralAssociation.__super__.constructor.apply(this, arguments);
-    }
-
     PluralAssociation.prototype.proxyClass = Batman.AssociationSet;
 
     PluralAssociation.prototype.isSingular = false;
 
-    PluralAssociation.prototype.setForRecord = Batman.Property.wrapTrackingPrevention(function(record) {
-      var id;
-      if (id = record.get(this.primaryKey)) {
-        return this.setIndex().get(id);
+    function PluralAssociation() {
+      PluralAssociation.__super__.constructor.apply(this, arguments);
+      this._resetSetHashes();
+    }
+
+    PluralAssociation.prototype.setForRecord = function(record) {
+      var childModelSetIndex, indexValue,
+        _this = this;
+      indexValue = this.indexValueForRecord(record);
+      childModelSetIndex = this.setIndex();
+      Batman.Property.withoutTracking(function() {
+        return _this._setsByRecord.getOrSet(record, function() {
+          var existingValueSet, newSet;
+          if (indexValue != null) {
+            existingValueSet = _this._setsByValue.get(indexValue);
+            if (existingValueSet != null) {
+              return existingValueSet;
+            }
+          }
+          newSet = new _this.proxyClass(indexValue, _this);
+          if (indexValue != null) {
+            _this._setsByValue.set(indexValue, newSet);
+          }
+          return newSet;
+        });
+      });
+      if (indexValue != null) {
+        return childModelSetIndex.get(indexValue);
       } else {
-        return new this.proxyClass(void 0, this);
+        return this._setsByRecord.get(record);
+      }
+    };
+
+    PluralAssociation.prototype.setForKey = Batman.Property.wrapTrackingPrevention(function(indexValue) {
+      var foundSet,
+        _this = this;
+      foundSet = void 0;
+      this._setsByRecord.forEach(function(record, set) {
+        if (foundSet != null) {
+          return;
+        }
+        if (_this.indexValueForRecord(record) === indexValue) {
+          return foundSet = set;
+        }
+      });
+      if (foundSet != null) {
+        foundSet.foreignKeyValue = indexValue;
+        return foundSet;
       }
+      return this._setsByValue.getOrSet(indexValue, function() {
+        return new _this.proxyClass(indexValue, _this);
+      });
     });
 
     PluralAssociation.prototype.getAccessor = function(self, model, label) {
@@ -10071,6 +10258,20 @@
       return this.index;
     };
 
+    PluralAssociation.prototype.indexValueForRecord = function(record) {
+      return record.get(this.primaryKey);
+    };
+
+    PluralAssociation.prototype.reset = function() {
+      PluralAssociation.__super__.reset.apply(this, arguments);
+      return this._resetSetHashes();
+    };
+
+    PluralAssociation.prototype._resetSetHashes = function() {
+      this._setsByRecord = new Batman.SimpleHash;
+      return this._setsByValue = new Batman.SimpleHash;
+    };
+
     return PluralAssociation;
 
   })(Batman.Association);
@@ -10279,18 +10480,33 @@
     SingularAssociation.prototype.isSingular = true;
 
     SingularAssociation.prototype.getAccessor = function(self, model, label) {
-      var proxy, recordInAttributes;
+      var parent, proxy, record, recordInAttributes, _ref;
       if (recordInAttributes = self.getFromAttributes(this)) {
         return recordInAttributes;
       }
       if (self.getRelatedModel()) {
         proxy = this.associationProxy(self);
-        Batman.Property.withoutTracking(function() {
-          if (!proxy.get('loaded') && self.options.autoload) {
-            return proxy.load();
+        record = false;
+        parent = this;
+        if ((_ref = proxy._loadSetter) == null) {
+          proxy._loadSetter = proxy.once('loaded', function(child) {
+            return parent._withoutDirtyTracking(function() {
+              return this.set(self.label, child);
+            });
+          });
+        }
+        if (!Batman.Property.withoutTracking(function() {
+          return proxy.get('loaded');
+        })) {
+          if (self.options.autoload) {
+            Batman.Property.withoutTracking(function() {
+              return proxy.load();
+            });
+          } else {
+            record = proxy.loadFromLocal();
           }
-        });
-        return proxy;
+        }
+        return record || proxy;
       }
     };
 
@@ -10352,6 +10568,9 @@
       association = this;
       return function(data, _, __, ___, parentRecord) {
         var record, relatedModel;
+        if (!data) {
+          return;
+        }
         relatedModel = association.getRelatedModel();
         record = relatedModel.createFromJSON(data);
         if (association.options.inverseOf) {
@@ -11008,8 +11227,10 @@
           return parentNode.removeChild(this.placeholderNode);
         }
       } else {
-        parentNode.insertBefore(this.placeholderNode, this.node);
-        return Batman.DOM.removeNode(this.node);
+        if (this.node.parentNode != null) {
+          parentNode.insertBefore(this.placeholderNode, this.node);
+          return Batman.DOM.removeNode(this.node);
+        }
       }
     };
 
@@ -11177,7 +11398,7 @@
 
   buntUndefined = function(f) {
     return function(value) {
-      if (typeof value === 'undefined') {
+      if (value == null) {
         return void 0;
       } else {
         return f.apply(this, arguments);
@@ -11240,10 +11461,10 @@
       }
     },
     prepend: function(value, string, binding) {
-      return string + value;
+      return string + (value != null ? value : '');
     },
     append: function(value, string, binding) {
-      return value + string;
+      return (value != null ? value : '') + string;
     },
     replace: buntUndefined(function(value, searchFor, replaceWith, flags, binding) {
       if (!binding) {
@@ -11677,7 +11898,7 @@
           }
           this.node = document.createElement('div');
           this._setNodeOwner(this.node);
-          Batman.setInnerHTML(this.node, html);
+          Batman.DOM.setInnerHTML(this.node, html);
         }
         return this.node;
       },
@@ -11688,7 +11909,7 @@
         this._setNodeOwner(node);
         updateHTML = function(html) {
           if (html != null) {
-            Batman.setInnerHTML(_this.node, html);
+            Batman.DOM.setInnerHTML(_this.node, html);
             return _this.forget('html', updateHTML);
           }
         };
@@ -11930,7 +12151,7 @@
       _results = [];
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         child = _ref[_i];
-        _results.push(Batman.removeOrDestroyNode(child));
+        _results.push(Batman.DOM.removeOrDestroyNode(child));
       }
       return _results;
     });
@@ -11951,7 +12172,7 @@
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
         child = _ref[_i];
         if (!~this.currentVersionNodes.indexOf(child)) {
-          _results.push(Batman.removeOrDestroyNode(child));
+          _results.push(Batman.DOM.removeOrDestroyNode(child));
         }
       }
       return _results;
@@ -11959,7 +12180,7 @@
 
     Yield.prototype.append = Yield.queued(function(node) {
       this.currentVersionNodes.push(node);
-      return Batman.appendChild(this.containerNode, node, true);
+      return Batman.DOM.appendChild(this.containerNode, node, true);
     });
 
     Yield.prototype.replace = Yield.queued(function(node) {
@@ -11979,8 +12200,6 @@
 
 }).call(this);
 
-(function() {
-  
 /*!
   * Reqwest! A general purpose XHR connection manager
   * (c) Dustin Diaz 2011
@@ -12355,13 +12574,69 @@
   }
 
   return reqwest
-})
+});
 
-;
+(function() {
+  var _ref, _ref1;
 
-  var prefixes;
+  Batman.extend(Batman.DOM, {
+    querySelectorAll: (typeof window !== "undefined" && window !== null ? (_ref = window.document) != null ? _ref.querySelectorAll : void 0 : void 0) != null ? function(node, selector) {
+      return node.querySelectorAll(selector);
+    } : function() {
+      return Batman.developer.error("Please include either jQuery or a querySelectorAll polyfill, or set Batman.DOM.querySelectorAll to return an empty array.");
+    },
+    querySelector: (typeof window !== "undefined" && window !== null ? (_ref1 = window.document) != null ? _ref1.querySelector : void 0 : void 0) != null ? function(node, selector) {
+      return node.querySelector(selector);
+    } : function() {
+      return Batman.developer.error("Please include either jQuery or a querySelector polyfill, or set Batman.DOM.querySelector to an empty function.");
+    },
+    setInnerHTML: function(node, html) {
+      var child, childNodes, result, _i, _j, _len, _len1;
+      childNodes = (function() {
+        var _i, _len, _ref2, _results;
+        _ref2 = node.childNodes;
+        _results = [];
+        for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+          child = _ref2[_i];
+          _results.push(child);
+        }
+        return _results;
+      })();
+      for (_i = 0, _len = childNodes.length; _i < _len; _i++) {
+        child = childNodes[_i];
+        Batman.DOM.willRemoveNode(child);
+      }
+      result = node.innerHTML = html;
+      for (_j = 0, _len1 = childNodes.length; _j < _len1; _j++) {
+        child = childNodes[_j];
+        Batman.DOM.didRemoveNode(child);
+      }
+      return result;
+    },
+    removeNode: function(node) {
+      var _ref2;
+      Batman.DOM.willRemoveNode(node);
+      if ((_ref2 = node.parentNode) != null) {
+        _ref2.removeChild(node);
+      }
+      return Batman.DOM.didRemoveNode(node);
+    },
+    destroyNode: function(node) {
+      Batman.DOM.willDestroyNode(node);
+      Batman.DOM.removeNode(node);
+      return Batman.DOM.didDestroyNode(node);
+    },
+    appendChild: function(parent, child) {
+      Batman.DOM.willInsertNode(child);
+      parent.appendChild(child);
+      return Batman.DOM.didInsertNode(child);
+    }
+  });
 
-  (typeof exports !== "undefined" && exports !== null ? exports : this).reqwest = typeof window !== "undefined" && window !== null ? window.reqwest : reqwest;
+}).call(this);
+
+(function() {
+  var prefixes;
 
   Batman.Request.prototype._parseResponseHeaders = function(xhr) {
     var headers;