marionette-rails 2.1.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d10008a4bdd7395c481f9176275a9a54da10d01
-  data.tar.gz: ab674f817ccd0980590767aeae47cb69a8e3b42a
+  metadata.gz: 97731fd8838b5590ee15c0d9cb0fbabfe575d264
+  data.tar.gz: fa19df0cc00e1a5887bbaf02ea6a348579b9afd2
 SHA512:
-  metadata.gz: 48b594f9ca211caa9108bcc5bd2df708a9f5b70461346e9fc53d747d69567727d9f86291067b503337443e051df8087510b16c4af83d14566f783392940bf04d
-  data.tar.gz: 6b6fad38c2a7ae1ad774c6702d5364b0787125c68c86de6a37ab60ee2837875dde2919959e2f7421b0aa15ecef4c59d6e1bc1380670b93e75bb9deadf309ee5b
+  metadata.gz: 3a8a8069c059b6ee0b4100a2e31b58c476ecda37aa9b1938c2573bf556917540ef750ecbe065bd45d08ed8db2df7bc1c818394d733272eca31284c81e6d83ed2
+  data.tar.gz: 92f348ccd1500aef5677e420ecda8f0dd0537a38b765aee6f5513e0175a3fc85d6d20997993d256b51bff2992c44c285e01efe3a55a4b14fa2fb1a48e189861b

data/lib/marionette-rails/version.rb

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

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

@@ -1,6 +1,6 @@
 // MarionetteJS (Backbone.Marionette)
 // ----------------------------------
-// v2.1.0
+// v2.2.1
 //
 // Copyright (c)2014 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
