marionette-rails 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97731fd8838b5590ee15c0d9cb0fbabfe575d264
-  data.tar.gz: fa19df0cc00e1a5887bbaf02ea6a348579b9afd2
+  metadata.gz: 5bb72c3e7ebd42ae9f6ff1cab755e4d75cbd33d7
+  data.tar.gz: 93bb3dd197d7c37ffc2698eebf39c93476d84246
 SHA512:
-  metadata.gz: 3a8a8069c059b6ee0b4100a2e31b58c476ecda37aa9b1938c2573bf556917540ef750ecbe065bd45d08ed8db2df7bc1c818394d733272eca31284c81e6d83ed2
-  data.tar.gz: 92f348ccd1500aef5677e420ecda8f0dd0537a38b765aee6f5513e0175a3fc85d6d20997993d256b51bff2992c44c285e01efe3a55a4b14fa2fb1a48e189861b
+  metadata.gz: 770e3d2afb69960a1572be93848b96a4a06dbc84f89652f0b0c61c98807fe3ecec3f088124750953b81d3c9b8914d9577c85ac575d061935e0d0bec7f63c01a6
+  data.tar.gz: aae08d6c39199c82b4ffb94c0c0b47a8b2b5b84d69b8c909a9ebc3815b35c89a710c851a009583cd0d61c2ada9a582d22ca161b9a5861da904d02912a9c05f6a

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Godfrey Chan
+Copyright (c) 2012-2014 Godfrey Chan & Stafford Brunk
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -16,4 +16,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.

data/README.md

@@ -5,7 +5,7 @@ marionette-rails
 
 This gem is a wrapper for Derick Bailey's [Backbone.Marionette](https://github.com/marionettejs/backbone.marionette) library. It vendors the javascript library code for use with Rails' asset pipeline (Rails 3.1+).
 
-This gem is currently maintained by [@chancancode](https://github.com/chancancode/) and [@wingrunr21](https://github.com/wingrunr21).
+This gem is currently maintained by [@wingrunr21](https://github.com/wingrunr21).
 
 ## Dependencies
 
@@ -44,12 +44,6 @@ For bugs in [Backbone.Marionette](https://github.com/marionettejs/backbone.mario
 
 For bugs in this gem distribution, use the [GitHub issue tracker](https://github.com/chancancode/marionette-rails/issues). If you could submit a pull request - that's even better!
 
-## Donations
-
-If you're using Marionette and you're finding that it is saving you time and effort, then please consider donating to the upstream [Backbone.Marionette](https://github.com/marionettejs/backbone.marionette) project.
-
-[![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=7SJHYWJ487SF4)
-
 ## License
 
 This library is distributed under the MIT license. Please see the LICENSE file.

data/lib/marionette-rails/version.rb

@@ -1,5 +1,5 @@
 module Marionette
   module Rails
-    VERSION = '2.2.1'
+    VERSION = '2.2.2'
   end
 end

data/vendor/assets/javascripts/backbone.marionette.js

@@ -1,6 +1,6 @@
 // MarionetteJS (Backbone.Marionette)
 // ----------------------------------
-// v2.2.1
+// v2.2.2
 //
 // Copyright (c)2014 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
@@ -493,7 +493,7 @@
 
   var Marionette = Backbone.Marionette = {};
 
-  Marionette.VERSION = '2.2.1';
+  Marionette.VERSION = '2.2.2';
 
   Marionette.noConflict = function() {
     root.Marionette = previousMarionette;
@@ -506,45 +506,45 @@
   Marionette.Deferred = Backbone.$.Deferred;
 
   /* jshint unused: false */
-
+  
   // Helpers
   // -------
-
+  
   // For slicing `arguments` in functions
   var slice = Array.prototype.slice;
-
+  
   // Marionette.extend
   // -----------------
-
+  
   // Borrow the Backbone `extend` method so we can use it as needed
   Marionette.extend = Backbone.Model.extend;
-
+  
   // Marionette.getOption
   // --------------------
-
+  
   // Retrieve an object, function or other value from a target
   // object or its `options`, with `options` taking precedence.
   Marionette.getOption = function(target, optionName) {
     if (!target || !optionName) { return; }
     var value;
-
+  
     if (target.options && (target.options[optionName] !== undefined)) {
       value = target.options[optionName];
     } else {
       value = target[optionName];
     }
-
+  
     return value;
   };
-
+  
   // Proxy `Marionette.getOption`
   Marionette.proxyGetOption = function(optionName) {
     return Marionette.getOption(this, optionName);
   };
-
+  
   // Marionette.normalizeMethods
   // ----------------------
-
+  
   // Pass in a mapping of events => functions or function names
   // and return a mapping of events => functions
   Marionette.normalizeMethods = function(hash) {
@@ -560,7 +560,7 @@
     }, this);
     return normalizedHash;
   };
-
+  
   // utility method for parsing @ui. syntax strings
   // into associated selector
   Marionette.normalizeUIString = function(uiString, ui) {
@@ -568,7 +568,7 @@
       return ui[r.slice(4)];
     });
   };
-
+  
   // allows for the use of the @ui. syntax within
   // a given key for triggers and events
   // swaps the @ui with the associated selector.
@@ -577,9 +577,9 @@
     if (typeof(hash) === 'undefined') {
       return;
     }
-
+  
     hash = _.clone(hash);
-
+  
     _.each(_.keys(hash), function(key) {
       var normalizedKey = Marionette.normalizeUIString(key, ui);
       if (normalizedKey !== key) {
@@ -587,10 +587,10 @@
         delete hash[key];
       }
     });
-
+  
     return hash;
   };
-
+  
   // allows for the use of the @ui. syntax within
   // a given value for regions
   // swaps the @ui with the associated selector
@@ -598,16 +598,16 @@
     if (typeof(hash) === 'undefined') {
       return;
     }
-
+  
     _.each(hash, function(val, key) {
       if (_.isString(val)) {
         hash[key] = Marionette.normalizeUIString(val, ui);
       }
     });
-
+  
     return hash;
   };
-
+  
   // Mix in methods from Underscore, for iteration, and other
   // collection related features.
   // Borrowing this code from Backbone.Collection:
@@ -617,7 +617,7 @@
       'select', 'reject', 'every', 'all', 'some', 'any', 'include',
       'contains', 'invoke', 'toArray', 'first', 'initial', 'rest',
       'last', 'without', 'isEmpty', 'pluck'];
-
+  
     _.each(methods, function(method) {
       object[method] = function() {
         var list = _.values(_.result(this, listProperty));
@@ -626,7 +626,7 @@
       };
     });
   };
-
+  
   // Trigger an event and/or a corresponding method name. Examples:
   //
   // `this.triggerMethod("foo")` will trigger the "foo" event and
@@ -635,35 +635,35 @@
   // `this.triggerMethod("foo:bar")` will trigger the "foo:bar" event and
   // call the "onFooBar" method.
   Marionette.triggerMethod = function(event) {
-
+  
     // split the event name on the ":"
     var splitter = /(^|:)(\w)/gi;
-
+  
     // take the event section ("section1:section2:section3")
     // and turn it in to uppercase name
     function getEventName(match, prefix, eventName) {
       return eventName.toUpperCase();
     }
-
+  
     // get the method name from the event name
     var methodName = 'on' + event.replace(splitter, getEventName);
     var method = this[methodName];
     var result;
-
+  
     // call the onMethodName if it exists
     if (_.isFunction(method)) {
       // pass all arguments, except the event name
       result = method.apply(this, _.tail(arguments));
     }
-
+  
     // trigger the event, if a trigger method exists
     if (_.isFunction(this.trigger)) {
       this.trigger.apply(this, arguments);
     }
-
+  
     return result;
   };
-
+  
   // triggerMethodOn invokes triggerMethod on a specific context
   //
   // e.g. `Marionette.triggerMethodOn(view, 'show')`
@@ -671,23 +671,23 @@
   Marionette.triggerMethodOn = function(context, event) {
     var args = _.tail(arguments, 2);
     var fnc;
-
+  
     if (_.isFunction(context.triggerMethod)) {
       fnc = context.triggerMethod;
     } else {
       fnc = Marionette.triggerMethod;
     }
-
+  
     return fnc.apply(context, [event].concat(args));
   };
-
+  
   // DOMRefresh
   // ----------
   //
   // Monitor a view's state, and after it has been rendered and shown
   // in the DOM, trigger a "dom:refresh" event every time it is
   // re-rendered.
-
+  
   Marionette.MonitorDOMRefresh = (function(documentElement) {
     // track when the view has been shown in the DOM,
     // using a Marionette.Region (or by other means of triggering "show")
@@ -695,13 +695,13 @@
       view._isShown = true;
       triggerDOMRefresh(view);
     }
-
+  
     // track when the view has been rendered
     function handleRender(view) {
       view._isRendered = true;
       triggerDOMRefresh(view);
     }
-
+  
     // Trigger the "dom:refresh" event and corresponding "onDomRefresh" method
     function triggerDOMRefresh(view) {
       if (view._isShown && view._isRendered && isInDOM(view)) {
@@ -710,26 +710,26 @@
         }
       }
     }
-
+  
     function isInDOM(view) {
       return Backbone.$.contains(documentElement, view.el);
     }
-
+  
     // Export public API
     return function(view) {
       view.listenTo(view, 'show', function() {
         handleShow(view);
       });
-
+  
       view.listenTo(view, 'render', function() {
         handleRender(view);
       });
     };
   })(document.documentElement);
-
+  
 
   /* jshint maxparams: 5 */
-
+  
   // Marionette.bindEntityEvents & unbindEntityEvents
   // ---------------------------
   //
@@ -745,53 +745,53 @@
   // The third parameter is a hash of { "event:name": "eventHandler" }
   // configuration. Multiple handlers can be separated by a space. A
   // function can be supplied instead of a string handler name.
-
+  
   (function(Marionette) {
     'use strict';
-
+  
     // Bind the event to handlers specified as a string of
     // handler names on the target object
     function bindFromStrings(target, entity, evt, methods) {
       var methodNames = methods.split(/\s+/);
-
+  
       _.each(methodNames, function(methodName) {
-
+  
         var method = target[methodName];
         if (!method) {
           throw new Marionette.Error('Method "' + methodName +
             '" was configured as an event handler, but does not exist.');
         }
-
+  
         target.listenTo(entity, evt, method);
       });
     }
-
+  
     // Bind the event to a supplied callback function
     function bindToFunction(target, entity, evt, method) {
       target.listenTo(entity, evt, method);
     }
-
+  
     // Bind the event to handlers specified as a string of
     // handler names on the target object
     function unbindFromStrings(target, entity, evt, methods) {
       var methodNames = methods.split(/\s+/);
-
+  
       _.each(methodNames, function(methodName) {
         var method = target[methodName];
         target.stopListening(entity, evt, method);
       });
     }
-
+  
     // Bind the event to a supplied callback function
     function unbindToFunction(target, entity, evt, method) {
       target.stopListening(entity, evt, method);
     }
-
-
+  
+  
     // generic looping function
     function iterateEvents(target, entity, bindings, functionCallback, stringCallback) {
       if (!entity || !bindings) { return; }
-
+  
       // type-check bindings
       if (!_.isFunction(bindings) && !_.isObject(bindings)) {
         throw new Marionette.Error({
@@ -799,15 +799,15 @@
           url: 'marionette.functions.html#marionettebindentityevents'
         });
       }
-
+  
       // allow the bindings to be a function
       if (_.isFunction(bindings)) {
         bindings = bindings.call(target);
       }
-
+  
       // iterate the bindings and bind them
       _.each(bindings, function(methods, evt) {
-
+  
         // allow for a function as the handler,
         // or a list of event names as a string
         if (_.isFunction(methods)) {
@@ -815,36 +815,36 @@
         } else {
           stringCallback(target, entity, evt, methods);
         }
-
+  
       });
     }
-
+  
     // Export Public API
     Marionette.bindEntityEvents = function(target, entity, bindings) {
       iterateEvents(target, entity, bindings, bindToFunction, bindFromStrings);
     };
-
+  
     Marionette.unbindEntityEvents = function(target, entity, bindings) {
       iterateEvents(target, entity, bindings, unbindToFunction, unbindFromStrings);
     };
-
+  
     // Proxy `bindEntityEvents`
     Marionette.proxyBindEntityEvents = function(entity, bindings) {
       return Marionette.bindEntityEvents(this, entity, bindings);
     };
-
+  
     // Proxy `unbindEntityEvents`
     Marionette.proxyUnbindEntityEvents = function(entity, bindings) {
       return Marionette.unbindEntityEvents(this, entity, bindings);
     };
   })(Marionette);
