extjs-mvc 0.4.0.f → 0.4.0.g

data/lib/src/lib/ControllerClassManager.js

@@ -1,95 +0,0 @@
-/**
- * @class ExtMVC.lib.ControllerClassManager
- * @extends ExtMVC.lib.ClassManager
- * Customised class manager for managing Controllers
- */
-ExtMVC.lib.ControllerClassManager = Ext.extend(ExtMVC.lib.ClassManager, {
-  constructor: function(config) {
-    config = config || {};
-          
-    Ext.applyIf(config, {
-      /**
-       * @property instances
-       * @type Object
-       * {name: instance} mapping of any classes which have been instantiated with this manager
-       * This is only really used for controllers, where there is only ever one instance at a time
-       */
-      instances: {},
-      
-      /**
-       * @property autoInstantiate
-       * @type Boolean
-       * If true, the ClassManager will attempt to instantiate controllers immediately after they are defined (defaults to true)
-       */
-      autoInstantiate: true
-    });
-    
-    ExtMVC.lib.ControllerClassManager.superclass.constructor.call(this, config);
-    
-    this.addEvents(
-      /**
-       * @event class-instantiated
-       * Fires when a class in this manager has been instantiated by the manager. This is mostly 
-       * useful when using autoInstantiate, e.g. for classes for which there should only be one instance
-       * @param {String} name The name of the class that was instantiated
-       * @param {Object} instance The instance that was just created
-       */
-      'class-instantiated'
-    );
-  },
-  
-  define: function(name) {
-    var overrides  = this.getRegistered(name);
-    
-    if (overrides == undefined) {
-      throw new Ext.Error(String.format("The {0} controller could not be found", name));
-    }
-    
-    //set 'application' as the default controller to inherit from
-    var superclass = name == "controller" ? Ext.util.Observable : this.getConstructor(overrides.extend || "application");
-    
-    //extend the parent object and register the constructor
-    var klass = Ext.extend(superclass, overrides);
-    this.constructors[name] = klass;
-    
-    if (this.autoInstantiate === true) this.instantiate(name);
-    
-    this.fireEvent('class-defined', name, klass);
-    
-    return klass;
-  },
-  
-  /**
-   * Instantiates the given class name, with an optional config object (usually the config is not needed)
-   * 
-   */
-  instantiate: function(name, config) {
-    //get the controller instance that has already been created
-    var instance = this.instances[name];
-    
-    //if the instance isn't defined yet, instantiate it now and cache it
-    if (instance == undefined) {
-      instance = new (this.getConstructor(name))(config);
-      instance.name = name;
-      // instance.superclass = 
-      
-      this.instances[name] = instance;
-      
-      this.fireEvent('class-instantiated', name, instance);
-    }
-    
-    return instance;    
-  },
-  
-  /**
-   * Only really useful for controllers, this returns the canonical instance for a given
-   * class name (e.g. getInstance('funds') would return the Funds Controller, instaniating first if required)
-   * @param {String} name The name of the class to instantiate
-   * @return {Object} The canonical instance of this class
-   */
-  getInstance: function(name) {
-    return this.instances[name] || this.instantiate(name);
-  }
-});
-
-ExtMVC.registerClassManager('controller', new ExtMVC.lib.ControllerClassManager());

data/lib/src/lib/Dependencies.js

@@ -1,44 +0,0 @@
-/**
- * @class ExtMVC.lib.Dependencies
- * @extends Ext.util.Observable
- * Very simply dependency management class
- */
-ExtMVC.lib.Dependencies = Ext.extend(Ext.util.Observable, {
-
-  constructor: function() {
-    
-    /**
-     * @property dependencies
-     * @type Object
-     * An object of model creation configurations awaiting definition because their dependency model(s) have not yet
-     * been defined. e.g. {'User': [{name: 'SuperUser', config: someConfigObject}, {name: 'AdminUser', config: anotherCfgObj}]}
-     * signifies that SuperUser and AdminUser should be defined as soon as User has been defined
-     */
-    this.dependencies = {};    
-    
-    ExtMVC.lib.Dependencies.superclass.constructor.apply(this, arguments);
-  },
-  
-  /**
-   * Returns an array of any Model subclasses waiting for this model to be defined
-   * @param {String} dependencyName The dependency model name to check against
-   * @return {Array} An array of items dependent on this item being defined (e.g. [{name: 'MyModel', config: someObject}])
-   */
-  get: function(dependencyName) {
-    return this.dependencies[dependencyName] || [];
-  },
-  
-  /**
-   * Adds a model definition to the dependencies object if it is waiting for another model to be defined first
-   * @param {String} dependencyName The name of another model which must be created before this one
-   * @param {String} dependentName The name of the new model to be defined after its dependency
-   * @param {Object} config The new model's config object, as sent to ExtMVC.model.define
-   */
-  add: function(dependencyName, dependentName, config) {
-    var arr = this.dependencies[dependencyName] || [];
-    
-    arr.push({name: dependentName, config: config});
-    
-    this.dependencies[dependencyName] = arr;
-  }
-});

