bootstrap_validator_rails 0.0.5

data/vendor/assets/javascripts/validator/cvv.js

@@ -0,0 +1,116 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.cvv = $.extend($.fn.bootstrapValidator.i18n.cvv || {}, {
+        'default': 'Please enter a valid CVV number'
+    });
+
+    $.fn.bootstrapValidator.validators.cvv = {
+        html5Attributes: {
+            message: 'message',
+            ccfield: 'creditCardField'
+        },
+
+        /**
+         * Return true if the input value is a valid CVV number.
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - creditCardField: The credit card number field. It can be null
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            if (!/^[0-9]{3,4}$/.test(value)) {
+                return false;
+            }
+
+            if (!options.creditCardField) {
+                return true;
+            }
+
+            // Get the credit card number
+            var creditCard = validator.getFieldElements(options.creditCardField).val();
+            if (creditCard === '') {
+                return true;
+            }
+            
+            creditCard = creditCard.replace(/\D/g, '');
+
+            // Supported credit card types
+            var cards = {
+                AMERICAN_EXPRESS: {
+                    length: [15],
+                    prefix: ['34', '37']
+                },
+                DINERS_CLUB: {
+                    length: [14],
+                    prefix: ['300', '301', '302', '303', '304', '305', '36']
+                },
+                DINERS_CLUB_US: {
+                    length: [16],
+                    prefix: ['54', '55']
+                },
+                DISCOVER: {
+                    length: [16],
+                    prefix: ['6011', '622126', '622127', '622128', '622129', '62213',
+                             '62214', '62215', '62216', '62217', '62218', '62219',
+                             '6222', '6223', '6224', '6225', '6226', '6227', '6228',
+                             '62290', '62291', '622920', '622921', '622922', '622923',
+                             '622924', '622925', '644', '645', '646', '647', '648',
+                             '649', '65']
+                },
+                JCB: {
+                    length: [16],
+                    prefix: ['3528', '3529', '353', '354', '355', '356', '357', '358']
+                },
+                LASER: {
+                    length: [16, 17, 18, 19],
+                    prefix: ['6304', '6706', '6771', '6709']
+                },
+                MAESTRO: {
+                    length: [12, 13, 14, 15, 16, 17, 18, 19],
+                    prefix: ['5018', '5020', '5038', '6304', '6759', '6761', '6762', '6763', '6764', '6765', '6766']
+                },
+                MASTERCARD: {
+                    length: [16],
+                    prefix: ['51', '52', '53', '54', '55']
+                },
+                SOLO: {
+                    length: [16, 18, 19],
+                    prefix: ['6334', '6767']
+                },
+                UNIONPAY: {
+                    length: [16, 17, 18, 19],
+                    prefix: ['622126', '622127', '622128', '622129', '62213', '62214',
+                             '62215', '62216', '62217', '62218', '62219', '6222', '6223',
+                             '6224', '6225', '6226', '6227', '6228', '62290', '62291',
+                             '622920', '622921', '622922', '622923', '622924', '622925']
+                },
+                VISA: {
+                    length: [16],
+                    prefix: ['4']
+                }
+            };
+            var type, i, creditCardType = null;
+            for (type in cards) {
+                for (i in cards[type].prefix) {
+                    if (creditCard.substr(0, cards[type].prefix[i].length) === cards[type].prefix[i]    // Check the prefix
+                        && $.inArray(creditCard.length, cards[type].length) !== -1)                     // and length
+                    {
+                        creditCardType = type;
+                        break;
+                    }
+                }
+            }
+
+            return (creditCardType === null)
+                        ? false
+                        : (('AMERICAN_EXPRESS' === creditCardType) ? (value.length === 4) : (value.length === 3));
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/date.js

@@ -0,0 +1,118 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.date = $.extend($.fn.bootstrapValidator.i18n.date || {}, {
+        'default': 'Please enter a valid date'
+    });
+
+    $.fn.bootstrapValidator.validators.date = {
+        html5Attributes: {
+            message: 'message',
+            format: 'format',
+            separator: 'separator'
+        },
+
+        /**
+         * Return true if the input value is valid date
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * - separator: Use to separate the date, month, and year.
+         * By default, it is /
+         * - format: The date format. Default is MM/DD/YYYY
+         * The format can be:
+         *
+         * i) date: Consist of DD, MM, YYYY parts which are separated by the separator option
+         * ii) date and time:
+         * The time can consist of h, m, s parts which are separated by :
+         * ii) date, time and A (indicating AM or PM)
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            options.format = options.format || 'MM/DD/YYYY';
+
+            var formats    = options.format.split(' '),
+                dateFormat = formats[0],
+                timeFormat = (formats.length > 1) ? formats[1] : null,
+                amOrPm     = (formats.length > 2) ? formats[2] : null,
+                sections   = value.split(' '),
+                date       = sections[0],
+                time       = (sections.length > 1) ? sections[1] : null;
+
+            if (formats.length !== sections.length) {
+                return false;
+            }
+
+            // Determine the separator
+            var separator = options.separator;
+            if (!separator) {
+                separator = (date.indexOf('/') !== -1) ? '/' : ((date.indexOf('-') !== -1) ? '-' : null);
+            }
+            if (separator === null || date.indexOf(separator) === -1) {
+                return false;
+            }
+
+            // Determine the date
+            date       = date.split(separator);
+            dateFormat = dateFormat.split(separator);
+            if (date.length !== dateFormat.length) {
+                return false;
+            }
+
+            var year  = date[$.inArray('YYYY', dateFormat)],
+                month = date[$.inArray('MM', dateFormat)],
+                day   = date[$.inArray('DD', dateFormat)];
+
+            if (!year || !month || !day) {
+                return false;
+            }
+
+            // Determine the time
+            var minutes = null, hours = null, seconds = null;
+            if (timeFormat) {
+                timeFormat = timeFormat.split(':');
+                time       = time.split(':');
+
+                if (timeFormat.length !== time.length) {
+                    return false;
+                }
+
+                hours   = time.length > 0 ? time[0] : null;
+                minutes = time.length > 1 ? time[1] : null;
+                seconds = time.length > 2 ? time[2] : null;
+
+                // Validate seconds
+                if (seconds) {
+                    seconds = parseInt(seconds, 10);
+                    if (isNaN(seconds) || seconds < 0 || seconds > 60) {
+                        return false;
+                    }
+                }
+
+                // Validate hours
+                if (hours) {
+                    hours = parseInt(hours, 10);
+                    if (isNaN(hours) || hours < 0 || hours >= 24 || (amOrPm && hours > 12)) {
+                        return false;
+                    }
+                }
+
+                // Validate minutes
+                if (minutes) {
+                    minutes = parseInt(minutes, 10);
+                    if (isNaN(minutes) || minutes < 0 || minutes > 59) {
+                        return false;
+                    }
+                }
+            }
+
+            // Validate day, month, and year
+            return $.fn.bootstrapValidator.helpers.date(year, month, day);
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/different.js

@@ -0,0 +1,41 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.different = $.extend($.fn.bootstrapValidator.i18n.different || {}, {
+        'default': 'Please enter a different value'
+    });
+
+    $.fn.bootstrapValidator.validators.different = {
+        html5Attributes: {
+            message: 'message',
+            field: 'field'
+        },
+
+        /**
+         * Return true if the input value is different with given field's value
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consists of the following key:
+         * - field: The name of field that will be used to compare with current one
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var compareWith = validator.getFieldElements(options.field);
+            if (compareWith === null) {
+                return true;
+            }
+
+            if (value !== compareWith.val()) {
+                validator.updateStatus(options.field, validator.STATUS_VALID, 'different');
+                return true;
+            } else {
+                return false;
+            }
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/digits.js

@@ -0,0 +1,24 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.digits = $.extend($.fn.bootstrapValidator.i18n.digits || {}, {
+        'default': 'Please enter only digits'
+    });
+
+    $.fn.bootstrapValidator.validators.digits = {
+        /**
+         * Return true if the input value contains digits only
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options]
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            return /^\d+$/.test(value);
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/ean.js

@@ -0,0 +1,40 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.ean = $.extend($.fn.bootstrapValidator.i18n.ean || {}, {
+        'default': 'Please enter a valid EAN number'
+    });
+
+    $.fn.bootstrapValidator.validators.ean = {
+        /**
+         * Validate EAN (International Article Number)
+         * Examples:
+         * - Valid: 73513537, 9780471117094, 4006381333931
+         * - Invalid: 73513536
+         *
+         * @see http://en.wikipedia.org/wiki/European_Article_Number
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            if (!/^(\d{8}|\d{12}|\d{13})$/.test(value)) {
+                return false;
+            }
+
+            var length = value.length,
+                sum    = 0,
+                weight = (length === 8) ? [3, 1] : [1, 3];
+            for (var i = 0; i < length - 1; i++) {
+                sum += parseInt(value.charAt(i), 10) * weight[i % 2];
+            }
+            sum = (10 - sum % 10) % 10;
+            return (sum + '' === value.charAt(length - 1));
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/emailAddress.js

@@ -0,0 +1,31 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.emailAddress = $.extend($.fn.bootstrapValidator.i18n.emailAddress || {}, {
+        'default': 'Please enter a valid email address'
+    });
+
+    $.fn.bootstrapValidator.validators.emailAddress = {
+        enableByHtml5: function($field) {
+            return ('email' === $field.attr('type'));
+        },
+
+        /**
+         * Return true if and only if the input value is a valid email address
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} [options]
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            // Email address regular expression
+            // http://stackoverflow.com/questions/46155/validate-email-address-in-javascript
+            var emailRegExp = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+            return emailRegExp.test(value);
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/file.js

@@ -0,0 +1,69 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.file = $.extend($.fn.bootstrapValidator.i18n.file || {}, {
+        'default': 'Please choose a valid file'
+    });
+
+    $.fn.bootstrapValidator.validators.file = {
+        html5Attributes: {
+            extension: 'extension',
+            maxsize: 'maxSize',
+            message: 'message',
+            type: 'type'
+        },
+
+        /**
+         * Validate upload file. Use HTML 5 API if the browser supports
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - extension: The allowed extensions, separated by a comma
+         * - maxSize: The maximum size in bytes
+         * - message: The invalid message
+         * - type: The allowed MIME type, separated by a comma
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var ext,
+                extensions = options.extension ? options.extension.toLowerCase().split(',') : null,
+                types      = options.type      ? options.type.toLowerCase().split(',')      : null,
+                html5      = (window.File && window.FileList && window.FileReader);
+
+            if (html5) {
+                // Get FileList instance
+                var files = $field.get(0).files,
+                    total = files.length;
+                for (var i = 0; i < total; i++) {
+                    // Check file size
+                    if (options.maxSize && files[i].size > parseInt(options.maxSize, 10)) {
+                        return false;
+                    }
+
+                    // Check file extension
+                    ext = files[i].name.substr(files[i].name.lastIndexOf('.') + 1);
+                    if (extensions && $.inArray(ext.toLowerCase(), extensions) === -1) {
+                        return false;
+                    }
+
+                    // Check file type
+                    if (types && $.inArray(files[i].type.toLowerCase(), types) === -1) {
+                        return false;
+                    }
+                }
+            } else {
+                // Check file extension
+                ext = value.substr(value.lastIndexOf('.') + 1);
+                if (extensions && $.inArray(ext.toLowerCase(), extensions) === -1) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/greaterThan.js

@@ -0,0 +1,61 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.greaterThan = $.extend($.fn.bootstrapValidator.i18n.greaterThan || {}, {
+        'default': 'Please enter a value greater than or equal to %s',
+        notInclusive: 'Please enter a value greater than %s'
+    });
+
+    $.fn.bootstrapValidator.validators.greaterThan = {
+        html5Attributes: {
+            message: 'message',
+            value: 'value',
+            inclusive: 'inclusive'
+        },
+
+        enableByHtml5: function($field) {
+            var min = $field.attr('min');
+            if (min) {
+                return {
+                    value: min
+                };
+            }
+
+            return false;
+        },
+
+        /**
+         * Return true if the input value is greater than or equals to given number
+         *
+         * @param {BootstrapValidator} validator Validate plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - value: Define the number to compare with. It can be
+         *      - A number
+         *      - Name of field which its value defines the number
+         *      - Name of callback function that returns the number
+         *      - A callback function that returns the number
+         *
+         * - inclusive [optional]: Can be true or false. Default is true
+         * - message: The invalid message
+         * @returns {Boolean|Object}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            var compareTo = $.isNumeric(options.value) ? options.value : validator.getDynamicOption($field, options.value);
+
+            value = parseFloat(value);
+			return (options.inclusive === true || options.inclusive === undefined)
+                    ? {
+                        valid: value >= compareTo,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.greaterThan['default'], compareTo)
+                    }
+                    : {
+                        valid: value > compareTo,
+                        message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.greaterThan.notInclusive, compareTo)
+                    };
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/grid.js

@@ -0,0 +1,37 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.grid = $.extend($.fn.bootstrapValidator.i18n.grid || {}, {
+        'default': 'Please enter a valid GRId number'
+    });
+
+    $.fn.bootstrapValidator.validators.grid = {
+        /**
+         * Validate GRId (Global Release Identifier)
+         * Examples:
+         * - Valid: A12425GABC1234002M, A1-2425G-ABC1234002-M, A1 2425G ABC1234002 M, Grid:A1-2425G-ABC1234002-M
+         * - Invalid: A1-2425G-ABC1234002-Q
+         *
+         * @see http://en.wikipedia.org/wiki/Global_Release_Identifier
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            value = value.toUpperCase();
+            if (!/^[GRID:]*([0-9A-Z]{2})[-\s]*([0-9A-Z]{5})[-\s]*([0-9A-Z]{10})[-\s]*([0-9A-Z]{1})$/g.test(value)) {
+                return false;
+            }
+            value = value.replace(/\s/g, '').replace(/-/g, '');
+            if ('GRID:' === value.substr(0, 5)) {
+                value = value.substr(5);
+            }
+            return $.fn.bootstrapValidator.helpers.mod37And36(value);
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/hex.js

@@ -0,0 +1,25 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.hex = $.extend($.fn.bootstrapValidator.i18n.hex || {}, {
+        'default': 'Please enter a valid hexadecimal number'
+    });
+
+    $.fn.bootstrapValidator.validators.hex = {
+        /**
+         * Return true if and only if the input value is a valid hexadecimal number
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Consist of key:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+
+            return /^[0-9a-fA-F]+$/.test(value);
+        }
+    };
+}(window.jQuery));

data/vendor/assets/javascripts/validator/hexColor.js

@@ -0,0 +1,28 @@
+(function($) {
+    $.fn.bootstrapValidator.i18n.hexColor = $.extend($.fn.bootstrapValidator.i18n.hexColor || {}, {
+        'default': 'Please enter a valid hex color'
+    });
+
+    $.fn.bootstrapValidator.validators.hexColor = {
+        enableByHtml5: function($field) {
+            return ('color' === $field.attr('type'));
+        },
+
+        /**
+         * Return true if the input value is a valid hex color
+         *
+         * @param {BootstrapValidator} validator The validator plugin instance
+         * @param {jQuery} $field Field element
+         * @param {Object} options Can consist of the following keys:
+         * - message: The invalid message
+         * @returns {Boolean}
+         */
+        validate: function(validator, $field, options) {
+            var value = $field.val();
+            if (value === '') {
+                return true;
+            }
+            return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(value);
+        }
+    };
+}(window.jQuery));