extjs-mvc 0.4.0.j → 0.4.0.k

data/test/app/vendor/extjs-mvc/model/validations/Validations.js

@@ -0,0 +1,276 @@
+Ext.ns('ExtMVC.model.plugin.validation');
+
+/**
+ * @ignore
+ * The Validation classes themselves are defined here.
+ * Subclass ExtMVC.model.plugin.validation.AbstractValidation to create your own validations
+ */
+
+/**
+ * @class ExtMVC.model.plugin.validation.AbstractValidation
+ * Base class for all validations - not used directly, but any of the following may be used:
+<pre><code>
+ExtMVC.model.define("SomeModel", {
+  fields: [
+    {name: 'title',  type: 'string'},
+    {name: 'price',  type: 'int'},
+    {name: 'stock',  type: 'int'},
+    {name: 'gender', type: 'string'},
+    {name: 'colour', type: 'string'}
+  ],
+  
+  validatesPresenceOf : ["title", "price"],
+  validatesLengthOf   : {field: 'title', minimum: 3, maximum: 12},
+  
+  validatesInclusionOf: {field: 'gender', allowed   : ["Male", "Female"]},
+  validatesExclusionOf: {field: 'colour', disallowed: ["Red"]},
+  validatesFormatOf   : {field: 'email',  regex: /someRegex/},
+  
+  validatesNumericalityOf: "stock"
+});
+</code></pre>
+ * 
+ * Most validations will allow an array to be passed to set the validation up on more than one field (e.g.
+ * see the validatesPresenceOf declaration above). If only a string is provided it is assume to be the field name.
+ * The following are all equivalent:
+<pre><code>
+validatesPresenceOf: "title"
+validatesPresenceOf: ["title"]
+validatesPresenceOf: {field: "title"}
+validatesPresenceOf: [{field: "title"}]
+</code></pre>
+ * 
+ * <h2>Running validations</h2>
+ * This plugin overrides ExtMVC.model.Base's usual isValid() function to provide feedback from the validations:
+ * 
+<pre><code>
+var user = new SomeModel({title: "A really long title", colour: "Blue"});
+user.isValid(); //returns false if any of the validations failed
+user.errors; //returns an {@link ExtMVC.model.plugin.validation.Errors Errors} object
+</code></pre>
+ */
+ExtMVC.model.plugin.validation.AbstractValidation = function(ownerClass, field, config) {
+  this.ownerClass = ownerClass;
+  this.field = field;
+  
+  Ext.apply(this, config);
+};
+
+ExtMVC.model.plugin.validation.AbstractValidation.prototype = {
+  /**
+   * Returns the current value of the field to which this validation applies
+   * @param {ExtMVC.model.Base} instance The model instance to get the value from
+   * @return {Mixed} The current value of the field
+   */
+  getValue: function(instance) {
+    return instance.get(this.field);
+  },
+  
+  /**
+   * Empty function which must be overridden by a validation subclass. Make your function return
+   * true if the validation passes, false otherwise
+   * @return {Boolean} True if this validation passes
+   */
+  isValid: function(instance) {
+    return true;
+  }
+};
+
+/**
+ * @class ExtMVC.model.plugin.validation.ValidatesPresenceOf
+ * @extends ExtMVC.model.plugin.validation.AbstractValidation
+ * Ensures that a field is present. See {*link ExtMVC.model.plugin.validation.AbstractValidation AbstractValidation} for example.
+ */
+ExtMVC.model.plugin.validation.ValidatesPresenceOf = Ext.extend(ExtMVC.model.plugin.validation.AbstractValidation, {
+  /**
+   * @property message
+   * @type String
+   * The textual message returned if this validation didn't pass
+   */
+  message: 'must be present',
+  
+  /**
+   * Returns true if the field is an object or a non-empty string
+   * @return {Boolean} True if the field is present
+   */
+  isValid: function(instance) {
+    var value = this.getValue(instance),
+        valid = false;
+    
+    switch(typeof value) {
+      case 'object': if (value != null)     valid = true; break;
+      case 'string': if (value.length != 0) valid = true; break;
+    };
+    
+    return valid;
+  }
+});
+
+/**
+ * @class ExtMVC.model.plugin.validation.ValidatesLengthOf
+ * @extends ExtMVC.model.plugin.validation.AbstractValidation
+ * Returns true if the field is within the length bounds imposed. See {*link ExtMVC.model.plugin.validation.AbstractValidation AbstractValidation} for example.
+ */
+ExtMVC.model.plugin.validation.ValidatesLengthOf = Ext.extend(ExtMVC.model.plugin.validation.AbstractValidation, {
+  
+  /**
+   * @property tooShortMessage
+   * @type String
+   * The message returned if this field was too short
+   */
+  tooShortMessage: 'is too short',
+  
+  /**
+   * @property tooLongMessage
+   * @type String
+   * The message returned if this field was too long
+   */
+  tooLongMessage: 'is too long',
+  
+  message: '',
+
+  /**
+   * Tests that the mimimum and maximum length of this field are met.
+   * Intended to be used on strings and arrays
+   * @return {Boolean} True if the conditions are met
+   */
+  isValid: function(instance) {
+    var value = this.getValue(instance);
+    
+    if (typeof value == 'undefined') return true;
+        
+    if (this.minimum && value.length < this.minimum) {
+      this.message = this.tooShortMessage;
+      return false;
+    }
+    
+    if (this.maximum & value.length > this.maximum) {
+      this.message = this.tooLongMessage;
+      return false;
+    }
+    
+    return true;
+  }
+});
+
+/**
+ * @class ExtMVC.model.plugin.validation.ValidatesNumericalityOf
+ * @extends ExtMVC.model.plugin.validation.AbstractValidation
+ * Ensures that the field is a number. See {*link ExtMVC.model.plugin.validation.AbstractValidation AbstractValidation} for example.
+ */
+ExtMVC.model.plugin.validation.ValidatesNumericalityOf = Ext.extend(ExtMVC.model.plugin.validation.AbstractValidation, {
+  /**
+   * @property message
+   * @type String
+   * The message returned if this field is not a number
+   */
+  message: 'must be a number',
+  
+  /**
+   * Returns true if the typeof this field is a number
+   * @return {Boolean} True if this is a number
+   */
+  isValid: function(instance) {
+    return 'number' == typeof this.getValue(instance);
+  }
+});
+
+/**
+ * @class ExtMVC.model.plugin.validation.ValidatesInclusionOf
+ * @extends ExtMVC.model.plugin.validation.AbstractValidation
+ * Ensures that the field is one of the allowed values. See {*link ExtMVC.model.plugin.validation.AbstractValidation AbstractValidation} for example.
+ */
+ExtMVC.model.plugin.validation.ValidatesInclusionOf = Ext.extend(ExtMVC.model.plugin.validation.AbstractValidation, {
+
+
+  /**
+   * Override Abstract constructor to build the validation message
+   */
+  constructor: function(m, f, config) {
+    //set up defaults
+    config = config || {};
+    Ext.applyIf(config, { allowed: [] });
+    
+    ExtMVC.model.plugin.validation.ValidatesInclusionOf.superclass.constructor.call(this, m, f, config);
+    
+    Ext.applyIf(this, {
+      message: 'must be one of ' + this.allowed.toSentence('or')
+    });
+  },
+  
+  /**
+   * Returns true if the value of this field is one of those specified in this.allowed
+   * @return {Boolean} True if the field's value is allowed
+   */
+  isValid: function(instance) {
+    var value = this.getValue(instance);
+    
+    for (var i=0; i < this.allowed.length; i++) {
+      if (this.allowed[i] == value) return true;
+    };
+    
+    return false;
+  }
+});
+
+/**
+ * @class ExtMVC.model.plugin.validation.ValidatesExclusionOf
+ * @extends ExtMVC.model.plugin.validation.AbstractValidation
+ * Ensures that the field is not one of the allowed values. See {*link ExtMVC.model.plugin.validation.AbstractValidation AbstractValidation} for example.
+ */
+ExtMVC.model.plugin.validation.ValidatesExclusionOf = Ext.extend(ExtMVC.model.plugin.validation.AbstractValidation, {
+
+  /**
+   * Override Abstract constructor to build the validation message
+   * @ignore
+   */
+  constructor: function(m, f, config) {
+    //set up defaults
+    config = config || {};
+    Ext.applyIf(config, { disallowed: [] });
+    
+    ExtMVC.model.plugin.validation.ValidatesExclusionOf.superclass.constructor.call(this, m, f, config);
+    
+    Ext.applyIf(this, {
+      message: 'must not be ' + this.disallowed.toSentence('or')
+    });
+  },
+  
+  /**
+   * Returns true if the value of this field is one of those specified in this.allowed
+   * @return {Boolean} True if the field's value is allowed
+   */
+  isValid: function(instance) {
+    var value = this.getValue(instance),
+        valid = true;
+    
+    for (var i=0; i < this.disallowed.length; i++) {
+      if (this.disallowed[i] == value) valid = false;
+    };
+    
+    return valid;
+  }
+});
+
+/**
+ * @class ExtMVC.model.plugin.validation.ValidatesFormatOf
+ * @extends ExtMVC.model.plugin.validation.AbstractValidation
+ * Ensures that the field matches the given regular expression. See {*link ExtMVC.model.plugin.validation.AbstractValidation AbstractValidation} for example.
+ */
+ExtMVC.model.plugin.validation.ValidatesFormatOf = Ext.extend(ExtMVC.model.plugin.validation.AbstractValidation, {
+  
+  /**
+   * @property message
+   * @type String
+   * The default message to return if this validation does not pass
+   */
+  message: 'is invalid',
+  
+  /**
+   * Returns true if the value of this field matches the suppled regular expression
+   * @return {Boolean} True if the field's value matches
+   */
+  isValid: function(instance) {
+    return this.regex.test(this.getValue(instance));
+  }
+});

