marionette-rails 2.2.2 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bb72c3e7ebd42ae9f6ff1cab755e4d75cbd33d7
-  data.tar.gz: 93bb3dd197d7c37ffc2698eebf39c93476d84246
+  metadata.gz: e6785ca4329e92cfb675a34ca251fd978c57e1e3
+  data.tar.gz: 0627a47da1f8b06cd8bb2316026ffcaaafcee58a
 SHA512:
-  metadata.gz: 770e3d2afb69960a1572be93848b96a4a06dbc84f89652f0b0c61c98807fe3ecec3f088124750953b81d3c9b8914d9577c85ac575d061935e0d0bec7f63c01a6
-  data.tar.gz: aae08d6c39199c82b4ffb94c0c0b47a8b2b5b84d69b8c909a9ebc3815b35c89a710c851a009583cd0d61c2ada9a582d22ca161b9a5861da904d02912a9c05f6a
+  metadata.gz: 1a63dbf909602bd5a283f5a4d622a9bfac2afa98aa4a78061216bfd14db9bafb4bbd267c75f8b2d29143ec6c83f8cedcdf5ca0431f235862487f0e55fae20628
+  data.tar.gz: 9a0560029ac2986b4a181ddc08cdca6043dbfed7864b518f5b53aca3d75d506058895cd5e723a4a37319ef688bf40e0b6954dd80b43fa2712479328e8ac6f069

data/lib/marionette-rails/version.rb

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

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

@@ -1,8 +1,8 @@
 // MarionetteJS (Backbone.Marionette)
 // ----------------------------------
-// v2.2.2
+// v2.3.2
 //
-// Copyright (c)2014 Derick Bailey, Muted Solutions, LLC.
+// Copyright (c)2015 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
 //
 // http://marionettejs.com
@@ -22,14 +22,14 @@
   /* istanbul ignore next */
   if (typeof define === 'function' && define.amd) {
     define(['backbone', 'underscore'], function(Backbone, _) {
-      return (root.Marionette = factory(root, Backbone, _));
+      return (root.Marionette = root.Mn = factory(root, Backbone, _));
     });
   } else if (typeof exports !== 'undefined') {
     var Backbone = require('backbone');
     var _ = require('underscore');
     module.exports = factory(root, Backbone, _);
   } else {
-    root.Marionette = factory(root, root.Backbone, root._);
+    root.Marionette = root.Mn = factory(root, root.Backbone, root._);
   }
 
 }(this, function(root, Backbone, _) {
@@ -38,7 +38,7 @@
   /* istanbul ignore next */
   // Backbone.BabySitter
   // -------------------
-  // v0.1.4
+  // v0.1.5
   //
   // Copyright (c)2014 Derick Bailey, Muted Solutions, LLC.
   // Distributed under MIT license
@@ -167,7 +167,7 @@
       // return the public API
       return Container;
     }(Backbone, _);
-    Backbone.ChildViewContainer.VERSION = "0.1.4";
+    Backbone.ChildViewContainer.VERSION = "0.1.5";
     Backbone.ChildViewContainer.noConflict = function() {
       Backbone.ChildViewContainer = previousChildViewContainer;
       return this;
@@ -493,7 +493,7 @@
 
   var Marionette = Backbone.Marionette = {};
 
-  Marionette.VERSION = '2.2.2';
+  Marionette.VERSION = '2.3.2';
 
   Marionette.noConflict = function() {
     root.Marionette = previousMarionette;
@@ -505,20 +505,26 @@
   // Get the Deferred creator for later use
   Marionette.Deferred = Backbone.$.Deferred;
 
-  /* jshint unused: false */
+  /* jshint unused: false *//* global console */
   
   // 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.isNodeAttached
+  // -------------------------
+  
+  // Determine if `el` is a child of the document
+  Marionette.isNodeAttached = function(el) {
+    return Backbone.$.contains(document.documentElement, el);
+  };
+  
+  
   // Marionette.getOption
   // --------------------
   
@@ -526,15 +532,11 @@
   // 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];
+      return target.options[optionName];
     } else {
-      value = target[optionName];
+      return target[optionName];
     }
-  
-    return value;
   };
   
   // Proxy `Marionette.getOption`
@@ -542,23 +544,36 @@
     return Marionette.getOption(this, optionName);
   };
   
+  // Similar to `_.result`, this is a simple helper
+  // If a function is provided we call it with context
+  // otherwise just return the value. If the value is
+  // undefined return a default value
+  Marionette._getValue = function(value, context, params) {
+    if (_.isFunction(value)) {
+      // We need to ensure that params is not undefined
+      // to prevent `apply` from failing in ie8
+      params = params || [];
+  
+      value = value.apply(context, params);
+    }
+    return value;
+  };
+  
   // Marionette.normalizeMethods
   // ----------------------
   
   // Pass in a mapping of events => functions or function names
   // and return a mapping of events => functions
   Marionette.normalizeMethods = function(hash) {
-    var normalizedHash = {};
-    _.each(hash, function(method, name) {
+    return _.reduce(hash, function(normalizedHash, method, name) {
       if (!_.isFunction(method)) {
         method = this[method];
       }
-      if (!method) {
-        return;
+      if (method) {
+        normalizedHash[name] = method;
       }
-      normalizedHash[name] = method;
-    }, this);
-    return normalizedHash;
+      return normalizedHash;
+    }, {}, this);
   };
   
   // utility method for parsing @ui. syntax strings
@@ -574,37 +589,22 @@
   // swaps the @ui with the associated selector.
   // Returns a new, non-mutated, parsed events hash.
   Marionette.normalizeUIKeys = function(hash, ui) {
-    if (typeof(hash) === 'undefined') {
-      return;
-    }
-  
-    hash = _.clone(hash);
-  
-    _.each(_.keys(hash), function(key) {
+    return _.reduce(hash, function(memo, val, key) {
       var normalizedKey = Marionette.normalizeUIString(key, ui);
-      if (normalizedKey !== key) {
-        hash[normalizedKey] = hash[key];
-        delete hash[key];
-      }
-    });
-  
-    return hash;
+      memo[normalizedKey] = val;
+      return memo;
+    }, {});
   };
   
   // allows for the use of the @ui. syntax within
   // a given value for regions
   // swaps the @ui with the associated selector
   Marionette.normalizeUIValues = function(hash, ui) {
-    if (typeof(hash) === 'undefined') {
-      return;
-    }
-  
     _.each(hash, function(val, key) {
       if (_.isString(val)) {
         hash[key] = Marionette.normalizeUIString(val, ui);
       }
     });
-  
     return hash;
   };
   
@@ -627,15 +627,31 @@
     });
   };
   
