// 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 || 'Thankyou!';
		var node = options.insertAfterWhatNode || this.element;
		this.insertAfterWhatNode = node.nodeType ? node : document
				.getElementById(node);
		this.onValid = options.onValid || function() {
			// this.insertMessage(this.createMessageSpan());
				this.removeMessageAndFieldClass();
				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.adopt(new Asset.image(this.message));
		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.element.className === undefined)
				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) {
		new Event(e).stop();
		self.valid = false;
		self.valid = LiveValidation.massValidate(this.fields)
		 return (LiveValidation.massValidate(self.fields)) ?
		 self.oldOnSubmit.call(this, e || window.event) !== false : false;
	}.bind(self);
},
/**
 * If the Validation was succesfull including Captcha then submit the form
 */
submitForm : function() {
	var registerForm = new MOOForm({
		form :'registerform',
		log :'basic',
		controller :'registration',
		action :'edit',
		tabsContainer :'main'
	});
},
/**
 * Evaluates the Catpcha response
 */
evaluateResponse : function(response) {
	if (response === "invalid") {
		this.captchaFailed();
	} else {
		this.valid = true;
		$('registerform').submit();
	}

},
captchaFailed : function() {
	var captchaField = this.fields.getLast();
	captchaField.validationFailed = true;
	captchaField.addFieldClass();
	captchaField.message = "X";
	this.valid = false;
	$("captcha").addClass(captchaField.invalidFieldClass);

	captchaField.insertMessage(captchaField.createMessageSpan());
	var myLoader = new chapchaLoader();
	myLoader.refresh();
},

/**
 * 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;
},
setTabHandler : function(handler) {
	this.tabs = handler
},
getTabHandler : function() {
	return this.tabs;
}

}
// 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 || "Can't be empty!";
		if (value === '' || value === null || value === undefined
				|| value.test("^[ \t]+|[ \t]+$")) {
			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 suppliedValue = value;
		var value = Number(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 notANumberMessage = paramsObj.notANumberMessage
				|| "Must be a number!";
		var notAnIntegerMessage = paramsObj.notAnIntegerMessage
				|| "Must be an integer!";
		var wrongNumberMessage = paramsObj.wrongNumberMessage || "Must be "
				+ is + "!";
		var tooLowMessage = paramsObj.tooLowMessage || "Must not be less than "
				+ minimum + "!";
		var tooHighMessage = paramsObj.tooHighMessage
				|| "Must not be more than " + maximum + "!";
		if (!isFinite(value))
			Validate.fail(notANumberMessage);
		if (paramsObj.onlyInteger
				&& (/\.0+$|\.$/.test(String(suppliedValue)) || value != parseInt(value)))
			Validate.fail(notAnIntegerMessage);
		switch (true) {
			case (is !== null) :
				if (value != Number(is))
					Validate.fail(wrongNumberMessage);
				break;
			case (minimum !== null && maximum !== null) :
				Validate.Numericality(value, {
					tooLowMessage :tooLowMessage,
					minimum :minimum
				});
				Validate.Numericality(value, {
					tooHighMessage :tooHighMessage,
					maximum :maximum
				});
				break;
			case (minimum !== null) :
				if (value < Number(minimum))
					Validate.fail(tooLowMessage);
				break;
			case (maximum !== null) :
				if (value > Number(maximum))
					Validate.fail(tooHighMessage);
				break;
		}
		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
				|| "Must be a valid email address!";
		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
				|| "Must not be less than " + minimum + " characters long!";
		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!");
		}
		return true;
	},

	/**
	 * 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
				|| "Must not be included in the list!";
		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 || "Does not match!";
		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';
	}

}