ÿþ// LiveValidation 1.3 (standalone version)

// Copyright (c) 2007-2008 Alec Hill (www.livevalidation.com)

// LiveValidation is licensed under the terms of the MIT License



/*********************************************** LiveValidation class ***********************************/



/**

 *	validates a form field in real-time based on validations you assign to it

 *	

 *	@var element {mixed} - either a dom element reference or the string id of the element to validate

 *	@var optionsObj {Object} - general options, see below for details

 *

 *	optionsObj properties:

 *							validMessage {String} 	- the message to show when the field passes validation

 *													  (DEFAULT: "Thankyou!")

 *							onValid {Function} 		- function to execute when field passes validation

 *													  (DEFAULT: function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); } )	

 *							onInvalid {Function} 	- function to execute when field fails validation

 *													  (DEFAULT: function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); })

 *							insertAfterWhatNode {Int} 	- position to insert default message

 *													  (DEFAULT: the field that is being validated)	

 *              onlyOnBlur {Boolean} - whether you want it to validate as you type or only on blur

 *                            (DEFAULT: false)

 *              wait {Integer} - the time you want it to pause from the last keystroke before it validates (ms)

 *                            (DEFAULT: 0)

 *              onlyOnSubmit {Boolean} - whether should be validated only when the form it belongs to is submitted

 *                            (DEFAULT: false)						

 */

var LiveValidation = function(element, optionsObj){

  	this.initialize(element, optionsObj);

}



LiveValidation.VERSION = '1.3 standalone';



/** element types constants ****/



LiveValidation.TEXTAREA 		= 1;

LiveValidation.TEXT 			    = 2;

LiveValidation.PASSWORD 		= 3;

LiveValidation.CHECKBOX 		= 4;

LiveValidation.SELECT = 5;

LiveValidation.FILE = 6;



/****** Static methods *******/



/**

 *	pass an array of LiveValidation objects and it will validate all of them

 *	

 *	@var validations {Array} - an array of LiveValidation objects

 *	@return {Bool} - true if all passed validation, false if any fail						

 */

LiveValidation.massValidate = function(validations){

  var returnValue = true;

	for(var i = 0, len = validations.length; i < len; ++i ){

		var valid = validations[i].validate();

		if(returnValue) returnValue = valid;

	}

	return returnValue;

}



/****** prototype ******/



