extjs-mvc 0.4.0.f → 0.4.0.g

data/lib/src/Presenter.js

@@ -1,52 +0,0 @@
-/**
- * @class ExtMVC.Presenter
- * @extends Ext.util.Observable
- * Used as an interface between a controller and its views
- */
-ExtMVC.Presenter = Ext.extend(Ext.util.Observable, {
-
-  constructor: function(config) {
-    ExtMVC.Presenter.superclass.constructor.apply(this, arguments);
-    
-    this.addEvents(
-      /**
-       * @event load
-       * Fires when all items in the Presenter have been loaded
-       */
-      'load'
-    );
-    
-    /**
-     * @property loaded
-     * @type Boolean
-     * True if all items that must be loaded before rendering have been
-     */
-    this.loaded = false;
-    
-    /**
-     * @property loading
-     * @type Boolean
-     * True while the loader is loading
-     */
-    this.loading = false;
-  },
-  
-  load: function() {
-    if (this.loaded || this.loading) return;
-    
-    this.each(function(item, index, length) {
-      var callback = function(index) {
-        return function() {
-          if (index == length) {
-            this.loaded = true;
-            this.loading = false;
-            
-            this.fireEvent('load');
-          }
-        };
-      }(index);
-      
-      item.on('load', callback, this, {single: true});
-    }, this);
-  }
-});

data/lib/src/README.rdoc

