violations/build/src/index.js

get violated arguments for validation and assertion

'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; desc = parent = getter = undefined; _again = false; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }

function toS(v) {
  return Object.prototype.toString.call(v);
}

var util = {
  isString: function isString(v) {
    return typeof v === 'string';
  },
  isFunction: function isFunction(v) {
    return typeof v === 'function';
  },
  isBoolean: function isBoolean(v) {
    return typeof v === 'boolean';
  },
  isNumber: function isNumber(v) {
    return (typeof v === 'number' || v instanceof Number) && !isNaN(v);
  },
  isInteger: function isInteger(v) {
    return typeof v === 'number' && Number.isInteger(v);
  },
  isUndefined: function isUndefined(v) {
    return typeof v === 'undefined';
  },
  isArray: function isArray(v) {
    return Array.isArray(v);
  },
  isNull: function isNull(v) {
    return v === null;
  },
  isEmpty: function isEmpty(v) {
    return util.isUndefined(v) || util.isNull(v) || v === '';
  },
  isObject: function isObject(v) {
    return typeof v === 'object' && !util.isArray(v) && !util.isNull(v) && !util.isDate(v) && !util.isRegExp(v) && !util.isNumber(v);
  },
  isDate: function isDate(v) {
    return toS(v) === '[object Date]';
  },
  isRegExp: function isRegExp(v) {
    return toS(v) === '[object RegExp]';
  },
  isError: function isError(v) {
    return v instanceof Error;
  },
  // https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
  isEmail: function isEmail(v) {
    return /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(v);
  }
};

exports.util = util;

var AssertionError = (function (_Error) {
  function AssertionError(message) {
    _classCallCheck(this, AssertionError);

    _get(Object.getPrototypeOf(AssertionError.prototype), 'constructor', this).call(this, message);
    this.name = 'AssertionError';
    this.message = message;

    if (Error.captureStackTrace) {
      Error.captureStackTrace(this);
    } else {
      var err = new Error();
      var stack = err.stack;

      if (!stack) {
        // IE10
        try {
          throw err;
        } catch (e) {
          stack = e.stack;
        }
      }
      this.stack = stack;
    }
  }

  _inherits(AssertionError, _Error);

  return AssertionError;
})(Error);

exports.AssertionError = AssertionError;

var Violate = (function () {
  function Violate() {
    var rules = arguments[0] === undefined ? {} : arguments[0];

    _classCallCheck(this, Violate);

    this.rules = rules;
  }

  _createClass(Violate, [{
    key: 'validate',
    value: function validate(values) {
      var _this = this;

      // validate arguments
      if (values === null || values === undefined) {
        return;
      }

      var violations = Object.keys(this.rules).map(function (key) {
        // execute rules with undefined if values not exists.
        var value = values[key];

        var rule = _this.rules[key];

        // apply rule if function
        if (util.isFunction(rule)) {
          return rule(value, key, util);
        }

        // create validator if rule is object
        var v = new Violate(rule);
        return v.validate(value);
      }).reduce(function (pre, curr) {
        // filter undefined
        if (curr === undefined) {
          return pre;
        }

        // filter empty array
        if (Array.isArray(curr) && curr.length === 0) {
          return pre;
        }

        // merge into array
        return pre.concat(curr);
      }, []);

      // return violations if exists
      if (violations.length > 0) {
        return violations;
      }

      // return undefined if no violations
    }
  }, {
    key: 'assert',
    value: function assert(values) {
      // delegate to this.validate
      var violations = this.validate(values);
      if (violations === undefined) {
        return;
      }

      throw new AssertionError(JSON.stringify(violations));
    }
  }]);

  return Violate;
})();

exports.Violate = Violate;