aboutsummaryrefslogtreecommitdiff
path: root/node_modules/yargs/lib
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/yargs/lib')
-rw-r--r--node_modules/yargs/lib/apply-extends.js21
-rw-r--r--node_modules/yargs/lib/argsert.js30
-rw-r--r--node_modules/yargs/lib/assign.js15
-rw-r--r--node_modules/yargs/lib/command.js309
-rw-r--r--node_modules/yargs/lib/completion.js51
-rw-r--r--node_modules/yargs/lib/levenshtein.js10
-rw-r--r--node_modules/yargs/lib/obj-filter.js7
-rw-r--r--node_modules/yargs/lib/usage.js299
-rw-r--r--node_modules/yargs/lib/validation.js239
-rw-r--r--node_modules/yargs/lib/yerror.js1
10 files changed, 543 insertions, 439 deletions
diff --git a/node_modules/yargs/lib/apply-extends.js b/node_modules/yargs/lib/apply-extends.js
index 5fc69fab1..3005848e3 100644
--- a/node_modules/yargs/lib/apply-extends.js
+++ b/node_modules/yargs/lib/apply-extends.js
@@ -1,13 +1,14 @@
-var fs = require('fs')
-var path = require('path')
-var assign = require('./assign')
-var YError = require('./yerror')
-var previouslyVisitedConfigs = []
+'use strict'
+const fs = require('fs')
+const path = require('path')
+const YError = require('./yerror')
+
+let previouslyVisitedConfigs = []
function checkForCircularExtends (path) {
if (previouslyVisitedConfigs.indexOf(path) > -1) {
- throw new YError("Circular extended configurations: '" + path + "'.")
+ throw new YError(`Circular extended configurations: '${path}'.`)
}
}
@@ -16,12 +17,12 @@ function getPathToDefaultConfig (cwd, pathToExtend) {
}
function applyExtends (config, cwd) {
- var defaultConfig = {}
+ let defaultConfig = {}
if (config.hasOwnProperty('extends')) {
if (typeof config.extends !== 'string') return defaultConfig
- var isPath = /\.json$/.test(config.extends)
- var pathToDefault = null
+ const isPath = /\.json$/.test(config.extends)
+ let pathToDefault = null
if (!isPath) {
try {
pathToDefault = require.resolve(config.extends)
@@ -46,7 +47,7 @@ function applyExtends (config, cwd) {
previouslyVisitedConfigs = []
- return assign(defaultConfig, config)
+ return Object.assign({}, defaultConfig, config)
}
module.exports = applyExtends
diff --git a/node_modules/yargs/lib/argsert.js b/node_modules/yargs/lib/argsert.js
index d3e72fce5..ed1d59871 100644
--- a/node_modules/yargs/lib/argsert.js
+++ b/node_modules/yargs/lib/argsert.js
@@ -1,20 +1,21 @@
+'use strict'
const command = require('./command')()
const YError = require('./yerror')
const positionName = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']
-module.exports = function (expected, callerArguments, length) {
+module.exports = function argsert (expected, callerArguments, length) {
// TODO: should this eventually raise an exception.
try {
// preface the argument description with "cmd", so
// that we can run it through yargs' command parser.
- var position = 0
- var parsed = {demanded: [], optional: []}
+ let position = 0
+ let parsed = {demanded: [], optional: []}
if (typeof expected === 'object') {
length = callerArguments
callerArguments = expected
} else {
- parsed = command.parseCommand('cmd ' + expected)
+ parsed = command.parseCommand(`cmd ${expected}`)
}
const args = [].slice.call(callerArguments)
@@ -22,33 +23,27 @@ module.exports = function (expected, callerArguments, length) {
length = length || args.length
if (length < parsed.demanded.length) {
- throw new YError('Not enough arguments provided. Expected ' + parsed.demanded.length +
- ' but received ' + args.length + '.')
+ throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`)
}
const totalCommands = parsed.demanded.length + parsed.optional.length
if (length > totalCommands) {
- throw new YError('Too many arguments provided. Expected max ' + totalCommands +
- ' but received ' + length + '.')
+ throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`)
}
- parsed.demanded.forEach(function (demanded) {
+ parsed.demanded.forEach((demanded) => {
const arg = args.shift()
const observedType = guessType(arg)
- const matchingTypes = demanded.cmd.filter(function (type) {
- return type === observedType || type === '*'
- })
+ const matchingTypes = demanded.cmd.filter(type => type === observedType || type === '*')
if (matchingTypes.length === 0) argumentTypeError(observedType, demanded.cmd, position, false)
position += 1
})
- parsed.optional.forEach(function (optional) {
+ parsed.optional.forEach((optional) => {
if (args.length === 0) return
const arg = args.shift()
const observedType = guessType(arg)
- const matchingTypes = optional.cmd.filter(function (type) {
- return type === observedType || type === '*'
- })
+ const matchingTypes = optional.cmd.filter(type => type === observedType || type === '*')
if (matchingTypes.length === 0) argumentTypeError(observedType, optional.cmd, position, true)
position += 1
})
@@ -67,6 +62,5 @@ function guessType (arg) {
}
function argumentTypeError (observedType, allowedTypes, position, optional) {
- throw new YError('Invalid ' + (positionName[position] || 'manyith') + ' argument.' +
- ' Expected ' + allowedTypes.join(' or ') + ' but received ' + observedType + '.')
+ throw new YError(`Invalid ${positionName[position] || 'manyith'} argument. Expected ${allowedTypes.join(' or ')} but received ${observedType}.`)
}
diff --git a/node_modules/yargs/lib/assign.js b/node_modules/yargs/lib/assign.js
deleted file mode 100644
index 7d5a3cef2..000000000
--- a/node_modules/yargs/lib/assign.js
+++ /dev/null
@@ -1,15 +0,0 @@
-// lazy Object.assign logic that only works for merging
-// two objects; eventually we should replace this with Object.assign.
-module.exports = function assign (defaults, configuration) {
- var o = {}
- configuration = configuration || {}
-
- Object.keys(defaults).forEach(function (k) {
- o[k] = defaults[k]
- })
- Object.keys(configuration).forEach(function (k) {
- o[k] = configuration[k]
- })
-
- return o
-}
diff --git a/node_modules/yargs/lib/command.js b/node_modules/yargs/lib/command.js
index 3567cf953..5ac848e21 100644
--- a/node_modules/yargs/lib/command.js
+++ b/node_modules/yargs/lib/command.js
@@ -1,27 +1,29 @@
-const path = require('path')
+'use strict'
+
const inspect = require('util').inspect
-const camelCase = require('camelcase')
+const path = require('path')
+const Parser = require('yargs-parser')
-const DEFAULT_MARKER = '*'
+const DEFAULT_MARKER = /(^\*)|(^\$0)/
// handles parsing positional arguments,
// and populating argv with said positional
// arguments.
-module.exports = function (yargs, usage, validation) {
+module.exports = function command (yargs, usage, validation) {
const self = {}
- var handlers = {}
- var aliasMap = {}
- var defaultCommand
- self.addHandler = function (cmd, description, builder, handler) {
- var aliases = []
- handler = handler || function () {}
+ let handlers = {}
+ let aliasMap = {}
+ let defaultCommand
+ self.addHandler = function addHandler (cmd, description, builder, handler) {
+ let aliases = []
+ handler = handler || (() => {})
if (Array.isArray(cmd)) {
aliases = cmd.slice(1)
cmd = cmd[0]
} else if (typeof cmd === 'object') {
- var command = (Array.isArray(cmd.command) || typeof cmd.command === 'string') ? cmd.command : moduleName(cmd)
+ 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)
return
@@ -34,34 +36,22 @@ module.exports = function (yargs, usage, validation) {
}
// parse positionals out of cmd string
- var parsedCommand = self.parseCommand(cmd)
+ const parsedCommand = self.parseCommand(cmd)
// remove positional args from aliases only
- aliases = aliases.map(function (alias) {
- return self.parseCommand(alias).cmd
- })
+ aliases = aliases.map(alias => self.parseCommand(alias).cmd)
// check for default and filter out '*''
- var isDefault = false
- var parsedAliases = [parsedCommand.cmd].concat(aliases).filter(function (c) {
- if (c === DEFAULT_MARKER) {
+ let isDefault = false
+ const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => {
+ if (DEFAULT_MARKER.test(c)) {
isDefault = true
return false
}
return true
})
-
- // short-circuit if default with no aliases
- if (isDefault && parsedAliases.length === 0) {
- defaultCommand = {
- original: cmd.replace(DEFAULT_MARKER, '').trim(),
- handler: handler,
- builder: builder || {},
- demanded: parsedCommand.demanded,
- optional: parsedCommand.optional
- }
- return
- }
+ // standardize on $0 for default command.
+ if (parsedAliases.length === 0 && isDefault) parsedAliases.push('$0')
// shift cmd and aliases after filtering out '*'
if (isDefault) {
@@ -71,7 +61,7 @@ module.exports = function (yargs, usage, validation) {
}
// populate aliasMap
- aliases.forEach(function (alias) {
+ aliases.forEach((alias) => {
aliasMap[alias] = parsedCommand.cmd
})
@@ -81,7 +71,8 @@ module.exports = function (yargs, usage, validation) {
handlers[parsedCommand.cmd] = {
original: cmd,
- handler: handler,
+ description: description,
+ handler,
builder: builder || {},
demanded: parsedCommand.demanded,
optional: parsedCommand.optional
@@ -90,16 +81,16 @@ module.exports = function (yargs, usage, validation) {
if (isDefault) defaultCommand = handlers[parsedCommand.cmd]
}
- self.addDirectory = function (dir, context, req, callerFile, opts) {
+ 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 : function (o) { return o }
+ const parentVisit = typeof opts.visit === 'function' ? opts.visit : o => o
// call addHandler via visitor function
- opts.visit = function (obj, joined, filename) {
+ opts.visit = function visit (obj, joined, filename) {
const visited = parentVisit(obj, joined, filename)
// allow consumer to skip modules with their own visitor
if (visited) {
@@ -119,7 +110,7 @@ module.exports = function (yargs, usage, validation) {
// 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))
+ if (!mod) throw new Error(`No command name given for module: ${inspect(obj)}`)
return commandFromFilename(mod.filename)
}
@@ -129,66 +120,62 @@ module.exports = function (yargs, usage, validation) {
}
function extractDesc (obj) {
- for (var keys = ['describe', 'description', 'desc'], i = 0, l = keys.length, test; i < l; i++) {
+ 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 (cmd) {
- var extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ')
- var splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/)
- var bregex = /\.*[\][<>]/g
- var parsedCommand = {
+ 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(function (cmd, i) {
- var variadic = false
+ 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: variadic
+ variadic
})
} else {
parsedCommand.demanded.push({
cmd: cmd.replace(bregex, '').split('|'),
- variadic: variadic
+ variadic
})
}
})
return parsedCommand
}
- self.getCommands = function () {
- return Object.keys(handlers).concat(Object.keys(aliasMap))
- }
+ self.getCommands = () => Object.keys(handlers).concat(Object.keys(aliasMap))
- self.getCommandHandlers = function () {
- return handlers
- }
+ self.getCommandHandlers = () => handlers
- self.hasDefaultCommand = function () {
- return !!defaultCommand
- }
+ self.hasDefaultCommand = () => !!defaultCommand
- self.runCommand = function (command, yargs, parsed, commandIndex) {
- var aliases = parsed.aliases
- var commandHandler = handlers[command] || handlers[aliasMap[command]] || defaultCommand
- var currentContext = yargs.getContext()
- var numFiles = currentContext.files.length
- var parentCommands = currentContext.commands.slice()
+ 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?
- var innerArgv = parsed.argv
- var innerYargs = null
- var positionalMap = {}
-
- if (command) currentContext.commands.push(command)
+ 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.
@@ -198,8 +185,11 @@ module.exports = function (yargs, usage, validation) {
// original command string as usage() for consistent behavior with
// options object below.
if (yargs.parsed === false) {
- if (typeof yargs.getUsageInstance().getUsage() === 'undefined') {
- yargs.usage('$0 ' + (parentCommands.length ? parentCommands.join(' ') + ' ' : '') + commandHandler.original)
+ 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 {
@@ -212,8 +202,13 @@ module.exports = function (yargs, usage, validation) {
// as a short hand, an object can instead be provided, specifying
// the options that a command takes.
innerYargs = yargs.reset(parsed.aliases)
- innerYargs.usage('$0 ' + (parentCommands.length ? parentCommands.join(' ') + ' ' : '') + commandHandler.original)
- Object.keys(commandHandler.builder).forEach(function (key) {
+ 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)
@@ -233,81 +228,163 @@ module.exports = function (yargs, usage, validation) {
commandHandler.handler(innerArgv)
}
- if (command) currentContext.commands.pop()
+ 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
- var demanded = commandHandler.demanded.slice(0)
- var optional = commandHandler.optional.slice(0)
- var positionalMap = {}
+ const demanded = commandHandler.demanded.slice(0)
+ const optional = commandHandler.optional.slice(0)
+ const positionalMap = {}
validation.positionalCount(demanded.length, argv._.length)
while (demanded.length) {
- var demand = demanded.shift()
- populatePositional(demand, argv, yargs, positionalMap)
+ const demand = demanded.shift()
+ populatePositional(demand, argv, positionalMap)
}
while (optional.length) {
- var maybe = optional.shift()
- populatePositional(maybe, argv, yargs, positionalMap)
+ const maybe = optional.shift()
+ populatePositional(maybe, argv, positionalMap)
}
argv._ = context.commands.concat(argv._)
+
+ postProcessPositionals(argv, positionalMap, self.cmdToParseOptions(commandHandler.original))
+
return positionalMap
}
- // populate a single positional argument and its
- // aliases onto argv.
- function populatePositional (positional, argv, yargs, positionalMap) {
- // "positional" consists of the positional.cmd, an array representing
- // the positional's name and aliases, and positional.variadic
- // indicating whether or not it is a variadic array.
- var variadics = null
- var value = null
- for (var i = 0, cmd; (cmd = positional.cmd[i]) !== undefined; i++) {
- if (positional.variadic) {
- if (variadics) argv[cmd] = variadics.slice(0)
- else argv[cmd] = variadics = argv._.splice(0)
- } else {
- if (!value && !argv._.length) continue
- if (value) argv[cmd] = value
- else argv[cmd] = value = argv._.shift()
- }
- positionalMap[cmd] = true
- postProcessPositional(yargs, argv, cmd)
- addCamelCaseExpansions(argv, cmd)
+ 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())]
}
}
- // TODO move positional arg logic to yargs-parser and remove this duplication
- function postProcessPositional (yargs, argv, key) {
- var coerce = yargs.getOptions().coerce[key]
- if (typeof coerce === 'function') {
- try {
- argv[key] = coerce(argv[key])
- } catch (err) {
- yargs.getUsageInstance().fail(err.message, err)
- }
+ // 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)
+
+ 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) {
+ argv[key] = parsed.argv[key]
+ }
+ })
}
}
- function addCamelCaseExpansions (argv, option) {
- if (/-/.test(option)) {
- const cc = camelCase(option)
- if (typeof argv[option] === 'object') argv[cc] = argv[option].slice(0)
- else argv[cc] = argv[option]
+ 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 = function () {
+ self.reset = () => {
handlers = {}
aliasMap = {}
defaultCommand = undefined
@@ -318,14 +395,14 @@ module.exports = function (yargs, usage, validation) {
// the state of commands such that
// we can apply .parse() multiple times
// with the same yargs instance.
- var frozen
- self.freeze = function () {
+ let frozen
+ self.freeze = () => {
frozen = {}
frozen.handlers = handlers
frozen.aliasMap = aliasMap
frozen.defaultCommand = defaultCommand
}
- self.unfreeze = function () {
+ self.unfreeze = () => {
handlers = frozen.handlers
aliasMap = frozen.aliasMap
defaultCommand = frozen.defaultCommand
diff --git a/node_modules/yargs/lib/completion.js b/node_modules/yargs/lib/completion.js
index 5cd9a18a0..ad6969a2d 100644
--- a/node_modules/yargs/lib/completion.js
+++ b/node_modules/yargs/lib/completion.js
@@ -1,16 +1,17 @@
+'use strict'
const fs = require('fs')
const path = require('path')
// add bash completions to your
// yargs-powered applications.
-module.exports = function (yargs, usage, command) {
+module.exports = function completion (yargs, usage, command) {
const self = {
completionKey: 'get-yargs-completions'
}
// get a list of completion commands.
// 'args' is the array of strings from the line to be completed
- self.getCompletion = function (args, done) {
+ self.getCompletion = function getCompletion (args, done) {
const completions = []
const current = args.length ? args[args.length - 1] : ''
const argv = yargs.parse(args, true)
@@ -20,14 +21,14 @@ module.exports = function (yargs, usage, command) {
// to completion().
if (completionFunction) {
if (completionFunction.length < 3) {
- var result = completionFunction(current, argv)
+ const result = completionFunction(current, argv)
// promise based completion function.
if (typeof result.then === 'function') {
- return result.then(function (list) {
- process.nextTick(function () { done(list) })
- }).catch(function (err) {
- process.nextTick(function () { throw err })
+ return result.then((list) => {
+ process.nextTick(() => { done(list) })
+ }).catch((err) => {
+ process.nextTick(() => { throw err })
})
}
@@ -35,14 +36,14 @@ module.exports = function (yargs, usage, command) {
return done(result)
} else {
// asynchronous completion function
- return completionFunction(current, argv, function (completions) {
+ return completionFunction(current, argv, (completions) => {
done(completions)
})
}
}
- var handlers = command.getCommandHandlers()
- for (var i = 0, ii = args.length; i < ii; ++i) {
+ const handlers = command.getCommandHandlers()
+ for (let i = 0, ii = args.length; i < ii; ++i) {
if (handlers[args[i]] && handlers[args[i]].builder) {
const builder = handlers[args[i]].builder
if (typeof builder === 'function') {
@@ -54,22 +55,21 @@ module.exports = function (yargs, usage, command) {
}
if (!current.match(/^-/)) {
- usage.getCommands().forEach(function (command) {
- if (args.indexOf(command[0]) === -1) {
- completions.push(command[0])
+ usage.getCommands().forEach((usageCommand) => {
+ const commandName = command.parseCommand(usageCommand[0]).cmd
+ if (args.indexOf(commandName) === -1) {
+ completions.push(commandName)
}
})
}
if (current.match(/^-/)) {
- Object.keys(yargs.getOptions().key).forEach(function (key) {
+ Object.keys(yargs.getOptions().key).forEach((key) => {
// If the key and its aliases aren't in 'args', add the key to 'completions'
- var keyAndAliases = [key].concat(aliases[key] || [])
- var notInArgs = keyAndAliases.every(function (val) {
- return args.indexOf('--' + val) === -1
- })
+ const keyAndAliases = [key].concat(aliases[key] || [])
+ const notInArgs = keyAndAliases.every(val => args.indexOf(`--${val}`) === -1)
if (notInArgs) {
- completions.push('--' + key)
+ completions.push(`--${key}`)
}
})
}
@@ -78,25 +78,26 @@ module.exports = function (yargs, usage, command) {
}
// generate the completion script to add to your .bashrc.
- self.generateCompletionScript = function ($0) {
- var script = fs.readFileSync(
+ self.generateCompletionScript = function generateCompletionScript ($0, cmd) {
+ let script = fs.readFileSync(
path.resolve(__dirname, '../completion.sh.hbs'),
'utf-8'
)
- var name = path.basename($0)
+ const name = path.basename($0)
// add ./to applications not yet installed as bin.
- if ($0.match(/\.js$/)) $0 = './' + $0
+ if ($0.match(/\.js$/)) $0 = `./${$0}`
script = script.replace(/{{app_name}}/g, name)
+ script = script.replace(/{{completion_command}}/g, cmd)
return script.replace(/{{app_path}}/g, $0)
}
// register a function to perform your own custom
// completions., this function can be either
// synchrnous or asynchronous.
- var completionFunction = null
- self.registerFunction = function (fn) {
+ let completionFunction = null
+ self.registerFunction = (fn) => {
completionFunction = fn
}
diff --git a/node_modules/yargs/lib/levenshtein.js b/node_modules/yargs/lib/levenshtein.js
index 6ec216f59..f32b0c277 100644
--- a/node_modules/yargs/lib/levenshtein.js
+++ b/node_modules/yargs/lib/levenshtein.js
@@ -10,22 +10,22 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
// levenshtein distance algorithm, pulled from Andrei Mackenzie's MIT licensed.
// gist, which can be found here: https://gist.github.com/andrei-m/982927
-
+'use strict'
// Compute the edit distance between the two given strings
-module.exports = function (a, b) {
+module.exports = function levenshtein (a, b) {
if (a.length === 0) return b.length
if (b.length === 0) return a.length
- var matrix = []
+ const matrix = []
// increment along the first column of each row
- var i
+ let i
for (i = 0; i <= b.length; i++) {
matrix[i] = [i]
}
// increment each column in the first row
- var j
+ let j
for (j = 0; j <= a.length; j++) {
matrix[0][j] = j
}
diff --git a/node_modules/yargs/lib/obj-filter.js b/node_modules/yargs/lib/obj-filter.js
index 42cb9961e..c344ac58c 100644
--- a/node_modules/yargs/lib/obj-filter.js
+++ b/node_modules/yargs/lib/obj-filter.js
@@ -1,7 +1,8 @@
-module.exports = function (original, filter) {
+'use strict'
+module.exports = function objFilter (original, filter) {
const obj = {}
- filter = filter || function (k, v) { return true }
- Object.keys(original || {}).forEach(function (key) {
+ filter = filter || ((k, v) => true)
+ Object.keys(original || {}).forEach((key) => {
if (filter(key, original[key])) {
obj[key] = original[key]
}
diff --git a/node_modules/yargs/lib/usage.js b/node_modules/yargs/lib/usage.js
index 43f71225c..cf79b10de 100644
--- a/node_modules/yargs/lib/usage.js
+++ b/node_modules/yargs/lib/usage.js
@@ -1,23 +1,25 @@
+'use strict'
// this file handles outputting usage instructions,
// failures, etc. keeps logging in one place.
const stringWidth = require('string-width')
const objFilter = require('./obj-filter')
+const path = require('path')
const setBlocking = require('set-blocking')
const YError = require('./yerror')
-module.exports = function (yargs, y18n) {
+module.exports = function usage (yargs, y18n) {
const __ = y18n.__
const self = {}
// methods for ouputting/building failure message.
- var fails = []
- self.failFn = function (f) {
+ const fails = []
+ self.failFn = function failFn (f) {
fails.push(f)
}
- var failMessage = null
- var showHelpOnFail = true
- self.showHelpOnFail = function (enabled, message) {
+ let failMessage = null
+ let showHelpOnFail = true
+ self.showHelpOnFail = function showHelpOnFailFn (enabled, message) {
if (typeof enabled === 'string') {
message = enabled
enabled = true
@@ -29,12 +31,12 @@ module.exports = function (yargs, y18n) {
return self
}
- var failureOutput = false
- self.fail = function (msg, err) {
+ let failureOutput = false
+ self.fail = function fail (msg, err) {
const logger = yargs._getLoggerInstance()
if (fails.length) {
- for (var i = fails.length - 1; i >= 0; --i) {
+ for (let i = fails.length - 1; i >= 0; --i) {
fails[i](msg, err, self)
}
} else {
@@ -63,56 +65,67 @@ module.exports = function (yargs, y18n) {
}
// methods for ouputting/building help (usage) message.
- var usage
- self.usage = function (msg) {
- usage = msg
+ let usages = []
+ let usageDisabled = false
+ self.usage = (msg, description) => {
+ if (msg === null) {
+ usageDisabled = true
+ usages = []
+ return
+ }
+ usageDisabled = false
+ usages.push([msg, description || ''])
+ return self
+ }
+ self.getUsage = () => {
+ return usages
}
- self.getUsage = function () {
- return usage
+ self.getUsageDisabled = () => {
+ return usageDisabled
+ }
+
+ self.getPositionalGroupName = () => {
+ return __('Positionals:')
}
- var examples = []
- self.example = function (cmd, description) {
+ let examples = []
+ self.example = (cmd, description) => {
examples.push([cmd, description || ''])
}
- var commands = []
- self.command = function (cmd, description, isDefault, aliases) {
+ let commands = []
+ self.command = function command (cmd, description, isDefault, aliases) {
// the last default wins, so cancel out any previously set default
if (isDefault) {
- commands = commands.map(function (cmdArray) {
+ commands = commands.map((cmdArray) => {
cmdArray[2] = false
return cmdArray
})
}
commands.push([cmd, description || '', isDefault, aliases])
}
- self.getCommands = function () {
- return commands
- }
+ self.getCommands = () => commands
- var descriptions = {}
- self.describe = function (key, desc) {
+ let descriptions = {}
+ self.describe = function describe (key, desc) {
if (typeof key === 'object') {
- Object.keys(key).forEach(function (k) {
+ Object.keys(key).forEach((k) => {
self.describe(k, key[k])
})
} else {
descriptions[key] = desc
}
}
- self.getDescriptions = function () {
- return descriptions
- }
+ self.getDescriptions = () => descriptions
- var epilog
- self.epilog = function (msg) {
+ let epilog
+ self.epilog = (msg) => {
epilog = msg
}
- var wrapSet = false
- var wrap
- self.wrap = function (cols) {
+ let wrapSet = false
+ let wrap
+ self.wrap = (cols) => {
wrapSet = true
wrap = cols
}
@@ -126,41 +139,57 @@ module.exports = function (yargs, y18n) {
return wrap
}
- var deferY18nLookupPrefix = '__yargsString__:'
- self.deferY18nLookup = function (str) {
- return deferY18nLookupPrefix + str
- }
+ const deferY18nLookupPrefix = '__yargsString__:'
+ self.deferY18nLookup = str => deferY18nLookupPrefix + str
- var defaultGroup = 'Options:'
- self.help = function () {
+ const defaultGroup = 'Options:'
+ self.help = function help () {
normalizeAliases()
// handle old demanded API
- var demandedOptions = yargs.getDemandedOptions()
- var demandedCommands = yargs.getDemandedCommands()
- var groups = yargs.getGroups()
- var options = yargs.getOptions()
- var keys = Object.keys(
+ const base$0 = path.basename(yargs.$0)
+ const demandedOptions = yargs.getDemandedOptions()
+ const demandedCommands = yargs.getDemandedCommands()
+ const groups = yargs.getGroups()
+ const options = yargs.getOptions()
+ let keys = Object.keys(
Object.keys(descriptions)
.concat(Object.keys(demandedOptions))
.concat(Object.keys(demandedCommands))
.concat(Object.keys(options.default))
- .reduce(function (acc, key) {
+ .reduce((acc, key) => {
if (key !== '_') acc[key] = true
return acc
}, {})
)
- var theWrap = getWrap()
- var ui = require('cliui')({
+ const theWrap = getWrap()
+ const ui = require('cliui')({
width: theWrap,
wrap: !!theWrap
})
// the usage string.
- if (usage) {
- var u = usage.replace(/\$0/g, yargs.$0)
- ui.div(u + '\n')
+ if (!usageDisabled) {
+ if (usages.length) {
+ // user-defined usage.
+ usages.forEach((usage) => {
+ ui.div(`${usage[0].replace(/\$0/g, base$0)}`)
+ if (usage[1]) {
+ ui.div({text: `${usage[1]}`, padding: [1, 0, 0, 0]})
+ }
+ })
+ ui.div()
+ } else if (commands.length) {
+ let u = null
+ // demonstrate how commands are used.
+ if (demandedCommands._) {
+ u = `${base$0} <${__('command')}>\n`
+ } else {
+ u = `${base$0} [${__('command')}]\n`
+ }
+ ui.div(`${u}`)
+ }
}
// your application's commands, i.e., non-option
@@ -168,15 +197,23 @@ module.exports = function (yargs, y18n) {
if (commands.length) {
ui.div(__('Commands:'))
- commands.forEach(function (command) {
+ const context = yargs.getContext()
+ const parentCommands = context.commands.length ? `${context.commands.join(' ')} ` : ''
+
+ commands.forEach((command) => {
+ const commandString = `${base$0} ${parentCommands}${command[0].replace(/^\$0 ?/, '')}` // drop $0 from default commands.
ui.span(
- {text: command[0], padding: [0, 2, 0, 2], width: maxWidth(commands, theWrap) + 4},
+ {
+ text: commandString,
+ padding: [0, 2, 0, 2],
+ width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4
+ },
{text: command[1]}
)
- var hints = []
- if (command[2]) hints.push('[' + __('default:').slice(0, -1) + ']') // TODO hacking around i18n here
+ const hints = []
+ if (command[2]) hints.push(`[${__('default:').slice(0, -1)}]`) // TODO hacking around i18n here
if (command[3] && command[3].length) {
- hints.push('[' + __('aliases:') + ' ' + command[3].join(', ') + ']')
+ hints.push(`[${__('aliases:')} ${command[3].join(', ')}]`)
}
if (hints.length) {
ui.div({text: hints.join(' '), padding: [0, 0, 0, 2], align: 'right'})
@@ -190,14 +227,10 @@ module.exports = function (yargs, y18n) {
// perform some cleanup on the keys array, making it
// only include top-level keys not their aliases.
- var aliasKeys = (Object.keys(options.alias) || [])
+ const aliasKeys = (Object.keys(options.alias) || [])
.concat(Object.keys(yargs.parsed.newAliases) || [])
- keys = keys.filter(function (key) {
- return !yargs.parsed.newAliases[key] && aliasKeys.every(function (alias) {
- return (options.alias[alias] || []).indexOf(key) === -1
- })
- })
+ keys = keys.filter(key => !yargs.parsed.newAliases[key] && aliasKeys.every(alias => (options.alias[alias] || []).indexOf(key) === -1))
// populate 'Options:' group with any keys that have not
// explicitly had a group set.
@@ -205,51 +238,54 @@ module.exports = function (yargs, y18n) {
addUngroupedKeys(keys, options.alias, groups)
// display 'Options:' table along with any custom tables:
- Object.keys(groups).forEach(function (groupName) {
+ Object.keys(groups).forEach((groupName) => {
if (!groups[groupName].length) return
ui.div(__(groupName))
// if we've grouped the key 'f', but 'f' aliases 'foobar',
// normalizedKeys should contain only 'foobar'.
- var normalizedKeys = groups[groupName].map(function (key) {
+ const normalizedKeys = groups[groupName].map((key) => {
if (~aliasKeys.indexOf(key)) return key
- for (var i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {
+ for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {
if (~(options.alias[aliasKey] || []).indexOf(key)) return aliasKey
}
return key
})
// actually generate the switches string --foo, -f, --bar.
- var switches = normalizedKeys.reduce(function (acc, key) {
+ const switches = normalizedKeys.reduce((acc, key) => {
acc[key] = [ key ].concat(options.alias[key] || [])
- .map(function (sw) {
- return (sw.length > 1 ? '--' : '-') + sw
+ .map(sw => {
+ // for the special positional group don't
+ // add '--' or '-' prefix.
+ if (groupName === self.getPositionalGroupName()) return sw
+ else return (sw.length > 1 ? '--' : '-') + sw
})
.join(', ')
return acc
}, {})
- normalizedKeys.forEach(function (key) {
- var kswitch = switches[key]
- var desc = descriptions[key] || ''
- var type = null
+ normalizedKeys.forEach((key) => {
+ const kswitch = switches[key]
+ let desc = descriptions[key] || ''
+ let type = null
if (~desc.lastIndexOf(deferY18nLookupPrefix)) desc = __(desc.substring(deferY18nLookupPrefix.length))
- if (~options.boolean.indexOf(key)) type = '[' + __('boolean') + ']'
- if (~options.count.indexOf(key)) type = '[' + __('count') + ']'
- if (~options.string.indexOf(key)) type = '[' + __('string') + ']'
- if (~options.normalize.indexOf(key)) type = '[' + __('string') + ']'
- if (~options.array.indexOf(key)) type = '[' + __('array') + ']'
- if (~options.number.indexOf(key)) type = '[' + __('number') + ']'
+ if (~options.boolean.indexOf(key)) type = `[${__('boolean')}]`
+ if (~options.count.indexOf(key)) type = `[${__('count')}]`
+ if (~options.string.indexOf(key)) type = `[${__('string')}]`
+ if (~options.normalize.indexOf(key)) type = `[${__('string')}]`
+ if (~options.array.indexOf(key)) type = `[${__('array')}]`
+ if (~options.number.indexOf(key)) type = `[${__('number')}]`
- var extra = [
+ const extra = [
type,
- (key in demandedOptions) ? '[' + __('required') + ']' : null,
- options.choices && options.choices[key] ? '[' + __('choices:') + ' ' +
- self.stringifiedValues(options.choices[key]) + ']' : null,
+ (key in demandedOptions) ? `[${__('required')}]` : null,
+ options.choices && options.choices[key] ? `[${__('choices:')} ${
+ self.stringifiedValues(options.choices[key])}]` : null,
defaultString(options.default[key], options.defaultDescription[key])
].filter(Boolean).join(' ')
@@ -269,11 +305,11 @@ module.exports = function (yargs, y18n) {
if (examples.length) {
ui.div(__('Examples:'))
- examples.forEach(function (example) {
- example[0] = example[0].replace(/\$0/g, yargs.$0)
+ examples.forEach((example) => {
+ example[0] = example[0].replace(/\$0/g, base$0)
})
- examples.forEach(function (example) {
+ examples.forEach((example) => {
if (example[1] === '') {
ui.div(
{
@@ -299,8 +335,8 @@ module.exports = function (yargs, y18n) {
// the usage string.
if (epilog) {
- var e = epilog.replace(/\$0/g, yargs.$0)
- ui.div(e + '\n')
+ const e = epilog.replace(/\$0/g, base$0)
+ ui.div(`${e}\n`)
}
return ui.toString()
@@ -308,19 +344,20 @@ module.exports = function (yargs, y18n) {
// return the maximum width of a string
// in the left-hand column of a table.
- function maxWidth (table, theWrap) {
- var width = 0
+ function maxWidth (table, theWrap, modifier) {
+ let width = 0
// table might be of the form [leftColumn],
// or {key: leftColumn}
if (!Array.isArray(table)) {
- table = Object.keys(table).map(function (key) {
- return [table[key]]
- })
+ table = Object.keys(table).map(key => [table[key]])
}
- table.forEach(function (v) {
- width = Math.max(stringWidth(v[0]), width)
+ table.forEach((v) => {
+ width = Math.max(
+ stringWidth(modifier ? `${modifier} ${v[0]}` : v[0]),
+ width
+ )
})
// if we've enabled 'wrap' we should limit
@@ -334,11 +371,11 @@ module.exports = function (yargs, y18n) {
// are copied to the keys being aliased.
function normalizeAliases () {
// handle old demanded API
- var demandedOptions = yargs.getDemandedOptions()
- var options = yargs.getOptions()
+ const demandedOptions = yargs.getDemandedOptions()
+ const options = yargs.getOptions()
- ;(Object.keys(options.alias) || []).forEach(function (key) {
- options.alias[key].forEach(function (alias) {
+ ;(Object.keys(options.alias) || []).forEach((key) => {
+ options.alias[key].forEach((alias) => {
// copy descriptions.
if (descriptions[alias]) self.describe(key, descriptions[alias])
// copy demanded.
@@ -357,43 +394,41 @@ module.exports = function (yargs, y18n) {
// given a set of keys, place any keys that are
// ungrouped under the 'Options:' grouping.
function addUngroupedKeys (keys, aliases, groups) {
- var groupedKeys = []
- var toCheck = null
- Object.keys(groups).forEach(function (group) {
+ let groupedKeys = []
+ let toCheck = null
+ Object.keys(groups).forEach((group) => {
groupedKeys = groupedKeys.concat(groups[group])
})
- keys.forEach(function (key) {
+ keys.forEach((key) => {
toCheck = [key].concat(aliases[key])
- if (!toCheck.some(function (k) {
- return groupedKeys.indexOf(k) !== -1
- })) {
+ if (!toCheck.some(k => groupedKeys.indexOf(k) !== -1)) {
groups[defaultGroup].push(key)
}
})
return groupedKeys
}
- self.showHelp = function (level) {
+ self.showHelp = (level) => {
const logger = yargs._getLoggerInstance()
if (!level) level = 'error'
- var emit = typeof level === 'function' ? level : logger[level]
+ const emit = typeof level === 'function' ? level : logger[level]
emit(self.help())
}
- self.functionDescription = function (fn) {
- var description = fn.name ? require('decamelize')(fn.name, '-') : __('generated-value')
+ self.functionDescription = (fn) => {
+ const description = fn.name ? require('decamelize')(fn.name, '-') : __('generated-value')
return ['(', description, ')'].join('')
}
- self.stringifiedValues = function (values, separator) {
- var string = ''
- var sep = separator || ', '
- var array = [].concat(values)
+ self.stringifiedValues = function stringifiedValues (values, separator) {
+ let string = ''
+ const sep = separator || ', '
+ const array = [].concat(values)
if (!values || !array.length) return string
- array.forEach(function (value) {
+ array.forEach((value) => {
if (string.length) string += sep
string += JSON.stringify(value)
})
@@ -404,7 +439,7 @@ module.exports = function (yargs, y18n) {
// format the default-value-string displayed in
// the right-hand column.
function defaultString (value, defaultDescription) {
- var string = '[' + __('default:') + ' '
+ let string = `[${__('default:')} `
if (value === undefined && !defaultDescription) return null
@@ -413,7 +448,7 @@ module.exports = function (yargs, y18n) {
} else {
switch (typeof value) {
case 'string':
- string += JSON.stringify(value)
+ string += `"${value}"`
break
case 'object':
string += JSON.stringify(value)
@@ -423,12 +458,12 @@ module.exports = function (yargs, y18n) {
}
}
- return string + ']'
+ return `${string}]`
}
// guess the width of the console window, max-width 80.
function windowWidth () {
- var maxWidth = 80
+ const maxWidth = 80
if (typeof process === 'object' && process.stdout && process.stdout.columns) {
return Math.min(maxWidth, process.stdout.columns)
} else {
@@ -437,47 +472,47 @@ module.exports = function (yargs, y18n) {
}
// logic for displaying application version.
- var version = null
- self.version = function (ver) {
+ let version = null
+ self.version = (ver) => {
version = ver
}
- self.showVersion = function () {
+ self.showVersion = () => {
const logger = yargs._getLoggerInstance()
- if (typeof version === 'function') logger.log(version())
- else logger.log(version)
+ logger.log(version)
}
- self.reset = function (localLookup) {
+ self.reset = function reset (localLookup) {
// do not reset wrap here
// do not reset fails here
failMessage = null
failureOutput = false
- usage = undefined
+ usages = []
+ usageDisabled = false
epilog = undefined
examples = []
commands = []
- descriptions = objFilter(descriptions, function (k, v) {
- return !localLookup[k]
- })
+ descriptions = objFilter(descriptions, (k, v) => !localLookup[k])
return self
}
- var frozen
- self.freeze = function () {
+ let frozen
+ self.freeze = function freeze () {
frozen = {}
frozen.failMessage = failMessage
frozen.failureOutput = failureOutput
- frozen.usage = usage
+ frozen.usages = usages
+ frozen.usageDisabled = usageDisabled
frozen.epilog = epilog
frozen.examples = examples
frozen.commands = commands
frozen.descriptions = descriptions
}
- self.unfreeze = function () {
+ self.unfreeze = function unfreeze () {
failMessage = frozen.failMessage
failureOutput = frozen.failureOutput
- usage = frozen.usage
+ usages = frozen.usages
+ usageDisabled = frozen.usageDisabled
epilog = frozen.epilog
examples = frozen.examples
commands = frozen.commands
diff --git a/node_modules/yargs/lib/validation.js b/node_modules/yargs/lib/validation.js
index 2f9ff8e6c..1eee2fb02 100644
--- a/node_modules/yargs/lib/validation.js
+++ b/node_modules/yargs/lib/validation.js
@@ -1,16 +1,18 @@
+'use strict'
+const argsert = require('./argsert')
const objFilter = require('./obj-filter')
const specialKeys = ['$0', '--', '_']
// validation-type-stuff, missing params,
// bad implications, custom checks.
-module.exports = function (yargs, usage, y18n) {
+module.exports = function validation (yargs, usage, y18n) {
const __ = y18n.__
const __n = y18n.__n
const self = {}
// validate appropriate # of non-option
// arguments were provided, i.e., '_'.
- self.nonOptionCount = function (argv) {
+ self.nonOptionCount = function nonOptionCount (argv) {
const demandedCommands = yargs.getDemandedCommands()
// don't count currently executing commands
const _s = argv._.length - yargs.getContext().commands.length
@@ -44,7 +46,7 @@ module.exports = function (yargs, usage, y18n) {
// validate the appropriate # of <required>
// positional arguments were provided:
- self.positionalCount = function (required, observed) {
+ self.positionalCount = function positionalCount (required, observed) {
if (observed < required) {
usage.fail(
__('Not enough non-option arguments: got %s, need at least %s', observed, required)
@@ -54,14 +56,14 @@ module.exports = function (yargs, usage, y18n) {
// make sure that any args that require an
// value (--foo=bar), have a value.
- self.missingArgumentValue = function (argv) {
+ self.missingArgumentValue = function missingArgumentValue (argv) {
const defaultValues = [true, false, '']
const options = yargs.getOptions()
if (options.requiresArg.length > 0) {
const missingRequiredArgs = []
- options.requiresArg.forEach(function (key) {
+ options.requiresArg.forEach((key) => {
const value = argv[key]
// if a value is explicitly requested,
@@ -85,11 +87,11 @@ module.exports = function (yargs, usage, y18n) {
}
// make sure all the required arguments are present.
- self.requiredArguments = function (argv) {
+ self.requiredArguments = function requiredArguments (argv) {
const demandedOptions = yargs.getDemandedOptions()
- var missing = null
+ let missing = null
- Object.keys(demandedOptions).forEach(function (key) {
+ Object.keys(demandedOptions).forEach((key) => {
if (!argv.hasOwnProperty(key) || typeof argv[key] === 'undefined') {
missing = missing || {}
missing[key] = demandedOptions[key]
@@ -98,14 +100,14 @@ module.exports = function (yargs, usage, y18n) {
if (missing) {
const customMsgs = []
- Object.keys(missing).forEach(function (key) {
+ Object.keys(missing).forEach((key) => {
const msg = missing[key]
if (msg && customMsgs.indexOf(msg) < 0) {
customMsgs.push(msg)
}
})
- const customMsg = customMsgs.length ? '\n' + customMsgs.join('\n') : ''
+ const customMsg = customMsgs.length ? `\n${customMsgs.join('\n')}` : ''
usage.fail(__n(
'Missing required argument: %s',
@@ -117,33 +119,23 @@ module.exports = function (yargs, usage, y18n) {
}
// check for unknown arguments (strict-mode).
- self.unknownArguments = function (argv, aliases, positionalMap) {
- const aliasLookup = {}
- const descriptions = usage.getDescriptions()
- const demandedOptions = yargs.getDemandedOptions()
+ self.unknownArguments = function unknownArguments (argv, aliases, positionalMap) {
const commandKeys = yargs.getCommandInstance().getCommands()
const unknown = []
const currentContext = yargs.getContext()
- Object.keys(aliases).forEach(function (key) {
- aliases[key].forEach(function (alias) {
- aliasLookup[alias] = key
- })
- })
-
- Object.keys(argv).forEach(function (key) {
+ Object.keys(argv).forEach((key) => {
if (specialKeys.indexOf(key) === -1 &&
- !descriptions.hasOwnProperty(key) &&
- !demandedOptions.hasOwnProperty(key) &&
!positionalMap.hasOwnProperty(key) &&
!yargs._getParseContext().hasOwnProperty(key) &&
- !aliasLookup.hasOwnProperty(key)) {
+ !aliases.hasOwnProperty(key)
+ ) {
unknown.push(key)
}
})
if (commandKeys.length > 0) {
- argv._.slice(currentContext.commands.length).forEach(function (key) {
+ argv._.slice(currentContext.commands.length).forEach((key) => {
if (commandKeys.indexOf(key) === -1) {
unknown.push(key)
}
@@ -161,18 +153,19 @@ module.exports = function (yargs, usage, y18n) {
}
// validate arguments limited to enumerated choices
- self.limitedChoices = function (argv) {
+ self.limitedChoices = function limitedChoices (argv) {
const options = yargs.getOptions()
const invalid = {}
if (!Object.keys(options.choices).length) return
- Object.keys(argv).forEach(function (key) {
+ Object.keys(argv).forEach((key) => {
if (specialKeys.indexOf(key) === -1 &&
options.choices.hasOwnProperty(key)) {
- [].concat(argv[key]).forEach(function (value) {
+ [].concat(argv[key]).forEach((value) => {
// TODO case-insensitive configurability
- if (options.choices[key].indexOf(value) === -1) {
+ if (options.choices[key].indexOf(value) === -1 &&
+ value !== undefined) {
invalid[key] = (invalid[key] || []).concat(value)
}
})
@@ -183,31 +176,31 @@ module.exports = function (yargs, usage, y18n) {
if (!invalidKeys.length) return
- var msg = __('Invalid values:')
- invalidKeys.forEach(function (key) {
- msg += '\n ' + __(
+ let msg = __('Invalid values:')
+ invalidKeys.forEach((key) => {
+ msg += `\n ${__(
'Argument: %s, Given: %s, Choices: %s',
key,
usage.stringifiedValues(invalid[key]),
usage.stringifiedValues(options.choices[key])
- )
+ )}`
})
usage.fail(msg)
}
// custom checks, added using the `check` option on yargs.
- var checks = []
- self.check = function (f, global) {
+ let checks = []
+ self.check = function check (f, global) {
checks.push({
func: f,
- global: global
+ global
})
}
- self.customChecks = function (argv, aliases) {
- for (var i = 0, f; (f = checks[i]) !== undefined; i++) {
- var func = f.func
- var result = null
+ self.customChecks = function customChecks (argv, aliases) {
+ for (let i = 0, f; (f = checks[i]) !== undefined; i++) {
+ const func = f.func
+ let result = null
try {
result = func(argv, aliases)
} catch (err) {
@@ -224,107 +217,129 @@ module.exports = function (yargs, usage, y18n) {
}
// check implications, argument foo implies => argument bar.
- var implied = {}
- self.implies = function (key, value) {
+ let implied = {}
+ self.implies = function implies (key, value) {
+ argsert('<string|object> [array|number|string]', [key, value], arguments.length)
+
if (typeof key === 'object') {
- Object.keys(key).forEach(function (k) {
+ Object.keys(key).forEach((k) => {
self.implies(k, key[k])
})
} else {
yargs.global(key)
- implied[key] = value
+ if (!implied[key]) {
+ implied[key] = []
+ }
+ if (Array.isArray(value)) {
+ value.forEach((i) => self.implies(key, i))
+ } else {
+ implied[key].push(value)
+ }
}
}
- self.getImplied = function () {
+ self.getImplied = function getImplied () {
return implied
}
- self.implications = function (argv) {
+ self.implications = function implications (argv) {
const implyFail = []
- Object.keys(implied).forEach(function (key) {
- var num
+ Object.keys(implied).forEach((key) => {
const origKey = key
- var value = implied[key]
-
- // convert string '1' to number 1
- num = Number(key)
- key = isNaN(num) ? key : num
-
- if (typeof key === 'number') {
- // check length of argv._
- key = argv._.length >= key
- } else if (key.match(/^--no-.+/)) {
- // check if key doesn't exist
- key = key.match(/^--no-(.+)/)[1]
- key = !argv[key]
- } else {
- // check if key exists
- key = argv[key]
- }
-
- num = Number(value)
- value = isNaN(num) ? value : num
+ ;(implied[key] || []).forEach((value) => {
+ let num
+ let key = origKey
+ const origValue = value
+
+ // convert string '1' to number 1
+ num = Number(key)
+ key = isNaN(num) ? key : num
+
+ if (typeof key === 'number') {
+ // check length of argv._
+ key = argv._.length >= key
+ } else if (key.match(/^--no-.+/)) {
+ // check if key doesn't exist
+ key = key.match(/^--no-(.+)/)[1]
+ key = !argv[key]
+ } else {
+ // check if key exists
+ key = argv[key]
+ }
- if (typeof value === 'number') {
- value = argv._.length >= value
- } else if (value.match(/^--no-.+/)) {
- value = value.match(/^--no-(.+)/)[1]
- value = !argv[value]
- } else {
- value = argv[value]
- }
+ num = Number(value)
+ value = isNaN(num) ? value : num
- if (key && !value) {
- implyFail.push(origKey)
- }
+ if (typeof value === 'number') {
+ value = argv._.length >= value
+ } else if (value.match(/^--no-.+/)) {
+ value = value.match(/^--no-(.+)/)[1]
+ value = !argv[value]
+ } else {
+ value = argv[value]
+ }
+ if (key && !value) {
+ implyFail.push(` ${origKey} -> ${origValue}`)
+ }
+ })
})
if (implyFail.length) {
- var msg = __('Implications failed:') + '\n'
+ let msg = `${__('Implications failed:')}\n`
- implyFail.forEach(function (key) {
- msg += (' ' + key + ' -> ' + implied[key])
+ implyFail.forEach((value) => {
+ msg += (value)
})
usage.fail(msg)
}
}
- var conflicting = {}
- self.conflicts = function (key, value) {
+ let conflicting = {}
+ self.conflicts = function conflicts (key, value) {
+ argsert('<string|object> [array|string]', [key, value], arguments.length)
+
if (typeof key === 'object') {
- Object.keys(key).forEach(function (k) {
+ Object.keys(key).forEach((k) => {
self.conflicts(k, key[k])
})
} else {
yargs.global(key)
- conflicting[key] = value
+ if (!conflicting[key]) {
+ conflicting[key] = []
+ }
+ if (Array.isArray(value)) {
+ value.forEach((i) => self.conflicts(key, i))
+ } else {
+ conflicting[key].push(value)
+ }
}
}
- self.getConflicting = function () {
- return conflicting
- }
-
- self.conflicting = function (argv) {
- var args = Object.getOwnPropertyNames(argv)
-
- args.forEach(function (arg) {
- if (conflicting[arg] && args.indexOf(conflicting[arg]) !== -1) {
- usage.fail(__('Arguments %s and %s are mutually exclusive', arg, conflicting[arg]))
+ self.getConflicting = () => conflicting
+
+ self.conflicting = function conflictingFn (argv) {
+ Object.keys(argv).forEach((key) => {
+ if (conflicting[key]) {
+ conflicting[key].forEach((value) => {
+ // we default keys to 'undefined' that have been configured, we should not
+ // apply conflicting check unless they are a value other than 'undefined'.
+ if (value && argv[key] !== undefined && argv[value] !== undefined) {
+ usage.fail(__(`Arguments ${key} and ${value} are mutually exclusive`))
+ }
+ })
}
})
}
- self.recommendCommands = function (cmd, potentialCommands) {
+ self.recommendCommands = function recommendCommands (cmd, potentialCommands) {
const distance = require('./levenshtein')
const threshold = 3 // if it takes more than three edits, let's move on.
- potentialCommands = potentialCommands.sort(function (a, b) { return b.length - a.length })
+ potentialCommands = potentialCommands.sort((a, b) => b.length - a.length)
- var recommended = null
- var bestDistance = Infinity
- for (var i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
- var d = distance(cmd, candidate)
+ let recommended = null
+ let bestDistance = Infinity
+ for (let i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
+ const d = distance(cmd, candidate)
if (d <= threshold && d < bestDistance) {
bestDistance = d
recommended = candidate
@@ -333,27 +348,21 @@ module.exports = function (yargs, usage, y18n) {
if (recommended) usage.fail(__('Did you mean %s?', recommended))
}
- self.reset = function (localLookup) {
- implied = objFilter(implied, function (k, v) {
- return !localLookup[k]
- })
- conflicting = objFilter(conflicting, function (k, v) {
- return !localLookup[k]
- })
- checks = checks.filter(function (c) {
- return c.global
- })
+ self.reset = function reset (localLookup) {
+ implied = objFilter(implied, (k, v) => !localLookup[k])
+ conflicting = objFilter(conflicting, (k, v) => !localLookup[k])
+ checks = checks.filter(c => c.global)
return self
}
- var frozen
- self.freeze = function () {
+ let frozen
+ self.freeze = function freeze () {
frozen = {}
frozen.implied = implied
frozen.checks = checks
frozen.conflicting = conflicting
}
- self.unfreeze = function () {
+ self.unfreeze = function unfreeze () {
implied = frozen.implied
checks = frozen.checks
conflicting = frozen.conflicting
diff --git a/node_modules/yargs/lib/yerror.js b/node_modules/yargs/lib/yerror.js
index ad96a8776..53375a0f7 100644
--- a/node_modules/yargs/lib/yerror.js
+++ b/node_modules/yargs/lib/yerror.js
@@ -1,3 +1,4 @@
+'use strict'
function YError (msg) {
this.name = 'YError'
this.message = msg || 'yargs error'
generated by cgit v1.2.3 (git 2.39.1) at 2025-09-12 05:18:51 +0000