Kenspeckled/oomph

// Generated by CoffeeScript 1.9.3
(function() {
  var ValidationError, _, _utilities, validate;

  _ = require('lodash');

  ValidationError = require('./ValidationError');

  _utilities = require('./utilities');

  validate = function(validationObj, attrName, attrValue) {
    var i, len, ref, validationSetting, validationType, validations;
    validations = [];
    ref = Object.keys(validationObj);
    for (i = 0, len = ref.length; i < len; i++) {
      validationType = ref[i];
      validationSetting = validationObj[validationType];
      if (validationType !== 'presence' && !attrValue) {
        continue;
      }
      switch (validationType) {
        case 'presence':
          if (_utilities.isBlank(attrValue)) {
            validations.push(new ValidationError(attrName + " must be present", {
              attribute: attrName,
              expected: validationSetting
            }));
          }
          break;
        case 'equalTo':
          if (attrValue !== validationSetting) {
            validations.push(new ValidationError(attrName + " should equal " + validationSetting, {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'lessThan':
          if (!(attrValue < validationSetting)) {
            validations.push(new ValidationError(attrName + " should be less than " + validationSetting, {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'lessThanOrEqualTo':
          if (!(attrValue <= validationSetting)) {
            validations.push(new ValidationError(attrName + " should be less than or equal to " + validationSetting, {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'greaterThanOrEqualTo':
          if (!(attrValue >= validationSetting)) {
            validations.push(new ValidationError(attrName + " should be greater than or equal to " + validationSetting, {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'greaterThan':
          if (!(attrValue > validationSetting)) {
            validations.push(new ValidationError(attrName + " should be greater than " + validationSetting, {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'inclusionIn':
          if (!_.includes(validationSetting, attrValue)) {
            validations.push(new ValidationError(attrName + " must be one of the accepted values", {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'exclusionIn':
          if (_.includes(validationSetting, attrValue)) {
            validations.push(new ValidationError(attrName + " must not be one of the forbidden values", {
              attribute: attrName,
              actual: attrValue,
              expected: validationSetting
            }));
          }
          break;
        case 'length':
          if (validationSetting.hasOwnProperty('is')) {
            if (attrValue.length !== validationSetting.is) {
              validations.push(new ValidationError(attrName + " should have a length of " + validationSetting.is, {
                attribute: attrName,
                actual: attrValue.length,
                expected: validationSetting.is
              }));
            }
          } else if (validationSetting.hasOwnProperty('minimum')) {
            if (!(attrValue.length >= validationSetting.minimum)) {
              validations.push(new ValidationError(attrName + " should have a minimum length of " + validationSetting.minimum, {
                attribute: attrName,
                actual: attrValue.length,
                expected: validationSetting.minimum
              }));
            }
          } else if (validationSetting.hasOwnProperty('maximum')) {
            if (!(attrValue.length <= validationSetting.maximum)) {
              validations.push(new ValidationError(attrName + " should have a maximum length of " + validationSetting.maximum, {
                attribute: attrName,
                actual: attrValue.length,
                expected: validationSetting.maximum
              }));
            }
          } else {
            throw new Error("length validation setting not valid on " + attrName);
          }
          break;
        case 'format':
          if (validationSetting.hasOwnProperty('with')) {
            if (validationSetting["with"].exec(attrValue) === null) {
              validations.push(new ValidationError(attrName + " should meet the format requirements", {
                attribute: attrName,
                actual: attrValue,
                expected: validationSetting["with"]
              }));
            }
          } else if (validationSetting.hasOwnProperty('without')) {
            if (validationSetting.without.exec(attrValue) !== null) {
              validations.push(new ValidationError(attrName + " should meet the format requirements", {
                attribute: attrName,
                actual: attrValue,
                expected: validationSetting.without
              }));
            }
          } else {
            throw new Error("format validation setting not valid on " + attrName);
          }
      }
    }
    return validations;
  };

  module.exports = validate;

}).call(this);