yargs 8.0.0 → 9.0.1

package/index.js

@@ -1,3 +1,4 @@
+'use strict'
 // classic singleton yargs API, to use yargs
 // without running as a singleton do:
 // require('yargs/yargs')(process.argv.slice(2))
@@ -21,7 +22,7 @@ function Argv (processArgs, cwd) {
     to get a parsed version of process.argv.
 */
 function singletonify (inst) {
-  Object.keys(inst).forEach(function (key) {
+  Object.keys(inst).forEach((key) => {
     if (key === 'argv') {
       Argv.__defineGetter__(key, inst.__lookupGetter__(key))
     } else {

package/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

package/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}.`)
 }

package/lib/command.js

@@ -1,3 +1,4 @@
+'use strict'
 const path = require('path')
 const inspect = require('util').inspect
 const camelCase = require('camelcase')
@@ -7,21 +8,21 @@ const DEFAULT_MARKER = '*'
 // 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,16 +35,14 @@ 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) {
+    let isDefault = false
+    const parsedAliases = [parsedCommand.cmd].concat(aliases).filter((c) => {
       if (c === DEFAULT_MARKER) {
         isDefault = true
         return false
@@ -55,7 +54,7 @@ module.exports = function (yargs, usage, validation) {
     if (isDefault && parsedAliases.length === 0) {
       defaultCommand = {
         original: cmd.replace(DEFAULT_MARKER, '').trim(),
-        handler: handler,
+        handler,
         builder: builder || {},
         demanded: parsedCommand.demanded,
         optional: parsedCommand.optional
@@ -71,7 +70,7 @@ module.exports = function (yargs, usage, validation) {
     }
 
     // populate aliasMap
-    aliases.forEach(function (alias) {
+    aliases.forEach((alias) => {
       aliasMap[alias] = parsedCommand.cmd
     })
 
@@ -81,7 +80,7 @@ module.exports = function (yargs, usage, validation) {
 
     handlers[parsedCommand.cmd] = {
       original: cmd,
-      handler: handler,
+      handler,
       builder: builder || {},
       demanded: parsedCommand.demanded,
       optional: parsedCommand.optional
@@ -90,16 +89,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 +118,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,64 +128,58 @@ 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 = {}
+    let innerArgv = parsed.argv
+    let innerYargs = null
+    let positionalMap = {}
 
     if (command) currentContext.commands.push(command)
     if (typeof commandHandler.builder === 'function') {
@@ -199,7 +192,7 @@ module.exports = function (yargs, usage, validation) {
       // options object below.
       if (yargs.parsed === false) {
         if (typeof yargs.getUsageInstance().getUsage() === 'undefined') {
-          yargs.usage('$0 ' + (parentCommands.length ? parentCommands.join(' ') + ' ' : '') + commandHandler.original)
+          yargs.usage(`$0 ${parentCommands.length ? `${parentCommands.join(' ')} ` : ''}${commandHandler.original}`)
         }
         innerArgv = innerYargs ? innerYargs._parseArgs(null, null, true, commandIndex) : yargs._parseArgs(null, null, true, commandIndex)
       } else {
@@ -212,8 +205,8 @@ 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) {
+      innerYargs.usage(`$0 ${parentCommands.length ? `${parentCommands.join(' ')} ` : ''}${commandHandler.original}`)
+      Object.keys(commandHandler.builder).forEach((key) => {
         innerYargs.option(key, commandHandler.builder[key])
       })
       innerArgv = innerYargs._parseArgs(null, null, true, commandIndex)
@@ -244,19 +237,19 @@ module.exports = function (yargs, usage, validation) {
   // 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()
+      const demand = demanded.shift()
       populatePositional(demand, argv, yargs, positionalMap)
     }
 
     while (optional.length) {
-      var maybe = optional.shift()
+      const maybe = optional.shift()
       populatePositional(maybe, argv, yargs, positionalMap)
     }
 
@@ -270,9 +263,9 @@ module.exports = function (yargs, usage, validation) {
     // "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++) {
+    let variadics = null
+    let value = null
+    for (let 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)
@@ -289,7 +282,7 @@ module.exports = function (yargs, usage, validation) {
 
   // TODO move positional arg logic to yargs-parser and remove this duplication
   function postProcessPositional (yargs, argv, key) {
-    var coerce = yargs.getOptions().coerce[key]
+    const coerce = yargs.getOptions().coerce[key]
     if (typeof coerce === 'function') {
       try {
         argv[key] = coerce(argv[key])
@@ -307,7 +300,7 @@ module.exports = function (yargs, usage, validation) {
     }
   }
 
-  self.reset = function () {
+  self.reset = () => {
     handlers = {}
     aliasMap = {}
     defaultCommand = undefined
@@ -318,14 +311,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

package/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,15 +78,15 @@ 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) {
+    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)
     return script.replace(/{{app_path}}/g, $0)
@@ -95,8 +95,8 @@ module.exports = function (yargs, usage, command) {
   // 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
   }
 

package/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
   }

package/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]
     }