1 files changed, 145 insertions, 122 deletions

diff --git a/deps/npm/node_modules/libnpx/node_modules/yargs/lib/validation.js b/deps/npm/node_modules/libnpx/node_modules/yargs/lib/validation.js
index f4655b4fdc..2f9ff8e6cf 100644
--- a/deps/npm/node_modules/libnpx/node_modules/yargs/lib/validation.js
+++ b/deps/npm/node_modules/libnpx/node_modules/yargs/lib/validation.js
@@ -1,18 +1,16 @@
-'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 validation (yargs, usage, y18n) {
+module.exports = function (yargs, usage, y18n) {
   const __ = y18n.__
   const __n = y18n.__n
   const self = {}
 
   // validate appropriate # of non-option
   // arguments were provided, i.e., '_'.
-  self.nonOptionCount = function nonOptionCount (argv) {
+  self.nonOptionCount = function (argv) {
     const demandedCommands = yargs.getDemandedCommands()
     // don't count currently executing commands
     const _s = argv._.length - yargs.getContext().commands.length
@@ -46,7 +44,7 @@ module.exports = function validation (yargs, usage, y18n) {
 
   // validate the appropriate # of <required>
   // positional arguments were provided:
-  self.positionalCount = function positionalCount (required, observed) {
+  self.positionalCount = function (required, observed) {
     if (observed < required) {
       usage.fail(
         __('Not enough non-option arguments: got %s, need at least %s', observed, required)
@@ -54,12 +52,44 @@ module.exports = function validation (yargs, usage, y18n) {
     }
   }
 
+  // make sure that any args that require an
+  // value (--foo=bar), have a value.
+  self.missingArgumentValue = function (argv) {
+    const defaultValues = [true, false, '']
+    const options = yargs.getOptions()
+
+    if (options.requiresArg.length > 0) {
+      const missingRequiredArgs = []
+
+      options.requiresArg.forEach(function (key) {
+        const value = argv[key]
+
+        // if a value is explicitly requested,
+        // flag argument as missing if it does not
+        // look like foo=bar was entered.
+        if (~defaultValues.indexOf(value) ||
+          (Array.isArray(value) && !value.length)) {
+          missingRequiredArgs.push(key)
+        }
+      })
+
+      if (missingRequiredArgs.length > 0) {
+        usage.fail(__n(
+          'Missing argument value: %s',
+          'Missing argument values: %s',
+          missingRequiredArgs.length,
+          missingRequiredArgs.join(', ')
+        ))
+      }
+    }
+  }
+
   // make sure all the required arguments are present.
-  self.requiredArguments = function requiredArguments (argv) {
+  self.requiredArguments = function (argv) {
     const demandedOptions = yargs.getDemandedOptions()
-    let missing = null
+    var missing = null
 
-    Object.keys(demandedOptions).forEach((key) => {
+    Object.keys(demandedOptions).forEach(function (key) {
       if (!argv.hasOwnProperty(key) || typeof argv[key] === 'undefined') {
         missing = missing || {}
         missing[key] = demandedOptions[key]
@@ -68,14 +98,14 @@ module.exports = function validation (yargs, usage, y18n) {
 
     if (missing) {
       const customMsgs = []
-      Object.keys(missing).forEach((key) => {
+      Object.keys(missing).forEach(function (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',
@@ -87,23 +117,33 @@ module.exports = function validation (yargs, usage, y18n) {
   }
 
   // check for unknown arguments (strict-mode).
-  self.unknownArguments = function unknownArguments (argv, aliases, positionalMap) {
+  self.unknownArguments = function (argv, aliases, positionalMap) {
+    const aliasLookup = {}
+    const descriptions = usage.getDescriptions()
+    const demandedOptions = yargs.getDemandedOptions()
     const commandKeys = yargs.getCommandInstance().getCommands()
     const unknown = []
     const currentContext = yargs.getContext()
 
-    Object.keys(argv).forEach((key) => {
+    Object.keys(aliases).forEach(function (key) {
+      aliases[key].forEach(function (alias) {
+        aliasLookup[alias] = key
+      })
+    })
+
+    Object.keys(argv).forEach(function (key) {
       if (specialKeys.indexOf(key) === -1 &&
+        !descriptions.hasOwnProperty(key) &&
+        !demandedOptions.hasOwnProperty(key) &&
         !positionalMap.hasOwnProperty(key) &&
         !yargs._getParseContext().hasOwnProperty(key) &&
-        !aliases.hasOwnProperty(key)
-      ) {
+        !aliasLookup.hasOwnProperty(key)) {
         unknown.push(key)
       }
     })
 
     if (commandKeys.length > 0) {
-      argv._.slice(currentContext.commands.length).forEach((key) => {
+      argv._.slice(currentContext.commands.length).forEach(function (key) {
         if (commandKeys.indexOf(key) === -1) {
           unknown.push(key)
         }
@@ -121,19 +161,18 @@ module.exports = function validation (yargs, usage, y18n) {
   }
 
   // validate arguments limited to enumerated choices
-  self.limitedChoices = function limitedChoices (argv) {
+  self.limitedChoices = function (argv) {
     const options = yargs.getOptions()
     const invalid = {}
 
     if (!Object.keys(options.choices).length) return
 
-    Object.keys(argv).forEach((key) => {
+    Object.keys(argv).forEach(function (key) {
       if (specialKeys.indexOf(key) === -1 &&
         options.choices.hasOwnProperty(key)) {
-        [].concat(argv[key]).forEach((value) => {
+        [].concat(argv[key]).forEach(function (value) {
           // TODO case-insensitive configurability
-          if (options.choices[key].indexOf(value) === -1 &&
-              value !== undefined) {
+          if (options.choices[key].indexOf(value) === -1) {
             invalid[key] = (invalid[key] || []).concat(value)
           }
         })
@@ -144,31 +183,31 @@ module.exports = function validation (yargs, usage, y18n) {
 
     if (!invalidKeys.length) return
 
-    let msg = __('Invalid values:')
-    invalidKeys.forEach((key) => {
-      msg += `\n  ${__(
+    var msg = __('Invalid values:')
+    invalidKeys.forEach(function (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.
-  let checks = []
-  self.check = function check (f, global) {
+  var checks = []
+  self.check = function (f, global) {
     checks.push({
       func: f,
-      global
+      global: global
     })
   }
 
-  self.customChecks = function customChecks (argv, aliases) {
-    for (let i = 0, f; (f = checks[i]) !== undefined; i++) {
-      const func = f.func
-      let result = null
+  self.customChecks = function (argv, aliases) {
+    for (var i = 0, f; (f = checks[i]) !== undefined; i++) {
+      var func = f.func
+      var result = null
       try {
         result = func(argv, aliases)
       } catch (err) {
@@ -185,129 +224,107 @@ module.exports = function validation (yargs, usage, y18n) {
   }
 
   // check implications, argument foo implies => argument bar.
-  let implied = {}
-  self.implies = function implies (key, value) {
-    argsert('<string|object> [array|number|string]', [key, value], arguments.length)
-
+  var implied = {}
+  self.implies = function (key, value) {
     if (typeof key === 'object') {
-      Object.keys(key).forEach((k) => {
+      Object.keys(key).forEach(function (k) {
         self.implies(k, key[k])
       })
     } else {
       yargs.global(key)
-      if (!implied[key]) {
-        implied[key] = []
-      }
-      if (Array.isArray(value)) {
-        value.forEach((i) => self.implies(key, i))
-      } else {
-        implied[key].push(value)
-      }
+      implied[key] = value
     }
   }
-  self.getImplied = function getImplied () {
+  self.getImplied = function () {
     return implied
   }
 
-  self.implications = function implications (argv) {
+  self.implications = function (argv) {
     const implyFail = []
 
-    Object.keys(implied).forEach((key) => {
+    Object.keys(implied).forEach(function (key) {
+      var num
       const origKey = key
-      ;(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]
-        }
+      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
+      num = Number(value)
+      value = isNaN(num) ? value : num
 
-        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 (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)
+      }
     })
 
     if (implyFail.length) {
-      let msg = `${__('Implications failed:')}\n`
+      var msg = __('Implications failed:') + '\n'
 
-      implyFail.forEach((value) => {
-        msg += (value)
+      implyFail.forEach(function (key) {
+        msg += ('  ' + key + ' -> ' + implied[key])
       })
 
       usage.fail(msg)
     }
   }
 
-  let conflicting = {}
-  self.conflicts = function conflicts (key, value) {
-    argsert('<string|object> [array|string]', [key, value], arguments.length)
-
+  var conflicting = {}
+  self.conflicts = function (key, value) {
     if (typeof key === 'object') {
-      Object.keys(key).forEach((k) => {
+      Object.keys(key).forEach(function (k) {
         self.conflicts(k, key[k])
       })
     } else {
       yargs.global(key)
-      if (!conflicting[key]) {
-        conflicting[key] = []
-      }
-      if (Array.isArray(value)) {
-        value.forEach((i) => self.conflicts(key, i))
-      } else {
-        conflicting[key].push(value)
-      }
+      conflicting[key] = value
     }
   }
-  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.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.recommendCommands = function recommendCommands (cmd, potentialCommands) {
+  self.recommendCommands = function (cmd, potentialCommands) {
     const distance = require('./levenshtein')
     const threshold = 3 // if it takes more than three edits, let's move on.
-    potentialCommands = potentialCommands.sort((a, b) => b.length - a.length)
+    potentialCommands = potentialCommands.sort(function (a, b) { return b.length - a.length })
 
-    let recommended = null
-    let bestDistance = Infinity
-    for (let i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
-      const d = distance(cmd, candidate)
+    var recommended = null
+    var bestDistance = Infinity
+    for (var i = 0, candidate; (candidate = potentialCommands[i]) !== undefined; i++) {
+      var d = distance(cmd, candidate)
       if (d <= threshold && d < bestDistance) {
         bestDistance = d
         recommended = candidate
@@ -316,21 +333,27 @@ module.exports = function validation (yargs, usage, y18n) {
     if (recommended) usage.fail(__('Did you mean %s?', recommended))
   }
 
-  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)
+  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
+    })
     return self
   }
 
-  let frozen
-  self.freeze = function freeze () {
+  var frozen
+  self.freeze = function () {
     frozen = {}
     frozen.implied = implied
     frozen.checks = checks
     frozen.conflicting = conflicting
   }
-  self.unfreeze = function unfreeze () {
+  self.unfreeze = function () {
     implied = frozen.implied
     checks = frozen.checks
     conflicting = frozen.conflicting