auto/dist/cli/args.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spread = (this && this.__spread) || function () {
    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
    return ar;
};
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;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var fs = __importStar(require("fs"));
var path = __importStar(require("path"));
var chalk_1 = __importDefault(require("chalk"));
var command_line_args_1 = __importDefault(require("command-line-args"));
var command_line_usage_1 = __importDefault(require("command-line-usage"));
var signale_1 = __importDefault(require("signale"));
var p = chalk_1.default.hex('#870048');
var y = chalk_1.default.hex('#F1A60E');
var r = chalk_1.default.hex('#C5000B');
var g = chalk_1.default.hex('#888888');
// prettier-ignore
var logo = "\n      " + y('_________') + "\n     " + p('/') + y('\\       /') + r('\\') + "                   _______ _     _ _______  _____\n    " + p('/') + "  " + y('\\_____/') + "  " + r('\\') + "                  |_____| |     |    |    |     |\n   " + p('/   /') + "     " + r('\\   \\') + "                 |     | |_____|    |    |_____|\n  " + p('/___/') + " \\\u2594\u2594\\ " + r(' \\___\\') + "\n  " + g('\\   \\') + "  \\_/  " + g('/   /') + "     ______ _______        _______ _______ _______ _______\n   " + g('\\   \\') + "     " + g('/   /') + "     |_____/ |______ |      |______ |_____| |______ |______\n    " + g('\\   ▔▔▔▔▔   /') + "      |    \\_ |______ |_____ |______ |     | ______| |______\n     " + g('\\         /') + "\n      " + g('▔▔▔▔▔▔▔▔▔ ') + "\n";
var help = {
    name: 'help',
    alias: 'h',
    type: Boolean
};
var version = {
    name: 'version',
    alias: 'V',
    type: Boolean,
    description: "Display auto's version"
};
var mainDefinitions = [
    { name: 'command', type: String, defaultOption: true },
    __assign({}, help, { description: 'Display the help output. Works on each command as well' }),
    version
];
var defaultOptions = [
    __assign({}, help, { description: 'Display the help output for the command', group: 'misc' }),
    {
        name: 'verbose',
        alias: 'v',
        type: Boolean,
        description: 'Show some more logs',
        group: 'misc'
    },
    {
        name: 'very-verbose',
        alias: 'w',
        type: Boolean,
        description: 'Show a lot more logs',
        group: 'misc'
    },
    {
        name: 'repo',
        type: String,
        description: 'The repo to set the status on. Defaults to looking in the package definition for the platform',
        group: 'misc'
    },
    {
        name: 'owner',
        type: String,
        description: 'The owner of the GitHub repo. Defaults to reading from the package definition for the platform',
        group: 'misc'
    },
    {
        name: 'github-api',
        type: String,
        description: 'GitHub API to use',
        group: 'misc'
    },
    {
        name: 'plugins',
        type: String,
        multiple: true,
        description: 'Plugins to load auto with. (defaults to just npm)',
        group: 'misc'
    }
];
var pr = {
    name: 'pr',
    type: Number,
    description: 'The pull request number you want the labels of',
    group: 'main'
};
var dryRun = {
    name: 'dry-run',
    alias: 'd',
    type: Boolean,
    description: 'Report what command will do but do not actually do anything',
    group: 'main'
};
var url = {
    name: 'url',
    type: String,
    description: 'URL to associate with this status',
    group: 'main'
};
var noVersionPrefix = {
    name: 'no-version-prefix',
    type: Boolean,
    description: "Use the version as the tag without the 'v' prefix",
    group: 'main'
};
var jira = {
    name: 'jira',
    type: String,
    description: 'Jira base URL',
    group: 'main'
};
var name = {
    name: 'name',
    type: String,
    description: 'Git name to commit and release with. Defaults to package definition for the platform',
    group: 'main'
};
var email = {
    name: 'email',
    type: String,
    description: 'Git email to commit with. Defaults to package definition for the platform',
    group: 'main'
};
var context = {
    name: 'context',
    type: String,
    description: 'A string label to differentiate this status from others',
    group: 'main'
};
var message = {
    name: 'message',
    group: 'main',
    type: String,
    alias: 'm'
};
var skipReleaseLabels = {
    name: 'skip-release-labels',
    type: String,
    group: 'main',
    multiple: true,
    description: "Labels that will not create a release. Defaults to just 'skip-release'"
};
var commands = [
    {
        name: 'init',
        summary: 'Interactive setup for most configurable options',
        examples: ['{green $} auto init'],
        options: [
            {
                name: 'only-labels',
                type: Boolean,
                group: 'main',
                description: 'Only run init for the labels. As most other options are for advanced users'
            },
            dryRun
        ]
    },
    {
        name: 'create-labels',
        summary: "Create your project's labels on github. If labels exist it will update them.",
        examples: ['{green $} auto create-labels'],
        options: __spread(defaultOptions, [dryRun])
    },
    {
        name: 'label',
        summary: 'Get the labels for a pull request',
        options: __spread([
            __assign({}, pr, { description: pr.description + " (defaults to last merged PR)" })
        ], defaultOptions),
        examples: ['{green $} auto label --pr 123']
    },
    {
        name: 'pr-check',
        summary: 'Check that a pull request has a SemVer label',
        require: ['pr', 'url'],
        options: __spread([
            pr,
            url,
            dryRun,
            __assign({}, context, { defaultValue: 'ci/pr-check' }),
            skipReleaseLabels
        ], defaultOptions),
        examples: [
            '{green $} auto pr-check --pr 32 --url http://your-ci.com/build/123'
        ]
    },
    {
        name: 'pr',
        summary: 'Set the status on a PR commit',
        require: ['state', 'url', 'description', 'context'],
        options: __spread([
            {
                name: 'sha',
                type: String,
                group: 'main',
                description: 'Specify a custom git sha. Defaults to the HEAD for a git repo in the current repository'
            },
            __assign({}, pr, { description: 'PR to set the status on' }),
            url,
            {
                name: 'state',
                type: String,
                group: 'main',
                description: "State of the PR. ['pending', 'success', 'error', 'failure']"
            },
            {
                name: 'description',
                type: String,
                group: 'main',
                description: 'A description of the status'
            },
            {
                name: 'context',
                type: String,
                group: 'main',
                description: 'A string label to differentiate this status from others'
            },
            dryRun
        ], defaultOptions),
        examples: [
            "{green $} auto pr \\\\ \n   --pr 32 \\\\ \n   --state pending \\\\ \n   --description \"Build still running...\" \\\\ \n   --context build-check"
        ]
    },
    {
        name: 'version',
        summary: 'Get the semantic version bump for the given changes.',
        options: __spread([
            {
                name: 'only-publish-with-release-label',
                type: Boolean,
                description: "Only bump version if 'release' label is on pull request",
                group: 'main'
            },
            skipReleaseLabels
        ], defaultOptions),
        examples: [
            {
                desc: 'Get the new version using the last release to head',
                example: '{green $} auto version'
            },
            {
                desc: 'Skip releases with multiple labels',
                example: '{green $} auto version --skip-release-labels documentation CI'
            }
        ]
    },
    {
        name: 'changelog',
        summary: "Prepend release notes to 'CHANGELOG.md'",
        options: __spread([
            dryRun,
            noVersionPrefix,
            name,
            email,
            jira,
            {
                name: 'from',
                type: String,
                group: 'main',
                description: 'Tag to start changelog generation on. Defaults to latest tag.'
            },
            {
                name: 'to',
                type: String,
                group: 'main',
                description: 'Tag to end changelog generation on. Defaults to HEAD.'
            },
            __assign({}, message, { description: "Message to commit the changelog with. Defaults to 'Update CHANGELOG.md [skip ci]'" })
        ], defaultOptions),
        examples: [
            {
                desc: 'Generate a changelog from the last release to head',
                example: '{green $} auto changelog'
            },
            {
                desc: 'Generate a changelog across specific versions',
                example: '{green $} auto changelog --from v0.20.1 --to v0.21.0'
            }
        ]
    },
    {
        name: 'release',
        summary: 'Auto-generate a github release',
        options: __spread([
            dryRun,
            noVersionPrefix,
            name,
            email,
            jira,
            {
                name: 'use-version',
                type: String,
                group: 'main',
                description: 'Version number to publish as. Defaults to reading from the package definition for the platform.'
            },
            {
                name: 'slack',
                alias: 's',
                type: String,
                group: 'main',
                description: 'Url to post a slack message to about the release. Make sure the SLACK_TOKEN environment variable is set.'
            }
        ], defaultOptions),
        examples: ['{green $} auto release']
    },
    {
        name: 'comment',
        summary: 'Comment on a pull request with a markdown message',
        require: ['pr', 'message'],
        options: __spread([
            pr,
            context,
            __assign({}, message, { description: 'Message to post to comment' }),
            dryRun
        ], defaultOptions),
        examples: [
            '{green $} auto comment --pr 123 --comment "# Why you\'re wrong..."'
        ]
    },
    {
        name: 'shipit',
        summary: 'Run the full `auto` release pipeline. Detects if in a lerna project',
        examples: ['{green $} auto shipit'],
        options: __spread(defaultOptions, [dryRun])
    }
];
function filterCommands(allCommands, include) {
    return allCommands
        .filter(function (command) { return include.includes(command.name); })
        .map(function (command) { return ({
        name: command.name,
        summary: command.summary
    }); });
}
function printRootHelp() {
    var options = __spread([
        __assign({}, version, { group: 'misc' })
    ], mainDefinitions, defaultOptions);
    options.forEach(function (option) {
        styleTypes({}, option);
    });
    var usage = command_line_usage_1.default([
        {
            content: logo.replace(/\\/g, '\\\\'),
            raw: true
        },
        {
            content: 'Generate releases based on semantic version labels on pull requests'
        },
        {
            header: 'Synopsis',
            content: '$ auto <command> <options>'
        },
        {
            header: 'Setup Commands',
            content: filterCommands(commands, ['init', 'create-labels'])
        },
        {
            header: 'Release Commands',
            content: filterCommands(commands, [
                'release',
                'version',
                'changelog',
                'shipit'
            ])
        },
        {
            header: 'Pull Request Interaction Commands',
            content: filterCommands(commands, ['label', 'pr-check', 'pr', 'comment'])
        },
        {
            header: 'Global Options',
            optionList: options,
            group: 'misc'
        }
    ]);
    console.log(usage);
}
function printCommandHelp(command) {
    var sections = [
        {
            header: "auto " + command.name,
            content: command.summary
        }
    ];
    if (command.options) {
        var hasLocalOptions = command.options.filter(function (option) { return option.group === 'main'; });
        if (hasLocalOptions.length > 0) {
            sections.push({
                header: 'Options',
                optionList: command.options,
                group: 'main'
            });
        }
        var hasGlobalOptions = command.options.filter(function (option) { return option.group === 'misc'; });
        if (hasGlobalOptions.length > 0) {
            sections.push({
                header: 'Global Options',
                optionList: command.options,
                group: 'misc'
            });
        }
    }
    sections.push({
        header: 'Examples',
        content: command.examples,
        raw: command.name === 'pr'
    });
    console.log(command_line_usage_1.default(sections));
}
function printVersion() {
    var packagePath = path.join(__dirname, '../../package.json');
    var packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
    console.log("v" + packageJson.version);
}
function styleTypes(command, option) {
    var isRequired = command.require && command.require.includes(option.name);
    if (isRequired && option.type === Number) {
        option.typeLabel =
            '{rgb(173, 216, 230) {underline number}} [{rgb(254,91,92) required}]';
    }
    else if (option.type === Number) {
        option.typeLabel = '{rgb(173, 216, 230) {underline number}}';
    }
    if (isRequired && option.type === String) {
        option.typeLabel =
            '{rgb(173, 216, 230) {underline string}} [{rgb(254,91,92) required}]';
    }
    else if (option.multiple && option.type === String) {
        option.typeLabel = '{rgb(173, 216, 230) {underline string[]}}';
    }
    else if (option.type === String) {
        option.typeLabel = '{rgb(173, 216, 230) {underline string}}';
    }
}
function parseArgs(testArgs) {
    var mainOptions = command_line_args_1.default(mainDefinitions, {
        stopAtFirstUnknown: true,
        camelCase: true,
        argv: testArgs
    });
    var argv = mainOptions._unknown || [];
    var command = commands.find(function (c) { return c.name === mainOptions.command; });
    if (!command && mainOptions.version) {
        printVersion();
        return;
    }
    if (!command) {
        printRootHelp();
        return;
    }
    var options = command.options || [];
    options.forEach(function (option) {
        styleTypes(command, option);
    });
    if (mainOptions.help) {
        printCommandHelp(command);
        return;
    }
    var autoOptions = __assign({ command: mainOptions.command }, command_line_args_1.default(options, { argv: argv, camelCase: true })._all);
    if (command.require) {
        var missing = command.require
            .filter(function (option) {
            return !autoOptions.hasOwnProperty(option) ||
                // tslint:disable-next-line strict-type-predicates
                autoOptions[option] === null;
        })
            .map(function (option) { return "--" + option; });
        var multiple = missing.length > 1;
        if (missing.length > 0) {
            printCommandHelp(command);
            signale_1.default.error("Missing required flag" + (multiple ? 's' : '') + ": " + missing.join(', '));
            return process.exit(1);
        }
    }
    return autoOptions;
}
exports.default = parseArgs;
//# sourceMappingURL=args.js.map