Update to work with marionette 1.0.0rc3

backbone.geppetto.js

@@ -1,4 +1,4 @@
-// Backbone.Geppetto v0.3
+// Backbone.Geppetto v0.3-dev
 //
 // Copyright (C) 2012 Model N, Inc.  
 // Distributed under the MIT License
@@ -29,9 +29,9 @@ define( [
 
             this.parentContext = this.options.parentContext;
 
-            this.vent = new Backbone.EventBinder();
+            this.vent = {};
 
-            _.extend(this.vent, Backbone.Events);
+			Marionette.addEventBinder(this.vent);
 
             this.initialize && this.initialize();
 
@@ -100,7 +100,7 @@ define( [
 
                         // unbind all the event bindings tied to this view
                         _.each(that._viewBindings[viewId], function(binding) {
-                            that.vent.unbindFrom(binding);
+                            that.vent.stopListening(binding[0], binding[1]);
                         });
 
                         target[VIEW_ID_KEY] = undefined;
@@ -114,7 +114,9 @@ define( [
                 }
             }
 
-            var binding = this.vent.bindTo( this.vent, eventName, callback );
+			this.vent.listenTo( this.vent, eventName, callback, target );
+			// The arguments to listenTo are enough to stop listening to an event so we'll store those as the binding
+            var binding = [this.vent, eventName, callback];
 
             if (target instanceof Backbone.View) {
                 this._viewBindings[viewId].push(binding);
@@ -142,7 +144,7 @@ define( [
 
         Geppetto.Context.prototype.mapCommand = function mapCommand( eventName, commandClass ) {
 
-            this.vent.bindTo( this.vent, eventName, function ( eventData ) {
+            this.vent.listenTo( this.vent, eventName, function ( eventData ) {
 
                 var commandInstance = new commandClass();
 
@@ -156,7 +158,7 @@ define( [
 
         Geppetto.Context.prototype.unmapAll = function unmapAll() {
 
-            this.vent.unbindAll();
+            this.vent.stopListening();
 
             delete contexts[this._contextId];
 

dependencies/backbone.babysitter.js

@@ -0,0 +1,213 @@
+// Backbone.BabySitter, v0.0.4
+// Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
+// Distributed under MIT license
+// http://github.com/marionettejs/backbone.babysitter
+(function (root, factory) {
+  if (typeof exports === 'object') {
+
+    var underscore = require('underscore');
+    var backbone = require('backbone');
+
+    module.exports = factory(underscore, backbone);
+
+  } else if (typeof define === 'function' && define.amd) {
+
+    define(['underscore', 'backbone'], factory);
+
+  } 
+}(this, function (_, Backbone) {
+  "option strict";
+
+  // Backbone.ChildViewContainer
+  // ---------------------------
+  //
+  // Provide a container to store, retrieve and
+  // shut down child views.
+
+  Backbone.ChildViewContainer = (function(Backbone, _){
+
+    // Container Constructor
+    // ---------------------
+
+    var Container = function(initialViews){
+      this._views = {};
+      this._indexByModel = {};
+      this._indexByCollection = {};
+      this._indexByCustom = {};
+      this._updateLength();
+
+      this._addInitialViews(initialViews);
+    };
+
+    // 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;
+
+        // 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:
+    // 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', 'pluck'];
+
+    _.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, _);
+
+  return Backbone.ChildViewContainer; 
+
+}));