-  // Trigger an event and/or a corresponding method name. Examples:
-  //
-  // `this.triggerMethod("foo")` will trigger the "foo" event and
-  // call the "onFoo" method.
-  //
-  // `this.triggerMethod("foo:bar")` will trigger the "foo:bar" event and
-  // call the "onFooBar" method.
-  Marionette.triggerMethod = function(event) {
+  var deprecate = Marionette.deprecate = function(message, test) {
+    if (_.isObject(message)) {
+      message = (
+        message.prev + ' is going to be removed in the future. ' +
+        'Please use ' + message.next + ' instead.' +
+        (message.url ? ' See: ' + message.url : '')
+      );
+    }
+  
+    if ((test === undefined || !test) && !deprecate._cache[message]) {
+      deprecate._warn('Deprecation warning: ' + message);
+      deprecate._cache[message] = true;
+    }
+  };
+  
+  deprecate._warn = typeof console !== 'undefined' && (console.warn || console.log) || function() {};
+  deprecate._cache = {};
   
+  /* jshint maxstatements: 14, maxcomplexity: 7 */
+  
+  // Trigger Method
+  // --------------
+  
+  
+  Marionette._triggerMethod = (function() {
     // split the event name on the ":"
     var splitter = /(^|:)(\w)/gi;
   
@@ -645,102 +661,109 @@
       return eventName.toUpperCase();
     }
   
-    // get the method name from the event name
-    var methodName = 'on' + event.replace(splitter, getEventName);
-    var method = this[methodName];
-    var result;
+    return function(context, event, args) {
+      var noEventArg = arguments.length < 3;
+      if (noEventArg) {
+        args = event;
+        event = args[0];
+      }
   
-    // call the onMethodName if it exists
-    if (_.isFunction(method)) {
-      // pass all arguments, except the event name
-      result = method.apply(this, _.tail(arguments));
-    }
+      // get the method name from the event name
+      var methodName = 'on' + event.replace(splitter, getEventName);
+      var method = context[methodName];
+      var result;
   
-    // trigger the event, if a trigger method exists
-    if (_.isFunction(this.trigger)) {
-      this.trigger.apply(this, arguments);
-    }
+      // call the onMethodName if it exists
+      if (_.isFunction(method)) {
+        // pass all args, except the event name
+        result = method.apply(context, noEventArg ? _.rest(args) : args);
+      }
+  
+      // trigger the event, if a trigger method exists
+      if (_.isFunction(context.trigger)) {
+        if (noEventArg + args.length > 1) {
+          context.trigger.apply(context, noEventArg ? args : [event].concat(_.rest(args, 0)));
+        } else {
+          context.trigger(event);
+        }
+      }
+  
+      return result;
+    };
+  })();
   
-    return result;
+  // Trigger an event and/or a corresponding method name. Examples:
+  //
+  // `this.triggerMethod("foo")` will trigger the "foo" event and
+  // call the "onFoo" method.
+  //
+  // `this.triggerMethod("foo:bar")` will trigger the "foo:bar" event and
+  // call the "onFooBar" method.
+  Marionette.triggerMethod = function(event) {
+    return Marionette._triggerMethod(this, arguments);
   };
   
   // triggerMethodOn invokes triggerMethod on a specific context
   //
   // e.g. `Marionette.triggerMethodOn(view, 'show')`
   // will trigger a "show" event or invoke onShow the view.
