expects.js

	function ValidationError(func, validation, value) {
		Error.call(this,
			'Parameter validation failed when calling function' +
			(func.name && func.name.length > 0 ? ' ' + func.name : ' ') +
			' - Validated for "' + validation.expected + '" - Got value: ' +
			value
		);
		this.func = func;
		this.value = value;
		this.validation = validation;
	}
	
	ValidationError.prototype = new Error();
	ValidationError.prototype.constructor = ValidationError;
	
	determineValidation = _.memoize(function(arg) {
		var validation, optional,
		wrappedFunc = function(func) {
			return function() { return func.apply(this, arguments); };
		};
		
		if(_.is.func(arg)) {
			validation = wrappedFunc(arg);
			validation.expected = arg.name; 
			return validation;
		}
		
		optional = (arg = arg.trim()).indexOf('?') !== -1;
		switch(arg)
		{
			case '':
			case '*':
			case 'any':
				validation = _.identity;
				break;
			default: {
				var key = optional ? _.str.trim(arg, ' ?') : arg;
				if(_.is.defined(_.is[key])) {
					validation = _.is[key];
				} else {
					throw new Error('Unknown validation supplied to expect: ' + key);
				}
				break;
			}
		}
		validation = optional ? function(value) {
			return _.is.defined(value) ? validation(value) : true;
		} : wrappedFunc(validation);
		validation.expected = arg;
		return validation;
	});

	function expects(argchecks) {
		var validations = _.slice(arguments).map(determineValidation);
		return function(wrapped) {
			return function() {
				var self = this,
				failedValue,
				failedValidation,
				args = _.slice(arguments),
				validate = function(validation, index) {
					return (failedValidation = validation)(failedValue = args[index]);
				};
				if(validations.every(validate, self)) {
					return wrapped.apply(self, arguments);
				} else {
					throw new ValidationError(wrapped, failedValidation, failedValue);
				}
			};
		};
	}