cressida
Version:
validation messages done simply.
394 lines (331 loc) • 14.5 kB
JavaScript
(function (global, factory) {
if (typeof define === 'function' && define.amd) {
define(['exports', 'module', 'babel-runtime/helpers/create-class', 'babel-runtime/helpers/class-call-check', 'babel-runtime/helpers/to-consumable-array', 'babel-runtime/helpers/sliced-to-array', 'babel-runtime/core-js/get-iterator', 'babel-runtime/core-js/object/keys', 'babel-runtime/core-js/array/from', 'util', '../utils'], factory);
} else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
factory(exports, module, require('babel-runtime/helpers/create-class'), require('babel-runtime/helpers/class-call-check'), require('babel-runtime/helpers/to-consumable-array'), require('babel-runtime/helpers/sliced-to-array'), require('babel-runtime/core-js/get-iterator'), require('babel-runtime/core-js/object/keys'), require('babel-runtime/core-js/array/from'), require('util'), require('../utils'));
} else {
var mod = {
exports: {}
};
factory(mod.exports, mod, global._createClass, global._classCallCheck, global._toConsumableArray, global._slicedToArray, global._getIterator, global._Object$keys, global._Array$from10, global.util, global.utils);
global.parser = mod.exports;
}
})(this, function (exports, module, _babelRuntimeHelpersCreateClass, _babelRuntimeHelpersClassCallCheck, _babelRuntimeHelpersToConsumableArray, _babelRuntimeHelpersSlicedToArray, _babelRuntimeCoreJsGetIterator, _babelRuntimeCoreJsObjectKeys, _babelRuntimeCoreJsArrayFrom, _util, _utils) {
/**
* Author: Umayr Shahid <umayrr@hotmail.com>,
* Created: 20:56, 06/09/15.
*/
'use strict';
var TYPES = {
DATE: ['before', 'after'],
NUMBER: ['greater', 'smaller', 'min', 'max', 'divisible', 'divisibleby'],
STRING: ['contains', 'alphanumeric', 'numeric', 'equals', 'alpha', 'len', 'length', 'bytelength', 'lowercase', 'uppercase', 'null'],
STANDALONE: ['email', 'regex', 'url', 'json', 'ip', 'ipv4', 'ipv6', 'uuid', 'uuidv3', 'uuidv4', 'uuidv5', 'array', 'creditcard', 'int', 'float', 'decimal', 'date', 'hexadecimal', 'hexcolor'],
PATTERN: ['matches', 'is', 'not'],
BOOL: ['boolean'],
ARRAY: ['in'],
NONE: ['empty']
};
var STANDALONE = {
EMAIL: 'email address',
CREDITCARD: 'credit card number',
INT: 'integer value',
FLOAT: 'float value',
DECIMAL: 'decimal value',
IP: 'ip address',
IPV4: 'ipv4 address',
IPV6: 'ipv6 address',
JSON: 'json string',
HEXCOLOR: 'hex color code'
};
var STRING = {
LOWERCASE: 'consist of lowercase letters',
UPPERCASE: 'consist of uppercase letters',
ALPHA: 'consist of only letters',
ALPHANUMERIC: 'consist of only letters & numbers',
EQUALS: 'equal to %s',
CONTAINS: 'containing %s in it',
LEN: 'between %s to %s characters',
MINLEN: 'at least %s characters long',
MAXLEN: 'at max %s characters long',
EXACTLEN: '%s characters long',
LENGTH: 'between %s to %s characters',
BYTELENGTH: 'between %s to %s characters',
ATLEAST: 'at least %s characters long',
NUMERIC: 'consist of only numbers',
NULL: 'a null string'
};
var PATTERN = {
MATCHES: 'matching with %s regex'
};
var NUMBER = {
GREATER: 'greater than %s',
SMALLER: 'smaller than %s',
MIN: 'minimum %s',
MAX: 'maximum %s',
DIVISIBLE: 'divisible by %s',
DIVISIBLEBY: 'divisible by %s'
};
var BOOL = {
BOOLEAN: 'either %s or %s'
};
var ARRAY = {
BINARY: 'either %s or %s',
N: 'one of these values (%s)',
ONE: 'equal to %s'
};
var Parser = (function () {
function Parser() {
(0, _babelRuntimeHelpersClassCallCheck['default'])(this, Parser);
}
(0, _babelRuntimeHelpersCreateClass['default'])(Parser, null, [{
key: 'operator',
/**
* Static method to parse operator.
*
* Possible inputs can be:
* - Positives: empty, isEmpty, !notEmpty, !isNotEmpty
* - Negatives: !empty, !isEmpty, notEmpty
* @param operator
* @returns {*[]}
*/
value: function operator(_operator2) {
var _count = 0;
var _not = false;
var _operator = undefined;
var _type = undefined;
_operator2 = String(_operator2);
if (_operator2.indexOf('!') > -1) {
_not = !_not;
_count++;
}
if (_operator2.substr(0, 3).toLowerCase().indexOf('is') > -1) _count += 2;
if (_operator2.indexOf('not') > -1) {
_not = !_not;
_count += 3;
}
_operator = _operator2.substr(_count, _operator2.length).toLowerCase();
_type = Parser.type(_operator);
return [_not, _operator, _type];
}
/**
* Static method to get the type of the operator.
*
* @param operator
* @returns {string}
*/
}, {
key: 'type',
value: function type(operator) {
if (!Parser.isSupported(operator)) throw new Error('Provided operator `' + operator + '` is not supported.');
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = (0, _babelRuntimeCoreJsGetIterator['default'])((0, _babelRuntimeCoreJsObjectKeys['default'])(TYPES)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var type = _step.value;
if (Parser._containsAny(operator, TYPES[type])) return String(type).toLowerCase();
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator['return']) {
_iterator['return']();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
/**
* Static method that wraps all type wise operations.
*
* @returns {*}
*/
}, {
key: 'isSupported',
/**
* Return true if provided operator is valid.
*
* @param operator
* @returns {*}
*/
value: function isSupported(operator) {
var _all = [];
operator = String(operator).toLowerCase();
if (operator === 'not' || operator === 'is' || operator === 'notnot' || operator === 'isis') return true;
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = (0, _babelRuntimeCoreJsGetIterator['default'])((0, _babelRuntimeCoreJsObjectKeys['default'])(TYPES)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var type = _step2.value;
_all.push.apply(_all, (0, _babelRuntimeHelpersToConsumableArray['default'])(TYPES[type]));
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2['return']) {
_iterator2['return']();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
_all.splice(_all.indexOf('not'), 1);
_all.splice(_all.indexOf('is'), 1);
return Parser._containsAny(operator, _all);
}
/**
* Search through an array and returns true if any value of array matches the provided needle.
*
* @param needle
* @param haystack
* @returns {boolean}
* @private
*/
}, {
key: '_containsAny',
value: function _containsAny(needle, haystack) {
needle = needle.replace(/^(!isnot|!is|!not|isnot|!|is|not)/, '').toLowerCase();
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = (0, _babelRuntimeCoreJsGetIterator['default'])(haystack), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var straw = _step3.value;
if (needle === straw.toLowerCase()) return true;
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3['return']) {
_iterator3['return']();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return false;
}
/**
* Parse arguments.
*
* @returns {*[]}
*/
}, {
key: 'args',
value: function args() {
var _Array$from = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from2 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from, 3);
var _first = _Array$from2[0];
var _second = _Array$from2[1];
var _third = _Array$from2[2];
return Parser.isSupported(_first) ? [_third, _first, _second] : [_first, _second, _third];
}
}, {
key: 'methods',
get: function get() {
return {
date: function date() {
var _Array$from3 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from32 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from3, 2);
var _operator = _Array$from32[0];
var _args = _Array$from32[1];
return _operator + ' than ' + (0, _utils.humanize)(_args);
},
number: function number() {
var _Array$from4 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from42 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from4, 2);
var _operator = _Array$from42[0];
var _args = _Array$from42[1];
return '' + ((0, _util.format)(NUMBER[_operator.toUpperCase()], _args) || _operator);
},
string: function string() {
var _Array$from5 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from52 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from5, 2);
var _operator = _Array$from52[0];
var _args = _Array$from52[1];
var _msg = undefined;
if (_operator === 'len' || _operator === 'length' || _operator === 'bytelength' || _operator === 'equals' || _operator === 'contains') {
if (_operator === 'len' || _operator === 'length' || _operator === 'bytelength') {
if (_args.length === 1) _operator = 'atleast';else {
var _args2 = _args;
var _args22 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_args2, 2);
var left = _args22[0];
var right = _args22[1];
// "Because I'm sexy and I know it." - ES6
if ((typeof left === 'undefined' || left === 0) && right) {
_operator = 'maxlen';
_args = [right];
}
if ((typeof right === 'undefined' || right === 0) && left) {
_operator = 'minlen';
_args = [left];
}
if (left === right) {
_operator = 'exactlen';
_args = [left];
}
}
}
_msg = _util.format.apply(undefined, [STRING[_operator.toUpperCase()]].concat((0, _babelRuntimeHelpersToConsumableArray['default'])(_args)));
} else _msg = '' + (STRING[_operator.toUpperCase()] || _operator);
return _msg;
},
standalone: function standalone() {
var _Array$from6 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from62 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from6, 1);
var _operator = _Array$from62[0];
return 'a valid ' + (STANDALONE[_operator.toUpperCase()] || _operator);
},
bool: function bool() {
var _Array$from7 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from72 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from7, 2);
var _operator = _Array$from72[0];
var _args = _Array$from72[1];
return '' + (_util.format.apply(undefined, [BOOL[_operator.toUpperCase()]].concat((0, _babelRuntimeHelpersToConsumableArray['default'])(_args))) || _operator);
},
array: function array() {
var _Array$from8 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from82 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from8, 2);
var _args = _Array$from82[1];
var _msg = undefined;
if (Array.isArray(_args)) _args = (0, _utils.flatten)(_args);
if (_args.length === 2) _msg = '' + _util.format.apply(undefined, [ARRAY['BINARY']].concat((0, _babelRuntimeHelpersToConsumableArray['default'])(_args)));else if (_args.length > 2) _msg = '' + (0, _util.format)(ARRAY['N'], _args.join(', '));else _msg = '' + (0, _util.format)(ARRAY['ONE'], typeof _args[0] === 'object' ? JSON.stringify(_args[0]) : _args[0]);
return _msg;
},
pattern: function pattern() {
var _Array$from9 = (0, _babelRuntimeCoreJsArrayFrom['default'])(arguments);
var _Array$from92 = (0, _babelRuntimeHelpersSlicedToArray['default'])(_Array$from9, 2);
var _operator = _Array$from92[0];
var _args = _Array$from92[1];
var _regex = undefined;
if (Array.isArray(_args)) {
if (_args.length > 1) _regex = new RegExp(_args[0], _args[1]);else _regex = new RegExp(_args[0]);
} else _regex = new RegExp(_args);
return '' + ((0, _util.format)(PATTERN[_operator.toUpperCase()], _regex) || _operator);
},
none: function none(operator) {
return operator;
}
};
}
}]);
return Parser;
})();
module.exports = Parser;
});
//# sourceMappingURL=parser.js.map