alinex-validator/dist/type/File.js

'use strict';

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

var _es6Promisify = require('es6-promisify');

var _es6Promisify2 = _interopRequireDefault(_es6Promisify);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _minimatch = require('minimatch');

var _minimatch2 = _interopRequireDefault(_minimatch);

var _String = require('./String');

var _String2 = _interopRequireDefault(_String);

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 FileSchema extends _String2.default {
  constructor(base) {
    super(base);

    let raw = this._rules.descriptor.pop();
    let allow = this._rules.descriptor.pop();
    this._rules.descriptor.push(this._baseDescriptor, allow, this._existsDescriptor, this._resolveDescriptor, raw);
    raw = this._rules.validator.pop();
    allow = this._rules.validator.pop();
    this._rules.validator.push(this._baseValidator, allow, this._existsValidator, this._resolveValidator, raw);
  }

  stripEmpty() {
    return this._setError('stripEmpty');
  }
  truncate() {
    return this._setError('truncate');
  }
  pad() {
    return this._setError('pad');
  }

  _typeDescriptor() {
    return 'It has to be a valid file or directory location.\n';
  }

  baseDir(base) {
    return this._setAny('baseDir', base);
  }

  _baseDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.base) {
      if (this._isReference('baseDir')) {
        msg += `If a relative path is given it will be resolved from the location defined under \
${set.baseDir.description}. `;
      } else msg += `If a relative path is given it will be resolved from ${set.baseDir}. `;
    }
    return msg.length ? `${msg.trim()}\n` : msg;
  }

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

    if (check.baseDir) data.temp.resolved = _path2.default.resolve(check.baseDir, data.value);else data.temp.resolved = _path2.default.resolve(data.value);
    return Promise.resolve();
  }

  _allowValidator(data) {
    const check = this._check;
    this._checkArray('allow');
    this._checkArray('deny');

    if (check.deny && check.deny.length && check.deny.filter(e => (0, _minimatch2.default)(data.value, e)).length) {
      return Promise.reject(new _Error2.default(this, data, 'Element found in blacklist (denyed item).'));
    }

    if (check.allow && check.allow.length && check.allow.filter(e => (0, _minimatch2.default)(data.value, e)).length === 0) {
      return Promise.reject(new _Error2.default(this, data, 'Element not in whitelist (allowed item).'));
    }

    return Promise.resolve();
  }

  exists(flag) {
    return this._setFlag('exists', flag);
  }
  readable(flag) {
    return this._setFlag('readable', flag);
  }
  writable(flag) {
    return this._setFlag('writable', flag);
  }

  _existsDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.writable) {
      if (this._isReference('writable')) {
        msg += `The file has to be writable if defined under ${set.writable.description}. `;
      } else msg += 'The file has to be writable. ';
    } else if (set.readable) {
      if (this._isReference('readable')) {
        msg += `The file has to be readable if defined under ${set.readable.description}. `;
      } else msg += 'The file has to be readable. ';
    } else if (set.exists) {
      if (this._isReference('exists')) {
        msg += `The file has to exist if defined under ${set.exists.description}. `;
      } else msg += 'The file has to exist. ';
    }
    return msg.length ? `${msg.trim()}\n` : msg;
  }

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

    let p = Promise.resolve();
    if (check.readable) p = p.then(() => (0, _es6Promisify2.default)(_fs2.default.access)(data.temp.resolved, _fs2.default.R_OK));else if (check.writable) p = p.then(() => (0, _es6Promisify2.default)(_fs2.default.access)(data.temp.resolved, _fs2.default.W_OK));else if (check.exists) p = p.then(() => (0, _es6Promisify2.default)(_fs2.default.access)(data.temp.resolved, _fs2.default.F_OK));
    return p;
  }

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

  _resolveDescriptor() {
    const set = this._setting;
    let msg = '';
    if (set.resolve) {
      if (this._isReference('resolve')) {
        msg += `A relative address will be set to it's absolute location if set under \
${set.resolve.description}. `;
      } else msg += 'A relative address will be set to it\'s absolute location. ';
    }
    return msg.length ? `${msg.trim()}\n` : msg;
  }

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

    if (check.resolve) data.value = data.temp.resolved;
    return Promise.resolve();
  }
}

exports.default = FileSchema;