alinex-validator/dist/type/Number.js

'use strict';

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

var _numeral = require('numeral');

var _numeral2 = _interopRequireDefault(_numeral);

var _convertUnits = require('convert-units');

var _convertUnits2 = _interopRequireDefault(_convertUnits);

var _alinexUtil = require('alinex-util');

var _alinexUtil2 = _interopRequireDefault(_alinexUtil);

var _Any = require('./Any');

var _Any2 = _interopRequireDefault(_Any);

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 }; }

const INTTYPE = {
  byte: 8,
  short: 16,
  long: 32,
  safe: 53,
  quad: 64
};

class Round {

  constructor(precision = 0, method = 'arithmetic') {
    if (precision < 0) {
      throw new Error('Precision for round should be 0 or greater.');
    }
    this.precision = precision;
    this.method = method;
  }
}

class NumberSchema extends _Any2.default {
  constructor(base) {
    super(base);

    let raw = this._rules.descriptor.pop();
    let allow = this._rules.descriptor.pop();
    this._rules.descriptor.push(this._unitDescriptor, this._sanitizeDescriptor, this._roundDescriptor, this._minmaxDescriptor, this._multipleDescriptor, allow, this._formatDescriptor, raw);
    raw = this._rules.validator.pop();
    allow = this._rules.validator.pop();
    this._rules.validator.push(this._unitValidator, this._sanitizeValidator, this._roundValidator, this._minmaxValidator, this._multipleValidator, allow, this._formatValidator, raw);
  }

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

  _sanitizeDescriptor() {
    const set = this._setting;
    let msg = 'A numerical value is needed. ';
    if (set.sanitize instanceof _Reference2.default) {
      msg += `Strings are sanitized depending on ${set.sanitize.description}. `;
    } else if (set.sanitize) {
      msg += 'Strings are sanitized to get the first numerical value out of it. ';
    }
    return msg.replace(/ $/, '\n');
  }

