marionette-rails 1.0.0.beta5 → 1.0.0.beta6

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

@@ -1,15 +1,192 @@
 /*!
- * Backbone.Marionette, v1.0.0-beta5
+ * Backbone.Marionette, v1.0.0-beta6
  * Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
  * Distributed under MIT license
  * http://github.com/marionettejs/backbone.marionette
 */
 /*!
+ * Includes BabySitter
+ * https://github.com/marionettejs/backbone.babysitter/
  * Includes Wreqr
  * https://github.com/marionettejs/backbone.wreqr/
  * Includes EventBinder
  * https://github.com/marionettejs/backbone.eventbinder/
  */
+// Backbone.BabySitter, v0.0.3
+// Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
+// Distributed under MIT license
+// http://github.com/marionettejs/backbone.babysitter
+// Backbone.ChildViewContainer
+// ---------------------------
+//
+// Provide a container to store, retrieve and
+// shut down child views.
+
+Backbone.ChildViewContainer = (function(Backbone, _){
+  
+  // Container Constructor
+  // ---------------------
+
+  var Container = function(options){
+    this._views = {};
+    this._indexByModel = {};
+    this._indexByCollection = {};
+    this._indexByCustom = {};
+    this._updateLength();
+  };
+
+  // Container Methods
+  // -----------------
+
+  _.extend(Container.prototype, {
+
+    // Add a view to this container. Stores the view
+    // by `cid` and makes it searchable by the model
+    // and/or collection of the view. Optionally specify
+    // a custom key to store an retrieve the view.
+    add: function(view, customIndex){
+      var viewCid = view.cid;
+
+      // store the view
+      this._views[viewCid] = view;
+
+      // index it by model
+      if (view.model){
+        this._indexByModel[view.model.cid] = viewCid;
+      }
+
+      // index it by collection
+      if (view.collection){
+        this._indexByCollection[view.collection.cid] = viewCid;
+      }
+
+      // index by custom
+      if (customIndex){
+        this._indexByCustom[customIndex] = viewCid;
+      }
+
+      this._updateLength();
+    },
+
+    // Find a view by the model that was attached to
+    // it. Uses the model's `cid` to find it, and
+    // retrieves the view by it's `cid` from the result
+    findByModel: function(model){
+      var viewCid = this._indexByModel[model.cid];
+      return this.findByCid(viewCid);
+    },
+
+    // Find a view by the collection that was attached to
+    // it. Uses the collection's `cid` to find it, and
+    // retrieves the view by it's `cid` from the result
+    findByCollection: function(col){
+      var viewCid = this._indexByCollection[col.cid];
+      return this.findByCid(viewCid);
+    },
+
+    // Find a view by a custom indexer.
+    findByCustom: function(index){
+      var viewCid = this._indexByCustom[index];
+      return this.findByCid(viewCid);
+    },
+
+    // Find by index. This is not guaranteed to be a
+    // stable index.
+    findByIndex: function(index){
+      return _.values(this._views)[index];
+    },
+
+    // retrieve a view by it's `cid` directly
+    findByCid: function(cid){
+      return this._views[cid];
+    },
+
+    // Remove a view
+    remove: function(view){
+      var viewCid = view.cid;
+
+      // delete model index
+      if (view.model){
+        delete this._indexByModel[view.model.cid];
+      }
+
+      // delete collection index
+      if (view.collection){
+        delete this._indexByCollection[view.collection.cid];
+      }
+
+      // delete custom index
+      var cust;
+
+      for (var key in this._indexByCustom){
+        if (this._indexByCustom.hasOwnProperty(key)){
+          if (this._indexByCustom[key] === viewCid){
+            cust = key;
+            break;
+          }
+        }
+      }
+
+      if (cust){
+        delete this._indexByCustom[cust];
+      }
+
+      // remove the view from the container
+      delete this._views[viewCid];
+
+      // update the length
+      this._updateLength();
+    },
+
+    // Call a method on every view in the container,
+    // passing parameters to the call method one at a
+    // time, like `function.call`.
+    call: function(method, args){
+      args = Array.prototype.slice.call(arguments, 1);
+      this.apply(method, args);
+    },
+
+    // Apply a method on every view in the container,
+    // passing parameters to the call method one at a
+    // time, like `function.apply`.
+    apply: function(method, args){
+      var view;
+      _.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);
+    }
+
+  });
+
+  // Borrowing this code from Backbone.Collection:
+  // http://backbonejs.org/docs/backbone.html#section-106
+  //
+  // Mix in methods from Underscore, for iteration, and other
+  // collection related features.
+  var methods = ['forEach', 'each', 'map', 'find', 'detect', 'filter', 
+    'select', 'reject', 'every', 'all', 'some', 'any', 'include', 
+    'contains', 'invoke', 'toArray', 'first', 'initial', 'rest', 
+    'last', 'without', 'isEmpty'];
+
+  _.each(methods, function(method) {
+    Container.prototype[method] = function() {
+      var views = _.values(this._views);
+      var args = [views].concat(_.toArray(arguments));
+      return _[method].apply(_, args);
+    };
+  });
+
+  // return the public API
+  return Container;
+})(Backbone, _);
+
 // Backbone.EventBinder, v0.1.0
 // Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
 // Distributed under MIT license
