js_stack 1.10.0 → 1.11.1

data/vendor/assets/javascripts/js_stack/base/marionette/{2.4.1.js → 2.4.3.js}

@@ -1,6 +1,6 @@
 // MarionetteJS (Backbone.Marionette)
 // ----------------------------------
-// v2.4.1
+// v2.4.3
 //
 // Copyright (c)2015 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
@@ -38,7 +38,7 @@
   /* istanbul ignore next */
   // Backbone.BabySitter
   // -------------------
-  // v0.1.6
+  // v0.1.10
   //
   // Copyright (c)2015 Derick Bailey, Muted Solutions, LLC.
   // Distributed under MIT license
@@ -167,7 +167,7 @@
       // return the public API
       return Container;
     }(Backbone, _);
-    Backbone.ChildViewContainer.VERSION = "0.1.6";
+    Backbone.ChildViewContainer.VERSION = "0.1.10";
     Backbone.ChildViewContainer.noConflict = function() {
       Backbone.ChildViewContainer = previousChildViewContainer;
       return this;
@@ -178,9 +178,9 @@
   /* istanbul ignore next */
   // Backbone.Wreqr (Backbone.Marionette)
   // ----------------------------------
-  // v1.3.1
+  // v1.3.5
   //
-  // Copyright (c)2014 Derick Bailey, Muted Solutions, LLC.
+  // Copyright (c)2015 Derick Bailey, Muted Solutions, LLC.
   // Distributed under MIT license
   //
   // http://github.com/marionettejs/backbone.wreqr
@@ -188,7 +188,7 @@
     "use strict";
     var previousWreqr = Backbone.Wreqr;
     var Wreqr = Backbone.Wreqr = {};
-    Backbone.Wreqr.VERSION = "1.3.1";
+    Backbone.Wreqr.VERSION = "1.3.5";
     Backbone.Wreqr.noConflict = function() {
       Backbone.Wreqr = previousWreqr;
       return this;
@@ -245,8 +245,7 @@
             return;
           }
           return function() {
-            var args = Array.prototype.slice.apply(arguments);
-            return config.callback.apply(config.context, args);
+            return config.callback.apply(config.context, arguments);
           };
         },
         // Remove a handler for the specified name
@@ -312,7 +311,7 @@
     //
     // A simple command pattern implementation. Register a command
     // handler and execute it.
