sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/frameworks/sproutcore/frameworks/foundation/validators/number.js

@@ -0,0 +1,82 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('validators/validator') ;
+
+/**
+  Handles parsing and validating of numbers.
+  
+  @extends SC.Validator
+  @author Charles Jolley
+  @version 1.0
+  @class
+*/
+SC.Validator.Number = SC.Validator.extend(
+/** @scope SC.Validator.Number.prototype */ {
+
+  /**
+    Number of decimal places to show.  
+    
+    If 0, then numbers will be treated as integers.  Otherwise, numbers will
+    show with a fixed number of decimals.
+  */
+  places: 0,
+  
+  fieldValueForObject: function(object, form, field) {
+    switch(SC.typeOf(object)) {
+      case SC.T_NUMBER:
+        object = object.toFixed(this.get('places')) ;
+        break ;
+      case SC.T_NULL:
+      case SC.T_UNDEFINED:
+        object = '';
+        break ;
+    }
+    return object ;
+  },
+
+  objectForFieldValue: function(value, form, field) {
+    
+    // strip out commas
+    value = value.replace(/,/g,'');
+    
+    switch(SC.typeOf(value)) {
+      case SC.T_STRING:
+        if (value.length == '') {
+          value = null ;
+        } else if (this.get('places') > 0) {
+          value = parseFloat(value) ;
+        } else {
+          value = parseInt(value,0) ;
+        }
+        break ;
+      case SC.T_NULL:
+      case SC.T_UNDEFINED:
+        value = null ;
+        break ;
+    }
+    return value ;
+  },
+  
+  validate: function(form, field) { 
+    var value = field.get('fieldValue') ;
+    return (value == '') || !(isNaN(value) || isNaN(parseFloat(value))) ; 
+  },
+  
+  validateError: function(form, field) {
+    var label = field.get('errorLabel') || 'Field' ;
+    return SC.$error("Invalid.Number(%@)".loc(label), label) ;
+  },
+  
+  /** 
+    Allow only numbers, dashes, period, and commas
+  */
+  validateKeyDown: function(form, field, charStr) {
+    return !!charStr.match(/[0-9\.,\-]/);
+  }
+    
+}) ;

data/frameworks/sproutcore/frameworks/foundation/validators/password.js

@@ -0,0 +1,86 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('validators/validator') ;
+
+/**
+  Ensures all fields with the Password validator attached in the same form
+  contain the same value.
+  
+  @class
+  @extends SC.Validator
+  @author Charles Jolley
+  @version 1.0
+*/
+SC.Validator.Password = SC.Validator.extend(
+/** @scope SC.Validator.Password.prototype */ {
+
+  attachTo: function(form,field) {
+    sc_super();
+    if (!this.fields) this.fields = [] ;
+    this.fields.push(field) ;
+  },
+
+  validate: function(force) {
+    if (!this.fields || this.fields.length == 0) return true ;
+    
+    var empty = false ;
+    var notEmpty = false ;
+    var ret = true ;
+    var value = this.fields[0].get('fieldValue') ;
+    this.fields.forEach(function(field) {
+      var curValue = field.get('fieldValue') ;
+      if (curValue != value) ret= false ;
+      if (!curValue || curValue.length == 0) empty = true ;
+      if (curValue && curValue.length > 0) notEmpty = true ;
+    }) ;
+
+    // if forces, valid OK if there was an empty.  If not forced, valid OK 
+    // only if all fields match AND they are not all empty.
+    if (force) {
+      return (notEmpty == false) ? false : ret ;
+    } else {
+      return (empty == true) ? true : ret ;
+    }
+  },
+  
+  // update field states
+  updateFields: function(form,valid) {
+    if (!this.fields || this.fields.length == 0) return true ;
+    var err = "Invalid.Password".loc();
+    var topField = this._field ;
+    this.fields.forEach(function(f) {
+      var msg = (valid) ? null : ((f == topField) ? err : '') ;
+      form.setErrorFor(f,msg) ;
+    }) ;
+    return (valid) ? SC.VALIDATE_OK : err ;
+  },
+  
+  validateChange: function(form, field, oldValue) { 
+    return this.updateFields(form, this.validate(false)) ;
+  },
+
+  // this method is called just before the form is submitted.
+  // field: the field toe validate.
+  validateSubmit: function(form, field) { 
+    return this.updateFields(form, this.validate(true)) ;
+  },
+
+  // this method gets called 1ms after the user types a key (if a change is
+  // allowed).  You can use this validate the new partial string and return 
+  // an error if needed.
+  //
+  // The default will validate a partial only if there was already an error.
+  // this allows the user to try to get it right before you bug them.
+  validatePartial: function(form, field) {
+    var isInvalid = !this._field.get('isValid') ;
+    if (isInvalid) {
+      return this.updateFields(form, this.validate(false)) ;
+    } else return SC.VALIDATE_NO_CHANGE ;
+  }
+    
+}) ;

