kindergarten/lib/Rule.js

Kindergarten is a JavaScript library which helps programmers to achieve modular security using sandbox pattern

'use strict';

exports.__esModule = true;
exports.default = undefined;

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 _some = require('lodash/some');

var _some2 = _interopRequireDefault(_some);

var _upperFirst = require('lodash/upperFirst');

var _upperFirst2 = _interopRequireDefault(_upperFirst);

var _rules = require('./rules');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

/**
 * The definition of Rule class.
 *
 * Rules are used by a governess. Governess can learn many rules and they are
 * defined in perimeter in most of the cases.
 */
var Rule = function () {
  function Rule(str, def) {
    _classCallCheck(this, Rule);

    this.type = new _rules.Type(this, str);
    this.definition = new _rules.Definition(this, def);
  }

  _createClass(Rule, [{
    key: 'verify',
    value: function verify() {
      var verifyMethodName = '_verify' + (0, _upperFirst2.default)(this.definition.type);

      var result = this[verifyMethodName].apply(this, arguments);

      return this.type.isPositive() ? result : !result;
    }
  }, {
    key: '_verifyItems',
    value: function _verifyItems() {
      var subject = arguments.length <= 0 ? undefined : arguments[0];

      return (0, _some2.default)(this.definition.items, function (item) {
        var isInstance = false;

        try {
          isInstance = subject instanceof item;
        } catch (ignore) {
          // Ignore if instanceof is not applicable
        }

        return isInstance || item === subject;
      });
    }
  }, {
    key: '_verifyRegex',
    value: function _verifyRegex() {
      var subject = arguments.length <= 0 ? undefined : arguments[0];

      return this.definition.regex.test(subject);
    }
  }, {
    key: '_verifyCustomMethod',
    value: function _verifyCustomMethod() {
      var definition = this.definition;

      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      return definition.customMethod.apply(definition.ruleContext, args);
    }
  }]);

  return Rule;
}();

exports.default = Rule;