conditional
Version:
A preconditions package based on Google's Preconditions library
394 lines (288 loc) • 12 kB
JavaScript
(function() {
var AbstractError, ArgumentChecker, Checker, ContainsChecker, DEFAULT_CALLBACK, DEFAULT_MESSAGES, DefinedChecker, EmptyChecker, EqualsChecker, IllegalArgumentError, IllegalStateError, IllegalValueError, InvalidTypeError, NullChecker, NumberTypeChecker, StateChecker, UndefinedValueError, UnknownValueError, argumentChecker, debug, isArray, isEmptyString, isEqual, isNotArray, isNotPrimitive, isNotUndefined, isNumeric, isObject, isPrimitive, isString, isUndefined, xor, _ref,
__hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
__indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
_ref = require('./util'), isObject = _ref.isObject, isArray = _ref.isArray, isNotArray = _ref.isNotArray, isNumeric = _ref.isNumeric, isString = _ref.isString, isEmptyString = _ref.isEmptyString, isNotUndefined = _ref.isNotUndefined, isUndefined = _ref.isUndefined, isEqual = _ref.isEqual, isNotPrimitive = _ref.isNotPrimitive, isPrimitive = _ref.isPrimitive, xor = _ref.xor;
debug = require('./debug_wrapper');
DEFAULT_CALLBACK = function(err) {
if (err != null) {
throw err;
}
};
Checker = (function() {
function Checker(name, defaultMessage, negate, argc) {
this.name = name;
this.defaultMessage = defaultMessage;
this.negate = negate != null ? negate : false;
this.argc = argc != null ? argc : 1;
module.exports[this.name] = (function(_this) {
return function() {
return _this.check.apply(_this, arguments);
};
})(this);
debug("registered checker '" + this.name + "'");
}
Checker.prototype.check = function() {
var arg, args, callback, e, message, _i, _len, _ref1;
message = arguments[this.argc];
callback = arguments[this.argc + 1] || DEFAULT_CALLBACK;
if (typeof message === 'function') {
callback = message;
message = null;
}
args = [];
_ref1 = Array.prototype.splice.call(arguments, 0, this.argc);
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
arg = _ref1[_i];
Array.prototype.push.call(args, arg);
}
if (message == null) {
message = this.getErrorMessage.apply(this, args);
}
try {
if (!xor(this.doCheck.apply(this, args), this.negate)) {
this.invokeError(message);
}
return callback(null);
} catch (_error) {
e = _error;
return callback(e);
}
};
Checker.prototype.invokeError = function() {
throw new Error('something went wrong');
};
Checker.prototype.doCheck = function() {
return false;
};
Checker.prototype.getErrorMessage = function() {
if (typeof this.defaultMessage === 'function') {
return this.defaultMessage.apply(this, arguments);
} else {
return this.defaultMessage;
}
};
return Checker;
})();
ArgumentChecker = (function(_super) {
__extends(ArgumentChecker, _super);
function ArgumentChecker(name, negate, message) {
if (message == null) {
message = DEFAULT_MESSAGES.INVALID_ARGUMENT;
}
ArgumentChecker.__super__.constructor.call(this, name, message, negate);
}
ArgumentChecker.prototype.doCheck = function(condition) {
return isString(condition) || isNumeric(condition) || condition;
};
ArgumentChecker.prototype.invokeError = function(message) {
throw new IllegalArgumentError(message);
};
return ArgumentChecker;
})(Checker);
NumberTypeChecker = (function(_super) {
__extends(NumberTypeChecker, _super);
function NumberTypeChecker(name, negate, message) {
if (message == null) {
message = DEFAULT_MESSAGES.INVALID_TYPE;
}
NumberTypeChecker.__super__.constructor.call(this, name, message, negate);
}
NumberTypeChecker.prototype.doCheck = function(value) {
return isNumeric(value);
};
NumberTypeChecker.prototype.invokeError = function(message) {
throw new InvalidTypeError(message);
};
return NumberTypeChecker;
})(Checker);
ContainsChecker = (function(_super) {
__extends(ContainsChecker, _super);
function ContainsChecker(name, negate, message) {
ContainsChecker.__super__.constructor.call(this, name, message, negate, 2);
}
ContainsChecker.prototype.doCheck = function(value, object) {
argumentChecker.check(object, 'invalid collection value');
switch (false) {
case !isString(object):
return !((!isString(value)) || (value.length > object.length) || (isEmptyString(object) ^ isEmptyString(value)) || (!(isEmptyString(object) || __indexOf.call(object, value) >= 0)));
case !isArray(object):
return __indexOf.call(object, value) >= 0;
case !isNumeric(object):
return ~object.toString().indexOf(value);
default:
return value in object;
}
};
ContainsChecker.prototype.invokeError = function(message) {
throw new UnknownValueError(message);
};
return ContainsChecker;
})(Checker);
EqualsChecker = (function(_super) {
__extends(EqualsChecker, _super);
function EqualsChecker(name, negate, message) {
EqualsChecker.__super__.constructor.call(this, name, message, negate, 2);
}
EqualsChecker.prototype.doCheck = function(actual, expected) {
argumentChecker.check(isNotUndefined(expected), 'invalid value expected');
return isEqual(actual, expected);
};
EqualsChecker.prototype.invokeError = function(message) {
throw new UnknownValueError(message);
};
return EqualsChecker;
})(Checker);
DefinedChecker = (function(_super) {
__extends(DefinedChecker, _super);
function DefinedChecker(name, negate, message) {
if (message == null) {
message = DEFAULT_MESSAGES.UNDEFINED_VALUE;
}
DefinedChecker.__super__.constructor.call(this, name, message, negate);
}
DefinedChecker.prototype.doCheck = function(value) {
return isNotUndefined(value);
};
DefinedChecker.prototype.invokeError = function(message) {
throw new UndefinedValueError(message);
};
return DefinedChecker;
})(Checker);
EmptyChecker = (function(_super) {
__extends(EmptyChecker, _super);
function EmptyChecker(name, negate, message) {
if (message == null) {
message = DEFAULT_MESSAGES.ILLEGAL_VALUE;
}
EmptyChecker.__super__.constructor.call(this, name, message, negate);
}
EmptyChecker.prototype.doCheck = function(value) {
return value === null || isUndefined(value) || (isNotPrimitive(value) && ((hasOwnProperty.call(value, 'length') && value.length === 0) || (typeof value === 'object' && Object.keys(value).length === 0)));
};
EmptyChecker.prototype.invokeError = function(message) {
throw new IllegalValueError(message);
};
return EmptyChecker;
})(Checker);
StateChecker = (function(_super) {
__extends(StateChecker, _super);
function StateChecker(name) {
StateChecker.__super__.constructor.call(this, name, false, DEFAULT_MESSAGES.ILLEGAL_STATE);
}
StateChecker.prototype.invokeError = function(message) {
throw new IllegalStateError(message);
};
return StateChecker;
})(ArgumentChecker);
NullChecker = (function(_super) {
__extends(NullChecker, _super);
function NullChecker(name, negate, message) {
if (message == null) {
message = DEFAULT_MESSAGES.NULL_VALUE;
}
NullChecker.__super__.constructor.call(this, name, message, negate);
}
NullChecker.prototype.doCheck = function(value) {
return isUndefined(value) || value === null;
};
NullChecker.prototype.invokeError = function(message) {
throw new IllegalValueError(message);
};
return NullChecker;
})(Checker);
DEFAULT_MESSAGES = {
INVALID_ARGUMENT: 'invalid argument',
INVALID_TYPE: 'invalid type',
UNKNOWN_VALUE: 'unknown value',
UNDEFINED_VALUE: 'undefined value',
ILLEGAL_VALUE: 'illegal value',
ILLEGAL_STATE: 'illegal state',
NULL_VALUE: 'value is null'
};
AbstractError = function(message) {
var _ref1, _ref2;
this.message = message;
Error.call(this);
Error.captureStackTrace(this, arguments.callee);
return this.name = ((_ref1 = arguments.callee) != null ? (_ref2 = _ref1.caller) != null ? _ref2.name : void 0 : void 0) || 'Error';
};
AbstractError.prototype.__proto__ = Error.prototype;
IllegalArgumentError = (function(_super) {
__extends(IllegalArgumentError, _super);
function IllegalArgumentError() {
return IllegalArgumentError.__super__.constructor.apply(this, arguments);
}
return IllegalArgumentError;
})(AbstractError);
InvalidTypeError = (function(_super) {
__extends(InvalidTypeError, _super);
function InvalidTypeError() {
return InvalidTypeError.__super__.constructor.apply(this, arguments);
}
return InvalidTypeError;
})(AbstractError);
UnknownValueError = (function(_super) {
__extends(UnknownValueError, _super);
function UnknownValueError() {
return UnknownValueError.__super__.constructor.apply(this, arguments);
}
return UnknownValueError;
})(AbstractError);
UndefinedValueError = (function(_super) {
__extends(UndefinedValueError, _super);
function UndefinedValueError() {
return UndefinedValueError.__super__.constructor.apply(this, arguments);
}
return UndefinedValueError;
})(AbstractError);
IllegalValueError = (function(_super) {
__extends(IllegalValueError, _super);
function IllegalValueError() {
return IllegalValueError.__super__.constructor.apply(this, arguments);
}
return IllegalValueError;
})(AbstractError);
IllegalStateError = (function(_super) {
__extends(IllegalStateError, _super);
function IllegalStateError() {
return IllegalStateError.__super__.constructor.apply(this, arguments);
}
return IllegalStateError;
})(AbstractError);
argumentChecker = new ArgumentChecker('checkArgument');
new NumberTypeChecker('checkNumberType');
new NumberTypeChecker('checkNotNumberType', true);
new ContainsChecker('checkContains', false, function(value, object) {
return "unknown value '" + value + "'";
});
new ContainsChecker('checkDoesNotContain', true, function(value, object) {
return "'" + value + "' is a known value";
});
new EqualsChecker('checkEquals', false, function(actual, expected) {
return "expected '" + expected + "' but got '" + actual + "'";
});
new EqualsChecker('checkDoesNotEqual', true, function(actual) {
return "did not expect value '" + actual + "'";
});
new DefinedChecker('checkDefined');
new DefinedChecker('checkUndefined', true, function(value) {
return "'" + value + "' is a defined value";
});
new EmptyChecker('checkEmpty', false, function(value) {
return "'" + value + "' is not empty";
});
new EmptyChecker('checkNotEmpty', true);
new StateChecker('checkState');
new NullChecker('checkNull', false, function(value) {
return "'" + value + "' is not null";
});
new NullChecker('checkNotNull', true);
module.exports.IllegalArgumentError = IllegalArgumentError;
module.exports.InvalidTypeError = InvalidTypeError;
module.exports.UnknownValueError = UnknownValueError;
module.exports.UndefinedValueError = UndefinedValueError;
module.exports.IllegalValueError = IllegalValueError;
module.exports.IllegalStateError = IllegalStateError;
}).call(this);