extjs-mvc 0.3.10 → 0.4.0.a

data/lib/js/lib/Router.js

@@ -0,0 +1,282 @@
+/**
+ * @class ExtMVC.router.Router
+ * @extends Object
+ * TODO: [DOCS] Give a good description of the Router
+ */
+ExtMVC.router.Router = function() {};
+
+ExtMVC.router.Router.prototype = {
+  
+  /**
+   * @property mappings
+   * @type Array
+   * Readonly. Maintains the collection of defined routes
+   */
+  mappings: [],
+  
+  /**
+   * @property namedRoutes
+   * @type Object
+   * Readonly. Maintains the collection of named routes
+   */
+  namedRoutes: {},
+  
+  /**
+   * Adds a new route to the collection.  Routes are given priority in the order they are added
+   * @param {String} re The regular expression-style string to match (e.g. ":controller/:action/:id")
+   * @param {Object} additional_params Any additional options which will be returned along with the match elements if the route matches
+   * @return {ExtMVC.router.Route} The newly created route object
+   */
+  connect: function(re, additional_params) {
+    var route = new ExtMVC.router.Route(re, additional_params);
+    this.mappings.push(route);
+    
+    return route;
+  },
+  
+  /**
+   * Defines a named route.  This is the same as using connect, but with the option to specify the route by name.  e.g.:
+   * this.name('myRoute', 'my/custom/route/:id', {controller: 'myController', action: 'myAction'});
+   * this.urlFor('myRoute', {id: 100}); //returns 'my/custom/route/100'
+   * @param {String} routeName The string name to give this route
+   * @param {String} re The regular expression-style string to match (e.g. ":controller/:action/:id")
+   * @param {Object} additional_params Any additional options which will be returned along with the match elements if the route matches
+   */
+  name: function(routeName, re, additional_params) {
+    this.namedRoutes[routeName] = this.connect(re, additional_params);
+  },
+  
+  /**
+   * Same as calling connect("", options) - connects the empty route string to a controller/action pair
+   * @params {Object} options An object containing at least a controller and optionally an action (which is otherwise defaulted to index)
+   */
+  root: function(options) {
+    var options = options || {};
+    this.connect("", Ext.applyIf(options, { action: 'index' }));
+  },
+  
+  /**
+   * Adds specific index, new, show and edit routes for this resource. e.g.:
+   * resources('videos') is equivalent to:
+   * name('videos_path',     'videos',          {controller: 'videos', action: 'index'});
+   * name('new_video_path',  'videos/new',      {controller: 'videos', action: 'new'  });
+   * name('video_path',      'videos/:id',      {controller: 'videos', action: 'show' });
+   * name('edit_video_path', 'videos/:id/edit', {controller: 'videos', action: 'edit' });
+   *
+   * You can pass a second parameter which is an options object, e.g.:
+   * resources('videos', {controller: 'myController', myKey: 'myValue'}) sets up the following:
+   * name('videos_path',     'videos',          {controller: 'myController', myKey: 'myValue', action: 'index'});
+   * name('new_video_path',  'videos/new',      {controller: 'myController', myKey: 'myValue', action: 'new'  });
+   * name('video_path',      'videos/:id',      {controller: 'myController', myKey: 'myValue', action: 'show' });
+   * name('edit_video_path', 'videos/:id/edit', {controller: 'myController', myKey: 'myValue', action: 'edit' });
+   * 
+   * Also accepts a series of arguments - resources('videos', 'bookmarks', 'messages')
+   * is the same as calling resources with each
+   *
+   * Finally, this format is also accepted:
+   * resources('videos', 'bookmarks', 'messages', {controller: 'myController', myKey: 'myValue'})
+   * Which is equivalent to calling resources with each of the three strings in turn, each with the
+   * final argument passed as options
+   */
+  resources: function(resource_name, options) {
+    //if we have been passed a bunch of strings, call resources with each
+    if (arguments[1] && typeof(arguments[1]) == 'string') {
+      var lastArg = arguments[arguments.length - 1];
+      
+      var opts = (typeof(lastArg) == 'object') ? lastArg : {};
+      
+      for (var i=0; i < arguments.length; i++) {
+        //don't call with the last argument if it is an object as this is a generic settings object
+        if (!(lastArg === arguments[i] && typeof(lastArg) == 'object')) {
+          this.resources(arguments[i], opts);
+        };
+      };
+      
+      return;
+    };
+    
+    //work out the named route names for index, show, new and edit actions
+    var indexName = String.format("{0}_path",      resource_name.pluralize()  );
+    var newName   = String.format("new_{0}_path",  resource_name.singularize());
+    var showName  = String.format("{0}_path",      resource_name.singularize());
+    var editName  = String.format("edit_{0}_path", resource_name.singularize());
+    
+    //add named routes for index, new, edit and show
+    this.name(indexName, resource_name,               Ext.apply({}, {controller: resource_name, action: 'index'}));
+    this.name(newName,   resource_name + '/new',      Ext.apply({}, {controller: resource_name, action: 'new'  }));
+    this.name(showName,  resource_name + '/:id',      Ext.apply({}, {controller: resource_name, action: 'show', conditions: {':id': "[0-9]+"}}));
+    this.name(editName,  resource_name + '/:id/edit', Ext.apply({}, {controller: resource_name, action: 'edit', conditions: {':id': "[0-9]+"}}));
+  },
+  
+  /**
+   * Given a hash containing at route segment options (e.g. {controller: 'index', action: 'welcome'}),
+   * attempts to generate a url and redirect to it using Ext.History.add.
+   * All arguments are passed through to this.urlFor()
+   * @param {Object} options An object containing url segment options (such as controller and action)
+   * @return {Boolean} True if a url was generated and redirected to
+   */
+  redirectTo: function() {
+    var url = this.urlFor.apply(this, arguments);
+    if (url) {
+      Ext.History.add(url);
+      return true;
+    } else return false;
+  },
+  
+  /**
+   * Constructs and returns a config object for a Ext.History based link to a given url spec.  This does not create
+   * an Ext.Component, only a shortcut to its config.  This is intended for use in quickly generating menu items
+   * @param {Object} urlOptions A standard url generation object, e.g. {controller: 'index', action: 'welcome'}
+   * @param {Object} linkOptions Options for the link itself, e.g. {text: 'My Link Text'}
+   * @return {Object} a constructed config object for the given parameters
+   */
+  linkTo: function(urlOptions, linkOptions) {
+    var linkOptions = linkOptions || {};
+    
+    var url = this.urlFor(urlOptions);
+    if (url) {
+      return Ext.applyIf(linkOptions, {
+        url:     url,
+        cls:     [urlOptions.controller, urlOptions.action, urlOptions.id].join("-").replace("--", "-").replace(/-$/, ""),
+        text:    this.constructDefaultLinkToName(urlOptions, linkOptions),
+        handler: function() {Ext.History.add(url);}
+      });
+    } else throw new Error("No match for that url specification");
+  },
+  
+  /**
+   * Attempts to create good link name for a given object containing action and controller.  Override with your own 
+   * function to create custom link names for your app
+   * @param {Object} urlOptions An object containing at least controller and action properties
+   * @param {Object} linkOptions An object of arbitrary options for the link, initially passed to linkTo.  Not used
+   * in default implementation but could be useful when overriding this method
+   * @return {String} The best-guess link name for the given params.
+   */
+  constructDefaultLinkToName: function(urlOptions, linkOptions) {
+    if (!urlOptions || !urlOptions.controller || !urlOptions.action) {return "";}
+    var linkOptions = linkOptions || {};
+    
+    Ext.applyIf(linkOptions, {
+      singularName: urlOptions.controller.singularize()
+    });
+    
+    var actionName = urlOptions.action.titleize();
+    if (actionName == 'Index') {
+      return "Show " + urlOptions.controller.titleize();
+    } else {
+      return actionName + " " + linkOptions.singularName.titleize();
+    }
+  },
+  
+  /**
+   * @params {String} url The url to be matched by the Router.  Router will match against
+   * all connected matchers in the order they were connected and return an object created
+   * by parsing the url with the first matching matcher as defined using the connect() method
+   * @returns {Object} Object of all matches to this url
+   */
+  recognise: function(url) {
+    for (var i=0; i < this.mappings.length; i++) {
+      var m = this.mappings[i];
+      var match = m.matchesFor(url);
+      if (match) { return match; }
+    };
+    
+    return false;
+  },
+  
+  /**
+   * Takes an object of url generation options such as controller and action.  Returns a generated url.
+   * For a url to be generated, all of these options must match the requirements of at least one route definition
+   * @param {Object/String} options An object containing url options, or a named route string.
+   * @param {Object} namedRouteOptions If using a named route, this object is passed as additional parameters.  e.g:
+   * this.name('myRoute', 'my/custom/route/:id', {controller: 'myController', action: 'myAction'});
+   * this.urlFor('myRoute', {id: 100}); //returns 'my/custom/route/100'
+   * this.urlFor('myRoute', 100);       //returns 'my/custom/route/100' - number argument assumed to be an ID
+   * this.urlFor('myRoute', modelObj);  //returns 'my/custom/route/100' if modelObj is a model object where modelObj.data.id = 100
+   * @return {String} The generated url, or false if there was no match
+   */
+  urlFor: function(options, namedRouteOptions) {
+    var route;
+    
+    //named route
+    if (typeof(options) == 'string') {
+      if (route = this.namedRoutes[options]) {
+        var namedRouteOptions = namedRouteOptions || {};
+        
+        //normalise named route options in case we're passed an integer
+        if (typeof(namedRouteOptions) == 'number') {
+          namedRouteOptions = {id: namedRouteOptions};
+        };
+        
+        //normalise named route options in case we're passed a model instance
+        if (namedRouteOptions.data && namedRouteOptions.data.id) {
+          namedRouteOptions = {id: namedRouteOptions.data.id};
+        };
+        
+        return route.urlForNamed(namedRouteOptions);
+      };
+    } 
+    //non-named route
+    else {
+      for (var i=0; i < this.mappings.length; i++) {
+        route = this.mappings[i]; var u = route.urlFor(options);
+        if (u) { return u; }
+      };
+    };
+    
+    //there were no matches so return false
+    return false;
+  },
+
+  /**
+   * Immediately redirects to the specified route.
+   * @param {String} route The route 
+   */
+  route: function(route) {
+    document.location.hash = route;
+  },
+
+  /**
+   * Creates a handler for redirecting to the specified route
+   * @param {String} route The route
+   * @return {Function} handler A function that redirects to the route
+   */
+  handleRoute: function(url) {
+    return this.route.createDelegate(this, [url]);
+  },
+  
+  //experimental...
+  withOptions: function(options, routes) {
+    var options = options || {};
+    
+    var defaultScope = this;
+    var optionScope  = {};
+    
+    optionScope.prototype = this;
+    Ext.apply(optionScope, {
+      connect: function(re, additional_params) {
+        var additional_params = additional_params || {};
+        Ext.applyIf(additional_params, options);
+        
+        defaultScope.connect.call(defaultScope, re, additional_params);
+      },
+      
+      name: function(routeName, re, additional_params) {
+        var additional_params = additional_params || {};
+        Ext.applyIf(additional_params, options);
+        
+        defaultScope.name.call(defaultScope, routeName, re, additional_params);
+      }
+    });
+    
+    routes.call(this, optionScope);
+  }
+};
+
+/**
+ * Basic default routes.  Redefine this method inside config/routes.js
+ */
+ExtMVC.router.Router.defineRoutes = function(map) {
+  map.connect(":controller/:action");
+  map.connect(":controller/:action/:id");
+};

