alinex-validator/dist/type/Boolean.js

'use strict';

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

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var _Schema = require('./Schema');

var _Schema2 = _interopRequireDefault(_Schema);

var _Error = require('../Error');

var _Error2 = _interopRequireDefault(_Error);

var _Reference = require('../Reference');

var _Reference2 = _interopRequireDefault(_Reference);

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

class BooleanSchema extends _Schema2.default {
  constructor(base) {
    super(base);

    const set = this._setting;
    set.truthy = new Set();
    set.falsy = new Set();
    set.format = new Map();

    let raw = this._rules.descriptor.pop();
    this._rules.descriptor.push(this._parserDescriptor, this._formatDescriptor, raw);
    raw = this._rules.validator.pop();
    this._rules.validator.push(this._parserValidator, this._formatValidator, raw);
  }

  truthy(...values) {
    const set = this._setting;
    const value = values.reduce((acc, val) => acc.concat(val), []);
    if (value.length === 1 && value[0] === undefined) set.truthy.clear();else if (value.length === 1 && value[0] instanceof _Reference2.default) set.truthy = value[0];else {
      set.truthy = new Set();
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          const e = _step.value;

          if (value === undefined) set.required = false;
          set.truthy.add(e);
          set.falsy.delete(e);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
    return this;
  }
  falsy(...values) {
    const set = this._setting;
    const value = values.reduce((acc, val) => acc.concat(val), []);
    if (value.length === 1 && value[0] === undefined) set.falsy.clear();else if (value.length === 1 && value[0] instanceof _Reference2.default) set.falsy = value[0];else {
      set.falsy = new Set();
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = value[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          const e = _step2.value;

          if (value === undefined) set.required = false;
          set.falsy.add(e);
          set.truthy.delete(e);
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }
    }
    return this;
  }

  tolerant(flag = true) {
    const set = this._setting;
    if (flag) {
      this.truthy(1, '1', 'true', 'on', 'yes', '+');
      this.falsy(0, '0', 'false', 'off', 'no', '-');
    } else {
      set.truthy.clear();
      set.falsy.clear();
    }
    return this;
  }

  insensitive(flag) {
    return this._setFlag('insensitive', flag);
  }

  _parserDescriptor() {
    const set = this._setting;
    let msg = '';
    let truthy = Array.from(set.truthy);
    truthy.unshift(true);
    truthy = truthy.map(e => `\`${_util2.default.inspect(e)}\``).join(', ').replace(/(.*),/, '$1 and');
    let falsy = Array.from(set.falsy);
    falsy.unshift(false);
    falsy = falsy.map(e => `\`${_util2.default.inspect(e)}\``).join(', ').replace(/(.*),/, '$1 and');
    msg = `A boolean which is \`true\` for ${truthy} and \`false\` for ${falsy}. `;
    if (set.insensitive instanceof _Reference2.default) {
      msg += `Strings are matched case insensitive depending on ${set.insensitive.description}. `;
    } else if (set.insensitive) {
      msg = 'Strings are matched insensitive for possible `true`/`false` values. ';
    }
    return msg.replace(/ $/, '\n');
  }

  _parserValidator(data) {
    const check = this._check;
    try {
      this._checkArray('truthy');
      this._checkArray('falsy');
      this._checkBoolean('insensitive');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }
    if (check.insensitive) {
      check.truthy = Array.from(check.truthy).map(e => typeof e === 'string' ? e.toLowerCase() : e);
      check.falsy = Array.from(check.falsy).map(e => typeof e === 'string' ? e.toLowerCase() : e);
    }
    check.truthy.unshift(true);
    check.falsy.unshift(false);

    if (check.insensitive) data.value = data.value.toLowerCase();
    if (check.truthy.includes(data.value)) data.value = true;else if (check.falsy.includes(data.value)) data.value = false;else {
      return Promise.reject(new _Error2.default(this, data, 'A boolean value is needed but neither `true` nor `false` was given.'));
    }

    return Promise.resolve();
  }

  format(truthy, falsy) {
    const set = this._setting;
    if (truthy) set.format.set(true, truthy);else if (truthy === undefined) set.format.delete(true);
    if (falsy) set.format.set(false, falsy);else if (falsy === undefined) set.format.delete(false);
    return this;
  }

  _formatDescriptor() {
    const set = this._setting;
    return set.format.size ? `Strings are formatted using \`${_util2.default.inspect(set.format.get(true))}\` for \
\`true\` and \`${_util2.default.inspect(set.format.get(false))}\` for \`false\`.\n` : '';
  }

  _formatValidator(data) {
    const check = this._check;
    try {
      this._checkObject('format');
      if (Object.keys(check.format).filter(e => e !== 'true' && e !== 'false').length) {
        throw new Error('Only `true` and `false` settings are allowed in format()`');
      }
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (Object.keys(check.format).length) data.value = check.format[data.value] || data.value;
    return Promise.resolve();
  }
}

exports.default = BooleanSchema;