@@ -340,7 +517,7 @@ Marionette.triggerMethod = function(){
 
   if (_.isFunction(this[methodName])){
     args.shift();
-    this[methodName].apply(this, args);
+    return this[methodName].apply(this, args);
   }
 };
 
@@ -562,12 +739,13 @@ Marionette.Renderer = {
 // modules and routers, and as a mediator for workflow
 // and coordination of other objects, views, and more.
 Marionette.Controller = function(options){
+  this.triggerMethod = Marionette.triggerMethod;
   this.options = options || {};
 
   Marionette.addEventBinder(this);
 
   if (_.isFunction(this.initialize)){
-    this.initialize(options);
+    this.initialize(this.options);
   }
 };
 
@@ -577,7 +755,13 @@ Marionette.Controller.extend = Marionette.extend;
 // --------------
 
 // Ensure it can trigger events with Backbone.Events
-_.extend(Marionette.Controller.prototype, Backbone.Events);
+_.extend(Marionette.Controller.prototype, Backbone.Events, {
+  close: function(){
+    this.unbindAll();
+    this.triggerMethod("close");
+    this.unbind();
+  }
+});
 
 // Region 
 // ------
@@ -964,6 +1148,7 @@ Marionette.ItemView =  Marionette.View.extend({
 Marionette.CollectionView = Marionette.View.extend({
   constructor: function(options){
     this.initChildViewStorage();
+
     Marionette.View.prototype.constructor.apply(this, arguments);
     this.initialEvents();
     this.onShowCallbacks = new Marionette.Callbacks();
@@ -1106,7 +1291,7 @@ Marionette.CollectionView = Marionette.View.extend({
 
     // Store the child view itself so we can properly
     // remove and/or close it later
-    this.storeChild(item, view);
+    this.children.add(view);
     this.triggerMethod("item:added", view);
 
     // Forward all child item view events through the parent,
@@ -1150,15 +1335,20 @@ Marionette.CollectionView = Marionette.View.extend({
 
   // Remove the child view and close it
   removeItemView: function(item){
-    var view = this.children[item.cid];
+    var view = this.children.findByModel(item);
+
     if (view){
       var childBinding = this.childBindings[view.cid];
       if (childBinding) {
         this.unbindFrom(childBinding);
         delete this.childBindings[view.cid];
       }
-      view.close();
-      delete this.children[item.cid];
+
+      if (view.close){
+        view.close();
+      }
+
+      this.children.remove(view);
     }
 
     if (!this.collection || this.collection.length === 0){
@@ -1175,16 +1365,10 @@ Marionette.CollectionView = Marionette.View.extend({
     collectionView.$el.append(itemView.el);
   },
 
-  // Store references to all of the child `itemView`
-  // instances so they can be managed and cleaned up, later.
-  storeChild: function(item, view){
-    this.children[item.cid] = view;
-  },
-
   // Internal method to set up the `children` object for
   // storing all of the child views
   initChildViewStorage: function(){
-    this.children = {};
+    this.children = new Backbone.ChildViewContainer();
   },
 
   // Handle cleanup and other closing needs for
@@ -1202,11 +1386,9 @@ Marionette.CollectionView = Marionette.View.extend({
   // is holding on to, if any
   closeChildren: function(){
     var that = this;
-    if (this.children){
-      _.each(_.clone(this.children), function(childView){
-        that.removeItemView(childView.model);
-      });
-    }
+    this.children.apply("close");
+    // re-initialize to clean up after ourselves
+    this.initChildViewStorage();
   }
 });
 
@@ -1480,13 +1662,11 @@ Marionette.Layout = Marionette.ItemView.extend({
 Marionette.AppRouter = Backbone.Router.extend({
 
   constructor: function(options){
-    Backbone.Router.prototype.constructor.call(this, options);
+    Backbone.Router.prototype.constructor.apply(this, arguments);
+    this.options = options;
 
     if (this.appRoutes){
-      var controller = this.controller;
-      if (options && options.controller) {
-        controller = options.controller;
-      }
+      var controller = Marionette.getOption(this, "controller");
       this.processAppRoutes(controller, this.appRoutes);
     }
   },
@@ -1649,12 +1829,19 @@ _.extend(Marionette.Module.prototype, Backbone.Events, {
 
   // Start the module, and run all of it's initializers
   start: function(options){
-    // Prevent re-start the module
+    // 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){
-      if (mod.config.options.startWithParent){
+      // check to see if we should start the sub-module with this parent
+      var startWithParent = true;
+      if (mod.config && mod.config.options){
+        startWithParent = mod.config.options.startWithParent;
+      }
+
+      // start the sub-module
+      if (startWithParent){
         mod.start(options);
       }
     });

metadata

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