extjs-mvc 0.4.0.j → 0.4.0.k

data/test/app/vendor/extjs-mvc/lib/ControllerClassManager.js

@@ -0,0 +1,95 @@
+/**
+ * @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/test/app/vendor/extjs-mvc/lib/Dependencies.js

@@ -0,0 +1,44 @@
+/**
+ * @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/test/app/vendor/extjs-mvc/lib/DispatchMatcher.js

@@ -0,0 +1,98 @@
+/**
+ * @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/test/app/vendor/extjs-mvc/lib/Dispatcher.js

@@ -0,0 +1,129 @@
+/**
+ * @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/test/app/vendor/extjs-mvc/lib/Environment.js

@@ -0,0 +1,43 @@
+/**
+ * @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/test/app/vendor/extjs-mvc/lib/Inflector.js

@@ -0,0 +1,155 @@
+/*
+ * 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;
+  }
+};