-  Marionette.triggerMethodOn = function(context, event) {
-    var args = _.tail(arguments, 2);
-    var fnc;
-  
-    if (_.isFunction(context.triggerMethod)) {
-      fnc = context.triggerMethod;
-    } else {
-      fnc = Marionette.triggerMethod;
-    }
+  Marionette.triggerMethodOn = function(context) {
+    var fnc = _.isFunction(context.triggerMethod) ?
+                  context.triggerMethod :
+                  Marionette.triggerMethod;
   
-    return fnc.apply(context, [event].concat(args));
+    return fnc.apply(context, _.rest(arguments));
   };
   
-  // DOMRefresh
-  // ----------
-  //
+  // DOM Refresh
+  // -----------
+  
   // 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) {
+  Marionette.MonitorDOMRefresh = function(view) {
+  
     // track when the view has been shown in the DOM,
     // using a Marionette.Region (or by other means of triggering "show")
-    function handleShow(view) {
+    function handleShow() {
       view._isShown = true;
-      triggerDOMRefresh(view);
+      triggerDOMRefresh();
     }
   
     // track when the view has been rendered
-    function handleRender(view) {
+    function handleRender() {
       view._isRendered = true;
-      triggerDOMRefresh(view);
+      triggerDOMRefresh();
     }
   
     // Trigger the "dom:refresh" event and corresponding "onDomRefresh" method
-    function triggerDOMRefresh(view) {
-      if (view._isShown && view._isRendered && isInDOM(view)) {
+    function triggerDOMRefresh() {
+      if (view._isShown && view._isRendered && Marionette.isNodeAttached(view.el)) {
         if (_.isFunction(view.triggerMethod)) {
           view.triggerMethod('dom:refresh');
         }
       }
     }
   
-    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);
+    view.on({
+      show: handleShow,
+      render: handleRender
+    });
+  };
   
-
   /* jshint maxparams: 5 */
   
-  // Marionette.bindEntityEvents & unbindEntityEvents
-  // ---------------------------
+  // Bind Entity Events & Unbind Entity Events
+  // -----------------------------------------
   //
-  // These methods are used to bind/unbind a backbone "entity" (collection/model)
+  // These methods are used to bind/unbind a backbone "entity" (e.g. collection/model)
   // to methods on a target object.
   //
-  // The first parameter, `target`, must have a `listenTo` method from the
-  // EventBinder object.
+  // The first parameter, `target`, must have the Backbone.Events module mixed in.
   //
-  // The second parameter is the entity (Backbone.Model or Backbone.Collection)
-  // to bind the events from.
+  // The second parameter is the `entity` (Backbone.Model, Backbone.Collection or
+  // any object that has Backbone.Events mixed in) to bind the events from.
   //
   // The third parameter is a hash of { "event:name": "eventHandler" }
   // configuration. Multiple handlers can be separated by a space. A
@@ -793,7 +816,7 @@
       if (!entity || !bindings) { return; }
   
       // type-check bindings
-      if (!_.isFunction(bindings) && !_.isObject(bindings)) {
+      if (!_.isObject(bindings)) {
         throw new Marionette.Error({
           message: 'Bindings must be an object or function.',
           url: 'marionette.functions.html#marionettebindentityevents'
@@ -801,9 +824,7 @@
       }
   
       // allow the bindings to be a function
-      if (_.isFunction(bindings)) {
-        bindings = bindings.call(target);
-      }
+      bindings = Marionette._getValue(bindings, target);
   
       // iterate the bindings and bind them
       _.each(bindings, function(methods, evt) {
@@ -840,6 +861,9 @@
   })(Marionette);
   
 
+  // Error
+  // -----
+  
   var errorProps = ['description', 'fileName', 'lineNumber', 'name', 'message', 'number'];
   
   Marionette.Error = Marionette.extend.call(Error, {
@@ -926,9 +950,9 @@
     }
   });
   
-  // Marionette Controller
-  // ---------------------
-  //
+  // Controller
+  // ----------
+  
   // A multi-purpose object to use as a controller for
   // modules and routers, and as a mediator for workflow
   // and coordination of other objects, views, and more.
@@ -948,9 +972,8 @@
   // 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));
+      Marionette._triggerMethod(this, 'before:destroy', arguments);
+      Marionette._triggerMethod(this, 'destroy', arguments);
   
       this.stopListening();
       this.off();
@@ -966,9 +989,9 @@
   
   });
   
-  // Marionette Object
-  // ---------------------
-  //
+  // Object
+  // ------
+  
   // A Base Class that other Classes should descend from.
   // Object borrows many conventions and utilities from Backbone.
   Marionette.Object = function(options) {
@@ -982,7 +1005,8 @@
   // Object Methods
   // --------------
   
-  _.extend(Marionette.Object.prototype, {
+  // Ensure it can trigger events with Backbone.Events
+  _.extend(Marionette.Object.prototype, Backbone.Events, {
   
     //this is a noop method intended to be overridden by classes that extend from this base
     initialize: function() {},
@@ -1000,138 +1024,43 @@
     // 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.
+    // Proxy `bindEntityEvents` 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 */
+  /* jshint maxcomplexity: 16, maxstatements: 45, maxlen: 120 */
   
   // 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, {
+  Marionette.Region = Marionette.Object.extend({
+    constructor: function (options) {
   
-    // 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.
-    //
-    // The config object should either be a string as a jQuery DOM selector,
-    // a Region class directly, or an object literal that specifies both
-    // a selector and regionClass:
-    //
-    // ```js
-    // {
-    //   selector: "#foo",
-    //   regionClass: MyCustomRegion
-    // }
-    // ```
-    //
-    buildRegion: function(regionConfig, DefaultRegionClass) {
-      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 }
-    // ```
-    _buildRegionFromObject: function(regionConfig, DefaultRegionClass) {
-      var RegionClass = regionConfig.regionClass || DefaultRegionClass;
-      var options = _.omit(regionConfig, 'selector', 'regionClass');
-  
-      if (regionConfig.selector && !options.el) {
-        options.el = regionConfig.selector;
-      }
+      // set options temporarily so that we can get `el`.
+      // options will be overriden by Object.constructor
+      this.options = options || {};
+      this.el = this.getOption('el');
   
-      var region = new RegionClass(options);
+      // Handle when this.el is passed in as a $ wrapped element.
+      this.el = this.el instanceof Backbone.$ ? this.el[0] : this.el;
   
-      // 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
-      // region's `el` to `parentEl.find(selector)` in the object
-      // literal to build the region, the element will not be
-      // guaranteed to be in the DOM already, and will cause problems
-      if (regionConfig.parentEl) {
-        region.getEl = function(el) {
-          if (_.isObject(el)) {
-            return Backbone.$(el);
-          }
-          var parentEl = regionConfig.parentEl;
-          if (_.isFunction(parentEl)) {
-            parentEl = parentEl();
-          }
-          return parentEl.find(el);
-        };
+      if (!this.el) {
+        throw new Marionette.Error({
+          name: 'NoElError',
+          message: 'An "el" must be specified for a region.'
+        });
       }
   
-      return region;
+      this.$el = this.getEl(this.el);
+      Marionette.Object.call(this, options);
     },
   
-    // 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,9 +1070,12 @@
     // 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();
+      if (!this._ensureElement()) {
+        return;
+      }
+  
+      this._ensureViewIsIntact(view);
   
       var showOptions     = options || {};
       var isDifferentView = view !== this.currentView;
@@ -1163,11 +1095,21 @@
       var _shouldShowView = isDifferentView || forceShow;
   
       if (isChangingView) {
-        this.triggerMethod('before:swapOut', this.currentView);
+        this.triggerMethod('before:swapOut', this.currentView, this, options);
+      }
+  
+      if (this.currentView) {
+        delete this.currentView._parent;
       }
   
       if (_shouldDestroyView) {
         this.empty();
+  
+      // A `destroy` event is attached to the clean up manually removed views.
+      // We need to detach this event when a new view is going to be shown as it
+      // is no longer relevant.
+      } else if (isChangingView && _shouldShowView) {
+        this.currentView.off('destroy', this.empty, this);
       }
   
       if (_shouldShowView) {
@@ -1180,27 +1122,49 @@
         view.once('destroy', this.empty, this);
         view.render();
   
+        view._parent = this;
+  
         if (isChangingView) {
-          this.triggerMethod('before:swap', view);
+          this.triggerMethod('before:swap', view, this, options);
         }
   
-        this.triggerMethod('before:show', view);
-        Marionette.triggerMethodOn(view, 'before:show');
-  
-        this.attachHtml(view);
+        this.triggerMethod('before:show', view, this, options);
+        Marionette.triggerMethodOn(view, 'before:show', view, this, options);
   
         if (isChangingView) {
-          this.triggerMethod('swapOut', this.currentView);
+          this.triggerMethod('swapOut', this.currentView, this, options);
         }
   
+        // An array of views that we're about to display
+        var attachedRegion = Marionette.isNodeAttached(this.el);
+  
+        // The views that we're about to attach to the document
+        // It's important that we prevent _getNestedViews from being executed unnecessarily
+        // as it's a potentially-slow method
+        var displayedViews = [];
+  
+        var triggerBeforeAttach = showOptions.triggerBeforeAttach || this.triggerBeforeAttach;
+        var triggerAttach = showOptions.triggerAttach || this.triggerAttach;
+  
+        if (attachedRegion && triggerBeforeAttach) {
+          displayedViews = this._displayedViews(view);
+          this._triggerAttach(displayedViews, 'before:');
+        }
+  
+        this.attachHtml(view);
         this.currentView = view;
   
+        if (attachedRegion && triggerAttach) {
+          displayedViews = this._displayedViews(view);
+          this._triggerAttach(displayedViews);
+        }
+  
         if (isChangingView) {
-          this.triggerMethod('swap', view);
+          this.triggerMethod('swap', view, this, options);
         }
   
-        this.triggerMethod('show', view);
-        Marionette.triggerMethodOn(view, 'show');
+        this.triggerMethod('show', view, this, options);
+        Marionette.triggerMethodOn(view, 'show', view, this, options);
   
         return this;
       }
@@ -1208,6 +1172,20 @@
       return this;
     },
   
+    triggerBeforeAttach: true,
+    triggerAttach: true,
+  
+    _triggerAttach: function(views, prefix) {
+      var eventName = (prefix || '') + 'attach';
+      _.each(views, function(view) {
+        Marionette.triggerMethodOn(view, eventName, view, this);
+      }, this);
+    },
+  
+    _displayedViews: function(view) {
+      return _.union([view], _.result(view, '_getNestedViews') || []);
+    },
+  
     _ensureElement: function(){
       if (!_.isObject(this.el)) {
         this.$el = this.getEl(this.el);
@@ -1215,21 +1193,43 @@
       }
   
       if (!this.$el || this.$el.length === 0) {
-        throw new Marionette.Error('An "el" ' + this.$el.selector + ' must exist in DOM');
+        if (this.getOption('allowMissingEl')) {
+          return false;
+        } else {
+          throw new Marionette.Error('An "el" ' + this.$el.selector + ' must exist in DOM');
+        }
       }
+      return true;
     },
   
-    // Override this method to change how the region finds the
-    // DOM element that it manages. Return a jQuery selector object.
+    _ensureViewIsIntact: function(view) {
+      if (!view) {
+        throw new Marionette.Error({
+          name: 'ViewNotValid',
+          message: 'The view passed is undefined and therefore invalid. You must pass a view instance to show.'
+        });
+      }
+  
+      if (view.isDestroyed) {
+        throw new Marionette.Error({
+          name: 'ViewDestroyedError',
+          message: 'View (cid: "' + view.cid + '") has already been destroyed and cannot be used.'
+        });
+      }
+    },
+  
+    // Override this method to change how the region finds the DOM
+    // element that it manages. Return a jQuery selector object scoped
+    // to a provided parent el or the document if none exists.
     getEl: function(el) {
-      return Backbone.$(el);
+      return Backbone.$(el, Marionette._getValue(this.options.parentEl, this));
     },
   
     // Override this method to change how the new view is
     // appended to the `$el` that the region is managing
     attachHtml: function(view) {
-      // empty the node and append new view
-      this.el.innerHTML='';
+      this.$el.contents().detach();
+  
       this.el.appendChild(view.el);
     },
   
@@ -1261,6 +1261,10 @@
         view.destroy();
       } else if (view.remove) {
         view.remove();
+  
+        // appending isDestroyed to raw Backbone View allows regions
+        // to throw a ViewDestroyedError for this view
+        view.isDestroyed = true;
       }
     },
   
@@ -1293,152 +1297,196 @@
   
       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
-  });
+  // Static Methods
+  {
+  
+    // 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.
+    //
+    // The config object should either be a string as a jQuery DOM selector,
+    // a Region class directly, or an object literal that specifies a selector,
+    // a custom regionClass, and any options to be supplied to the region:
+    //
+    // ```js
+    // {
+    //   selector: "#foo",
+    //   regionClass: MyCustomRegion,
+    //   allowMissingEl: false
+    // }
+    // ```
+    //
+    buildRegion: function(regionConfig, DefaultRegionClass) {
+      if (_.isString(regionConfig)) {
+        return this._buildRegionFromSelector(regionConfig, DefaultRegionClass);
+      }
   
-  // Copy the `extend` function used by Backbone's classes
-  Marionette.Region.extend = Marionette.extend;
+      if (regionConfig.selector || regionConfig.el || regionConfig.regionClass) {
+        return this._buildRegionFromObject(regionConfig, DefaultRegionClass);
+      }
   
-  // Marionette.RegionManager
-  // ------------------------
-  //
-  // Manage one or more related `Marionette.Region` objects.
-  Marionette.RegionManager = (function(Marionette) {
+      if (_.isFunction(regionConfig)) {
+        return this._buildRegionFromRegionClass(regionConfig);
+      }
   
-    var RegionManager = Marionette.Controller.extend({
-      constructor: function(options) {
-        this._regions = {};
-        Marionette.Controller.call(this, options);
-      },
+      throw new Marionette.Error({
+        message: 'Improper region configuration type.',
+        url: 'marionette.region.html#region-configuration-types'
+      });
+    },
   
-      // 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
-      // the region definition.
-      addRegions: function(regionDefinitions, defaults) {
-        if (_.isFunction(regionDefinitions)) {
-          regionDefinitions = regionDefinitions.apply(this, arguments);
-        }
+    // Build the region from a string selector like '#foo-region'
+    _buildRegionFromSelector: function(selector, DefaultRegionClass) {
+      return new DefaultRegionClass({ el: selector });
+    },
   
-        var regions = {};
+    // Build the region from a configuration object
+    // ```js
+    // { selector: '#foo', regionClass: FooRegion, allowMissingEl: false }
+    // ```
+    _buildRegionFromObject: function(regionConfig, DefaultRegionClass) {
+      var RegionClass = regionConfig.regionClass || DefaultRegionClass;
+      var options = _.omit(regionConfig, 'selector', 'regionClass');
   
-        _.each(regionDefinitions, function(definition, name) {
-          if (_.isString(definition)) {
-            definition = {selector: definition};
-          }
+      if (regionConfig.selector && !options.el) {
+        options.el = regionConfig.selector;
+      }
   
-          if (definition.selector) {
-            definition = _.defaults({}, definition, defaults);
-          }
+      return new RegionClass(options);
+    },
   
-          var region = this.addRegion(name, definition);
-          regions[name] = region;
-        }, this);
+    // Build the region directly from a given `RegionClass`
+    _buildRegionFromRegionClass: function(RegionClass) {
+      return new RegionClass();
+    }
+  });
   
-        return regions;
-      },
+  // Region Manager
+  // --------------
   
-      // Add an individual region to the region manager,
-      // and return the region instance
-      addRegion: function(name, definition) {
-        var region;
+  // Manage one or more related `Marionette.Region` objects.
+  Marionette.RegionManager = Marionette.Controller.extend({
+    constructor: function(options) {
+      this._regions = {};
   
-        if (definition instanceof Marionette.Region) {
-          region = definition;
-        } else {
-          region = Marionette.Region.buildRegion(definition, Marionette.Region);
+      Marionette.Controller.call(this, options);
+  
+      this.addRegions(this.getOption('regions'));
+    },
+  
+    // 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
+    // the region definition.
+    addRegions: function(regionDefinitions, defaults) {
+      regionDefinitions = Marionette._getValue(regionDefinitions, this, arguments);
+  
+      return _.reduce(regionDefinitions, function(regions, definition, name) {
+        if (_.isString(definition)) {
+          definition = {selector: definition};
+        }
+        if (definition.selector) {
+          definition = _.defaults({}, definition, defaults);
         }
   
-        this.triggerMethod('before:add:region', name, region);
+        regions[name] = this.addRegion(name, definition);
+        return regions;
+      }, {}, this);
+    },
   
-        this._store(name, region);
+    // Add an individual region to the region manager,
+    // and return the region instance
+    addRegion: function(name, definition) {
+      var region;
   
-        this.triggerMethod('add:region', name, region);
-        return region;
-      },
+      if (definition instanceof Marionette.Region) {
+        region = definition;
+      } else {
+        region = Marionette.Region.buildRegion(definition, Marionette.Region);
+      }
   
-      // Get a region by name
-      get: function(name) {
-        return this._regions[name];
-      },
+      this.triggerMethod('before:add:region', name, region);
   
-      // Gets all the regions contained within
-      // the `regionManager` instance.
-      getRegions: function(){
-        return _.clone(this._regions);
-      },
+      region._parent = this;
+      this._store(name, region);
   
-      // Remove a region by name
-      removeRegion: function(name) {
-        var region = this._regions[name];
-        this._remove(name, region);
+      this.triggerMethod('add:region', name, region);
+      return region;
+    },
   
-        return region;
-      },
+    // Get a region by name
+    get: function(name) {
+      return this._regions[name];
+    },
   
-      // Empty all regions in the region manager, and
-      // remove them
-      removeRegions: function() {
-        var regions = this.getRegions();
-        _.each(this._regions, function(region, name) {
-          this._remove(name, region);
-        }, this);
+    // Gets all the regions contained within
+    // the `regionManager` instance.
+    getRegions: function(){
+      return _.clone(this._regions);
+    },
   
-        return regions;
-      },
+    // Remove a region by name
+    removeRegion: function(name) {
+      var region = this._regions[name];
+      this._remove(name, region);
   
-      // Empty all regions in the region manager, but
-      // leave them attached
-      emptyRegions: function() {
-        var regions = this.getRegions();
-        _.each(regions, function(region) {
-          region.empty();
-        }, this);
+      return region;
+    },
   
-        return regions;
-      },
+    // Empty all regions in the region manager, and
+    // remove them
+    removeRegions: function() {
+      var regions = this.getRegions();
+      _.each(this._regions, function(region, name) {
+        this._remove(name, region);
+      }, this);
   
-      // Destroy all regions and shut down the region
-      // manager entirely
-      destroy: function() {
-        this.removeRegions();
-        return Marionette.Controller.prototype.destroy.apply(this, arguments);
-      },
+      return regions;
+    },
   
-      // internal method to store regions
-      _store: function(name, region) {
-        this._regions[name] = region;
-        this._setLength();
-      },
+    // Empty all regions in the region manager, but
+    // leave them attached
+    emptyRegions: function() {
+      var regions = this.getRegions();
+      _.invoke(regions, 'empty');
+      return regions;
+    },
   
-      // internal method to remove a region
-      _remove: function(name, region) {
-        this.triggerMethod('before:remove:region', name, region);
-        region.empty();
-        region.stopListening();
-        delete this._regions[name];
-        this._setLength();
-        this.triggerMethod('remove:region', name, region);
-      },
+    // Destroy all regions and shut down the region
+    // manager entirely
+    destroy: function() {
+      this.removeRegions();
+      return Marionette.Controller.prototype.destroy.apply(this, arguments);
+    },
   
-      // set the number of regions current held
-      _setLength: function() {
-        this.length = _.size(this._regions);
-      }
+    // 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);
+      region.empty();
+      region.stopListening();
   
-    Marionette.actAsCollection(RegionManager.prototype, '_regions');
+      delete region._parent;
+      delete this._regions[name];
+      this._setLength();
+      this.triggerMethod('remove:region', name, region);
+    },
   
-    return RegionManager;
-  })(Marionette);
+    // set the number of regions current held
+    _setLength: function() {
+      this.length = _.size(this._regions);
+    }
+  });
+  
+  Marionette.actAsCollection(Marionette.RegionManager.prototype, '_regions');
   
 
   // Template Cache
@@ -1479,7 +1527,7 @@
     // `clear("#t1", "#t2", "...")`
     clear: function() {
       var i;
-      var args = slice.call(arguments);
+      var args = _.toArray(arguments);
       var length = args.length;
   
       if (length > 0) {
@@ -1557,12 +1605,7 @@
         });
       }
   
-      var templateFunc;
-      if (typeof template === 'function') {
-        templateFunc = template;
-      } else {
-        templateFunc = Marionette.TemplateCache.get(template);
-      }
+      var templateFunc = _.isFunction(template) ? template : Marionette.TemplateCache.get(template);
   
       return templateFunc(data);
     }
@@ -1570,27 +1613,30 @@
   
 
   /* jshint maxlen: 114, nonew: false */
-  // Marionette.View
-  // ---------------
+  // View
+  // ----
   
   // The core view class that other Marionette views extend from.
   Marionette.View = Backbone.View.extend({
+    isDestroyed: false,
   
     constructor: function(options) {
       _.bindAll(this, 'render');
   
+      options = Marionette._getValue(options, this);
+  
       // 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.options = _.extend({}, _.result(this, 'options'), options);
   
       this._behaviors = Marionette.Behaviors(this);
   
       Backbone.View.apply(this, arguments);
   
       Marionette.MonitorDOMRefresh(this);
-      this.listenTo(this, 'show', this.onShowCalled);
+      this.on('show', this.onShowCalled);
     },
   
     // Get the template for this view
@@ -1604,7 +1650,7 @@
     // 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));
+      return model.toJSON.apply(model, _.rest(arguments));
     },
   
     // Mix in template helper methods. Looks for a
@@ -1615,18 +1661,15 @@
     mixinTemplateHelpers: function(target) {
       target = target || {};
       var templateHelpers = this.getOption('templateHelpers');
-      if (_.isFunction(templateHelpers)) {
-        templateHelpers = templateHelpers.call(this);
-      }
+      templateHelpers = Marionette._getValue(templateHelpers, this);
       return _.extend(target, templateHelpers);
     },
   
     // normalize the keys of passed hash with the views `ui` selectors.
     // `{"@ui.foo": "bar"}`
     normalizeUIKeys: function(hash) {
-      var ui = _.result(this, 'ui');
       var uiBindings = _.result(this, '_uiBindings');
-      return Marionette.normalizeUIKeys(hash, uiBindings || ui);
+      return Marionette.normalizeUIKeys(hash, uiBindings || _.result(this, 'ui'));
     },
   
     // normalize the values of passed hash with the views `ui` selectors.
@@ -1642,18 +1685,15 @@
     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;
+      return _.reduce(triggers, function(events, value, key) {
+        events[key] = this._buildViewTrigger(value);
+        return events;
+      }, {}, this);
     },
   
     // Overriding Backbone.View's delegateEvents to handle
@@ -1673,8 +1713,7 @@
   
     // internal method to delegate DOM events and triggers
     _delegateDOMEvents: function(eventsArg) {
-      var events = eventsArg || this.events;
-      if (_.isFunction(events)) { events = events.call(this); }
+      var events = Marionette._getValue(eventsArg || this.events, this);
   
       // normalize ui keys
       events = this.normalizeUIKeys(events);
@@ -1696,8 +1735,7 @@
     // 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);
+      Backbone.View.prototype.undelegateEvents.apply(this, arguments);
   
       this.unbindEntityEvents(this.model, this.getOption('modelEvents'));
       this.unbindEntityEvents(this.collection, this.getOption('collectionEvents'));
@@ -1730,7 +1768,7 @@
     destroy: function() {
       if (this.isDestroyed) { return; }
   
-      var args = slice.call(arguments);
+      var args = _.toArray(arguments);
   
       this.triggerMethod.apply(this, ['before:destroy'].concat(args));
   
@@ -1778,8 +1816,7 @@
       this.ui = {};
   
       // bind each of the selectors
-      _.each(_.keys(bindings), function(key) {
-        var selector = bindings[key];
+      _.each(bindings, function(selector, key) {
         this.ui[key] = this.$(selector);
       }, this);
     },
@@ -1850,17 +1887,35 @@
     // 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);
-      });
+      var triggerMethod = Marionette._triggerMethod;
+      var ret = triggerMethod(this, arguments);
+      var behaviors = this._behaviors;
+      // Use good ol' for as this is a very hot function
+      for (var i = 0, length = behaviors && behaviors.length; i < length; i++) {
+        triggerMethod(behaviors[i], arguments);
+      }
   
       return ret;
     },
   
+    // This method returns any views that are immediate
+    // children of this view
+    _getImmediateChildren: function() {
+      return [];
+    },
+  
+    // Returns an array of every nested view within this view
+    _getNestedViews: function() {
+      var children = this._getImmediateChildren();
+  
+      if (!children.length) { return children; }
+  
+      return _.reduce(children, function(memo, view) {
+        if (!view._getNestedViews) { return memo; }
+        return memo.concat(view._getNestedViews());
+      }, children);
+    },
+  
     // Imports the "normalizeMethods" to transform hashes of
     // events=>function references/names to a hash of events=>function references
     normalizeMethods: Marionette.normalizeMethods,
@@ -1868,7 +1923,7 @@
     // 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.
+    // Proxy `bindEntityEvents` to enable binding view's events from another entity.
     bindEntityEvents: Marionette.proxyBindEntityEvents,
   
     // Proxy `unbindEntityEvents` to enable unbinding view's events from another entity.
@@ -1897,21 +1952,27 @@
     // 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);
+      if (!this.model && !this.collection) {
+        return {};
       }
-      else if (this.collection) {
-        data = { items: _.partial(this.serializeCollection, this.collection).apply(this, arguments) };
+  
+      var args = [this.model || this.collection];
+      if (arguments.length) {
+        args.push.apply(args, arguments);
       }
   
-      return data;
+      if (this.model) {
+        return this.serializeModel.apply(this, args);
+      } else {
+        return {
+          items: this.serializeCollection.apply(this, args)
+        };
+      }
     },
   
     // Serialize a collection by serializing each of its models.
     serializeCollection: function(collection){
-      return collection.toJSON.apply(collection, slice.call(arguments, 1));
+      return collection.toJSON.apply(collection, _.rest(arguments));
     },
   
     // Render the view, defaulting to underscore.js templates.
@@ -1978,14 +2039,6 @@
       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);
     }
   });
   
@@ -2008,7 +2061,9 @@
     // This will fallback onto appending childView's to the end.
     constructor: function(options){
       var initOptions = options || {};
-      this.sort = _.isUndefined(initOptions.sort) ? true : initOptions.sort;
+      if (_.isUndefined(this.sort)){
+        this.sort = _.isUndefined(initOptions.sort) ? true : initOptions.sort;
+      }
   
       this.once('render', this._initialEvents);
       this._initChildViewStorage();
@@ -2126,6 +2181,9 @@
       }
     },
   
+    // Internal reference to what index a `emptyView` is.
+    _emptyViewIndex: -1,
+  
     // Internal method. Separated so that CompositeView can have
     // more control over events being triggered, around the rendering
     // process
@@ -2189,7 +2247,7 @@
     },
   
     // Render and show the emptyView. Similar to addChild method
-    // but "child:added" events are not fired, and the event from
+    // but "add:child" events are not fired, and the event from
     // emptyView are not forwarded
     addEmptyView: function(child, EmptyView) {
   
@@ -2198,12 +2256,14 @@
                             this.getOption('childViewOptions');
   
       if (_.isFunction(emptyViewOptions)){
-        emptyViewOptions = emptyViewOptions.call(this);
+        emptyViewOptions = emptyViewOptions.call(this, child, this._emptyViewIndex);
       }
   
       // build the empty view
       var view = this.buildChildView(child, EmptyView, emptyViewOptions);
   
+      view._parent = this;
+  
       // Proxy emptyView events
       this.proxyChildEvents(view);
   
@@ -2218,7 +2278,7 @@
       this.children.add(view);
   
       // Render it and show it
-      this.renderChildView(view, -1);
+      this.renderChildView(view, this._emptyViewIndex);
   
       // call the 'show' method if the collection view
       // has already been shown
@@ -2252,9 +2312,7 @@
     // in order to keep the children in sync with the collection.
     addChild: function(child, ChildView, index) {
       var childViewOptions = this.getOption('childViewOptions');
-      if (_.isFunction(childViewOptions)) {
-        childViewOptions = childViewOptions.call(this, child, index);
-      }
+      childViewOptions = Marionette._getValue(childViewOptions, this, [child, index]);
   
       var view = this.buildChildView(child, ChildView, childViewOptions);
   
@@ -2263,6 +2321,8 @@
   
       this._addChildView(view, index);
   
+      view._parent = this;
+  
       return view;
     },
   
@@ -2276,22 +2336,14 @@
       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) {
-            laterView._index++;
-          }
-        });
-      }
-      else {
-        // decrement the index of views after this one
-        this.children.each(function (laterView) {
-          if (laterView._index >= view._index) {
-            laterView._index--;
-          }
-        });
       }
