/*!
 * Guards JavaScript jQuery Plugin v0.7.2
 * https://github.com/on-site/guards.js
 *
 * Copyright 2010-2013, On-Site.com, http://www.on-site.com/
 * Licensed under the MIT license.
 *
 * Includes code for email and phone number validation from the jQuery
 * Validation plugin.  http://docs.jquery.com/Plugins/Validation
 *
 * Date: Mon Feb 25 03:47:45 2013 -0800
 */

/**
 * This plugin is initially inspired by the standard Validation jQuery
 * plugin (http://docs.jquery.com/Plugins/Validation).
 *
 * To guard forms with this plugin, you must specify a set of guards
 * via $.guards.add(selector).using(guard) or
 * $.guard(selector).using(guard).  These guards are then invoked from
 * the first one specified to the last one specified.
 *
 * Example usage:
 *
 * $(function() {
 *   // Change the default error tag wrapper to a div.
 *   $.guards.defaults.tag = "div";
 *
 *   // Enable the submit guard hook for the form with the "myForm" id.
 *   $("#myForm").enableGuards();
 *
 *   // Guard that fields with "required" class have a value.
 *   $.guard(".required").using("required");
 *
 *   // Guard that the text fields don't have the value "invalid" or "bad".
 *   $.guard(":text").using(function(value, element) {
 *     return $.inArray(value, ["invalid", "bad"]) == -1;
 *   }).message("Don't use the keyword 'invalid' or 'bad'.");
 *
 *   // Guard that fields with "email" class specify at least one
 *   // value, but only show 1 error message if none is specified (but
 *   // still highlight all of the fields).
 *   $.guard(".email").using("oneRequired")
 *       .message("Please specify at least one email.").grouped();
 */