data/lib/src/lib/DispatchMatcher.js

@@ -1,98 +0,0 @@
-/**
- * @class ExtMVC.lib.DispatchMatcher
- * @extends Object
- * Abstract base class for dispatch matchers. A Dispatch Matcher just takes the arguments that
- * are passed to an ExtMVC.lib.Dispatcher's dispatch method, and returns normalised arguments.
- * This allows the Dispatcher to accept numerous forms, such as:
- *   dispatch('controllerName', 'actionName', ['list', 'of', 'arguments'])
- *   dispatch({controller: 'controllerName', action: 'actionName', arguments: ['list', 'of', 'arguments']})
- *   dispatch("controller/action/123")
- */
-ExtMVC.lib.DispatchMatcher = Ext.extend(Object, {
-
-  constructor: function(config) {
-    Ext.applyIf(this, config || {});
-    
-    ExtMVC.lib.DispatchMatcher.superclass.constructor.apply(this, arguments);
-  },
-  
-  matches: function() {
-    throw new Ext.Error("DispatchMatcher subclass must implement this method");
-  },
-  
-  /**
-   * Returns an object like the following:
-   * {
-   *   controller: 'someControllerName',
-   *   action    : 'someActionName',
-   *   arguments : ['some', 'list', 'of', 'arguments']
-   * }
-   */
-  getDispatchConfig: function() {
-    throw new Ext.Error("DispatchMatcher subclass must implement this method");
-  }
-});
-
-/**
- * @class ExtMVC.lib.DefaultDispatchMatcher
- * @extends ExtMVC.lib.DispatchMatcher
- * Dispatch matcher that accepts arguments in the form (controller, action, [args])
- */
-ExtMVC.lib.DefaultDispatchMatcher = Ext.extend(ExtMVC.lib.DispatchMatcher, {
-  name: 'default',
-  
-  /**
-   * Returns true if the supplied arguments look like ('controllerName', 'actionName', ['args'])
-   */
-  matches: function(controller, action, args) {
-    return Ext.isString(controller) && Ext.isString(action) && Ext.isArray(args || []);
-  },
-  
-  getDispatchConfig: function() {
-    return {
-      controller: arguments[0],
-      action    : arguments[1],
-      arguments : arguments[2] || []
-    };
-  }
-});
-
-/**
- * @class ExtMVC.lib.ObjectDispatchMatcher
- * @extends ExtMVC.lib.DispatchMatcher
- * Dispatch matcher that accepts arguments in the form ({controller: controller, action: action, arguments: [args]})
- */
-ExtMVC.lib.ObjectDispatchMatcher = Ext.extend(ExtMVC.lib.DispatchMatcher, {
-  name: 'object',
-  
-  /**
-   * Returns true if the supplied arguments are parseable by this matcher
-   * @return {Boolean} true if this matcher matches the supplied arguments
-   */
-  matches: function() {
-    var obj = arguments[0];
-    
-    //set the default action to 'index', if not supplied
-    Ext.applyIf(obj, {
-      action: 'index'
-    });
-    
-    return arguments.length == 1 && obj.controller != undefined && obj.action != undefined;
-  },
-  
-  getDispatchConfig: function() {
-    return arguments[0];
-  }
-});
-
-
-/**
- * @class ExtMVC.lib.RouterDispatchManager
- * @extends ExtMVC.lib.DispatchMatcher
- * Dispatch matcher that uses a Router to match a given string and split it into suitable arguments
- */
-ExtMVC.lib.RouterDispatchManager = Ext.extend(ExtMVC.lib.DispatchMatcher, {
-  name: 'router'
-  
-  //TODO
-});