+  
+      // update the indexes of views after this one
+      this.children.each(function (laterView) {
+        if (laterView._index >= view._index) {
+          laterView._index += increment ? 1 : -1;
+        }
+      });
     },
   
   
@@ -2340,6 +2392,7 @@
         if (view.destroy) { view.destroy(); }
         else if (view.remove) { view.remove(); }
   
+        delete view._parent;
         this.stopListening(view);
         this.children.remove(view);
         this.triggerMethod('remove:child', view);
@@ -2448,7 +2501,7 @@
       // 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 args = _.toArray(arguments);
         var rootEvent = args[0];
         var childEvents = this.normalizeMethods(_.result(this, 'childEvents'));
   
@@ -2462,6 +2515,10 @@
   
         this.triggerMethod.apply(this, args);
       }, this);
+    },
+  
+    _getImmediateChildren: function() {
+      return _.values(this.children._views);
     }
   });
   
@@ -2510,17 +2567,10 @@
     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.
+    // Serialize the model 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() {
@@ -2533,9 +2583,7 @@
       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.
+    // Renders the model and the collection.
     render: function() {
       this._ensureViewIsIntact();
       this.isRendered = true;
@@ -2604,13 +2652,13 @@
     // Overidden from CollectionView to ensure view is appended to
     // childViewContainer
     _insertAfter: function (childView) {
-      var $container = this.getChildViewContainer(this);
+      var $container = this.getChildViewContainer(this, childView);
       $container.append(childView.el);
     },
   
     // Internal method to ensure an `$childViewContainer` exists, for the
     // `attachHtml` method to use.
-    getChildViewContainer: function(containerView) {
+    getChildViewContainer: function(containerView, childView) {
       if ('$childViewContainer' in containerView) {
         return containerView.$childViewContainer;
       }
@@ -2619,7 +2667,7 @@
       var childViewContainer = Marionette.getOption(containerView, 'childViewContainer');
       if (childViewContainer) {
   
-        var selector = _.isFunction(childViewContainer) ? childViewContainer.call(containerView) : childViewContainer;
+        var selector = Marionette._getValue(childViewContainer, containerView);
   
         if (selector.charAt(0) === '@' && containerView.ui) {
           container = containerView.ui[selector.substr(4)];
@@ -2650,8 +2698,8 @@
     }
   });
   
-  // LayoutView
-  // ----------
+  // Layout View
+  // -----------
   
   // Used for managing application layoutViews, nested layoutViews and
   // multiple regions within an application or sub-application.
@@ -2734,11 +2782,9 @@
   
     // internal method to build regions
     _buildRegions: function(regions) {
-      var that = this;
-  
       var defaults = {
         regionClass: this.getOption('regionClass'),
-        parentEl: function() { return that.$el; }
+        parentEl: _.partial(_.result, this, 'el')
       };
   
       return this.regionManager.addRegions(regions, defaults);
@@ -2750,19 +2796,13 @@
       var regions;
       this._initRegionManager();
   
-      if (_.isFunction(this.regions)) {
-        regions = this.regions(options);
-      } else {
-        regions = this.regions || {};
-      }
+      regions = Marionette._getValue(this.regions, this, [options]) || {};
   
       // 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);
-      }
+      regionOptions = Marionette._getValue(regionOptions, this, [options]);
   
       _.extend(regions, regionOptions);
   
@@ -2776,10 +2816,7 @@
     // Internal method to re-initialize all of the regions by updating the `el` that
     // they point to
     _reInitializeRegions: function() {
-      this.regionManager.emptyRegions();
-      this.regionManager.each(function(region) {
-        region.reset();
-      });
+      this.regionManager.invoke('reset');
     },
   
     // Enable easy overriding of the default `RegionManager`
@@ -2793,6 +2830,7 @@
     // and all regions in it
     _initRegionManager: function() {
       this.regionManager = this.getRegionManager();
+      this.regionManager._parent = this;
   
       this.listenTo(this.regionManager, 'before:add:region', function(name) {
         this.triggerMethod('before:add:region', name);
@@ -2811,20 +2849,27 @@
         delete this[name];
         this.triggerMethod('remove:region', name, region);
       });
+    },
+  
+    _getImmediateChildren: function() {
+      return _.chain(this.regionManager.getRegions())
+        .pluck('currentView')
+        .compact()
+        .value();
     }
   });
   
 
   // 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) {