(function($) {
    $.guard = function(selector) {
        return $.guards.add(selector);
    };

    $.guard.version = "0.7.2";

    $.Guards = function() {
        var self = this;
        this._guards = [];

        this.options = {
            stackErrors: false
        };

        this.constants = {
            notChecked: ""
        };

        var defineGuard = function(aggregator, validator) {
            return function() {
                var args = $.makeArray(arguments);
                return function(value, element) {
                    return self[aggregator](value, function(v) {
                        return self[validator].apply(self, $.merge([v], args));
                    });
                };
            };
        };

        var minMaxMessage = function(formatting, minMaxFormat) {
            return function(options) {
                if (self.isNullOrUndefined(options)) {
                    options = {};
                }

                if (!$.isFunction(minMaxFormat)) {
                    minMaxFormat = function(x) { return x; };
                }

                var minDefined = !self.isNullOrUndefined(options.min);
                var maxDefined = !self.isNullOrUndefined(options.max);

                if (minDefined && maxDefined) {
                    return self.format(formatting.minAndMax, minMaxFormat(options.min), minMaxFormat(options.max));
                }

                if (minDefined) {
                    return self.format(formatting.min, minMaxFormat(options.min));
                }

                if (maxDefined) {
                    return self.format(formatting.max, minMaxFormat(options.max));
                }

                if (formatting.invalid) {
                    return formatting.invalid;
                }

                return self.defaults.messages.undefined;
            };
        };

        var arrayMessage = function(formatting) {
            return function(array) {
                return self.format(formatting, $.map(array, function(x, i) { return $.trim("" + x); }).join(", "));
            };
        };

        this.defaults = {
            grouped: false,
            guard: "required",

            guards: {
                allow: defineGuard("isAllValid", "isAllowed"),
                always: defineGuard("isAllValid", "always"),
                different: defineGuard("passThrough", "isDifferent"),
                disallow: defineGuard("isAllValid", "isDisallowed"),
                email: defineGuard("isAllValid", "isValidEmail"),
                "float": defineGuard("isAllValid", "isValidFloat"),
                "int": defineGuard("isAllValid", "isValidInt"),
                moneyUS: defineGuard("isAllValid", "isValidMoneyUS"),
                never: defineGuard("isAllValid", "never"),
                oneRequired: defineGuard("isAnyValid", "isPresent"),
                phoneUS: defineGuard("isAllValid", "isValidPhoneUS"),
                required: defineGuard("isAllValid", "isPresent"),
                same: defineGuard("passThrough", "isSame"),
                string: defineGuard("isAllValid", "isValidString")
            },

            invalidClass: "invalid-field",
            messageClass: "error-message",

            messages: {
                allow: arrayMessage("Please enter one of: #{0}."),
                always: "There was an error.",
                different: "These values must all be different.",
                disallow: arrayMessage("Please don't enter: #{0}."),
                email: "Please enter a valid E-mail address.",

                "float": minMaxMessage({
                    minAndMax: "Please enter a number from #{0} to #{1}.",
                    min: "Please enter a number no less than #{0}.",
                    max: "Please enter a number no greater than #{0}.",
                    invalid: "Please enter a number."
                }),

                "int": minMaxMessage({
                    minAndMax: "Please enter a number from #{0} to #{1}.",
                    min: "Please enter a number no less than #{0}.",
                    max: "Please enter a number no greater than #{0}.",
                    invalid: "Please enter a number."
                }),

                moneyUS: minMaxMessage({
                    minAndMax: "Please enter a dollar amount from #{0} to #{1}.",
                    min: "Please enter a dollar amount no less than #{0}.",
                    max: "Please enter a dollar amount no greater than #{0}.",
                    invalid: "Please enter a dollar amount."
                }, function(x) { return x.toFixed(2); }),

                never: "There was an error.",
                oneRequired: "Specify at least one.",
                phoneUS: "Please enter a valid phone number.",
                required: "This field is required.",
                same: "These values must all match.",

                string: minMaxMessage({
                    minAndMax: "Please enter a string with length #{0} to #{1}.",
                    min: "Please enter a string with length at least #{0}.",
                    max: "Please enter a string with length no greater than #{0}."
                }),

                "undefined": "Please fix this field."
            },

            style: {
                field: {
                    "background-color": "#ffff66"
                },

                message: {
                    color: "#ff0000",
                    "margin-left": "10px"
                }
            },

            tag: "span",

            target: function(errorElement) {
                var last = $(this).filter(":last");

                if (last.is(":radio,:checkbox")) {
                    last = $(last[0].nextSibling);
                }

                errorElement.insertAfter(last);
                return false;
            }
        };
    };

    $.Guards.prototype.version = "0.7.2";

    // Really old jQuery doesn't have isArray, so use this alias
    // instead.
    $.Guards.prototype.isArray = $.isArray;

    if (!$.Guards.prototype.isArray) {
        var ARRAY_CONSTRUCTOR = [].constructor;
        var JQUERY_CONSTRUCTOR = jQuery;

        $.Guards.prototype.isArray = function(obj) {
            // Simplistic, but good enough for guards.
            return obj.constructor == ARRAY_CONSTRUCTOR || obj.constructor == JQUERY_CONSTRUCTOR;
        };
    }

    // Alias for console.log, but check that such a thing exists.
    $.Guards.prototype.log = function(message) {
        if (console && console.log) {
            console.log(message);
        }
    };

    // Utility method to trigger live events, but works against any
    // jQuery version that supports live events.
    $.Guards.prototype.on = function(selector, event, callback) {
        if ($.fn.on) {
            $(document).on(event, selector, callback);
        } else if ($.fn.delegate) {
            $(document).delegate(selector, event, callback);
        } else if ($.fn.live) {
            $(selector).live(event, callback);
        } else {
            this.log("Could not bind live handlers, probably because jQuery is too old.");
        }
    };

    // Implementation of $.enableGuards(selector);
    $.Guards.prototype.enableGuards = function(selector) {
        var self = this;

        this.on(selector, "submit", function() {
            return self.guard($(this));
        });
    };

    // Implementation of $.liveGuard(selector);
    $.Guards.prototype.liveGuard = function(selector) {
        var self = this;
        this.enableGuards(selector);

        this.on(selector, "change blur", function(e) {
            var $element = $(e.target);

            if (!$element.is(":guardable")) {
                return;
            }

            self.applyGuards(function(guard) {
                if (guard.isGrouped()) {
                    if (guard.appliesTo($element)) {
                        return $element.parents("form:first").find(":guardable");
                    } else {
                        return false;
                    }
                } else {
                    return $element;
                }
            });
        });
    };

    /**
     * Format all arguments into the first argument.  This is a
     * convenience function similar to the C sprintf function, though
     * only with simple replacements.  Replacements are formatted like
     * #{i} where i is a zero based index into the additional
     * arguments passed in to format beyond the first.
     *
     * Additional parameters not used will be ignored.
     *
     * Including formatting requests for parameters that don't exist
     * will throw an exception.
     *
     * The first argument must be the string that needs to be
     * formatted.  Additional arguments are formatted into that
     * string.
     *
     * If any of the arguments to the format string include a string
     * that matches the #{i} format, the result could be erroneous.
     *
     * Example: $.guards.format("#{2} #{0} #{1}", "hello", "world", 3); // "3 hello world"
     * Example: $.guards.format("#{0} #{1}", "hello", "world", 3);      // "hello world".
     * Example: $.guards.format("#{2} #{0} #{1}", "hello", "world");    // throws exception
     */
    $.Guards.prototype.format = function() {
        var str = arguments[0];

        if (arguments.length > 1) {
            for (var i = 1; i < arguments.length; i++) {
                var regex = "\\#\\{" + (i - 1) + "\\}";
                str = str.replace(new RegExp(regex, "g"), arguments[i]);
            }
        }

        if (/\#\{\d+\}/.test(str)) {
            throw new Error("Unmatched formatting found!");
        }

        return str;
    };

    /**
     * Add a style element to the document head which will style
     * elements with errors and their error messages.  This will use
     * $.guards.defaults.style.field and
     * $.guards.defaults.style.message to determine what styling to
     * use.  These defaults are initialized to a yellow background for
     * the invalid fields, and red color with a small left margin for
     * error messages.  The selectors used to style these are
     * determined by $.guards.defaults.invalidClass and
     * $.guards.defaults.messageClass.
     *
     * There are 2 optional arguments allowed.  The first is a
     * selector scope to use, and the second is overrides for styling.
     * Either, both or neither arguments are allowed.
     *
     * With a changed selector scope, the selector for the styles is
     * scoped to the given value.  This can be useful for different
     * styling on different forms.  Note that the keys to the object
     * in the "field" and "message" keys are used as css styles, and
     * the values to those keys are the values for those styles.
     *
     * The custom style overrides can be used to change the field,
     * message or both styles.
     *
     * Example: $.guards.style();
     * Example: $.guards.style("#myForm");
     * Example: $.guards.style({ field: { "color": "#ff0000" } });
     * Example: $.guards.style({ message: { "color": "#ff6666" } });
     * Example: $.guards.style("#myForm", { field: { "color": "#ff0000" }, message: { "color": "#ff6666" } });
     */
    $.Guards.prototype.style = function() {
        $("head").append(this.styleHtml.apply(this, arguments));
    };

    /**
     * Retrieve the style html as a string to use for the
     * $.guards.style() function.  The documentation for that function
     * applies to this as well.
     */
    $.Guards.prototype.styleHtml = function() {
        var fieldStyle = {};
        var messageStyle = {};
        var fieldSelector = "." + this.defaults.invalidClass;
        var messageSelector = "." + this.defaults.messageClass;
        var selectorScope, styles;

        if (this.defaults.style && this.defaults.style.field) {
            fieldStyle = this.defaults.style.field;
        }

        if (this.defaults.style && this.defaults.style.message) {
            messageStyle = this.defaults.style.message;
        }

        if (arguments.length == 1) {
            if (typeof(arguments[0]) == "string") {
                selectorScope = arguments[0];
            } else {
                styles = arguments[0];
            }
        } else if (arguments.length == 2) {
            selectorScope = arguments[0];
            styles = arguments[1];
        }

        if (styles && styles.field) {
            fieldStyle = styles.field;
        }

        if (styles && styles.message) {
            messageStyle = styles.message;
        }

        var result = "<style>\n";

        var addStyles = function(selector, styles) {
            result += "  " + selector + " {";

            if (styles) {
                $.each(styles, function(key, value) {
                    result += " " + key + ": " + value +  ";";
                });
            }

            result += " }\n";
        };

        if (selectorScope) {
            fieldSelector = selectorScope + " " + fieldSelector;
            messageSelector = selectorScope + " " + messageSelector;
        }

        addStyles(fieldSelector, fieldStyle);
        addStyles(messageSelector, messageStyle);
        result += "</style>";
        return result;
    };

    /**
     * This guard test method is intended to always fail, thus it
     * returns false no matter what.
     */
    $.Guards.prototype.always = function(value) {
        return false;
    };

    /**
     * Return whether or not the value exists in the given allowed
     * list.  The allowed parameter must be an array of valid values.
     * Blank is considered invalid unless it exists in the list.
     * Whitespace is ignored.
     */
    $.Guards.prototype.isAllowed = function(value, allowed) {
        value = $.trim(value);
        return $.inArray(value, $.map(allowed, function(x, i) { return $.trim("" + x); })) != -1;
    };

    /**
     * If the given values is an array, this will return false if the
     * given fn returns false for any value in the array.  If the
     * given values is not an array, the result of calling the given
     * fn on that value is returned directly.
     *
     * Example: $.guards.isAllValid([true, false, true], function(x) { return x; }); // false
     * Example: $.guards.isAllValid(true, function(x) { return x; });                // true
     */
    $.Guards.prototype.isAllValid = function(values, fn) {
        if (this.isArray(values)) {
            var result = true;

            $.each(values, function(i, x) {
                if (!fn(x)) {
                    result = false;
                    return false;
                }
            });

            return result;
        }

        return fn(values);
    };

    /**
     * If the given values is an array, this will return true if the
     * given fn returns true for any value in the array.  If the given
     * values is not an array, the result of calling the given fn on
     * that value is returned directly.
     *
     * Example: $.guards.isAllValid([false, false, true], function(x) { return x; }); // true
     * Example: $.guards.isAllValid(false, function(x) { return x; });                // false
     */
    $.Guards.prototype.isAnyValid = function(values, fn) {
        if (this.isArray(values)) {
            var result = false;

            $.each(values, function(i, x) {
                if (fn(x)) {
                    result = true;
                    return false;
                }
            });

            return result;
        }

        return fn(values);
    };

    /**
     * Return true if the value is null, undefined, an empty string,
     * or a string of just spaces.
     */
    $.Guards.prototype.isBlank = function(value) {
        return this.isNullOrUndefined(value) || $.trim(value) == "";
    };

    /**
     * Return whether all the values in the given array are different.
     */
    $.Guards.prototype.isDifferent = function(values) {
        if (values.length < 2) {
            return true;
        }

        var found = {};
        var result = true;

        $.each(values, function(i, x) {
            if (found[x] === true) {
                result = false;
                return false;
            }

            found[x] = true;
        });

        return result;
    };

    /**
     * Return whether or not the value doesn't exist in the given
     * disallowed list.  The disallowed parameter must be an array of
     * invalid values.  Blank is considered valid unless it exists in
     * the list.  Whitespace is ignored.
     */
    $.Guards.prototype.isDisallowed = function(value, disallowed) {
        return !this.isAllowed(value, disallowed);
    };

    /**
     * Return true if the value is null or undefined.
     */
    $.Guards.prototype.isNullOrUndefined = function(value) {
        return value === null || value === undefined;
    };

    /**
     * Return the negation of calling isBlank(value).
     */
    $.Guards.prototype.isPresent = function(value) {
        return !this.isBlank(value);
    };

    /**
     * Return whether all the values in the given array are the same.
     */
    $.Guards.prototype.isSame = function(values) {
        if (values.length < 2) {
            return true;
        }

        var value = values[0];
        var result = true;

        $.each(values, function(i, x) {
            if (x != value) {
                result = false;
                return false;
            }
        });

        return result;
    };

    /**
     * Return true if the given value is greater than or equal to
     * options.min (if options.min is defined) and less than or equal
     * to options.max (if options.max is defined).
     */
    $.Guards.prototype.isInRange = function(value, options) {
        if (this.isNullOrUndefined(options)) {
            options = {};
        }

        var bigEnough = this.isNullOrUndefined(options.min) || value >= options.min;
        var smallEnough = this.isNullOrUndefined(options.max) || value <= options.max;
        return bigEnough && smallEnough;
    };

    /**
     * Return whether or not the value is a valid integer.
     * Appropriate options are min, max, both or neither.  Blank is
     * valid as a number.
     */
    $.Guards.prototype.isValidInt = function(value, options) {
        value = $.trim(value);

        if (value == "") {
            return true;
        }

        if (!/^(-|\+)?\d+$/.test(value)) {
            return false;
        }

        value = parseInt(value, 10);
        return this.isInRange(value, options);
    };

    /**
     * Return whether or not the value is a valid float.  Appropriate
     * options are min, max, both or neither.  Blank is valid as a
     * number.
     */
    $.Guards.prototype.isValidFloat = function(value, options) {
        value = $.trim(value);

        if (value == "") {
            return true;
        }

        if (!/^(-|\+)?(\d+)?\.?\d+$/.test(value)) {
            return false;
        }

        value = parseFloat(value);
        return this.isInRange(value, options);
    };

    /**
     * Validates the given value is a valid US money value.  It
     * optionally accepts min and max to specify the minimum or
     * maximum values.  Blank is a valid money.
     */
    $.Guards.prototype.isValidMoneyUS = function(value, options) {
        value = $.trim(value);

        if (value == "") {
            return true;
        }

        if (!/^\$?(-|\+)?\$?([\d,]+)?\.?\d+$/.test(value)) {
            return false;
        }

        // Only allow 1 $.
        var $i = value.indexOf("$");
        if ($i >= 0 && value.indexOf("$", $i + 1) >= 0) {
            return false;
        }

        // Ensure if there are commas they are every 3 digits
        if (value.indexOf(",") >= 0 && !/^\$?(-|\+)?\$?[1-9]\d{0,2}(,\d{3,3})+(\.\d+)?$/.test(value)) {
            return false;
        }

        // Ensure no more than 2 digits after decimal
        if (value.indexOf(".") >= 0 && /\.\d{3,}$/.test(value)) {
            return false;
        }

        value = parseFloat(value.replace(/[\$,]/g, ""));
        return this.isInRange(value, options);
    };

    /**
     * Validates the given value is a valid email.  If options is
     * passed with allowDisplay as true, display emails will be
     * considered valid.  A display email differs from a regular email
     * in that it can be contained with < and > with some text ahead
     * of that.  Thus "John Doe <jdoe@example.com>" would be valid.
     */
    $.Guards.prototype.isValidEmail = function(value, options) {
        if (options && options.allowDisplay) {
            var result = /.*\<([^>]+)\>\s*$/.exec(value);

            if (result) {
                value = result[1];
            }
        }

        return value == "" || /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([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])))\.?$/i.test(value);
    };

    /**
     * Validates the given value is a valid US phone number.
     */
    $.Guards.prototype.isValidPhoneUS = function(value) {
        value = value.replace(/\s+/g, "");
        return value == "" || value.length > 9 &&
              value.match(/^(1-?)?(\([2-9]\d{2}\)|[2-9]\d{2})-?[2-9]\d{2}-?\d{4}$/);
    };

    /**
     * Return whether or not the value is a valid string.  Appropriate
     * options are min or max (or both).  Whitespace is not
     * considered.
     */
    $.Guards.prototype.isValidString = function(value, options) {
        value = $.trim(value);
        return this.isValidInt("" + value.length, options);
    };

    /**
     * This guard test method is intended to never fail, thus it
     * returns true no matter what.  It is intended to be used to set
     * up a guard that is triggered manually via triggerError().
     */
    $.Guards.prototype.never = function(value) {
        return true;
    };

    /**
     * This is a utility function to act like isAnyValid or
     * isAllValid, except instead of aggregating the function results,
     * it passes the arguments on to the function and returns the
     * results.  It makes the argument an array always.
     *
     * Example: $.guards.passThrough([true, false, true], function(x) { return x[1]; }); // false
     * Example: $.guards.passThrough(true, function(x) { return x[0]; });                // true
     */
    $.Guards.prototype.passThrough = function(values, fn) {
        if (!this.isArray(values)) {
            values = [values];
        }

        return fn(values);
    };

    /**
     * Guard all elements with the specified jQuery selector.  Using
     * is implicitly called with $.guards.defaults.guard, which
     * defaults to "required".  Note that it is simpler to use
     * $.guard(selector) instead of $.guards.add(selector).
     *
     * Example: $.guards.add(".validPhone").using("phoneUS");
     * Example: $.guards.add(".custom").using(function(value, element) {
     *            return value != "invalid";
     *          }).message("Don't use the keyword 'invalid'.");
     * Example: $.guards.add(".custom").grouped().using(function(values, elements) {
     *            return $.inArray("invalid", values) == -1;
     *          }).target("#custom-error-location").tag("div")
     *              .message("Don't use the keyword 'invalid'.");
     */
    $.Guards.prototype.add = function(selector) {
        var guard = new $.Guard(selector, this);
        this._guards.push(guard);
        return guard;
    };

    /**
     * Clear all errors on the form's guard fields, then invoke each
     * guard on the fields in order and guard them, adding errors
     * along the way as needed.  Once done, focus the first visible
     * field with an error.
     */
    $.Guards.prototype.guard = function(form) {
        var fields = form.guardableFields().clearErrors();
        var result = this.applyGuards(function(guard) { return fields; });
        fields.filter(":visible:has-error").eq(0).focus();
        return result;
    };

    /**
     * Apply all the guards to the fields returned from the given
     * callback.  The callback will receive the guard, and is expected
     * to return the fields to guard against.  If it returns false,
     * that guard is skipped and does not affect the return value.
     */
    $.Guards.prototype.applyGuards = function(callback) {
        var result = true;
        var self = this;

        $.each(this._guards, function(index, guard) {
            var fields = callback(guard);

            if (fields !== false && !self.test(guard, fields)) {
                result = false;
            }
        });

        return result;
    };

    /**
     * Use the given guard to test the given guarded fields.  Errors
     * will be applied if the field doesn't have an error yet.
     */
    $.Guards.prototype.test = function(guard, fields) {
        if (guard._grouped) {
            return guard.test(fields);
        }

        var result = true;

        fields.each(function() {
            if (!guard.test(this)) {
                result = false;
            }
        });

        return result;
    };

    $.Guard = function(selector, guards) {
        this._guards = guards || $.guards;
        this._selector = selector;
        this._grouped = this._guards.defaults.grouped;
        this._tag = this._guards.defaults.tag;
        this._messageClass = this._guards.defaults.messageClass;
        this._invalidClass = this._guards.defaults.invalidClass;
        this._target = this._guards.defaults.target;
        this.using(this._guards.defaults.guard);
    };

    /**
     * Guard inputs using a specified guard.  The guard may be either
     * a string or a function.  When it is a string, it must match one
     * of the pre-defined guards defined in $.guards.defaults.guards.
     * The function is expected to have 2 arguments.  The first is the
     * value of the element being guarded, and the second is the
     * actual element.  If grouped is true, it will be an array of all
     * matched values and all matched elements (the order of values
     * will match the order of elements).  Radio buttons are passed as
     * separate values and elements, but the value of each will be the
     * same.  Specifically, the value of the checked radio button is
     * the value used, unless none are checked, in which case
     * $.guards.constants.notChecked will be used (which is predefined
     * as an empty string).
     *
     * Note that the message is implicitly set when this method is
     * called.  If the guard is a string, the message will be set to
     * $.guards.defaults.messages[guard].  If it is a function, it
     * will be set to $.guards.defaults.messages.undefined.
     *
     * Example: $.guard(".required").using("required");
     * Example: $.guard(".required").using(function(value, element) {
     *   return $.inArray("invalid", values) == -1;
     * });
     */
    $.Guard.prototype.using = function(guard) {
        if (typeof(guard) == "string") {
            var args = [];

            if (arguments.length > 1) {
                args = $.makeArray(arguments).slice(1);
            }

            var fn = this._guards.defaults.guards[guard];

            if (this._guards.isNullOrUndefined(fn)) {
                throw new Error("There is no standard guard named '" + guard + "'");
            }

            this._guard = fn.apply(this._guards.defaults.guards, args);
            var message = this._guards.defaults.messages[guard];

            if ($.isFunction(message)) {
                message = message.apply(this._guards.defaults.messages, args);
            }

            return this.message(message);
        }

        this._guard = guard;
        return this.message(this._guards.defaults.messages.undefined);
    };

    /**
     * Specify a precondition for this guard.  The precondition should
     * be a function that accepts the element and element value as the
     * parameters, like a custom guard function.  The precondition is
     * executed before the guard when any given input is about to be
     * guarded.  If the precondition returns false explicitly, the
     * guard will not be executed and the field will be considered
     * valid.  Any other return value means the precondition passed
     * (even no return).  If the guard is grouped, the parameters will
     * be the array of values and elements (like for a custom guard
     * function).
     *
     * // Only require this if #other_element is checked.
     * Example: $.guard(".required").using("required").precondition(function(value, element) {
     *   return $("#other_element").is(":checked");
     * });
     *
     * @since 0.4
     */
    $.Guard.prototype.precondition = function(fn) {
        this._precondition = fn;
        return this;
    };

    /**
     * Return whether or not this guard is grouped.
     */
    $.Guard.prototype.isGrouped = function() {
        return this._grouped;
    };

    /**
     * Specify whether to group element guarding by passing all values
     * and elements at once instead of one at a time.  When grouped,
     * only 1 error message is added, and it is added after the last
     * element.  This defaults to $.guards.defaults.grouped.  If an
     * argument is passed, the value is used as the grouped value,
     * otherwise invoking this method will set grouped to true.
     *
     * Example: $.guard(".required").using("required").grouped();
     * Example: $.guard(".required").using("required").grouped(true);
     */
    $.Guard.prototype.grouped = function() {
        if (arguments.length == 0) {
            return this.grouped(true);
        }

        this._grouped = arguments[0];
        return this;
    };

    /**
     * Set the type of tag to surround the error message with
     * (defaults to $.guards.defaults.tag, which defaults to span).
     *
     * Example: $.guard(".required").using("required").tag("div");
     */
    $.Guard.prototype.tag = function(tag) {
        this._tag = tag;
        return this.resetMessageFn();
    };

    $.Guard.prototype.messageClass = function(messageClass) {
        this._messageClass = messageClass;
        return this.resetMessageFn();
    };

    /**
     * Set the error message to display on errors.  If using is called
     * with a string, this is implicitly invoked using
     * $.guards.defaults.messages[usingValue].  If using is called
     * with a function, this is implicitly invoked using
     * $.guards.defaults.messages.undefined.
     *
     * Example: $.guard(".required").using("required").message("Enter something!");
     */
    $.Guard.prototype.message = function(message) {
        this._message = message;
        return this.resetMessageFn();
    };

    $.Guard.prototype.invalidClass = function(invalidClass) {
        this._invalidClass = invalidClass;
        return this;
    };

    $.Guard.prototype.resetMessageFn = function() {
        var self = this;
        return this.messageFn(function() {
            return $('<' + self._tag + ' class="' + self._messageClass + '"/>').html(self._message);
        });
    };

    $.Guard.prototype.messageFn = function(messageFn) {
        this._messageFn = messageFn;
        return this;
    };

    $.Guard.prototype.errorElement = function() {
        return this._messageFn();
    };

    $.Guard.prototype.attachError = function(elements, errorElement) {
        if (this._target && $.isFunction(this._target)) {
            var result = this._target.call(elements, errorElement);

            if (result !== false) {
                errorElement.appendTo($(result).eq(0));
            }
        } else if (this._target) {
            errorElement.appendTo($(this._target).eq(0));
        } else {
            throw new Error("The target must be a function or selector!");
        }
    };

    /**
     * Set the target for where error messages should be appended to.
     * By default, the error is placed after the error element, but
     * when a target is specified, the error is appended within.  The
     * target may be either a selector, function, element or set of
     * elements, however, only the first element is used as the target
     * location for errors.  If a function is specified, it will be
     * called when there is a new error with the invalid element (or
     * set of elements if it is a grouped guard) as the "this"
     * reference.  The returned value should be a single element,
     * though if an array of elements is returned (or a jQuery
     * selected set of elements), only the first element will be used
     * as the target.  Alternatively the function can take a single
     * argument that specifies the error element to add to the DOM,
     * and the function is expected to add the element and return
     * false (indicating that it has taken care of adding the error
     * element).
     *
     * The default target is a function that appends the error after
     * the last element and returns false.  The default can be changed
     * via $.guards.defaults.target.
     *
     * Example: $.guard(".required").using("required").target("#my-errors");
     * Example: $.guard(".required").using("required").target(function() { return $(this).nextAll(".error:eq(0)"); });
     * Example: $.guard(".required").using("required").target(function(errorElement) {
     *            errorElement.appendTo($("#myErrors"));
     *            return false;
     *          });
     */
    $.Guard.prototype.target = function(target) {
        this._target = target;
        return this;
    };

    /**
     * Determine if this guard applies to the given element (or
     * elements).
     */
    $.Guard.prototype.appliesTo = function(element) {
        return $(element).filter(this._selector).size() > 0;
    };

    /**
     * Using this guard, test the given element.  If this guard is
     * grouped, the element is expected to actually be all field
     * elements.  Returns false but doesn't apply the guard if there
     * are already errors detected on the element(s).  Returns true if
     * the selector defined for this guard doesn't apply to this
     * element(s).  Otherwise, applies the guard and adds an error if
     * it fails.
     */
    $.Guard.prototype.test = function(element) {
        var $elements = $(element).filter(this._selector);

        if ($elements.size() == 0) {
            return true;
        }

        if (!this._guards.options.stackErrors && $elements.hasErrors()) {
            return false;
        }

        var result;

        // Grouped expects a group of elements, while non-grouped
        // expects a single element.
        if (this._grouped) {
            var values = [];
            var elements = [];

            $elements.each(function() {
                values.push($(this).inputValue(this._guards));
                elements.push(this);
            });

            if (this._precondition && this._precondition(values, elements) === false) {
                result = true;
            } else {
                result = this._guard(values, elements);
            }
        } else {
            var value = $elements.inputValue(this._guards);

            if (this._precondition && this._precondition(value, element) === false) {
                result = true;
            } else {
                result = this._guard(value, element);
            }
        }

        if (!result) {
            this.triggerError($elements);
        }

        return result;
    };

    /**
     * Explicitly trigger the error for this guard on all the elements
     * provided to this function.  The elements are wrapped with a
     * jQuery object, so they may be a single element, a list of
     * elements, a jQuery selected set of elements, or even a valid
     * jQuery selector.  Note that the elements don't have to be valid
     * for this guard to be applied.
     */
    $.Guard.prototype.triggerError = function(elements) {
        if (this._grouped) {
            $(elements).addSingleError(this);
        } else {
            $(elements).addError(this);
        }

        return this;
    }

    $.GuardError = function(guard, element, errorElement, linked) {
        this._guard = guard;
        this._element = element;
        this._errorElement = errorElement;
        this._linked = linked;
        this._cleared = false;
    };

    /**
     * Clear this error and any errors linked with it (grouped guards
     * and radio buttons cause all elements involved to be linked).
     */
    $.GuardError.prototype.clear = function() {
        if (this._cleared) {
            return;
        }

        this._errorElement.remove();
        var index = $.inArray(this, this._element.errors);

        if (index >= 0) {
            this._element.errors.splice(index, 1);
        }

        if (!$(this._element).hasErrorsWithInvalidClass(this._guard._invalidClass)) {
            $(this._element).removeClass(this._guard._invalidClass);
        }

        this._cleared = true;

        while (this._linked.length > 0) {
            this._linked.shift().clear();
        }
    };

    /**
     * Find any applicable fields for this selected item.  Applicable
     * fields are any inputs, textareas or selects.
     */
    $.fn.guardableFields = function() {
        return this.find(":guardable");
    };

    /**
     * Return the result of guarding the selected form.
     */
    $.fn.guard = function() {
        return $.guards.guard(this);
    };

    /**
     * Explicitly trigger the given guard's error all the selected
     * elements.  Note that the selected elements don't have to be
     * valid for this guard to be applied.  This is equivalent to
     * calling guard.triggerError($this);
     */
    $.fn.triggerError = function(guard) {
        guard.triggerError(this);
    };

    /**
     * Add a single error message, but mark every selected element as
     * in error pointing to the single error message.  This differs
     * from addError because addError will add a new error message for
     * each selected element instead of just 1.
     */
    $.fn.addSingleError = function(guard) {
        if (this.size() == 0) {
            $.guards.log("Attempted to add error to nothing.");
            return this;
        }

        var element = guard.errorElement();
        guard.attachError(this, element);
        this.addClass(guard._invalidClass);
        var linked = [];

        return this.each(function() {
            if (!this.errors) {
                this.errors = [];
            }

            var error = new $.GuardError(guard, this, element, linked);
            linked.push(error);
            this.errors.push(error);
        });
    };

    /**
     * Add an error message to each of the selected elements, with an
     * optional error target to place it.  The target can be a
     * selector, though it will use the first selected element as the
     * target.
     */
    $.fn.addError = function(guard) {
        var radiosAdded = {};

        return this.each(function() {
            var $this = $(this);

            if ($this.is(":radio")) {
                var name = $this.attr("name");

                if (radiosAdded[name]) {
                    return;
                }

                radiosAdded[name] = true;
                var radios = $("input[name='" + name + "']:radio", $this.parents("form"));
                radios.addSingleError(guard);
            } else {
                $this.addSingleError(guard);
            }
        });
    };

    /**
     * Obtain all errors attached to the selected elements.
     */
    $.fn.errors = function() {
        var result = [];

        this.each(function() {
            if (this.errors && this.errors.length > 0) {
                result.push.apply(result, this.errors);
            }
        });

        return result;
    };

    /**
     * Clear errors attached to the selected elements.
     */
    $.fn.clearErrors = function() {
        $.each(this.errors(), function(index, error) {
            error.clear();
        });

        return this;
    };

    /**
     * Determine if any errors exist in the selected elements.
     */
    $.fn.hasErrors = function() {
        return this.errors().length > 0;
    };

    $.fn.hasErrorsWithInvalidClass = function(invalidClass) {
        var result = false;

        $.each(this.errors(), function(i, error) {
            if (error._guard._invalidClass == invalidClass) {
                result = true;
                return false;
            }
        });

        return result;
    };

    /**
     * Obtain the value of the first selected input.  This differs
     * from val() in that it will properly get the value of a set of
     * radio buttons.
     */
    $.fn.inputValue = function(guards) {
        guards = guards || $.guards;

        if (this.is(":radio")) {
            var checked = $("input[name='" + this.attr("name") + "']:radio:checked", this.parents("form"));

            if (checked.size() == 0) {
                return guards.constants.notChecked;
            }

            return checked.val();
        }

        if (this.is(":checkbox")) {
            if (this.is(":checked")) {
                return this.val();
            }

            return guards.constants.notChecked;
        }

        return this.val();
    };

    /**
     * Enable guards of this form by attaching a submit button to it
     * that returns the result of calling guard().  This will block
     * any other submit event handlers and prevent the form from being
     * submitted if guarding fails.
     */
    $.fn.enableGuards = function() {
        return this.submit(function() {
            return $(this).guard();
        });
    };

    /**
     * Enable guards for any form that matches the given selector.
     * This uses live events to catch submit on forms matching the
     * selector.
     */
    $.enableGuards = function(selector) {
        $.guards.enableGuards(selector);
    };

    /**
     * Live guard the form(s) in the given selector.  This will bind
     * live on change and blur events that will guard the elements
     * when they change.  It will also guard the form when it is
     * submitted.
     */
    $.liveGuard = function(selector) {
        $.guards.liveGuard(selector);
    };

    $.extend($.expr[":"], {
        "has-error": function(x) {
            return new Boolean(x.errors && x.errors.length > 0).valueOf();
        },
        "guardable": function(x) {
            return x.tagName.toLowerCase() == "input" || x.tagName.toLowerCase() == "textarea" || x.tagName.toLowerCase() == "select";
        }
    });

    $.guards = new $.Guards();

    $(function() {
        // Clear errors when the user expresses intent to fix the
        // errors.
        var clearFn = function() { $(this).clearErrors(); };
        $.guards.on(":has-error", "change", clearFn);
        $.guards.on(":has-error:radio,:has-error:checkbox", "mouseup", clearFn);
        $.guards.on("select:has-error", "mousedown", clearFn);

        // Make sure we don't clear it if there was no error when the
        // keydown happened, otherwise a submit on enter will have the
        // error flash and then go away on the keyup.
        $.guards.on(":has-error", "keydown", function() { this.clearable = true; });
        $.guards.on(":has-error", "keyup", function() {
            if (this.clearable) {
                this.clearable = false;
                $(this).clearErrors();
            }
        });
    });
})(jQuery);