327 lines
6.5 KiB
JavaScript
327 lines
6.5 KiB
JavaScript
var _ = require('underscore');
|
|
|
|
var Rules = function(param, rules)
|
|
{
|
|
this.param = param;
|
|
this.rules = rules;
|
|
};
|
|
|
|
Rules.prototype.Error = function(message, rule, value)
|
|
{
|
|
switch(typeof(this.rules.error))
|
|
{
|
|
case 'string':
|
|
message = this.rules.error;
|
|
break;
|
|
|
|
case 'object':
|
|
|
|
if(this.rules.error[rule])
|
|
{
|
|
message = this.rules.error[rule];
|
|
}
|
|
else if(this.rules.error['default'])
|
|
{
|
|
message = this.rules.error['default'];
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if(_.isString(value))
|
|
message = message.replace(/%v/, value.toString());
|
|
|
|
if(_.isString(rule))
|
|
message = message.replace(/%r/, rule);
|
|
|
|
return message.replace(/%p/, this.param).replace(/%v/, "value").replace(/%r/, "rule");
|
|
};
|
|
|
|
Rules.prototype.apply = function(value)
|
|
{
|
|
if(_.isEmpty(value) && !_.isUndefined(this.rules['default']))
|
|
{
|
|
value = this.rules['default'];
|
|
}
|
|
|
|
if(this.rules.required)
|
|
{
|
|
if(this.rules.required && _.isUndefined(value))
|
|
{
|
|
throw this.Error("%p is a required parameter", "required", value);
|
|
}
|
|
}
|
|
// if value is not required and is undefined, no more rules need to be run
|
|
else if(_.isUndefined(value))
|
|
return value;
|
|
|
|
if(this.rules.filters)
|
|
{
|
|
value = this.filter(value);
|
|
}
|
|
|
|
if(this.rules.type)
|
|
{
|
|
if(typeof(this.rules.type) == "string" && typeof(is[this.rules.type]) == "function")
|
|
{
|
|
if(!is[this.rules.type](value))
|
|
throw this.Error("%p is not a " + this.rules.type, "type", value);
|
|
}
|
|
else if(typeof(this.rules.type == "function"))
|
|
{
|
|
if(!this.rules.type(value))
|
|
throw this.Error("%p is not a valid type", "type", value);
|
|
}
|
|
else
|
|
{
|
|
throw this.Error("%p is not a valid type", "type", value);
|
|
}
|
|
}
|
|
|
|
if(this.rules.properties)
|
|
{
|
|
this.check(value);
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
Rules.prototype.filter = function(value)
|
|
{
|
|
switch(typeof(this.rules.filters))
|
|
{
|
|
case 'function':
|
|
value = this.rules.filters(value);
|
|
break;
|
|
|
|
case 'string':
|
|
|
|
if(typeof(filters[this.rules.filters]) === 'function')
|
|
{
|
|
value = filters[this.rules.filters](value);
|
|
}
|
|
|
|
break;
|
|
|
|
case 'object':
|
|
|
|
if(_.isArray(this.rules.filters))
|
|
{
|
|
this.rules.filters.forEach(function(filter) { value = filters[filter](value); });
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
Rules.prototype.check = function(value)
|
|
{
|
|
switch(typeof(this.rules.properties))
|
|
{
|
|
case 'function':
|
|
|
|
if(!this.rules.properties(value))
|
|
throw this.Error("%p is not valid");
|
|
|
|
break;
|
|
|
|
case 'object':
|
|
|
|
var properties = _.keys(this.rules.properties);
|
|
|
|
for(var i = 0; i < properties.length; i++)
|
|
{
|
|
var property = properties[i];
|
|
|
|
if(typeof(checks[property]) === "function")
|
|
{
|
|
var args = this.rules.properties[property];
|
|
|
|
if(!checks[property].apply(null, [value, args]))
|
|
throw this.Error("%p failed %r with %v", property);
|
|
}
|
|
else if(typeof(this.rules.properties[property]) === "function")
|
|
{
|
|
if(!this.rules.properties[property].apply(null, [value]))
|
|
throw this.Error("%p failed on %r with %v", property);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
};
|
|
|
|
var checks =
|
|
{
|
|
'max': function(value, length)
|
|
{
|
|
if(_.isArray(value) || typeof(value) == "string")
|
|
{
|
|
return value.length <= length;
|
|
}
|
|
else if(typeof(value) == "number")
|
|
{
|
|
return value <= length;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
},
|
|
|
|
'min': function(value, length)
|
|
{
|
|
if(_.isArray(value) || typeof(value) == "string")
|
|
{
|
|
return value.length >= length;
|
|
}
|
|
else if(typeof(value) == "number")
|
|
{
|
|
return value >= length;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
},
|
|
|
|
'regex': function(value, regex)
|
|
{
|
|
return regex.test(value);
|
|
},
|
|
|
|
'in': function(value, list)
|
|
{
|
|
return list.indexOf(value) != -1;
|
|
}
|
|
};
|
|
|
|
var is =
|
|
{
|
|
'string+': function(value)
|
|
{
|
|
return typeof(value) == 'string' && value.length && !(/\s+/.test(value));
|
|
},
|
|
|
|
'string': function(value)
|
|
{
|
|
return typeof(value) == 'string';
|
|
},
|
|
|
|
'alphanum': function(value)
|
|
{
|
|
return (/^[a-zA-Z0-9]+$/i).test(value);
|
|
},
|
|
|
|
'alpha': function(value)
|
|
{
|
|
return (/^[a-zA-Z]+$/i).test(value);
|
|
},
|
|
|
|
'object': function(value)
|
|
{
|
|
return typeof(value) == 'object' && !_.isArray(value);
|
|
},
|
|
|
|
'array': function(value)
|
|
{
|
|
return _.isArray(value);
|
|
},
|
|
|
|
'date': function(value)
|
|
{
|
|
// getTime() allows us to check if date is valid
|
|
return _.isDate(value) && !isNaN(value.getTime());
|
|
},
|
|
|
|
'number': function(value)
|
|
{
|
|
return typeof(value) == 'number' && !isNaN(value);
|
|
},
|
|
|
|
'int': function(value)
|
|
{
|
|
return typeof(value) == 'number' && value % 1 === 0 && !isNaN(value);
|
|
},
|
|
|
|
'boolean': function(value)
|
|
{
|
|
return _.isBoolean(value);
|
|
},
|
|
|
|
'float': function(value)
|
|
{
|
|
return typeof(value) == 'number' && !isNaN(value);
|
|
},
|
|
|
|
'email': function(value)
|
|
{
|
|
return (/[a-zA-Z0-9!#$%&'*+\/=?\^_`{|}~\-]+(?:\.[a-zA-Z0-9!#$%&'*+\/=?\^_`{|}~\-]+)*@(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?/).test(value);
|
|
},
|
|
|
|
'url': function(value)
|
|
{
|
|
return (/^(http(s)?:\/\/)?([\w\-]+\.{1})*(([\w\-]*){1}(\.{1}[A-Za-z]{2,4}){1}){1}(\:{1}\d*)?([\?\/|\#]+[\@\~\;\+\'\#\,\.\%\-\/\&\?\=\w\$\s]*)*$/i).test(value);
|
|
},
|
|
|
|
'zipcode': function(value)
|
|
{
|
|
return (/\d{5}/).test(value);
|
|
}
|
|
};
|
|
|
|
var filters =
|
|
{
|
|
'toInt': function(value)
|
|
{
|
|
return parseInt(value, 10);
|
|
},
|
|
|
|
'toFloat': function(value)
|
|
{
|
|
return parseFloat(value, 10);
|
|
},
|
|
|
|
'toString': function(value)
|
|
{
|
|
return value.toString();
|
|
},
|
|
|
|
'toDate': function(value)
|
|
{
|
|
return new Date(value);
|
|
},
|
|
|
|
'toBoolean': function(value)
|
|
{
|
|
if(value === 1 || value === true || /true|on|yes|1/.test(value))
|
|
return true;
|
|
else if(value === 0 || value === false || /false|off|no|0/.test(value))
|
|
return false;
|
|
else
|
|
return value;
|
|
},
|
|
|
|
'trim': function(value)
|
|
{
|
|
return _.isString(value) ? value.replace(/^\s\s*/, '').replace(/\s\s*$/, '') : value;
|
|
},
|
|
|
|
'lowercase': function(value)
|
|
{
|
|
return _.isString(value) ? value.toLowerCase() : value;
|
|
},
|
|
|
|
'uppercase': function(value)
|
|
{
|
|
return _.isString(value) ? value.toUpperCase() : value;
|
|
}
|
|
};
|
|
|
|
exports.create = function(param, rules) { return new Rules(param, rules); };
|
|
exports.types = is;
|
|
exports.filters = filters;
|
|
exports.properties = checks;
|