data/frameworks/sproutcore/frameworks/foundation/validators/validator.js

@@ -0,0 +1,311 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+SC.VALIDATE_OK = YES;
+SC.VALIDATE_NO_CHANGE = NO;
+
+/**
+  @class
+  
+  Validators provide a way for you to implement simple form field validation
+  and transformation.  To use a validator, simply name the validator in the
+  "validate" attribute in your text field.  For example, if you want to
+  validate a field using the PhoneNumberValidator use this:
+
+  <input value="1234567890" validate="phone-number" />
+
+  Validators get notified at three points.  You can implement one or all
+  of these methods to support validation.  All of the validate methods except
+  for validateKeypress behave the same way.  You are passed a form, field,
+  and possibly the oldValue.  You are expected to return Validator.OK or
+  an error string.  Inside this method you typically do one of all of the
+  following:
+
+  1. You can simply validate the field value and return OK or an error str
+  
+  2. You can modify the field value (for example, you could format the
+     string to match some predefined format).
+     
+  3. If you need to roundtrip the server first to perform validation, you can
+     return Validator.OK, then save the form and field info until after the
+     roundtrip.  On return, if there is a problem, first verify the field
+     value has not changed and then call form.errorFor(field,str) ;
+
+  @extends SC.Object
+  @since SproutCore 1.0
+*/
+SC.Validator = SC.Object.extend(
+/** @scope SC.Validator.prototype */ {
+
+  // ..........................................
+  // OBJECT VALUE CONVERSION
+  //
+  // The following methods are used to convert the string value of a field
+  // to and from an object value.  The default implementations return
+  // the string, but you can override this to provide specific behaviors. 
+  // For example, you might add or remove a dollar sign or convert the 
+  // value to a number.
+  
+/**
+  Returns the value to set in the field for the passed object value.  
+  
+  The form and view to be set MAY (but will not always) be passed also.  You
+  should override this method to help convert an input object into a value
+  that can be displayed by the field.  For example, you might convert a 
+  date to a property formatted string or a number to a properly formatted
+  value.
+  
+  @param {Object} object The object to transform
+  @param {SC.FormView} form The form this field belongs to. (optional)
+  @param {SC.View} view The view the value is required for.
+  @returns {Object} a value (usually a string) suitable for display
+*/
+  fieldValueForObject: function(object, form, view) { return object; },
+  
+  /**
+    Returns the object value for the passed string.
+    
+    The form and view MAY (but wil not always) be passed also.  You should
+    override this method to convert a field value, such as string, into an
+    object value suitable for consumption by the rest of the app.  For example
+    you may convert a string into a date or a number.
+    
+    @param {String} value the field value.  (Usually a String).
+    @param {SC.FormView} form The form this field belongs to. (optional)
+    @param {SC.View} view The view this value was pulled from.
+    @returns {Object} an object suitable for consumption by the app.
+  */
+  objectForFieldValue: function(value, form, view) { return value; },
+  
+  // ..........................................
+  // VALIDATION PRIMITIVES
+  //
+
+  /**
+    Validate the field value.  
+    
+    You can implement standard behavior for your validator by using the validate() and validateError() methods.  validate() should return NO if the field is not valid, YES otherwise.  If you return NO from this method, then the validateError() method will be called so you can generate an error object describing the specific problem.
+
+    @param {SC.FormView} form the form this view belongs to
+    @param {SC.View} field the field to validate.  Responds to fieldValue.
+    @returns {Boolean} YES if field is valid.
+  */
+  validate: function(form, field) { return true; },
+
+  /**
+    Returns an error object if the field is invalid.
+  
+    This is the other standard validator method that can be used to impement basic validation.  Return an error object explaining why the field is not valid.  It will only be called if validate() returned NO.
+    
+    The default implementation of htis method returns a generic error message with the loc string "Invalid.Generate({fieldValue})".  You can simply define this loc string in strings.js if you prefer or you can override this method to provide a more specific error message.
+  
+    @param {SC.FormView} form the form this view belongs to
+    @param {SC.View} field the field to validate.  Responds to fieldValue.
+    @returns {SC.Error} an error object
+  */
+  validateError: function(form, field) { 
+    return SC.$error(
+      "Invalid.General(%@)".loc(field.get('fieldValue')),
+      field.get('fieldKey')) ; 
+  },
+
+  // ..........................................
+  // VALIDATION API
+  //
+
+  /**
+    Invoked just before the user ends editing of the field.
+
+    This is a primitive validation method.  You can implement the two higher-level methods (validate() and validateError()) if you prefer.
+    
+    The default implementation calls your validate() method and then validateError() if valiate() returns NO.  This method should return SC.VALIDATE_OK if validation succeeded or an error object if it fails.
+  
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+    @param {Object} oldValue: the value of the field before the change
+
+    @returns SC.VALIDATE_OK or an error object.
+  
+  */
+  validateChange: function(form, field, oldValue) { 
+    return this.validate(form,field) ? SC.VALIDATE_OK : this.validateError(form, field);
+  },
+
+  /**
+    Invoked just before the form is submitted.
+  
+    This method gives your validators one last chance to perform validation
+    on the form as a whole.  The default version does the same thing as the 
+    validateChange() method.
+  
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+
+    @returns SC.VALIDATE_OK or an error object.
+  
+  */  
+  validateSubmit: function(form, field) { 
+    return this.validate(form,field) ? SC.VALIDATE_OK : this.validateError(form, field);
+  },
+
+  /**
+    Invoked 1ms after the user types a key (if a change is allowed).  
+  
+    You can use this validate the new partial string and return an error if 
+    needed. The default will validate a partial only if there was already an 
+    error. This allows the user to try to get it right before you bug them.
+  
+    Unlike the other methods, you should return SC.VALIDATE_NO_CHANGE if you
+    did not actually validate the partial string.  If you return 
+    SC.VALIDATE_OK then any showing errors will be hidden.
+  
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+
+    @returns SC.VALIDATE_OK, SC.VALIDATE_NO_CHANGE or an error object.
+  */  
+  validatePartial: function(form, field) { 
+    if (!field.get('isValid')) {
+      return this.validate(form,field) ? SC.VALIDATE_OK : this.validateError(form, field);
+    } else return SC.VALIDATE_NO_CHANGE ;
+  },
+  
+  /**
+    Invoked when the user presses a key.  
+  
+    This method is used to restrict the letters and numbers the user is 
+    allowed to enter.  You should not use this method to perform full 
+    validation on the field.  Instead use validatePartial().
+  
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+    @param {String} char the characters being added
+    
+    @returns {Boolean} YES if allowed, NO otherwise
+  */
+  validateKeyDown: function(form, field,charStr) { return true; },
+
+  // .....................................
+  // OTHER METHODS
+
+  /**
+    Called on all validators when they are attached to a field.  
+  
+    You can use this to do any setup that you need.  The default does nothing.
+    
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+  */
+  attachTo: function(form,field) { },
+
+  /**
+    Called on a validator just before it is removed from a field.  You can 
+    tear down any setup you did for the attachTo() method.
+    
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+  */
+  detachFrom: function(form, field) {}
+
+}) ;
+
+SC.Validator.mixin(/** @scope SC.Validator */ {
+
+  /**
+    Return value when validation was performed and value is OK.
+  */
+  OK: true, 
+  
+  /**
+    Return value when validation was not performed.
+  */
+  NO_CHANGE: false,  
+
+  /**
+    Invoked by a field whenever a validator is attached to the field.
+    
+    The passed validatorKey can be a validator instance, a validator class
+    or a string naming a validator. To make your validator
+    visible, you should name your validator under the SC.Validator base.
+    for example SC.Validator.Number would get used for the 'number' 
+    validator key.
+  
+    This understands validatorKey strings in the following format:
+
+    * 'key' or 'multiple_words' will find validators Key and MultipleWords
+
+    * if you want to share a single validator among multiple fields (for
+      example to validate that two passwords are the same) set a name inside
+      brackets. i.e. 'password[pwd]'.
+
+    @param {SC.FormView} form the form for the field
+    @param {SC.View} field the field to validate
+    @param {Object} validatorKey the key to validate
+    
+    @returns {SC.Validator} validator instance or null
+  */  
+  findFor: function(form,field, validatorKey) {
+    
+    // Convert the validator into a validator instance.
+    var validator ;
+    if (!validatorKey) return ; // nothing to do...
+    
+    if (validatorKey instanceof SC.Validator) {
+      validator = validatorKey ;
+    } else if (validatorKey.isClass) {
+      validator = validatorKey.create() ;
+      
+    } else if (SC.typeOf(validatorKey) === SC.T_STRING) {
+
+      // extract optional key name
+      var name = null ;
+      var m = validatorKey.match(/^(.+)\[(.*)\]/) ;
+      if (m) {
+        validatorKey = m[1] ; name = m[2]; 
+      }
+      
+      // convert the validatorKey name into a class.
+      validatorKey = validatorKey.classify() ;
+      var validatorClass = SC.Validator[validatorKey] ;
+      if (SC.none(validatorClass)) {
+        throw "validator %@ not found for %@".fmt(validatorKey, field) ;
+      } else if (name) {
+
+        // if a key was also passed, then find the validator in the list of
+        // validators for the form.  Otherwise, just create a new instance.
+        if (!form) {
+          throw "named validator (%@) could not be found for field %@ because the field does not belong to a form".fmt(name,field) ;
+        }
+        
+        if (!form._validatorHash) form._validatorHash = {} ;
+        validator = (name) ? form._validatorHash[name] : null ;
+        if (!validator) validator = validatorClass.create() ;
+        if (name) form._validatorHash[name] = validator ;
+      } else validator = validatorClass.create() ;
+    } 
+    
+    return validator ;
+  },
+  
+  /**
+    Convenience class method to call the fieldValueForObject() instance
+    method you define in your subclass.
+  */
+  fieldValueForObject: function(object, form, field) {
+    return this.prototype.fieldValueForObject(object,form,field) ;
+  },
+
+  /**
+    Convenience class method to call the objectForFieldValue() instance
+    method you define in your subclass.
+  */
+  objectForFieldValue: function(value, form, field) {
+    return this.prototype.objectForFieldValue(value,form,field) ;
+  }
+  
+}) ;
+