+  Marionette.Behavior = Marionette.Object.extend({
+    constructor: function(options, view) {
       // Setup reference to the view.
       // this comes in handle when a behavior
       // wants to directly talk up the chain
@@ -2833,57 +2878,31 @@
       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,
+      Marionette.Object.apply(this, arguments);
+    },
   
-      // Proxy `unbindEntityEvents` to enable unbinding view's events from another entity.
-      unbindEntityEvents: Marionette.proxyUnbindEntityEvents
-    });
+    // proxy behavior $ method to the view
+    // this is useful for doing jquery DOM lookups
+    // scoped to behaviors view.
+    $: function() {
+      return this.view.$.apply(this.view, arguments);
+    },
   
-    // 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;
+    // Stops the behavior from listening to events.
+    // Overrides Object#destroy to prevent additional events from being triggered.
+    destroy: function() {
+      this.stopListening();
+    },
   
-    return Behavior;
-  })(_, Backbone);
+    proxyViewProperties: function (view) {
+      this.$el = view.$el;
+      this.el = view.el;
+    }
+  });
   
   /* jshint maxlen: 143 */
-  // Marionette.Behaviors
-  // --------
+  // Behaviors
+  // ---------
   
   // Behaviors is a utility class that takes care of
   // gluing your behavior instances to their given View.
