zoro-cli/lib/index.js

https://github.com/vuejs/vue-cli

const {
  log,
  info,
  warn,
  error,
  success
} = require('zoro-cli-util/logger');

const {
  getPkgVersion,
  packInstallPkgGlobalCmd,
  installPkgGlobal
} = require('zoro-cli-util/pkg');

const path = require('path');

const chalk = require('chalk');

const semver = require('semver');

const program = require('commander');

const {
  merge
} = require('lodash');

const inquirer = require('inquirer');

const currPkgPath = '../package.json';
/* eslint-disable import/no-dynamic-require */

const currPkg = require(currPkgPath);
/* eslint-enable import/no-dynamic-require */


let cliPkg = currPkg;
const cmdConfig = {
  init: {
    docSite: ''
  }
};

function loadPkg(pkgPath) {
  if (pkgPath) {
    if (pkgPath.indexOf('package.json') === -1) {
      pkgPath = path.join(pkgPath, 'package.json');
    }
    /* eslint-disable import/no-dynamic-require */


    cliPkg = require(pkgPath);
    /* eslint-enable import/no-dynamic-require */
  }
}

function config(options = {}) {
  const {
    pkgPath,
    cmd
  } = options;
  loadPkg(pkgPath);
  merge(cmdConfig, cmd);
} // commander passes the Command object itself as options,
// extract only actual options into a fresh object.


function cleanArgs(cmd) {
  const args = {
    cliPkg
  };
  cmd.options.forEach(o => {
    const key = o.long.replace(/^--/, ''); // if an option is not present and Command has a method with the same name
    // it should not be copied

    if (typeof cmd[key] !== 'function') {
      args[key] = cmd[key];
    }
  });
  return merge(cmdConfig[cmd._name], args);
}

async function run() {
  // ref https://github.com/vuejs/vue-cli/blob/v3.0.0-beta.6/packages/%40vue/cli/bin/vue.js
  // check node version
  const requiredVersion = '>8.2.0';

  if (!semver.satisfies(process.version, requiredVersion)) {
    warn(`You are using Node ${process.version}, but this version of cli ` + `requires Node ${requiredVersion}.\nPlease upgrade your Node version.`); // process.exit(1);
  } // check pkg update


  const latest = await getPkgVersion(cliPkg);
  const current = cliPkg.version;

  if (semver.gt(latest, current)) {
    log(chalk.green(`
──────────────────────────${'─'.repeat(latest.length)}──
  ✨  Update available: ${latest} ✨
──────────────────────────${'─'.repeat(latest.length)}──\n\n`));
    const {
      update
    } = await inquirer.prompt([{
      type: 'list',
      name: 'update',
      message: 'update available, you should update now',
      choices: [{
        name: 'yes',
        value: true
      }, {
        name: 'no',
        value: false
      }]
    }]);

    if (update) {
      await installPkgGlobal({
        name: cliPkg.name,
        version: latest
      });
      log();
      success(`${cliPkg.name} is updated, please re-run your last command`);
      log();
      warn(`if somehow the auto-update doesn't work for you,
- you can update manually by run command like: ${packInstallPkgGlobalCmd({
        name: cliPkg.name,
        version: latest
      })}
- or you can always contact the author
`);
      log();
      process.exit();
    }
  }

  program.version(cliPkg.version).usage('<command> [options]');

  function collect(val, memo) {
    memo.push(val);
    return memo;
  }

  program.command('init').description('init project').option('--npmClient [npm]', 'npm client').option('--pluginDirs [pluginDirs]', 'plugin dirs', collect, []).option('--pnp', 'use Yarn pnp').action(cmd => {
    const options = cleanArgs(cmd);

    require('./init')(options);
  }); // output help information on unknown commands

  program.arguments('<command>').action(cmd => {
    program.outputHelp();
    error(`  ' + Unknown command ${chalk.yellow(cmd)}.`);
  });
  program.commands.forEach(c => c.on('--help', () => {
    const options = cleanArgs(c);

    if (options.docSite) {
      info('  文档: ' + options.docSite);
    }

    log();
  })); // enhance common error messages

  const enhanceErrorMessages = (methodName, logFunc) => {
    program.Command.prototype[methodName] = function enhanceErrorMessagesForCommand(...args) {
      if (methodName === 'unknownOption' && this._allowUnknownOption) {
        return;
      }

      this.outputHelp();
      log('  ' + chalk.red(logFunc(...args)));
      process.exit(1);
    };
  };

  enhanceErrorMessages('missingArgument', argName => `Missing required argument ${chalk.yellow(`<${argName}>`)}.`);
  enhanceErrorMessages('unknownOption', optionName => `Unknown option ${chalk.yellow(optionName)}.`);
  enhanceErrorMessages('optionMissingArgument', (option, flag) => `Missing required argument for option ${chalk.yellow(option.flags)}` + (flag ? `, got ${chalk.yellow(flag)}` : ''));
  program.parse(process.argv);

  if (!process.argv.slice(2).length) {
    program.outputHelp();
  }
}

module.exports = {
  config,
  run
};