nav tabs on admin dashboard

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
@@ -35,7 +37,7 @@ module.exports = function (yargs, usage, y18n) {
           )
         } else {
           usage.fail(
-          __('Too many non-option arguments: got %s, maximum of %s', _s, demandedCommands._.max)
+            __('Too many non-option arguments: got %s, maximum of %s', _s, demandedCommands._.max)
           )
         }
       }
@@ -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)
@@ -52,44 +54,12 @@ module.exports = function (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 (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 +68,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 +87,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 +121,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 +144,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 +185,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]
+      ;(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
+        // 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 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)
-      }
+        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.getConflicting = () => 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.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 %s and %s are mutually exclusive', key, value))
+          }
+        })
       }
     })
   }
 
-  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 +316,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