@@ -2892,6 +2911,8 @@
   // method for things to work properly.
   
   Marionette.Behaviors = (function(Marionette, _) {
+    // Borrow event splitter from Backbone
+    var delegateEventSplitter = /^(\S+)\s*(.*)$/;
   
     function Behaviors(view, behaviors) {
   
@@ -2918,12 +2939,12 @@
   
       behaviorEvents: function(behaviorEvents, behaviors) {
         var _behaviorsEvents = {};
-        var viewUI = _.result(this, 'ui');
+        var viewUI = this._uiBindings || _.result(this, 'ui');
   
         _.each(behaviors, function(b, i) {
           var _events = {};
           var behaviorEvents = _.clone(_.result(b, 'events')) || {};
-          var behaviorUI = _.result(b, 'ui');
+          var behaviorUI = b._uiBindings || _.result(b, 'ui');
   
           // Construct an internal UI hash first using
           // the views UI hash and then the behaviors UI hash.
@@ -2936,21 +2957,25 @@
           // 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 ".
+          var j = 0;
+          _.each(behaviorEvents, function(behaviour, key) {
+            var match     = key.match(delegateEventSplitter);
+  
+            // Set event name to be namespaced using the view cid,
+            // the behavior index, and the behavior event index
+            // to generate a non colliding event namespace
+            // http://api.jquery.com/event.namespace/
+            var eventName = match[1] + '.' + [this.cid, i, j++, ' '].join(''),
+                selector  = match[2];
   
-            // +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]];
+            var eventKey  = eventName + selector;
+            var handler   = _.isFunction(behaviour) ? behaviour : b[behaviour];
   
             _events[eventKey] = _.bind(handler, b);
-          });
+          }, this);
   
           _behaviorsEvents = _.extend(_behaviorsEvents, _events);
-        });
+        }, this);
   
         return _behaviorsEvents;
       }