-
+  
 
   var errorProps = ['description', 'fileName', 'lineNumber', 'name', 'message', 'number'];
-
+  
   Marionette.Error = Marionette.extend.call(Error, {
-    urlRoot: 'http://marionettejs.com/docs/' + Marionette.VERSION + '/',
-
+    urlRoot: 'http://marionettejs.com/docs/v' + Marionette.VERSION + '/',
+  
     constructor: function(message, options) {
       if (_.isObject(message)) {
         options = message;
@@ -852,33 +852,33 @@
       } else if (!options) {
         options = {};
       }
-
+  
       var error = Error.call(this, message);
       _.extend(this, _.pick(error, errorProps), _.pick(options, errorProps));
-
+  
       this.captureStackTrace();
-
+  
       if (options.url) {
         this.url = this.urlRoot + options.url;
       }
     },
-
+  
     captureStackTrace: function() {
       if (Error.captureStackTrace) {
         Error.captureStackTrace(this, Marionette.Error);
       }
     },
-
+  
     toString: function() {
       return this.name + ': ' + this.message + (this.url ? ' See: ' + this.url : '');
     }
   });
-
+  
   Marionette.Error.extend = Marionette.extend;
-
+  
   // Callbacks
   // ---------
-
+  
   // A simple way of managing a collection of callbacks
   // and executing them at a later point in time, using jQuery's
   // `Deferred` object.
@@ -886,23 +886,23 @@
     this._deferred = Marionette.Deferred();
     this._callbacks = [];
   };
-
+  
   _.extend(Marionette.Callbacks.prototype, {
-
+  
     // Add a callback to be executed. Callbacks added here are
     // guaranteed to execute, even if they are added after the
     // `run` method is called.
     add: function(callback, contextOverride) {
       var promise = _.result(this._deferred, 'promise');
-
+  
       this._callbacks.push({cb: callback, ctx: contextOverride});
-
+  
       promise.then(function(args) {
         if (contextOverride){ args.context = contextOverride; }
         callback.call(args.context, args.options);
       });
     },
-
+  
     // Run all registered callbacks with the context specified.
     // Additional callbacks can be added after this has been run
     // and they will still be executed.
@@ -912,20 +912,20 @@
         context: context
       });
     },
-
+  
     // Resets the list of callbacks to be run, allowing the same list
     // to be run multiple times - whenever the `run` method is called.
     reset: function() {
       var callbacks = this._callbacks;
       this._deferred = Marionette.Deferred();
       this._callbacks = [];
-
+  
       _.each(callbacks, function(cb) {
         this.add(cb.cb, cb.ctx);
       }, this);
     }
   });
-
+  
   // Marionette Controller
   // ---------------------
   //
@@ -934,38 +934,38 @@
   // and coordination of other objects, views, and more.
   Marionette.Controller = function(options) {
     this.options = options || {};
-
+  
     if (_.isFunction(this.initialize)) {
       this.initialize(this.options);
     }
   };
-
+  
   Marionette.Controller.extend = Marionette.extend;
-
+  
   // Controller Methods
   // --------------
-
+  
   // Ensure it can trigger events with Backbone.Events
   _.extend(Marionette.Controller.prototype, Backbone.Events, {
     destroy: function() {
       var args = slice.call(arguments);
       this.triggerMethod.apply(this, ['before:destroy'].concat(args));
       this.triggerMethod.apply(this, ['destroy'].concat(args));
-
+  
       this.stopListening();
       this.off();
       return this;
     },
-
+  
     // import the `triggerMethod` to trigger events with corresponding
     // methods if the method exists
     triggerMethod: Marionette.triggerMethod,
-
+  
     // Proxy `getOption` to enable getting options from this or this.options by name.
     getOption: Marionette.proxyGetOption
-
+  
   });
-
+  
   // Marionette Object
   // ---------------------
   //
@@ -973,79 +973,79 @@
   // Object borrows many conventions and utilities from Backbone.
   Marionette.Object = function(options) {
     this.options = _.extend({}, _.result(this, 'options'), options);
-
+  
     this.initialize.apply(this, arguments);
   };
-
+  
   Marionette.Object.extend = Marionette.extend;
-
+  
   // Object Methods
   // --------------
-
+  
   _.extend(Marionette.Object.prototype, {
-
+  
     //this is a noop method intended to be overridden by classes that extend from this base
     initialize: function() {},
-
+  
     destroy: function() {
       this.triggerMethod('before:destroy');
       this.triggerMethod('destroy');
       this.stopListening();
     },
-
+  
     // Import the `triggerMethod` to trigger events with corresponding
     // methods if the method exists
     triggerMethod: Marionette.triggerMethod,
-
+  
     // Proxy `getOption` to enable getting options from this or this.options by name.
     getOption: Marionette.proxyGetOption,
-
+  
     // Proxy `unbindEntityEvents` to enable binding view's events from another entity.
     bindEntityEvents: Marionette.proxyBindEntityEvents,
-
+  
     // Proxy `unbindEntityEvents` to enable unbinding view's events from another entity.
     unbindEntityEvents: Marionette.proxyUnbindEntityEvents
   });
-
+  
   // Ensure it can trigger events with Backbone.Events
   _.extend(Marionette.Object.prototype, Backbone.Events);
-
+  
   /* jshint maxcomplexity: 10, maxstatements: 29 */
-
+  
   // Region
   // ------
   //
   // Manage the visual regions of your composite application. See
   // http://lostechies.com/derickbailey/2011/12/12/composite-js-apps-regions-and-region-managers/
-
+  
   Marionette.Region = function(options) {
     this.options = options || {};
     this.el = this.getOption('el');
-
+  
     // Handle when this.el is passed in as a $ wrapped element.
     this.el = this.el instanceof Backbone.$ ? this.el[0] : this.el;
-
+  
     if (!this.el) {
       throw new Marionette.Error({
         name: 'NoElError',
         message: 'An "el" must be specified for a region.'
       });
     }
-
+  
     this.$el = this.getEl(this.el);
-
+  
     if (this.initialize) {
       var args = slice.apply(arguments);
       this.initialize.apply(this, args);
     }
   };
-
-
+  
+  
   // Region Class methods
   // -------------------
-
+  
   _.extend(Marionette.Region, {
-
+  
     // Build an instance of a region by passing in a configuration object
     // and a default region class to use if none is specified in the config.
     //
@@ -1064,26 +1064,26 @@
       if (_.isString(regionConfig)) {
         return this._buildRegionFromSelector(regionConfig, DefaultRegionClass);
       }
-
+  
       if (regionConfig.selector || regionConfig.el || regionConfig.regionClass) {
         return this._buildRegionFromObject(regionConfig, DefaultRegionClass);
       }
-
+  
       if (_.isFunction(regionConfig)) {
         return this._buildRegionFromRegionClass(regionConfig);
       }
-
+  
       throw new Marionette.Error({
         message: 'Improper region configuration type.',
         url: 'marionette.region.html#region-configuration-types'
       });
     },
-
+  
     // Build the region from a string selector like '#foo-region'
     _buildRegionFromSelector: function(selector, DefaultRegionClass) {
       return new DefaultRegionClass({ el: selector });
     },
-
+  
     // Build the region from a configuration object
     // ```js
     // { selector: '#foo', regionClass: FooRegion }
@@ -1091,13 +1091,13 @@
     _buildRegionFromObject: function(regionConfig, DefaultRegionClass) {
       var RegionClass = regionConfig.regionClass || DefaultRegionClass;
       var options = _.omit(regionConfig, 'selector', 'regionClass');
-
+  
       if (regionConfig.selector && !options.el) {
         options.el = regionConfig.selector;
       }
-
+  
       var region = new RegionClass(options);
-
+  
       // override the `getEl` function if we have a parentEl
       // this must be overridden to ensure the selector is found
       // on the first use of the region. if we try to assign the
@@ -1116,22 +1116,22 @@
           return parentEl.find(el);
         };
       }
-
+  
       return region;
     },
-
+  
     // Build the region directly from a given `RegionClass`
     _buildRegionFromRegionClass: function(RegionClass) {
       return new RegionClass();
     }
-
+  
   });
-
+  
   // Region Instance Methods
   // -----------------------
