yargs 8.0.0 → 9.0.1

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

package/lib/yerror.js

@@ -1,3 +1,4 @@
+'use strict'
 function YError (msg) {
   this.name = 'YError'
   this.message = msg || 'yargs error'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yargs",
-  "version": "8.0.0",
+  "version": "9.0.1",
   "description": "yargs the modern, pirate-themed, successor to optimist.",
   "main": "./index.js",
   "files": [
@@ -12,19 +12,19 @@
     "LICENSE"
   ],
   "dependencies": {
-    "camelcase": "^3.0.0",
+    "camelcase": "^4.1.0",
     "cliui": "^3.2.0",
     "decamelize": "^1.1.1",
     "get-caller-file": "^1.0.1",
-    "os-locale": "^1.4.0",
-    "read-pkg-up": "^1.0.1",
+    "os-locale": "^2.0.0",
+    "read-pkg-up": "^2.0.0",
     "require-directory": "^2.1.1",
     "require-main-filename": "^1.0.1",
     "set-blocking": "^2.0.0",
-    "string-width": "^1.0.2",
-    "which-module": "^1.0.0",
+    "string-width": "^2.0.0",
+    "which-module": "^2.0.0",
     "y18n": "^3.2.1",
-    "yargs-parser": "^6.0.1"
+    "yargs-parser": "^7.0.0"
   },
   "devDependencies": {
     "chai": "^3.4.1",
@@ -38,7 +38,7 @@
     "nyc": "^10.3.0",
     "rimraf": "^2.5.0",
     "standard": "^8.6.0",
-    "standard-version": "^3.0.0",
+    "standard-version": "^4.2.0",
     "which": "^1.2.9",
     "yargs-test-extends": "^1.0.1"
   },
@@ -69,13 +69,6 @@
   ],
   "license": "MIT",
   "engine": {
-    "node": ">=0.10"
-  },
-  "greenkeeper": {
-    "ignore": [
-      "string-width",
-      "read-pkg-up",
-      "camelcase"
-    ]
+    "node": ">=4"
   }
 }