-    Wreqr.Commands = function(Wreqr) {
+    Wreqr.Commands = function(Wreqr, _) {
       "use strict";
       return Wreqr.Handlers.extend({
         // default storage type
@@ -321,13 +320,12 @@
           this.options = options || {};
           this._initializeStorage(this.options);
           this.on("handler:add", this._executeCommands, this);
-          var args = Array.prototype.slice.call(arguments);
-          Wreqr.Handlers.prototype.constructor.apply(this, args);
+          Wreqr.Handlers.prototype.constructor.apply(this, arguments);
         },
         // Execute a named command with the supplied args
-        execute: function(name, args) {
+        execute: function(name) {
           name = arguments[0];
-          args = Array.prototype.slice.call(arguments, 1);
+          var args = _.rest(arguments);
           if (this.hasHandler(name)) {
             this.getHandler(name).apply(this, args);
           } else {
@@ -356,24 +354,22 @@
           this.storage = storage;
         }
       });
-    }(Wreqr);
+    }(Wreqr, _);
     // Wreqr.RequestResponse
     // ---------------------
     //
     // A simple request/response implementation. Register a
     // request handler, and return a response from it
-    Wreqr.RequestResponse = function(Wreqr) {
+    Wreqr.RequestResponse = function(Wreqr, _) {
       "use strict";
       return Wreqr.Handlers.extend({
-        request: function() {
-          var name = arguments[0];
-          var args = Array.prototype.slice.call(arguments, 1);
+        request: function(name) {
           if (this.hasHandler(name)) {
-            return this.getHandler(name).apply(this, args);
+            return this.getHandler(name).apply(this, _.rest(arguments));
           }
         }
       });
-    }(Wreqr);
+    }(Wreqr, _);
     // Event Aggregator
     // ----------------
     // A pub-sub object that can be used to decouple various parts
@@ -440,7 +436,7 @@
     // --------------
     //
     // An object that lets you communicate with many channels.
-    Wreqr.radio = function(Wreqr) {
+    Wreqr.radio = function(Wreqr, _) {
       "use strict";
       var Radio = function() {
         this._channels = {};
@@ -480,12 +476,11 @@
       var proxyMethod = function(radio, system, method) {
         return function(channelName) {
           var messageSystem = radio._getChannel(channelName)[system];
-          var args = Array.prototype.slice.call(arguments, 1);
-          return messageSystem[method].apply(messageSystem, args);
+          return messageSystem[method].apply(messageSystem, _.rest(arguments));
         };
       };
       return new Radio();
-    }(Wreqr);
+    }(Wreqr, _);
     return Backbone.Wreqr;
   })(Backbone, _);
 
@@ -494,7 +489,7 @@
 
   var Marionette = Backbone.Marionette = {};
 
-  Marionette.VERSION = '2.4.1';
+  Marionette.VERSION = '2.4.3';
 
   Marionette.noConflict = function() {
     root.Marionette = previousMarionette;
@@ -734,6 +729,8 @@
   // re-rendered.
 
   Marionette.MonitorDOMRefresh = function(view) {
+    if (view._isDomRefreshMonitored) { return; }
+    view._isDomRefreshMonitored = true;
 
     // track when the view has been shown in the DOM,
     // using a Marionette.Region (or by other means of triggering "show")
@@ -751,9 +748,7 @@
     // Trigger the "dom:refresh" event and corresponding "onDomRefresh" method
     function triggerDOMRefresh() {
       if (view._isShown && view._isRendered && Marionette.isNodeAttached(view.el)) {
-        if (_.isFunction(view.triggerMethod)) {
-          view.triggerMethod('dom:refresh');
-        }
+        Marionette.triggerMethodOn(view, 'dom:refresh', view);
       }
     }
 
@@ -1094,6 +1089,7 @@
       }
 
       this._ensureViewIsIntact(view);
+      Marionette.MonitorDOMRefresh(view);
 
       var showOptions     = options || {};
       var isDifferentView = view !== this.currentView;
@@ -1138,7 +1134,8 @@
         // to the currentView since once a view has been destroyed
         // we can not reuse it.
         view.once('destroy', this.empty, this);
-        view.render();
+
+        this._renderView(view);
 
         view._parent = this;
 
@@ -1161,10 +1158,12 @@
         // as it's a potentially-slow method
         var displayedViews = [];
 
-        var triggerBeforeAttach = showOptions.triggerBeforeAttach || this.triggerBeforeAttach;
-        var triggerAttach = showOptions.triggerAttach || this.triggerAttach;
+        var attachOptions = _.extend({
+          triggerBeforeAttach: this.triggerBeforeAttach,
+          triggerAttach: this.triggerAttach
+        }, showOptions);
 
-        if (attachedRegion && triggerBeforeAttach) {
+        if (attachedRegion && attachOptions.triggerBeforeAttach) {
           displayedViews = this._displayedViews(view);
           this._triggerAttach(displayedViews, 'before:');
         }
@@ -1172,7 +1171,7 @@
         this.attachHtml(view);
         this.currentView = view;
 
-        if (attachedRegion && triggerAttach) {
+        if (attachedRegion && attachOptions.triggerAttach) {
           displayedViews = this._displayedViews(view);
           this._triggerAttach(displayedViews);
         }
@@ -1204,6 +1203,16 @@
       return _.union([view], _.result(view, '_getNestedViews') || []);
     },
 
+    _renderView: function(view) {
+      if (!view.supportsRenderLifecycle) {
+        Marionette.triggerMethodOn(view, 'before:render', view);
+      }
+      view.render();
+      if (!view.supportsRenderLifecycle) {
+        Marionette.triggerMethodOn(view, 'render', view);
+      }
+    },
+
     _ensureElement: function() {
       if (!_.isObject(this.el)) {
         this.$el = this.getEl(this.el);
@@ -1256,7 +1265,8 @@
     empty: function(options) {
       var view = this.currentView;
 
-      var preventDestroy = Marionette._getValue(options, 'preventDestroy', this);
+      var emptyOptions = options || {};
+      var preventDestroy  = !!emptyOptions.preventDestroy;
       // If there is no view in the region
       // we should not remove anything
       if (!view) { return; }
@@ -1282,16 +1292,23 @@
     // on the view (if showing a raw Backbone view or a Marionette View)
     _destroyView: function() {
       var view = this.currentView;
+      if (view.isDestroyed) { return; }
 
-      if (view.destroy && !view.isDestroyed) {
+      if (!view.supportsDestroyLifecycle) {
+        Marionette.triggerMethodOn(view, 'before:destroy', view);
+      }
+      if (view.destroy) {
         view.destroy();
-      } else if (view.remove) {
+      } else {
         view.remove();
 
         // appending isDestroyed to raw Backbone View allows regions
         // to throw a ViewDestroyedError for this view
         view.isDestroyed = true;
       }
+      if (!view.supportsDestroyLifecycle) {
+        Marionette.triggerMethodOn(view, 'destroy', view);
+      }
     },
 
     // Attach an existing view to the region. This
@@ -1299,6 +1316,10 @@
     // and will not replace the current HTML for the `el`
     // of the region.
     attachView: function(view) {
+      if (this.currentView) {
+        delete this.currentView._parent;
+      }
+      view._parent = this;
       this.currentView = view;
       return this;
     },
@@ -1590,16 +1611,15 @@
     // using a template-loader plugin as described here:
     // https://github.com/marionettejs/backbone.marionette/wiki/Using-marionette-with-requirejs
     loadTemplate: function(templateId, options) {
-      var template = Backbone.$(templateId).html();
+      var $template = Backbone.$(templateId);
 
-      if (!template || template.length === 0) {
+      if (!$template.length) {
         throw new Marionette.Error({
           name: 'NoTemplateError',
           message: 'Could not find template: "' + templateId + '"'
         });
       }
-
-      return template;
+      return $template.html();
     },
 
     // Pre-compile the template before caching it. Override
@@ -1644,9 +1664,11 @@
   // The core view class that other Marionette views extend from.
   Marionette.View = Backbone.View.extend({
     isDestroyed: false,
+    supportsRenderLifecycle: true,
+    supportsDestroyLifecycle: true,
 
     constructor: function(options) {
-      _.bindAll(this, 'render');
+      this.render = _.bind(this.render, this);
 
       options = Marionette._getValue(options, this);
 
@@ -1866,14 +1888,13 @@
     // 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 : {}), {
+      var options = _.defaults({}, triggerDef, {
         preventDefault: true,
         stopPropagation: true
       });
 
-      var eventName = hasOptions ? options.event : triggerDef;
+      var eventName = _.isObject(triggerDef) ? options.event : triggerDef;
 
       return function(e) {
         if (e) {
@@ -1936,15 +1957,16 @@
       // invoke triggerMethod on parent view
       var eventPrefix = Marionette.getOption(layoutView, 'childViewEventPrefix');
       var prefixedEventName = eventPrefix + ':' + eventName;
+      var callArgs = [this].concat(args);
 
-      Marionette._triggerMethod(layoutView, [prefixedEventName, this].concat(args));
+      Marionette._triggerMethod(layoutView, prefixedEventName, callArgs);
 
       // call the parent view's childEvents handler
       var childEvents = Marionette.getOption(layoutView, 'childEvents');
       var normalizedChildEvents = layoutView.normalizeMethods(childEvents);
 
-      if (!!normalizedChildEvents && _.isFunction(normalizedChildEvents[eventName])) {
-        normalizedChildEvents[eventName].apply(layoutView, [this].concat(args));
+      if (normalizedChildEvents && _.isFunction(normalizedChildEvents[eventName])) {
+        normalizedChildEvents[eventName].apply(layoutView, callArgs);
       }
     },
 
@@ -2117,7 +2139,7 @@
     }
   });
 
-  /* jshint maxstatements: 14 */
+  /* jshint maxstatements: 20, maxcomplexity: 7 */
 
   // Collection View
   // ---------------
@@ -2141,14 +2163,17 @@
     // option to pass `{comparator: compFunction()}` to allow the `CollectionView`
     // to use a custom sort order for the collection.
     constructor: function(options) {
-
       this.once('render', this._initialEvents);
       this._initChildViewStorage();
 
       Marionette.View.apply(this, arguments);
 
-      this.on('show', this._onShowCalled);
-
+      this.on({
+        'before:show':   this._onBeforeShowCalled,
+        'show':          this._onShowCalled,
+        'before:attach': this._onBeforeAttachCalled,
+        'attach':        this._onAttachCalled
+      });
       this.initRenderBuffer();
     },
 
@@ -2165,33 +2190,38 @@
     },
 
     endBuffering: function() {
-      this.isBuffering = false;
-      this._triggerBeforeShowBufferedChildren();
-
-      this.attachBuffer(this);
+      // Only trigger attach if already shown and attached, otherwise Region#show() handles this.
+      var canTriggerAttach = this._isShown && Marionette.isNodeAttached(this.el);
+      var nestedViews;
 
-      this._triggerShowBufferedChildren();
-      this.initRenderBuffer();
-    },
+      this.isBuffering = false;
 
-    _triggerBeforeShowBufferedChildren: function() {
       if (this._isShown) {
-        _.each(this._bufferedChildren, _.partial(this._triggerMethodOnChild, 'before:show'));
+        this._triggerMethodMany(this._bufferedChildren, this, 'before:show');
+      }
+      if (canTriggerAttach && this._triggerBeforeAttach) {
+        nestedViews = this._getNestedViews();
+        this._triggerMethodMany(nestedViews, this, 'before:attach');
       }
-    },
 
-    _triggerShowBufferedChildren: function() {
-      if (this._isShown) {
-        _.each(this._bufferedChildren, _.partial(this._triggerMethodOnChild, 'show'));
+      this.attachBuffer(this, this._createBuffer());
 
-        this._bufferedChildren = [];
+      if (canTriggerAttach && this._triggerAttach) {
+        nestedViews = this._getNestedViews();
+        this._triggerMethodMany(nestedViews, this, 'attach');
       }
+      if (this._isShown) {
+        this._triggerMethodMany(this._bufferedChildren, this, 'show');
+      }
+      this.initRenderBuffer();
     },
 
-    // Internal method for _.each loops to call `Marionette.triggerMethodOn` on
-    // a child view
-    _triggerMethodOnChild: function(event, childView) {
-      Marionette.triggerMethodOn(childView, event);
+    _triggerMethodMany: function(targets, source, eventName) {
+      var args = _.drop(arguments, 3);
+
+      _.each(targets, function(target) {
+        Marionette.triggerMethodOn.apply(target, [target, eventName, target, source].concat(args));
+      });
     },
 
     // Configured the initial events that the collection view
@@ -2210,11 +2240,12 @@
 
     // Handle a child added to the collection
     _onCollectionAdd: function(child, collection, opts) {
-      var index;
-      if (opts.at !== undefined) {
-        index = opts.at;
-      } else {
-        index = _.indexOf(this._filteredSortedModels(), child);
+      // `index` is present when adding with `at` since BB 1.2; indexOf fallback for < 1.2
+      var index = opts.at !== undefined && (opts.index || collection.indexOf(child));
+
+      // When filtered or when there is no initial index, calculate index.
+      if (this.getOption('filter') || index === false) {
+        index = _.indexOf(this._filteredSortedModels(index), child);
       }
 
       if (this._shouldAddChild(child, index)) {
@@ -2231,8 +2262,29 @@
       this.checkEmpty();
     },
 
+    _onBeforeShowCalled: function() {
+      // Reset attach event flags at the top of the Region#show() event lifecycle; if the Region's
+      // show() options permit onBeforeAttach/onAttach events, these flags will be set true again.
+      this._triggerBeforeAttach = this._triggerAttach = false;
+      this.children.each(function(childView) {
+        Marionette.triggerMethodOn(childView, 'before:show', childView);
+      });
+    },
+
     _onShowCalled: function() {
-      this.children.each(_.partial(this._triggerMethodOnChild, 'show'));
+      this.children.each(function(childView) {
+        Marionette.triggerMethodOn(childView, 'show', childView);
+      });
+    },
+
+    // If during Region#show() onBeforeAttach was fired, continue firing it for child views
+    _onBeforeAttachCalled: function() {
+      this._triggerBeforeAttach = true;
+    },
+
+    // If during Region#show() onAttach was fired, continue firing it for child views
+    _onAttachCalled: function() {
+      this._triggerAttach = true;
     },
 
     // Render children views. Override this method to
@@ -2265,8 +2317,10 @@
         this.render();
       } else {
         // get the DOM nodes in the same order as the models
-        var els = _.map(models, function(model) {
-          return children.findByModel(model).el;
+        var els = _.map(models, function(model, index) {
+          var view = children.findByModel(model);
+          view._index = index;
+          return view.el;
         });
 
         // since append moves elements that are already in the DOM,
@@ -2319,7 +2373,7 @@
     // process
     _renderChildren: function() {
       this.destroyEmptyView();
-      this.destroyChildren();
+      this.destroyChildren({checkEmpty: false});
 
       if (this.isEmpty(this.collection)) {
         this.showEmptyView();
@@ -2331,7 +2385,7 @@
         this.triggerMethod('render:collection', this);
 
         // If we have shown children and none have passed the filter, show the empty view
-        if (this.children.isEmpty()) {
+        if (this.children.isEmpty() && this.getOption('filter')) {
           this.showEmptyView();
         }
       }
@@ -2350,18 +2404,22 @@
     },
 
     // Allow the collection to be sorted by a custom view comparator
-    _filteredSortedModels: function() {
-      var models;
+    _filteredSortedModels: function(addedAt) {
       var viewComparator = this.getViewComparator();
+      var models = this.collection.models;
+      addedAt = Math.min(Math.max(addedAt, 0), models.length - 1);
 
       if (viewComparator) {
-        if (_.isString(viewComparator) || viewComparator.length === 1) {
-          models = this.collection.sortBy(viewComparator, this);
-        } else {
-          models = _.clone(this.collection.models).sort(_.bind(viewComparator, this));
+        var addedModel;
+        // Preserve `at` location, even for a sorted view
+        if (addedAt) {
+          addedModel = models[addedAt];
+          models = models.slice(0, addedAt).concat(models.slice(addedAt + 1));
+        }
+        models = this._sortModelsBy(models, viewComparator);
+        if (addedModel) {
+          models.splice(addedAt, 0, addedModel);
         }
-      } else {
-        models = this.collection.models;
       }
 
       // Filter after sorting in case the filter uses the index
@@ -2374,6 +2432,18 @@
       return models;
     },
 
+    _sortModelsBy: function(models, comparator) {
+      if (typeof comparator === 'string') {
+        return _.sortBy(models, function(model) {
+          return model.get(comparator);
+        }, this);
+      } else if (comparator.length === 1) {
+        return _.sortBy(models, comparator, this);
+      } else {
+        return models.sort(_.bind(comparator, this));
+      }
+    },
+
     // Internal method to show an empty view in place of
     // a collection of child views, when the collection is empty
     showEmptyView: function() {
@@ -2413,6 +2483,10 @@
     // but "add:child" events are not fired, and the event from
     // emptyView are not forwarded
     addEmptyView: function(child, EmptyView) {
+      // Only trigger attach if already shown, attached, and not buffering, otherwise endBuffer() or
+      // Region#show() handles this.
+      var canTriggerAttach = this._isShown && !this.isBuffering && Marionette.isNodeAttached(this.el);
+      var nestedViews;
 
       // get the emptyViewOptions, falling back to childViewOptions
       var emptyViewOptions = this.getOption('emptyViewOptions') ||
@@ -2430,23 +2504,32 @@
       // Proxy emptyView events
       this.proxyChildEvents(view);
 
-      // trigger the 'before:show' event on `view` if the collection view
-      // has already been shown
-      if (this._isShown) {
-        Marionette.triggerMethodOn(view, 'before:show');
-      }
+      view.once('render', function() {
+        // trigger the 'before:show' event on `view` if the collection view has already been shown
+        if (this._isShown) {
+          Marionette.triggerMethodOn(view, 'before:show', view);
+        }
 
-      // Store the `emptyView` like a `childView` so we can properly
-      // remove and/or close it later
-      this.children.add(view);
+        // Trigger `before:attach` following `render` to avoid adding logic and event triggers
+        // to public method `renderChildView()`.
+        if (canTriggerAttach && this._triggerBeforeAttach) {
+          nestedViews = this._getViewAndNested(view);
+          this._triggerMethodMany(nestedViews, this, 'before:attach');
+        }
+      }, this);
 
-      // Render it and show it
+      // Store the `emptyView` like a `childView` so we can properly remove and/or close it later
+      this.children.add(view);
       this.renderChildView(view, this._emptyViewIndex);
 
-      // call the 'show' method if the collection view
-      // has already been shown
+      // Trigger `attach`
+      if (canTriggerAttach && this._triggerAttach) {
+        nestedViews = this._getViewAndNested(view);
+        this._triggerMethodMany(nestedViews, this, 'attach');
+      }
+      // call the 'show' method if the collection view has already been shown
       if (this._isShown) {
-        Marionette.triggerMethodOn(view, 'show');
+        Marionette.triggerMethodOn(view, 'show', view);
       }
     },
 
@@ -2482,7 +2565,9 @@
       // increment indices of views after this one
       this._updateIndices(view, true, index);
 
+      this.triggerMethod('before:add:child', view);
       this._addChildView(view, index);
+      this.triggerMethod('add:child', view);
 
       view._parent = this;
 
@@ -2512,32 +2597,52 @@
     // Internal Method. Add the view to children and render it at
     // the given index.
     _addChildView: function(view, index) {
+      // Only trigger attach if already shown, attached, and not buffering, otherwise endBuffer() or
+      // Region#show() handles this.
+      var canTriggerAttach = this._isShown && !this.isBuffering && Marionette.isNodeAttached(this.el);
+      var nestedViews;
+
       // set up the child view event forwarding
       this.proxyChildEvents(view);
 
-      this.triggerMethod('before:add:child', view);
+      view.once('render', function() {
+        // trigger the 'before:show' event on `view` if the collection view has already been shown
+        if (this._isShown && !this.isBuffering) {
+          Marionette.triggerMethodOn(view, 'before:show', view);
+        }
 
-      // trigger the 'before:show' event on `view` if the collection view
-      // has already been shown
-      if (this._isShown && !this.isBuffering) {
-        Marionette.triggerMethodOn(view, 'before:show');
-      }
+        // Trigger `before:attach` following `render` to avoid adding logic and event triggers
+        // to public method `renderChildView()`.
+        if (canTriggerAttach && this._triggerBeforeAttach) {
+          nestedViews = this._getViewAndNested(view);
+          this._triggerMethodMany(nestedViews, this, 'before:attach');
+        }
+      }, this);
 
-      // Store the child view itself so we can properly
-      // remove and/or destroy it later
+      // Store the child view itself so we can properly remove and/or destroy it later
       this.children.add(view);
       this.renderChildView(view, index);
 
+      // Trigger `attach`
+      if (canTriggerAttach && this._triggerAttach) {
+        nestedViews = this._getViewAndNested(view);
+        this._triggerMethodMany(nestedViews, this, 'attach');
+      }
+      // Trigger `show`
       if (this._isShown && !this.isBuffering) {
-        Marionette.triggerMethodOn(view, 'show');
+        Marionette.triggerMethodOn(view, 'show', view);
       }
-
-      this.triggerMethod('add:child', view);
     },
 
     // render the child view
     renderChildView: function(view, index) {
+      if (!view.supportsRenderLifecycle) {
+        Marionette.triggerMethodOn(view, 'before:render', view);
+      }
       view.render();
+      if (!view.supportsRenderLifecycle) {
+        Marionette.triggerMethodOn(view, 'render', view);
+      }
       this.attachHtml(this, view, index);
       return view;
     },
@@ -2545,7 +2650,9 @@
     // Build a `childView` for a model in the collection.
     buildChildView: function(child, ChildViewClass, childViewOptions) {
       var options = _.extend({model: child}, childViewOptions);
-      return new ChildViewClass(options);
+      var childView = new ChildViewClass(options);
+      Marionette.MonitorDOMRefresh(childView);
+      return childView;
     },
 
     // Remove the child view and destroy it.
@@ -2553,25 +2660,30 @@
     // later views in the collection in order to keep
     // the children in sync with the collection.
     removeChildView: function(view) {
+      if (!view) { return view; }
 
-      if (view) {
-        this.triggerMethod('before:remove:child', 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();
-        }
+      if (!view.supportsDestroyLifecycle) {
+        Marionette.triggerMethodOn(view, 'before:destroy', view);
+      }
+      // call 'destroy' or 'remove', depending on which is found
+      if (view.destroy) {
+        view.destroy();
+      } else {
+        view.remove();
+      }
+      if (!view.supportsDestroyLifecycle) {
+        Marionette.triggerMethodOn(view, 'destroy', view);
+      }
 
-        delete view._parent;
-        this.stopListening(view);
-        this.children.remove(view);
-        this.triggerMethod('remove:child', view);
+      delete view._parent;
+      this.stopListening(view);
+      this.children.remove(view);
+      this.triggerMethod('remove:child', view);
 
-        // decrement the index of views after this one
-        this._updateIndices(view, false);
-      }
+      // decrement the index of views after this one
+      this._updateIndices(view, false);
 
       return view;
     },
@@ -2589,14 +2701,14 @@
     },
 
     // You might need to override this if you've overridden attachHtml
-    attachBuffer: function(collectionView) {
-      collectionView.$el.append(this._createBuffer(collectionView));
+    attachBuffer: function(collectionView, buffer) {
+      collectionView.$el.append(buffer);
     },
 
     // Create a fragment buffer from the currently buffered children
-    _createBuffer: function(collectionView) {
+    _createBuffer: function() {
       var elBuffer = document.createDocumentFragment();
-      _.each(collectionView._bufferedChildren, function(b) {
+      _.each(this._bufferedChildren, function(b) {
         elBuffer.appendChild(b.el);
       });
       return elBuffer;
@@ -2657,7 +2769,7 @@
       if (this.isDestroyed) { return this; }
 
       this.triggerMethod('before:destroy:collection');
-      this.destroyChildren();
+      this.destroyChildren({checkEmpty: false});
       this.triggerMethod('destroy:collection');
 
       return Marionette.View.prototype.destroy.apply(this, arguments);
@@ -2665,10 +2777,20 @@
 
     // Destroy the child views that this collection view
     // is holding on to, if any
-    destroyChildren: function() {
+    destroyChildren: function(options) {
+      var destroyOptions = options || {};
+      var shouldCheckEmpty = true;
       var childViews = this.children.map(_.identity);
+
+      if (!_.isUndefined(destroyOptions.checkEmpty)) {
+        shouldCheckEmpty = destroyOptions.checkEmpty;
+      }
+
       this.children.each(this.removeChildView, this);
-      this.checkEmpty();
+
+      if (shouldCheckEmpty) {
+        this.checkEmpty();
+      }
       return childViews;
     },
 
@@ -2712,6 +2834,11 @@
       return _.values(this.children._views);
     },
 
+    _getViewAndNested: function(view) {
+      // This will not fail on Backbone.View which does not have #_getNestedViews.
+      return [view].concat(_.result(view, '_getNestedViews') || []);
+    },
+
     getViewComparator: function() {
       return this.getOption('viewComparator');
     }
@@ -2840,9 +2967,9 @@
     },
 
     // You might need to override this if you've overridden attachHtml
-    attachBuffer: function(compositeView) {
+    attachBuffer: function(compositeView, buffer) {
       var $container = this.getChildViewContainer(compositeView);
-      $container.append(this._createBuffer(compositeView));
+      $container.append(buffer);
     },
 
     // Internal method. Append a view to the end of the $el.
@@ -2864,7 +2991,7 @@
     // Internal method to ensure an `$childViewContainer` exists, for the
     // `attachHtml` method to use.
     getChildViewContainer: function(containerView, childView) {
-      if ('$childViewContainer' in containerView) {
+      if (!!containerView.$childViewContainer) {
         return containerView.$childViewContainer;
       }
 
@@ -2898,7 +3025,7 @@
     // Internal method to reset the `$childViewContainer` on render
     resetChildViewContainer: function() {
       if (this.$childViewContainer) {
-        delete this.$childViewContainer;
+        this.$childViewContainer = undefined;
       }
     }
   });
@@ -3408,7 +3535,7 @@
       this.submodules = {};
       _.extend(this, options);
       this._initChannel();
-      Marionette.Object.call(this, options);
+      Marionette.Object.apply(this, arguments);
     },
 
     // Command execution, facilitated by Backbone.Wreqr.Commands