data/lib/src/lib/Dispatcher.js

@@ -1,129 +0,0 @@
-/**
- * @class ExtMVC.lib.Dispatcher
- * @extends Ext.util.MixedCollection
- * Normalises dispatch info received by an application, finds and calls the relevant controller action
- * with any arguments supplied
- */
-ExtMVC.lib.Dispatcher = Ext.extend(Ext.util.MixedCollection, {
-
-  constructor: function(config) {
-    ExtMVC.lib.Dispatcher.superclass.constructor.apply(this, arguments);
-    
-    Ext.apply(this, config || {}, {
-      /**
-       * @property matchers
-       * @type Array
-       * All registered Dispatch Matchers
-       */
-      matchers: [],
-      
-      /**
-       * @cfg matcherOrder
-       * @type Array
-       * An array of strings that correspond to DispatchMatcher names. This defines the order
-       * in which dispatch matchers will be called. Override if you wish to inject your own matchers
-       * before the default ones. This is empty by default, and pushed to whenever a matcher is registered
-       */
-      matcherOrder: []
-    });
-    
-    this.addEvents(
-      /**
-       * @event dispatch
-       * Fires before the dispatcher dispatches a request. Return false to cancel
-       * @param {Array} arguments The arguments receivd by the dispatcher
-       * @param {ExtMVC.lib.DispatchMatcher} matcher The DispatchMatcher instance that will be used
-       * @param {Object} dispatchConfig An object containing controller, action and arguments properties
-       */
-      'dispatch'
-    );
-    
-    this.registerDefaultDispatchMatchers();
-  },
-  
-  /**
-   * Dispatches to a controller action. Takes numerous argument formats, such as:
-    <pre>
-      <ul>
-        <li>dispatch('controllerName', 'actionName', ['list', 'of', 'arguments'])</li>
-        <li>dispatch({controller: 'controllerName', action: 'actionName', arguments: ['list', 'of', 'arguments']})</li>
-      </ul>
-    </pre>
-   * These are normalised, the controller found and the action called with the supplied arguments.
-   */
-  dispatch: function() {
-    var matcher = this.getDispatchMatcher.apply(this, arguments),
-        config  = matcher.getDispatchConfig.apply(matcher, arguments);
-
-    //fire the 'dispatch' event, and then dispatch if no listeners return false
-    if (this.fireEvent('dispatch', arguments, matcher, config) !== false) {
-      var controller = ExtMVC.getController(config.controller);
-      
-      if (controller == undefined) {
-        throw new Ext.Error(
-          String.format("The controller you are trying to dispatch to ({0}) does not exist", config.controller)
-        );
-      }
-      
-      if (controller[config.action] == undefined) {
-        throw new Ext.Error(
-          String.format("The action {0} does not exist on the {1} controller", config.action, config.controller)
-        );
-      }
-      
-      //if controller and action both exist, dispatch now
-      return controller[config.action].apply(controller, config.arguments);      
-    }
-  },
-
-  /**
-   * Registers a dispatch matcher for use with this dispatcher.
-   * @param {ExtMVC.lib.DispatchMatcher} matcher The matcher to register
-   */
-  registerDispatchMatcher: function(matcher) {
-    this.add(matcher);
-    
-    this.matcherOrder.push(matcher.name);
-  },
-
-  /**
-   * Adds the default dispatch matchers. This is called automatically by the constructor
-   */
-  registerDefaultDispatchMatchers: function() {
-    this.registerDispatchMatcher(new ExtMVC.lib.DefaultDispatchMatcher());
-    this.registerDispatchMatcher(new ExtMVC.lib.ObjectDispatchMatcher());
-  },
-  
-  /**
-   * @private
-   * Returns a DispatchMatcher object if any matchers match the supplied dispatch format
-   */
-  getDispatchMatcher: function() {
-    var dispatchArgs = arguments,
-        dispatchMatcher;
-    
-    Ext.each(this.matcherOrder, function(name) {
-      var matcher = this.get(name);
-      
-      if (matcher.matches.apply(matcher, dispatchArgs)) {
-        dispatchMatcher = matcher;
-        
-        //stops Ext.each
-        return false;
-      }
-    }, this);
-    
-    if (dispatchMatcher == undefined) {
-      throw new Ext.Error("Could not find a suitable Dispatch Matcher for the dispatch arguments provided", dispatchArgs);
-    } else {
-      return dispatchMatcher;
-    }
-  },
-  
-  /**
-   * @private
-   */
-  getKey: function(item) {
-    return item.name;
-  }
-});