-
+  
   _.extend(Marionette.Region.prototype, Backbone.Events, {
-
+  
     // Displays a backbone view instance inside of the region.
     // Handles calling the `render` method for you. Reads content
     // directly from the `el` attribute. Also calls an optional
@@ -1141,86 +1141,90 @@
     // the old view being destroyed on show.
     // The `forceShow` option can be used to force a view to be
     // re-rendered if it's already shown in the region.
-
+  
     show: function(view, options){
       this._ensureElement();
-
-      var showOptions = options || {};
+  
+      var showOptions     = options || {};
       var isDifferentView = view !== this.currentView;
-      var preventDestroy =  !!showOptions.preventDestroy;
-      var forceShow = !!showOptions.forceShow;
-
-      // we are only changing the view if there is a view to change to begin with
+      var preventDestroy  = !!showOptions.preventDestroy;
+      var forceShow       = !!showOptions.forceShow;
+  
+      // We are only changing the view if there is a current view to change to begin with
       var isChangingView = !!this.currentView;
-
-      // only destroy the view if we don't want to preventDestroy and the view is different
-      var _shouldDestroyView = !preventDestroy && isDifferentView;
-
-      // show the view if the view is different or if you want to re-show the view
+  
+      // Only destroy the current view if we don't want to `preventDestroy` and if
+      // the view given in the first argument is different than `currentView`
+      var _shouldDestroyView = isDifferentView && !preventDestroy;
+  
+      // Only show the view given in the first argument if it is different than
+      // the current view or if we want to re-show the view. Note that if
+      // `_shouldDestroyView` is true, then `_shouldShowView` is also necessarily true.
       var _shouldShowView = isDifferentView || forceShow;
-
+  
       if (isChangingView) {
         this.triggerMethod('before:swapOut', this.currentView);
       }
-
+  
       if (_shouldDestroyView) {
         this.empty();
       }
-
+  
       if (_shouldShowView) {
-
+  
         // We need to listen for if a view is destroyed
         // in a way other than through the region.
         // If this happens we need to remove the reference
         // to the currentView since once a view has been destroyed
         // we can not reuse it.
-        view.once('destroy', _.bind(this.empty, this));
+        view.once('destroy', this.empty, this);
         view.render();
-
+  
         if (isChangingView) {
           this.triggerMethod('before:swap', view);
         }
-
+  
         this.triggerMethod('before:show', view);
         Marionette.triggerMethodOn(view, 'before:show');
-
+  
+        this.attachHtml(view);
+  
         if (isChangingView) {
           this.triggerMethod('swapOut', this.currentView);
         }
-
-        this.attachHtml(view);
+  
         this.currentView = view;
-
+  
         if (isChangingView) {
           this.triggerMethod('swap', view);
         }
-
+  
         this.triggerMethod('show', view);
         Marionette.triggerMethodOn(view, 'show');
-
+  
         return this;
       }
-
+  
       return this;
     },
-
+  
     _ensureElement: function(){
       if (!_.isObject(this.el)) {
         this.$el = this.getEl(this.el);
         this.el = this.$el[0];
       }
-
+  
       if (!this.$el || this.$el.length === 0) {
         throw new Marionette.Error('An "el" ' + this.$el.selector + ' must exist in DOM');
       }
     },
-
+  
     // Override this method to change how the region finds the
     // DOM element that it manages. Return a jQuery selector object.
     getEl: function(el) {
       return Backbone.$(el);
     },
-
+  
     // Override this method to change how the new view is
     // appended to the `$el` that the region is managing
     attachHtml: function(view) {
@@ -1228,37 +1232,38 @@
       this.el.innerHTML='';
       this.el.appendChild(view.el);
     },
-
+  
     // Destroy the current view, if there is one. If there is no
     // current view, it does nothing and returns immediately.
     empty: function() {
       var view = this.currentView;
-
+  
       // If there is no view in the region
       // we should not remove anything
       if (!view) { return; }
-
+  
+      view.off('destroy', this.empty, this);
       this.triggerMethod('before:empty', view);
       this._destroyView();
       this.triggerMethod('empty', view);
-
+  
       // Remove region pointer to the currentView
       delete this.currentView;
       return this;
     },
-
+  
     // call 'destroy' or 'remove', depending on which is found
     // on the view (if showing a raw Backbone view or a Marionette View)
     _destroyView: function() {
       var view = this.currentView;
-
+  
       if (view.destroy && !view.isDestroyed) {
         view.destroy();
       } else if (view.remove) {
         view.remove();
       }
     },
-
+  
     // Attach an existing view to the region. This
     // will not call `render` or `onShow` for the new view,
     // and will not replace the current HTML for the `el`
@@ -1267,52 +1272,52 @@
       this.currentView = view;
       return this;
     },
-
+  
     // Checks whether a view is currently present within
     // the region. Returns `true` if there is and `false` if
     // no view is present.
     hasView: function() {
       return !!this.currentView;
     },
-
+  
     // Reset the region by destroying any existing view and
     // clearing out the cached `$el`. The next time a view
     // is shown via this region, the region will re-query the
     // DOM for the region's `el`.
     reset: function() {
       this.empty();
-
+  
       if (this.$el) {
         this.el = this.$el.selector;
       }
-
+  
       delete this.$el;
       return this;
     },
-
+  
     // Proxy `getOption` to enable getting options from this or this.options by name.
     getOption: Marionette.proxyGetOption,
-
+  
     // import the `triggerMethod` to trigger events with corresponding
     // methods if the method exists
     triggerMethod: Marionette.triggerMethod
   });
-
+  
   // Copy the `extend` function used by Backbone's classes
   Marionette.Region.extend = Marionette.extend;
-
+  
   // Marionette.RegionManager
   // ------------------------
   //
   // Manage one or more related `Marionette.Region` objects.
   Marionette.RegionManager = (function(Marionette) {
-
+  
     var RegionManager = Marionette.Controller.extend({
       constructor: function(options) {
         this._regions = {};
         Marionette.Controller.call(this, options);
       },
-
+  
       // Add multiple regions using an object literal or a
       // function that returns an object literal, where
       // each key becomes the region name, and each value is
@@ -1321,63 +1326,63 @@
         if (_.isFunction(regionDefinitions)) {
           regionDefinitions = regionDefinitions.apply(this, arguments);
         }
-
+  
         var regions = {};
-
+  
         _.each(regionDefinitions, function(definition, name) {
           if (_.isString(definition)) {
             definition = {selector: definition};
           }
-
+  
           if (definition.selector) {
             definition = _.defaults({}, definition, defaults);
           }
-
+  
           var region = this.addRegion(name, definition);
           regions[name] = region;
         }, this);
-
+  
         return regions;
       },
-
+  
       // Add an individual region to the region manager,
       // and return the region instance
       addRegion: function(name, definition) {
         var region;
-
+  
         if (definition instanceof Marionette.Region) {
           region = definition;
         } else {
           region = Marionette.Region.buildRegion(definition, Marionette.Region);
         }
-
+  
         this.triggerMethod('before:add:region', name, region);
-
+  
         this._store(name, region);
-
+  
         this.triggerMethod('add:region', name, region);
         return region;
       },
-
+  
       // Get a region by name
       get: function(name) {
         return this._regions[name];
       },
-
+  
       // Gets all the regions contained within
       // the `regionManager` instance.
       getRegions: function(){
         return _.clone(this._regions);
       },
-
+  
       // Remove a region by name
       removeRegion: function(name) {
         var region = this._regions[name];
         this._remove(name, region);
-
+  
         return region;
       },
-
+  
       // Empty all regions in the region manager, and
       // remove them
       removeRegions: function() {
@@ -1385,10 +1390,10 @@
         _.each(this._regions, function(region, name) {
           this._remove(name, region);
         }, this);
-
+  
         return regions;
       },
-
+  
       // Empty all regions in the region manager, but
       // leave them attached
       emptyRegions: function() {
@@ -1396,23 +1401,23 @@
         _.each(regions, function(region) {
           region.empty();
         }, this);
-
+  
         return regions;
       },
-
+  
       // Destroy all regions and shut down the region
       // manager entirely
       destroy: function() {
         this.removeRegions();
         return Marionette.Controller.prototype.destroy.apply(this, arguments);
       },
-
+  
       // internal method to store regions
       _store: function(name, region) {
         this._regions[name] = region;
         this._setLength();
       },
-
+  
       // internal method to remove a region
       _remove: function(name, region) {
         this.triggerMethod('before:remove:region', name, region);
@@ -1422,49 +1427,49 @@
         this._setLength();
         this.triggerMethod('remove:region', name, region);
       },
-
+  
       // set the number of regions current held
       _setLength: function() {
         this.length = _.size(this._regions);
       }
-
+  
     });
-
+  
     Marionette.actAsCollection(RegionManager.prototype, '_regions');
-
+  
     return RegionManager;
   })(Marionette);
-
+  
 
   // Template Cache
   // --------------
-
+  
   // Manage templates stored in `<script>` blocks,
   // caching them for faster access.
   Marionette.TemplateCache = function(templateId) {
     this.templateId = templateId;
   };
-
+  
   // TemplateCache object-level methods. Manage the template
   // caches from these method calls instead of creating
   // your own TemplateCache instances
   _.extend(Marionette.TemplateCache, {
     templateCaches: {},
-
+  
     // Get the specified template by id. Either
     // retrieves the cached version, or loads it
     // from the DOM.
     get: function(templateId) {
       var cachedTemplate = this.templateCaches[templateId];
-
+  
       if (!cachedTemplate) {
         cachedTemplate = new Marionette.TemplateCache(templateId);
         this.templateCaches[templateId] = cachedTemplate;
       }
-
+  
       return cachedTemplate.load();
     },
-
+  
     // Clear templates from the cache. If no arguments
     // are specified, clears all templates:
     // `clear()`
@@ -1476,7 +1481,7 @@
       var i;
       var args = slice.call(arguments);
       var length = args.length;
-
+  
       if (length > 0) {
         for (i = 0; i < length; i++) {
           delete this.templateCaches[args[i]];
@@ -1486,26 +1491,26 @@
       }
     }
   });
-
+  
   // TemplateCache instance methods, allowing each
   // template cache object to manage its own state
   // and know whether or not it has been loaded
   _.extend(Marionette.TemplateCache.prototype, {
-
+  
     // Internal method to load the template
     load: function() {
       // Guard clause to prevent loading this template more than once
       if (this.compiledTemplate) {
         return this.compiledTemplate;
       }
-
+  
       // Load the template and compile it
       var template = this.loadTemplate(this.templateId);
       this.compiledTemplate = this.compileTemplate(template);
-
+  
       return this.compiledTemplate;
     },
-
+  
     // Load a template from the DOM, by default. Override
     // this method to provide your own template retrieval
     // For asynchronous loading with AMD/RequireJS, consider
@@ -1513,17 +1518,17 @@
     // https://github.com/marionettejs/backbone.marionette/wiki/Using-marionette-with-requirejs
     loadTemplate: function(templateId) {
       var template = Backbone.$(templateId).html();
-
+  
       if (!template || template.length === 0) {
         throw new Marionette.Error({
           name: 'NoTemplateError',
           message: 'Could not find template: "' + templateId + '"'
         });
       }
-
+  
       return template;
     },
-
+  
     // Pre-compile the template before caching it. Override
     // this method if you do not need to pre-compile a template
     // (JST / RequireJS for example) or if you want to change
@@ -1532,14 +1537,14 @@
       return _.template(rawTemplate);
     }
   });
-
+  
   // Renderer
   // --------
-
+  
   // Render a template with data by passing in the template
   // selector and the data to render.
   Marionette.Renderer = {
-
+  
     // Render a template with data. The `template` parameter is
     // passed to the `TemplateCache` object to retrieve the
     // template function. Override this method to provide your own
@@ -1551,43 +1556,43 @@
           message: 'Cannot render the template since its false, null or undefined.'
         });
       }
-
+  
       var templateFunc;
       if (typeof template === 'function') {
         templateFunc = template;
       } else {
         templateFunc = Marionette.TemplateCache.get(template);
       }
-
+  
       return templateFunc(data);
     }
   };
-
+  
 
   /* jshint maxlen: 114, nonew: false */
   // Marionette.View
   // ---------------
-
+  
   // The core view class that other Marionette views extend from.
   Marionette.View = Backbone.View.extend({
-
+  
     constructor: function(options) {
       _.bindAll(this, 'render');
-
+  
       // this exposes view options to the view initializer
       // this is a backfill since backbone removed the assignment
       // of this.options
       // at some point however this may be removed
       this.options = _.extend({}, _.result(this, 'options'), _.isFunction(options) ? options.call(this) : options);
-
+  
       this._behaviors = Marionette.Behaviors(this);
-
+  
       Backbone.View.apply(this, arguments);
-
+  
       Marionette.MonitorDOMRefresh(this);
       this.listenTo(this, 'show', this.onShowCalled);
     },
-
+  
     // Get the template for this view
     // instance. You can set a `template` attribute in the view
     // definition or pass a `template: "whatever"` parameter in
@@ -1595,13 +1600,13 @@
     getTemplate: function() {
       return this.getOption('template');
     },
-
+  
     // Serialize a model by returning its attributes. Clones
     // the attributes to allow modification.
     serializeModel: function(model){
       return model.toJSON.apply(model, slice.call(arguments, 1));
     },
-
+  
     // Mix in template helper methods. Looks for a
     // `templateHelpers` attribute, which can either be an
     // object literal, or a function that returns an object
@@ -1615,7 +1620,7 @@
       }
       return _.extend(target, templateHelpers);
     },