@@ -19,6 +19,7 @@
 
 (function(root, factory) {
 
+  /* istanbul ignore next */
   if (typeof define === 'function' && define.amd) {
     define(['backbone', 'underscore'], function(Backbone, _) {
       return (root.Marionette = factory(root, Backbone, _));
@@ -34,6 +35,7 @@
 }(this, function(root, Backbone, _) {
   'use strict';
 
+  /* istanbul ignore next */
   // Backbone.BabySitter
   // -------------------
   // v0.1.4
@@ -172,6 +174,8 @@
     };
     return Backbone.ChildViewContainer;
   })(Backbone, _);
+
+  /* istanbul ignore next */
   // Backbone.Wreqr (Backbone.Marionette)
   // ----------------------------------
   // v1.3.1
@@ -489,7 +493,7 @@
 
   var Marionette = Backbone.Marionette = {};
 
-  Marionette.VERSION = '2.1.0';
+  Marionette.VERSION = '2.2.1';
 
   Marionette.noConflict = function() {
     root.Marionette = previousMarionette;
@@ -502,51 +506,45 @@
   Marionette.Deferred = Backbone.$.Deferred;
 
   /* jshint unused: false */
-  
+
   // Helpers
   // -------
-  
+
   // For slicing `arguments` in functions
   var slice = Array.prototype.slice;
-  
-  function throwError(message, name) {
-    var error = new Error(message);
-    error.name = name || 'Error';
-    throw error;
-  }
-  
+
   // 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) {
@@ -562,29 +560,54 @@
     }, this);
     return normalizedHash;
   };
-  
-  
+
+  // utility method for parsing @ui. syntax strings
+  // into associated selector
+  Marionette.normalizeUIString = function(uiString, ui) {
+    return uiString.replace(/@ui\.[a-zA-Z_$0-9]*/g, function(r) {
+      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
+  // 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;
     }
-  
-    _.each(_.keys(hash), function(v) {
-      var pattern = /@ui\.[a-zA-Z_$0-9]*/g;
-      if (v.match(pattern)) {
-        hash[v.replace(pattern, function(r) {
-          return ui[r.slice(4)];
-        })] = hash[v];
-        delete hash[v];
+
+    hash = _.clone(hash);
+
+    _.each(_.keys(hash), function(key) {
+      var normalizedKey = Marionette.normalizeUIString(key, ui);
+      if (normalizedKey !== key) {
+        hash[normalizedKey] = hash[key];
+        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
+  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;
   };
-  
+
   // Mix in methods from Underscore, for iteration, and other
   // collection related features.
   // Borrowing this code from Backbone.Collection:
@@ -594,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));
@@ -603,7 +626,7 @@
       };
     });
   };
-  
+
   // Trigger an event and/or a corresponding method name. Examples:
   //
   // `this.triggerMethod("foo")` will trigger the "foo" event and
@@ -611,48 +634,60 @@
   //
   // `this.triggerMethod("foo:bar")` will trigger the "foo:bar" event and
   // call the "onFooBar" method.
-  Marionette.triggerMethod = (function() {
-  
+  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();
     }
-  
-    // actual triggerMethod implementation
-    var triggerMethod = function(event) {
-      // 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;
-    };
-  
-    return triggerMethod;
-  })();
-  
+
+    // 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')`
+  // 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;
+    }
+
+    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")
@@ -660,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)) {
@@ -675,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
   // ---------------------------
   //
@@ -710,61 +745,69 @@
   // 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) {
-          throwError('Method "' + methodName +
+          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({
+          message: 'Bindings must be an object or function.',
+          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)) {
@@ -772,34 +815,70 @@
         } 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 + '/',
+
+    constructor: function(message, options) {
+      if (_.isObject(message)) {
+        options = message;
+        message = options.message;
+      } 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.
@@ -807,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.
@@ -833,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
   // ---------------------
   //
@@ -855,116 +934,118 @@
   // 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
   // ---------------------
   //
   // A Base Class that other Classes should descend from.
   // Object borrows many conventions and utilities from Backbone.
   Marionette.Object = function(options) {
-  
     this.options = _.extend({}, _.result(this, 'options'), options);
-  
-    this.initialize(this.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) {
-      throwError('An "el" must be specified for a region.', 'NoElError');
+      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.
     //
@@ -983,24 +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);
       }
-  
-      throwError('Improper region configuration type. Please refer ' +
-        'to http://marionettejs.com/docs/marionette.region.html#region-configuration-types');
+
+      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 }
@@ -1008,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
@@ -1033,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
@@ -1058,30 +1141,34 @@
     // 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 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 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
+      var _shouldShowView = isDifferentView || forceShow;
+
+      if (isChangingView) {
+        this.triggerMethod('before:swapOut', this.currentView);
+      }
+
       if (_shouldDestroyView) {
         this.empty();
       }
-  
-      // show the view if the view is different or if you want to re-show the view
-      var _shouldShowView = isDifferentView || forceShow;
-  
+
       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
@@ -1089,57 +1176,51 @@
         // we can not reuse it.
         view.once('destroy', _.bind(this.empty, this));
         view.render();
-  
+
         if (isChangingView) {
           this.triggerMethod('before:swap', view);
         }
-  
+
         this.triggerMethod('before:show', view);
-  
-        if (_.isFunction(view.triggerMethod)) {
-          view.triggerMethod('before:show');
-        } else {
-          this.triggerMethod.call(view, 'before:show');
+        Marionette.triggerMethodOn(view, 'before:show');
+
+        if (isChangingView) {
+          this.triggerMethod('swapOut', this.currentView);
         }
-  
+
         this.attachHtml(view);
         this.currentView = view;
-  
+
         if (isChangingView) {
           this.triggerMethod('swap', view);
         }
-  
+
         this.triggerMethod('show', view);
-  
-        if (_.isFunction(view.triggerMethod)) {
-          view.triggerMethod('show');
-        } else {
-          this.triggerMethod.call(view, 'show');
-        }
-  
+        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) {
-        throwError('An "el" ' + this.$el.selector + ' must exist in DOM');
+        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) {
@@ -1147,37 +1228,37 @@
       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; }
-  
+
       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`
@@ -1186,52 +1267,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
@@ -1240,69 +1321,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;
-  
-        var isObject = _.isObject(definition);
-        var isString = _.isString(definition);
-        var hasSelector = !!definition.selector;
-  
-        if (isString || (isObject && hasSelector)) {
-          region = Marionette.Region.buildRegion(definition, Marionette.Region);
-        } else if (_.isFunction(definition)) {
-          region = Marionette.Region.buildRegion(definition, Marionette.Region);
-        } else {
+
+        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() {
@@ -1310,10 +1385,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() {
@@ -1321,23 +1396,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);
@@ -1347,49 +1422,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()`
@@ -1401,7 +1476,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]];
@@ -1411,26 +1486,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
@@ -1438,14 +1513,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) {
-        throwError('Could not find template: "' + templateId + '"', 'NoTemplateError');
+        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
@@ -1454,64 +1532,62 @@
       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
     // custom rendering and template handling for all of Marionette.
     render: function(template, data) {
       if (!template) {
-        throwError('Cannot render the template since its false, null or undefined.',
-          'TemplateNotFoundError');
+        throw new Marionette.Error({
+          name: 'TemplateNotFoundError',
+          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);
-      // parses out the @ui DSL for events
-      this.events = this.normalizeUIKeys(_.result(this, 'events'));
-  
-      if (_.isObject(this.behaviors)) {
-        new Marionette.Behaviors(this);
-      }
-  
+
+      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
@@ -1519,13 +1595,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
@@ -1539,208 +1615,275 @@
       }
       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);
     },
-  
+
+    // normalize the values of passed hash with the views `ui` selectors.
+    // `{foo: "@ui.bar"}`
+    normalizeUIValues: function(hash) {
+      var ui = _.result(this, 'ui');
+      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) {
-  
-        var hasOptions = _.isObject(value);
-        var eventName = hasOptions ? value.event : value;
-  
-        // build the event handler function for the DOM event
-        triggerEvents[key] = function(e) {
-  
-          // stop the event in its tracks
-          if (e) {
-            var prevent = e.preventDefault;
-            var stop = e.stopPropagation;
-  
-            var shouldPrevent = hasOptions ? value.preventDefault : prevent;
-            var shouldStop = hasOptions ? value.stopPropagation : stop;
-  
-            if (shouldPrevent && prevent) { prevent.apply(e); }
-            if (shouldStop && stop) { stop.apply(e); }
-          }
-  
-          // build the args for the event
-          var args = {
-            view: this,
-            model: this.model,
-            collection: this.collection
-          };
-  
-          // trigger the event
-          this.triggerMethod(eventName, args);
-        };
-  
+        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(events) {
-      events = events || this.events;
+    _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);
-  
+      _.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) {
-        var err = new Error('Cannot use a view thats already been destroyed.');
-        err.name = 'ViewDestroyedError';
-        throw err;
+        throw new Marionette.Error({
+          name: 'ViewDestroyedError',
+          message: 'View (cid: "' + this.cid + '") has already been destroyed and cannot be used.'
+        });
       }
     },