data/lib/src/lib/Environment.js

@@ -1,43 +0,0 @@
-/**
- * @class ExtMVC.Environment
- * @extends Ext.util.Observable
- * Represents an application in which to load an application. This is used by the
- * environment files inside the public/config and public/config/environments directories
- * 
- */
-ExtMVC.Environment = Ext.extend(Ext.util.Observable, {
-
-  constructor: function(config) {
-    config = config || {};
-    
-    Ext.apply(this, config, {
-      //TODO: jsdoc these defaults
-      pluginsDir  : '../vendor/plugins',
-      libDir      : '../lib',
-      configDir   : '../config',
-      overridesDir: '../config/overrides',
-      appDir      : '../app',
-      vendor      : ['mvc'],
-      mvcFilename : 'ext-mvc-all-min',
-      config      : ['app/App', 'config/routes'],
-      
-      /**
-       * @property stylesheets
-       * @type Array
-       * The stylesheets to load for this app (defaults to just ext-all)
-       */
-      stylesheets: ['ext-all']
-    });
-    
-    ExtMVC.Environment.superclass.constructor.apply(this, arguments);
-  },
-  
-  /**
-   * Updates this environment by applying the updates argument to itself
-   * @param {Object} updates Any updated values to apply to the Environment
-   * @return {ExtMVC.Environment} The environment object
-   */
-  update: function(updates) {
-    Ext.apply(this, updates);
-  }
-});

data/lib/src/lib/Inflector.js