data/test/app/vendor/extjs-mvc/overrides/Ext.Component.js

@@ -0,0 +1,21 @@
+/**
+ * Override how getXTypes works so that it doesn't require that every single class has
+ * an xtype registered for it.
+ */
+Ext.override(Ext.Component, {
+  getXTypes : function(){
+      var tc = this.constructor;
+      if(!tc.xtypes){
+          var c = [], sc = this;
+          while(sc){ //was: while(sc && sc.constructor.xtype) {
+            var xtype = sc.constructor.xtype;
+            if (xtype != undefined) c.unshift(xtype);
+            
+            sc = sc.constructor.superclass;
+          }
+          tc.xtypeChain = c;
+          tc.xtypes = c.join('/');
+      }
+      return tc.xtypes;
+  }
+});

data/test/app/vendor/extjs-mvc/overrides/Ext.extend.js

@@ -0,0 +1,142 @@
+// /**
+//  * An extension to Ext.extend which calls the extended object's onExtended function, if it exists
+//  * The only lines that are different from vanilla Ext.extend are the 2 before the return sb statement
+//  */
+// Ext.extend = function(){
+//     // inline overrides
+//     var io = function(o){
+//         for(var m in o){
+//             this[m] = o[m];
+//         }
+//     };
+//     var oc = Object.prototype.constructor;
+//     
+//     return function(sb, sp, overrides){
+//         if(Ext.isObject(sp)){
+//             overrides = sp;
+//             sp = sb;
+//             sb = overrides.constructor!= oc ? overrides.constructor : function(){sp.apply(this, arguments);};
+//         }
+//         var F = function(){},
+//             sbp,
+//             spp = sp.prototype;
+// 
+//         F.prototype = spp;
+//         sbp = sb.prototype = new F();
+//         sbp.constructor=sb;
+//         sb.superclass=spp;
+//         if(spp.constructor == oc){
+//             spp.constructor=sp;
+//         }
+//         sb.override = function(o){
+//             Ext.override(sb, o);
+//         };
+//         sbp.superclass = sbp.supr = (function(){
+//             return spp;
+//         });
+//         sbp.override = io;
+//         Ext.override(sb, overrides);
+//         sb.extend = function(o){Ext.extend(sb, o);};
+//         
+//         var extendFunction = sb.prototype.onExtended;
+//         if (extendFunction) extendFunction.call(sb.prototype);
+//         
+//         return sb;
+//     };
+// }();
+
+// (function() {
+//   var inlineOverrides = function(o) {
+//     for(var m in o){
+//       this[m] = o[m];
+//     }
+//   };
+//   
+//   //reference to the constructor of Object - we can match against this so as not to extend improperly
+//   var objectConstructor = Object.prototype.constructor;
+//   
+//   /**
+//    * Returns true if the given function is the bottom level Object object. We use this to test if we are
+//    * extending Object directly, or some subclass of Object.
+//    * @param {Object} superclass The superclass constructor function
+//    */
+//   var superclassIsObject = function(superclass) {
+//     return superclass.prototype.constructor == objectConstructor;
+//   };
+//   
+//   Ext.extend = function() {
+//     //this method has two different signatures - 2 or 3 arguments
+//     if (arguments.length == 3) {
+//       // 3 arguments - where we're given the subclass constructor function, the superclass and some overrides
+//       var subclassConstructor = arguments[0],
+//           superclass          = arguments[1],
+//           overrides           = arguments[2];
+//     } else {
+//       // 2 arguments - where we're just given the superclass and some overrides
+//       var superclass          = arguments[0],
+//           overrides           = arguments[1];
+//       
+//       // Because we weren't given a subclass constructor, make one now
+//       var subclassConstructor = overrides.constructor == objectConstructor
+//                               ? function(){superclass.apply(this, arguments);} //TODO: Explain this
+//                               : overrides.constructor;
+//     }
+//     
+//     //This is the beginnings of our new class - just an empty function for now
+//     var F = function() {};
+//     
+//     //set our new class' prototype to the same as the superclass
+//     F.prototype = superclass.prototype;
+//     
+//     // This is where the actual 'inheritance' happens. In JavaScript we extend objects by setting the prototype
+//     // of a new object to an instance of an existing one
+//     subclassConstructor.prototype =  new F();
+//     
+//     // We'll use the subclass and superclass prototypes a lot, so get references to them here
+//     var subclassProto   = subclassConstructor.prototype,
+//         superclassProto = superclass.prototype;
+//     
+//     //Tell our new subclass its constructor
+//     subclassProto.constructor = subclassConstructor;
+//     
+//     //TODO: Here we're giving the subclass's constructor FUNCTION a supertype property, which is set to the prototype
+//     //of the supertype... why?
+//     subclassConstructor.superclass = superclass.prototype;
+//     
+//     // TODO: Explain this
+//     if (superclassIsObject(superclass)) superclassProto.constructor = superclass;
+//     
+//     //This is what enables your to do things like MyExtendedClass.superclass.initComponent.apply(this, arguments);
+//     subclassProto.superclass = subclassProto.supr = function() {
+//       return superclassProto;
+//     };
+//     
+//     subclassProto.override = inlineOverrides;
+//     Ext.override(subclassConstructor, overrides);
+//     
+//     //Here we're adding override and extend to the constructor Function itself... for some reason (e.g. Ext.Window.override({}))
+//     Ext.apply(subclassConstructor, {
+//       extend: function(o){
+//         Ext.extend(subclassConstructor, o);
+//       },
+//       override: function(o) {
+//         Ext.override(subclassConstructor, o);
+//       }
+//     });
+//     
+//     return subclassConstructor;
+//   };
+// })();
+
+
+
+
+
+
+
+
+
+
+
+
+

data/test/app/vendor/extjs-mvc/spec/Array.spec.js

@@ -0,0 +1,15 @@
+Screw.Unit(function() {
+  describe("Array extensions", function() {
+    describe("toSentence", function() {
+      var array = ['Adama', 'Tigh', 'Roslin'];
+      
+      it("should join an array using and by default", function() {
+        expect(array.toSentence()).to(equal, "Adama, Tigh and Roslin");
+      });
+      
+      it("should allow specification of a custom connector string", function() {
+        expect(array.toSentence('or')).to(equal, "Adama, Tigh or Roslin");
+      });
+    });
+  });
+});