// Accept a value from a file input based on a required mimetype
    $.validator.addMethod("accept", function(value, element, param) {
        // Split mime on commas in case we have multiple types we can accept
        var typeParam = typeof param === "string" ? param.replace(/\s/g, "").replace(/,/g, "|") : "image/*",
            optionalValue = this.optional(element),
            i, file;

        // Element is optional
        if (optionalValue) {
            return optionalValue;
        }

        if ($(element).attr("type") === "file") {
            // If we are using a wildcard, make it regex friendly
            typeParam = typeParam.replace(/\*/g, ".*");

            // Check if the element has a FileList before checking each file
            if (element.files && element.files.length) {
                for (i = 0; i < element.files.length; i++) {
                    file = element.files[i];

                    // Grab the mimetype from the loaded file, verify it matches
                    if (!file.type.match(new RegExp( ".?(" + typeParam + ")$", "i"))) {
                        return false;
                    }
                }
            }
        }

        // Either return true because we've validated each file, or because the
        // browser does not support element.files and the FileList feature
        return true;
    }, $.validator.format("Please enter a value with a valid mimetype."));

    $.validator.addMethod("alphanumeric", function(value, element) {
        return this.optional(element) || /^\w+$/i.test(value);
    }, "Letters, numbers, and underscores only please");

    /* NOTICE: Modified version of Castle.Components.Validator.CreditCardValidator
     * Redistributed under the the Apache License 2.0 at http://www.apache.org/licenses/LICENSE-2.0
     * Valid Types: mastercard, visa, amex, dinersclub, enroute, discover, jcb, unknown, all (overrides all other settings)
     */
    $.validator.addMethod("creditcardtypes", function(value, element, param) {
        if (/[^0-9\-]+/.test(value)) {
            return false;
        }

        value = value.replace(/\D/g, "");

        var validTypes = 0x0000;

        if (param.mastercard) {
            validTypes |= 0x0001;
        }
        if (param.visa) {
            validTypes |= 0x0002;
        }
        if (param.amex) {
            validTypes |= 0x0004;
        }
        if (param.dinersclub) {
            validTypes |= 0x0008;
        }
        if (param.enroute) {
            validTypes |= 0x0010;
        }
        if (param.discover) {
            validTypes |= 0x0020;
        }
        if (param.jcb) {
            validTypes |= 0x0040;
        }
        if (param.unknown) {
            validTypes |= 0x0080;
        }
        if (param.all) {
            validTypes = 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040 | 0x0080;
        }
        if (validTypes & 0x0001 && /^(5[12345])/.test(value)) { //mastercard
            return value.length === 16;
        }
        if (validTypes & 0x0002 && /^(4)/.test(value)) { //visa
            return value.length === 16;
        }
        if (validTypes & 0x0004 && /^(3[47])/.test(value)) { //amex
            return value.length === 15;
        }
        if (validTypes & 0x0008 && /^(3(0[012345]|[68]))/.test(value)) { //dinersclub
            return value.length === 14;
        }
        if (validTypes & 0x0010 && /^(2(014|149))/.test(value)) { //enroute
            return value.length === 15;
        }
        if (validTypes & 0x0020 && /^(6011)/.test(value)) { //discover
            return value.length === 16;
        }
        if (validTypes & 0x0040 && /^(3)/.test(value)) { //jcb
            return value.length === 16;
        }
        if (validTypes & 0x0040 && /^(2131|1800)/.test(value)) { //jcb
            return value.length === 15;
        }
        if (validTypes & 0x0080) { //unknown
            return true;
        }
        return false;
    }, "Please enter a valid credit card number.");

    $.validator.addMethod("integer", function(value, element) {
        return this.optional(element) || /^-?\d+$/.test(value);
    }, "A positive or negative non-decimal number please");

    $.validator.addMethod("lettersonly", function(value, element) {
        return this.optional(element) || /^[a-z]+$/i.test(value);
    }, "Letters only please");

    $.validator.addMethod("letterswithbasicpunc", function(value, element) {
        return this.optional(element) || /^[a-z\-.,()'"\s]+$/i.test(value);
    }, "Letters or punctuation only please");

    $.validator.addMethod("nowhitespace", function(value, element) {
        return this.optional(element) || /^\S+$/i.test(value);
    }, "No white space please");

    /**
     * Return true if the field value matches the given format RegExp
     *
     * @example $.validator.methods.pattern("AR1004",element,/^AR\d{4}$/)
     * @result true
     *
     * @example $.validator.methods.pattern("BR1004",element,/^AR\d{4}$/)
     * @result false
     *
     * @name $.validator.methods.pattern
     * @type Boolean
     * @cat Plugins/Validate/Methods
     */
    $.validator.addMethod("pattern", function(value, element, param) {
        if (this.optional(element)) {
            return true;
        }
        if (typeof param === "string") {
            param = new RegExp(param);
        }
        return param.test(value);
    }, "Invalid format.");

    /**
     * matches US phone number format
     *
     * where the area code may not start with 1 and the prefix may not start with 1
     * allows '-' or ' ' as a separator and allows parens around area code
     * some people may want to put a '1' in front of their number
     *
     * 1(212)-999-2345 or
     * 212 999 2344 or
     * 212-999-0983
     *
     * but not
     * 111-123-5434
     * and not
     * 212 123 4567
     */
    $.validator.addMethod("phoneUS", function(phone_number, element) {
        phone_number = phone_number.replace(/\s+/g, "");
        return this.optional(element) || phone_number.length > 9 &&
            phone_number.match(/^(\+?1-?)?(\([2-9]([02-9]\d|1[02-9])\)|[2-9]([02-9]\d|1[02-9]))-?[2-9]([02-9]\d|1[02-9])-?\d{4}$/);
    }, "Please specify a valid phone number");

    /* For UK phone functions, do the following server side processing:
     * Compare original input with this RegEx pattern:
     * ^\(?(?:(?:00\)?[\s\-]?\(?|\+)(44)\)?[\s\-]?\(?(?:0\)?[\s\-]?\(?)?|0)([1-9]\d{1,4}\)?[\s\d\-]+)$
     * Extract $1 and set $prefix to '+44<space>' if $1 is '44', otherwise set $prefix to '0'
     * Extract $2 and remove hyphens, spaces and parentheses. Phone number is combined $prefix and $2.
     * A number of very detailed GB telephone number RegEx patterns can also be found at:
     * http://www.aa-asterisk.org.uk/index.php/Regular_Expressions_for_Validating_and_Formatting_GB_Telephone_Numbers
     */

    /**
     * Matches a valid Canadian Postal Code
     *
     * @example jQuery.validator.methods.postalCodeCA( "H0H 0H0", element )
     * @result true
     *
     * @example jQuery.validator.methods.postalCodeCA( "H0H0H0", element )
     * @result false
     *
     * @name jQuery.validator.methods.postalCodeCA
     * @type Boolean
     * @cat Plugins/Validate/Methods
     */
    $.validator.addMethod( "postalCodeCA", function( value, element ) {
        return this.optional( element ) || /^[ABCEGHJKLMNPRSTVXY]\d[A-Z] \d[A-Z]\d$/.test( value );
    }, "Please specify a valid postal code" );

    /*
     * Lets you say "at least X inputs that match selector Y must be filled."
     *
     * The end result is that neither of these inputs:
     *
     *	<input class="productinfo" name="partnumber">
     *	<input class="productinfo" name="description">
     *
     *	...will validate unless at least one of them is filled.
     *
     * partnumber:	{require_from_group: [1,".productinfo"]},
     * description: {require_from_group: [1,".productinfo"]}
     *
     * options[0]: number of fields that must be filled in the group
     * options[1]: CSS selector that defines the group of conditionally required fields
     */
    $.validator.addMethod("require_from_group", function(value, element, options) {
        var $fields = $(options[1], element.form),
            $fieldsFirst = $fields.eq(0),
            validator = $fieldsFirst.data("valid_req_grp") ? $fieldsFirst.data("valid_req_grp") : $.extend({}, this),
            isValid = $fields.filter(function() {
                return validator.elementValue(this);
            }).length >= options[0];

        // Store the cloned validator for future validation
        $fieldsFirst.data("valid_req_grp", validator);

        // If element isn't being validated, run each require_from_group field's validation rules
        if (!$(element).data("being_validated")) {
            $fields.data("being_validated", true);
            $fields.each(function() {
                validator.element(this);
            });
            $fields.data("being_validated", false);
        }
        return isValid;
    }, $.validator.format("Please fill at least {0} of these fields."));

    /*
     * Lets you say "either at least X inputs that match selector Y must be filled,
     * OR they must all be skipped (left blank)."
     *
     * The end result, is that none of these inputs:
     *
     *	<input class="productinfo" name="partnumber">
     *	<input class="productinfo" name="description">
     *	<input class="productinfo" name="color">
     *
     *	...will validate unless either at least two of them are filled,
     *	OR none of them are.
     *
     * partnumber:	{skip_or_fill_minimum: [2,".productinfo"]},
     * description: {skip_or_fill_minimum: [2,".productinfo"]},
     * color:		{skip_or_fill_minimum: [2,".productinfo"]}
     *
     * options[0]: number of fields that must be filled in the group
     * options[1]: CSS selector that defines the group of conditionally required fields
     *
     */
    $.validator.addMethod("skip_or_fill_minimum", function(value, element, options) {
        var $fields = $(options[1], element.form),
            $fieldsFirst = $fields.eq(0),
            validator = $fieldsFirst.data("valid_skip") ? $fieldsFirst.data("valid_skip") : $.extend({}, this),
            numberFilled = $fields.filter(function() {
                return validator.elementValue(this);
            }).length,
            isValid = numberFilled === 0 || numberFilled >= options[0];

        // Store the cloned validator for future validation
        $fieldsFirst.data("valid_skip", validator);

        // If element isn't being validated, run each skip_or_fill_minimum field's validation rules
        if (!$(element).data("being_validated")) {
            $fields.data("being_validated", true);
            $fields.each(function() {
                validator.element(this);
            });
            $fields.data("being_validated", false);
        }
        return isValid;
    }, $.validator.format("Please either skip these fields or fill at least {0} of them."));

// TODO check if value starts with <, otherwise don't try stripping anything
    $.validator.addMethod("strippedminlength", function(value, element, param) {
        return $(value).text().length >= param;
    }, $.validator.format("Please enter at least {0} characters"));

    $.validator.addMethod("time", function(value, element) {
        return this.optional(element) || /^([01]\d|2[0-3])(:[0-5]\d){1,2}$/.test(value);
    }, "Please enter a valid time, between 00:00 and 23:59");

    $.validator.addMethod("time12h", function(value, element) {
        return this.optional(element) || /^((0?[1-9]|1[012])(:[0-5]\d){1,2}(\ ?[AP]M))$/i.test(value);
    }, "Please enter a valid time in 12-hour am/pm format");

// same as url, but TLD is optional
    $.validator.addMethod("url2", function(value, element) {
        return this.optional(element) || /^(https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)*(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i.test(value);
    }, $.validator.messages.url);

    $.validator.addMethod("zipcodeUS", function(value, element) {
        return this.optional(element) || /^\d{5}(-\d{4})?$/.test(value);
    }, "The specified US ZIP Code is invalid");

    $.validator.addMethod("ziprange", function(value, element) {
        return this.optional(element) || /^90[2-5]\d\{2\}-\d{4}$/.test(value);
    }, "Your ZIP-code must be in the range 902xx-xxxx to 905xx-xxxx");


/* JSP */
jQuery.validator.addMethod("dateCA", function(value, element) {
	return this.optional(element) || /^\d\d\d\d[\.\/-]\d\d?[\.\/-]\d\d?$/.test(value);
}, "Veuillez entrer la date sous le format AAAA-MM-JJ.");

// Addon method for validating postal codes. Valid
// formats are (X1X 1X1) or (X1X1X1) or (X1X-1X1).
$.validator.addMethod("postalZipCode", function(value, element) {
     return this.optional(element) || /^[ABCEGHJKLMNPRSTVXY]\d[A-Z]\s*\d[A-Z]\d$/i.test( value ) || /\d{5}-\d{4}$|^\d{5}$/.test(value);
}, 'Please enter a valid postal code');

$.validator.addMethod('daterange', function(value, element, arg) {
	if (this.optional(element)) {
        return true;
    }

     var startDate = arg[0],
	 endDate = arg[1],
	 enteredDate = value;

    return ((startDate <= enteredDate) && (enteredDate <= endDate));
 }, "Please specify a date between {0} and {1}.");