Cleanup

README.md

@@ -19,7 +19,7 @@ var V = require('o-validator');
 var R = require('ramda');
 
 var hasLengthGreaterThan = R.curry(function(n, x) {
-  return R.propSatisfies(R.lt(n), 'length');
+  return R.propSatisfies(R.lt(n), 'length', x);
 });
 
 var schema = {
@@ -153,10 +153,10 @@ Error codes that define the type of validation error that was found. Used to pop
 
 ```js
 {
-  REQUIRED    : 'Required',
-  UNSUPPORTED : 'Unsupported',
-  VALUE       : 'Value',
-  UNKNOWN     : 'Unknown'
+  REQUIRED    : 'REQUIRED',
+  UNSUPPORTED : 'UNSUPPORTED',
+  VALUE       : 'VALUE',
+  UNKNOWN     : 'UNKNOWN'
 }
 ```
 

lib/validator.js

@@ -10,10 +10,10 @@ var Err      = require('./validator/errors');
 /**
  * Types:
  *
- * Predicate :: a -> Boolean
- * Schema :: {k: Predicate}
- * ErrorObject :: {property: String, errorCode: String}
- * ErrorObjectWithMessage :: {property: String, errorCode: String, message: String}
+ * Predicate (a -> Boolean)
+ * Schema {k: Predicate}
+ * ErrorObject {property: String, errorCode: String}
+ * ErrorObjectWithMessage {property: String, errorCode: String, message: String}
  */
 
 
@@ -44,6 +44,7 @@ module.exports = {
    /**
     * Throws an error containing information about any validation errors, if
     * found. Otherwise returns the original input arguments.
+    *
     * Schema -> Object -> Error or Object
     */
    validateOrThrow : Core.validateWithErrorHandler(
@@ -83,5 +84,5 @@ module.exports = {
    *
    * (type not exposed, implementation details are internal to this library)
    */
-  required : Core.annotatePredicateAsRequired
+  required : Core.annotateAsRequired
 };

lib/validator/constants.js

@@ -1,9 +1,9 @@
 module.exports = {
   errorCodes: {
-    REQUIRED    : 'Required',
-    UNSUPPORTED : 'Unsupported',
-    VALUE       : 'Value',
-    UNKNOWN     : 'Unknown'
+    REQUIRED    : 'REQUIRED',
+    UNSUPPORTED : 'UNSUPPORTED',
+    VALUE       : 'VALUE',
+    UNKNOWN     : 'UNKNOWN'
   },
   errorMessages: {
     REQUIRED    : 'Missing required parameter',

lib/validator/core.js

@@ -5,65 +5,53 @@ var R = require('ramda');
 var Err = require('./errors');
 
 
-var annotatePredicate = R.curry(function(annotation, predicate) {
+var annotate = R.curry(function(annotation, predicate) {
   return R.merge(annotation, {predicate : predicate});
 });
 
 
-var annotatePredicateAsRequired = annotatePredicate({required: true});
-var annotatePredicateAsOptional = annotatePredicate({required: false});
+var annotateAsRequired = annotate({required: true});
+var annotateAsOptional = annotate({required: false});
+var emptyAnnotatedPredicate = annotateAsOptional(undefined);
 
 
-var makeEmptyAnnotatedPredicate = R.always(annotatePredicateAsOptional(undefined));
+var maybeAnnotatePredicate = R.ifElse(R.is(Function), annotateAsOptional, R.identity);
 
 
-var maybeAnnotatePredicate = R.ifElse(R.is(Function), annotatePredicateAsOptional, R.identity);
-
-
-var annotatePredicateWithResult = R.curry(function(values, predicate, property) {
-  var annotatedPredicate = maybeAnnotatePredicate(predicate);
-  var value = values[property];
-
-  return R.merge(annotatedPredicate, {
-    value    : value,
-    property : property,
-    result   : annotatedPredicate.predicate ? annotatedPredicate.predicate(value) : undefined
+var annotateWithResult = function(annotatedP) {
+  return R.merge(annotatedP, {
+    result: annotatedP.predicate ? annotatedP.predicate(annotatedP.value) : undefined
   });
-});
-
-
-// [Predicate] -> [a] -> [AnnotatedPredicateWithResults]
-function annotatePredicatesWithResults(predicates, values) {
-  var unsupportedParameters = getUnsupportedParameters(predicates, values),
-      allPredicates = R.merge(predicates, unsupportedParameters);
-
-  return R.values(R.mapObjIndexed(annotatePredicateWithResult(values), allPredicates));
-}
+};
 
 
-function getUnsupportedParameters(predicates, values) {
+var annotateWithPropVals = R.curry(function(annotatedPs, values) {
+  return R.mapObjIndexed(function(pred, prop) {
+    return R.merge(pred, {property: prop, value: values[prop]});
+  }, annotatedPs);
+});
 
-  // Find all the parameters that are defined in the value set, but not in the predicates
-  // these will be the unsupported parameters
-  var unSupportedParameters = R.filter(R.complement(R.has(R.__, predicates)), R.keys(values));
 
-  return R.zipObj(unSupportedParameters, R.map(makeEmptyAnnotatedPredicate, unSupportedParameters));
-}
+var addUnsupportedParameters = function(predicates, values) {
+  var unsupportedParameters = R.reject(R.has(R.__, predicates), R.keys(values));
+  return R.assoc(unsupportedParameters, emptyAnnotatedPredicate, predicates);
+};
 
 
-function annotateWithDefaultErrorMessage(a) {
+var annotateWithDefaultErrorMessage = function(a) {
   return R.merge(a, {message: Err.getDefaultErrorMessage(a)});
-}
+};
+
 
+var validateWithHandlers = R.curry(function(successHandler, errorHandler, schema, data) {
+  var annotatedPs = R.mapObj(maybeAnnotatePredicate, schema);
+  var allPredicates = addUnsupportedParameters(annotatedPs, data);
+  var predList = R.values(annotateWithPropVals(allPredicates, data));
 
-// keep success handler portion of API internal
-// validation functions should (and will) always return original args
-// unless other functionality is explicitly provided by this library
-var validateWithHandlers = R.curry(function(successHandler, errorHandler, schema, props) {
-  var results = annotatePredicatesWithResults(schema, props);
+  var results = R.map(annotateWithResult, predList);
   var errors = Err.getErrors(results);
 
-  return R.isEmpty(errors) ? successHandler(props) : errorHandler(errors);
+  return R.isEmpty(errors) ? successHandler(data) : errorHandler(errors);
 });
 
 
@@ -74,8 +62,8 @@ var addDefaultErrorMessages = R.map(annotateWithDefaultErrorMessage);
 
 
 module.exports = {
-  validateWithHandlers        : validateWithHandlers,
-  validateWithErrorHandler    : validateWithErrorHandler,
-  addDefaultErrorMessages     : addDefaultErrorMessages,
-  annotatePredicateAsRequired : annotatePredicateAsRequired,
+  validateWithHandlers     : validateWithHandlers,
+  validateWithErrorHandler : validateWithErrorHandler,
+  addDefaultErrorMessages  : addDefaultErrorMessages,
+  annotateAsRequired       : annotateAsRequired
 };

lib/validator/errors.js

@@ -10,7 +10,6 @@ var errorCodes    = Constant.errorCodes;
 var errorMessages = Constant.errorMessages;
 
 
-// AnnotatedPredicateWithResults -> String
 var getErrorType = R.cond([
   [Result.isRequiredWithUndefinedValue,   R.always(errorCodes.REQUIRED)],
   [Result.hasUndefinedPredicate,          R.always(errorCodes.UNSUPPORTED)],
@@ -19,7 +18,6 @@ var getErrorType = R.cond([
 ]);
 
 
-// AnnotatedPredicateWithResults -> AnnotatedPredicateWithResults
 var annotateErrorCode = function(annotatedPredicate) {
   return {
     property  : annotatedPredicate.property,
@@ -28,14 +26,12 @@ var annotateErrorCode = function(annotatedPredicate) {
 };
 
 
-// [AnnotatedPredicateWithResults] -> [AnnotatedPredicateWithResults]
 var getErrors = R.compose(
   R.map(annotateErrorCode),
   R.reject(Result.isPassingResult)
 );
 
 
-// String -> String
 var getDefaultErrorPrefix = R.cond([
   [R.equals(errorCodes.REQUIRED),    R.always(errorMessages.REQUIRED)],
   [R.equals(errorCodes.UNSUPPORTED), R.always(errorMessages.UNSUPPORTED)],
@@ -44,19 +40,16 @@ var getDefaultErrorPrefix = R.cond([
 ]);
 
 
-// AnnotatedPredicateWithResults -> String
 var getDefaultErrorMessage = function(annotatedPredicate) {
   return getDefaultErrorPrefix(annotatedPredicate.errorCode) + ' "' + annotatedPredicate.property + '"';
 };
 
 
-// String -> Error
 var throwError = function(msg) {
   throw new Error('Validation Error: ' + msg);
 };
 
 
-// [AnnotatedPredicateWithResults] -> Error
 var throwValidationErrors = R.compose(throwError, R.join(', '), R.pluck('message'));
 
 

lib/validator/results.js

@@ -19,33 +19,27 @@ var R = require('ramda');
  */
 
 
- // AnnotatedPredicateWithResults -> Boolean
  var isRequiredWithUndefinedValue = R.allPass([
    R.propEq('required', true),
    R.propEq('value', undefined)
  ]);
 
 
- // AnnotatedPredicateWithResults -> Boolean
  var hasUndefinedPredicate = R.propEq('predicate', undefined);
 
 
- // AnnotatedPredicateWithResults -> Boolean
  var hasDefinedValueWithFalseResult = R.allPass([
    R.complement(R.propEq('value', undefined)),
    R.propEq('result', false)
  ]);
 
 
- // AnnotatedPredicateWithResults -> Boolean
  var satisfiedPredicate = R.propEq('result', true);
 
 
- // AnnotatedPredicateWithResults -> Boolean
  var isOptionallyOmmitted = R.allPass([R.propEq('required', false), R.propEq('value', undefined)]);
 
 
- // AnnotatedPredicateWithResults -> Boolean
 var isPassingResult = R.anyPass([satisfiedPredicate, isOptionallyOmmitted]);
 
 

spec/validator.spec.js

@@ -102,19 +102,19 @@ describe('Validator', function() {
   describe('getErrors', function() {
     var expectedTitleRequiredError = {
       property  : 'title',
-      errorCode : 'Required',
+      errorCode : 'REQUIRED',
       message   : 'Missing required parameter "title"'
     };
 
     var expectedDescriptionValueError = {
       property  : 'description',
-      errorCode : 'Value',
+      errorCode : 'VALUE',
       message   : 'Illegal value for parameter "description"'
     };
 
     var expectedIsAdminUnsupportedError = {
       property  : 'isAdmin',
-      errorCode : 'Unsupported',
+      errorCode : 'UNSUPPORTED',
       message   : 'Unsupported parameter "isAdmin"'
     };
 
@@ -182,4 +182,15 @@ describe('Validator', function() {
       expect(Validator.validateOrThrow(pattern, args)).toBe(args);
     });
   });
+
+  describe('errorCodes', function() {
+    it('should be a set of error codes', function() {
+      expect(Validator.errorCodes).toEqual({
+        REQUIRED    : 'REQUIRED',
+        UNSUPPORTED : 'UNSUPPORTED',
+        VALUE       : 'VALUE',
+        UNKNOWN     : 'UNKNOWN'
+      });
+    });
+  });
 });