directory-helpers/index.js

A collection of helper methods for working with directories

'use strict';

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

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _entries = require('babel-runtime/core-js/object/entries');

var _entries2 = _interopRequireDefault(_entries);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _path2 = require('path');

var _path = _interopRequireWildcard(_path2);

var _nodePromiseEs = require('node-promise-es6');

var _fsExtraPromiseEs = require('fs-extra-promise-es6');

var fse = _interopRequireWildcard(_fsExtraPromiseEs);

var _esnextAsync = require('esnext-async');

var _dedent = require('dedent');

var _dedent2 = _interopRequireDefault(_dedent);

var _resolve = require('resolve');

var _resolve2 = _interopRequireDefault(_resolve);

var _glob2 = require('glob');

var _glob3 = _interopRequireDefault(_glob2);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

var _default = function () {
  function _default(basePath) {
    (0, _classCallCheck3.default)(this, _default);

    this.basePath = _path.resolve(basePath);
  }

  (0, _createClass3.default)(_default, [{
    key: 'contains',
    value: function contains(filePath) {
      return !_path.relative(this.path(), this.path(filePath)).includes('..');
    }
  }, {
    key: 'create',
    value: function () {
      var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
        return _regenerator2.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return fse.mkdirs(this.basePath);

              case 2:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function create() {
        return _ref.apply(this, arguments);
      }

      return create;
    }()
  }, {
    key: 'exec',
    value: function () {
      var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(command, params) {
        var _ref3, stdout, stderr;

        return _regenerator2.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.prev = 0;
                _context2.next = 3;
                return _nodePromiseEs.childProcess.execFile(command, params, {
                  cwd: this.path()
                });

              case 3:
                _ref3 = _context2.sent;
                stdout = _ref3.stdout;
                return _context2.abrupt('return', stdout.trim());

              case 8:
                _context2.prev = 8;
                _context2.t0 = _context2['catch'](0);
                stderr = _context2.t0.stderr;
                throw new Error(stderr.trim());

              case 12:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this, [[0, 8]]);
      }));

      function exec(_x, _x2) {
        return _ref2.apply(this, arguments);
      }

      return exec;
    }()
  }, {
    key: 'execJs',
    value: function execJs(code) {
      var _this = this;

      return new _promise2.default(function (resolve, reject) {
        var child = _nodePromiseEs.childProcess.spawn('dist-es6-run', { cwd: _this.path() });
        child.stdin.write(code);
        child.stdin.end();

        var stdoutOutput = '';
        child.stdout.on('data', function (output) {
          stdoutOutput += output;
        });

        var stderrOutput = '';
        child.stderr.on('data', function (output) {
          stderrOutput += output;
        });

        child.on('close', function (exitCode) {
          if (exitCode === 0) {
            resolve(stdoutOutput.trim());
          } else {
            reject(stderrOutput.trim());
          }
        });
      });
    }
  }, {
    key: 'glob',
    value: function () {
      var _ref5 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(pattern, options) {
        return _regenerator2.default.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return (0, _nodePromiseEs.promisify)(_glob3.default)(pattern, (0, _assign2.default)({}, options, {
                  cwd: this.path()
                }));

              case 2:
                return _context3.abrupt('return', _context3.sent);

              case 3:
              case 'end':
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function glob(_x3, _x4) {
        return _ref5.apply(this, arguments);
      }

      return glob;
    }()
  }, {
    key: 'path',
    value: function path() {
      for (var _len = arguments.length, components = Array(_len), _key = 0; _key < _len; _key++) {
        components[_key] = arguments[_key];
      }

      return _path.resolve.apply(_path, [this.basePath].concat(components));
    }
  }, {
    key: 'read',
    value: function () {
      var _ref6 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4(filePath) {
        var contents;
        return _regenerator2.default.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.next = 2;
                return _nodePromiseEs.fs.readFile(this.path(filePath), 'utf8');

              case 2:
                contents = _context4.sent;
                _context4.prev = 3;
                return _context4.abrupt('return', JSON.parse(contents));

              case 7:
                _context4.prev = 7;
                _context4.t0 = _context4['catch'](3);
                return _context4.abrupt('return', contents);

              case 10:
              case 'end':
                return _context4.stop();
            }
          }
        }, _callee4, this, [[3, 7]]);
      }));

      function read(_x5) {
        return _ref6.apply(this, arguments);
      }

      return read;
    }()
  }, {
    key: 'remove',
    value: function () {
      var _ref7 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee5() {
        var _args5 = arguments;
        return _regenerator2.default.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _context5.next = 2;
                return fse.remove(this.path.apply(this, _args5));

              case 2:
              case 'end':
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function remove(_x6) {
        return _ref7.apply(this, arguments);
      }

      return remove;
    }()
  }, {
    key: 'resolve',
    value: function () {
      var _ref8 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee6(request) {
        var _this2 = this;

        return _regenerator2.default.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.next = 2;
                return new _promise2.default(function (resolve, reject) {
                  (0, _resolve2.default)(request, { basedir: _this2.path() }, function (error, result) {
                    if (error) {
                      reject(error);
                    } else {
                      resolve(result);
                    }
                  });
                });

              case 2:
                return _context6.abrupt('return', _context6.sent);

              case 3:
              case 'end':
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function resolve(_x7) {
        return _ref8.apply(this, arguments);
      }

      return resolve;
    }()
  }, {
    key: 'spawn',
    value: function spawn(command) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

      var child = _nodePromiseEs.childProcess.spawn('setsid', [command].concat((0, _toConsumableArray3.default)(params)), { cwd: this.path() });
      var observable = new _esnextAsync.AwaitableObservable(function (observer) {
        child.stdout.on('data', function (data) {
          observer.next(data.toString());
        });
        child.stderr.on('data', function (data) {
          observer.next(data.toString());
        });
      });
      observable.process = child;
      return observable;
    }
  }, {
    key: 'start',
    value: function () {
      var _ref9 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee7() {
        var waitPattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : /^/;
        return _regenerator2.default.wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                this.server = this.spawn('npm', ['start']);
                this.server.forEach(function (output) {
                  process.stderr.write(output);
                });
                _context7.next = 4;
                return this.server.filter(function (output) {
                  return output.match(waitPattern);
                });

              case 4:
              case 'end':
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function start(_x9) {
        return _ref9.apply(this, arguments);
      }

      return start;
    }()
  }, {
    key: 'stat',
    value: function () {
      var _ref10 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee8(filePath) {
        return _regenerator2.default.wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                _context8.next = 2;
                return _nodePromiseEs.fs.stat(this.path(filePath));

              case 2:
                return _context8.abrupt('return', _context8.sent);

              case 3:
              case 'end':
                return _context8.stop();
            }
          }
        }, _callee8, this);
      }));

      function stat(_x11) {
        return _ref10.apply(this, arguments);
      }

      return stat;
    }()
  }, {
    key: 'stop',
    value: function () {
      var _ref11 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee9() {
        var _this3 = this;

        return _regenerator2.default.wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                _context9.next = 2;
                return new _promise2.default(function (resolve) {
                  _this3.server.process.on('close', resolve);
                  process.kill(-_this3.server.process.pid);
                });

              case 2:
              case 'end':
                return _context9.stop();
            }
          }
        }, _callee9, this);
      }));

      function stop() {
        return _ref11.apply(this, arguments);
      }

      return stop;
    }()
  }, {
    key: 'symlink',
    value: function () {
      var _ref12 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee10(source, destination) {
        return _regenerator2.default.wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                _context10.next = 2;
                return fse.ensureSymlink(this.path(source), this.path(destination));

              case 2:
              case 'end':
                return _context10.stop();
            }
          }
        }, _callee10, this);
      }));

      function symlink(_x12, _x13) {
        return _ref12.apply(this, arguments);
      }

      return symlink;
    }()
  }, {
    key: 'write',
    value: function () {
      var _ref13 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee11(files) {
        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step$value, filePath, fileContents, absoluteFilePath;

        return _regenerator2.default.wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                _iteratorNormalCompletion = true;
                _didIteratorError = false;
                _iteratorError = undefined;
                _context11.prev = 3;
                _iterator = (0, _getIterator3.default)((0, _entries2.default)(files));

              case 5:
                if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
                  _context11.next = 20;
                  break;
                }

                _step$value = (0, _slicedToArray3.default)(_step.value, 2), filePath = _step$value[0], fileContents = _step$value[1];
                absoluteFilePath = this.path(filePath);
                _context11.next = 10;
                return fse.ensureFile(absoluteFilePath);

              case 10:
                if (!((typeof fileContents === 'undefined' ? 'undefined' : (0, _typeof3.default)(fileContents)) === 'object')) {
                  _context11.next = 15;
                  break;
                }

                _context11.next = 13;
                return fse.writeJson(absoluteFilePath, fileContents);

              case 13:
                _context11.next = 17;
                break;

              case 15:
                _context11.next = 17;
                return _nodePromiseEs.fs.writeFile(absoluteFilePath, (0, _dedent2.default)(fileContents) + '\n');

              case 17:
                _iteratorNormalCompletion = true;
                _context11.next = 5;
                break;

              case 20:
                _context11.next = 26;
                break;

              case 22:
                _context11.prev = 22;
                _context11.t0 = _context11['catch'](3);
                _didIteratorError = true;
                _iteratorError = _context11.t0;

              case 26:
                _context11.prev = 26;
                _context11.prev = 27;

                if (!_iteratorNormalCompletion && _iterator.return) {
                  _iterator.return();
                }

              case 29:
                _context11.prev = 29;

                if (!_didIteratorError) {
                  _context11.next = 32;
                  break;
                }

                throw _iteratorError;

              case 32:
                return _context11.finish(29);

              case 33:
                return _context11.finish(26);

              case 34:
              case 'end':
                return _context11.stop();
            }
          }
        }, _callee11, this, [[3, 22, 26, 34], [27,, 29, 33]]);
      }));

      function write(_x14) {
        return _ref13.apply(this, arguments);
      }

      return write;
    }()
  }]);
  return _default;
}();

exports.default = _default;