data/frameworks/sproutcore/frameworks/foundation/views/container.js

@@ -0,0 +1,136 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('views/view') ;
+
+/** 
+  @class
+  
+  A container view will display its "content" view as its only child.  You can
+  use a container view to easily swap out views on your page.  In addition to
+  displaying the actual view in the content property, you can also set the 
+  nowShowing property to the property path of a view in your page and the
+  view will be found and swapped in for you.
+  
+  If you want to change the way the container view swaps in your new view, 
+  override the replaceContent() method.
+  
+  @extends SC.View
+  @since SproutCore 1.0
+*/
+SC.ContainerView = SC.View.extend(
+/** @scope SC.ContainerView.prototype */ {
+
+  classNames: ['sc-container-view'],
+  
+  /**
+    Optional path name for the content view.  Set this to a property path 
+    pointing to the view you want to display.  This will automatically change
+    the content view for you.  If you pass a single property name (e.g.
+    "myView") then the container view will look up the property on its own 
+    page object.  If you pass a full property name 
+    (e.g. "MyApp.anotherPage.anotherView"), then the path will be followed 
+    from the top-level.
+    
+    @property {String, SC.View}
+  */
+  nowShowing: null,
+
+  /** 
+    The content view to display.  This will become the only child view of
+    the view.  Note that if you set the nowShowing property to any value other
+    than 'null', the container view will automatically change the contentView
+    to reflect view indicated by the value.
+    
+    @property {SC.View}
+  */
+  contentView: null,
+  
+  /** @private */
+  contentViewBindingDefault: SC.Binding.single(),
+  
+  /**
+    Replaces any child views with the passed new content.  
+    
+    This method is automatically called whenever your contentView property 
+    changes.  You can override it if you want to provide some behavior other
+    than the default.
+    
+    @param {SC.View} newContent the new content view or null.
+  */
+  replaceContent: function(newContent) {
+    this.removeAllChildren() ;
+    if (newContent) this.appendChild(newContent) ;
+  },
+
+  /** @private */
+  createChildViews: function() {
+    // if contentView is defined, then create the content
+    var view = this.contentView ;
+    if (view) {
+      view = this.contentView = this.createChildView(view) ;
+      this.childViews = [view] ;
+    } 
+  },
+  
+  /**
+    When a container view awakes, it will try to find the nowShowing, if 
+    there is one, and set it as content if necessary.
+  */
+  awake: function() {
+    sc_super();
+    var nowShowing = this.get('nowShowing') ;
+    if (nowShowing && nowShowing.length>0) this.nowShowingDidChange();
+  },
+  
+  /**
+    Invoked whenever the nowShowing property changes.  This will try to find
+    the new content if possible and set it.  If you set nowShowing to an 
+    empty string or null, then the current content will be cleared.
+    
+    If you set the content manually, the nowShowing property will be set to
+    SC.CONTENT_SET_DIRECTLY
+  */
+  nowShowingDidChange: function() {
+    var nowShowing = this.get('nowShowing') ;
+    var content = null;
+    //its a property path
+    if(SC.typeOf(nowShowing) === SC.T_STRING){
+      // if nowShowing was set because the content was set directly, then 
+      // do nothing.
+      if (nowShowing === SC.CONTENT_SET_DIRECTLY) return ;
+
+      // otherwise, if nowShowing is a non-empty string, try to find it...
+      if (nowShowing && nowShowing.length>0) {
+        if (nowShowing.indexOf('.')>0) {
+          content = SC.objectForPropertyPath(nowShowing, null);
+        } else {
+          content = SC.objectForPropertyPath(nowShowing, this.get('page'));
+        }
+      }
+    }else{ //its a view
+      content = nowShowing;
+    }
+
+    
+    // only allow views
+    if (content && !(content instanceof SC.View)) content = null;
+    
+    // set content
+    this.set('contentView', content) ;
+  }.observes('nowShowing'),
+  
+  /**
+    Invoked whenever the content property changes.  This method will simply
+    call replaceContent.  Override replaceContent to change how the view is
+    swapped out.
+  */
+  contentViewDidChange: function() {
+    this.replaceContent(this.get('contentView'));
+  }.observes('contentView')
+  
+}) ;