extjs-mvc 0.4.0.f → 0.4.0.g

data/lib/src/model/validations/Validations.js

@@ -1,276 +0,0 @@
-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/lib/src/overrides/Ext.Component.js

@@ -1,21 +0,0 @@
-/**
- * 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/lib/src/overrides/Ext.extend.js

@@ -1,142 +0,0 @@
-// /**
-//  * 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/lib/src/spec/Array.spec.js

@@ -1,15 +0,0 @@
-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");
-      });
-    });
-  });
-});