-
+  
     // normalize the keys of passed hash with the views `ui` selectors.
     // `{"@ui.foo": "bar"}`
     normalizeUIKeys: function(hash) {
@@ -1623,7 +1628,7 @@
       var uiBindings = _.result(this, '_uiBindings');
       return Marionette.normalizeUIKeys(hash, uiBindings || ui);
     },
-
+  
     // normalize the values of passed hash with the views `ui` selectors.
     // `{foo: "@ui.bar"}`
     normalizeUIValues: function(hash) {
@@ -1631,83 +1636,83 @@
       var uiBindings = _.result(this, '_uiBindings');
       return Marionette.normalizeUIValues(hash, uiBindings || ui);
     },
-
+  
     // Configure `triggers` to forward DOM events to view
     // events. `triggers: {"click .foo": "do:foo"}`
     configureTriggers: function() {
       if (!this.triggers) { return; }
-
+  
       var triggerEvents = {};
-
+  
       // Allow `triggers` to be configured as a function
       var triggers = this.normalizeUIKeys(_.result(this, 'triggers'));
-
+  
       // Configure the triggers, prevent default
       // action and stop propagation of DOM events
       _.each(triggers, function(value, key) {
         triggerEvents[key] = this._buildViewTrigger(value);
       }, this);
-
+  
       return triggerEvents;
     },
-
+  
     // Overriding Backbone.View's delegateEvents to handle
     // the `triggers`, `modelEvents`, and `collectionEvents` configuration
     delegateEvents: function(events) {
       this._delegateDOMEvents(events);
       this.bindEntityEvents(this.model, this.getOption('modelEvents'));
       this.bindEntityEvents(this.collection, this.getOption('collectionEvents'));
-
+  
       _.each(this._behaviors, function(behavior) {
         behavior.bindEntityEvents(this.model, behavior.getOption('modelEvents'));
         behavior.bindEntityEvents(this.collection, behavior.getOption('collectionEvents'));
       }, this);
-
+  
       return this;
     },
-
+  
     // internal method to delegate DOM events and triggers
     _delegateDOMEvents: function(eventsArg) {
       var events = eventsArg || this.events;
       if (_.isFunction(events)) { events = events.call(this); }
-
+  
       // normalize ui keys
       events = this.normalizeUIKeys(events);
       if(_.isUndefined(eventsArg)) {this.events = events;}
-
+  
       var combinedEvents = {};
-
+  
       // look up if this view has behavior events
       var behaviorEvents = _.result(this, 'behaviorEvents') || {};
       var triggers = this.configureTriggers();
       var behaviorTriggers = _.result(this, 'behaviorTriggers') || {};
-
+  
       // behavior events will be overriden by view events and or triggers
       _.extend(combinedEvents, behaviorEvents, events, triggers, behaviorTriggers);
-
+  
       Backbone.View.prototype.delegateEvents.call(this, combinedEvents);
     },
-
+  
     // Overriding Backbone.View's undelegateEvents to handle unbinding
     // the `triggers`, `modelEvents`, and `collectionEvents` config
     undelegateEvents: function() {
       var args = slice.call(arguments);
       Backbone.View.prototype.undelegateEvents.apply(this, args);
-
+  
       this.unbindEntityEvents(this.model, this.getOption('modelEvents'));
       this.unbindEntityEvents(this.collection, this.getOption('collectionEvents'));
-
+  
       _.each(this._behaviors, function(behavior) {
         behavior.unbindEntityEvents(this.model, behavior.getOption('modelEvents'));
         behavior.unbindEntityEvents(this.collection, behavior.getOption('collectionEvents'));
       }, this);
-
+  
       return this;
     },
-
+  
     // Internal method, handles the `show` event.
     onShowCalled: function() {},
-
+  
     // Internal helper method to verify whether the view hasn't been destroyed
     _ensureViewIsIntact: function() {
       if (this.isDestroyed) {
@@ -1717,173 +1722,173 @@
         });
       }
     },
-
+  
     // Default `destroy` implementation, for removing a view from the
     // DOM and unbinding it. Regions will call this method
     // for you. You can specify an `onDestroy` method in your view to
     // add custom code that is called after the view is destroyed.
     destroy: function() {
       if (this.isDestroyed) { return; }
-
+  
       var args = slice.call(arguments);
-
+  
       this.triggerMethod.apply(this, ['before:destroy'].concat(args));
-
+  
       // mark as destroyed before doing the actual destroy, to
       // prevent infinite loops within "destroy" event handlers
       // that are trying to destroy other views
       this.isDestroyed = true;
       this.triggerMethod.apply(this, ['destroy'].concat(args));
-
+  
       // unbind UI elements
       this.unbindUIElements();
-
+  
       // remove the view from the DOM
       this.remove();
-
+  
       // Call destroy on each behavior after
       // destroying the view.
       // This unbinds event listeners
       // that behaviors have registered for.
       _.invoke(this._behaviors, 'destroy', args);
-
+  
       return this;
     },
-
+  
     bindUIElements: function() {
       this._bindUIElements();
       _.invoke(this._behaviors, this._bindUIElements);
     },
-
+  
     // This method binds the elements specified in the "ui" hash inside the view's code with
     // the associated jQuery selectors.
     _bindUIElements: function() {
       if (!this.ui) { return; }
-
+  
       // store the ui hash in _uiBindings so they can be reset later
       // and so re-rendering the view will be able to find the bindings
       if (!this._uiBindings) {
         this._uiBindings = this.ui;
       }
-
+  
       // get the bindings result, as a function or otherwise
       var bindings = _.result(this, '_uiBindings');
-
+  
       // empty the ui so we don't have anything to start with
       this.ui = {};
-
+  
       // bind each of the selectors
       _.each(_.keys(bindings), function(key) {
         var selector = bindings[key];
         this.ui[key] = this.$(selector);
       }, this);
     },
-
+  
     // This method unbinds the elements specified in the "ui" hash
     unbindUIElements: function() {
       this._unbindUIElements();
       _.invoke(this._behaviors, this._unbindUIElements);
     },
-
+  
     _unbindUIElements: function() {
       if (!this.ui || !this._uiBindings) { return; }
-
+  
       // delete all of the existing ui bindings
       _.each(this.ui, function($el, name) {
         delete this.ui[name];
       }, this);
-
+  
       // reset the ui element to the original bindings configuration
       this.ui = this._uiBindings;
       delete this._uiBindings;
     },
-
+  
     // Internal method to create an event handler for a given `triggerDef` like
     // 'click:foo'
     _buildViewTrigger: function(triggerDef) {
       var hasOptions = _.isObject(triggerDef);
-
+  
       var options = _.defaults({}, (hasOptions ? triggerDef : {}), {
         preventDefault: true,
         stopPropagation: true
       });
-
+  
       var eventName = hasOptions ? options.event : triggerDef;
-
+  
       return function(e) {
         if (e) {
           if (e.preventDefault && options.preventDefault) {
             e.preventDefault();
           }
-
+  
           if (e.stopPropagation && options.stopPropagation) {
             e.stopPropagation();
           }
         }
-
+  
         var args = {
           view: this,
           model: this.model,
           collection: this.collection
         };
-
+  
         this.triggerMethod(eventName, args);
       };
     },
-
+  
     setElement: function() {
       var ret = Backbone.View.prototype.setElement.apply(this, arguments);
-
+  
       // proxy behavior $el to the view's $el.
       // This is needed because a view's $el proxy
       // is not set until after setElement is called.
       _.invoke(this._behaviors, 'proxyViewProperties', this);
-
+  
       return ret;
     },
-
+  
     // import the `triggerMethod` to trigger events with corresponding
     // methods if the method exists
     triggerMethod: function() {
       var args = arguments;
       var triggerMethod = Marionette.triggerMethod;
-
+  
       var ret = triggerMethod.apply(this, args);
       _.each(this._behaviors, function(b) {
         triggerMethod.apply(b, args);
       });
-
+  
       return ret;
     },
-
+  
     // Imports the "normalizeMethods" to transform hashes of
     // events=>function references/names to a hash of events=>function references
     normalizeMethods: Marionette.normalizeMethods,
-
+  
     // Proxy `getOption` to enable getting options from this or this.options by name.
     getOption: Marionette.proxyGetOption,
-
+  
     // Proxy `unbindEntityEvents` to enable binding view's events from another entity.
     bindEntityEvents: Marionette.proxyBindEntityEvents,
-
+  
     // Proxy `unbindEntityEvents` to enable unbinding view's events from another entity.
     unbindEntityEvents: Marionette.proxyUnbindEntityEvents
   });
-
+  
   // Item View
   // ---------
-
+  
   // A single item view implementation that contains code for rendering
   // with underscore.js templates, serializing the view's model or collection,
   // and calling several methods on extended views, such as `onRender`.
   Marionette.ItemView = Marionette.View.extend({
-
+  
     // Setting up the inheritance chain which allows changes to
     // Marionette.View.prototype.constructor which allows overriding
     constructor: function() {
       Marionette.View.apply(this, arguments);
     },
-
+  
     // Serialize the model or collection for the view. If a model is
     // found, the view's `serializeModel` is called. If a collection is found,
     // each model in the collection is serialized by calling
@@ -1893,22 +1898,22 @@
     // to provide custom serialization for your view's data.
     serializeData: function(){
       var data = {};
-
+  
       if (this.model) {
         data = _.partial(this.serializeModel, this.model).apply(this, arguments);
       }
       else if (this.collection) {
         data = { items: _.partial(this.serializeCollection, this.collection).apply(this, arguments) };
       }
-
+  
       return data;
     },
-
+  
     // Serialize a collection by serializing each of its models.
     serializeCollection: function(collection){
       return collection.toJSON.apply(collection, slice.call(arguments, 1));
     },
-
+  
     // Render the view, defaulting to underscore.js templates.
     // You can override this in your view definition to provide
     // a very specific rendering for your view. In general, though,
@@ -1916,47 +1921,47 @@
     // change how Marionette renders views.
     render: function() {
       this._ensureViewIsIntact();
-
+  
       this.triggerMethod('before:render', this);
-
+  
       this._renderTemplate();
       this.bindUIElements();
-
+  
       this.triggerMethod('render', this);
-
+  
       return this;
     },
-
+  
     // Internal method to render the template with the serialized data
     // and template helpers via the `Marionette.Renderer` object.
     // Throws an `UndefinedTemplateError` error if the template is
     // any falsely value but literal `false`.
     _renderTemplate: function() {
       var template = this.getTemplate();
-
+  
       // Allow template-less item views
       if (template === false) {
         return;
       }
-
+  
       if (!template) {
         throw new Marionette.Error({
           name: 'UndefinedTemplateError',
           message: 'Cannot render the template since it is null or undefined.'
         });
       }
-
+  
       // Add in entity data and template helpers
       var data = this.serializeData();
       data = this.mixinTemplateHelpers(data);
-
+  
       // Render and add to el
       var html = Marionette.Renderer.render(template, data, this);
       this.attachElContent(html);
-
+  
       return this;
     },
-
+  
     // Attaches the content of a given view.
     // This method can be overridden to optimize rendering,
     // or to render in a non standard way.
@@ -1971,32 +1976,32 @@
     // ```
     attachElContent: function(html) {
       this.$el.html(html);
-
+  
       return this;
     },
-
+  
     // Override the default destroy event to add a few
     // more events that are triggered.
     destroy: function() {
       if (this.isDestroyed) { return; }
-
+  
       return Marionette.View.prototype.destroy.apply(this, arguments);
     }
   });