LiveValidation.prototype = {



    validClass: 'LV_valid',

    invalidClass: 'LV_invalid',

    messageClass: 'LV_validation_message',

    validFieldClass: 'LV_valid_field',

    invalidFieldClass: 'LV_invalid_field',



    /**

     *	initialises all of the properties and events

     *

     * @var - Same as constructor above

     */

    initialize: function(element, optionsObj){

      var self = this;

      if(!element) throw new Error("LiveValidation::initialize - No element reference or element id has been provided!");

    	this.element = element.nodeName ? element : document.getElementById(element);

    	if(!this.element) throw new Error("LiveValidation::initialize - No element with reference or id of '" + element + "' exists!");

      // default properties that could not be initialised above

    	this.validations = [];

      this.elementType = this.getElementType();

      this.form = this.element.form;

      // options

    	var options = optionsObj || {};

    	this.validMessage = options.validMessage || '"';

    	

    	

    	var node = options.insertAfterWhatNode || this.element;

		this.insertAfterWhatNode = node.nodeType ? node : document.getElementById(node);

      this.onValid = options.onValid || function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); };

      this.onInvalid = options.onInvalid || function(){ this.insertMessage(this.createMessageSpan()); this.addFieldClass(); };	

    	this.onlyOnBlur =  options.onlyOnBlur || false;

    	this.wait = options.wait || 0;

      this.onlyOnSubmit = options.onlyOnSubmit || false;

      // add to form if it has been provided

      if(this.form){

        this.formObj = LiveValidationForm.getInstance(this.form);

        this.formObj.addField(this);

      }

      // events

      // collect old events

      this.oldOnFocus = this.element.onfocus || function(){};

      this.oldOnBlur = this.element.onblur || function(){};

      this.oldOnClick = this.element.onclick || function(){};

      this.oldOnChange = this.element.onchange || function(){};

      this.oldOnKeyup = this.element.onkeyup || function(){};

      this.element.onfocus = function(e){ self.doOnFocus(e); return self.oldOnFocus.call(this, e); }

      if(!this.onlyOnSubmit){

        switch(this.elementType){

          case LiveValidation.CHECKBOX:

            this.element.onclick = function(e){ self.validate(); return self.oldOnClick.call(this, e); }

          // let it run into the next to add a change event too

          case LiveValidation.SELECT:

          case LiveValidation.FILE:

            this.element.onchange = function(e){ self.validate(); return self.oldOnChange.call(this, e); }

            break;

          default:

            if(!this.onlyOnBlur) this.element.onkeyup = function(e){ self.deferValidation(); return self.oldOnKeyup.call(this, e); }

      	    this.element.onblur = function(e){ self.doOnBlur(e); return self.oldOnBlur.call(this, e); }

        }

      }

    },

	

	/**

     *	destroys the instance's events (restoring previous ones) and removes it from any LiveValidationForms

     */

    destroy: function(){

  	  if(this.formObj){

		// remove the field from the LiveValidationForm

		this.formObj.removeField(this);

		// destroy the LiveValidationForm if no LiveValidation fields left in it

		this.formObj.destroy();

	  }

      // remove events - set them back to the previous events

	  this.element.onfocus = this.oldOnFocus;

      if(!this.onlyOnSubmit){

        switch(this.elementType){

          case LiveValidation.CHECKBOX:

            this.element.onclick = this.oldOnClick;

          // let it run into the next to add a change event too

          case LiveValidation.SELECT:

          case LiveValidation.FILE:

            this.element.onchange = this.oldOnChange;

            break;

          default:

            if(!this.onlyOnBlur) this.element.onkeyup = this.oldOnKeyup;

      	    this.element.onblur = this.oldOnBlur;

        }

      }

      this.validations = [];

	  this.removeMessageAndFieldClass();

    },

    

    /**

     *	adds a validation to perform to a LiveValidation object

     *

     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )

     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary

     * @return {Object} - the LiveValidation object itself so that calls can be chained

     */

    add: function(validationFunction, validationParamsObj){

      this.validations.push( {type: validationFunction, params: validationParamsObj || {} } );

      return this;

    },

    

	/**

     *	removes a validation from a LiveValidation object - must have exactly the same arguments as used to add it 

     *

     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )

     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary

     * @return {Object} - the LiveValidation object itself so that calls can be chained

     */

    remove: function(validationFunction, validationParamsObj){

	  var found = false;

	  for( var i = 0, len = this.validations.length; i < len; i++ ){

	  		if( this.validations[i].type == validationFunction ){

				if (this.validations[i].params == validationParamsObj) {

					found = true;

					break;

				}

			}

	  }

      if(found) this.validations.splice(i,1);

      return this;

    },

    

	

    /**

     * makes the validation wait the alotted time from the last keystroke 

     */

    deferValidation: function(e){

      if(this.wait >= 300) this.removeMessageAndFieldClass();

    	var self = this;

      if(this.timeout) clearTimeout(self.timeout);

      this.timeout = setTimeout( function(){ self.validate() }, self.wait); 

    },

        

    /**

     * sets the focused flag to false when field loses focus 

     */

    doOnBlur: function(e){

      this.focused = false;

      this.validate(e);

    },

        

    /**

     * sets the focused flag to true when field gains focus 

     */

    doOnFocus: function(e){

      this.focused = true;

      this.removeMessageAndFieldClass();

    },

    

    /**

     *	gets the type of element, to check whether it is compatible

     *

     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )

     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary

     */

    getElementType: function(){

      switch(true){

        case (this.element.nodeName.toUpperCase() == 'TEXTAREA'):

        return LiveValidation.TEXTAREA;

      case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'TEXT'):

        return LiveValidation.TEXT;

      case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'PASSWORD'):

        return LiveValidation.PASSWORD;

      case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'CHECKBOX'):

        return LiveValidation.CHECKBOX;

      case (this.element.nodeName.toUpperCase() == 'INPUT' && this.element.type.toUpperCase() == 'FILE'):

        return LiveValidation.FILE;

      case (this.element.nodeName.toUpperCase() == 'SELECT'):

        return LiveValidation.SELECT;

        case (this.element.nodeName.toUpperCase() == 'INPUT'):

        	throw new Error('LiveValidation::getElementType - Cannot use LiveValidation on an ' + this.element.type + ' input!');

        default:

        	throw new Error('LiveValidation::getElementType - Element must be an input, select, or textarea!');

      }

    },

    

    /**

     *	loops through all the validations added to the LiveValidation object and checks them one by one

     *

     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )

     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary

     * @return {Boolean} - whether the all the validations passed or if one failed

     */

    doValidations: function(){

      	this.validationFailed = false;

      	for(var i = 0, len = this.validations.length; i < len; ++i){

    	 	var validation = this.validations[i];

    		switch(validation.type){

    		   	case Validate.Presence:

                case Validate.Confirmation:

                case Validate.Acceptance:

    		   		this.displayMessageWhenEmpty = true;

    		   		this.validationFailed = !this.validateElement(validation.type, validation.params); 

    				break;

    		   	default:

    		   		this.validationFailed = !this.validateElement(validation.type, validation.params);

    		   		break;

    		}

    		if(this.validationFailed) return false;	

    	}

    	this.message = this.validMessage;

    	return true;

    },

    

    /**

     *	performs validation on the element and handles any error (validation or otherwise) it throws up

     *

     *	@var validationFunction {Function} - validation function to be used (ie Validate.Presence )

     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary

     * @return {Boolean} - whether the validation has passed or failed

     */

    validateElement: function(validationFunction, validationParamsObj){

      	var value = (this.elementType == LiveValidation.SELECT) ? this.element.options[this.element.selectedIndex].value : this.element.value;     

        if(validationFunction == Validate.Acceptance){

    	    if(this.elementType != LiveValidation.CHECKBOX) throw new Error('LiveValidation::validateElement - Element to validate acceptance must be a checkbox!');

    		value = this.element.checked;

    	}

        var isValid = true;

      	try{    

    		validationFunction(value, validationParamsObj);

    	} catch(error) {

    	  	if(error instanceof Validate.Error){

    			if( value !== '' || (value === '' && this.displayMessageWhenEmpty) ){

    				this.validationFailed = true;

    				this.message = error.message;

    				isValid = false;

    			}

    		}else{

    		  	throw error;

    		}

    	}finally{

    	    return isValid;

        }

    },

    

    /**

     *	makes it do the all the validations and fires off the onValid or onInvalid callbacks

     *

     * @return {Boolean} - whether the all the validations passed or if one failed

     */

    validate: function(){

      if(!this.element.disabled){

		var isValid = this.doValidations();

		if(isValid){

			this.onValid();

			return true;

		}else {

			this.onInvalid();

			return false;

		}

	  }else{

      return true;

    }

    },

	

 /**

   *  enables the field

   *

   *  @return {LiveValidation} - the LiveValidation object for chaining

   */

  enable: function(){

  	this.element.disabled = false;

	return this;

  },

  

  /**

   *  disables the field and removes any message and styles associated with the field

   *

   *  @return {LiveValidation} - the LiveValidation object for chaining

   */

  disable: function(){

  	this.element.disabled = true;

	this.removeMessageAndFieldClass();

	return this;

  },

    

    /** Message insertion methods ****************************

     * 

     * These are only used in the onValid and onInvalid callback functions and so if you overide the default callbacks,

     * you must either impliment your own functions to do whatever you want, or call some of these from them if you 

     * want to keep some of the functionality

     */

    

    /**

     *	makes a span containg the passed or failed message

     *

     * @return {HTMLSpanObject} - a span element with the message in it

     */

    createMessageSpan: function(){

        var span = document.createElement('span');

    	var textNode = document.createTextNode(this.message);

      	span.appendChild(textNode);

        return span;

    },

    

    /**

     *	inserts the element containing the message in place of the element that already exists (if it does)

     *

     * @var elementToIsert {HTMLElementObject} - an element node to insert

     */

    insertMessage: function(elementToInsert){

      	this.removeMessage();

      	if( (this.displayMessageWhenEmpty && (this.elementType == LiveValidation.CHECKBOX || this.element.value == ''))

    	  || this.element.value != '' ){

            var className = this.validationFailed ? this.invalidClass : this.validClass;

    	  	elementToInsert.className += ' ' + this.messageClass + ' ' + className;

            if(this.insertAfterWhatNode.nextSibling){

    		  		this.insertAfterWhatNode.parentNode.insertBefore(elementToInsert, this.insertAfterWhatNode.nextSibling);

    		}else{

    			    this.insertAfterWhatNode.parentNode.appendChild(elementToInsert);

    	    }

    	}

    },

    

    

    /**

     *	changes the class of the field based on whether it is valid or not

     */

    addFieldClass: function(){

        this.removeFieldClass();

        if(!this.validationFailed){

            if(this.displayMessageWhenEmpty || this.element.value != ''){

                if(this.element.className.indexOf(this.validFieldClass) == -1) this.element.className += ' ' + this.validFieldClass;

            }

        }else{

            if(this.element.className.indexOf(this.invalidFieldClass) == -1) this.element.className += ' ' + this.invalidFieldClass;

        }

    },

    

    /**

     *	removes the message element if it exists, so that the new message will replace it

     */

    removeMessage: function(){

    	var nextEl;

    	var el = this.insertAfterWhatNode;

    	while(el.nextSibling){

    	    if(el.nextSibling.nodeType === 1){

    		  	nextEl = el.nextSibling;

    		  	break;

    		}

    		el = el.nextSibling;

    	}

      	if(nextEl && nextEl.className.indexOf(this.messageClass) != -1) this.insertAfterWhatNode.parentNode.removeChild(nextEl);

    },

    

    /**

     *	removes the class that has been applied to the field to indicte if valid or not

     */

    removeFieldClass: function(){

      if(this.element.className.indexOf(this.invalidFieldClass) != -1) this.element.className = this.element.className.split(this.invalidFieldClass).join('');

      if(this.element.className.indexOf(this.validFieldClass) != -1) this.element.className = this.element.className.split(this.validFieldClass).join(' ');

    },

        

    /**

     *	removes the message and the field class

     */

    removeMessageAndFieldClass: function(){

      this.removeMessage();

      this.removeFieldClass();

    }



} // end of LiveValidation class



