jmms/bin/yo.js

Jmms cli tools, Jmms is a java meta-micro-service framework

const meow    = require('meow');
const chalk   = require('chalk');
const log     = require('../generators/log');
const yeoman  = require('yeoman-environment');
const table   = require('text-table');
const metas   = require('../generators/metas');
const pkg     = require('../package.json');
const fs      = require('fs');
const env     = yeoman.createEnv();
const binName = Object.keys(pkg.bin)[0];

const init = () => {

    Object.keys(metas).forEach((generator) => {
        const meta = metas[generator];
        meta.generator = generator;
        if(!meta.path) {
            meta.path = generator;
        }

        //set all option's name
        if(meta.opts) {
            Object.keys(meta.opts).forEach(key=>{
                meta.opts[key].name = key;
            });
        }   
        
        if(meta.childs && Object.keys(meta.childs).length > 0) {
            //register self.
            if(meta.self) {
                env.register(require.resolve(`../generators/${meta.path}`), `${binName}:${meta.generator}`);
            }

            //register sub generators
            Object.keys(meta.childs).forEach((subGenerator) => {
                const child = meta.childs[subGenerator];
                child.generator = subGenerator;
                if(!child.path) {
                    child.path = child.generator;
                }

                //set option's name
                if(child.opts) {
                    Object.keys(child.opts).forEach(key=>{
                        child.opts[key].name = key;
                    });
                } 

                //register sub generator
                const path = require.resolve(`../generators/${meta.path}/${child.path}`)
                env.register(path,`${binName}:${meta.generator}:${child.generator}`);
            });

            //register parent generator is exists.
            if(fs.existsSync('../generators/' + meta.generator + '/index.js')) {
                env.register(require.resolve(`../generators/${meta.path}`), `${binName}:${meta.generator}`);    
            }
        }else {
            //register generator
            env.register(require.resolve(`../generators/${meta.path}`), `${binName}:${meta.generator}`);
        }     
    });

    return this;
}

const printSubCommandsAndExit = (command, childs) => {
    const rows = [];

    Object.keys(childs).forEach(key => {
        const child = childs[key];
        rows.push([
            '',
            '',
            command + ' ' + child.generator,
            '- ' + child.desc
        ])
    }); 

    log.info('\n  Sub Commands:\n')
    log.info(table(rows) + '\n');
    process.exit(0);
}

/** Run the generator command */
const run = (meta, help) => {
    const argv = process.argv.slice(3);
    const info = meow({help:false, pkg, argv});

    var args = info.input;
    var opts = info.flags;
    
    var generator;
    if(meta.childs && Object.keys(meta.childs).length > 0) {
        if(args.length == 0) {
            if(meta.self) {
                generator = meta.generator;
            }else {
                if(!help) {
                    log.error(`Missing sub command of ${chalk.yellow(meta.generator)}`);
                }
                printSubCommandsAndExit(meta.generator, meta.childs);    
            }
        }else {
            const subGenerator = args[0];
            const child = meta.childs[subGenerator];
            if(!child) {
                log.error(`${chalk.yellow(subGenerator)} is not a known sub command of ${chalk.yellow(meta.generator)}`);
                printSubCommandsAndExit(meta.generator, meta.childs);
            }

            generator = meta.generator + ':' + child.generator;
            meta      = child;
            args      = args.slice(1);       
        }
    }else {
        generator = meta.generator;
    }

    const yoCommand  = binName + ':' + generator;
    const cliCommand = yoCommand.replace(new RegExp(':', 'g'), ' ');  

    if(help) {
        opts.help = true;
    }

    opts.meta = meta;
    opts.args = args;
    opts.generator  = generator;
    opts.cliCommand = cliCommand;

    if(opts.args.length > 0) {
        env.run(`${yoCommand} ${opts.args.join(' ')}`, opts);
    }else {
        env.run(`${yoCommand}`, opts);
    }
}

/* Converts the yo generator to commander's command name */
const toCommandName = (generator, meta) => {
    var cmd = generator;

    /*
    if(meta.arg) {
        var required = meta.arg.required == true;
        if(required) {
            cmd = cmd + ' <' + meta.arg.name + '>';
        }else{
            cmd = cmd + ' [' + meta.arg.name + ']';
        }
    }
    */

    //cmd = cmd + ' [options]';

    return cmd;
}

/**
 * Converts the yo option to commander's option flags.
 * 
 * Examples:
 *  .option('-C, --chdir <path>', 'change the working directory')
 *  .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
 *  .option('-T, --no-tests', 'ignore test hook')
 */ 
const toCommandOptionFlags = (opt) => {
    var s = '';

    if(opt.alias) {
        s += `-${opt.alias}, `;
    }else {
        s += '  , ';
    }

    s += `--${opt.name}`;

    return s;
}

/**
 * Converts the yo option's desc to commander option's desc .
 */ 
const toCommandOptionDesc = (opt) => {
    var s = '';

    if(opt.desc) {
        s += opt.desc;

        if(opt.type) {
            s += ', type {' + opt.type + '}';
        }

        if(opt.defaults) {
            s += ', defaults ' + opt.defaults;
        }
    }

    return s;
}

/* Converts the commander's args to yo's generator options 
const toGeneratorOptions = (meta, args, argv) => {
    var options = meow({help:false, pkg, argv}).flags

    const arg = meta.arg;
    if(arg) {
        if(args) {
            options[arg.name] = args;
        }else if(arg.defaults) {
            options[arg.name] = arg.defaults;
        }
    }
    
    options.meta = meta;
    return options;
}
*/

module.exports = {
    init,
    metas,
    toCommandName,
    toCommandOptionFlags,
    toCommandOptionDesc,
    //toGeneratorOptions,
    run
}