-
+  
   /* jshint maxstatements: 14 */
-
+  
   // Collection View
   // ---------------
-
+  
   // A view that iterates over a Backbone.Collection
   // and renders an individual child view for each model.
   Marionette.CollectionView = Marionette.View.extend({
-
+  
     // used as the prefix for child view events
     // that are forwarded through the collectionview
     childViewEventPrefix: 'childview',
-
+  
     // constructor
     // option to pass `{sort: false}` to prevent the `CollectionView` from
     // maintaining the sorted order of the collection.
@@ -2004,15 +2009,15 @@
     constructor: function(options){
       var initOptions = options || {};
       this.sort = _.isUndefined(initOptions.sort) ? true : initOptions.sort;
-
+  
       this.once('render', this._initialEvents);
       this._initChildViewStorage();
-
+  
       Marionette.View.apply(this, arguments);
-
+  
       this.initRenderBuffer();
     },
-
+  
     // Instead of inserting elements one by one into the page,
     // it's much more performant to insert elements into a document
     // fragment and then insert that document fragment into the page
@@ -2020,12 +2025,12 @@
       this.elBuffer = document.createDocumentFragment();
       this._bufferedChildren = [];
     },
-
+  
     startBuffering: function() {
       this.initRenderBuffer();
       this.isBuffering = true;
     },
-
+  
     endBuffering: function() {
       this.isBuffering = false;
       this._triggerBeforeShowBufferedChildren();
@@ -2033,27 +2038,27 @@
       this._triggerShowBufferedChildren();
       this.initRenderBuffer();
     },
-
+  
     _triggerBeforeShowBufferedChildren: function() {
       if (this._isShown) {
         _.each(this._bufferedChildren, _.partial(this._triggerMethodOnChild, 'before:show'));
       }
     },
-
+  
     _triggerShowBufferedChildren: function() {
       if (this._isShown) {
         _.each(this._bufferedChildren, _.partial(this._triggerMethodOnChild, 'show'));
-
+  
         this._bufferedChildren = [];
       }
     },
-
+  
     // Internal method for _.each loops to call `Marionette.triggerMethodOn` on
     // a child view
     _triggerMethodOnChild: function(event, childView) {
       Marionette.triggerMethodOn(childView, event);
     },
-
+  
     // Configured the initial events that the collection view
     // binds to.
     _initialEvents: function() {
@@ -2061,13 +2066,13 @@
         this.listenTo(this.collection, 'add', this._onCollectionAdd);
         this.listenTo(this.collection, 'remove', this._onCollectionRemove);
         this.listenTo(this.collection, 'reset', this.render);
-
+  
         if (this.sort) {
           this.listenTo(this.collection, 'sort', this._sortViews);
         }
       }
     },
-
+  
     // Handle a child added to the collection
     _onCollectionAdd: function(child) {
       this.destroyEmptyView();
@@ -2075,19 +2080,19 @@
       var index = this.collection.indexOf(child);
       this.addChild(child, ChildView, index);
     },
-
+  
     // get the child view by model it holds, and remove it
     _onCollectionRemove: function(model) {
       var view = this.children.findByModel(model);
       this.removeChildView(view);
       this.checkEmpty();
     },
-
+  
     // Override from `Marionette.View` to trigger show on child views
     onShowCalled: function() {
       this.children.each(_.partial(this._triggerMethodOnChild, 'show'));
     },
-
+  
     // Render children views. Override this method to
     // provide your own implementation of a render function for
     // the collection view.
@@ -2098,7 +2103,7 @@
       this.triggerMethod('render', this);
       return this;
     },
-
+  
     // Render view after sorting. Override this method to
     // change how the view renders after a `sort` on the collection.
     // An example of this would be to only `renderChildren` in a `CompositeView`
@@ -2106,7 +2111,7 @@
     resortView: function() {
       this.render();
     },
-
+  
     // Internal method. This checks for any changes in the order of the collection.
     // If the index of any view doesn't match, it will render.
     _sortViews: function() {
@@ -2115,19 +2120,19 @@
         var view = this.children.findByModel(item);
         return !view || view._index !== index;
       }, this);
-
+  
       if (orderChanged) {
         this.resortView();
       }
     },
-
+  
     // Internal method. Separated so that CompositeView can have
     // more control over events being triggered, around the rendering
     // process
     _renderChildren: function() {
       this.destroyEmptyView();
       this.destroyChildren();
-
+  
       if (this.isEmpty(this.collection)) {
         this.showEmptyView();
       } else {
@@ -2138,7 +2143,7 @@
         this.triggerMethod('render:collection', this);
       }
     },
-
+  
     // Internal method to loop through collection and show each child view.
     showCollection: function() {
       var ChildView;
@@ -2147,81 +2152,81 @@
         this.addChild(child, ChildView, index);
       }, this);
     },
-
+  
     // Internal method to show an empty view in place of
     // a collection of child views, when the collection is empty
     showEmptyView: function() {
       var EmptyView = this.getEmptyView();
-
+  
       if (EmptyView && !this._showingEmptyView) {
         this.triggerMethod('before:render:empty');
-
+  
         this._showingEmptyView = true;
         var model = new Backbone.Model();
         this.addEmptyView(model, EmptyView);
-
+  
         this.triggerMethod('render:empty');
       }
     },
-
+  
     // Internal method to destroy an existing emptyView instance
     // if one exists. Called when a collection view has been
     // rendered empty, and then a child is added to the collection.
     destroyEmptyView: function() {
       if (this._showingEmptyView) {
         this.triggerMethod('before:remove:empty');
-
+  
         this.destroyChildren();
         delete this._showingEmptyView;
-
+  
         this.triggerMethod('remove:empty');
       }
     },
-
+  
     // Retrieve the empty view class
     getEmptyView: function() {
       return this.getOption('emptyView');
     },
-
+  
     // Render and show the emptyView. Similar to addChild method
     // but "child:added" events are not fired, and the event from
     // emptyView are not forwarded
     addEmptyView: function(child, EmptyView) {
-
+  
       // get the emptyViewOptions, falling back to childViewOptions
       var emptyViewOptions = this.getOption('emptyViewOptions') ||
                             this.getOption('childViewOptions');
-
+  
       if (_.isFunction(emptyViewOptions)){
         emptyViewOptions = emptyViewOptions.call(this);
       }
-
+  
       // build the empty view
       var view = this.buildChildView(child, EmptyView, emptyViewOptions);
-
+  
       // Proxy emptyView events
       this.proxyChildEvents(view);
-
+  
       // trigger the 'before:show' event on `view` if the collection view
       // has already been shown
       if (this._isShown) {
         Marionette.triggerMethodOn(view, 'before:show');
       }
-
+  
       // Store the `emptyView` like a `childView` so we can properly
       // remove and/or close it later
       this.children.add(view);
-
+  
       // Render it and show it
       this.renderChildView(view, -1);
-
+  
       // call the 'show' method if the collection view
       // has already been shown
       if (this._isShown) {
         Marionette.triggerMethodOn(view, 'show');
       }
     },
-
+  
     // Retrieve the `childView` class, either from `this.options.childView`
     // or from the `childView` in the object definition. The "options"
     // takes precedence.
@@ -2230,17 +2235,17 @@
     // to determine what `childView` class to return.
     getChildView: function(child) {
       var childView = this.getOption('childView');
-
+  
       if (!childView) {
         throw new Marionette.Error({
           name: 'NoChildViewError',
           message: 'A "childView" must be specified'
         });
       }
-
+  
       return childView;
     },
-
+  
     // Render the child's view and add it to the
     // HTML for the collection view at a given index.
     // This will also update the indices of later views in the collection
@@ -2250,28 +2255,28 @@
       if (_.isFunction(childViewOptions)) {
         childViewOptions = childViewOptions.call(this, child, index);
       }
-
+  
       var view = this.buildChildView(child, ChildView, childViewOptions);
-
+  
       // increment indices of views after this one
       this._updateIndices(view, true, index);
-
+  
       this._addChildView(view, index);
-
+  
       return view;
     },
-
+  
     // Internal method. This decrements or increments the indices of views after the
     // added/removed view to keep in sync with the collection.
     _updateIndices: function(view, increment, index) {
       if (!this.sort) {
         return;
       }
-
+  
       if (increment) {
         // assign the index to the view
         view._index = index;
-
+  
         // increment the index of views after this one
         this.children.each(function (laterView) {
           if (laterView._index >= view._index) {
@@ -2288,81 +2293,81 @@
         });
       }
     },
-
-
+  
+  
     // Internal Method. Add the view to children and render it at
     // the given index.
     _addChildView: function(view, index) {
       // set up the child view event forwarding
       this.proxyChildEvents(view);
-
+  
       this.triggerMethod('before:add:child', view);
-
+  
       // Store the child view itself so we can properly
       // remove and/or destroy it later
       this.children.add(view);
       this.renderChildView(view, index);
-
+  
       if (this._isShown && !this.isBuffering) {
         Marionette.triggerMethodOn(view, 'show');
       }
-
+  
       this.triggerMethod('add:child', view);
     },
-
+  
     // render the child view
     renderChildView: function(view, index) {
       view.render();
       this.attachHtml(this, view, index);
       return view;
     },
-
+  
     // Build a `childView` for a model in the collection.
     buildChildView: function(child, ChildViewClass, childViewOptions) {
       var options = _.extend({model: child}, childViewOptions);
       return new ChildViewClass(options);
     },
-
+  
     // Remove the child view and destroy it.
     // This function also updates the indices of
     // later views in the collection in order to keep
     // the children in sync with the collection.
     removeChildView: function(view) {
-
+  
       if (view) {
         this.triggerMethod('before:remove:child', view);
         // call 'destroy' or 'remove', depending on which is found
         if (view.destroy) { view.destroy(); }
         else if (view.remove) { view.remove(); }
-
+  
         this.stopListening(view);
         this.children.remove(view);
         this.triggerMethod('remove:child', view);
-
+  
         // decrement the index of views after this one
         this._updateIndices(view, false);
       }
-
+  
       return view;
     },
-
+  
     // check if the collection is empty
     isEmpty: function() {
       return !this.collection || this.collection.length === 0;
     },
-
+  
     // If empty, show the empty view
     checkEmpty: function() {
       if (this.isEmpty(this.collection)) {
         this.showEmptyView();
       }
     },
-
+  
     // You might need to override this if you've overridden attachHtml
     attachBuffer: function(collectionView, buffer) {
       collectionView.$el.append(buffer);
     },
-
+  
     // Append the HTML to the collection's `el`.
     // Override this method to do something other
     // than `.append`.
@@ -2383,7 +2388,7 @@
         }
       }
     },
-
+  
     // Internal method. Check whether we need to insert the view into
     // the correct position.
     _insertBefore: function(childView, index) {
@@ -2395,37 +2400,37 @@
           return view._index === index + 1;
         });
       }
-
+  
       if (currentView) {
         currentView.$el.before(childView.el);
         return true;
       }
-
+  
       return false;
     },
-
+  
     // Internal method. Append a view to the end of the $el
     _insertAfter: function(childView) {
       this.$el.append(childView.el);
     },
-
+  
     // Internal method to set up the `children` object for
     // storing all of the child views
     _initChildViewStorage: function() {
       this.children = new Backbone.ChildViewContainer();
     },
-
+  
     // Handle cleanup and other destroying needs for the collection of views
     destroy: function() {
       if (this.isDestroyed) { return; }
-
+  
       this.triggerMethod('before:destroy:collection');
       this.destroyChildren();
       this.triggerMethod('destroy:collection');
-
+  
       return Marionette.View.prototype.destroy.apply(this, arguments);
     },
