cli-engine/lib/dispatcher.js

Generic CLI Framework

'use strict';

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

require('cli-engine-config');

require('cli-engine-command');

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

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

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

const debug = require('debug')('cli:dispatcher');

class CommandManagerBase {
  constructor(config) {
    this.config = config;
  }
  async findCommand(id) {
    return null;
  }

  async listTopics() {
    return [];
  }

  require(p) {
    return (0, _util.undefault)(require(p));
  }
}

class BuiltinCommandManager extends CommandManagerBase {
  async findCommand(id) {
    const builtins = {
      version: 'version',
      help: 'newhelp'
    };

    let p = builtins[id];
    if (p) {
      p = _path2.default.join(__dirname, 'commands', p);
      return this.require(p);
    }
  }
}

class CLICommandManager extends CommandManagerBase {
  async findCommand(id) {
    let root = this.config.commandsDir;
    if (!root) return;
    let p;
    try {
      debug(`finding ${id} command`);
      p = require.resolve(_path2.default.join(root, ...id.split(':')));
    } catch (err) {
      if (err.code !== 'MODULE_NOT_FOUND') throw err;
    }
    if (p) return this.require(p);
  }
}

class PluginCommandManager extends CommandManagerBase {
  async findCommand(id) {
    const { default: Plugins } = require('./plugins');
    let plugins = new Plugins(this.config);
    await plugins.load();
    let Command = await plugins.findCommand(id || this.config.defaultCommand || 'help');
    if (!Command) return;
    Command.plugin = await plugins.findPluginWithCommand(Command.id);
    return Command;
  }
}

class Dispatcher {

  constructor(config) {
    this.config = config;
    this.managers = [new CLICommandManager(config), new BuiltinCommandManager(config)];
    if (this.config.userPlugins) {
      this.managers.unshift(new PluginCommandManager(config));
    }
  }

  async findCommand(id) {
    if (!id) return;
    for (let manager of this.managers) {
      let Command = await manager.findCommand(id);
      if (Command) return Command;
    }
  }

  findTopic(id) {
    return null;
    // let Topic = await plugins.findTopic(id)
  }

  async listTopics() {
    let arrs = await Promise.all(this.managers.map(m => m.listTopics()));
    return arrs.reduce((next, res) => res.concat(next), []);
  }

  get cmdAskingForHelp() {
    for (let arg of this.config.argv) {
      if (['--help', '-h'].includes(arg)) return true;
      if (arg === '--') return false;
    }
    return false;
  }
}
exports.Dispatcher = Dispatcher;