434 lines
14 KiB
JavaScript
434 lines
14 KiB
JavaScript
'use strict'
|
|
|
|
const inspect = require('util').inspect
|
|
const path = require('path')
|
|
const Parser = require('yargs-parser')
|
|
|
|
const DEFAULT_MARKER = /(^\*)|(^\$0)/
|
|
|
|
// handles parsing positional arguments,
|
|
// and populating argv with said positional
|
|
// arguments.
|
|
module.exports = function command (yargs, usage, validation, globalMiddleware) {
|
|
const self = {}
|
|
let handlers = {}
|
|
let aliasMap = {}
|
|
let defaultCommand
|
|
globalMiddleware = globalMiddleware || []
|
|
self.addHandler = function addHandler (cmd, description, builder, handler, middlewares) {
|
|
let aliases = []
|
|
handler = handler || (() => {})
|
|
middlewares = middlewares || []
|
|
globalMiddleware.push(...middlewares)
|
|
middlewares = globalMiddleware
|
|
if (Array.isArray(cmd)) {
|
|
aliases = cmd.slice(1)
|
|
cmd = cmd[0]
|
|
} else if (typeof cmd === 'object') {
|
|
let command = (Array.isArray(cmd.command) || typeof cmd.command === 'string') ? cmd.command : moduleName(cmd)
|
|
if (cmd.aliases) command = [].concat(command).concat(cmd.aliases)
|
|
self.addHandler(command, extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares)
|
|
return
|
|
}
|
|
|
|
// allow a module to be provided instead of separate builder and handler
|
|
if (typeof builder === 'object' && builder.builder && typeof builder.handler === 'function') {
|
|
self.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares)
|
|
return
|
|
}
|
|
|
|
// parse positionals out of cmd string
|
|
const parsedCommand = self.parseCommand(cmd)
|
|
|
|
// remove positional args from aliases only
|
|
aliases = aliases.map(alias => self.parseCommand(alias).cmd)
|
|
|
|
// check for default and filter out '*''
|
|
let isDefault = false
|
|
const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => {
|
|
if (DEFAULT_MARKER.test(c)) {
|
|
isDefault = true
|
|
return false
|
|
}
|
|
return true
|
|
})
|
|
|
|
// standardize on $0 for default command.
|
|
if (parsedAliases.length === 0 && isDefault) parsedAliases.push('$0')
|
|
|
|
// shift cmd and aliases after filtering out '*'
|
|
if (isDefault) {
|
|
parsedCommand.cmd = parsedAliases[0]
|
|
aliases = parsedAliases.slice(1)
|
|
cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd)
|
|
}
|
|
|
|
// populate aliasMap
|
|
aliases.forEach((alias) => {
|
|
aliasMap[alias] = parsedCommand.cmd
|
|
})
|
|
|
|
if (description !== false) {
|
|
usage.command(cmd, description, isDefault, aliases)
|
|
}
|
|
|
|
handlers[parsedCommand.cmd] = {
|
|
original: cmd,
|
|
description: description,
|
|
handler,
|
|
builder: builder || {},
|
|
middlewares: middlewares || [],
|
|
demanded: parsedCommand.demanded,
|
|
optional: parsedCommand.optional
|
|
}
|
|
|
|
if (isDefault) defaultCommand = handlers[parsedCommand.cmd]
|
|
}
|
|
|
|
self.addDirectory = function addDirectory (dir, context, req, callerFile, opts) {
|
|
opts = opts || {}
|
|
// disable recursion to support nested directories of subcommands
|
|
if (typeof opts.recurse !== 'boolean') opts.recurse = false
|
|
// exclude 'json', 'coffee' from require-directory defaults
|
|
if (!Array.isArray(opts.extensions)) opts.extensions = ['js']
|
|
// allow consumer to define their own visitor function
|
|
const parentVisit = typeof opts.visit === 'function' ? opts.visit : o => o
|
|
// call addHandler via visitor function
|
|
opts.visit = function visit (obj, joined, filename) {
|
|
const visited = parentVisit(obj, joined, filename)
|
|
// allow consumer to skip modules with their own visitor
|
|
if (visited) {
|
|
// check for cyclic reference
|
|
// each command file path should only be seen once per execution
|
|
if (~context.files.indexOf(joined)) return visited
|
|
// keep track of visited files in context.files
|
|
context.files.push(joined)
|
|
self.addHandler(visited)
|
|
}
|
|
return visited
|
|
}
|
|
require('require-directory')({ require: req, filename: callerFile }, dir, opts)
|
|
}
|
|
|
|
// lookup module object from require()d command and derive name
|
|
// if module was not require()d and no name given, throw error
|
|
function moduleName (obj) {
|
|
const mod = require('which-module')(obj)
|
|
if (!mod) throw new Error(`No command name given for module: ${inspect(obj)}`)
|
|
return commandFromFilename(mod.filename)
|
|
}
|
|
|
|
// derive command name from filename
|
|
function commandFromFilename (filename) {
|
|
return path.basename(filename, path.extname(filename))
|
|
}
|
|
|
|
function extractDesc (obj) {
|
|
for (let keys = ['describe', 'description', 'desc'], i = 0, l = keys.length, test; i < l; i++) {
|
|
test = obj[keys[i]]
|
|
if (typeof test === 'string' || typeof test === 'boolean') return test
|
|
}
|
|
return false
|
|
}
|
|
|
|
self.parseCommand = function parseCommand (cmd) {
|
|
const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ')
|
|
const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/)
|
|
const bregex = /\.*[\][<>]/g
|
|
const parsedCommand = {
|
|
cmd: (splitCommand.shift()).replace(bregex, ''),
|
|
demanded: [],
|
|
optional: []
|
|
}
|
|
splitCommand.forEach((cmd, i) => {
|
|
let variadic = false
|
|
cmd = cmd.replace(/\s/g, '')
|
|
if (/\.+[\]>]/.test(cmd) && i === splitCommand.length - 1) variadic = true
|
|
if (/^\[/.test(cmd)) {
|
|
parsedCommand.optional.push({
|
|
cmd: cmd.replace(bregex, '').split('|'),
|
|
variadic
|
|
})
|
|
} else {
|
|
parsedCommand.demanded.push({
|
|
cmd: cmd.replace(bregex, '').split('|'),
|
|
variadic
|
|
})
|
|
}
|
|
})
|
|
return parsedCommand
|
|
}
|
|
|
|
self.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap))
|
|
|
|
self.getCommandHandlers = () => handlers
|
|
|
|
self.hasDefaultCommand = () => !!defaultCommand
|
|
|
|
self.runCommand = function runCommand (command, yargs, parsed, commandIndex) {
|
|
let aliases = parsed.aliases
|
|
const commandHandler = handlers[command] || handlers[aliasMap[command]] || defaultCommand
|
|
const currentContext = yargs.getContext()
|
|
let numFiles = currentContext.files.length
|
|
const parentCommands = currentContext.commands.slice()
|
|
|
|
// what does yargs look like after the buidler is run?
|
|
let innerArgv = parsed.argv
|
|
let innerYargs = null
|
|
let positionalMap = {}
|
|
if (command) {
|
|
currentContext.commands.push(command)
|
|
currentContext.fullCommands.push(commandHandler.original)
|
|
}
|
|
if (typeof commandHandler.builder === 'function') {
|
|
// a function can be provided, which builds
|
|
// up a yargs chain and possibly returns it.
|
|
innerYargs = commandHandler.builder(yargs.reset(parsed.aliases))
|
|
// if the builder function did not yet parse argv with reset yargs
|
|
// and did not explicitly set a usage() string, then apply the
|
|
// original command string as usage() for consistent behavior with
|
|
// options object below.
|
|
if (yargs.parsed === false) {
|
|
if (shouldUpdateUsage(yargs)) {
|
|
yargs.getUsageInstance().usage(
|
|
usageFromParentCommandsCommandHandler(parentCommands, commandHandler),
|
|
commandHandler.description
|
|
)
|
|
}
|
|
innerArgv = innerYargs ? innerYargs._parseArgs(null, null, true, commandIndex) : yargs._parseArgs(null, null, true, commandIndex)
|
|
} else {
|
|
innerArgv = yargs.parsed.argv
|
|
}
|
|
|
|
if (innerYargs && yargs.parsed === false) aliases = innerYargs.parsed.aliases
|
|
else aliases = yargs.parsed.aliases
|
|
} else if (typeof commandHandler.builder === 'object') {
|
|
// as a short hand, an object can instead be provided, specifying
|
|
// the options that a command takes.
|
|
innerYargs = yargs.reset(parsed.aliases)
|
|
if (shouldUpdateUsage(innerYargs)) {
|
|
innerYargs.getUsageInstance().usage(
|
|
usageFromParentCommandsCommandHandler(parentCommands, commandHandler),
|
|
commandHandler.description
|
|
)
|
|
}
|
|
Object.keys(commandHandler.builder).forEach((key) => {
|
|
innerYargs.option(key, commandHandler.builder[key])
|
|
})
|
|
innerArgv = innerYargs._parseArgs(null, null, true, commandIndex)
|
|
aliases = innerYargs.parsed.aliases
|
|
}
|
|
|
|
if (!yargs._hasOutput()) {
|
|
positionalMap = populatePositionals(commandHandler, innerArgv, currentContext, yargs)
|
|
}
|
|
|
|
// we apply validation post-hoc, so that custom
|
|
// checks get passed populated positional arguments.
|
|
if (!yargs._hasOutput()) yargs._runValidation(innerArgv, aliases, positionalMap, yargs.parsed.error)
|
|
|
|
if (commandHandler.handler && !yargs._hasOutput()) {
|
|
yargs._setHasOutput()
|
|
if (commandHandler.middlewares.length > 0) {
|
|
const middlewareArgs = commandHandler.middlewares.reduce(function (initialObj, middleware) {
|
|
return Object.assign(initialObj, middleware(innerArgv))
|
|
}, {})
|
|
Object.assign(innerArgv, middlewareArgs)
|
|
}
|
|
const handlerResult = commandHandler.handler(innerArgv)
|
|
if (handlerResult && typeof handlerResult.then === 'function') {
|
|
handlerResult.then(
|
|
null,
|
|
(error) => yargs.getUsageInstance().fail(null, error)
|
|
)
|
|
}
|
|
}
|
|
|
|
if (command) {
|
|
currentContext.commands.pop()
|
|
currentContext.fullCommands.pop()
|
|
}
|
|
numFiles = currentContext.files.length - numFiles
|
|
if (numFiles > 0) currentContext.files.splice(numFiles * -1, numFiles)
|
|
|
|
return innerArgv
|
|
}
|
|
|
|
function shouldUpdateUsage (yargs) {
|
|
return !yargs.getUsageInstance().getUsageDisabled() &&
|
|
yargs.getUsageInstance().getUsage().length === 0
|
|
}
|
|
|
|
function usageFromParentCommandsCommandHandler (parentCommands, commandHandler) {
|
|
const c = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, '').trim() : commandHandler.original
|
|
const pc = parentCommands.filter((c) => { return !DEFAULT_MARKER.test(c) })
|
|
pc.push(c)
|
|
return `$0 ${pc.join(' ')}`
|
|
}
|
|
|
|
self.runDefaultBuilderOn = function (yargs) {
|
|
if (shouldUpdateUsage(yargs)) {
|
|
// build the root-level command string from the default string.
|
|
const commandString = DEFAULT_MARKER.test(defaultCommand.original)
|
|
? defaultCommand.original : defaultCommand.original.replace(/^[^[\]<>]*/, '$0 ')
|
|
yargs.getUsageInstance().usage(
|
|
commandString,
|
|
defaultCommand.description
|
|
)
|
|
}
|
|
const builder = defaultCommand.builder
|
|
if (typeof builder === 'function') {
|
|
builder(yargs)
|
|
} else {
|
|
Object.keys(builder).forEach((key) => {
|
|
yargs.option(key, builder[key])
|
|
})
|
|
}
|
|
}
|
|
|
|
// transcribe all positional arguments "command <foo> <bar> [apple]"
|
|
// onto argv.
|
|
function populatePositionals (commandHandler, argv, context, yargs) {
|
|
argv._ = argv._.slice(context.commands.length) // nuke the current commands
|
|
const demanded = commandHandler.demanded.slice(0)
|
|
const optional = commandHandler.optional.slice(0)
|
|
const positionalMap = {}
|
|
|
|
validation.positionalCount(demanded.length, argv._.length)
|
|
|
|
while (demanded.length) {
|
|
const demand = demanded.shift()
|
|
populatePositional(demand, argv, positionalMap)
|
|
}
|
|
|
|
while (optional.length) {
|
|
const maybe = optional.shift()
|
|
populatePositional(maybe, argv, positionalMap)
|
|
}
|
|
|
|
argv._ = context.commands.concat(argv._)
|
|
|
|
postProcessPositionals(argv, positionalMap, self.cmdToParseOptions(commandHandler.original))
|
|
|
|
return positionalMap
|
|
}
|
|
|
|
function populatePositional (positional, argv, positionalMap, parseOptions) {
|
|
const cmd = positional.cmd[0]
|
|
if (positional.variadic) {
|
|
positionalMap[cmd] = argv._.splice(0).map(String)
|
|
} else {
|
|
if (argv._.length) positionalMap[cmd] = [String(argv._.shift())]
|
|
}
|
|
}
|
|
|
|
// we run yargs-parser against the positional arguments
|
|
// applying the same parsing logic used for flags.
|
|
function postProcessPositionals (argv, positionalMap, parseOptions) {
|
|
// combine the parsing hints we've inferred from the command
|
|
// string with explicitly configured parsing hints.
|
|
const options = Object.assign({}, yargs.getOptions())
|
|
options.default = Object.assign(parseOptions.default, options.default)
|
|
options.alias = Object.assign(parseOptions.alias, options.alias)
|
|
options.array = options.array.concat(parseOptions.array)
|
|
delete options.config // don't load config when processing positionals.
|
|
|
|
const unparsed = []
|
|
Object.keys(positionalMap).forEach((key) => {
|
|
positionalMap[key].map((value) => {
|
|
unparsed.push(`--${key}`)
|
|
unparsed.push(value)
|
|
})
|
|
})
|
|
|
|
// short-circuit parse.
|
|
if (!unparsed.length) return
|
|
|
|
const parsed = Parser.detailed(unparsed, options)
|
|
|
|
if (parsed.error) {
|
|
yargs.getUsageInstance().fail(parsed.error.message, parsed.error)
|
|
} else {
|
|
// only copy over positional keys (don't overwrite
|
|
// flag arguments that were already parsed).
|
|
const positionalKeys = Object.keys(positionalMap)
|
|
Object.keys(positionalMap).forEach((key) => {
|
|
[].push.apply(positionalKeys, parsed.aliases[key])
|
|
})
|
|
|
|
Object.keys(parsed.argv).forEach((key) => {
|
|
if (positionalKeys.indexOf(key) !== -1) {
|
|
// any new aliases need to be placed in positionalMap, which
|
|
// is used for validation.
|
|
if (!positionalMap[key]) positionalMap[key] = parsed.argv[key]
|
|
argv[key] = parsed.argv[key]
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
self.cmdToParseOptions = function (cmdString) {
|
|
const parseOptions = {
|
|
array: [],
|
|
default: {},
|
|
alias: {},
|
|
demand: {}
|
|
}
|
|
|
|
const parsed = self.parseCommand(cmdString)
|
|
parsed.demanded.forEach((d) => {
|
|
const cmds = d.cmd.slice(0)
|
|
const cmd = cmds.shift()
|
|
if (d.variadic) {
|
|
parseOptions.array.push(cmd)
|
|
parseOptions.default[cmd] = []
|
|
}
|
|
cmds.forEach((c) => {
|
|
parseOptions.alias[cmd] = c
|
|
})
|
|
parseOptions.demand[cmd] = true
|
|
})
|
|
|
|
parsed.optional.forEach((o) => {
|
|
const cmds = o.cmd.slice(0)
|
|
const cmd = cmds.shift()
|
|
if (o.variadic) {
|
|
parseOptions.array.push(cmd)
|
|
parseOptions.default[cmd] = []
|
|
}
|
|
cmds.forEach((c) => {
|
|
parseOptions.alias[cmd] = c
|
|
})
|
|
})
|
|
|
|
return parseOptions
|
|
}
|
|
|
|
self.reset = () => {
|
|
handlers = {}
|
|
aliasMap = {}
|
|
defaultCommand = undefined
|
|
return self
|
|
}
|
|
|
|
// used by yargs.parse() to freeze
|
|
// the state of commands such that
|
|
// we can apply .parse() multiple times
|
|
// with the same yargs instance.
|
|
let frozen
|
|
self.freeze = () => {
|
|
frozen = {}
|
|
frozen.handlers = handlers
|
|
frozen.aliasMap = aliasMap
|
|
frozen.defaultCommand = defaultCommand
|
|
}
|
|
self.unfreeze = () => {
|
|
handlers = frozen.handlers
|
|
aliasMap = frozen.aliasMap
|
|
defaultCommand = frozen.defaultCommand
|
|
frozen = undefined
|
|
}
|
|
|
|
return self
|
|
}
|