|
|
|
/**
|
|
|
|
* mod-validator
|
|
|
|
*
|
|
|
|
* @author overtrue <anzhengchao@gmail.com>
|
|
|
|
* @link https://github.com/overtrue/validator.js
|
|
|
|
* @version 0.0.9
|
|
|
|
* @license MIT
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* mod-validator
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
(function() {
|
|
|
|
|
|
|
|
// numeric rules
|
|
|
|
var _numericRules = ['Numeric', 'Integer'];
|
|
|
|
|
|
|
|
// messages
|
|
|
|
var _messages = {
|
|
|
|
accepted : "The :attribute must be accepted.",
|
|
|
|
alpha : "The :attribute may only contain letters.",
|
|
|
|
alpha_dash : "The :attribute may only contain letters, numbers, and dashes.",
|
|
|
|
alpha_num : "The :attribute may only contain letters and numbers.",
|
|
|
|
array : "The :attribute must be an array.",
|
|
|
|
object : "The :attribute must be an object.",
|
|
|
|
between : {
|
|
|
|
numeric : "The :attribute must be between :min and :max.",
|
|
|
|
string : "The :attribute must be between :min and :max characters.",
|
|
|
|
array : "The :attribute must have between :min and :max items.",
|
|
|
|
},
|
|
|
|
confirmed : "The :attribute confirmation does not match.",
|
|
|
|
different : "The :attribute and :other must be different.",
|
|
|
|
digits : "The :attribute must be :digits digits.",
|
|
|
|
digits_between : "The :attribute must be between :min and :max digits.",
|
|
|
|
email : ":attribute 格式错误.",
|
|
|
|
allow : "The selected :attribute is invalid.",
|
|
|
|
integer : "The :attribute must be an integer.",
|
|
|
|
ip : ":attribute 必须是一个有效的IP地址.",
|
|
|
|
max : {
|
|
|
|
numeric : ":attribute 不能超过 :max.",
|
|
|
|
string : "The :attribute may not be greater than :max characters.",
|
|
|
|
array : "The :attribute may not have more than :max items.",
|
|
|
|
},
|
|
|
|
min : {
|
|
|
|
numeric : "The :attribute must be at least :min.",
|
|
|
|
string : "The :attribute must be at least :min characters.",
|
|
|
|
array : "The :attribute must have at least :min items.",
|
|
|
|
},
|
|
|
|
not_in : "选择项 :attribute 无效.",
|
|
|
|
numeric : " :attribute 必须是数字.",
|
|
|
|
regex : " :attribute 格式无效.",
|
|
|
|
required : " :attribute 不可为空.",
|
|
|
|
required_if : "The :attribute field is required when :other is :value.",
|
|
|
|
required_with : "The :attribute field is required when :values is present.",
|
|
|
|
required_without : "The :attribute field is required when :values is not present.",
|
|
|
|
same : "The :attribute and :other must match.",
|
|
|
|
size : {
|
|
|
|
numeric : "The :attribute must be :size.",
|
|
|
|
string : "The :attribute must be :size characters.",
|
|
|
|
array : "The :attribute must contain :size items.",
|
|
|
|
},
|
|
|
|
url : ":attribute 格式无效.",
|
|
|
|
def : 'The :attribute attribute has errors.',
|
|
|
|
};
|
|
|
|
|
|
|
|
// attribute alias
|
|
|
|
var _attributes = {};
|
|
|
|
|
|
|
|
// attribute value alias
|
|
|
|
var _values = {};
|
|
|
|
|
|
|
|
// input data
|
|
|
|
var _input = {};
|
|
|
|
|
|
|
|
// validation rules
|
|
|
|
var _rules = {};
|
|
|
|
|
|
|
|
// failed rules
|
|
|
|
var _failedRules = {};
|
|
|
|
|
|
|
|
// errors
|
|
|
|
var _errors = {};
|
|
|
|
|
|
|
|
// attribute replacers
|
|
|
|
var _replacers = {};
|
|
|
|
|
|
|
|
// translator
|
|
|
|
var _translator = {
|
|
|
|
trans: function(key){
|
|
|
|
return key;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Based on jquery's extend function
|
|
|
|
function extend() {
|
|
|
|
var src, copy, name, options, clone;
|
|
|
|
var target = arguments[0] || {};
|
|
|
|
var i = 1;
|
|
|
|
var length = arguments.length;
|
|
|
|
|
|
|
|
for ( ; i < length; i++ ) {
|
|
|
|
// Only deal with non-null/undefined values
|
|
|
|
if ( (options = arguments[ i ]) != null ) {
|
|
|
|
// Extend the base object
|
|
|
|
for ( name in options ) {
|
|
|
|
src = target[ name ];
|
|
|
|
copy = options[ name ];
|
|
|
|
|
|
|
|
// Prevent never-ending loop
|
|
|
|
if ( target === copy ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Recurse if we're merging plain objects or arrays
|
|
|
|
if ( copy && typeof copy === "object" ) {
|
|
|
|
clone = src && typeof src === "object" ? src : {};
|
|
|
|
|
|
|
|
// Never move original objects, clone them
|
|
|
|
target[ name ] = extend( clone, copy );
|
|
|
|
|
|
|
|
// Don't bring in undefined values
|
|
|
|
} else if ( copy !== undefined ) {
|
|
|
|
target[ name ] = copy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the modified object
|
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
|
|
|
//php function:in_array
|
|
|
|
function in_array(needle, haystack, argStrict) {
|
|
|
|
var key = '',
|
|
|
|
strict = !! argStrict;
|
|
|
|
|
|
|
|
for (key in haystack) {
|
|
|
|
if (strict ? (haystack[key] === needle) : haystack[key] == needle) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine needle is a object
|
|
|
|
*
|
|
|
|
* @param {Mixed} needle
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function is_object(needle) {
|
|
|
|
return (typeof needle === 'object');
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine object is a empty object
|
|
|
|
*
|
|
|
|
* @param {Object} obj
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function isEmptyObject(obj){
|
|
|
|
for(var n in obj){return false}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine needle is a array
|
|
|
|
*
|
|
|
|
* @param {Mixed} needle
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function is_array(arr) {
|
|
|
|
return typeof arr === 'object' && typeof arr.length === 'number' && !(arr.propertyIsEnumerable('length')) &&
|
|
|
|
typeof arr.splice === 'function';
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine needle is a function
|
|
|
|
*
|
|
|
|
* @param {Mixed} needle
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function is_function(needle) {
|
|
|
|
return (typeof needle === 'function');
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine needle is a object
|
|
|
|
*
|
|
|
|
* @param {Mixed} needle
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function is_string(needle) {
|
|
|
|
return (typeof needle === 'string');
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* explode the rules into an array of rules.
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
function _explodeRules(rules) {
|
|
|
|
for (var i in rules) {
|
|
|
|
if (is_string(rules[i])) {
|
|
|
|
rules[i] = rules[i].split('|');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rules;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* parse the rule
|
|
|
|
*
|
|
|
|
* @param {Array} rule
|
|
|
|
*
|
|
|
|
* @return {Object}
|
|
|
|
*/
|
|
|
|
function _parseRule(rule) {
|
|
|
|
var parameters = [];
|
|
|
|
|
|
|
|
// The format for specifying validation rules and parameters follows an
|
|
|
|
// easy {rule}:{parameters} formatting convention. For instance the
|
|
|
|
// rule "Max:3" states that the value may only be three letters.
|
|
|
|
if (rule.indexOf(':')) {
|
|
|
|
var ruleInfo = rule.split(':');
|
|
|
|
parameters = _parseParameters(ruleInfo[0], ruleInfo[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return { parameters: parameters, rule: ruleInfo[0]};
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* parse parameters of rule
|
|
|
|
*
|
|
|
|
* @param {String} rule
|
|
|
|
* @param {String} parameter
|
|
|
|
*
|
|
|
|
* @return {Array}
|
|
|
|
*/
|
|
|
|
function _parseParameters(rule, parameter) {
|
|
|
|
if (rule.toLowerCase() == 'regex') return [parameter];
|
|
|
|
if (is_string(parameter)) {
|
|
|
|
return parameter.split(',');
|
|
|
|
};
|
|
|
|
|
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* add a failure rule
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {String} rule
|
|
|
|
* @param {Array} parameters
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
function _addFailure(attribute, rule, parameters) {
|
|
|
|
_addError(attribute, rule, parameters);
|
|
|
|
if (! _failedRules[attribute]) {
|
|
|
|
_failedRules[attribute] = {};
|
|
|
|
}
|
|
|
|
_failedRules[attribute][rule] = parameters;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* add a error message
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {String} rule
|
|
|
|
* @param {Array} parameters
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
function _addError(attribute, rule, parameters) {
|
|
|
|
if (_errors[attribute]) {
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
_errors[attribute] = _formatMessage(_getMessage(attribute, rule) || '', attribute, rule, parameters);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get value of arrtibute
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
*
|
|
|
|
* @return {Mixed}
|
|
|
|
*/
|
|
|
|
function _getValue(attribute) {
|
|
|
|
return _input[attribute] || null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get attribute message
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {String} rule
|
|
|
|
*
|
|
|
|
* @return {String}
|
|
|
|
*/
|
|
|
|
function _getMessage(attribute, rule) {
|
|
|
|
|
|
|
|
var message = _messages[rule];
|
|
|
|
if (is_object(message)) {
|
|
|
|
var value = _getValue(attribute);
|
|
|
|
if (is_array(value) && message['array']) {
|
|
|
|
return message['array'];
|
|
|
|
} else if (_resolvers.numeric(value) && message['numeric']) {
|
|
|
|
return message['numeric'];
|
|
|
|
} else if (is_string(value) && message['string']){
|
|
|
|
return message['string'];
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
return message;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* replace attributes.
|
|
|
|
*
|
|
|
|
* @param {String} message
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {String} rule
|
|
|
|
* @param {Array} parameters
|
|
|
|
*
|
|
|
|
* @return {String}
|
|
|
|
*/
|
|
|
|
function _formatMessage(message, attribute, rule, parameters) {
|
|
|
|
parameters.unshift(_getAttribute(attribute));
|
|
|
|
|
|
|
|
for(i in parameters){
|
|
|
|
message = message.replace(/:[a-zA-z_][a-zA-z_0-9]+/, parameters[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (typeof _replacers[rule] === 'function') {
|
|
|
|
message = _replacers[rule](message, attribute, rule, parameters);
|
|
|
|
}
|
|
|
|
|
|
|
|
return message;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get attribute name
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
*
|
|
|
|
* @return {String}
|
|
|
|
*/
|
|
|
|
function _getAttribute(attribute) {
|
|
|
|
if (is_string(_attributes[attribute])) {
|
|
|
|
return _attributes[attribute];
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((line = _translator.trans(attribute)) !== attribute) {
|
|
|
|
return line;
|
|
|
|
} else {
|
|
|
|
return attribute.replace('_', ' ');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine if the given attribute has a rule in the given set.
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {String|array} rules
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function _hasRule(attribute, rules) {
|
|
|
|
return ! _getRule(attribute, rules) == null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get rule and parameters of a rules
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {String|array} rules
|
|
|
|
*
|
|
|
|
* @return {Array|null}
|
|
|
|
*/
|
|
|
|
function _getRule(attribute, rules) {
|
|
|
|
rules = rules || [];
|
|
|
|
|
|
|
|
if ( ! rules[attribute]) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(var i in rules[attribute]) {
|
|
|
|
var value = rules[attribute][i];
|
|
|
|
parsedRule = _parseRule(rule);
|
|
|
|
|
|
|
|
if (in_array(parsedRule.rule, rules))
|
|
|
|
return [parsedRule.rule, parsedRule.parameters];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get attribute size
|
|
|
|
*
|
|
|
|
* @param {String} attribute
|
|
|
|
* @param {Mixed} value
|
|
|
|
*
|
|
|
|
* @return {Number}
|
|
|
|
*/
|
|
|
|
function _getSize(attribute, value) {
|
|
|
|
hasNumeric = _hasRule(attribute, _numericRules);
|
|
|
|
|
|
|
|
// This method will determine if the attribute is a number, string, or file and
|
|
|
|
// return the proper size accordingly. If it is a number, then number itself
|
|
|
|
// is the size. If it is a file, we take kilobytes, and for a string the
|
|
|
|
// entire length of the string will be considered the attribute size.
|
|
|
|
if (/^[0-9]+$/.test(value) && hasNumeric) {
|
|
|
|
return getValue(attribute);
|
|
|
|
} else if (value && is_string(value) || is_array(value)) {
|
|
|
|
return value.length;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* check parameters count
|
|
|
|
*
|
|
|
|
* @param {Number} count
|
|
|
|
* @param {Array} parameters
|
|
|
|
* @param {String} rule
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
function _requireParameterCount(count, parameters, rule) {
|
|
|
|
if (parameters.length < count) {
|
|
|
|
throw Error('Validation rule"' + rule + '" requires at least ' + count + ' parameters.');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* all failing check
|
|
|
|
*
|
|
|
|
* @param {Array} attributes
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
function _allFailingRequired(attributes) {
|
|
|
|
for (var i in attributes) {
|
|
|
|
var akey = attributes[i];
|
|
|
|
|
|
|
|
if (resolvers.validateRequired(key, self._getValue(key))) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* determine if any of the given attributes fail the required test.
|
|
|
|
*
|
|
|
|
* @param array $attributes
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
function _anyFailingRequired(attributes) {
|
|
|
|
for (var i in attributes) {
|
|
|
|
var key = attributes[i];
|
|
|
|
if ( ! _resolvers.validateRequired(key, self.date[key])) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
var _resolvers = {
|
|
|
|
accepted: function(attribute, value) {
|
|
|
|
var acceptable = ['yes', 'on', '1', 1, true, 'true'];
|
|
|
|
|
|
|
|
is_string(value) && (value = value.toLowerCase());
|
|
|
|
|
|
|
|
return (this.required(attribute, value) && in_array(value, acceptable, true));
|
|
|
|
},
|
|
|
|
|
|
|
|
alpha: function(attribute, value) {
|
|
|
|
if (!value) { return false;};
|
|
|
|
return ((new RegExp('^[a-z]+$', 'i')).test(value));
|
|
|
|
},
|
|
|
|
|
|
|
|
alpha_dash: function(attribute, value) {
|
|
|
|
return ((new RegExp('^[a-z0-9\-_]+$', 'i')).test(value));
|
|
|
|
},
|
|
|
|
|
|
|
|
alpha_num: function(attribute, value) {
|
|
|
|
return ((new RegExp('^[a-z0-9]+$', 'i')).test(value));
|
|
|
|
},
|
|
|
|
|
|
|
|
array: function(attribute, value) {
|
|
|
|
return is_array(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
object: function(attribute, value) {
|
|
|
|
return is_object(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
between: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(2, parameters, 'between');
|
|
|
|
|
|
|
|
var size = _getSize(attribute, value);
|
|
|
|
|
|
|
|
return size >= parameters[0] && size <= parameters[1];
|
|
|
|
},
|
|
|
|
|
|
|
|
confirmed: function(attribute, value, parameters) {
|
|
|
|
return this.same(attribute, value, [attribute + '_confirmation']);
|
|
|
|
},
|
|
|
|
|
|
|
|
same: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(1, parameters, 'same');
|
|
|
|
|
|
|
|
var other = _getValue(parameters[0]);
|
|
|
|
|
|
|
|
return (other && value == other);
|
|
|
|
},
|
|
|
|
|
|
|
|
different: function(attribute, value, parameters) {
|
|
|
|
return ! this.same(attribute, value, parameters);
|
|
|
|
},
|
|
|
|
|
|
|
|
digits: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(1, parameters, 'digits');
|
|
|
|
|
|
|
|
return (new RegExp('^\d{' + Math.abs(parameters[0]) + '}$')).test(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
digits_between: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(2, parameters, 'digits_between');
|
|
|
|
|
|
|
|
return ((new RegExp('^\d{' + Math.abs(parameters[0]) + '}$')).test(value)
|
|
|
|
&& value > parameters[0]
|
|
|
|
&& value < parameters[1]);
|
|
|
|
},
|
|
|
|
|
|
|
|
email: function(attribute, value) {
|
|
|
|
var regex = /^((([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;
|
|
|
|
|
|
|
|
return regex.test(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
"in": function(attribute, value, parameters) {
|
|
|
|
return in_array(value || '', parameters);
|
|
|
|
},
|
|
|
|
|
|
|
|
not_in: function(attribute, value, parameters) {
|
|
|
|
return !in_array(value || '', parameters);
|
|
|
|
},
|
|
|
|
|
|
|
|
integer: function(attribute, value) {
|
|
|
|
return /^(?:-?(?:0|[1-9][0-9]*))$/.test(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
ip: function(attribute, value) {
|
|
|
|
var ipv4Maybe = /^(\d?\d?\d)\.(\d?\d?\d)\.(\d?\d?\d)\.(\d?\d?\d)$/
|
|
|
|
, ipv6 = /^::|^::1|^([a-fA-F0-9]{1,4}::?){1,7}([a-fA-F0-9]{1,4})$/;
|
|
|
|
return ipv4Maybe.test(value) || ipv6.test(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
max: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(1, parameters, 'max');
|
|
|
|
|
|
|
|
return _getSize(attribute, value) <= parameters[0];
|
|
|
|
},
|
|
|
|
|
|
|
|
min: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(1, parameters, 'min');
|
|
|
|
|
|
|
|
return _getSize(attribute, value) >= parameters[0];
|
|
|
|
},
|
|
|
|
|
|
|
|
numeric: function(attribute, value) {
|
|
|
|
return /^[0-9]+$/.test(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
regex: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(1, parameters, 'regex');
|
|
|
|
|
|
|
|
return (new RegExp(eval(parameters[0]))).test(value);
|
|
|
|
},
|
|
|
|
|
|
|
|
required: function(attribute, value) {
|
|
|
|
if (!value || undefined === value) {
|
|
|
|
return false;
|
|
|
|
} else if ((is_string(value) || is_array(value) || is_object(value)) && !value.length) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
required_if: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(2, parameters, 'required_if');
|
|
|
|
|
|
|
|
var _input = getValue(parameters[0]);
|
|
|
|
|
|
|
|
var values = parameters.splice(1);
|
|
|
|
|
|
|
|
if (in_array(data, values)) {
|
|
|
|
return resolvers.required(attribute, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
required_with: function(attribute, value, parameters) {
|
|
|
|
if ( ! self._allFailingRequired(parameters)) {
|
|
|
|
return resolvers.required(attribute, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
required_without: function(attribute, value, parameters) {
|
|
|
|
if (self._anyFailingRequired(parameters)) {
|
|
|
|
return resolvers.required(attribute, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
|
|
|
|
size: function(attribute, value, parameters) {
|
|
|
|
_requireParameterCount(1, parameters, 'size');
|
|
|
|
|
|
|
|
return _getSize(attribute, value) == parameters[0];
|
|
|
|
},
|
|
|
|
|
|
|
|
url: function(attribute, value) {
|
|
|
|
var strRegex = "^((https|http|ftp|rtsp|mms)?://)"
|
|
|
|
+ "?(([0-9a-z_!~*'().&=+$%-]+: )?[0-9a-z_!~*'().&=+$%-]+@)?" //ftp user@
|
|
|
|
+ "(([0-9]{1,3}/.){3}[0-9]{1,3}" // IP- 199.194.52.184
|
|
|
|
+ "|" // ip or domain
|
|
|
|
+ "([0-9a-z_!~*'()-]+/.)*" // domain- www.
|
|
|
|
+ "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]/." // sub domain
|
|
|
|
+ "[a-z]{2,6})" // first level domain- .com or .museum
|
|
|
|
+ "(:[0-9]{1,4})?" // port- :80
|
|
|
|
+ "((/?)|" // a slash isn't required if there is no file name
|
|
|
|
+ "(/[0-9a-z_!~*'().;?:@&=+$,%#-]+)+/?)$";
|
|
|
|
var regex = new RegExp(strRegex);
|
|
|
|
|
|
|
|
return regex.test(value);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
var Validator = function(input, rules, customMessages) {
|
|
|
|
if (undefined === input || undefined === rules) {
|
|
|
|
throw Error('Validator constructor requires at least 2 parameters.');
|
|
|
|
};
|
|
|
|
// reset data expect _messages,_atteibutes, _values
|
|
|
|
_input = input;
|
|
|
|
_rules = rules;
|
|
|
|
_failedRules = {};
|
|
|
|
_errors = {};
|
|
|
|
_messages = extend({}, _messages, customMessages || {});
|
|
|
|
};
|
|
|
|
|
|
|
|
Validator.prototype = {
|
|
|
|
name: 'Validator',
|
|
|
|
constructor: Validator,
|
|
|
|
|
|
|
|
// error messages
|
|
|
|
// {username: xxxx, password: xxxx}
|
|
|
|
messages: function() {
|
|
|
|
return _errors;
|
|
|
|
},
|
|
|
|
|
|
|
|
errors: function(){
|
|
|
|
return _errors;
|
|
|
|
},
|
|
|
|
|
|
|
|
// faildRules
|
|
|
|
faildRules: _failedRules,
|
|
|
|
|
|
|
|
// set translator
|
|
|
|
setTranslator: function(translator){
|
|
|
|
_translator = translator || _translator;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* exec validate
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
passes: function() {
|
|
|
|
rulesArray = _explodeRules(_rules);
|
|
|
|
|
|
|
|
for (var attribute in rulesArray) {
|
|
|
|
|
|
|
|
var rules = rulesArray[attribute];
|
|
|
|
for (var i in rules) {
|
|
|
|
if (_errors[attribute]) {
|
|
|
|
continue;
|
|
|
|
};
|
|
|
|
var ruleString = rules[i];
|
|
|
|
var parsedRule = _parseRule(ruleString);
|
|
|
|
var rule = parsedRule.rule;
|
|
|
|
var parameters = parsedRule.parameters;
|
|
|
|
var value = _input[attribute] || null;
|
|
|
|
var validatable = is_function(_resolvers[rule]);
|
|
|
|
|
|
|
|
if (validatable && ! _resolvers[rule](attribute, value, parameters)) {
|
|
|
|
_addFailure(attribute, rule, parameters);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return isEmptyObject(_errors);
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* return the validate value
|
|
|
|
*
|
|
|
|
* @return {Boolean}
|
|
|
|
*/
|
|
|
|
fails: function() {
|
|
|
|
return ! this.passes();
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* add custom messages
|
|
|
|
*
|
|
|
|
* @param {String/Object} rule
|
|
|
|
* @param {String} message
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
mergeMessage: function(rule, message) {
|
|
|
|
if (is_object(rule)) {
|
|
|
|
_messages = extend({}, _messages, rule);
|
|
|
|
} else if (is_string(rule)) {
|
|
|
|
_messages[rule] = message;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* add attributes alias
|
|
|
|
*
|
|
|
|
* @param {String/Object} attribute
|
|
|
|
* @param {String} alias
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
mergeAttribute: function(attribute, alias) {
|
|
|
|
if (is_object(attribute)) {
|
|
|
|
_attributes = extend({}, _attributes, attribute);
|
|
|
|
} else if (is_string(attribute)) {
|
|
|
|
_attributes[attribute] = alias;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* add values alias
|
|
|
|
*
|
|
|
|
* @param {String/Object} attribute
|
|
|
|
* @param {String} alias
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
mergeValue: function(value, alias) {
|
|
|
|
if (is_object(value)) {
|
|
|
|
_values = extend({}, _values, value);
|
|
|
|
} else if (is_string(rule)) {
|
|
|
|
_values[value] = alias;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* add message replacers
|
|
|
|
*
|
|
|
|
* @param {String/Object} rule
|
|
|
|
* @param {Function} fn
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
mergeReplacers: function(rule, fn) {
|
|
|
|
if (is_object(rule)) {
|
|
|
|
_replacers = extend({}, _replacers, rule);
|
|
|
|
} else if (is_string(rule)) {
|
|
|
|
_replacers[rule] = fn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* register a user custom rule
|
|
|
|
*
|
|
|
|
* @param {String} rule
|
|
|
|
* @param {Function} fn
|
|
|
|
* @param {Object} errMsg
|
|
|
|
*
|
|
|
|
* @return {Void}
|
|
|
|
*/
|
|
|
|
Validator.register = function(rule, fn, errMsg) {
|
|
|
|
_resolvers[rule] = fn;
|
|
|
|
_messages[rule] = (is_string(errMsg)) ? errMsg : _messages['def'];
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* make a Validator instance
|
|
|
|
*
|
|
|
|
* @param {Object} data
|
|
|
|
* @param {Object} rule
|
|
|
|
* @param {Object} messages
|
|
|
|
*
|
|
|
|
* @return {Object}
|
|
|
|
*/
|
|
|
|
Validator.make = function(data, rule, messages){
|
|
|
|
return new Validator(data, rule, messages);
|
|
|
|
};
|
|
|
|
|
|
|
|
if (typeof module !== 'undefined' && typeof require !== 'undefined') {
|
|
|
|
module.exports = Validator;
|
|
|
|
} else {
|
|
|
|
window.Validator = window.validator = Validator;
|
|
|
|
}
|
|
|
|
|
|
|
|
}()); |
|
|
\ No newline at end of file |