/*************************************** LiveValidationForm class ****************************************/

/**

 * This class is used internally by LiveValidation class to associate a LiveValidation field with a form it is icontained in one

 * 

 * It will therefore not really ever be needed to be used directly by the developer, unless they want to associate a LiveValidation 

 * field with a form that it is not a child of

 */



/**

   *	handles validation of LiveValidation fields belonging to this form on its submittal

   *	

   *	@var element {HTMLFormElement} - a dom element reference to the form to turn into a LiveValidationForm

   */

var LiveValidationForm = function(element){

  this.initialize(element);

}



/**

 * namespace to hold instances

 */

LiveValidationForm.instances = {};



/**

   *	gets the instance of the LiveValidationForm if it has already been made or creates it if it doesnt exist

   *	

   *	@var element {HTMLFormElement} - a dom element reference to a form

   */

LiveValidationForm.getInstance = function(element){

  var rand = Math.random() * Math.random();

  if(!element.id) element.id = 'formId_' + rand.toString().replace(/\./, '') + new Date().valueOf();

  if(!LiveValidationForm.instances[element.id]) LiveValidationForm.instances[element.id] = new LiveValidationForm(element);

  return LiveValidationForm.instances[element.id];

}



LiveValidationForm.prototype = {

  

  /**

   *	constructor for LiveValidationForm - handles validation of LiveValidation fields belonging to this form on its submittal

   *	

   *	@var element {HTMLFormElement} - a dom element reference to the form to turn into a LiveValidationForm

   */

  initialize: function(element){

  	this.name = element.id;

    this.element = element;

    this.fields = [];

    // preserve the old onsubmit event

	this.oldOnSubmit = this.element.onsubmit || function(){};

    var self = this;

    this.element.onsubmit = function(e){

      return (LiveValidation.massValidate(self.fields)) ? self.oldOnSubmit.call(this, e || window.event) !== false : false;

    }

  },

  

  /**

   *	adds a LiveValidation field to the forms fields array

   *	

   *	@var element {LiveValidation} - a LiveValidation object

   */

  addField: function(newField){

    this.fields.push(newField);

  },

  

  /**

   *	removes a LiveValidation field from the forms fields array

   *	

   *	@var victim {LiveValidation} - a LiveValidation object

   */

  removeField: function(victim){

  	var victimless = [];

  	for( var i = 0, len = this.fields.length; i < len; i++){

		if(this.fields[i] !== victim) victimless.push(this.fields[i]);

	}

    this.fields = victimless;

  },

  

  /**

   *	destroy this instance and its events

   *

   * @var force {Boolean} - whether to force the detruction even if there are fields still associated

   */

  destroy: function(force){

  	// only destroy if has no fields and not being forced

  	if (this.fields.length != 0 && !force) return false;

	// remove events - set back to previous events

	this.element.onsubmit = this.oldOnSubmit;

	// remove from the instances namespace

	LiveValidationForm.instances[this.name] = null;

	return true;

  }

   

}// end of LiveValidationForm prototype



