cli-engine/lib/cli.js

Generic CLI Framework

'use strict';

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

require('./fs');

var _cliEngineCommand = require('cli-engine-command');

var _cliEngineCommand2 = _interopRequireDefault(_cliEngineCommand);

var _cliEngineConfig = require('cli-engine-config');

var _output = require('cli-engine-command/lib/output');

var _output2 = _interopRequireDefault(_output);

var _plugins = require('./plugins');

var _plugins2 = _interopRequireDefault(_plugins);

var _util = require('./util');

var _analytics = require('./analytics');

var _analytics2 = _interopRequireDefault(_analytics);

var _updater = require('./updater');

var _updater2 = _interopRequireDefault(_updater);

var _not_found = require('./not_found');

var _not_found2 = _interopRequireDefault(_not_found);

var _lock = require('./lock');

var _lock2 = _interopRequireDefault(_lock);

var _migrator = require('./plugins/migrator');

var _migrator2 = _interopRequireDefault(_migrator);

var _help = require('./commands/help');

var _help2 = _interopRequireDefault(_help);

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

const debug = require('debug')('cli-engine:cli');
const handleEPIPE = err => {
  if (err.code !== 'EPIPE') throw err;
};

let out;
if (!global.testing) {
  process.once('SIGINT', () => {
    if (out) {
      if (out.action.task) out.action.stop(out.color.red('ctrl-c'));
      out.exit(1);
    } else {
      process.exit(1);
    }
  });
  let handleErr = err => {
    if (!out) throw err;
    out.error(err);
  };
  process.once('uncaughtException', handleErr);
  process.once('unhandledRejection', handleErr);
  process.stdout.on('error', handleEPIPE);
  process.stderr.on('error', handleEPIPE);
}

process.env.CLI_ENGINE_VERSION = require('../package.json').version;

class Main {

  constructor(options) {
    this.mock = !!options.mock;
    this.argv = options.argv;
    this.config = (0, _cliEngineConfig.buildConfig)(options.config);
    out = new _output2.default({ config: this.config, mock: this.mock });
    if (process.env.CLI_ENGINE_SHOW_CONFIG) {
      out.inspect(this.config);
    }
    this.lock = new _lock2.default(out);
  }

  async run() {
    debug('starting run');

    const updater = new _updater2.default(out);
    debug('autoupdating');
    await updater.autoupdate();

    try {
      const migrator = new _migrator2.default(out);
      await migrator.run();
    } catch (err) {
      out.warn('Error migrating v5 plugins');
      out.warn(err);
    }

    if (this.cmdAskingForHelp) {
      debug('running help');
      this.cmd = await _help2.default.run({ argv: this.argv.slice(1), config: this.config, mock: this.mock });
    } else {
      debug('loading plugins');
      let plugins = new _plugins2.default(out);
      await plugins.load();

      debug('finding command');
      const id = this.argv[1];
      let Command = await plugins.findCommand(id || this.config.defaultCommand);
      if (!Command) return new _not_found2.default(out, this.argv).run();
      debug('out.done()');
      await out.done();
      debug('recording analytics');
      let analytics = new _analytics2.default({ config: this.config, out, plugins });
      await analytics.record(id);
      debug('running cmd');
      await this.lock.unread();
      this.cmd = await Command.run({ argv: this.argv.slice(2), config: this.config, mock: this.mock });
    }
    debug('flushing stdout');
    await (0, _util.timeout)(this.flush(), 10000);
    debug('exiting');
    out.exit(0);
  }

  flush() {
    if (global.testing) return Promise.resolve();
    let p = new Promise(resolve => process.stdout.once('drain', resolve));
    process.stdout.write('');
    return p;
  }

  get cmdAskingForHelp() {
    if (this.isCmdEdgeCase) return false;
    if (this.argv.find(arg => ['--help', '-h'].includes(arg))) {
      return true;
    }
    return false;
  }

  get isCmdEdgeCase() {
    let j = this.argv.indexOf('--');
    if (j !== -1) {
      for (var i = 0; i < j; i++) {
        if (['--help', '-h'].includes(this.argv[i])) return false;
      }
      return true;
    }
    return false;
  }
}
exports.default = Main;