@@ -2985,7 +3010,7 @@
         }
   
         // 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];
+        return Marionette._getValue(Behaviors.behaviorsLookup, this, [options, key])[key];
       },
   
       // Iterate over the behaviors object, for each behavior
@@ -3036,7 +3061,7 @@
   
         triggersHash = Marionette.normalizeUIKeys(triggersHash, ui);
   
-        _.each(triggersHash, _.partial(this._setHandlerForBehavior, behavior, i), this);
+        _.each(triggersHash, _.bind(this._setHandlerForBehavior, this, behavior, i));
       },
   
       // Internal method to create and assign the trigger handler for a given
@@ -3056,8 +3081,8 @@
   })(Marionette, _);
   
 
-  // AppRouter
-  // ---------
+  // App Router
+  // ----------
   
   // Reduce the boilerplate code of handling route events
   // and then calling a single method on another object.
@@ -3077,10 +3102,10 @@
   Marionette.AppRouter = Backbone.Router.extend({
   
     constructor: function(options) {
-      Backbone.Router.apply(this, arguments);
-  
       this.options = options || {};
   
+      Backbone.Router.apply(this, arguments);
+  
       var appRoutes = this.getOption('appRoutes');
       var controller = this._getController();
       this.processAppRoutes(controller, appRoutes);
@@ -3097,11 +3122,10 @@
     // 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
+      // make sure an onRoute before trying to call it
       if (_.isFunction(this.onRoute)) {
+        // find the path that matches the current route
+        var routePath = _.invert(this.getOption('appRoutes'))[routeName];
         this.onRoute(routeName, routePath, routeArgs);
       }
     },
@@ -3134,7 +3158,13 @@
     },
   
     // Proxy `getOption` to enable getting options from this or this.options by name.
-    getOption: Marionette.proxyGetOption
+    getOption: Marionette.proxyGetOption,
+  
+    triggerMethod: Marionette.triggerMethod,
+  
+    bindEntityEvents: Marionette.proxyBindEntityEvents,
+  
+    unbindEntityEvents: Marionette.proxyUnbindEntityEvents
   });
   
   // Application