-
+  
     // Destroy the child views that this collection view
     // is holding on to, if any
     destroyChildren: function() {
@@ -2434,42 +2439,42 @@
       this.checkEmpty();
       return childViews;
     },
-
+  
     // Set up the child view event forwarding. Uses a "childview:"
     // prefix in front of all forwarded events.
     proxyChildEvents: function(view) {
       var prefix = this.getOption('childViewEventPrefix');
-
+  
       // Forward all child view events through the parent,
       // prepending "childview:" to the event name
       this.listenTo(view, 'all', function() {
         var args = slice.call(arguments);
         var rootEvent = args[0];
         var childEvents = this.normalizeMethods(_.result(this, 'childEvents'));
-
+  
         args[0] = prefix + ':' + rootEvent;
         args.splice(1, 0, view);
-
+  
         // call collectionView childEvent if defined
         if (typeof childEvents !== 'undefined' && _.isFunction(childEvents[rootEvent])) {
           childEvents[rootEvent].apply(this, args.slice(1));
         }
-
+  
         this.triggerMethod.apply(this, args);
       }, this);
     }
   });
-
+  
   /* jshint maxstatements: 17, maxlen: 117 */
-
+  
   // Composite View
   // --------------
-
+  
   // Used for rendering a branch-leaf, hierarchical structure.
   // Extends directly from CollectionView and also renders an
   // a child view as `modelView`, for the top leaf
   Marionette.CompositeView = Marionette.CollectionView.extend({
-
+  
     // Setting up the inheritance chain which allows changes to
     // Marionette.CollectionView.prototype.constructor which allows overriding
     // option to pass '{sort: false}' to prevent the CompositeView from
@@ -2478,56 +2483,56 @@
     constructor: function() {
       Marionette.CollectionView.apply(this, arguments);
     },
-
+  
     // Configured the initial events that the composite view
     // binds to. Override this method to prevent the initial
     // events, or to add your own initial events.
     _initialEvents: function() {
-
+  
       // Bind only after composite view is rendered to avoid adding child views
       // to nonexistent childViewContainer
-
+  
       if (this.collection) {
         this.listenTo(this.collection, 'add', this._onCollectionAdd);
         this.listenTo(this.collection, 'remove', this._onCollectionRemove);
         this.listenTo(this.collection, 'reset', this._renderChildren);
-
+  
         if (this.sort) {
           this.listenTo(this.collection, 'sort', this._sortViews);
         }
       }
     },
-
+  
     // Retrieve the `childView` to be used when rendering each of
     // the items in the collection. The default is to return
     // `this.childView` or Marionette.CompositeView if no `childView`
     // has been defined
     getChildView: function(child) {
       var childView = this.getOption('childView') || this.constructor;
-
+  
       if (!childView) {
         throw new Marionette.Error({
           name: 'NoChildViewError',
           message: 'A "childView" must be specified'
         });
       }
-
+  
       return childView;
     },
-
+  
     // Serialize the collection for the view.
     // You can override the `serializeData` method in your own view
     // definition, to provide custom serialization for your view's data.
     serializeData: function() {
       var data = {};
-
+  
       if (this.model){
         data = _.partial(this.serializeModel, this.model).apply(this, arguments);
       }
-
+  
       return data;
     },
-
+  
     // Renders the model once, and the collection once. Calling
     // this again will tell the model's view to re-render itself
     // but the collection will not re-render.
@@ -2535,42 +2540,42 @@
       this._ensureViewIsIntact();
       this.isRendered = true;
       this.resetChildViewContainer();
-
+  
       this.triggerMethod('before:render', this);
-
+  
       this._renderTemplate();
       this._renderChildren();
-
+  
       this.triggerMethod('render', this);
       return this;
     },
-
+  
     _renderChildren: function() {
       if (this.isRendered) {
         Marionette.CollectionView.prototype._renderChildren.call(this);
       }
     },
-
+  
     // Render the root template that the children
     // views are appended to
     _renderTemplate: function() {
       var data = {};
       data = this.serializeData();
       data = this.mixinTemplateHelpers(data);
-
+  
       this.triggerMethod('before:render:template');
-
+  
       var template = this.getTemplate();
       var html = Marionette.Renderer.render(template, data, this);
       this.attachElContent(html);
-
+  
       // the ui bindings is done here and not at the end of render since they
       // will not be available until after the model is rendered, but should be
       // available before the collection is rendered.
       this.bindUIElements();
       this.triggerMethod('render:template');
     },
-
+  
     // Attaches the content of the root.
     // This method can be overridden to optimize rendering,
     // or to render in a non standard way.
@@ -2585,16 +2590,16 @@
     // ```
     attachElContent: function(html) {
       this.$el.html(html);
-
+  
       return this;
     },
-
+  
     // You might need to override this if you've overridden attachHtml
     attachBuffer: function(compositeView, buffer) {
       var $container = this.getChildViewContainer(compositeView);
       $container.append(buffer);
     },
-
+  
     // Internal method. Append a view to the end of the $el.
     // Overidden from CollectionView to ensure view is appended to
     // childViewContainer
@@ -2602,41 +2607,41 @@
       var $container = this.getChildViewContainer(this);
       $container.append(childView.el);
     },
-
+  
     // Internal method to ensure an `$childViewContainer` exists, for the
     // `attachHtml` method to use.
     getChildViewContainer: function(containerView) {
       if ('$childViewContainer' in containerView) {
         return containerView.$childViewContainer;
       }
-
+  
       var container;
       var childViewContainer = Marionette.getOption(containerView, 'childViewContainer');
       if (childViewContainer) {
-
+  
         var selector = _.isFunction(childViewContainer) ? childViewContainer.call(containerView) : childViewContainer;
-
+  
         if (selector.charAt(0) === '@' && containerView.ui) {
           container = containerView.ui[selector.substr(4)];
         } else {
           container = containerView.$(selector);
         }
-
+  
         if (container.length <= 0) {
           throw new Marionette.Error({
             name: 'ChildViewContainerMissingError',
             message: 'The specified "childViewContainer" was not found: ' + containerView.childViewContainer
           });
         }
-
+  
       } else {
         container = containerView.$el;
       }
-
+  
       containerView.$childViewContainer = container;
       return container;
     },
-
+  
     // Internal method to reset the `$childViewContainer` on render
     resetChildViewContainer: function() {
       if (this.$childViewContainer) {
@@ -2644,10 +2649,10 @@
       }
     }
   });
-
+  
   // LayoutView
   // ----------
-
+  
   // Used for managing application layoutViews, nested layoutViews and
   // multiple regions within an application or sub-application.
   //
@@ -2656,25 +2661,25 @@
   // Used for composite view management and sub-application areas.
   Marionette.LayoutView = Marionette.ItemView.extend({
     regionClass: Marionette.Region,
-
+  
     // Ensure the regions are available when the `initialize` method
     // is called.
     constructor: function(options) {
       options = options || {};
-
+  
       this._firstRender = true;
       this._initializeRegions(options);
-
+  
       Marionette.ItemView.call(this, options);
     },
-
+  
     // LayoutView's render will use the existing region objects the
     // first time it is called. Subsequent calls will destroy the
     // views that the regions are showing and then reset the `el`
     // for the regions to the newly rendered DOM elements.
     render: function() {
       this._ensureViewIsIntact();
-
+  
       if (this._firstRender) {
         // if this is the first render, don't do anything to
         // reset the regions
@@ -2684,90 +2689,90 @@
         // re-initialize the `el` for each region
         this._reInitializeRegions();
       }
-
+  
       return Marionette.ItemView.prototype.render.apply(this, arguments);
     },
-
+  
     // Handle destroying regions, and then destroy the view itself.
     destroy: function() {
       if (this.isDestroyed) { return this; }
-
+  
       this.regionManager.destroy();
       return Marionette.ItemView.prototype.destroy.apply(this, arguments);
     },
-
+  
     // Add a single region, by name, to the layoutView
     addRegion: function(name, definition) {
       var regions = {};
       regions[name] = definition;
       return this._buildRegions(regions)[name];
     },
-
+  
     // Add multiple regions as a {name: definition, name2: def2} object literal
     addRegions: function(regions) {
       this.regions = _.extend({}, this.regions, regions);
       return this._buildRegions(regions);
     },
-
+  
     // Remove a single region from the LayoutView, by name
     removeRegion: function(name) {
       delete this.regions[name];
       return this.regionManager.removeRegion(name);
     },
-
+  
     // Provides alternative access to regions
     // Accepts the region name
     // getRegion('main')
     getRegion: function(region) {
       return this.regionManager.get(region);
     },
-
+  
     // Get all regions
     getRegions: function(){
       return this.regionManager.getRegions();
     },
-
+  
     // internal method to build regions
     _buildRegions: function(regions) {
       var that = this;
-
+  
       var defaults = {
         regionClass: this.getOption('regionClass'),
         parentEl: function() { return that.$el; }
       };
-
+  
       return this.regionManager.addRegions(regions, defaults);
     },
-
+  
     // Internal method to initialize the regions that have been defined in a
     // `regions` attribute on this layoutView.
     _initializeRegions: function(options) {
       var regions;
       this._initRegionManager();
-
+  
       if (_.isFunction(this.regions)) {
         regions = this.regions(options);
       } else {
         regions = this.regions || {};
       }
-
+  
       // Enable users to define `regions` as instance options.
       var regionOptions = this.getOption.call(options, 'regions');
-
+  
       // enable region options to be a function
       if (_.isFunction(regionOptions)) {
         regionOptions = regionOptions.call(this, options);
       }
-
+  
       _.extend(regions, regionOptions);
-
+  
       // Normalize region selectors hash to allow
       // a user to use the @ui. syntax.
       regions = this.normalizeUIValues(regions);
-
+  
       this.addRegions(regions);
     },
-
+  
     // Internal method to re-initialize all of the regions by updating the `el` that
     // they point to
     _reInitializeRegions: function() {
@@ -2776,48 +2781,48 @@
         region.reset();
       });
     },
-
+  
     // Enable easy overriding of the default `RegionManager`
     // for customized region interactions and business specific
     // view logic for better control over single regions.
     getRegionManager: function() {
       return new Marionette.RegionManager();
     },
-
+  
     // Internal method to initialize the region manager
     // and all regions in it
     _initRegionManager: function() {
       this.regionManager = this.getRegionManager();
-
+  
       this.listenTo(this.regionManager, 'before:add:region', function(name) {
         this.triggerMethod('before:add:region', name);
       });
-
+  
       this.listenTo(this.regionManager, 'add:region', function(name, region) {
         this[name] = region;
         this.triggerMethod('add:region', name, region);
       });
-
+  
       this.listenTo(this.regionManager, 'before:remove:region', function(name) {
         this.triggerMethod('before:remove:region', name);
       });
-
+  
       this.listenTo(this.regionManager, 'remove:region', function(name, region) {
         delete this[name];
         this.triggerMethod('remove:region', name, region);
       });
     }
   });
-
+  
 
   // Behavior
   // -----------
-
+  
   // A Behavior is an isolated set of DOM /
   // user interactions that can be mixed into any View.
   // Behaviors allow you to blackbox View specific interactions
   // into portable logical chunks, keeping your views simple and your code DRY.