@@ -1,69 +0,0 @@
-= Ext MVC
-
-EXT MVC is a complete MVC stack on top of Ext JS (http://extjs.com).
-
-== Base App
-
-You are advised to use the base app to get up and running with Ext MVC as it sets everything up for you.
-
-If you're comfortable with git:
-
-1. git clone git://github.com/extmvc/baseapp.git myapp
-2. cd myapp
-3. rm -rf .git/
-4. git init
-
-If not:
-
-1. Download the latest zip file from Github at http://github.com/extmvc/baseapp/zipball/master and unzip.
-
-== Getting started
-
-Read the readme file inside the base app and refer to http://extmvc.com
-
-== Building
-
-Ext MVC comes with a set of build tools for itself and your applications, written in Ruby.  You need to be using
-the Baseapp or a structure similar to it for these to work effectively.
-
-=== Building your Ext MVC application
-
-Build any app started from the base app by running this from the app's root directory:
-
-ruby script/build all
-
-This will examine the contents of index.html, pull out all of the javascript includes and concatenate them into
-public/application-all.js.  If you have the yui-compressor in your vendor directory (this is included by default)
-and you have java installed, the build process will also minify your application-all.js into application-all-min.js.
-
-Building your app also concatenates any CSS includes in index.html into public/application-all.css.
-
-*NOTE*: Building looks at your index.html, NOT public/index.html.  index.html is your development version, 
-public/index.html should simply include those concatenated/minified files.
-
-=== Autobuild
-
-If you need your app to be built every time you change any of the source files for whatever reason, use:
-
-ruby script/build auto
-
-This will again look at index.html and will force a rebuild any time any of those files are changed.
-
-=== Other app build options
-
-There are several other build commands, most of which are used by the two above:
-
-- ruby script/build css            - only build CSS files, no JS concatenation or minification
-- ruby script/build js             - only builds JS files, not CSS
-- ruby script/build concatenate_js - concatenates but does not attempt to minify your JS
-- ruby script/build minify_js      - minifies an already concatenated public/application-all.js file
-
-=== Building Ext MVC
-
-If you are changing Ext MVC files and need to build Ext MVC itself, use:
-
-- ruby script/build mvc
-- ruby script/build mvc_auto
-
-Again run from the app root directory.  Like with ruby script/build auto, mvc_auto automatically rebuilds whenever
-any Ext MVC file is changed.

data/lib/src/controller/Controller.js

@@ -1,278 +0,0 @@
-/**
- * @class ExtMVC.controller.Controller
- * @extends Ext.util.Observable
- * <h1>Controllers in Ext MVC</h1>
- * <p>Controllers are the glue that stick applications together. They listen to events emitted by the UI as the user
- * clicks interface elements, and take actions as appropriate. The relevant action may be to create or save a model
- * instance, to render another view, to perform AJAX requests, or any other action.</p>
- * 
- * <p>Controllers should be kept skinny as far as possible - receive an event, then hand any processing off to the 
- * appropriate model. This ensures we can keep the code as DRY as possible and makes refactoring easier.</p>
- * 
- * <h2>Example Controller</h2>
- * Here is a simple example controller which renders a couple of views and listens to events:
-<pre><code>
-//simple controller which manages the Page model within our application
-MyApp.controllers.PagesController = Ext.extend(ExtMVC.controller.Controller, {
-  name: 'pages',
-
-  //renders the 'Index' template and sets up listeners
-  index: function() {
-    this.render('Index', {
-      listeners: {
-        scope   : this,
-        'edit'  : this.edit,
-        'delete': this.destroy
-      }
-    });
-  },
-
-  //renders the 'Edit' template (let's say it's a FormPanel), and loads the instance
-  edit: function(instance) {
-    this.render('Edit', {
-      listeners: {
-        scope  : this,
-        save   : this.update,
-        cancel : function() {
-          alert("You cancelled the update!");
-        }
-      }
-    }).loadRecord(instance);
-  },
-
-  //when the 'delete' event is fired by our 'Index' template (see the index action), this method is called.
-  //In this fictional example, we assume that the templates 'delete' event was called with the single argument
-  //of the Page instance the user wishes to destroy
-  destroy: function(instance) {
-    instance.destroy({
-      success: function() {
-        alert("The Page was deleted");
-        //at this point we might render another page for the user to look at
-      },
-      failure: function() {
-        alert('Curses! The Page could not be deleted');
-      }
-    });
-  },
-
-  //when the 'save' event is fired by our 'Edit' template, this method is called.
-  //Again, we assume that our template fired the event with the Page instance, and also an object with updates
-  update: function(instance, updates) {
-    //this applies the updates to the model instance and saves
-    instance.update(updates, {
-      success: function(updatedInstance) {
-        alert('Success! It saved');
-        //at this point we might render another page for the user to look at
-      },
-      failure: function(updatedInstance) {
-        alert('Darn it. Did not save');
-
-        //here we're firing the controller's update-failed event, which the view can pick up on
-        //The view can simply listen to our Pages controller and add errors from this instance to the form
-        //using form.markInvalid(instance.errors.forForm())
-        this.fireEvent('update-failed', instance);
-      };
-    });
-  },
-
-   //Sets up events emitted by this controller. Controllers are expected to fire events, so this method is called
-   //automatically when a controller is instantiated. Don't forget to call super here
-  initEvents: function() {
-    this.addEvents(
-      //this event will be fired when the controller can't update a Page instance
-      'update-failed'
-    );
-
-    MyApp.controllers.PagesController.superclass.initEvents.apply(this, arguments);
-  }
-})
-</code></pre>
- * Note that many of the methods above are provided by the {@link ExtMVC.controller.CrudController CrudController}
- * 
- * <h2>Rendering Views</h2>
- * Each controller can automatically render view classes inside its views package. In the Pages controller above the
- * views package is MyApp.views.pages - the application itself is called MyApp, and the 'pages' segment comes from the
- * controller's 'name' property
- * <br />
- * <br />
- * In the example above, the line: <pre><code>this.render('Edit', {})</code></pre> will automatically find the
- * MyApp.views.pages.Edit class, with the second argument to this.render being a config argument passed to the view's constructor.
- * 
- * <br />
- * <h4>Rendering strategies</h4>
- * Not all applications will render views in the same way
- */
-// ExtMVC.controller.Controller = Ext.extend(Ext.util.Observable,
-ExtMVC.registerController('controller', {
-
-  constructor: function(config) {
-    Ext.util.Observable.prototype.constructor.apply(this, arguments);
-    
-    Ext.apply(this, {
-      /**
-       * @property renderStrategies
-       * @type Object
-       * An object of the form {xtype: function} which keys a container's xtype to the function to use
-       * when rendering a view to that container (see registerRenderStrategy)
-       */
-      renderStrategies: {}
-    }, config || {});
-    
-    this.registerDefaultRenderStrategies();
-    
-    this.initEvents();
-    this.initListeners();
-  },
-  
-  /**
-   * Registers a rendering function for a given container xtype. When a view is rendered via this.render,
-   * the xtype of the container it is being rendered to is compared to the registered strategy xtypes, and
-   * the most specific match will be used to perform the rendering.
-   * @param {String} xtype The container xtype to register
-   * @param {Function} strategy The function to call when rendering to a container of the given xtype
-   */
-  registerRenderStrategy: function(xtype, strategy) {
-    this.renderStrategies[xtype] = strategy;
-  },
-  
-  /**
-   * Returns the strategy function to use when rendering to the given container instance.
-   * @param {Ext.Container} container The container to add to
-   * @return {Function} The rendering strategy to use
-   */
-  getRenderStrategy: function(container) {
-    var xtypes = container.getXTypes().split("/");
-    
-    for (var i = xtypes.length - 1; i >= 0; i--){
-      var strategy = this.renderStrategies[xtypes[i]];
-      
-      if (strategy != undefined) return strategy;
-    };
-    
-    throw new Ext.Error("No render strategy could be found for the container you specified");
-  },
-  
-  /**
-   * @private
-   * Adds the default strategies for panel and tabpanel
-   */
-  registerDefaultRenderStrategies: function() {
-    this.registerRenderStrategy('panel', this.panelRenderStrategy);
-    this.registerRenderStrategy('tabpanel', this.tabPanelRenderStrategy);
-  },
-  
-  /**
-   * Sets up events emitted by this controller. This defaults to an empty function and is
-   * called automatically when the controller is constructed so can simply be overridden
-   */
-  initEvents: function() {},
-  
-  /**
-   * Sets up events this controller listens to, and the actions the controller should take
-   * when each event is received.  This defaults to an empty function and is called when
-   * the controller is constructed so can simply be overridden
-   */
-  initListeners: function() {},
-  
-  /**
-   * Shows the user a notification message. Usually used to inform user of a successful save, deletion, etc
-   * This is an empty function which you must implement yourself
-   * @param {String} notice The string notice to display
-   */
-  showNotice: function(notice) {},
-  
-  /**
-   * @property addTo
-   * @type Ext.Container
-   * The container to add views to using the 'add' renderMethod.  Usually set to an Ext.TabPanel instance or similar
-   */
-  addTo: null,
-  
-  /**
-   * Renders a given view name in the way set up by the controller.  For this to work you must have passed a 
-   * 'name' property when creating the controller, which is automatically used to find the view namespace for
-   * this controller.  For example, in an application called MyApp, and a controller with a name of 'users',
-   * the view namespace would be MyApp.views.users, and render('Index') would search for a class called
-   * MyApp.views.users.Index and instantiate it with the passed config.
-   * An error is thrown if the view could not be found.
-   * @param {String} viewName The name of the view class within the view namespace used by this controller
-   * @param {Object} config Configuration options passed through to the view class' constructor
-   * @return {Ext.Component} The view object that was just created
-   */
-  render: function render() {
-    //handle both method signatures
-    switch(arguments.length) {
-      case 1:
-        //this just falls through into case 2, which provides a config {} if one is not supplied
-      case 2:
-        var namespace = this.name,
-            viewName  = arguments[0],
-            config    = arguments[1] || {};
-        break;
-      case 3:
-        var namespace = arguments[0],
-            viewName  = arguments[1],
-            config    = arguments[2] || {};
-        break;
-    }
-    
-    //we also use this constructor object to define whether or not the view should be added to the default
-    //container or not
-    Ext.applyIf(config, { 
-      autoAdd: true,
-      addTo  : ExtMVC.app.main
-    });
-    
-    //NOTE: ExtMVC.getView will throw an error if the view hasn't been defined anywhere yet. At the moment this
-    //error will just propagate up as it's probably pretty clear, but we could provide a custom Error message here instead
-    var view = new (this.getView(namespace, viewName))(config);
-    
-    if (config.autoAdd === true) {
-      if (view.isXType('window')) {
-        view.show();
-      } else {
-        this.getRenderStrategy(config.addTo)(config.addTo, view);
-      }
-    }
-
-    return view;
-  },
-  
-  /**
-   * Just calls ExtMVC.getView and returns. This is here because we override it in Crud Controller
-   * @param {String} namespace The view namespace
-   * @param {String} name The view name
-   * @return {Function} The view constructor function
-   */
-  getView: function(namespace, name) {
-    return ExtMVC.getView(namespace, name);
-  },
-  
-  /**
-   * @private
-   * The tabpanel render strategy
-   */
-  tabPanelRenderStrategy: function(container, view) {
-    var existing = container.getItem(view.id);
-    
-    //don't add a tab with the same id as an existing one
-    if (existing == undefined) {
-      container.add(view);
-      container.doLayout();
-      container.activate(view);      
-    } else {
-      container.setActiveTab(view.id);
-      view.destroy();
-    }
-  },
-  
-  /**
-   * @private
-   * The panel render strategy
-   */
-  panelRenderStrategy: function(container, view) {
-    container.removeAll();
-    container.add(view);
-    container.doLayout();
-  }
-});

data/lib/src/controller/CrudController.js

@@ -1,460 +0,0 @@
-/**
- * @class ExtMVC.controller.CrudController
- * @extends ExtMVC.controller.Controller
- * <h1>CRUD Controller</h1>
- * <p>The CRUD Controller is an extension of Controller which provides the generic CRUD actions (Create, Read, Update and Delete).
- * Although CRUD Controller provides sensible default options for most cases, it is also highly extensible. Here's an example for
- * managing CRUD operations on a fictional 'Page' model in our app. Note that the name and model are the only required properties
- * for a CRUD controller with default behaviour:</p>
-<pre><code>
-MyApp.controllers.PagesController = Ext.extend(ExtMVC.controller.CrudController, {
-  //the name of the controller (see {@link ExtMVC.controller.Controller})
-  name : 'pages',
-  
-  //The model that this controller will be providing CRUD services for
-  model: MyApp.models.Page,
-  
-  //override the default behaviour that occurs when the 'create' action was successfully completed
-  onCreateSuccess: function(instance) {
-    alert('new Page successfully created!');
-  },
-  
-  //override the listeners that are attached to the Index view. The Index view is usually an instance of
-  //{@link ExtMVC.view.scaffold.Index} or a subclass of it.
-  getIndexViewListeners: function() {
-    return {
-      scope : this,
-      'edit': function(instance) {
-        alert('inside the Index view (usually a scaffold grid), the user wants to edit an instance');
-      }
-    };
-  },
-  
-  //provide our own implementation for destroy
-  destroy: function(instance) {
-    alert('user wants to destroy an instance');
-  }
-});
-</code></pre>
- * 
- * <p>The 3 CRUD Controller methods that take action are create, update and destroy<p>
- * <p>The 3 CRUD Controller methods that render views are index, new and edit</p>
- * <p>By default, CRUD Controllers render the scaffolding views, which provide sensible default views.
- * The index action renders a {@link ExtMVC.view.scaffold.Index Scaffold Grid}, edit renders a 
- * {@link ExtMVC.view.scaffold.Edit Scaffold Edit Form} and new renders a {@link ExtMVC.view.scaffold.New Scaffold New Form}</p>
- * <p>To make CRUD controller render a customised view instead of the scaffold, simply define the relevant view and ensure it is
- * available within your code. For example, if you want to show a customised Ext.Panel instead of the Scaffold Grid on index,
- * simply define:</p>
-<pre><code>
-MyApp.views.pages.Index = Ext.extend(Ext.Panel, {
-  title: 'My Specialised Index view - replaces the scaffold grid'
-});
-</code></pre>
- * <p>The same applies with Edit and New classes within the appropriate views namespace. See more on view namespaces in
- * {@link ExtMVC.controller.Controller Controller}.</p>
- */
-ExtMVC.registerController('crud', {
-  extend: "controller",
-  
-  /**
-   * @property model
-   * @type Function/Null
-   * Defaults to null.  If set to a reference to an ExtMVC.model subclass, renderView will attempt to dynamically
-   * scaffold any missing views, if the corresponding view is defined in the ExtMVC.view.scaffold package
-   */
-  model: null,
-
-  /**
-   * Attempts to create a new instance of this controller's associated model
-   * @param {Object} data A fields object (e.g. {title: 'My instance'})
-   */
-  create: function create(data, form) {
-    var instance = new this.model(data);
-
-    instance.save({
-      scope:   this,
-      success: this.onCreateSuccess,
-      failure: this.onCreateFailure
-    });
-  },
-  
-  /**
-   * Attempts to find (read) a single model instance by ID
-   * @param {Number} id The Id of the instance to read
-   */
-  read: function read(id) {
-    this.model.findById(id, {
-      scope: this,
-      success: function(instance) {
-        this.fireEvent('read', instance);
-      },
-      failure: function() {
-        this.fireEvent('read-failed', id);
-      }
-    });
-  },
-  
-  /**
-   * Attempts to update an existing instance with new values.  If the update was successful the controller fires
-   * the 'update' event and then shows a default notice to the user (this.showUpdatedNotice()) and calls this.index().
-   * To cancel this default behaviour, return false from any listener on the 'update' event.
-   * @param {ExtMVC.model.Base} instance The existing instance object
-   * @param {Object} updates An object containing updates to apply to the instance
-   */
-  update: function update(instance, updates) {
-    for (var key in updates) {
-      instance.set(key, updates[key]);
-    }
-    
-    instance.save({
-      scope:   this,
-      success: function(instance) {
-        this.onUpdateSuccess(instance, updates);
-      },
-      failure: function() {
-        this.onUpdateFailure(instance, updates);
-      }
-    });
-  },
-  
-  /**
-   * Attempts to delete an existing instance
-   * @param {Mixed} instance The ExtMVC.model.Base subclass instance to delete.  Will also accept a string/number ID
-   */
-  destroy: function destroy(instance) {
-    if (instance.destroy == undefined) {
-      //if we're passed an ID instead of an instance, make a fake model instance
-      var config = {};
-      config[this.model.prototype.primaryKey] = parseInt(instance, 10);
-      var instance = new (this.model)(config);
-    }
-
-    instance.destroy({
-      scope:   this,
-      success: this.onDestroySuccess,
-      failure: this.onDestroyFailure
-    });
-  },
-  
-  /**
-   * Renders the custom Index view if present, otherwise falls back to the default scaffold grid
-   * @param {Object} config Optional config object to be passed to the view's constructor
-   */
-  index: function index(config) {
-    config = config || {};
-    
-    Ext.applyIf(config, {
-      model       : this.model,
-      controller  : this,
-      listeners   : this.getIndexViewListeners(),
-      viewsPackage: this.viewsPackage
-    });
-    
-    var index = this.render('index', config);
-    
-    this.fireEvent('index');
-    
-    return index;
-  },
-  
-  /**
-   * Renders the custom New view if present, otherwise falls back to the default scaffold New form
-   */
-  build: function build() {
-    var buildView = this.render('new', {
-      model       : this.model,
-      controller  : this,
-      listeners   : this.getBuildViewListeners()
-      // items       : ExtMVC.getFields(this.name)
-    });
-    
-    this.onBuild(buildView);
-    
-    return buildView;
-  },
-
-  /**
-   * Renders the custom Edit view if present, otherwise falls back to the default scaffold Edit form
-   * @param {Mixed} instance The model instance to edit. If not given an ExtMVC.model.Base
-   * instance, a findById() will be called on this controller's associated model
-   * @param {Object} viewConfig Optional config object to pass to the view class constructor
-   */
-  edit: function edit(instance, viewConfig) {
-    viewConfig = viewConfig || {};
-    
-    if (instance instanceof Ext.data.Record) {
-      Ext.applyIf(viewConfig, {
-        model       : this.model,
-        controller  : this,
-        listeners   : this.getEditViewListeners(),
-        // items       : ExtMVC.getFields(this.name),
-        id          : String.format("{0}_edit_{1}", this.name, instance.get(instance.primaryKey))        
-      });
-      
-      var editView = this.render('edit', viewConfig);
-      
-      editView.loadRecord(instance);
-      
-      this.onEdit(editView, instance);
-      this.fireEvent('edit', instance);
-      
-      return editView;
-    } else {
-      var id = instance;
-      
-      this.model.find(parseInt(id, 10), {
-        scope  : this,
-        success: function(instance) {
-          this.edit(instance);
-        }
-      });
-    }
-  },
-  
-  /**
-   * Returns a listeners object passed to the Index view when rendered inside the index action. This contains 
-   * default listeners, but can be overridden in subclasses to provide custom behaviour
-   * @return {Object} The listeners object
-   */
-  getIndexViewListeners: function getIndexViewListeners() {
-    return {
-      scope   : this,
-      'delete': this.destroy,
-      'new'   : this.build,
-      'edit'  : this.edit
-    };
-  },
-  
-  /**
-   * Returns a listeners object passed to the Edit view when rendered inside the edit action. This contains 
-   * default listeners, but can be overridden in subclasses to provide custom behaviour
-   * @return {Object} The listeners object
-   */
-  getEditViewListeners: function getEditViewListeners() {
-    return {
-      scope : this,
-      cancel: this.index,
-      save  : this.update
-    };
-  },
-  
-  /**
-   * Returns a listeners object passed to the New view when rendered inside the build action. This contains 
-   * default listeners, but can be overridden in subclasses to provide custom behaviour
-   * @return {Object} The listeners object
-   */
-  getBuildViewListeners: function getBuildViewListeners() {
-    return {
-      scope : this,
-      cancel: this.index,
-      save  : this.create
-    };
-  },
-  
-  /**
-   * Called when an instance has been successfully created.  This just calls this.showNotice
-   * with a default message for this model. Overwrite to provide your own implementation
-   */
-  showCreatedNotice: function() {
-    this.showNotice(String.format("{0} successfully created", this.model.prototype.singularHumanName));
-  },
-  
-  /**
-   * Called when an instance has been successfully updated.  This just calls this.showNotice
-   * with a default message for this model. Overwrite to provide your own implementation
-   */
-  showUpdatedNotice: function() {
-    this.showNotice(String.format("{0} successfully updated", this.model.prototype.singularHumanName));    
-  },
-  
-  /**
-   * Called when an instance has been successfully destroyed.  This just calls this.showNotice
-   * with a default message for this model. Overwrite to provide your own implementation
-   */
-  showDestroyedNotice: function() {
-    this.showNotice(String.format("{0} successfully deleted", this.model.prototype.singularHumanName));    
-  },
-  
-  /**
-   * Called after a successful update. By default this calls showUpdatedNotice and then this.index()
-   * @param {ExtMVC.model.Base} instance The newly updated instance
-   * @param {Object} updates The updates that were made
-   */
-  onCreateSuccess: function(instance) {
-    if(this.fireEvent('create', instance) !== false) {
-      this.showCreatedNotice();
-      this.index();
-    }
-  },
-  
-  /**
-   * Called after an unsuccessful update. By default this simply fires the 'update-failed' event
-   * @param {ExtMVC.model.Base} instance The instance that could not be updated
-   * @param {Object} updates The updates that were attempted to be made
-   */
-  onCreateFailure: function(instance) {
-    this.fireEvent('create-failed', instance);
-  },
-  
-  /**
-   * Called after a successful update. By default this calls showUpdatedNotice and then this.index()
-   * @param {ExtMVC.model.Base} instance The newly updated instance
-   * @param {Object} updates The updates that were made
-   */
-  onUpdateSuccess: function(instance, updates) {
-    if (this.fireEvent('update', instance, updates) !== false) {
-      this.showUpdatedNotice();
-      this.index();          
-    }
-  },
-  
-  /**
-   * Called after an unsuccessful update. By default this simply fires the 'update-failed' event
-   * @param {ExtMVC.model.Base} instance The instance that could not be updated
-   * @param {Object} updates The updates that were attempted to be made
-   */
-  onUpdateFailure: function(instance, updates) {
-    this.fireEvent('update-failed', instance, updates);
-  },
-  
-  /**
-   * Called after successful destruction of a model instance. By default simply fires the 'delete' event
-   * with the instance as a single argument
-   * @param {ExtMVC.model.Base} instance The instane that was just destroyed
-   */
-  onDestroySuccess: function(instance) {
-    this.fireEvent('delete', instance);
-    
-    this.showDestroyedNotice();
-  },
-  
-  /**
-   * Called after unsuccessful destruction of a model instance. By default simply fires the 'delete-failed' event
-   * with the instance as a single argument
-   * @param {ExtMVC.model.Base} instance The instance that could not be destroyed
-   */
-  onDestroyFailure: function(instance) {
-    this.fireEvent('delete-failed', instance);
-  },
-  
-  /**
-   * Called whenever the 'New' form has been rendered for a given instance. This is an empty function by default,
-   * which you can override to provide your own logic if needed
-   * @param {Ext.Component} form The rendered 'New' form
-   */
-  onBuild: function(form) {},
-  
-  /**
-   * Called whenever the Edit form has been rendered for a given instance. This is an empty function by default,
-   * which you can override to provide your own logic if needed
-   * @param {Ext.Component} form The rendered Edit form
-   * @param {ExtMVC.model.Base} instance The instance loaded into the form
-   */
-  onEdit: function(form) {},
-  
-  /**
-   * Sets up events emitted by the CRUD Controller's actions
-   */
-  initEvents: function() {
-    this.addEvents(
-      /**
-       * @event create
-       * Fired when a new instance has been successfully created
-       * @param {ExtMVC.model.Base} instance The newly created model instance
-       */
-      'create',
-      
-      /**
-       * @event create-failed
-       * Fired when an attempt to create a new instance failed
-       * @param {ExtMVC.model.Base} instance The instance object which couldn't be saved
-       */
-      'create-failed',
-      
-      /**
-       * @event read
-       * Fired when a single instance has been loaded from the database
-       * @param {ExtMVC.model.Base} instance The instance instance that was loaded
-       */
-      'read',
-      
-      /**
-       * @event read-failed
-       * Fired when an attempt to load a single instance failed
-       * @param {Number} id The ID of the instance we were attempting to find
-       */
-      'read-failed',
-      
-      /**
-       * @event update
-       * Fired when an existing instance has been successfully created
-       * @param {ExtMVC.model.Base} instance The updated instance
-       * @param {Object} updates The updates object that was supplied
-       */
-      'update',
-      
-      /**
-       * @event update-failed
-       * Fired when an attempty to update an existing instance failed
-       * @param {ExtMVC.model.Base} instance The instance we were attempting to update
-       * @param {Object} updates The object of updates we were trying to apply
-       */
-      'update-failed',
-      
-      /**
-       * @event delete
-       * Fired when an existing instance has been successfully deleteed
-       * @param {ExtMVC.model.Base} instance The instance that was deleteed
-       */
-      'delete',
-      
-      /**
-       * @event delete-failed
-       * Fired when an attempt to delete an existing instance failed
-       * @param {ExtMVC.model.Base} instance The instance we were trying to delete
-       */
-      'delete-failed',
-      
-      /**
-       * @event index
-       * Fired when an instances collection has been loaded from the database
-       */
-      'index',
-      
-      /**
-       * @event edit
-       * Fired when an instance is being edited
-       * @param {ExtMVC.model.Base} instance The instance being edited
-       */
-      'edit'
-    );
-  },
-  
-  /**
-   * If a view of the given viewName is defined in this controllers viewPackage, a reference to its
-   * constructor is defined.  If not, a reference to the default scaffold for the viewName is returned
-   * @param {String} namespace The view namesapce
-   * @param {String} name The name of the view to return a constructor function for
-   * @return {Function} A reference to the custom view, or the scaffold fallback
-   */
-  getView: function getView(namespace, name) {
-    var view;
-    
-    try {
-      view = ExtMVC.getController("controller").getView.apply(this, arguments);
-    } catch(e) {
-      view = this.scaffoldViewName(name);
-    }
-    
-    return view;
-  },
-  
-  /**
-   * Returns a reference to the Scaffold view class for a given viewName
-   * @param {String} viewName The name of the view to return a class for (index, new, edit or show)
-   * @return {Function} A reference to the view class to instantiate to render this scaffold view
-   */
-  scaffoldViewName: function scaffoldViewName(viewName) {
-    return ExtMVC.getView('scaffold', viewName);
-  }
-});