marionette-rails 1.0.0.beta3 → 1.0.0.beta4

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

@@ -1,5 +1,5 @@
 /*!
- * Backbone.Marionette, v1.0.0-beta3
+ * Backbone.Marionette, v1.0.0-beta4
  * Copyright (c)2012 Derick Bailey, Muted Solutions, LLC.
  * Distributed under MIT license
  * http://github.com/marionettejs/backbone.marionette
@@ -244,9 +244,79 @@ Backbone.Marionette = Marionette = (function(Backbone, _, $){
 // For slicing `arguments` in functions
 var slice = Array.prototype.slice;
 
+// Marionette.extend
+// -----------------
+
 // Borrow the Backbone `extend` method so we can use it as needed
 Marionette.extend = Backbone.Model.extend;
 
+// Marionette.getOption
+// --------------------
+
+// Retrieve an object, function or other value from a target
+// object or it's `options`, with `options` taking precedence.
+Marionette.getOption = function(target, optionName){
+  if (!target || !optionName){ return; }
+  var value;
+
+  if (target.options && target.options[optionName]){
+    value = target.options[optionName];
+  } else {
+    value = target[optionName];
+  }
+
+  return value;
+};
+
+// Mairionette.createObject
+// ------------------------
+
+// A wrapper / shim for `Object.create`. Uses native `Object.create`
+// if available, otherwise shims it in place for Marionette to use.
+Marionette.createObject = (function(){
+  var createObject;
+  
+  // Define this once, and just replace the .prototype on it as needed,
+  // to improve performance in older / less optimized JS engines
+  function F() {}
+
+
+  // Check for existing native / shimmed Object.create
+  if (typeof Object.create === "function"){
+
+    // found native/shim, so use it
+    createObject = Object.create;
+
+  } else {
+
+    // An implementation of the Boodman/Crockford delegation 
+    // w/ Cornford optimization, as suggested by @unscriptable
+    // https://gist.github.com/3959151
+
+    // native/shim not found, so shim it ourself
+    createObject = function (o) {
+
+      // set the prototype of the function
+      // so we will get `o` as the prototype
+      // of the new object instance
+      F.prototype = o;
+
+      // create a new object that inherits from
+      // the `o` parameter
+      var child = new F();
+      
+      // clean up just in case o is really large
+      F.prototype = null; 
+
+      // send it back
+      return child;
+    };
+
+  }
+
+  return createObject;
+})();
+
 // Trigger an event and a corresponding method name. Examples:
 //
 // `this.triggerMethod("foo")` will trigger the "foo" event and
@@ -274,11 +344,22 @@ Marionette.triggerMethod = function(){
   }
 };
 
+
 // EventBinder
 // -----------
 // Import the event binder from it's new home
 // https://github.com/marionettejs/backbone.eventbinder
-Marionette.EventBinder = 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);
+  }
+  
+});
 
 // Add the EventBinder methods to the view directly,
 // but keep them bound to the EventBinder instance so they work properly.
@@ -310,6 +391,361 @@ Marionette.EventAggregator = Backbone.Wreqr.EventAggregator.extend({
 
 });
 
+// Callbacks
+// ---------
+
+// A simple way of managing a collection of callbacks
+// and executing them at a later point in time, using jQuery's
+// `Deferred` object.
+Marionette.Callbacks = function(){
+  this._deferred = $.Deferred();
+  this._callbacks = [];
+};
+
+_.extend(Marionette.Callbacks.prototype, {
+
+  // Add a callback to be executed. Callbacks added here are
+  // guaranteed to execute, even if they are added after the 
+  // `run` method is called.
+  add: function(callback, contextOverride){
+    this._callbacks.push({cb: callback, ctx: contextOverride});
+
+    this._deferred.done(function(context, options){
+      if (contextOverride){ context = contextOverride; }
+      callback.call(context, options);
+    });
+  },
+
+  // Run all registered callbacks with the context specified. 
+  // 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);
+  },
+
+  // 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;
+    var callbacks = this._callbacks;
+    this._deferred = $.Deferred();
+    this._callbacks = [];
+    _.each(callbacks, function(cb){
+      that.add(cb.cb, cb.ctx);
+    });
+  }
+});
+
+
+// Template Cache
+// --------------
+
+// Manage templates stored in `<script>` blocks,
+// caching them for faster access.
+Marionette.TemplateCache = function(templateId){
+  this.templateId = templateId;
+};
+
+// TemplateCache object-level methods. Manage the template
+// caches from these method calls instead of creating 
+// your own TemplateCache instances
+_.extend(Marionette.TemplateCache, {
+  templateCaches: {},
+
+  // Get the specified template by id. Either
+  // retrieves the cached version, or loads it
+  // from the DOM.
+  get: function(templateId){
+    var that = this;
+    var cachedTemplate = this.templateCaches[templateId];
+
+    if (!cachedTemplate){
+      cachedTemplate = new Marionette.TemplateCache(templateId);
+      this.templateCaches[templateId] = cachedTemplate;
+    }
+
+    return cachedTemplate.load();
+  },
+
+  // Clear templates from the cache. If no arguments
+  // are specified, clears all templates:
+  // `clear()`
+  //
+  // If arguments are specified, clears each of the 
+  // specified templates from the cache:
+  // `clear("#t1", "#t2", "...")`
+  clear: function(){
+    var i;
+    var length = arguments.length;
+
+    if (length > 0){
+      for(i=0; i<length; i++){
+        delete this.templateCaches[arguments[i]];
+      }
+    } else {
+      this.templateCaches = {};
+    }
+  }
+});
+
+// TemplateCache instance methods, allowing each
+// template cache object to manage it's own state
+// and know whether or not it has been loaded
+_.extend(Marionette.TemplateCache.prototype, {
+
+  // Internal method to load the template asynchronously.
+  load: function(){
+    var that = this;
+
+    // Guard clause to prevent loading this template more than once
+    if (this.compiledTemplate){
+      return this.compiledTemplate;
+    }
+
+    // Load the template and compile it
+    var template = this.loadTemplate(this.templateId);
+    this.compiledTemplate = this.compileTemplate(template);
+
+    return this.compiledTemplate;
+  },
+
+  // Load a template from the DOM, by default. Override
+  // this method to provide your own template retrieval,
+  // such as asynchronous loading from a server.
+  loadTemplate: function(templateId){
+    var template = $(templateId).html();
+
+    if (!template || template.length === 0){
+      var msg = "Could not find template: '" + templateId + "'";
+      var err = new Error(msg);
+      err.name = "NoTemplateError";
+      throw err;
+    }
+
+    return template;
+  },
+
+  // Pre-compile the template before caching it. Override
+  // this method if you do not need to pre-compile a template
+  // (JST / RequireJS for example) or if you want to change
+  // the template engine used (Handebars, etc).
+  compileTemplate: function(rawTemplate){
+    return _.template(rawTemplate);
+  }
+});
+
+
+// Renderer
+// --------
+
+// Render a template with data by passing in the template
+// selector and the data to render.
+Marionette.Renderer = {
+
+  // Render a template with data. The `template` parameter is
+  // passed to the `TemplateCache` object to retrieve the
+  // template function. Override this method to provide your own
+  // custom rendering and template handling for all of Marionette.
+  render: function(template, data){
+    var templateFunc = typeof template === 'function' ? template : Marionette.TemplateCache.get(template);
+    var html = templateFunc(data);
+    return html;
+  }
+};
+
+
+
+// Marionette Controller
+// ---------------------
+//
+// A multi-purpose object to use as a controller for
+// modules and routers, and as a mediator for workflow
+// and coordination of other objects, views, and more.
+Marionette.Controller = function(options){
+  this.options = options || {};
+
+  Marionette.addEventBinder(this);
+
+  if (_.isFunction(this.initialize)){
+    this.initialize(options);
+  }
+};
+
+Marionette.Controller.extend = Marionette.extend;
+
+// Controller Methods
+// --------------
+
+// Ensure it can trigger events with Backbone.Events
+_.extend(Marionette.Controller.prototype, Backbone.Events);
+
+// Region 
+// ------
+//
+// Manage the visual regions of your composite application. See
+// http://lostechies.com/derickbailey/2011/12/12/composite-js-apps-regions-and-region-managers/
+
+Marionette.Region = function(options){
+  this.options = options || {};
+
+  Marionette.addEventBinder(this);
+
+  this.el = Marionette.getOption(this, "el");
+
+  if (!this.el){
+    var err = new Error("An 'el' must be specified for a region.");
+    err.name = "NoElError";
+    throw err;
+  }
+
+  if (this.initialize){
+    this.initialize.apply(this, arguments);
+  }
+};
+
+
+// Region Type methods
+// -------------------
+
+_.extend(Marionette.Region, {
+
+  // Build an instance of a region by passing in a configuration object
+  // and a default region type to use if none is specified in the config.
+  //
+  // The config object should either be a string as a jQuery DOM selector,
+  // a Region type directly, or an object literal that specifies both
+  // a selector and regionType:
+  //
+  // ```js
+  // {
+  //   selector: "#foo",
+  //   regionType: MyCustomRegion
+  // }
+  // ```
+  //
+  buildRegion: function(regionConfig, defaultRegionType){
+    var regionIsString = (typeof regionConfig === "string");
+    var regionSelectorIsString = (typeof regionConfig.selector === "string");
+    var regionTypeIsUndefined = (typeof regionConfig.regionType === "undefined");
+    var regionIsType = (typeof regionConfig === "function");
+
+    if (!regionIsType && !regionIsString && !regionSelectorIsString) {
+      throw new Error("Region must be specified as a Region type, a selector string or an object with selector property");
+    }
+
+    var selector, RegionType;
+   
+    // get the selector for the region
+    
+    if (regionIsString) {
+      selector = regionConfig;
+    } 
+
+    if (regionConfig.selector) {
+      selector = regionConfig.selector;
+    }
+
+    // get the type for the region
+    
+    if (regionIsType){
+      RegionType = regionConfig;
+    }
+
+    if (!regionIsType && regionTypeIsUndefined) {
+      RegionType = defaultRegionType;
+    }
+
+    if (regionConfig.regionType) {
+      RegionType = regionConfig.regionType;
+    }
+    
+    // build the region instance
+
+    var regionManager = new RegionType({
+      el: selector
+    });
+
+    return regionManager;
+  }
+
+});
+
+// Region Instance Methods
+// -----------------------
+
+_.extend(Marionette.Region.prototype, Backbone.Events, {
+
+  // Displays a backbone view instance inside of the region.
+  // Handles calling the `render` method for you. Reads content
+  // directly from the `el` attribute. Also calls an optional
+  // `onShow` and `close` method on your view, just after showing
+  // or just before closing the view, respectively.
+  show: function(view){
+
+    this.ensureEl();
+    this.close();
+
+    view.render();
+    this.open(view);
+
+    Marionette.triggerMethod.call(view, "show");
+    Marionette.triggerMethod.call(this, "show", view);
+
+    this.currentView = view;
+  },
+
+  ensureEl: function(){
+    if (!this.$el || this.$el.length === 0){
+      this.$el = this.getEl(this.el);
+    }
+  },
+
+  // Override this method to change how the region finds the
+  // DOM element that it manages. Return a jQuery selector object.
+  getEl: function(selector){
+    return $(selector);
+  },
+
+  // Override this method to change how the new view is
+  // appended to the `$el` that the region is managing
+  open: function(view){
+    this.$el.empty().append(view.el);
+  },
+
+  // Close the current view, if there is one. If there is no
+  // current view, it does nothing and returns immediately.
+  close: function(){
+    var view = this.currentView;
+    if (!view || view.isClosed){ return; }
+
+    if (view.close) { view.close(); }
+    Marionette.triggerMethod.call(this, "close");
+
+    delete this.currentView;
+  },
+
+  // Attach an existing view to the region. This 
+  // will not call `render` or `onShow` for the new view, 
+  // and will not replace the current HTML for the `el`
+  // of the region.
+  attachView: function(view){
+    this.currentView = view;
+  },
+
+  // Reset the region by closing any existing view and
+  // clearing out the cached `$el`. The next time a view
+  // is shown via this region, the region will re-query the
+  // DOM for the region's `el`.
+  reset: function(){
+    this.close();
+    delete this.$el;
+  }
+});
+
+// Copy the `extend` function used by Backbone's classes
+Marionette.Region.extend = Marionette.extend;
+
+
 // Marionette.View
 // ---------------
 
@@ -337,17 +773,7 @@ Marionette.View = Backbone.View.extend({
   // definition or pass a `template: "whatever"` parameter in
   // to the constructor options.
   getTemplate: function(){
-    var template;
-
-    // Get the template from `this.options.template` or
-    // `this.template`. The `options` takes precedence.
-    if (this.options && this.options.template){
-      template = this.options.template;
-    } else {
-      template = this.template;
-    }
-
-    return template;
+    return Marionette.getOption(this, "template");
   },
 
   // Mix in template helper methods. Looks for a
@@ -628,7 +1054,8 @@ Marionette.CollectionView = Marionette.View.extend({
   // a collection of item views, when the collection is
   // empty
   showEmptyView: function(){
-    var EmptyView = this.options.emptyView || this.emptyView;
+    var EmptyView = Marionette.getOption(this, "emptyView");
+
     if (EmptyView && !this._showingEmptyView){
       this._showingEmptyView = true;
       var model = new Backbone.Model();
@@ -650,7 +1077,7 @@ Marionette.CollectionView = Marionette.View.extend({
   // or from the `itemView` in the object definition. The "options"
   // takes precedence.
   getItemView: function(item){
-    var itemView = this.options.itemView || this.itemView;
+    var itemView = Marionette.getOption(this, "itemView");
 
     if (!itemView){
       var err = new Error("An `itemView` must be specified");
@@ -666,11 +1093,20 @@ Marionette.CollectionView = Marionette.View.extend({
   addItemView: function(item, ItemView, index){
     var that = this;
 
-    var view = this.buildItemView(item, ItemView);
+    // get the itemViewOptions if any were specified
+    var itemViewOptions;
+    if (_.isFunction(this.itemViewOptions)){
+      itemViewOptions = this.itemViewOptions(item);
+    } else {
+      itemViewOptions = this.itemViewOptions;
+    }
+
+    // build the view 
+    var view = this.buildItemView(item, ItemView, itemViewOptions);
 
     // Store the child view itself so we can properly
     // remove and/or close it later
-    this.storeChild(view);
+    this.storeChild(item, view);
     this.triggerMethod("item:added", view);
 
     // Forward all child item view events through the parent,
@@ -706,17 +1142,9 @@ Marionette.CollectionView = Marionette.View.extend({
   },
 
   // Build an `itemView` for every model in the collection.
-  buildItemView: function(item, ItemView){
-    var itemViewOptions;
-
-    if (_.isFunction(this.itemViewOptions)){
-      itemViewOptions = this.itemViewOptions(item);
-    } else {
-      itemViewOptions = this.itemViewOptions;
-    }
-
+  buildItemView: function(item, ItemViewType, itemViewOptions){
     var options = _.extend({model: item}, itemViewOptions);
-    var view = new ItemView(options);
+    var view = new ItemViewType(options);
     return view;
   },
 
@@ -749,8 +1177,8 @@ Marionette.CollectionView = Marionette.View.extend({
 
   // Store references to all of the child `itemView`
   // instances so they can be managed and cleaned up, later.
-  storeChild: function(view){
-    this.children[view.model.cid] = view;
+  storeChild: function(item, view){
+    this.children[item.cid] = view;
   },
 
   // Internal method to set up the `children` object for
@@ -811,7 +1239,7 @@ Marionette.CompositeView = Marionette.CollectionView.extend({
   // `this.itemView` or Marionette.CompositeView if no `itemView`
   // has been defined
   getItemView: function(item){
-    var itemView = this.options.itemView || this.itemView || this.constructor;
+    var itemView = Marionette.getOption(this, "itemView") || this.constructor;
 
     if (!itemView){
       var err = new Error("An `itemView` must be specified");
@@ -832,8 +1260,6 @@ Marionette.CompositeView = Marionette.CollectionView.extend({
       data = this.model.toJSON();
     }
 
-    data = this.mixinTemplateHelpers(data);
-
     return data;
   },
 
@@ -872,6 +1298,7 @@ Marionette.CompositeView = Marionette.CollectionView.extend({
   renderModel: function(){
     var data = {};
     data = this.serializeData();
+    data = this.mixinTemplateHelpers(data);
 
     var template = this.getTemplate();
     return Marionette.Renderer.render(template, data);
@@ -921,177 +1348,6 @@ Marionette.CompositeView = Marionette.CollectionView.extend({
 });
 
 
-// Region 
-// ------
-//
-// Manage the visual regions of your composite application. See
-// http://lostechies.com/derickbailey/2011/12/12/composite-js-apps-regions-and-region-managers/
-
-Marionette.Region = function(options){
-  this.options = options || {};
-
-  var el = this.options.el;
-  delete this.options.el;
-
-  Marionette.addEventBinder(this);
-
-  if (el){
-    this.el = el;
-  }
-
-  if (!this.el){
-    var err = new Error("An 'el' must be specified for a region.");
-    err.name = "NoElError";
-    throw err;
-  }
-
-  if (this.initialize){
-    this.initialize.apply(this, arguments);
-  }
-};
-
-
-// Region Type methods
-// -------------------
-
-_.extend(Marionette.Region, {
-
-  // Build an instance of a region by passing in a configuration object
-  // and a default region type to use if none is specified in the config.
-  //
-  // The config object should either be a string as a jQuery DOM selector,
-  // a Region type directly, or an object literal that specifies both
-  // a selector and regionType:
-  //
-  // ```js
-  // {
-  //   selector: "#foo",
-  //   regionType: MyCustomRegion
-  // }
-  // ```
-  //
-  buildRegion: function(regionConfig, defaultRegionType){
-    var regionIsString = (typeof regionConfig === "string");
-    var regionSelectorIsString = (typeof regionConfig.selector === "string");
-    var regionTypeIsUndefined = (typeof regionConfig.regionType === "undefined");
-    var regionIsType = (typeof regionConfig === "function");
-
-    if (!regionIsType && !regionIsString && !regionSelectorIsString) {
-      throw new Error("Region must be specified as a Region type, a selector string or an object with selector property");
-    }
-
-    var selector, RegionType;
-   
-    // get the selector for the region
-    
-    if (regionIsString) {
-      selector = regionConfig;
-    } 
-
-    if (regionConfig.selector) {
-      selector = regionConfig.selector;
-    }
-
-    // get the type for the region
-    
-    if (regionIsType){
-      RegionType = regionConfig;
-    }
-
-    if (!regionIsType && regionTypeIsUndefined) {
-      RegionType = defaultRegionType;
-    }
-
-    if (regionConfig.regionType) {
-      RegionType = regionConfig.regionType;
-    }
-    
-    // build the region instance
-
-    var regionManager = new RegionType({
-      el: selector
-    });
-
-    return regionManager;
-  }
-
-});
-
-// Region Instance Methods
-// -----------------------
-
-_.extend(Marionette.Region.prototype, Backbone.Events, {
-
-  // Displays a backbone view instance inside of the region.
-  // Handles calling the `render` method for you. Reads content
-  // directly from the `el` attribute. Also calls an optional
-  // `onShow` and `close` method on your view, just after showing
-  // or just before closing the view, respectively.
-  show: function(view){
-
-    this.ensureEl();
-    this.close();
-
-    view.render();
-    this.open(view);
-
-    Marionette.triggerMethod.call(view, "show");
-    Marionette.triggerMethod.call(this, "show", view);
-
-    this.currentView = view;
-  },
-
-  ensureEl: function(){
-    if (!this.$el || this.$el.length === 0){
-      this.$el = this.getEl(this.el);
-    }
-  },
-
-  // Override this method to change how the region finds the
-  // DOM element that it manages. Return a jQuery selector object.
-  getEl: function(selector){
-    return $(selector);
-  },
-
-  // Override this method to change how the new view is
-  // appended to the `$el` that the region is managing
-  open: function(view){
-    this.$el.html(view.el);
-  },
-
-  // Close the current view, if there is one. If there is no
-  // current view, it does nothing and returns immediately.
-  close: function(){
-    var view = this.currentView;
-    if (!view || view.isClosed){ return; }
-
-    if (view.close) { view.close(); }
-    Marionette.triggerMethod.call(this, "close");
-
-    delete this.currentView;
-  },
-
-  // Attach an existing view to the region. This 
-  // will not call `render` or `onShow` for the new view, 
-  // and will not replace the current HTML for the `el`
-  // of the region.
-  attachView: function(view){
-    this.currentView = view;
-  },
-
-  // Reset the region by closing any existing view and
-  // clearing out the cached `$el`. The next time a view
-  // is shown via this region, the region will re-query the
-  // DOM for the region's `el`.
-  reset: function(){
-    this.close();
-    delete this.$el;
-  }
-});
-
-// Copy the `extend` function used by Backbone's classes
-Marionette.Region.extend = Marionette.extend;
-
 // Layout
 // ------
 
@@ -1180,24 +1436,92 @@ Marionette.Layout = Marionette.ItemView.extend({
     }
   },
 
-  // Close all of the regions that have been opened by
-  // this layout. This method is called when the layout
-  // itself is closed.
-  closeRegions: function () {
-    var that = this;
-    _.each(this.regionManagers, function (manager, name) {
-      manager.close();
-    });
-  },
+  // Close all of the regions that have been opened by
+  // this layout. This method is called when the layout
+  // itself is closed.
+  closeRegions: function () {
+    var that = this;
+    _.each(this.regionManagers, function (manager, name) {
+      manager.close();
+    });
+  },
+
+  // Destroys all of the regions by removing references
+  // from the Layout
+  destroyRegions: function(){
+    var that = this;
+    _.each(this.regionManagers, function (manager, name) {
+      delete that[name];
+    });
+    this.regionManagers = {};
+  }
+});
+
+
+
+// AppRouter
+// ---------
+
+// Reduce the boilerplate code of handling route events
+// and then calling a single method on another object.
+// Have your routers configured to call the method on
+// your object, directly.
+//
+// Configure an AppRouter with `appRoutes`.
+//
+// App routers can only take one `controller` object. 
+// It is recommended that you divide your controller
+// objects in to smaller peices of related functionality
+// and have multiple routers / controllers, instead of
+// just one giant router and controller.
+//
+// You can also add standard routes to an AppRouter.
+
+Marionette.AppRouter = Backbone.Router.extend({
+
+  constructor: function(options){
+    Backbone.Router.prototype.constructor.call(this, options);
+
+    if (this.appRoutes){
+      var controller = this.controller;
+      if (options && options.controller) {
+        controller = options.controller;
+      }
+      this.processAppRoutes(controller, this.appRoutes);
+    }
+  },
+
+  // Internal method to process the `appRoutes` for the
+  // router, and turn them in to routes that trigger the
+  // specified method on the specified `controller`.
+  processAppRoutes: function(controller, appRoutes){
+    var method, methodName;
+    var route, routesLength, i;
+    var routes = [];
+    var router = this;
+
+    for(route in appRoutes){
+      if (appRoutes.hasOwnProperty(route)){
+        routes.unshift([route, appRoutes[route]]);
+      }
+    }
+
+    routesLength = routes.length;
+    for (i = 0; i < routesLength; i++){
+      route = routes[i][0];
+      methodName = routes[i][1];
+      method = controller[methodName];
+
+      if (!method){
+        var msg = "Method '" + methodName + "' was not found on the controller";
+        var err = new Error(msg);
+        err.name = "NoMethodError";
+        throw err;
+      }
 
-  // Destroys all of the regions by removing references
-  // from the Layout
-  destroyRegions: function(){
-    var that = this;
-    _.each(this.regionManagers, function (manager, name) {
-      delete that[name];
-    });
-    this.regionManagers = {};
+      method = _.bind(method, controller);
+      router.route(route, methodName, method);
+    }
   }
 });
 
@@ -1285,73 +1609,6 @@ _.extend(Marionette.Application.prototype, Backbone.Events, {
 // Copy the `extend` function used by Backbone's classes
 Marionette.Application.extend = Marionette.extend;
 
-// AppRouter
-// ---------
-
-// Reduce the boilerplate code of handling route events
-// and then calling a single method on another object.
-// Have your routers configured to call the method on
-// your object, directly.
-//
-// Configure an AppRouter with `appRoutes`.
-//
-// App routers can only take one `controller` object. 
-// It is recommended that you divide your controller
-// objects in to smaller peices of related functionality
-// and have multiple routers / controllers, instead of
-// just one giant router and controller.
-//
-// You can also add standard routes to an AppRouter.
-
-Marionette.AppRouter = Backbone.Router.extend({
-
-  constructor: function(options){
-    Backbone.Router.prototype.constructor.call(this, options);
-
-    if (this.appRoutes){
-      var controller = this.controller;
-      if (options && options.controller) {
-        controller = options.controller;
-      }
-      this.processAppRoutes(controller, this.appRoutes);
-    }
-  },
-
-  // Internal method to process the `appRoutes` for the
-  // router, and turn them in to routes that trigger the
-  // specified method on the specified `controller`.
-  processAppRoutes: function(controller, appRoutes){
-    var method, methodName;
-    var route, routesLength, i;
-    var routes = [];
-    var router = this;
-
-    for(route in appRoutes){
-      if (appRoutes.hasOwnProperty(route)){
-        routes.unshift([route, appRoutes[route]]);
-      }
-    }
-
-    routesLength = routes.length;
-    for (i = 0; i < routesLength; i++){
-      route = routes[i][0];
-      methodName = routes[i][1];
-      method = controller[methodName];
-
-      if (!method){
-        var msg = "Method '" + methodName + "' was not found on the controller";
-        var err = new Error(msg);
-        err.name = "NoMethodError";
-        throw err;
-      }
-
-      method = _.bind(method, controller);
-      router.route(route, methodName, method);
-    }
-  }
-});
-
-
 // Module
 // ------
 
@@ -1567,169 +1824,6 @@ _.extend(Marionette.Module, {
   }
 });
 
-// Template Cache
-// --------------
-
-// Manage templates stored in `<script>` blocks,
-// caching them for faster access.
-Marionette.TemplateCache = function(templateId){
-  this.templateId = templateId;
-};
-
-// TemplateCache object-level methods. Manage the template
-// caches from these method calls instead of creating 
-// your own TemplateCache instances
-_.extend(Marionette.TemplateCache, {
-  templateCaches: {},
-
-  // Get the specified template by id. Either
-  // retrieves the cached version, or loads it
-  // from the DOM.
-  get: function(templateId){
-    var that = this;
-    var cachedTemplate = this.templateCaches[templateId];
-
-    if (!cachedTemplate){
-      cachedTemplate = new Marionette.TemplateCache(templateId);
-      this.templateCaches[templateId] = cachedTemplate;
-    }
-
-    return cachedTemplate.load();
-  },
-
-  // Clear templates from the cache. If no arguments
-  // are specified, clears all templates:
-  // `clear()`
-  //
-  // If arguments are specified, clears each of the 
-  // specified templates from the cache:
-  // `clear("#t1", "#t2", "...")`
-  clear: function(){
-    var i;
-    var length = arguments.length;
-
-    if (length > 0){
-      for(i=0; i<length; i++){
-        delete this.templateCaches[arguments[i]];
-      }
-    } else {
-      this.templateCaches = {};
-    }
-  }
-});
-
-// TemplateCache instance methods, allowing each
-// template cache object to manage it's own state
-// and know whether or not it has been loaded
-_.extend(Marionette.TemplateCache.prototype, {
-
-  // Internal method to load the template asynchronously.
-  load: function(){
-    var that = this;
-
-    // Guard clause to prevent loading this template more than once
-    if (this.compiledTemplate){
-      return this.compiledTemplate;
-    }
-
-    // Load the template and compile it
-    var template = this.loadTemplate(this.templateId);
-    this.compiledTemplate = this.compileTemplate(template);
-
-    return this.compiledTemplate;
-  },
-
-  // Load a template from the DOM, by default. Override
-  // this method to provide your own template retrieval,
-  // such as asynchronous loading from a server.
-  loadTemplate: function(templateId){
-    var template = $(templateId).html();
-
-    if (!template || template.length === 0){
-      var msg = "Could not find template: '" + templateId + "'";
-      var err = new Error(msg);
-      err.name = "NoTemplateError";
-      throw err;
-    }
-
-    return template;
-  },
-
-  // Pre-compile the template before caching it. Override
-  // this method if you do not need to pre-compile a template
-  // (JST / RequireJS for example) or if you want to change
-  // the template engine used (Handebars, etc).
-  compileTemplate: function(rawTemplate){
-    return _.template(rawTemplate);
-  }
-});
-
-
-// Renderer
-// --------
-
-// Render a template with data by passing in the template
-// selector and the data to render.
-Marionette.Renderer = {
-
-  // Render a template with data. The `template` parameter is
-  // passed to the `TemplateCache` object to retrieve the
-  // template function. Override this method to provide your own
-  // custom rendering and template handling for all of Marionette.
-  render: function(template, data){
-    var templateFunc = typeof template === 'function' ? template : Marionette.TemplateCache.get(template);
-    var html = templateFunc(data);
-    return html;
-  }
-};
-
-
-// Callbacks
-// ---------
-
-// A simple way of managing a collection of callbacks
-// and executing them at a later point in time, using jQuery's
-// `Deferred` object.
-Marionette.Callbacks = function(){
-  this._deferred = $.Deferred();
-  this._callbacks = [];
-};
-
-_.extend(Marionette.Callbacks.prototype, {
-
-  // Add a callback to be executed. Callbacks added here are
-  // guaranteed to execute, even if they are added after the 
-  // `run` method is called.
-  add: function(callback, contextOverride){
-    this._callbacks.push({cb: callback, ctx: contextOverride});
-
-    this._deferred.done(function(context, options){
-      if (contextOverride){ context = contextOverride; }
-      callback.call(context, options);
-    });
-  },
-
-  // Run all registered callbacks with the context specified. 
-  // 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);
-  },
-
-  // 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;
-    var callbacks = this._callbacks;
-    this._deferred = $.Deferred();
-    this._callbacks = [];
-    _.each(callbacks, function(cb){
-      that.add(cb.cb, cb.ctx);
-    });
-  }
-});
-
-
 
   return Marionette;
 })(Backbone, _, $ || window.jQuery || window.Zepto || window.ender);

metadata

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