/*************************************** Validate class ****************************************/

/**

 * This class contains all the methods needed for doing the actual validation itself

 *

 * All methods are static so that they can be used outside the context of a form field

 * as they could be useful for validating stuff anywhere you want really

 *

 * All of them will return true if the validation is successful, but will raise a ValidationError if

 * they fail, so that this can be caught and the message explaining the error can be accessed ( as just 

 * returning false would leave you a bit in the dark as to why it failed )

 *

 * Can use validation methods alone and wrap in a try..catch statement yourself if you want to access the failure

 * message and handle the error, or use the Validate::now method if you just want true or false

 */



var Validate = {



    /**

     *	validates that the field has been filled in

     *

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation 

     *													  (DEFAULT: "Can't be empty!")

     */

    Presence: function(value, paramsObj){

      	var paramsObj = paramsObj || {};

      	var message = paramsObj.failureMessage || " ";

    	if(value === '' || value === null || value === undefined){ 

    	  	Validate.fail(message);

    	}

    	return true;

    },

    

    /**

     *	validates that the value is numeric, does not fall within a given range of numbers

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							notANumberMessage {String} - the message to show when the validation fails when value is not a number

     *													  	  (DEFAULT: "Must be a number!")

     *							notAnIntegerMessage {String} - the message to show when the validation fails when value is not an integer

     *													  	  (DEFAULT: "Must be a number!")

     *							wrongNumberMessage {String} - the message to show when the validation fails when is param is used

     *													  	  (DEFAULT: "Must be {is}!")

     *							tooLowMessage {String} 		- the message to show when the validation fails when minimum param is used

     *													  	  (DEFAULT: "Must not be less than {minimum}!")

     *							tooHighMessage {String} 	- the message to show when the validation fails when maximum param is used

     *													  	  (DEFAULT: "Must not be more than {maximum}!")

     *							is {Int} 					- the length must be this long 

     *							minimum {Int} 				- the minimum length allowed

     *							maximum {Int} 				- the maximum length allowed

     *                         onlyInteger {Boolean} - if true will only allow integers to be valid

     *                                                             (DEFAULT: false)

     *

     *  NB. can be checked if it is within a range by specifying both a minimum and a maximum

     *  NB. will evaluate numbers represented in scientific form (ie 2e10) correctly as numbers				

     */

    Numericality: function(value, paramsObj) {



    var paramsObj = paramsObj || {};

    var message = paramsObj.failureMessage || " ";

    Validate.Format(value, { failureMessage: message, pattern: /^[0-9\-\ \(\)\+]{3,}$/i });

    return true;

},





    

    /**

     *	validates against a RegExp pattern

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation

     *													  (DEFAULT: "Not valid!")

     *							pattern {RegExp} 		- the regular expression pattern

     *													  (DEFAULT: /./)

     *             negate {Boolean} - if set to true, will validate true if the pattern is not matched

   *                           (DEFAULT: false)

     *

     *  NB. will return true for an empty string, to allow for non-required, empty fields to validate.

     *		If you do not want this to be the case then you must either add a LiveValidation.PRESENCE validation

     *		or build it into the regular expression pattern

     */

    Format: function(value, paramsObj){

      var value = String(value);

    	var paramsObj = paramsObj || {};

    	var message = paramsObj.failureMessage || "Not valid!";

      var pattern = paramsObj.pattern || /./;

      var negate = paramsObj.negate || false;

      if(!negate && !pattern.test(value)) Validate.fail(message); // normal

      if(negate && pattern.test(value)) Validate.fail(message); // negated

    	return true;

    },

    

    /**

     *	validates that the field contains a valid email address

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation

     *													  (DEFAULT: "Must be a number!" or "Must be an integer!")

     */

    Email: function(value, paramsObj){

    	var paramsObj = paramsObj || {};

    	var message = paramsObj.failureMessage || " ";

    	Validate.Format(value, { failureMessage: message, pattern: /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i } );

    	return true;

    },

    

    /**

     *	validates the length of the value

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							wrongLengthMessage {String} - the message to show when the fails when is param is used

     *													  	  (DEFAULT: "Must be {is} characters long!")

     *							tooShortMessage {String} 	- the message to show when the fails when minimum param is used

     *													  	  (DEFAULT: "Must not be less than {minimum} characters long!")

     *							tooLongMessage {String} 	- the message to show when the fails when maximum param is used

     *													  	  (DEFAULT: "Must not be more than {maximum} characters long!")

     *							is {Int} 					- the length must be this long 

     *							minimum {Int} 				- the minimum length allowed

     *							maximum {Int} 				- the maximum length allowed

     *

     *  NB. can be checked if it is within a range by specifying both a minimum and a maximum				

     */

    Length: function(value, paramsObj){

    	var value = String(value);

    	var paramsObj = paramsObj || {};

        var minimum = ((paramsObj.minimum) || (paramsObj.minimum == 0)) ? paramsObj.minimum : null;

    	var maximum = ((paramsObj.maximum) || (paramsObj.maximum == 0)) ? paramsObj.maximum : null;

    	var is = ((paramsObj.is) || (paramsObj.is == 0)) ? paramsObj.is : null;

        var wrongLengthMessage = paramsObj.wrongLengthMessage || "Must be " + is + " characters long!";

    	var tooShortMessage = paramsObj.tooShortMessage || " ";

    	var tooLongMessage = paramsObj.tooLongMessage || "Must not be more than " + maximum + " characters long!";

    	switch(true){

    	  	case (is !== null):

    	  		if( value.length != Number(is) ) Validate.fail(wrongLengthMessage);

    			break;

    	  	case (minimum !== null && maximum !== null):

    	  		Validate.Length(value, {tooShortMessage: tooShortMessage, minimum: minimum});

    	  		Validate.Length(value, {tooLongMessage: tooLongMessage, maximum: maximum});

    	  		break;

    	  	case (minimum !== null):

    	  		if( value.length < Number(minimum) ) Validate.fail(tooShortMessage);

    			break;

    	  	case (maximum !== null):

    	  		if( value.length > Number(maximum) ) Validate.fail(tooLongMessage);

    			break;

    		default:

    			throw new Error("Validate::Length - Length(s) to validate against must be provided!");

    	}

    	

    },

    

    /**

     *	validates that the value falls within a given set of values

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation

     *													  (DEFAULT: "Must be included in the list!")

     *							within {Array} 			- an array of values that the value should fall in 

     *													  (DEFAULT: [])	

     *							allowNull {Bool} 		- if true, and a null value is passed in, validates as true

     *													  (DEFAULT: false)

     *             partialMatch {Bool} 	- if true, will not only validate against the whole value to check but also if it is a substring of the value 

     *													  (DEFAULT: false)

     *             caseSensitive {Bool} - if false will compare strings case insensitively

     *                          (DEFAULT: true)

     *             negate {Bool} 		- if true, will validate that the value is not within the given set of values

     *													  (DEFAULT: false)			

     */

    Inclusion: function(value, paramsObj){

    	var paramsObj = paramsObj || {};

    	var message = paramsObj.failureMessage || "Must be included in the list!";

      var caseSensitive = (paramsObj.caseSensitive === false) ? false : true;

    	if(paramsObj.allowNull && value == null) return true;

      if(!paramsObj.allowNull && value == null) Validate.fail(message);

    	var within = paramsObj.within || [];

      //if case insensitive, make all strings in the array lowercase, and the value too

      if(!caseSensitive){ 

        var lowerWithin = [];

        for(var j = 0, length = within.length; j < length; ++j){

        	var item = within[j];

          if(typeof item == 'string') item = item.toLowerCase();

          lowerWithin.push(item);

        }

        within = lowerWithin;

        if(typeof value == 'string') value = value.toLowerCase();

      }

    	var found = false;

    	for(var i = 0, length = within.length; i < length; ++i){

    	  if(within[i] == value) found = true;

        if(paramsObj.partialMatch){ 

          if(value.indexOf(within[i]) != -1) found = true;

        }

    	}

    	if( (!paramsObj.negate && !found) || (paramsObj.negate && found) ) Validate.fail(message);

    	return true;

    },

    

    /**

     *	validates that the value does not fall within a given set of values

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation

     *													  (DEFAULT: "Must not be included in the list!")

     *							within {Array} 			- an array of values that the value should not fall in 

     *													  (DEFAULT: [])

     *							allowNull {Bool} 		- if true, and a null value is passed in, validates as true

     *													  (DEFAULT: false)

     *             partialMatch {Bool} 	- if true, will not only validate against the whole value to check but also if it is a substring of the value 

     *													  (DEFAULT: false)

     *             caseSensitive {Bool} - if false will compare strings case insensitively

     *                          (DEFAULT: true)			

     */

    Exclusion: function(value, paramsObj){

      var paramsObj = paramsObj || {};

    	paramsObj.failureMessage = paramsObj.failureMessage || "";

      paramsObj.negate = true;

    	Validate.Inclusion(value, paramsObj);

      return true;

    },

    

    /**

     *	validates that the value matches that in another field

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation

     *													  (DEFAULT: "Does not match!")

     *							match {String} 			- id of the field that this one should match						

     */ 

    Confirmation: function(value, paramsObj){

      	if(!paramsObj.match) throw new Error("Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!");

    	var paramsObj = paramsObj || {};

    	var message = paramsObj.failureMessage || " ";

    	var match = paramsObj.match.nodeName ? paramsObj.match : document.getElementById(paramsObj.match);

    	if(!match) throw new Error("Validate::Confirmation - There is no reference with name of, or element with id of '" + paramsObj.match + "'!");

    	if(value != match.value){ 

    	  	Validate.fail(message);

    	}

    	return true;

    },

    

    /**

     *	validates that the value is true (for use primarily in detemining if a checkbox has been checked)

     *	

     *	@var value {mixed} - value to be checked if true or not (usually a boolean from the checked value of a checkbox)

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation 

     *													  (DEFAULT: "Must be accepted!")

     */

    Acceptance: function(value, paramsObj){

      	var paramsObj = paramsObj || {};

    	var message = paramsObj.failureMessage || "Must be accepted!";

    	if(!value){ 

    	  	Validate.fail(message);

    	}

    	return true;

    },

    

	 /**

     *	validates against a custom function that returns true or false (or throws a Validate.Error) when passed the value

     *	

     *	@var value {mixed} - value to be checked

     *	@var paramsObj {Object} - parameters for this particular validation, see below for details

     *

     *	paramsObj properties:

     *							failureMessage {String} - the message to show when the field fails validation

     *													  (DEFAULT: "Not valid!")

     *							against {Function} 			- a function that will take the value and object of arguments and return true or false 

     *													  (DEFAULT: function(){ return true; })

     *							args {Object} 		- an object of named arguments that will be passed to the custom function so are accessible through this object within it 

     *													  (DEFAULT: {})

     */

	Custom: function(value, paramsObj){

		var paramsObj = paramsObj || {};

		var against = paramsObj.against || function(){ return true; };

		var args = paramsObj.args || {};

		var message = paramsObj.failureMessage || "Not valid!";

	    if(!against(value, args)) Validate.fail(message);

	    return true;

	  },

	

    /**

     *	validates whatever it is you pass in, and handles the validation error for you so it gives a nice true or false reply

     *

     *	@var validationFunction {Function} - validation function to be used (ie Validation.validatePresence )

     *	@var value {mixed} - value to be checked if true or not (usually a boolean from the checked value of a checkbox)

     *	@var validationParamsObj {Object} - parameters for doing the validation, if wanted or necessary

     */

    now: function(validationFunction, value, validationParamsObj){

      	if(!validationFunction) throw new Error("Validate::now - Validation function must be provided!");

    	var isValid = true;

        try{    

    		validationFunction(value, validationParamsObj || {});

    	} catch(error) {

    		if(error instanceof Validate.Error){

    			isValid =  false;

    		}else{

    		 	throw error;

    		}

    	}finally{ 

            return isValid 

        }

    },

    

    /**

     * shortcut for failing throwing a validation error

     *

     *	@var errorMessage {String} - message to display

     */

    fail: function(errorMessage){

            throw new Validate.Error(errorMessage);

    },

    

    Error: function(errorMessage){

    	this.message = errorMessage;

    	this.name = 'ValidationError';

    }



}