@@ -1,155 +0,0 @@
-/*
- * Adapted from http://snippets.dzone.com/posts/show/3205
- */
-
-ExtMVC.Inflector = {
-  /*
-   * The order of all these lists has been reversed from the way 
-   * ActiveSupport had them to keep the correct priority.
-   */
-  Inflections: {
-    plural: [
-      [(/(quiz)$/i),               "$1zes"  ],
-      [(/^(ox)$/i),                "$1en"   ],
-      [(/([m|l])ouse$/i),          "$1ice"  ],
-      [(/(matr|vert|ind)ix|ex$/i), "$1ices" ],
-      [(/(x|ch|ss|sh)$/i),         "$1es"   ],
-      [(/([^aeiouy]|qu)y$/i),      "$1ies"  ],
-      [(/(hive)$/i),               "$1s"    ],
-      [(/(?:([^f])fe|([lr])f)$/i), "$1$2ves"],
-      [(/sis$/i),                  "ses"    ],
-      [(/([ti])um$/i),             "$1a"    ],
-      [(/(buffal|tomat)o$/i),      "$1oes"  ],
-      [(/(bu)s$/i),                "$1ses"  ],
-      [(/(alias|status)$/i),       "$1es"   ],
-      [(/(octop|vir)us$/i),        "$1i"    ],
-      [(/(ax|test)is$/i),          "$1es"   ],
-      [(/s$/i),                    "s"      ],
-      [(/$/),                      "s"      ]
-    ],
-    singular: [
-      [(/(quiz)zes$/i),                                                    "$1"     ],
-      [(/(matr)ices$/i),                                                   "$1ix"   ],
-      [(/(vert|ind)ices$/i),                                               "$1ex"   ],
-      [(/^(ox)en/i),                                                       "$1"     ],
-      [(/(alias|status)es$/i),                                             "$1"     ],
-      [(/(octop|vir)i$/i),                                                 "$1us"   ],
-      [(/(cris|ax|test)es$/i),                                             "$1is"   ],
-      [(/(shoe)s$/i),                                                      "$1"     ],
-      [(/(o)es$/i),                                                        "$1"     ],
-      [(/(bus)es$/i),                                                      "$1"     ],
-      [(/([m|l])ice$/i),                                                   "$1ouse" ],
-      [(/(x|ch|ss|sh)es$/i),                                               "$1"     ],
-      [(/(m)ovies$/i),                                                     "$1ovie" ],
-      [(/(s)eries$/i),                                                     "$1eries"],
-      [(/([^aeiouy]|qu)ies$/i),                                            "$1y"    ],
-      [(/([lr])ves$/i),                                                    "$1f"    ],
-      [(/(tive)s$/i),                                                      "$1"     ],
-      [(/(hive)s$/i),                                                      "$1"     ],
-      [(/([^f])ves$/i),                                                    "$1fe"   ],
-      [(/(^analy)ses$/i),                                                  "$1sis"  ],
-      [(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i), "$1$2sis"],
-      [(/([ti])a$/i),                                                      "$1um"   ],
-      [(/(n)ews$/i),                                                       "$1ews"  ],
-      [(/s$/i),                                                            ""       ]
-    ],
-    irregular: [
-      ['move',   'moves'   ],
-      ['sex',    'sexes'   ],
-      ['child',  'children'],
-      ['man',    'men'     ],
-      ['person', 'people'  ]
-    ],
-    uncountable: [
-      "sheep",
-      "fish",
-      "series",
-      "species",
-      "money",
-      "rice",
-      "information",
-      "equipment"
-    ]
-  },
-  
-  ordinalize: function(number) {
-    if (11 <= parseInt(number, 10) % 100 && parseInt(number, 10) % 100 <= 13) {
-      return number + "th";
-    } else {
-      switch (parseInt(number, 10) % 10) {
-        case  1: return number + "st";
-        case  2: return number + "nd";
-        case  3: return number + "rd";
-        default: return number + "th";
-      }
-    }
-  },
-  
-  camelize: function(str) {
-    return (str.charAt(0).toUpperCase()+str.slice(1)).replace(/[\-_]+(\S)?/g, function(match, chr) {
-      return chr ? chr.toUpperCase() : '';
-    });
-  },
-  
-  // From http://code.google.com/p/inflection-js/source/browse/trunk/inflection.js
-  underscore: function(str) {
-    var str_path=str.split('::');
-    var upCase=new RegExp('([A-Z])','g');
-    var fb=new RegExp('^_');
-    for(var i=0;i<str_path.length;i++)
-      str_path[i]=str_path[i].replace(upCase,'_$1').replace(fb,'');
-      str=str_path.join('/').toLowerCase();
-    return str;
-  },
-  
-  pluralize: function(word) {
-    var unusual = ExtMVC.Inflector.uncountableOrIrregular(word);
-    if (unusual) { return unusual; }
-    
-    for (var i = 0; i < ExtMVC.Inflector.Inflections.plural.length; i++) {
-      var regex          = ExtMVC.Inflector.Inflections.plural[i][0];
-      var replace_string = ExtMVC.Inflector.Inflections.plural[i][1];
-      if (regex.test(word)) {
-        return word.replace(regex, replace_string);
-      }
-    }
-    
-    //return the word if it is already pluralized
-    return word;
-  },
-  
-  singularize: function(word) {
-    var unusual = ExtMVC.Inflector.uncountableOrIrregular(word);
-    if (unusual) { return unusual; }
-    
-    for (var i = 0; i < ExtMVC.Inflector.Inflections.singular.length; i++) {
-      var regex          = ExtMVC.Inflector.Inflections.singular[i][0];
-      var replace_string = ExtMVC.Inflector.Inflections.singular[i][1];
-      
-      if (regex.test(word)) {
-        return word.replace(regex, replace_string);
-      }
-    }
-    
-    //return the word if it is already singularized
-    return word;
-  },
-  
-  uncountableOrIrregular: function(word) {
-    for (var i = 0; i < ExtMVC.Inflector.Inflections.uncountable.length; i++) {
-      var uncountable = ExtMVC.Inflector.Inflections.uncountable[i];
-      if (word.toLowerCase == uncountable) {
-        return uncountable;
-      }
-    }
-    for (var i = 0; i < ExtMVC.Inflector.Inflections.irregular.length; i++) {
-      var singular = ExtMVC.Inflector.Inflections.irregular[i][0];
-      var plural   = ExtMVC.Inflector.Inflections.irregular[i][1];
-      if ((word.toLowerCase == singular) || (word == plural)) {
-        return plural;
-      }
-    }
-    
-    return false;
-  }
-};