-  
+
     // 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() {
+    _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: Marionette.triggerMethod,
-  
+    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
@@ -1750,22 +1893,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,
@@ -1773,47 +1916,49 @@
     // 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) {
-        throwError('Cannot render the template since it is null or undefined.',
-          'UndefinedTemplateError');
+        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 overriden to optimize rendering,
+    // This method can be overridden to optimize rendering,
     // or to render in a non standard way.
     //
     // For example, using `innerHTML` instead of `$el.html`
@@ -1826,32 +1971,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.
@@ -1859,15 +2004,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._initialEvents();
+
       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
@@ -1875,12 +2020,12 @@
       this.elBuffer = document.createDocumentFragment();
       this._bufferedChildren = [];
     },
-  
+
     startBuffering: function() {
       this.initRenderBuffer();
       this.isBuffering = true;
     },
-  
+
     endBuffering: function() {
       this.isBuffering = false;
       this._triggerBeforeShowBufferedChildren();
@@ -1888,26 +2033,27 @@
       this._triggerShowBufferedChildren();
       this.initRenderBuffer();
     },
-  
+
     _triggerBeforeShowBufferedChildren: function() {
       if (this._isShown) {
-        _.invoke(this._bufferedChildren, 'triggerMethod', 'before:show');
+        _.each(this._bufferedChildren, _.partial(this._triggerMethodOnChild, 'before:show'));
       }
     },