@@ -3143,20 +3173,15 @@
   // Contain and manage the composite application as a whole.
   // Stores and starts up `Region` objects, includes an
   // event aggregator as `app.vent`
-  Marionette.Application = function(options) {
-    this.options = options;
-    this._initializeRegions(options);
-    this._initCallbacks = new Marionette.Callbacks();
-    this.submodules = {};
-    _.extend(this, options);
-    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() {},
+  Marionette.Application = Marionette.Object.extend({
+    constructor: function(options) {
+      this._initializeRegions(options);
+      this._initCallbacks = new Marionette.Callbacks();
+      this.submodules = {};
+      _.extend(this, options);
+      this._initChannel();
+      Marionette.Object.call(this, options);
+    },
   
     // Command execution, facilitated by Backbone.Wreqr.Commands
     execute: function() {
@@ -3222,9 +3247,7 @@
       // 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);
+      var args = _.toArray(arguments);
       args.unshift(this);
   
       // see the Marionette.Module object for more information
@@ -3264,23 +3287,24 @@
     // Internal method to set up the region manager
     _initRegionManager: function() {
       this._regionManager = this.getRegionManager();
+      this._regionManager._parent = this;
   
-      this.listenTo(this._regionManager, 'before:add:region', function(name) {
-        this.triggerMethod('before:add:region', name);
+      this.listenTo(this._regionManager, 'before:add:region', function() {
+        Marionette._triggerMethod(this, 'before:add:region', arguments);
       });
   
       this.listenTo(this._regionManager, 'add:region', function(name, region) {
         this[name] = region;
-        this.triggerMethod('add:region', name, region);
+        Marionette._triggerMethod(this, 'add:region', arguments);
       });
   
-      this.listenTo(this._regionManager, 'before:remove:region', function(name) {
-        this.triggerMethod('before:remove:region', name);
+      this.listenTo(this._regionManager, 'before:remove:region', function() {
+        Marionette._triggerMethod(this, 'before:remove:region', arguments);
       });
   
-      this.listenTo(this._regionManager, 'remove:region', function(name, region) {
+      this.listenTo(this._regionManager, 'remove:region', function(name) {
         delete this[name];
-        this.triggerMethod('remove:region', name, region);
+        Marionette._triggerMethod(this, 'remove:region', arguments);
       });
     },
   
@@ -3291,19 +3315,9 @@
       this.vent = _.result(this, 'vent') || this.channel.vent;
       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
@@ -3391,7 +3405,7 @@
   
       // stop the sub-modules; depth-first, to make sure the
       // sub-modules are stopped / finalized before parents
-      _.each(this.submodules, function(mod) { mod.stop(); });
+      _.invoke(this.submodules, 'stop');
   
       // run the finalizers
       this._finalizerCallbacks.run(undefined, this);
@@ -3450,8 +3464,7 @@
   
       // 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);
+      var customArgs = _.rest(arguments, 3);
   
       // Split the module names and get the number of submodules.
       // i.e. an example module name of `Doge.Wow.Amaze` would