commandpost/lib/command.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const option_1 = __importDefault(require("./option"));
const argument_1 = __importDefault(require("./argument"));
const error_1 = require("./error");
const utils = __importStar(require("./utils"));
// jsdoc, see constructor.
class Command {
    /**
     * class of command.
     * ```
     * cmd -v sub --path foo/bar buzz.txt
     *        ↑ this one!
     * ```
     * @param name name and flags pass flags pass 'foo'(sub command) or 'foo <bar>'(sub command & required argument) or 'foo [bar]'(sub command & optional argument) or 'foo <bar...>'(sub command & required variadic argument) or 'foo [bar...]'(sub command & optional variadic argument).
     * @class
     */
    constructor(name) {
        /**
         * @private
         */
        this._help = new option_1.default("-h, --help", "display help");
        /**
         * e.g. bar
         * @private
         */
        this._rest = [];
        /**
         * e.g.
         * ```
         *   git -p clone git@github.com:vvakame/dtsm.git
         *       ↑ this!
         * ```
         * @type {Array}
         */
        this.options = [];
        /**
         * e.g.
         * ```
         *   git -p clone git@github.com:vvakame/dtsm.git
         *          ↑ this!
         * ```
         * @type {Array}
         */
        this.subCommands = [];
        /**
         * parsed option values.
         * @type {any}
         */
        this.parsedOpts = {};
        /**
         * parsed option arguments.
         * @type {any}
         */
        this.parsedArgs = {};
        /**
         * unknown options.
         * @type {Array}
         */
        this.unknownOptions = [];
        let args = name.split(/\s+/);
        this.name = args.shift();
        let findOptional = false;
        let findVariadic = false;
        this.args = args.map(argStr => {
            if (findVariadic) {
                throw new error_1.CommandpostError({
                    parts: [argStr],
                    message: "parameter can not placed after variadic parameter",
                    reason: error_1.ErrorReason.ParameterCantPlacedAfterVariadic,
                });
            }
            let arg = new argument_1.default(argStr);
            if (arg.required && findOptional) {
                throw new error_1.CommandpostError({
                    parts: [argStr],
                    message: "parameter can not placed after variadic parameter",
                    reason: error_1.ErrorReason.ParameterCannPlacedAfterOptional,
                });
            }
            if (!arg.required) {
                findOptional = true;
            }
            if (arg.variadic) {
                findVariadic = true;
            }
            return arg;
        });
        this._action = () => {
            process.stdout.write(this.helpText() + "\n");
        };
    }
    /**
     * set description for this command.
     * @param desc
     * @returns {Command}
     * @method
     */
    description(desc) {
        this._description = desc;
        return this;
    }
    /**
     * set usage for this command.
     * @param usage
     * @returns {Command}
     * @method
     */
    usage(usage) {
        this._usage = usage;
        return this;
    }
    /**
     * add option for this command.
     * see {@link Option}.
     * @param flags
     * @param description
     * @param defaultValue
     * @returns {Command}
     */
    option(flags, description, defaultValue) {
        let option = new option_1.default(flags, description, defaultValue);
        this.options.push(option);
        return this;
    }
    /**
     * allow unknown option.
     * by default, An error occured if unknown option is included.
     * @param flag
     * @returns {Command}
     */
    allowUnknownOption(flag = true) {
        this._allowUnknownOption = flag;
        return this;
    }
    /**
     * add action at this command selected.
     * @param fn
     * @returns {Command}
     */
    action(fn) {
        this._action = fn;
        return this;
    }
    /**
     * create sub command.
     * @param name
     * @returns {Command<Opt2, Arg2>} new command instance
     */
    subCommand(name) {
        let command = new Command(name);
        command.parent = this;
        this.subCommands.push(command);
        return command;
    }
    /**
     * check arg is matches this command.
     * @param arg
     * @returns {boolean}
     */
    is(arg) {
        return this.name === arg;
    }
    /**
     * add help this option.
     * in general case, use default help option.
     * @param flags
     * @param description
     * @returns {Command}
     */
    help(flags, description) {
        this._help = new option_1.default(flags, description);
        return this;
    }
    /**
     * add show version option to this command.
     * @param version
     * @param flags
     * @param description
     * @returns {Command}
     */
    version(version, flags, description = "output the version number") {
        this._version = new option_1.default(flags, description);
        this._versionStr = version;
        return this;
    }
    /**
     * exec action of command.
     * this method MUST call after parse process.
     * @returns {Promise<{}>}
     */
    exec() {
        return Promise.resolve(this._action(this.parsedOpts, this.parsedArgs, this._rest));
    }
    /**
     * parse argv.
     * @param argv
     * @returns {Promise<{}>}
     */
    parse(argv) {
        return Promise
            .resolve(null)
            .then(() => {
            let rest = this._parseRawArgs(argv);
            // resolve help action
            if (this._args.some(arg => this._help.is(arg))) {
                // include help option. (help for this command
                process.stdout.write(this.helpText() + "\n");
                process.exit(0);
                return Promise.resolve({});
            }
            let subCommand;
            if (this.parent == null) {
                // only for top level (why? because I can't decide which is natural syntax between `foo help bar buzz` and `foo bar help buzz`.
                if (this._rest.some(arg => this._help.name() === arg)) {
                    // include help sub command. (help for deeper level sub command
                    if (rest[0]) {
                        subCommand = this.subCommands.filter(cmd => cmd.is(rest[0]))[0];
                        if (subCommand) {
                            process.stdout.write(subCommand.helpText() + "\n");
                            process.exit(0);
                            return Promise.resolve({});
                        }
                    }
                    // TODO raise error? pass through?
                }
            }
            // resolve version option
            if (this._version && this._args.some(arg => this._version.is(arg))) {
                process.stdout.write((this._versionStr || "unknown") + "\n");
                process.exit(0);
                return Promise.resolve({});
            }
            if (rest[0]) {
                subCommand = this.subCommands.filter(cmd => cmd.is(rest[0]))[0];
                if (subCommand) {
                    return subCommand.parse(rest.slice(1));
                }
            }
            return this.exec();
        });
    }
    /**
     * @returns {*}
     * @private
     */
    _getAncestorsAndMe() {
        if (!this.parent) {
            return [this];
        }
        else {
            return this.parent._getAncestorsAndMe().concat([this]);
        }
    }
    /**
     * @param args
     * @returns {string[]}
     * @private
     */
    _parseRawArgs(args) {
        args = args.slice(0);
        let target = [];
        let rest = [];
        for (let i = 0; i < args.length; i++) {
            let arg = args[i];
            if (arg === "--") {
                // Honor option terminator
                target = target.concat(args.slice(i));
                break;
            }
            let cmd = this.subCommands.filter(cmd => cmd.is(arg))[0];
            if (cmd) {
                rest = args.slice(i);
                break;
            }
            target.push(arg);
        }
        this._rawArgs = target.slice(0);
        this._args = this._normalize(target);
        this._rest = this._parseOptions(this._args);
        let cmds = this._getAncestorsAndMe();
        let allowUnknownOption = cmds.reverse().map(cmd => cmd._allowUnknownOption).filter(allowUnknownOption => typeof allowUnknownOption !== "undefined")[0];
        if (this.unknownOptions.length !== 0 && !allowUnknownOption) {
            let errMsg = "unknown option";
            errMsg += this.unknownOptions.length === 1 ? " " : "s ";
            errMsg += this.unknownOptions.join(", ") + "\n";
            errMsg += this.helpText();
            throw new error_1.CommandpostError({
                message: errMsg,
                reason: error_1.ErrorReason.UnknownOption,
                parts: this.unknownOptions,
                params: {
                    origin: this,
                    args,
                },
            });
        }
        if (this._matchSubCommand(rest)) {
            return rest;
        }
        this._rest = this._parseArgs(this._rest);
        return rest;
    }
    /**
     * @param rest
     * @returns {boolean}
     * @private
     */
    _matchSubCommand(rest) {
        if (rest == null || !rest[0]) {
            return false;
        }
        let subCommand = this.subCommands.filter(cmd => cmd.is(rest[0]))[0];
        return !!subCommand;
    }
    /**
     * @param args
     * @returns {string[]}
     * @private
     */
    _parseOptions(args) {
        args = args.slice(0);
        let rest = [];
        let processedOptions = [];
        while (args.length !== 0) {
            let arg = args.shift();
            if (arg === "--") {
                rest = rest.concat(args);
                break;
            }
            let opt = this.options.filter(opt => opt.is(arg))[0];
            if (!opt) {
                rest.push(arg);
                if (arg.indexOf("-") === 0 && !this._help.is(arg) && (!this._version || !this._version.is(arg))) {
                    this.unknownOptions.push(arg);
                }
                continue;
            }
            args = opt.parse(this.parsedOpts, [arg].concat(args));
            processedOptions.push(opt);
        }
        this.options
            .filter(opt => processedOptions.indexOf(opt) === -1)
            .forEach(opt => {
            let optName = utils.kebabToLowerCamelCase(opt.name());
            if (opt.required || opt.optional) {
                // string[]
                this.parsedOpts[optName] = this.parsedOpts[optName] || [];
                if (opt.defaultValue) {
                    this.parsedOpts[optName].push(opt.defaultValue);
                }
            }
            else {
                this.parsedOpts[optName] = opt.defaultValue;
            }
        });
        return rest;
    }
    /**
     * @param rest
     * @returns {string[]}
     * @private
     */
    _parseArgs(rest) {
        rest = rest.slice(0);
        this.args.forEach(argInfo => {
            rest = argInfo.parse(this.parsedArgs, rest);
        });
        return rest;
    }
    /**
     * @param args
     * @returns {string[]}
     * @private
     */
    _normalize(args) {
        let result = [];
        for (let i = 0; i < args.length; i++) {
            let arg = args[i];
            let lastOpt;
            if (0 < i) {
                lastOpt = this.options.filter(opt => opt.is(args[i - 1]))[0];
            }
            if (arg === "--") {
                // Honor option terminator
                result = result.concat(args.slice(i));
                break;
            }
            else if (lastOpt && lastOpt.required) {
                result.push(arg);
            }
            else if (/^-[^-]/.test(arg)) {
                // expand combined short hand option. "-abc" to "-a -b -c"
                arg.slice(1).split("").forEach(c => result.push("-" + c));
            }
            else if (/^--/.test(arg) && arg.indexOf("=") !== -1) {
                result.push(arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1));
            }
            else {
                result.push(arg);
            }
        }
        return result;
    }
    /**
     * generate help text.
     * @returns {string}
     */
    helpText() {
        let result = "";
        if (this._description) {
            result += this._description + "\n\n";
        }
        // usage part
        result += "  Usage: ";
        if (this._usage != null) {
            result += this._usage;
        }
        else {
            result += this._getAncestorsAndMe().map(cmd => cmd.name).join(" ") + " ";
            if (this.options.length !== 0) {
                result += "[options] ";
            }
            if (this.subCommands.length !== 0) {
                result += "[command] ";
            }
            if (this.args.length !== 0) {
                result += "[--] ";
                result += this.args.map(arg => {
                    if (arg.required) {
                        return "<" + arg.name + (arg.variadic ? "..." : "") + ">";
                    }
                    else {
                        return "[" + arg.name + (arg.variadic ? "..." : "") + "]";
                    }
                }).join(" ");
            }
        }
        result += "\n\n";
        // options part
        if (this.options.length !== 0) {
            result += "  Options:\n\n";
            let optionsMaxLength = utils.maxLength(this.options.map(opt => opt.flags));
            result += this.options.map(opt => {
                let result = "    ";
                result += utils.pad(opt.flags, optionsMaxLength);
                result += "  ";
                result += opt.description || "";
                result += "\n";
                return result;
            }).join("");
            result += "\n\n";
        }
        // sub commands part
        if (this.subCommands.length !== 0) {
            result += "  Commands:\n\n";
            let subCommandsMaxLength = utils.maxLength(this.subCommands.map(cmd => cmd.name));
            result += this.subCommands.map(cmd => {
                let result = "    ";
                result += utils.pad(cmd.name, subCommandsMaxLength);
                result += "  ";
                result += cmd._description || "";
                result += "\n";
                return result;
            }).join("");
            result += "\n\n";
        }
        return result;
    }
}
exports.default = Command;
//# sourceMappingURL=command.js.map