-  
+
     _triggerShowBufferedChildren: function() {
       if (this._isShown) {
-        _.each(this._bufferedChildren, function (child) {
-          if (_.isFunction(child.triggerMethod)) {
-            child.triggerMethod('show');
-          } else {
-            Marionette.triggerMethod.call(child, 'show');
-          }
-        });
+        _.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() {
@@ -1915,13 +2061,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();
@@ -1929,25 +2075,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(function(child){
-        if (_.isFunction(child.triggerMethod)) {
-          child.triggerMethod('show');
-        } else {
-          Marionette.triggerMethod.call(child, 'show');
-        }
-      });
+    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.
@@ -1958,7 +2098,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`
@@ -1966,7 +2106,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() {
@@ -1975,19 +2115,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 {
@@ -1998,7 +2138,7 @@
         this.triggerMethod('render:collection', this);
       }
     },
-  
+
     // Internal method to loop through collection and show each child view.
     showCollection: function() {
       var ChildView;
@@ -2007,74 +2147,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){
-  
+    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){
-        this.triggerMethod.call(view, 'before:show');
+      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){
-        this.triggerMethod.call(view, 'show');
+      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.
@@ -2083,14 +2230,17 @@
     // to determine what `childView` class to return.
     getChildView: function(child) {
       var childView = this.getOption('childView');
-  
+
       if (!childView) {
-        throwError('A "childView" must be specified', 'NoChildViewError');
+        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
@@ -2100,28 +2250,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) {
@@ -2138,85 +2288,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){
-        if (_.isFunction(view.triggerMethod)) {
-          view.triggerMethod('show');
-        } else {
-          Marionette.triggerMethod.call(view, 'show');
-        }
+
+      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(collection) {
+    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`.
@@ -2237,7 +2383,7 @@
         }
       }
     },
-  
+
     // Internal method. Check whether we need to insert the view into
     // the correct position.
     _insertBefore: function(childView, index) {
@@ -2249,37 +2395,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() {
@@ -2288,42 +2434,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
@@ -2332,55 +2478,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
-      this.once('render', function() {
-        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);
-          }
+
+      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) {
-        throwError('A "childView" must be specified', 'NoChildViewError');
+        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.
@@ -2388,44 +2535,44 @@
       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 overriden to optimize rendering,
+    // This method can be overridden to optimize rendering,
     // or to render in a non standard way.
     //
     // For example, using `innerHTML` instead of `$el.html`
@@ -2438,16 +2585,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
@@ -2455,39 +2602,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) {
-          throwError('The specified "childViewContainer" was not found: ' +
-            containerView.childViewContainer, 'ChildViewContainerMissingError');
+          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) {
@@ -2495,10 +2644,10 @@
       }
     }
   });
-  
+
   // LayoutView
   // ----------
-  
+
   // Used for managing application layoutViews, nested layoutViews and
   // multiple regions within an application or sub-application.
   //
@@ -2507,25 +2656,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
@@ -2535,88 +2684,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) {
-      this.triggerMethod('before:region:add', name);
       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) {
-      this.triggerMethod('before:region:remove', 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() {
@@ -2625,48 +2776,48 @@
         region.reset();
       });
     },
-  
-    // Enable easy overiding of the default `RegionManager`
-    // for customized region interactions and buisness specific
+
+    // 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.
@@ -2676,185 +2827,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
-    // inheritence pattern that follow in suite
+    // inheritance pattern that follows suit
     // with the rest of Marionette views.
     Behavior.extend = Marionette.extend;
-  
+
     return Behavior;
   })(_, Backbone);
-  
-  /* jshint maxlen: 143, nonew: false */
+
+  /* jshint maxlen: 143 */
   // Marionette.Behaviors
   // --------
-  
+
   // Behaviors is a utility class that takes care of