data/lib/js/lib/String.js

@@ -0,0 +1,94 @@
+/**
+ * @class String
+ * Extensions to the String class
+ **/
+
+/**
+ * Capitalizes a string (e.g. ("some test sentence").capitalize() == "Some test sentence")
+ * @return {String} The capitalized String
+ */
+String.prototype.capitalize = function() {
+  return this.charAt(0).toUpperCase() + this.substr(1).toLowerCase();
+};
+
+/**
+ * Puts the string in Title Case (e.g. ("some test sentence").titleize() == "Some Test Sentence")
+ * @return {String} The titleized String
+ */
+String.prototype.titleize = function() {
+  return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
+};
+
+/**
+ * Takes any string and de-underscores and uppercases it
+ * e.g. long_underscored_string => LongUnderscoredString
+ */
+String.prototype.camelize = function() {
+  return this.replace(/_/g, " ").titleize().replace(/ /g, "");
+};
+
+/**
+ * Underscores a string (e.g. (("SomeCamelizedString").underscore() == 'some_camelized_string', 
+ *                             ("some normal string").underscore()  == 'some_normal_string')
+ * @return {String} The underscored string
+ */
+String.prototype.underscore = function() {
+  return this.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/ /g, "_").replace(/^_/, '');
+};
+
+/**
+ * Uses the Inflector to singularize itself (e.g. ("cats").singularize() == 'cat')
+ * @return {String} The singularized version of this string
+ */
+String.prototype.singularize = function() {
+  return ExtMVC.Inflector.singularize(this);
+};
+
+/**
+ * Uses the Inflector to pluralize itself (e.g. ("cat").pluralize() == 'cats')
+ * @return {String} The pluralized version of this string
+ */
+String.prototype.pluralize = function() {
+  return ExtMVC.Inflector.pluralize(this);
+};
+
+/**
+ * Attempts to humanize a name by replacing underscores with spaces. Mainly useful for Ext.Model.Base
+ * @return {String} The humanized string
+ */
+String.prototype.humanize = function() {
+  return this.underscore().replace(/_/g, " ");
+};
+
+/**
+ * Replaces instances of the strings &, >, < and " with their escaped versions
+ * @return {String} The escaped version of the original text
+ */
+String.prototype.escapeHTML = function () {                                       
+  return this.replace(/&/g,'&amp;').replace(/>/g,'&gt;').replace(/</g,'&lt;').replace(/"/g,'&quot;');
+};
+
+/**
+ * Converts this string into a currency, prepended with the given currency symbol
+ * @param {String} symbol The currency symbol to use (defaults to $)
+ */
+String.prototype.toCurrency = function(symbol) {
+  if (typeof(symbol) == 'undefined') {var symbol = '$';}
+  
+  var beforeDecimal = this.split(".")[0],
+      afterDecimal  = this.split(".")[1];
+  
+  var segmentCount      = Math.floor(beforeDecimal.length / 3);
+  var firstSegmentWidth = beforeDecimal.length % 3,
+      pointerPosition   = firstSegmentWidth;
+  
+  var segments = firstSegmentWidth == 0 ? [] : [beforeDecimal.substr(0, firstSegmentWidth)];
+  
+  for (var i=0; i < segmentCount; i++) {
+    segments.push(beforeDecimal.substr(firstSegmentWidth + (i * 3), 3));
+  };
+  
+  beforeDecimal = symbol + segments.join(",");
+  
+  return afterDecimal ? String.format("{0}.{1}", beforeDecimal, afterDecimal) : beforeDecimal;
+};

data/lib/js/lib/ViewClassManager.js

@@ -0,0 +1,229 @@
+/**
+ * @class ExtMVC.lib.ViewClassManager
+ * @extends ExtMVC.lib.ClassManager
+ * Customised class manager for views. Views differ from most other classes as they are namespaced
+ * by view package, so they take namespace and name when registering.
+ * VCM will attempt to recursively define view classes that extend others, so if a view's xtype hasn't
+ * been registered with Ext.ComponentMgr yet, VCM will attempt to find that xtype by seeing if any of 
+ * the other registered views have declared that xtype via the 'registerXType' property. If one is found,
+ * VCM will either return its constructor if it is already defined, otherwise it will try to define it first,
+ * again recursing up the inheritance stack if necessary. Example:
+<pre>
+  vcm.register('somePackage', 'someView', {
+    xtype: 'anotherview' //this doesn't exist yet
+  });
+  
+  //anotherview extends the 'myxtype' type, which hasn't been defined yet
+  vcm.register('somePackage', 'someOtherView', {
+    xtype: 'myxtype',
+    registerXType: 'anotherview'
+  });
+  
+  //myview extends panel, and is registered with the 'myxtype' xtype
+  vcm.register('somepackage', 'myview', {
+    xtype: 'panel',
+    registerXType: 'myxtype'
+  });
+  
+  When vcm.getConstructor('somepackage', 'someview') is called, it looks to see if 'anotherview' has
+  been registered with Ext.ComponentMgr first. If it has, it just calls Ext.extend with the config included
+  when registering 'someview', extending the constructor of 'anotherview', and returns the result.
+  
+  If 'anotherview' hasn't yet been registered with Ext.ComponentMgr, it is automatically defined first with
+  this.define. In this case, the parent class of 'anotherview' ('myxtype') hasn't been defined yet either,
+  so again the inheritance chain is automatically traversed, 'myview' is defined and registered to 'myxtype',
+  and the resulting extended class constructor returned so that 'anotherview' can in turn be extended.
+</pre>
+ */
+ExtMVC.lib.ViewClassManager = Ext.extend(ExtMVC.lib.ClassManager, {
+  autoDefine: false,
+  
+  /**
+   * Uses Ext.extend to define a previously registered view class config into a full class.
+   * The new class constructor is then cached in this.constructors, keyed by name.
+   * @param {String} name The name of the view to turn from config object to class constructor
+   */
+  define: function define(name) {
+    var overrides = this.getRegistered(name);
+    if (overrides == undefined) this.throwViewNotFoundError(name);
+    
+    var xtype = overrides.xtype || 'panel';
+    
+    delete overrides.xtype;
+    
+    //extend the class, register it if required
+    var constructor = this.getConstructorForXType(xtype);
+    var klass = Ext.extend(constructor, overrides);
+    
+    if (klass == undefined) {
+      throw new Error(
+        String.format("The {0} view could not be created because the xtype you supplied ('{1}') could not be found", name, overrides.xtype)
+      );
+    }
+    
+    var newXType = overrides.registerXType;
+    if (newXType) {
+      Ext.reg(newXType, klass);
+      this.xtypeLookup[newXType] = klass;
+    }
+    
+    this.constructors[name] = klass;
+    this.fireEvent('class-defined', name, klass);
+    
+    return klass;
+  },
+  
+  /**
+   * Register works slightly differently for views because we use a namespace too,
+   * so convert it here first
+   */
+  register: function register(namespace, name, config) {
+    var viewName = this.buildName(namespace, name);
+    
+    ExtMVC.lib.ViewClassManager.superclass.register.call(this, viewName, config);
+  },
+  
+  getConstructor: function getConstructor(namespace, name) {
+    var viewName = this.buildName(namespace, name);
+    
+    return ExtMVC.lib.ViewClassManager.superclass.getConstructor.call(this, viewName);
+  },
+  
+  /**
+   * @private
+   * Finds the constructor for a registered xtype.
+   * FIXME: This uses a horrible hack and really shouldn't be here at all - the reason being that Ext.ComponentMgr
+   * hides its registered types locally, 
+   * @param {String} xtype The xtype to retrieve a constructor for
+   * @return {Function} The constructor for the xtype requested
+   */
+  getConstructorForXType: function getConstructorForXType(xtype) {
+    var constructor = this.xtypeLookup[xtype];
+    
+    if (constructor == undefined) {
+      for (var className in this.registeredClasses) {
+        var value = this.registeredClasses[className];
+        
+        //extend the parent object and register the constructor
+        if (value.registerXType == xtype) {
+          constructor = this.getConstructor(className.split('-')[0], className.split('-')[1]);
+        }
+      }
+    }
+    
+    return constructor;
+  },
+  
+  /**
+   * Because views are named by namespace and name, we need to turn these 2 names into 1
+   * to be able to register them, which is what this function does
+   * @param {String} namespace The view namespace
+   * @param {String} name The view name
+   * @return {String} The composited view name (defaults to "{namespace}-{name}")
+   */
+  buildName: function buildName(namespace, name) {
+    return String.format("{0}-{1}", namespace, name);
+  },
+  
+  xtypeLookup: {
+    box           : Ext.BoxComponent,
+    button        : Ext.Button,
+    buttongroup   : Ext.ButtonGroup,
+    colorpalette  : Ext.ColorPalette,
+    component     : Ext.Component,
+    container     : Ext.Container,
+    cycle         : Ext.CycleButton,
+    dataview      : Ext.DataView,
+    datepicker    : Ext.DatePicker,
+    editor        : Ext.Editor,
+    editorgrid    : Ext.grid.EditorGridPanel,
+    flash         : Ext.FlashComponent,
+    grid          : Ext.grid.GridPanel,
+    listview      : Ext.ListView,
+    panel         : Ext.Panel,
+    progress      : Ext.ProgressBar,
+    propertygrid  : Ext.grid.PropertyGrid,
+    slider        : Ext.Slider,
+    spacer        : Ext.Spacer,
+    splitbutton   : Ext.SplitButton,
+    tabpanel      : Ext.TabPanel,
+    treepanel     : Ext.tree.TreePanel,
+    viewport      : Ext.ViewPort,
+    'window'      : Ext.Window,
+    
+    paging        : Ext.PagingToolbar,
+    toolbar       : Ext.Toolbar,
+    tbbutton      : Ext.Toolbar.Button,
+    tbfill        : Ext.Toolbar.Fill,
+    tbitem        : Ext.Toolbar.Item,
+    tbseparator   : Ext.Toolbar.Separator,
+    tbspacer      : Ext.Toolbar.Spacer,
+    tbsplit       : Ext.Toolbar.SplitButton,
+    tbtext        : Ext.Toolbar.TextItem,
+
+    menu          : Ext.menu.Menu,
+    colormenu     : Ext.menu.ColorMenu,
+    datemenu      : Ext.menu.DateMenu,
+    menubaseitem  : Ext.menu.BaseItem,
+    menucheckitem : Ext.menu.CheckItem,
+    menuitem      : Ext.menu.Item,
+    menuseparator : Ext.menu.Separator,
+    menutextitem  : Ext.menu.TextItem,
+    
+    form          : Ext.FormPanel,
+    checkbox      : Ext.form.Checkbox,
+    checkboxgroup : Ext.form.CheckboxGroup,
+    combo         : Ext.form.ComboBox,
+    datefield     : Ext.form.DateField,
+    displayfield  : Ext.form.DisplayField,
+    field         : Ext.form.Field,
+    fieldset      : Ext.form.FieldSet,
+    hidden        : Ext.form.Hidden,
+    htmleditor    : Ext.form.HtmlEditor,
+    label         : Ext.form.Label,
+    numberfield   : Ext.form.NumberField,
+    radio         : Ext.form.Radio,
+    radiogroup    : Ext.form.RadioGroup,
+    textarea      : Ext.form.TextArea,
+    textfield     : Ext.form.TextField,
+    timefield     : Ext.form.TimeField,
+    trigger       : Ext.form.TriggerField,
+
+    chart         : Ext.chart.Chart,
+    barchart      : Ext.chart.BarChart,
+    cartesianchart: Ext.chart.CartesianChart,
+    columnchart   : Ext.chart.ColumnChart,
+    linechart     : Ext.chart.LineChart,
+    piechart      : Ext.chart.PieChart,
+
+    arraystore    : Ext.data.ArrayStore,
+    directstore   : Ext.data.DirectStore,
+    groupingstore : Ext.data.GroupingStore,
+    jsonstore     : Ext.data.JsonStore,
+    simplestore   : Ext.data.SimpleStore,
+    store         : Ext.data.Store,
+    xmlstore      : Ext.data.XmlStore
+  },
+  
+  /**
+   * @private
+   * Throws a custom Error if the view name has not been registered yet
+   * @param {String} name The name of the view that could not be found
+   */
+  throwViewNotFoundError: function(name) {
+    var dir  = name.split("-")[0],
+        file = name.split("-")[1];
+    
+    var msg = String.format(
+      "The {0} view could not be found, please check that your app/views/{1} directory contains a file called {2}, " +
+      "that the file contains \"{3}\" and that config/environment.json includes this file",
+      name,
+      dir,
+      file,
+      String.format("Ext.registerView('{0}', '{1}')", dir, file)
+    );
+    throw new Error(msg);
+  }
+});
+
+ExtMVC.registerClassManager('view', new ExtMVC.lib.ViewClassManager());

data/lib/js/lib/notes.txt

@@ -0,0 +1,32 @@
+/**
+ * Old versions of String extensions.  Not sure if we should be augmenting String like the above so have left this for reference
+ */
+
+// /**
+//  * @param {String} str A string to be capitalized
+//  * @returns A capitalized string (e.g. "some test sentence" becomes "Some test sentence")
+//  * @type String
+//  */
+// String.capitalize = function(str) {
+//   return str.charAt(0).toUpperCase() + str.substr(1).toLowerCase();
+// };
+// 
+// /**
+//  * @param {String} str A string to be turned into title case
+//  * @returns The string in Title Case (e.g. "some test sentence" becomes "Some Test Sentence")
+//  * @type String
+//  */
+// String.titleize = function(str) {
+//   return str.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
+// };
+// 
+// /**
+//  * Takes any string and de-underscores and uppercases it
+//  * e.g. long_underscored_string => LongUnderscoredString
+//  */
+// String.camelize = function(class_name_string) {
+//   return String.titleize(class_name_string.replace(/_/g, " ")).replace(/ /g, "");
+// 
+//   // this feels nicer, sadly no collect function (yet) though
+//   // class_name_string.split("_").collect(function(e) {return String.capitalize(e)}).join("");
+// };

data/lib/js/model/AdapterManager.js

@@ -0,0 +1,30 @@
+/**
+ * Manages registration and retrieval of MVC Model adapters
+ * @class ExtMVC.model.AdapterManager
+ */
+ExtMVC.model.AdapterManager = {
+  /**
+   * @property adapters
+   * @type Object
+   * Key/Value pairs of registered names and the relevant Adapter objects
+   */
+  adapters: {},
+  
+  /**
+   * Registers an adapter for use with MVC Models.  
+   * @param {String} name String name for this Adapter (e.g. 'REST')
+   * @param {Function} object A reference to the Adapter object itself
+   */
+  register: function(name, constructor) {
+    this.adapters[name] = constructor;
+  },
+  
+  /**
+   * Retrieves the requested adapter by key name
+   * @param {String} name The name of the adapter to fine (e.g. 'REST')
+   * @return {Object/Null} The Adapter object, if found
+   */
+  find: function(name, config) {
+    return this.adapters[name];
+  }
+};