  _sanitizeValidator(data) {
    const check = this._check;
    try {
      this._checkBoolean('sanitize');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    const orig = data.value;
    if (typeof data.value === 'string') {
      if (check.sanitize) data.value = data.value.replace(/^.*?([-+]?\d+\.?\d*).*?$/, '$1');
      data.value = Number(data.value);
    }
    if (typeof data.value !== 'number') {
      return Promise.reject(new _Error2.default(this, data, `The given value is of type ${typeof data.value} but a number is needed.`));
    } else if (Number.isNaN(data.value)) {
      return Promise.reject(new _Error2.default(this, data, `The given element \`${_alinexUtil2.default.inspect(orig)}\` is no valid number.`));
    }
    return Promise.resolve();
  }

  unit(unit) {
    const set = this._setting;
    if (unit instanceof _Reference2.default) set.unit = unit;else if (unit) {
      try {
        (0, _convertUnits2.default)().from(unit);
        set.unit = unit;
      } catch (e) {
        throw new Error(`Unit ${unit} not recognized`);
      }
    } else delete set.unit;
    return this;
  }

  toUnit(unit) {
    const set = this._setting;
    if (!set.unit) throw new Error('First define the input `unit()` before converting further');
    if (unit instanceof _Reference2.default) set.toUnit = unit;else if (unit) {
      try {
        (0, _convertUnits2.default)().from(unit);
        set.toUnit = unit;
      } catch (e) {
        throw new Error(`Unit ${unit} not recognized`);
      }
    } else delete set.toUnit;
    return this;
  }

  _unitDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.unit) {
      if (set.unit instanceof _Reference2.default) {
        msg += `The value is given in unit specified in ${set.unit.description}. `;
      } else msg += `Give the values in \`${set.unit}\`. `;
      if (set.toUnit instanceof _Reference2.default) {
        msg += `The value converted to unit specified in ${set.toUnit.description}. `;
      } else if (set.toUnit) {
        msg = msg.replace(/\. $/, ` and onvert the values to \`${set.toUnit}\`. `);
      }
    }
    return msg.length ? msg.replace(/ $/, '\n') : '';
  }

  _unitValidator(data) {
    const check = this._check;
    if (check.unit) {
      try {
        this._checkString('unit');
        (0, _convertUnits2.default)().from(check.unit);
      } catch (e) {
        throw new Error(`Unit ${check.unit} not recognized`);
      }
    }
    if (check.toUnit) {
      try {
        this._checkString('unit');
        (0, _convertUnits2.default)().from(check.toUnit);
      } catch (e) {
        throw new Error(`Unit ${check.toUnit} not recognized`);
      }
    }

    if (check.unit && typeof data.value === 'string') {
      if (check.sanitize) data.value = data.value.replace(/^.*?([-+]?\d+\.?\d*\s*\S*).*?$/, '$1');
      let quantity;
      try {
        const match = data.value.match(/(^[-+]?\d+\.?\d*)\s*(\S*)/);
        quantity = (0, _convertUnits2.default)(match[1]).from(match[2]);
      } catch (e) {
        return Promise.reject(new _Error2.default(this, data, `Could not parse the unit of ${data.value}: ${e.message}`));
      }
      try {
        data.value = quantity.to(check.unit);
      } catch (e) {
        return Promise.reject(new _Error2.default(this, data, `Could not convert to ${check.unit}: ${e.message}`));
      }
    }
    if (check.unit && check.toUnit && typeof data.value === 'number') {
      try {
        data.value = (0, _convertUnits2.default)(data.value).from(check.unit).to(check.toUnit);
      } catch (e) {
        return Promise.reject(new _Error2.default(this, data, `Could not convert ${check.unit} to ${check.toUnit}: ${e.message}`));
      }
    }
    return Promise.resolve();
  }

  min(value) {
    const set = this._setting;
    if (value) {
      if (!(value instanceof _Reference2.default)) {
        if (set.max && !this._isReference('max') && value > set.max) {
          throw new Error('Min can´t be greater than max value');
        }
        if (set.less && !this._isReference('less') && value >= set.less) {
          throw new Error('Min can´t be greater or equal less value');
        }
        if (set.negative && !this._isReference('negative') && value > 0) {
          throw new Error('Min can´t be positive, because defined as negative');
        }
      }
      set.min = value;
    } else delete set.min;
    return this;
  }

  max(value) {
    const set = this._setting;
    if (value) {
      if (!(value instanceof _Reference2.default)) {
        if (set.min && !this._isReference('min') && value < set.min) {
          throw new Error('Max can´t be less than min value');
        }
        if (set.greater && !this._isReference('greater') && value >= set.greater) {
          throw new Error('Max can´t be less or equal greater value');
        }
        if (set.positive && !this._isReference('positive') && value < 0) {
          throw new Error('Max can´t be negative, because defined as positive');
        }
      }
      set.max = value;
    } else delete set.max;
    return this;
  }

  less(value) {
    const set = this._setting;
    if (value) {
      if (!(value instanceof _Reference2.default)) {
        if (set.min && !this._isReference('min') && value <= set.min) {
          throw new Error('Less can´t be less than min value');
        }
        if (set.greater && !this._isReference('greater') && value <= set.greater) {
          throw new Error('Less can´t be less or equal greater value');
        }
        if (set.positive && !this._isReference('positive') && value <= 0) {
          throw new Error('Less can´t be negative, because defined as positive');
        }
      }
      set.less = value;
    } else delete set.less;
    return this;
  }

  greater(value) {
    const set = this._setting;
    if (value) {
      if (!(value instanceof _Reference2.default)) {
        if (set.max && !this._isReference('max') && value >= set.max) {
          throw new Error('Greater can´t be greater than max value');
        }
        if (set.less && !this._isReference('less') && value >= set.less) {
          throw new Error('Greater can´t be greater or equal less value');
        }
        if (set.negative && !this._isReference('negative') && value >= 0) {
          throw new Error('Greater can´t be positive, because defined as negative');
        }
      }
      set.greater = value;
    } else delete set.greater;
    return this;
  }

  positive(flag = true) {
    const set = this._setting;
    if (flag === false) delete set.positive;else if (flag instanceof _Reference2.default) set.positive = flag;else {
      if (!this._isReference('max') && set.max < 0) {
        throw new Error('Positive can´t be set because max value is negative');
      }
      if (!this._isReference('less') && set.less <= 0) {
        throw new Error('Positive can´t be set because less value is negative');
      }
      if (!this._isReference('negative')) set.negative = false;
      set.positive = true;
    }
    return this;
  }

  negative(flag = true) {
    const set = this._setting;
    if (flag === false) delete set.negative;else if (flag instanceof _Reference2.default) set.negative = flag;else {
      if (!this._isReference('min') && set.min > 0) {
        throw new Error('Negative can´t be set because min value is positive');
      }
      if (!this._isReference('greater') && set.greater >= 0) {
        throw new Error('Negative can´t be set because greater value is positive');
      }
      if (!this._isReference('positive')) set.positive = false;
      set.negative = true;
    }
    return this;
  }

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

  integerType(type) {
    const set = this._setting;
    if (type) {
      if (!(type instanceof _Reference2.default)) {
        set.integer = true;
        if (INTTYPE[type]) set.integerType = INTTYPE[type];else if (typeof type === 'number') {
          if (Object.values(INTTYPE).includes(type)) set.integerType = type;
        } else throw new Error(`Undefined type ${type} for integer.`);
      } else {
        set.integerType = type;
      }
    } else delete set.integerType;
    return this;
  }

  _minmaxDescriptor() {
    const set = this._setting;

    let max;
    let min;
    if (set.integer && !this._isReference('integer') && set.integerType) {
      const unsigned = set.positive ? 1 : 0;
      max = Math.pow(2, set.integerType - 1 + unsigned) - 1;
      min = (unsigned - 1) * max - 1 + unsigned;
    }
    if (min === undefined || !(!this._isReference('min') && set.min <= min)) min = set.min;
    if (max === undefined || !(!this._isReference('max') && set.max >= max)) max = set.max;
    if (min !== undefined && !this._isReference('greater') && set.greater !== undefined) {
      if (set.greater >= min) min = undefined;else delete set.greater;
    }
    if (max !== undefined && !this._isReference('less') && set.less !== undefined) {
      if (set.less <= max) max = undefined;else delete set.less;
    }

    let msg = '';
    if (this._isReference('integer')) {
      msg += `The value has to be an integer if specified in ${set.integer.description}. `;
    } else if (set.integer && set.integerType) {
      msg += `It has to be an ${set.positive ? 'unsigned ' : ''}\
 ${set.integerType}-bit integer. `;
    }
    if (this._isReference('positive')) {
      msg += `The value has to be positive if specified in ${set.positive.description}. `;
    } else if (set.positive) msg += 'The number should be positive. ';
    if (this._isReference('negative')) {
      msg += `The value has to be negative if specified in ${set.negative.description}. `;
    } else if (set.negative) msg += 'The number should be negative. ';
    if (this._isReference('min')) {
      msg += `The value has to be at least the number given in ${set.min.description}. `;
    } else if (min !== undefined) msg += `The value has to be at least \`${set.min}\`. `;
    if (this._isReference('greater')) {
      msg += `The value has to be higher than given in ${set.greater.description}. `;
    } else if (set.greater !== undefined) {
      msg += `The value has to be greater than \`${set.greater}\`. `;
    }
    if (this._isReference('less')) {
      msg += `The value has to be at lower than given in ${set.less.description}. `;
    } else if (set.less !== undefined) msg += `The value has to be less than \`${set.less}\`. `;
    if (this._isReference('max')) {
      msg += `The value has to be at least the number given in ${set.max.description}. `;
    } else if (max !== undefined) msg += `The value has to be at most \`${set.max}\`. `;
    if ((min !== undefined || set.greater !== undefined) && (max !== undefined || set.less !== undefined)) {
      msg = msg.replace(/(.*)\. The value has to be/, '$1 and');
    }
    return msg.replace(/ $/, '\n');
  }

  _minmaxValidator(data) {
    const check = this._check;
    try {
      this._checkNumber('min');
      this._checkNumber('max');
      this._checkNumber('greater');
      this._checkNumber('less');
      this._checkBoolean('positive');
      this._checkBoolean('negative');
      if (check.integerType) {
        if (INTTYPE[check.integerType]) check.integerType = INTTYPE[check.integerType];
        this._checkNumber('integerType');
        if (!Object.values(INTTYPE).includes(check.integerType)) {
          throw new Error(`Impossible to use ${check.integerType}-bit for integer.`);
        }
      }
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    let max;
    let min;
    if (check.integer && check.integerType) {
      const unsigned = check.positive ? 1 : 0;
      max = Math.pow(2, check.integerType - 1 + unsigned) - 1;
      min = (unsigned - 1) * max - 1 + unsigned;
    }
    if (min === undefined || check.min !== undefined && !(check.min <= min)) min = check.min;
    if (max === undefined || check.max !== undefined && !(check.max >= max)) max = check.max;
    if (min !== undefined && check.greater !== undefined) {
      if (check.greater >= min) min = undefined;else delete check.greater;
    }
    if (max !== undefined && check.less !== undefined) {
      if (check.less <= max) max = undefined;else delete check.less;
    }

    if (check.positive && data.value < 0) {
      return Promise.reject(new _Error2.default(this, data, 'The number should be positive.'));
    }
    if (check.negative && data.value > 0) {
      return Promise.reject(new _Error2.default(this, data, 'The number should be negative.'));
    }
    if (min !== undefined && data.value < min) {
      return Promise.reject(new _Error2.default(this, data, `The value has to be at least ${min}.`));
    }
    if (check.greater !== undefined && data.value <= check.greater) {
      return Promise.reject(new _Error2.default(this, data, `The value has to be greater than ${check.greater}.`));
    }
    if (check.less !== undefined && data.value >= check.less) {
      return Promise.reject(new _Error2.default(this, data, `The value has to be less than ${check.less}.`));
    }
    if (max !== undefined && data.value > max) {
      return Promise.reject(new _Error2.default(this, data, `The value has to be at most ${max}.`));
    }
    return Promise.resolve();
  }

  round(precision = 0, method) {
    const set = this._setting;
    if (typeof precision === 'boolean' && !precision) delete set.round;else {
      if (set.integer && !(set.integer instanceof _Reference2.default)) {
        throw new Error('Rounding not possible because defined as integer');
      }
      set.round = new Round(typeof precision === 'boolean' ? 0 : precision, method);
    }
    return this;
  }

  _roundDescriptor() {
    const set = this._setting;
    if (set.integer && set.sanitize) return 'The value is rounded to an integer.\n';
    if (set.round && set.integer) {
      return `The value is rounded to \`${set.round.method}\` to get an integer.\n`;
    }
    if (set.round) {
      return `The value is rounded to \`${set.round.method}\` with \
 ${set.round.precision} digits precision.\n`;
    }
    if (set.integer && !set.integerType) return 'An integer value is needed.\n';
    return '';
  }

  _roundValidator(data) {
    const check = this._check;
    try {
      this._checkBoolean('integer');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (check.integer && !Number.isInteger(data.value)) {
      if (check.sanitize) {
        const method = check.round ? check.round.method : 'arithmetic';
        if (method === 'ceil') data.value = Math.ceil(data.value);else if (method === 'floor') data.value = Math.floor(data.value);else data.value = Math.round(data.value);
      } else {
        return Promise.reject(new _Error2.default(this, data, 'The value has to be an integer number.'));
      }
    } else if (check.round) {
      const exp = check.integer ? 1 : Math.pow(10, check.round.precision);
      let value = data.value * exp;
      if (check.round.method === 'ceil') value = Math.ceil(value);else if (check.round.method === 'floor') value = Math.floor(value);else value = Math.round(value);
      data.value = value / exp;
    }
    return Promise.resolve();
  }

  multiple(value) {
    const set = this._setting;
    if (value) {
      if (!(value instanceof _Reference2.default)) {
        if (set.negative && !this._isReference('negative') && value > 0) {
          throw new Error('Multiplicator has to be negative, too.');
        }
        if (set.positive && !this._isReference('positive') && value < 0) {
          throw new Error('Multiplicator has to be positive, too.');
        }
        set.multiple = value;
      } else {
        set.multiple = value;
      }
    } else delete set.multiple;
    return this;
  }

  _multipleDescriptor() {
    const set = this._setting;
    if (set.multiple) {
      return `The value has to be multiple of \
${this._isReference('multiple') ? set.multiple.description : set.multiple}.\n`;
    }
    return '';
  }

  _multipleValidator(data) {
    const check = this._check;
    try {
      this._checkNumber('multiple');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (check.multiple && data.value % check.multiple) {
      return Promise.reject(new _Error2.default(this, data, `The value has to be a multiple of ${check.multiple}.`));
    }
    return Promise.resolve();
  }

  format(format) {
    return this._setAny('format', format);
  }

  _formatDescriptor() {
    const set = this._setting;
    if (set.format) {
      return `The value will be formatted as string in the form of \
${this._isReference('format') ? set.format.description : set.format}.\n`;
    }
    return '';
  }

  _formatValidator(data) {
    const check = this._check;
    try {
      this._checkString('format');
    } catch (err) {
      return Promise.reject(new _Error2.default(this, data, err.message));
    }

    if (check.format) {
      const match = check.format.match(/(^.*?)(\s*\$(?:unit|best))/);
      let unit = match ? match[2] : '';
      if (unit.includes('$best')) {
        const quantity = (0, _convertUnits2.default)(data.value).from(check.toUnit || check.unit).toBest();
        data.value = quantity.val;
        unit = unit.replace('$best', quantity.unit);
      }
      if (unit.includes('$unit')) unit = unit.replace('$unit', check.toUnit || check.unit || '');
      const format = match ? match[1] : check.format;
      try {
        data.value = `${(0, _numeral2.default)(data.value).format(format)}${unit}`;
      } catch (e) {
        return Promise.reject(new _Error2.default(this, data, `Could not format value: ${e.message}`));
      }
    }
    return Promise.resolve();
  }
}

exports.default = NumberSchema;