-  // glueing your behavior instances to their given View.
+  // 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 = {
-      setElement: function(setElement, behaviors) {
-        setElement.apply(this, _.tail(arguments, 2));
-  
-        // 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.
-        _.each(behaviors, function(b) {
-          b.$el = this.$el;
-          b.el = this.el;
-        }, this);
-  
-        return this;
-      },
-  
-      destroy: function(destroy, behaviors) {
-        var args = _.tail(arguments, 2);
-        destroy.apply(this, args);
-  
-        // Call destroy on each behavior after
-        // destroying the view.
-        // This unbinds event listeners
-        // that behaviors have registerd for.
-        _.invoke(behaviors, 'destroy', args);
-        return this;
-      },
-  
-      bindUIElements: function(bindUIElements, behaviors) {
-        bindUIElements.apply(this);
-        _.invoke(behaviors, bindUIElements);
-      },
-  
-      unbindUIElements: function(unbindUIElements, behaviors) {
-        unbindUIElements.apply(this);
-        _.invoke(behaviors, unbindUIElements);
-      },
-  
-      triggerMethod: function(triggerMethod, behaviors) {
-        var args = _.tail(arguments, 2);
-        triggerMethod.apply(this, args);
-  
-        _.each(behaviors, function(b) {
-          triggerMethod.apply(b, args);
-        });
-      },
-  
-      delegateEvents: function(delegateEvents, behaviors) {
-        var args = _.tail(arguments, 2);
-        delegateEvents.apply(this, args);
-  
-        _.each(behaviors, function(b) {
-          Marionette.bindEntityEvents(b, this.model, Marionette.getOption(b, 'modelEvents'));
-          Marionette.bindEntityEvents(b, this.collection, Marionette.getOption(b, 'collectionEvents'));
-        }, this);
-  
-        return this;
+      behaviorTriggers: function(behaviorTriggers, behaviors) {
+        var triggerBuilder = new BehaviorTriggersBuilder(this, behaviors);
+        return triggerBuilder.buildBehaviorTriggers();
       },
-  
-      undelegateEvents: function(undelegateEvents, behaviors) {
-        var args = _.tail(arguments, 2);
-        undelegateEvents.apply(this, args);
-  
-        _.each(behaviors, function(b) {
-          Marionette.unbindEntityEvents(b, this.model, Marionette.getOption(b, 'modelEvents'));
-          Marionette.unbindEntityEvents(b, this.collection, Marionette.getOption(b, 'collectionEvents'));
-        }, this);
-  
-        return this;
-      },
-  
+
       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.
@@ -2865,11 +2963,12 @@
       // }
       // ```
       behaviorsLookup: function() {
-        throw new Error('You must define where your behaviors are stored.' +
-          'See https://github.com/marionettejs/backbone.marionette' +
-          '/blob/master/docs/marionette.behaviors.md#behaviorslookup');
+        throw new Marionette.Error({
+          message: 'You must define where your behaviors are stored.',
+          url: 'marionette.behaviors.html#behaviorslookup'
+        });
       },
-  
+
       // Takes care of getting the behavior class
       // given options and a key.
       // If a user passes in options.behaviorClass
@@ -2879,24 +2978,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.
@@ -2908,15 +3007,53 @@
         });
       }
     });
-  
+
+    // Class to build handlers for `triggers` on behaviors
+    // for views
+    function BehaviorTriggersBuilder(view, behaviors) {
+      this._view      = view;
+      this._viewUI    = _.result(view, 'ui');
+      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) {
+        // Unique identifier for the `this._triggers` hash
+        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
@@ -2931,102 +3068,108 @@
   // 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) {
-        throwError('Method "' + methodName + '" was not found on the controller');
+        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`
   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() {},
+
     // 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
@@ -3035,7 +3178,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"})
@@ -3043,99 +3186,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';
@@ -3144,23 +3287,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) {
@@ -3169,52 +3312,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;
-  
-    // By default modules start with their parents.
-    this.startWithParent = true;
-  
+
     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
@@ -3222,51 +3365,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,
@@ -3276,10 +3419,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.
@@ -3287,52 +3430,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);
@@ -3340,10 +3483,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.
@@ -3352,71 +3495,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);
@@ -3424,7 +3567,7 @@
       });
     }
   });
-  
+
 
   return Marionette;
 }));