D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
opt
/
alt
/
alt-nodejs14
/
root
/
usr
/
lib
/
node_modules
/
npm
/
node_modules.bundled
/
yargs
/
lib
/
Filename :
validation.js
back
Copy
'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) { const __ = y18n.__ const __n = y18n.__n const self = {} // validate appropriate # of non-option // arguments were provided, i.e., '_'. self.nonOptionCount = function nonOptionCount (argv) { const demandedCommands = yargs.getDemandedCommands() // don't count currently executing commands const _s = argv._.length - yargs.getContext().commands.length if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) { if (_s < demandedCommands._.min) { if (demandedCommands._.minMsg !== undefined) { usage.fail( // replace $0 with observed, $1 with expected. demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s).replace(/\$1/, demandedCommands._.min) : null ) } else { usage.fail( __('Not enough non-option arguments: got %s, need at least %s', _s, demandedCommands._.min) ) } } else if (_s > demandedCommands._.max) { if (demandedCommands._.maxMsg !== undefined) { usage.fail( // replace $0 with observed, $1 with expected. demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s).replace(/\$1/, demandedCommands._.max) : null ) } else { usage.fail( __('Too many non-option arguments: got %s, maximum of %s', _s, demandedCommands._.max) ) } } } } // validate the appropriate # of <required> // positional arguments were provided: self.positionalCount = function positionalCount (required, observed) { if (observed < required) { usage.fail( __('Not enough non-option arguments: got %s, need at least %s', observed, required) ) } } // make sure all the required arguments are present. self.requiredArguments = function requiredArguments (argv) { const demandedOptions = yargs.getDemandedOptions() let missing = null Object.keys(demandedOptions).forEach((key) => { if (!argv.hasOwnProperty(key) || typeof argv[key] === 'undefined') { missing = missing || {} missing[key] = demandedOptions[key] } }) if (missing) { const customMsgs = [] 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')}` : '' usage.fail(__n( 'Missing required argument: %s', 'Missing required arguments: %s', Object.keys(missing).length, Object.keys(missing).join(', ') + customMsg )) } } // check for unknown arguments (strict-mode). self.unknownArguments = function unknownArguments (argv, aliases, positionalMap) { const commandKeys = yargs.getCommandInstance().getCommands() const unknown = [] const currentContext = yargs.getContext() Object.keys(argv).forEach((key) => { if (specialKeys.indexOf(key) === -1 && !positionalMap.hasOwnProperty(key) && !yargs._getParseContext().hasOwnProperty(key) && !self.isValidAndSomeAliasIsNotNew(key, aliases) ) { unknown.push(key) } }) if ((currentContext.commands.length > 0) || (commandKeys.length > 0)) { argv._.slice(currentContext.commands.length).forEach((key) => { if (commandKeys.indexOf(key) === -1) { unknown.push(key) } }) } if (unknown.length > 0) { usage.fail(__n( 'Unknown argument: %s', 'Unknown arguments: %s', unknown.length, unknown.join(', ') )) } } // check for a key that is not an alias, or for which every alias is new, // implying that it was invented by the parser, e.g., during camelization self.isValidAndSomeAliasIsNotNew = function isValidAndSomeAliasIsNotNew (key, aliases) { if (!aliases.hasOwnProperty(key)) { return false } const newAliases = yargs.parsed.newAliases for (let a of [key, ...aliases[key]]) { if (!newAliases.hasOwnProperty(a) || !newAliases[key]) { return true } } return false } // validate arguments limited to enumerated choices self.limitedChoices = function limitedChoices (argv) { const options = yargs.getOptions() const invalid = {} if (!Object.keys(options.choices).length) return Object.keys(argv).forEach((key) => { if (specialKeys.indexOf(key) === -1 && options.choices.hasOwnProperty(key)) { [].concat(argv[key]).forEach((value) => { // TODO case-insensitive configurability if (options.choices[key].indexOf(value) === -1 && value !== undefined) { invalid[key] = (invalid[key] || []).concat(value) } }) } }) const invalidKeys = Object.keys(invalid) if (!invalidKeys.length) return 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. let checks = [] self.check = function check (f, global) { checks.push({ func: f, global }) } 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) { usage.fail(err.message ? err.message : err, err) continue } if (!result) { usage.fail(__('Argument check failed: %s', func.toString())) } else if (typeof result === 'string' || result instanceof Error) { usage.fail(result.toString(), result) } } } // 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) if (typeof key === 'object') { Object.keys(key).forEach((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) } } } self.getImplied = function getImplied () { return implied } function keyExists (argv, val) { // convert string '1' to number 1 let num = Number(val) val = isNaN(num) ? val : num if (typeof val === 'number') { // check length of argv._ val = argv._.length >= val } else if (val.match(/^--no-.+/)) { // check if key/value doesn't exist val = val.match(/^--no-(.+)/)[1] val = !argv[val] } else { // check if key/value exists val = argv[val] } return val } self.implications = function implications (argv) { const implyFail = [] Object.keys(implied).forEach((key) => { const origKey = key ;(implied[key] || []).forEach((value) => { let key = origKey const origValue = value key = keyExists(argv, key) value = keyExists(argv, value) if (key && !value) { implyFail.push(` ${origKey} -> ${origValue}`) } }) }) if (implyFail.length) { let msg = `${__('Implications failed:')}\n` implyFail.forEach((value) => { msg += (value) }) usage.fail(msg) } } 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((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) } } } 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 %s and %s are mutually exclusive', key, value)) } }) } }) } 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((a, b) => 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) if (d <= threshold && d < bestDistance) { bestDistance = d recommended = candidate } } 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) return self } let frozens = [] self.freeze = function freeze () { let frozen = {} frozens.push(frozen) frozen.implied = implied frozen.checks = checks frozen.conflicting = conflicting } self.unfreeze = function unfreeze () { let frozen = frozens.pop() implied = frozen.implied checks = frozen.checks conflicting = frozen.conflicting } return self }