marionette-rails 0.9.13 → 0.10.0

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

@@ -1,4 +1,4 @@
-// Backbone.Marionette, v0.9.13
+// Backbone.Marionette, v0.10.0
 // Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
 // http://github.com/derickbailey/backbone.marionette
@@ -440,7 +440,14 @@ Marionette.CollectionView = Marionette.View.extend({
 
   // Build an `itemView` for every model in the collection.
   buildItemView: function(item, ItemView){
-    var itemViewOptions = _.result(this, "itemViewOptions");
+    var itemViewOptions;
+
+    if (_.isFunction(this.itemViewOptions)){
+      itemViewOptions = this.itemViewOptions(item);
+    } else {
+      itemViewOptions = this.itemViewOptions;
+    }
+
     var options = _.extend({model: item}, itemViewOptions);
     var view = new ItemView(options);
     return view;
@@ -1010,10 +1017,10 @@ Marionette.Module = function(moduleName, app, customArgs){
   this._setupInitializersAndFinalizers();
 
   // store the configuration for this module
-  this._config = {};
-  this._config.app = app;
-  this._config.customArgs = customArgs;
-  this._config.definitions = [];
+  this.config = {};
+  this.config.app = app;
+  this.config.customArgs = customArgs;
+  this.config.definitions = [];
 
   // extend this module with an event binder
   var eventBinder = new Marionette.EventBinder();
@@ -1042,16 +1049,16 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
     // Prevent re-start the module
     if (this._isInitialized){ return; }
 
-    this._runModuleDefinition();
+    // start the sub-modules (depth-first hierarchy)
+    _.each(this.submodules, function(mod){
+      if (mod.config.options.startWithParent){
+        mod.start(options);
+      }
+    });
+
+    // run the callbacks to "start" the current module
     this._initializerCallbacks.run(options, this);
     this._isInitialized = true;
-
-    // start the sub-modules
-    if (this.submodules){
-      _.each(this.submodules, function(mod){
-        mod.start(options);
-      });
-    }
   },
 
   // Stop this module by running its finalizers and then stop all of
@@ -1061,44 +1068,40 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
     if (!this._isInitialized){ return; }
     this._isInitialized = false;
 
+    // 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();
-    // then reset the initializers and finalizers
-    this._setupInitializersAndFinalizers();
 
-    // stop the sub-modules
-    _.each(this.submodules, function(mod){ mod.stop(); });
+    // reset the initializers and finalizers
+    this._initializerCallbacks.reset();
+    this._finalizerCallbacks.reset();
   },
 
   // Configure the module with a definition function and any custom args
   // that are to be passed in to the definition function
   addDefinition: function(moduleDefinition){
-    this._config.definitions.push(moduleDefinition);
+    this._runModuleDefinition(moduleDefinition);
   },
 
   // Internal method: run the module definition function with the correct
   // arguments
-  _runModuleDefinition: function(){
-    if (this._config.definitions.length === 0) { return; }
+  _runModuleDefinition: function(definition){
+    if (!definition){ return; }
 
     // build the correct list of arguments for the module definition
     var args = _.flatten([
       this, 
-      this._config.app, 
+      this.config.app, 
       Backbone, 
       Marionette, 
       $, _, 
-      this._config.customArgs
+      this.config.customArgs
     ]);
 
-    // run the module definition function with the correct args
-    var definitionCount = this._config.definitions.length-1;
-    for(var i=0; i <= definitionCount; i++){
-
-      var definition = this._config.definitions[i];
-      definition.apply(this, args);
-
-    }
+    definition.apply(this, args);
   },
 
   // Internal method: set up new copies of initializers and finalizers.
@@ -1128,22 +1131,22 @@ _.extend(Marionette.Module, {
     var length = moduleNames.length;
     _.each(moduleNames, function(moduleName, i){
       var isLastModuleInChain = (i === length-1);
+      var isFirstModuleInChain = (i === 0);
 
-      // 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 Marionette.Module(moduleName, app, customArgs);
-        parentModule[moduleName] = module;
-        // store the module on the parent
-        parentModule.submodules[moduleName] = module;
+      var module = that._getModuleDefinition(parentModule, moduleName, app, customArgs);
+      module.config.options = that._getModuleOptions(parentModule, moduleDefinition);
+
+      // if it's the first module in the chain, configure it
+      // for auto-start, as specified by the options
+      if (isFirstModuleInChain){
+        that._configureAutoStart(app, module);
       }
 
       // Only add a module definition and initializer when this is
       // the last module in a "parent.child.grandchild" hierarchy of
       // module names
-      if (isLastModuleInChain ){
-        that._createModuleDefinition(module, moduleDefinition, app);
+      if (isLastModuleInChain && module.config.options.hasDefinition){
+        module.addDefinition(module.config.options.definition);
       }
 
       // Reset the parent module so that the next child
@@ -1155,28 +1158,46 @@ _.extend(Marionette.Module, {
     return parentModule;
   },
 
-  _createModuleDefinition: function(module, moduleDefinition, app){
-    var moduleOptions = this._getModuleDefinitionOptions(moduleDefinition);
-    
-    // add the module definition
-    if (moduleOptions.definition){
-      module.addDefinition(moduleOptions.definition);
-    }
-
-    if (moduleOptions.startWithApp){
+  _configureAutoStart: function(app, module){
+    // Only add the initializer if it's the first module, and
+    // if it is set to auto-start, and if it has not yet been added
+    if (module.config.options.startWithParent && !module.config.autoStartConfigured){
       // start the module when the app starts
       app.addInitializer(function(options){
         module.start(options);
       });
     }
+
+    // prevent this module from being configured for
+    // auto start again. the first time the module
+    // is defined, determines it's auto-start
+    module.config.autoStartConfigured = true;
+  },
+
+  _getModuleDefinition: function(parentModule, moduleName, app, customArgs){
+    // 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 Marionette.Module(moduleName, app, customArgs);
+      parentModule[moduleName] = module;
+      // store the module on the parent
+      parentModule.submodules[moduleName] = module;
+    }
+
+    return module;
   },
 
-  _getModuleDefinitionOptions: function(moduleDefinition){
+  _getModuleOptions: function(parentModule, moduleDefinition){
     // default to starting the module with the app
-    var options = { startWithApp: true };
+    var options = { 
+      startWithParent: true,
+      hasDefinition: !!moduleDefinition
+    };
 
     // short circuit if we don't have a module definition
-    if (!moduleDefinition){ return options; }
+    if (!options.hasDefinition){ return options; }
 
     if (_.isFunction(moduleDefinition)){
       // if the definition is a function, assign it directly
@@ -1185,12 +1206,15 @@ _.extend(Marionette.Module, {
 
     } else {
 
-      // the definition is an object. grab the "define" attribute
-      // and the "startWithApp" attribute, as set the options
-      // appropriately
+      // the definition is an object. 
+
+      // grab the "define" attribute
+      options.hasDefinition = !!moduleDefinition.define;
       options.definition = moduleDefinition.define;
-      if (moduleDefinition.hasOwnProperty("startWithApp")){
-        options.startWithApp = moduleDefinition.startWithApp;
+      
+      // grab the "startWithParent" attribute if one exists
+      if (moduleDefinition.hasOwnProperty("startWithParent")){
+        options.startWithParent = moduleDefinition.startWithParent;
       }
     }
 
@@ -1322,8 +1346,8 @@ Marionette.Renderer = {
 // and executing them at a later point in time, using jQuery's
 // `Deferred` object.
 Marionette.Callbacks = function(){
-  this.deferred = $.Deferred();
-  this.promise = this.deferred.promise();
+  this._deferred = $.Deferred();
+  this._callbacks = [];
 };
 
 _.extend(Marionette.Callbacks.prototype, {
@@ -1332,7 +1356,9 @@ _.extend(Marionette.Callbacks.prototype, {
   // guaranteed to execute, even if they are added after the 
   // `run` method is called.
   add: function(callback, contextOverride){
-    this.promise.done(function(context, options){
+    this._callbacks.push({cb: callback, ctx: contextOverride});
+
+    this._deferred.done(function(context, options){
       if (contextOverride){ context = contextOverride; }
       callback.call(context, options);
     });
@@ -1342,7 +1368,17 @@ _.extend(Marionette.Callbacks.prototype, {
   // Additional callbacks can be added after this has been run 
   // and they will still be executed.
   run: function(options, context){
-    this.deferred.resolve(context, options);
+    this._deferred.resolve(context, options);
+  },
+
+  // 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 that = this;
+    this._deferred = $.Deferred();
+    _.each(this._callbacks, function(cb){
+      that.add(cb.cb, cb.ctx);
+    });
   }
 });
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 9
-  - 13
-  version: 0.9.13
+  - 10
+  - 0
+  version: 0.10.0
 platform: ruby
 authors: 
 - Godfrey Chan