-
+  
   Marionette.Behavior = (function(_, Backbone) {
     function Behavior(options, view) {
       // Setup reference to the view.
@@ -2827,132 +2832,132 @@
       this.view = view;
       this.defaults = _.result(this, 'defaults') || {};
       this.options  = _.extend({}, this.defaults, options);
-
+  
       // proxy behavior $ method to the view
       // this is useful for doing jquery DOM lookups
       // scoped to behaviors view.
       this.$ = function() {
         return this.view.$.apply(this.view, arguments);
       };
-
+  
       // Call the initialize method passing
       // the arguments from the instance constructor
       this.initialize.apply(this, arguments);
     }
-
+  
     _.extend(Behavior.prototype, Backbone.Events, {
       initialize: function() {},
-
+  
       // stopListening to behavior `onListen` events.
       destroy: function() {
         this.stopListening();
       },
-
+  
       proxyViewProperties: function (view) {
         this.$el = view.$el;
         this.el = view.el;
       },
-
+  
       // import the `triggerMethod` to trigger events with corresponding
       // methods if the method exists
       triggerMethod: Marionette.triggerMethod,
-
+  
       // Proxy `getOption` to enable getting options from this or this.options by name.
       getOption: Marionette.proxyGetOption,
-
+  
       // Proxy `unbindEntityEvents` to enable binding view's events from another entity.
       bindEntityEvents: Marionette.proxyBindEntityEvents,
-
+  
       // Proxy `unbindEntityEvents` to enable unbinding view's events from another entity.
       unbindEntityEvents: Marionette.proxyUnbindEntityEvents
     });
-
+  
     // Borrow Backbones extend implementation
     // this allows us to setup a proper
     // inheritance pattern that follows suit
     // with the rest of Marionette views.
     Behavior.extend = Marionette.extend;
-
+  
     return Behavior;
   })(_, Backbone);
-
+  
   /* jshint maxlen: 143 */
   // Marionette.Behaviors
   // --------
-
+  
   // Behaviors is a utility class that takes care of
   // gluing your behavior instances to their given View.
   // The most important part of this class is that you
   // **MUST** override the class level behaviorsLookup
   // method for things to work properly.
-
+  
   Marionette.Behaviors = (function(Marionette, _) {
-
+  
     function Behaviors(view, behaviors) {
-
+  
       if (!_.isObject(view.behaviors)) {
         return {};
       }
-
+  
       // Behaviors defined on a view can be a flat object literal
       // or it can be a function that returns an object.
       behaviors = Behaviors.parseBehaviors(view, behaviors || _.result(view, 'behaviors'));
-
+  
       // Wraps several of the view's methods
       // calling the methods first on each behavior
       // and then eventually calling the method on the view.
       Behaviors.wrap(view, behaviors, _.keys(methods));
       return behaviors;
     }
-
+  
     var methods = {
       behaviorTriggers: function(behaviorTriggers, behaviors) {
         var triggerBuilder = new BehaviorTriggersBuilder(this, behaviors);
         return triggerBuilder.buildBehaviorTriggers();
       },
-
+  
       behaviorEvents: function(behaviorEvents, behaviors) {
         var _behaviorsEvents = {};
         var viewUI = _.result(this, 'ui');
-
+  
         _.each(behaviors, function(b, i) {
           var _events = {};
           var behaviorEvents = _.clone(_.result(b, 'events')) || {};
           var behaviorUI = _.result(b, 'ui');
-
+  
           // Construct an internal UI hash first using
           // the views UI hash and then the behaviors UI hash.
           // This allows the user to use UI hash elements
           // defined in the parent view as well as those
           // defined in the given behavior.
           var ui = _.extend({}, viewUI, behaviorUI);
-
+  
           // Normalize behavior events hash to allow
           // a user to use the @ui. syntax.
           behaviorEvents = Marionette.normalizeUIKeys(behaviorEvents, ui);
-
+  
           _.each(_.keys(behaviorEvents), function(key) {
             // Append white-space at the end of each key to prevent behavior key collisions.
             // This is relying on the fact that backbone events considers "click .foo" the same as
             // "click .foo ".
-
+  
             // +2 is used because new Array(1) or 0 is "" and not " "
             var whitespace = (new Array(i + 2)).join(' ');
             var eventKey   = key + whitespace;
             var handler    = _.isFunction(behaviorEvents[key]) ? behaviorEvents[key] : b[behaviorEvents[key]];
-
+  
             _events[eventKey] = _.bind(handler, b);
           });
-
+  
           _behaviorsEvents = _.extend(_behaviorsEvents, _events);
         });
-
+  
         return _behaviorsEvents;
       }
     };
-
+  
     _.extend(Behaviors, {
-
+  
       // Placeholder method to be extended by the user.
       // The method should define the object that stores the behaviors.
       // i.e.
@@ -2968,7 +2973,7 @@
           url: 'marionette.behaviors.html#behaviorslookup'
         });
       },
-
+  
       // Takes care of getting the behavior class
       // given options and a key.
       // If a user passes in options.behaviorClass
@@ -2978,24 +2983,24 @@
         if (options.behaviorClass) {
           return options.behaviorClass;
         }
-
+  
         // Get behavior class can be either a flat object or a method
         return _.isFunction(Behaviors.behaviorsLookup) ? Behaviors.behaviorsLookup.apply(this, arguments)[key] : Behaviors.behaviorsLookup[key];
       },
-
+  
       // Iterate over the behaviors object, for each behavior
       // instantiate it and get its grouped behaviors.
       parseBehaviors: function(view, behaviors) {
         return _.chain(behaviors).map(function(options, key) {
           var BehaviorClass = Behaviors.getBehaviorClass(options, key);
-
+  
           var behavior = new BehaviorClass(options, view);
           var nestedBehaviors = Behaviors.parseBehaviors(view, _.result(behavior, 'behaviors'));
-
+  
           return [behavior].concat(nestedBehaviors);
         }).flatten().value();
       },
-
+  
       // Wrap view internal methods so that they delegate to behaviors. For example,
       // `onDestroy` should trigger destroy on all of the behaviors and then destroy itself.
       // i.e.
@@ -3007,7 +3012,7 @@
         });
       }
     });
-
+  
     // Class to build handlers for `triggers` on behaviors
     // for views
     function BehaviorTriggersBuilder(view, behaviors) {
@@ -3016,24 +3021,24 @@
       this._behaviors = behaviors;
       this._triggers  = {};
     }
-
+  
     _.extend(BehaviorTriggersBuilder.prototype, {
       // Main method to build the triggers hash with event keys and handlers
       buildBehaviorTriggers: function() {
         _.each(this._behaviors, this._buildTriggerHandlersForBehavior, this);
         return this._triggers;
       },
-
+  
       // Internal method to build all trigger handlers for a given behavior
       _buildTriggerHandlersForBehavior: function(behavior, i) {
         var ui = _.extend({}, this._viewUI, _.result(behavior, 'ui'));
         var triggersHash = _.clone(_.result(behavior, 'triggers')) || {};
-
+  
         triggersHash = Marionette.normalizeUIKeys(triggersHash, ui);
-
+  
         _.each(triggersHash, _.partial(this._setHandlerForBehavior, behavior, i), this);
       },
-
+  
       // Internal method to create and assign the trigger handler for a given
       // behavior
       _setHandlerForBehavior: function(behavior, i, eventName, trigger) {
@@ -3041,19 +3046,19 @@
         var triggerKey = trigger.replace(/^\S+/, function(triggerName) {
           return triggerName + '.' + 'behaviortriggers' + i;
         });
-
+  
         this._triggers[triggerKey] = this._view._buildViewTrigger(eventName);
       }
     });
-
+  
     return Behaviors;
-
+  
   })(Marionette, _);
-
+  
 
   // AppRouter
   // ---------
-
+  
   // Reduce the boilerplate code of handling route events
   // and then calling a single method on another object.
   // Have your routers configured to call the method on
@@ -3068,73 +3073,73 @@
   // just one giant router and controller.
   //
   // You can also add standard routes to an AppRouter.
-
+  
   Marionette.AppRouter = Backbone.Router.extend({
-
+  
     constructor: function(options) {
       Backbone.Router.apply(this, arguments);
-
+  
       this.options = options || {};
-
+  
       var appRoutes = this.getOption('appRoutes');
       var controller = this._getController();
       this.processAppRoutes(controller, appRoutes);
       this.on('route', this._processOnRoute, this);
     },
-
+  
     // Similar to route method on a Backbone Router but
     // method is called on the controller
     appRoute: function(route, methodName) {
       var controller = this._getController();
       this._addAppRoute(controller, route, methodName);
     },
-
+  
     // process the route event and trigger the onRoute
     // method call, if it exists
     _processOnRoute: function(routeName, routeArgs) {
       // find the path that matched
       var routePath = _.invert(this.getOption('appRoutes'))[routeName];
-
+  
       // make sure an onRoute is there, and call it
       if (_.isFunction(this.onRoute)) {
         this.onRoute(routeName, routePath, routeArgs);
       }
     },
-
+  
     // Internal method to process the `appRoutes` for the
     // router, and turn them in to routes that trigger the
     // specified method on the specified `controller`.
     processAppRoutes: function(controller, appRoutes) {
       if (!appRoutes) { return; }
-
+  
       var routeNames = _.keys(appRoutes).reverse(); // Backbone requires reverted order of routes
-
+  
       _.each(routeNames, function(route) {
         this._addAppRoute(controller, route, appRoutes[route]);
       }, this);
     },
-
+  
     _getController: function() {
       return this.getOption('controller');
     },
-
+  
     _addAppRoute: function(controller, route, methodName) {
       var method = controller[methodName];
-
+  
       if (!method) {
         throw new Marionette.Error('Method "' + methodName + '" was not found on the controller');
       }
-
+  
       this.route(route, methodName, _.bind(method, controller));
     },
-
+  
     // Proxy `getOption` to enable getting options from this or this.options by name.
     getOption: Marionette.proxyGetOption
   });
-
+  
   // Application
   // -----------
-
+  
   // Contain and manage the composite application as a whole.
   // Stores and starts up `Region` objects, includes an
   // event aggregator as `app.vent`
@@ -3147,29 +3152,29 @@
     this._initChannel();
     this.initialize.apply(this, arguments);
   };
-
+  
   _.extend(Marionette.Application.prototype, Backbone.Events, {
     // Initialize is an empty function by default. Override it with your own
     // initialization logic.
     initialize: function() {},
-
+  
     // Command execution, facilitated by Backbone.Wreqr.Commands
     execute: function() {
       this.commands.execute.apply(this.commands, arguments);
     },
-
+  
     // Request/response, facilitated by Backbone.Wreqr.RequestResponse
     request: function() {
       return this.reqres.request.apply(this.reqres, arguments);
     },
-
+  
     // Add an initializer that is either run at when the `start`
     // method is called, or run immediately if added after `start`
     // has already been called.
     addInitializer: function(initializer) {
       this._initCallbacks.add(initializer);
     },
-
+  
     // kick off all of the application's processes.
     // initializes all of the regions that have been added
     // to the app, and runs all of the initializer functions
@@ -3178,7 +3183,7 @@
       this._initCallbacks.run(options, this);
       this.triggerMethod('start', options);
     },
-
+  
     // Add regions to your app.
     // Accepts a hash of named strings or Region objects
     // addRegions({something: "#someRegion"})
@@ -3186,99 +3191,99 @@
     addRegions: function(regions) {
       return this._regionManager.addRegions(regions);
     },
-
+  
     // Empty all regions in the app, without removing them
     emptyRegions: function() {
       return this._regionManager.emptyRegions();
     },
-
+  
     // Removes a region from your app, by name
     // Accepts the regions name
     // removeRegion('myRegion')
     removeRegion: function(region) {
       return this._regionManager.removeRegion(region);
     },
-
+  
     // Provides alternative access to regions
     // Accepts the region name
     // getRegion('main')
     getRegion: function(region) {
       return this._regionManager.get(region);
     },
-
+  
     // Get all the regions from the region manager
     getRegions: function(){
       return this._regionManager.getRegions();
     },
-
+  
     // Create a module, attached to the application
     module: function(moduleNames, moduleDefinition) {
-
+  
       // Overwrite the module class if the user specifies one
       var ModuleClass = Marionette.Module.getClass(moduleDefinition);
-
+  
       // slice the args, and add this application object as the
       // first argument of the array
       var args = slice.call(arguments);
       args.unshift(this);
-
+  
       // see the Marionette.Module object for more information
       return ModuleClass.create.apply(ModuleClass, args);
     },
-
+  
     // Enable easy overriding of the default `RegionManager`
     // for customized region interactions and business-specific
     // view logic for better control over single regions.
     getRegionManager: function() {
       return new Marionette.RegionManager();
     },
-
+  
     // Internal method to initialize the regions that have been defined in a
     // `regions` attribute on the application instance
     _initializeRegions: function(options) {
       var regions = _.isFunction(this.regions) ? this.regions(options) : this.regions || {};
-
+  
       this._initRegionManager();
-
+  
       // Enable users to define `regions` in instance options.
       var optionRegions = Marionette.getOption(options, 'regions');
-
+  
       // Enable region options to be a function
       if (_.isFunction(optionRegions)) {
         optionRegions = optionRegions.call(this, options);
       }
-
+  
       // Overwrite current regions with those passed in options
       _.extend(regions, optionRegions);
-
+  
       this.addRegions(regions);
-
+  
       return this;
     },
-
+  
     // Internal method to set up the region manager
     _initRegionManager: function() {
       this._regionManager = this.getRegionManager();
-
+  
       this.listenTo(this._regionManager, 'before:add:region', function(name) {
         this.triggerMethod('before:add:region', name);
       });
-
+  
       this.listenTo(this._regionManager, 'add:region', function(name, region) {
         this[name] = region;
         this.triggerMethod('add:region', name, region);
       });
-
+  
       this.listenTo(this._regionManager, 'before:remove:region', function(name) {
         this.triggerMethod('before:remove:region', name);
       });
-
+  
       this.listenTo(this._regionManager, 'remove:region', function(name, region) {
         delete this[name];
         this.triggerMethod('remove:region', name, region);
       });
     },
-
+  
     // Internal method to setup the Wreqr.radio channel
     _initChannel: function() {
       this.channelName = _.result(this, 'channelName') || 'global';
@@ -3287,23 +3292,23 @@
       this.commands = _.result(this, 'commands') || this.channel.commands;
       this.reqres = _.result(this, 'reqres') || this.channel.reqres;
     },
-
+  
     // import the `triggerMethod` to trigger events with corresponding
     // methods if the method exists
     triggerMethod: Marionette.triggerMethod,
-
+  
     // Proxy `getOption` to enable getting options from this or this.options by name.
     getOption: Marionette.proxyGetOption
   });
-
+  
   // Copy the `extend` function used by Backbone's classes
   Marionette.Application.extend = Marionette.extend;
-
+  
   /* jshint maxparams: 9 */
-
+  
   // Module
   // ------
-
+  
   // A simple module system, used to create privacy and encapsulation in
   // Marionette applications
   Marionette.Module = function(moduleName, app, options) {
@@ -3312,52 +3317,52 @@
     // Allow for a user to overide the initialize
     // for a given module instance.
     this.initialize = options.initialize || this.initialize;
-
+  
     // Set up an internal store for sub-modules.
     this.submodules = {};
-
+  
     this._setupInitializersAndFinalizers();
-
+  
     // Set an internal reference to the app
     // within a module.
     this.app = app;
-
+  
     if (_.isFunction(this.initialize)) {
       this.initialize(moduleName, app, this.options);
     }
   };
-
+  
   Marionette.Module.extend = Marionette.extend;
-
+  
   // Extend the Module prototype with events / listenTo, so that the module
   // can be used as an event aggregator or pub/sub.
   _.extend(Marionette.Module.prototype, Backbone.Events, {
-
+  
     // By default modules start with their parents.
     startWithParent: true,
-
+  
     // Initialize is an empty function by default. Override it with your own
     // initialization logic when extending Marionette.Module.
     initialize: function() {},
-
+  
     // Initializer for a specific module. Initializers are run when the
     // module's `start` method is called.
     addInitializer: function(callback) {
       this._initializerCallbacks.add(callback);
     },
-
+  
     // Finalizers are run when a module is stopped. They are used to teardown
     // and finalize any variables, references, events and other code that the
     // module had set up.
     addFinalizer: function(callback) {
       this._finalizerCallbacks.add(callback);
     },
-
+  
     // Start the module, and run all of its initializers
     start: function(options) {
       // Prevent re-starting a module that is already started
       if (this._isInitialized) { return; }
-
+  
       // start the sub-modules (depth-first hierarchy)
       _.each(this.submodules, function(mod) {
         // check to see if we should start the sub-module with this parent
@@ -3365,51 +3370,51 @@
           mod.start(options);
         }
       });
-
+  
       // run the callbacks to "start" the current module
       this.triggerMethod('before:start', options);
-
+  
       this._initializerCallbacks.run(options, this);
       this._isInitialized = true;
-
+  
       this.triggerMethod('start', options);
     },
-
+  
     // Stop this module by running its finalizers and then stop all of
     // the sub-modules for this module
     stop: function() {
       // if we are not initialized, don't bother finalizing
       if (!this._isInitialized) { return; }
       this._isInitialized = false;
-
+  
       this.triggerMethod('before:stop');
-
+  
       // stop the sub-modules; depth-first, to make sure the
       // sub-modules are stopped / finalized before parents
       _.each(this.submodules, function(mod) { mod.stop(); });
-
+  
       // run the finalizers
       this._finalizerCallbacks.run(undefined, this);
-
+  
       // reset the initializers and finalizers
       this._initializerCallbacks.reset();
       this._finalizerCallbacks.reset();
-
+  
       this.triggerMethod('stop');
     },
-
+  
     // Configure the module with a definition function and any custom args
     // that are to be passed in to the definition function
     addDefinition: function(moduleDefinition, customArgs) {
       this._runModuleDefinition(moduleDefinition, customArgs);
     },
-
+  
     // Internal method: run the module definition function with the correct
     // arguments
     _runModuleDefinition: function(definition, customArgs) {
       // If there is no definition short circut the method.
       if (!definition) { return; }
-
+  
       // build the correct list of arguments for the module definition
       var args = _.flatten([
         this,
@@ -3419,10 +3424,10 @@
         Backbone.$, _,
         customArgs
       ]);
-
+  
       definition.apply(this, args);
     },
-
+  
     // Internal method: set up new copies of initializers and finalizers.
     // Calling this method will wipe out all existing initializers and
     // finalizers.
@@ -3430,52 +3435,52 @@
       this._initializerCallbacks = new Marionette.Callbacks();
       this._finalizerCallbacks = new Marionette.Callbacks();
     },
-
+  
     // import the `triggerMethod` to trigger events with corresponding
     // methods if the method exists
     triggerMethod: Marionette.triggerMethod
   });
-
+  
   // Class methods to create modules
   _.extend(Marionette.Module, {
-
+  
     // Create a module, hanging off the app parameter as the parent object.
     create: function(app, moduleNames, moduleDefinition) {
       var module = app;
-
+  
       // get the custom args passed in after the module definition and
       // get rid of the module name and definition function
       var customArgs = slice.call(arguments);
       customArgs.splice(0, 3);
-
+  
       // Split the module names and get the number of submodules.
       // i.e. an example module name of `Doge.Wow.Amaze` would
       // then have the potential for 3 module definitions.
       moduleNames = moduleNames.split('.');
       var length = moduleNames.length;
-
+  
       // store the module definition for the last module in the chain
       var moduleDefinitions = [];
       moduleDefinitions[length - 1] = moduleDefinition;
-
+  
       // Loop through all the parts of the module definition
       _.each(moduleNames, function(moduleName, i) {
         var parentModule = module;
         module = this._getModule(parentModule, moduleName, app, moduleDefinition);
         this._addModuleDefinition(parentModule, module, moduleDefinitions[i], customArgs);
       }, this);
-
+  
       // Return the last module in the definition chain
       return module;
     },
-
+  
     _getModule: function(parentModule, moduleName, app, def, args) {
       var options = _.extend({}, def);
       var ModuleClass = this.getClass(def);
-
+  
       // Get an existing module of this name if we have one
       var module = parentModule[moduleName];
-
+  
       if (!module) {
         // Create a new module if we don't have one
         module = new ModuleClass(moduleName, app, options);
@@ -3483,10 +3488,10 @@
         // store the module on the parent
         parentModule.submodules[moduleName] = module;
       }
-
+  
       return module;
     },
-
+  
     // ## Module Classes
     //
     // Module classes can be used as an alternative to the define pattern.
@@ -3495,71 +3500,71 @@
     // This allows module lifecyle events like `onStart` and `onStop` to be called directly.
     getClass: function(moduleDefinition) {
       var ModuleClass = Marionette.Module;
-
+  
       if (!moduleDefinition) {
         return ModuleClass;
       }
-
+  
       // If all of the module's functionality is defined inside its class,
       // then the class can be passed in directly. `MyApp.module("Foo", FooModule)`.
       if (moduleDefinition.prototype instanceof ModuleClass) {
         return moduleDefinition;
       }
-
+  
       return moduleDefinition.moduleClass || ModuleClass;
     },
-
+  
     // Add the module definition and add a startWithParent initializer function.
     // This is complicated because module definitions are heavily overloaded
     // and support an anonymous function, module class, or options object
     _addModuleDefinition: function(parentModule, module, def, args) {
       var fn = this._getDefine(def);
       var startWithParent = this._getStartWithParent(def, module);
-
+  
       if (fn) {
         module.addDefinition(fn, args);
       }
-
+  
       this._addStartWithParent(parentModule, module, startWithParent);
     },
-
+  
     _getStartWithParent: function(def, module) {
       var swp;
-
+  
       if (_.isFunction(def) && (def.prototype instanceof Marionette.Module)) {
         swp = module.constructor.prototype.startWithParent;
         return _.isUndefined(swp) ? true : swp;
       }
-
+  
       if (_.isObject(def)) {
         swp = def.startWithParent;
         return _.isUndefined(swp) ? true : swp;
       }
-
+  
       return true;
     },
-
+  
     _getDefine: function(def) {
       if (_.isFunction(def) && !(def.prototype instanceof Marionette.Module)) {
         return def;
       }
-
+  
       if (_.isObject(def)) {
         return def.define;
       }
-
+  
       return null;
     },
-
+  
     _addStartWithParent: function(parentModule, module, startWithParent) {
       module.startWithParent = module.startWithParent && startWithParent;
-
+  
       if (!module.startWithParent || !!module.startWithParentIsConfigured) {
         return;
       }
-
+  
       module.startWithParentIsConfigured = true;
-
+  
       parentModule.addInitializer(function(options) {
         if (module.startWithParent) {
           module.start(options);
@@ -3567,7 +3572,7 @@
       });
     }
   });
-
+  
 
   return Marionette;
 }));