marionette-rails 1.0.0.beta6 → 1.0.0.rc1

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

@@ -1,5 +1,5 @@
 /*!
- * Backbone.Marionette, v1.0.0-beta6
+ * Backbone.Marionette, v1.0.0-rc1
  * Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
  * Distributed under MIT license
  * http://github.com/marionettejs/backbone.marionette
@@ -12,7 +12,7 @@
  * Includes EventBinder
  * https://github.com/marionettejs/backbone.eventbinder/
  */
-// Backbone.BabySitter, v0.0.3
+// Backbone.BabySitter, v0.0.4
 // Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
 // http://github.com/marionettejs/backbone.babysitter
@@ -27,12 +27,14 @@ Backbone.ChildViewContainer = (function(Backbone, _){
   // Container Constructor
   // ---------------------
 
-  var Container = function(options){
+  var Container = function(initialViews){
     this._views = {};
     this._indexByModel = {};
     this._indexByCollection = {};
     this._indexByCustom = {};
     this._updateLength();
+
+    this._addInitialViews(initialViews);
   };
 
   // Container Methods
@@ -151,18 +153,35 @@ Backbone.ChildViewContainer = (function(Backbone, _){
     // time, like `function.apply`.
     apply: function(method, args){
       var view;
+
+      // fix for IE < 9
+      args = args || [];
+
       _.each(this._views, function(view, key){
         if (_.isFunction(view[method])){
           view[method].apply(view, args);
         }
       });
+
     },
 
     // Update the `.length` attribute on this container
     _updateLength: function(){
       this.length = _.size(this._views);
-    }
+    },
+
+    // set up an initial list of views
+    _addInitialViews: function(views){
+      if (!views){ return; }
+
+      var view, i,
+          length = views.length;
 
+      for (i=0; i<length; i++){
+        view = views[i];
+        this.add(view);
+      }
+    }
   });
 
   // Borrowing this code from Backbone.Collection:
@@ -173,7 +192,7 @@ Backbone.ChildViewContainer = (function(Backbone, _){
   var methods = ['forEach', 'each', 'map', 'find', 'detect', 'filter', 
     'select', 'reject', 'every', 'all', 'some', 'any', 'include', 
     'contains', 'invoke', 'toArray', 'first', 'initial', 'rest', 
-    'last', 'without', 'isEmpty'];
+    'last', 'without', 'isEmpty', 'pluck'];
 
   _.each(methods, function(method) {
     Container.prototype[method] = function() {
@@ -187,7 +206,7 @@ Backbone.ChildViewContainer = (function(Backbone, _){
   return Container;
 })(Backbone, _);
 
-// Backbone.EventBinder, v0.1.0
+// Backbone.EventBinder, v1.0.2
 // Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
 // http://github.com/marionettejs/backbone.eventbinder
@@ -257,6 +276,10 @@ Backbone.EventBinder = (function(Backbone, _){
   // Use whatever best logic necessary to determine the type
   // of the supplied object
   function getHandlerForObject(obj) {
+    if (_.isUndefined(obj) || _.isNull(obj)) {
+      throw new Error("Can't bindTo undefined");
+    }
+
     if (obj.jquery) { return handlerMap.jquery; }
 
     return handlerMap["default"];
@@ -280,7 +303,8 @@ Backbone.EventBinder = (function(Backbone, _){
       var obj = arguments[0];
       var handlers = getHandlerForObject(obj);
 
-      var binding = handlers.bindTo.apply(this,arguments);
+      var args = Array.prototype.slice.apply(arguments);
+      var binding = handlers.bindTo.apply(this, args);
 
       this._eventBindings.push(binding);
 
@@ -290,7 +314,9 @@ Backbone.EventBinder = (function(Backbone, _){
     // Unbind from a single binding object. Binding objects are
     // returned from the `bindTo` method call. 
     unbindFrom: function(binding) {
-      handlerMap[binding.type].unbindFrom.apply(this,arguments);
+      var args = Array.prototype.slice.apply(arguments);
+      handlerMap[binding.type].unbindFrom.apply(this, args);
+
       this._eventBindings = _.reject(this._eventBindings, function(bind){return bind === binding;});
     },
 
@@ -306,7 +332,7 @@ Backbone.EventBinder = (function(Backbone, _){
   return EventBinder;
 })(Backbone, _);
 
-// Backbone.Wreqr, v0.0.0
+// Backbone.Wreqr, v0.1.0
 // Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
 // http://github.com/marionettejs/backbone.wreqr
@@ -314,9 +340,16 @@ Backbone.Wreqr = (function(Backbone, Marionette, _){
   "option strict";
   var Wreqr = {};
 
+  // Handlers
+  // --------
+  // A registry of functions to call, given a name
+  
   Wreqr.Handlers = (function(Backbone, _){
     "option strict";
     
+    // Constructor
+    // -----------
+  
     var Handlers = function(){
       "use strict";
       this._handlers = {};
@@ -324,7 +357,13 @@ Backbone.Wreqr = (function(Backbone, Marionette, _){
   
     Handlers.extend = Backbone.Model.extend;
   
+    // Instance Members
+    // ----------------
+  
     _.extend(Handlers.prototype, {
+  
+      // Add a handler for the given name, with an
+      // optional context to run the handler within
       addHandler: function(name, handler, context){
         var config = {
           callback: handler,
@@ -334,6 +373,9 @@ Backbone.Wreqr = (function(Backbone, Marionette, _){
         this._handlers[name] = config;
       },
   
+      // Get the currently registered handler for
+      // the specified name. Throws an exception if
+      // no handler is found.
       getHandler: function(name){
         var config = this._handlers[name];
   
@@ -342,14 +384,17 @@ Backbone.Wreqr = (function(Backbone, Marionette, _){
         }
   
         return function(){
-          return config.callback.apply(config.context, arguments);
+          var args = Array.prototype.slice.apply(arguments);
+          return config.callback.apply(config.context, args);
         };
       },
   
+      // Remove a handler for the specified name
       removeHandler: function(name){
         delete this._handlers[name];
       },
   
+      // Remove all handlers from this registry
       removeAllHandlers: function(){
         this._handlers = {};
       }
@@ -367,8 +412,11 @@ Backbone.Wreqr = (function(Backbone, Marionette, _){
     "option strict";
   
     return Wreqr.Handlers.extend({
-      execute: function(name, args){
-        this.getHandler(name)(args);
+      execute: function(){
+        var name = arguments[0];
+        var args = Array.prototype.slice.call(arguments, 1);
+  
+        this.getHandler(name).apply(this, args);
       }
     });
   
@@ -383,8 +431,11 @@ Backbone.Wreqr = (function(Backbone, Marionette, _){
     "option strict";
   
     return Wreqr.Handlers.extend({
-      request: function(name, args){
-        return this.getHandler(name)(args);
+      request: function(){
+        var name = arguments[0];
+        var args = Array.prototype.slice.call(arguments, 1);
+  
+        return this.getHandler(name).apply(this, args);
       }
     });
   
@@ -513,7 +564,7 @@ Marionette.triggerMethod = function(){
     methodName += capLetter + segment.slice(1);
   }
 
-  this.trigger.apply(this, arguments);
+  this.trigger.apply(this, args);
 
   if (_.isFunction(this[methodName])){
     args.shift();
@@ -526,17 +577,7 @@ Marionette.triggerMethod = function(){
 // -----------
 // Import the event binder from it's new home
 // https://github.com/marionettejs/backbone.eventbinder
-Marionette.EventBinder = Backbone.EventBinder.extend({
-
-  augment: function(target){
-    var eventBinder = new Marionette.EventBinder();
-    target.eventBinder = eventBinder;
-    target.bindTo = _.bind(eventBinder.bindTo, eventBinder);
-    target.unbindFrom = _.bind(eventBinder.unbindFrom, eventBinder);
-    target.unbindAll = _.bind(eventBinder.unbindAll, eventBinder);
-  }
-  
-});
+Marionette.EventBinder = Backbone.EventBinder.extend();
 
 // Add the EventBinder methods to the view directly,
 // but keep them bound to the EventBinder instance so they work properly.
@@ -547,7 +588,15 @@ Marionette.EventBinder = Backbone.EventBinder.extend({
 Marionette.addEventBinder = function(target){
   var eventBinder = new Marionette.EventBinder();
   target.eventBinder = eventBinder;
-  target.bindTo = _.bind(eventBinder.bindTo, eventBinder);
+
+  target.bindTo = function(source, event, callback, context){
+    // check the context of the bindTo and set it to the object
+    // that is having the eventBinder attached to it, if no context
+    // has been specified in the .bindTo call
+    context = context || target;
+    eventBinder.bindTo(source, event, callback, context);
+  };
+
   target.unbindFrom = _.bind(eventBinder.unbindFrom, eventBinder);
   target.unbindAll = _.bind(eventBinder.unbindAll, eventBinder);
 };
@@ -563,11 +612,70 @@ Marionette.EventAggregator = Backbone.Wreqr.EventAggregator.extend({
 
   constructor: function(){
     Marionette.addEventBinder(this);
-    Backbone.Wreqr.EventAggregator.prototype.constructor.apply(this, arguments);
+
+    var args = Array.prototype.slice.apply(arguments);
+    Backbone.Wreqr.EventAggregator.prototype.constructor.apply(this, args);
   }
 
 });
 
+// Marionette.bindEntityEvents
+// ---------------------------
+//
+// This method is used to bind a backbone "entity" (collection/model) 
+// to methods on a target object. 
+//
+// The first paremter, `target`, must have a `bindTo` method from the
+// EventBinder object.
+//
+// The second parameter is the entity (Backbone.Model or Backbone.Collection)
+// to bind the events from.
+//
+// The third parameter is a hash of { "event:name": "eventHandler" }
+// configuration. Multiple handlers can be separated by a space. A
+// function can be supplied instead of a string handler name. 
+Marionette.bindEntityEvents = (function(){
+
+  // Bind the event to handlers specified as a string of
+  // handler names on the target object
+  function bindFromStrings(target, entity, evt, methods){
+    var methodNames = methods.split(/\s+/);
+
+    _.each(methodNames,function(methodName) {
+
+      var method = target[methodName];
+      if(!method) {
+        throw new Error("Method '"+ methodName +"' was configured as an event handler, but does not exist.");
+      }
+
+      target.bindTo(entity, evt, method, target);
+    });
+  }
+
+  // Bind the event to a supplied callback function
+  function bindToFunction(target, entity, evt, method){
+      target.bindTo(entity, evt, method, target);
+  }
+
+  // Export the bindEntityEvents method
+  return function(target, entity, bindings){
+    if (!entity || !bindings) { return; }
+
+    _.each(bindings, function(methods, evt){
+
+      // allow for a function as the handler, 
+      // or a list of event names as a string
+      if (_.isFunction(methods)){
+        bindToFunction(target, entity, evt, methods);
+      } else {
+        bindFromStrings(target, entity, evt, methods);
+      }
+
+    });
+  };
+})();
+
+  
 // Callbacks
 // ---------
 
@@ -653,11 +761,12 @@ _.extend(Marionette.TemplateCache, {
   // `clear("#t1", "#t2", "...")`
   clear: function(){
     var i;
-    var length = arguments.length;
+    var args = Array.prototype.slice.apply(arguments);
+    var length = args.length;
 
     if (length > 0){
       for(i=0; i<length; i++){
-        delete this.templateCaches[arguments[i]];
+        delete this.templateCaches[args[i]];
       }
     } else {
       this.templateCaches = {};
@@ -783,7 +892,8 @@ Marionette.Region = function(options){
   }
 
   if (this.initialize){
-    this.initialize.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    this.initialize.apply(this, args);
   }
 };
 
@@ -940,10 +1050,11 @@ Marionette.View = Backbone.View.extend({
     _.bindAll(this, "render");
     Marionette.addEventBinder(this);
 
-    Backbone.View.prototype.constructor.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    Backbone.View.prototype.constructor.apply(this, args);
 
-    this.bindBackboneEntityTo(this.model, this.modelEvents);
-    this.bindBackboneEntityTo(this.collection, this.collectionEvents);
+    Marionette.bindEntityEvents(this, this.model, Marionette.getOption(this, "modelEvents"));
+    Marionette.bindEntityEvents(this, this.collection, Marionette.getOption(this, "collectionEvents"));
 
     this.bindTo(this, "show", this.onShowCalled, this);
   },
@@ -1023,13 +1134,17 @@ Marionette.View = Backbone.View.extend({
   close: function(){
     if (this.isClosed) { return; }
 
-    this.triggerMethod("before:close");
+    var shouldClose = this.triggerMethod("before:close");
+    if (shouldClose === false){
+      return;
+    }
 
     this.remove();
-    this.unbindAll();
 
     this.triggerMethod("close");
     this.isClosed = true;
+
+    this.unbindAll();
   },
 
   // This method binds the elements specified in the "ui" hash inside the view's code with
@@ -1051,22 +1166,6 @@ Marionette.View = Backbone.View.extend({
       var selector = that.uiBindings[key];
       that.ui[key] = that.$(selector);
     });
-  },
-
-  // This method is used to bind a backbone "entity" (collection/model) to methods on the view.
-  bindBackboneEntityTo: function(entity, bindings){
-    if (!entity || !bindings) { return; }
-
-    var view = this;
-    _.each(bindings, function(methodName, evt){
-
-      var method = view[methodName];
-      if(!method) {
-        throw new Error("View method '"+ methodName +"' was configured as an event handler, but does not exist.");
-      }
-
-      view.bindTo(entity, evt, method, view);
-    });
   }
 });
 
@@ -1078,11 +1177,35 @@ Marionette.View = Backbone.View.extend({
 // and calling several methods on extended views, such as `onRender`.
 Marionette.ItemView =  Marionette.View.extend({
   constructor: function(){
-    Marionette.View.prototype.constructor.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    Marionette.View.prototype.constructor.apply(this, args);
 
     if (this.initialEvents){
       this.initialEvents();
     }
+
+    this.bindTo(this, "show", this._handleShow, this);
+    this.bindTo(this, "render", this._handleRender, this);
+  },
+
+  // internal event handler to track when the view has been rendered
+  _handleShow: function(){
+    this._isShown = true;
+    this.triggerDOMRefresh();
+  },
+
+  // internal event handler to track when the view has been shown in the DOM,
+  // using a Marionette.Region (or by other means of triggering "show")
+  _handleRender: function(){
+    this._isRendered = true;
+    this.triggerDOMRefresh();
+  },
+
+  // Trigger the "dom:refresh" event and corresponding "onDomRefresh" method
+  triggerDOMRefresh: function(){
+    if (this._isShown && this._isRendered){
+      this.triggerMethod("dom:refresh");
+    }
   },
 
   // Serialize the model or collection for the view. If a model is
@@ -1135,7 +1258,10 @@ Marionette.ItemView =  Marionette.View.extend({
     if (this.isClosed){ return; }
 
     this.triggerMethod('item:before:close');
-    Marionette.View.prototype.close.apply(this, arguments);
+
+    var args = Array.prototype.slice.apply(arguments);
+    Marionette.View.prototype.close.apply(this, args);
+
     this.triggerMethod('item:closed');
   }
 });
@@ -1146,16 +1272,19 @@ Marionette.ItemView =  Marionette.View.extend({
 // A view that iterates over a Backbone.Collection
 // and renders an individual ItemView for each model.
 Marionette.CollectionView = Marionette.View.extend({
+  // used as the prefix for item view events
+  // that are forwarded through the collectionview
+  itemViewEventPrefix: "itemview",
+
+  // constructor
   constructor: function(options){
     this.initChildViewStorage();
 
-    Marionette.View.prototype.constructor.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    Marionette.View.prototype.constructor.apply(this, args);
+
     this.initialEvents();
     this.onShowCallbacks = new Marionette.Callbacks();
-
-    if (options && options.itemViewOptions) {
-      this.itemViewOptions = options.itemViewOptions;
-    }
   },
 
   // Configured the initial events that the collection view
@@ -1279,45 +1408,54 @@ Marionette.CollectionView = Marionette.View.extend({
     var that = this;
 
     // get the itemViewOptions if any were specified
-    var itemViewOptions;
-    if (_.isFunction(this.itemViewOptions)){
-      itemViewOptions = this.itemViewOptions(item);
-    } else {
-      itemViewOptions = this.itemViewOptions;
+    var itemViewOptions = Marionette.getOption(this, "itemViewOptions");
+    if (_.isFunction(itemViewOptions)){
+      itemViewOptions = itemViewOptions.call(this, item);
     }
 
     // build the view 
     var view = this.buildItemView(item, ItemView, itemViewOptions);
+    
+    // set up the child view event forwarding
+    this.addChildViewEventForwarding(view);
 
     // Store the child view itself so we can properly
     // remove and/or close it later
     this.children.add(view);
+
+    // Render it and show it
+    var renderResult = this.renderItemView(view, index);
+
+    // let the world know this view was added
     this.triggerMethod("item:added", view);
 
+    // call onShow for child item views
+    if (view.onShow){
+      this.onShowCallbacks.add(view.onShow, view);
+    }
+
+    return renderResult;
+  },
+
+  // Set up the child view event forwarding. Uses an "itemview:"
+  // prefix in front of all forwarded events.
+  addChildViewEventForwarding: function(view){
+    var prefix = Marionette.getOption(this, "itemViewEventPrefix");
+
     // Forward all child item view events through the parent,
     // prepending "itemview:" to the event name
     var childBinding = this.bindTo(view, "all", function(){
       var args = slice.call(arguments);
-      args[0] = "itemview:" + args[0];
+      args[0] = prefix + ":" + args[0];
       args.splice(1, 0, view);
 
-      that.triggerMethod.apply(that, args);
-    });
+      this.triggerMethod.apply(this, args);
+    }, this);
 
     // Store all child event bindings so we can unbind
     // them when removing / closing the child view
-    this.childBindings = this.childBindings || {};
-    this.childBindings[view.cid] = childBinding;
-
-    // Render it and show it
-    var renderResult = this.renderItemView(view, index);
-
-    // call onShow for child item views
-    if (view.onShow){
-      this.onShowCallbacks.add(view.onShow, view);
-    }
-
-    return renderResult;
+    this._childBindings = this._childBindings || {};
+    this._childBindings[view.cid] = childBinding;
   },
 
   // render the item view
@@ -1338,10 +1476,10 @@ Marionette.CollectionView = Marionette.View.extend({
     var view = this.children.findByModel(item);
 
     if (view){
-      var childBinding = this.childBindings[view.cid];
+      var childBinding = this._childBindings[view.cid];
       if (childBinding) {
         this.unbindFrom(childBinding);
-        delete this.childBindings[view.cid];
+        delete this._childBindings[view.cid];
       }
 
       if (view.close){
@@ -1379,7 +1517,9 @@ Marionette.CollectionView = Marionette.View.extend({
     this.triggerMethod("collection:before:close");
     this.closeChildren();
     this.triggerMethod("collection:closed");
-    Marionette.View.prototype.close.apply(this, arguments);
+
+    var args = Array.prototype.slice.apply(arguments);
+    Marionette.View.prototype.close.apply(this, args);
   },
 
   // Close the child views that this collection view
@@ -1401,7 +1541,9 @@ Marionette.CollectionView = Marionette.View.extend({
 // an item view as `modelView`, for the top leaf
 Marionette.CompositeView = Marionette.CollectionView.extend({
   constructor: function(options){
-    Marionette.CollectionView.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    Marionette.CollectionView.apply(this, args);
+
     this.itemView = this.getItemView();
   },
 
@@ -1470,7 +1612,9 @@ Marionette.CompositeView = Marionette.CollectionView.extend({
 
   // Render the collection for the composite view
   renderCollection: function(){
-    Marionette.CollectionView.prototype.render.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    Marionette.CollectionView.prototype.render.apply(this, args);
+
     this.triggerMethod("composite:collection:rendered");
   },
 
@@ -1547,7 +1691,9 @@ Marionette.Layout = Marionette.ItemView.extend({
   constructor: function () {
     this._firstRender = true;
     this.initializeRegions();
-    Backbone.Marionette.ItemView.apply(this, arguments);
+
+    var args = Array.prototype.slice.apply(arguments);
+    Backbone.Marionette.ItemView.apply(this, args);
   },
 
   // Layout's render will use the existing region objects the
@@ -1567,7 +1713,9 @@ Marionette.Layout = Marionette.ItemView.extend({
       this.reInitializeRegions();
     }
 
-    var result = Marionette.ItemView.prototype.render.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    var result = Marionette.ItemView.prototype.render.apply(this, args);
+
     return result;
   },
 
@@ -1577,7 +1725,9 @@ Marionette.Layout = Marionette.ItemView.extend({
 
     this.closeRegions();
     this.destroyRegions();
-    Backbone.Marionette.ItemView.prototype.close.call(this, arguments);
+
+    var args = Array.prototype.slice.apply(arguments);
+    Backbone.Marionette.ItemView.prototype.close.apply(this, args);
   },
 
   // Initialize the regions that have been defined in a
@@ -1662,7 +1812,9 @@ Marionette.Layout = Marionette.ItemView.extend({
 Marionette.AppRouter = Backbone.Router.extend({
 
   constructor: function(options){
-    Backbone.Router.prototype.constructor.apply(this, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    Backbone.Router.prototype.constructor.apply(this, args);
+
     this.options = options;
 
     if (this.appRoutes){
@@ -1728,12 +1880,14 @@ Marionette.Application = function(options){
 _.extend(Marionette.Application.prototype, Backbone.Events, {
   // Command execution, facilitated by Backbone.Wreqr.Commands
   execute: function(){
-    this.commands.execute.apply(this.commands, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    this.commands.execute.apply(this.commands, args);
   },
 
   // Request/response, facilitated by Backbone.Wreqr.RequestResponse
   request: function(){
-    return this.reqres.request.apply(this.reqres, arguments);
+    var args = Array.prototype.slice.apply(arguments);
+    return this.reqres.request.apply(this.reqres, args);
   },
 
   // Add an initializer that is either run at when the `start`
@@ -1808,6 +1962,7 @@ Marionette.Module = function(moduleName, app){
 
   // extend this module with an event binder
   Marionette.addEventBinder(this);
+  this.triggerMethod = Marionette.triggerMethod;
 };
 
 // Extend the Module prototype with events / bindTo, so that the module
@@ -1847,8 +2002,12 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
     });
 
     // 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
@@ -1858,6 +2017,8 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
     if (!this._isInitialized){ return; }
     this._isInitialized = false;
 
+    Marionette.triggerMethod.call(this, "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(); });
@@ -1868,6 +2029,8 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
     // reset the initializers and finalizers
     this._initializerCallbacks.reset();
     this._finalizerCallbacks.reset();
+
+    Marionette.triggerMethod.call(this, "stop");
   },
 
   // Configure the module with a definition function and any custom args
@@ -1883,11 +2046,11 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
 
     // build the correct list of arguments for the module definition
     var args = _.flatten([
-      this, 
-      this.config.app, 
-      Backbone, 
-      Marionette, 
-      $, _, 
+      this,
+      this.config.app,
+      Backbone,
+      Marionette,
+      $, _,
       customArgs
     ]);
 
@@ -1906,7 +2069,7 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
 // Function level methods to create modules
 _.extend(Marionette.Module, {
 
-  // Create a module, hanging off the app parameter as the parent object. 
+  // Create a module, hanging off the app parameter as the parent object.
   create: function(app, moduleNames, moduleDefinition){
     var that = this;
     var parentModule = app;
@@ -1929,7 +2092,7 @@ _.extend(Marionette.Module, {
       if (isLastModuleInChain){
         module.config.options = that._getModuleOptions(module, parentModule, moduleDefinition);
 
-        // Only add a module definition and initializer when this is the last 
+        // Only add a module definition and initializer when this is the last
         // module in a "parent.child.grandchild" hierarchy of module names and
         // when the module call has a definition function supplied
         if (module.config.options.hasDefinition){
@@ -1953,14 +2116,14 @@ _.extend(Marionette.Module, {
     return parentModule;
   },
 
-  // Only add the initializer if it is set to start with parent (the app), 
+  // Only add the initializer if it is set to start with parent (the app),
   // and if it has not yet been added
   _configureStartWithApp: function(app, module){
     // skip this if we have already configured the module to start w/ the app
     if (module.config.startWithAppIsConfigured){
       return;
     }
-      
+
     // start the module when the app starts
     app.addInitializer(function(options){
       // but only if the module is configured to start w/ parent
@@ -1979,7 +2142,7 @@ _.extend(Marionette.Module, {
     // Get an existing module of this name if we have one
     var module = parentModule[moduleName];
 
-    if (!module){ 
+    if (!module){
       // Create a new module if we don't have one
       module = new Marionette.Module(moduleName, app);
       parentModule[moduleName] = module;
@@ -1998,7 +2161,7 @@ _.extend(Marionette.Module, {
     }
 
     // set up initial options for the module
-    var options = { 
+    var options = {
       startWithParent: startWithParent,
       hasDefinition: !!moduleDefinition
     };
@@ -2013,12 +2176,12 @@ _.extend(Marionette.Module, {
 
     } else {
 
-      // the definition is an object. 
+      // the definition is an object.
 
       // grab the "define" attribute
       options.hasDefinition = !!moduleDefinition.define;
       options.definition = moduleDefinition.define;
-      
+
       // grab the "startWithParent" attribute if one exists
       if (moduleDefinition.hasOwnProperty("startWithParent")){
         options.startWithParent = moduleDefinition.startWithParent;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marionette-rails
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta6
+  version: 1.0.0.rc1
   prerelease: 6
 platform: ruby
 authors: