dingtalk-cli-pro/lib/core.js

/**
 * ----------------------------------
 * @file core.js
 * @desc Client 上下文作用域
 * @author Matrix <fangbo.fb@alibaba-inc.com>
 * @create: 2018/6
 * ----------------------------------
 */

const program = require('commander');
const path = require('path');
const util = require('./util');
const memFs = require('./util/file');
const inquirer = require('inquirer');
const EventEmitter = require('events');
const readPkgUp = require('read-pkg-up');
const findUp = require('find-up');
const makeDir = require('make-dir');
const fs = require('fs');
const _ = require('lodash');
const chalk = require('chalk');
const log = require('./util/log');
const config = require('../bin/config');
const debug = require('debug')('dingtalk-cli-pro:core');


const SYSTEM_PLUGIN_LIST = config.SYSTEM_PLUGIN_LIST

const SYS_COMMAND_LIST = [
  {
    name: 'init',
    path: path.resolve(__dirname, './commands', './init')
  },
  {
    name: 'dev',
    path: path.resolve(__dirname, './commands', './dev')
  },
  {
    name: 'must',
    path: path.resolve(__dirname, './commands', './must')
  },
  {
    name: 'test',
    path: path.resolve(__dirname, './commands', './test')
  },
  {
    name: 'publish',
    path: path.resolve(__dirname, './commands', './publish')
  },
  {
    name: 'build',
    path: path.resolve(__dirname, './commands', './build')
  }, 
  {
    name: 'generator',
    path: path.resolve(__dirname, './commands', './generator')
  }
]

const COMMAND_MAP = new Map();

class Client extends EventEmitter {
  constructor(options) {
    super(options);
    this.fs = memFs;
    this.program = program;
    this.log = log;
    this.context = {
      plugins: []
    }
  }

  prompt(question) {
    return inquirer.prompt(question)
  }

  registryCommand(cmdString) {
    if (COMMAND_MAP.has(cmdString)) {
      this.log.error(`${cmdString} command aleady has be registried, please rename it`)
      return null;
    } else {
      COMMAND_MAP.set(cmdString, 1);
      return this.program.command(cmdString)
    }
  }

  hasCommand(cmdString) {
    return COMMAND_MAP.has(cmdString);
  }
  
  executeSystemPlugin() {
    this.context.plugins =  this.context.plugins.concat(SYS_COMMAND_LIST);
    this.executePlugin(SYS_COMMAND_LIST);
  }

  loaderInstalledPlugin(root) {
    const plugins = util.getPluginNameAndPath(root) || [];
    const context = this.context;
   
    const reducePlugins = plugins.filter(plugin => {
      if (context.plugins.map(item => item.name).indexOf(plugin.name) === -1) {
        return true;
      } else {
        if (SYSTEM_PLUGIN_LIST.indexOf(plugin.name) === -1) {
          this.log.error(`${plugin.name} is registried, please rename it`)
        }
        
        return false
      }
    });

    if (reducePlugins.length) {
      context.plugins = context.plugins.concat(reducePlugins);
      this.executePlugin(reducePlugins);
    }
  }

  loaderConfigPluginDir(dir) {
    fs.readdirSync(dir).forEach(file => {
      if (/\.js?/.test(file)) {
        require(path.join(dir, file)).call(this, this);
      }
    })
  }
  loaderConfigPluginFiles(list, dir) {
    debug(`configpluinfiles: %o, ${dir}`, list);
    list.forEach(item => {
      const file = item[0];
      const options = item[1];
      if (/\.js?/.test(file)) {
        if (path.isAbsolute(file)) {
          require(file).call(this, this, options)
        } else {
          require(path.join(dir, file)).call(this, this, options);
        }
      }
    })
  }
  executePlugin(plugins){
    plugins.forEach(plugin => {
      require(plugin.path).call(this, this)
    })
  }

  pluginIsExist(name) {
    const context = this.context;
    return context.plugins.filter(plugin => plugin.name === name).length ? true : false;
  }

  /**
   * Determine the root generator name (the one who's extending Generator).
   * @return {String} The name of the root generator
   */
  rootGeneratorName() {
   
    const pkg = readPkgUp.sync().package;
    return pkg ? pkg.name : '*';
  }

  readPackageInfo() {
    return readPkgUp.sync();
  }

  /**
   * Determine the root generator version (the one who's extending Generator).
   * @return {String} The version of the root generator
   */
  rootGeneratorVersion() {
    const pkg = readPkgUp.sync().package;
    return pkg ? pkg.version : '0.0.0';
  }

  /**
   * Change the generator destination root directory.
   * This path is used to find storage, when using a file system helper method (like
   * `this.write` and `this.copy`)
   * @param  {String} rootPath new destination root path
   * @return {String}          destination root path
   */
  destinationRoot(rootPath) {
    let _destinationRoot = null
    if (typeof rootPath === 'string') {
      _destinationRoot = path.resolve(rootPath);

      if (!fs.existsSync(rootPath)) {
        makeDir.sync(rootPath);
      }

      process.chdir(rootPath);
    } else {
      _destinationRoot = path.resolve(rootPath);
    }
    

    return _destinationRoot;
  }
  /**
   * Change the generator source root directory.
   * This path is used by multiples file system methods like (`this.read` and `this.copy`)
   * @param  {String} rootPath new source root path
   * @return {String}          source root path
   */
  sourceRoot(rootPath) {
    let _sourceRoot = null;
    if (typeof rootPath === 'string') {
      _sourceRoot = path.resolve(rootPath);
    } else {
      _sourceRoot = path.resolve('./templates');
    }
    
    return _sourceRoot;
  }

  /**
   * Join a path to the source root.
   * @param  {...String} path
   * @return {String}    joined path
   */
  templatePath(rootPath, ...args) {
    let filepath = path.join.apply(path, args);

    if (!path.isAbsolute(filepath)) {
      filepath = path.join(rootPath, filepath);
    }
    
    return filepath;
  }

  /**
   * Join a path to the destination root.
   * @param  {...String} path
   * @return {String}    joined path
   */
  destinationPath(rootPath, ...args) {
    let filepath = path.join.apply(path, args);

    if (!path.isAbsolute(filepath)) {
      filepath = path.join(rootPath, filepath);
    }

    return filepath;
  }

  async createGenerator(options) {
    let config = {};
    // config default options with sourcePath, targetPath
    const _config = async () => {
      const sourcePath = this.sourceRoot(config.origin);
      const targetPath = this.destinationRoot(config.target);
      this.templatePath = this.templatePath.bind(this, sourcePath);
      this.destinationPath = this.destinationPath.bind(this, targetPath);      
    }

    const { configuring = async () => {}, writing, install = async () => {}, end = async () => {}} = options
    try {
      config = await configuring();
      
      await _config();
      await writing.call(this);
      await install.call(this);
      await end.call(this); 
    } catch(err) {
      throw err;
    }
    
    

  }
}

_.extend(Client.prototype, util);
_.extend(Client.prototype, require('./util/user'));
_.extend(Client.prototype, require('./util/install'));
_.extend(Client.prototype, require('./util/spawn-command'));
_.extend(Client.prototype, require('./util/emoji'));



module.exports = new Client({});