Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/npm/cli.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/node_modules/yargs-parser/index.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/yargs-parser/index.js')
-rw-r--r--node_modules/yargs-parser/index.js349
1 files changed, 253 insertions, 96 deletions
diff --git a/node_modules/yargs-parser/index.js b/node_modules/yargs-parser/index.js
index d39414b73..726855321 100644
--- a/node_modules/yargs-parser/index.js
+++ b/node_modules/yargs-parser/index.js
@@ -1,4 +1,5 @@
var camelCase = require('camelcase')
+var decamelize = require('decamelize')
var path = require('path')
var tokenizeArgString = require('./lib/tokenize-arg-string')
var util = require('util')
@@ -8,9 +9,10 @@ function parse (args, opts) {
// allow a string argument to be passed in rather
// than an argv array.
args = tokenizeArgString(args)
+
// aliases might have transitive relationships, normalize this.
var aliases = combineAliases(opts.alias || {})
- var configuration = assign({
+ var configuration = Object.assign({
'short-option-groups': true,
'camel-case-expansion': true,
'dot-notation': true,
@@ -20,7 +22,12 @@ function parse (args, opts) {
'duplicate-arguments-array': true,
'flatten-duplicate-arrays': true,
'populate--': false,
- 'combine-arrays': false
+ 'combine-arrays': false,
+ 'set-placeholder-key': false,
+ 'halt-at-non-option': false,
+ 'strip-aliased': false,
+ 'strip-dashed': false,
+ 'unknown-options-as-args': false
}, opts.configuration)
var defaults = opts.default || {}
var configObjects = opts.configObjects || []
@@ -29,9 +36,7 @@ function parse (args, opts) {
var notFlagsArgv = notFlagsOption ? '--' : '_'
var newAliases = {}
// allow a i18n handler to be passed in, default to a fake one (util.format).
- var __ = opts.__ || function (str) {
- return util.format.apply(util, Array.prototype.slice.call(arguments))
- }
+ var __ = opts.__ || util.format
var error = null
var flags = {
aliases: {},
@@ -42,43 +47,67 @@ function parse (args, opts) {
counts: {},
normalize: {},
configs: {},
- defaulted: {},
nargs: {},
- coercions: {}
+ coercions: {},
+ keys: []
}
var negative = /^-[0-9]+(\.[0-9]+)?/
var negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
- ;[].concat(opts.array).filter(Boolean).forEach(function (key) {
+ ;[].concat(opts.array).filter(Boolean).forEach(function (opt) {
+ var key = opt.key || opt
+
+ // assign to flags[bools|strings|numbers]
+ const assignment = Object.keys(opt).map(function (key) {
+ return ({
+ boolean: 'bools',
+ string: 'strings',
+ number: 'numbers'
+ })[key]
+ }).filter(Boolean).pop()
+
+ // assign key to be coerced
+ if (assignment) {
+ flags[assignment][key] = true
+ }
+
flags.arrays[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.boolean).filter(Boolean).forEach(function (key) {
flags.bools[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.string).filter(Boolean).forEach(function (key) {
flags.strings[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.number).filter(Boolean).forEach(function (key) {
flags.numbers[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.count).filter(Boolean).forEach(function (key) {
flags.counts[key] = true
+ flags.keys.push(key)
})
;[].concat(opts.normalize).filter(Boolean).forEach(function (key) {
flags.normalize[key] = true
+ flags.keys.push(key)
})
Object.keys(opts.narg || {}).forEach(function (k) {
flags.nargs[k] = opts.narg[k]
+ flags.keys.push(k)
})
Object.keys(opts.coerce || {}).forEach(function (k) {
flags.coercions[k] = opts.coerce[k]
+ flags.keys.push(k)
})
if (Array.isArray(opts.config) || typeof opts.config === 'string') {
@@ -103,17 +132,7 @@ function parse (args, opts) {
})
var argv = { _: [] }
-
- Object.keys(flags.bools).forEach(function (key) {
- setArg(key, !(key in defaults) ? false : defaults[key])
- setDefaulted(key)
- })
-
var notFlags = []
- if (args.indexOf('--') !== -1) {
- notFlags = args.slice(args.indexOf('--') + 1)
- args = args.slice(0, args.indexOf('--'))
- }
for (var i = 0; i < args.length; i++) {
var arg = args[i]
@@ -124,8 +143,10 @@ function parse (args, opts) {
var next
var value
- // -- seperated by =
- if (arg.match(/^--.+=/) || (
+ if (isUnknownOptionAsArg(arg)) {
+ argv._.push(arg)
+ // -- separated by =
+ } else if (arg.match(/^--.+=/) || (
!configuration['short-option-groups'] && arg.match(/^-.+=/)
)) {
// Using [\s\S] instead of . because js doesn't support the
@@ -138,7 +159,7 @@ function parse (args, opts) {
args.splice(i + 1, 0, m[2])
i = eatNargs(i, m[1], args)
// arrays format = '--f=a b c'
- } else if (checkAllAliases(m[1], flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(m[1], flags.arrays)) {
args.splice(i + 1, 0, m[2])
i = eatArray(i, m[1], args)
} else {
@@ -146,19 +167,20 @@ function parse (args, opts) {
}
} else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
key = arg.match(negatedBoolean)[1]
- setArg(key, false)
+ setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false)
- // -- seperated by space.
+ // -- separated by space.
} else if (arg.match(/^--.+/) || (
- !configuration['short-option-groups'] && arg.match(/^-.+/)
+ !configuration['short-option-groups'] && arg.match(/^-[^-]+/)
)) {
key = arg.match(/^--?(.+)/)[1]
// nargs format = '--foo a b c'
- if (checkAllAliases(key, flags.nargs)) {
+ // should be truthy even if: flags.nargs[key] === 0
+ if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args)
// array format = '--foo a b c'
- } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args)
} else {
next = args[i + 1]
@@ -173,16 +195,16 @@ function parse (args, opts) {
setArg(key, next)
i++
} else {
- setArg(key, defaultForType(guessType(key, flags)))
+ setArg(key, defaultValue(key))
}
}
- // dot-notation flag seperated by '='.
+ // dot-notation flag separated by '='.
} else if (arg.match(/^-.\..+=/)) {
m = arg.match(/^-([^=]+)=([\s\S]*)$/)
setArg(m[1], m[2])
- // dot-notation flag seperated by space.
+ // dot-notation flag separated by space.
} else if (arg.match(/^-.\..+/)) {
next = args[i + 1]
key = arg.match(/^-(.\..+)/)[1]
@@ -193,7 +215,7 @@ function parse (args, opts) {
setArg(key, next)
i++
} else {
- setArg(key, defaultForType(guessType(key, flags)))
+ setArg(key, defaultValue(key))
}
} else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
letters = arg.slice(1, -1).split('')
@@ -211,7 +233,7 @@ function parse (args, opts) {
args.splice(i + 1, 0, value)
i = eatNargs(i, key, args)
// array format = '-f=a b c'
- } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(key, flags.arrays)) {
args.splice(i + 1, 0, value)
i = eatArray(i, key, args)
} else {
@@ -240,7 +262,7 @@ function parse (args, opts) {
broken = true
break
} else {
- setArg(letters[j], defaultForType(guessType(letters[j], flags)))
+ setArg(letters[j], defaultValue(letters[j]))
}
}
@@ -248,10 +270,11 @@ function parse (args, opts) {
if (!broken && key !== '-') {
// nargs format = '-f a b c'
- if (checkAllAliases(key, flags.nargs)) {
+ // should be truthy even if: flags.nargs[key] === 0
+ if (checkAllAliases(key, flags.nargs) !== false) {
i = eatNargs(i, key, args)
// array format = '-f a b c'
- } else if (checkAllAliases(key, flags.arrays) && args.length > i + 1) {
+ } else if (checkAllAliases(key, flags.arrays)) {
i = eatArray(i, key, args)
} else {
next = args[i + 1]
@@ -266,10 +289,16 @@ function parse (args, opts) {
setArg(key, next)
i++
} else {
- setArg(key, defaultForType(guessType(key, flags)))
+ setArg(key, defaultValue(key))
}
}
}
+ } else if (arg === '--') {
+ notFlags = args.slice(i + 1)
+ break
+ } else if (configuration['halt-at-non-option']) {
+ notFlags = args.slice(i)
+ break
} else {
argv._.push(maybeCoerceNumber('_', arg))
}
@@ -287,6 +316,7 @@ function parse (args, opts) {
setConfigObjects()
applyDefaultsAndAliases(argv, flags.aliases, defaults)
applyCoercions(argv)
+ if (configuration['set-placeholder-key']) setPlaceholderKeys(argv)
// for any counts either not in args or without an explicit default, set to 0
Object.keys(flags.counts).forEach(function (key) {
@@ -299,17 +329,39 @@ function parse (args, opts) {
argv[notFlagsArgv].push(key)
})
+ if (configuration['camel-case-expansion'] && configuration['strip-dashed']) {
+ Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
+ delete argv[key]
+ })
+ }
+
+ if (configuration['strip-aliased']) {
+ // XXX Switch to [].concat(...Object.values(aliases)) once node.js 6 is dropped
+ ;[].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => {
+ if (configuration['camel-case-expansion']) {
+ delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')]
+ }
+
+ delete argv[alias]
+ })
+ }
+
// how many arguments should we consume, based
// on the nargs option?
function eatNargs (i, key, args) {
var ii
const toEat = checkAllAliases(key, flags.nargs)
+ if (toEat === 0) {
+ setArg(key, defaultValue(key))
+ return i
+ }
+
// nargs will not consume flag arguments, e.g., -abc, --foo,
// and terminates when one is observed.
var available = 0
for (ii = i + 1; ii < args.length; ii++) {
- if (!args[ii].match(/^-[^0-9]/)) available++
+ if (!args[ii].match(/^-[^0-9]/) || isUnknownOptionAsArg(args[ii])) available++
else break
}
@@ -327,38 +379,36 @@ function parse (args, opts) {
// following it... YUM!
// e.g., --foo apple banana cat becomes ["apple", "banana", "cat"]
function eatArray (i, key, args) {
- var start = i + 1
- var argsToSet = []
- var multipleArrayFlag = i > 0
- for (var ii = i + 1; ii < args.length; ii++) {
- if (/^-/.test(args[ii]) && !negative.test(args[ii])) {
- if (ii === start) {
- setArg(key, defaultForType('array'))
- }
- multipleArrayFlag = true
- break
+ let argsToSet = []
+ let next = args[i + 1]
+
+ if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
+ argsToSet.push(true)
+ } else if (isUndefined(next) || (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) {
+ // for keys without value ==> argsToSet remains an empty []
+ // set user default value, if available
+ if (defaults.hasOwnProperty(key)) {
+ argsToSet.push(defaults[key])
}
- i = ii
- argsToSet.push(args[ii])
- }
- if (multipleArrayFlag) {
- setArg(key, argsToSet.map(function (arg) {
- return processValue(key, arg)
- }))
} else {
- argsToSet.forEach(function (arg) {
- setArg(key, arg)
- })
+ for (var ii = i + 1; ii < args.length; ii++) {
+ next = args[ii]
+ if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) break
+ i = ii
+ argsToSet.push(processValue(key, next))
+ }
}
+ setArg(key, argsToSet)
return i
}
function setArg (key, val) {
- unsetDefaulted(key)
-
if (/-/.test(key) && configuration['camel-case-expansion']) {
- addNewAlias(key, camelCase(key))
+ var alias = key.split('.').map(function (prop) {
+ return camelCase(prop)
+ }).join('.')
+ addNewAlias(key, alias)
}
var value = processValue(key, val)
@@ -367,7 +417,7 @@ function parse (args, opts) {
setKey(argv, splitKey, value)
// handle populating aliases of the full key
- if (flags.aliases[key]) {
+ if (flags.aliases[key] && flags.aliases[key].forEach) {
flags.aliases[key].forEach(function (x) {
x = x.split('.')
setKey(argv, x, value)
@@ -414,12 +464,22 @@ function parse (args, opts) {
}
function processValue (key, val) {
+ // strings may be quoted, clean this up as we assign values.
+ if (typeof val === 'string' &&
+ (val[0] === "'" || val[0] === '"') &&
+ val[val.length - 1] === val[0]
+ ) {
+ val = val.substring(1, val.length - 1)
+ }
+
// handle parsing boolean arguments --foo=true --bar false.
if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
if (typeof val === 'string') val = val === 'true'
}
- var value = maybeCoerceNumber(key, val)
+ var value = Array.isArray(val)
+ ? val.map(function (v) { return maybeCoerceNumber(key, v) })
+ : maybeCoerceNumber(key, val)
// increment a count given as arg (either no value or value parsed as boolean)
if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
@@ -435,7 +495,7 @@ function parse (args, opts) {
}
function maybeCoerceNumber (key, value) {
- if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.coercions)) {
+ if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
const shouldCoerceNumber = isNumber(value) && configuration['parse-numbers'] && (
Number.isSafeInteger(Math.floor(value))
)
@@ -498,7 +558,7 @@ function parse (args, opts) {
} else {
// setting arguments via CLI takes precedence over
// values within the config file.
- if (!hasKey(argv, fullKey.split('.')) || (flags.defaulted[fullKey]) || (flags.arrays[fullKey] && configuration['combine-arrays'])) {
+ if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) {
setArg(fullKey, value)
}
}
@@ -527,7 +587,7 @@ function parse (args, opts) {
return camelCase(key)
})
- if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && (!hasKey(argv, keys) || flags.defaulted[keys.join('.')])) {
+ if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) {
setArg(keys.join('.'), process.env[envVar])
}
}
@@ -542,7 +602,7 @@ function parse (args, opts) {
coerce = checkAllAliases(key, flags.coercions)
if (typeof coerce === 'function') {
try {
- var value = coerce(argv[key])
+ var value = maybeCoerceNumber(key, coerce(argv[key]))
;([].concat(flags.aliases[key] || [], key)).forEach(ali => {
applied[ali] = argv[ali] = value
})
@@ -554,6 +614,15 @@ function parse (args, opts) {
})
}
+ function setPlaceholderKeys (argv) {
+ flags.keys.forEach((key) => {
+ // don't set placeholder keys for dot notation options 'foo.bar'.
+ if (~key.indexOf('.')) return
+ if (typeof argv[key] === 'undefined') argv[key] = undefined
+ })
+ return argv
+ }
+
function applyDefaultsAndAliases (obj, aliases, defaults) {
Object.keys(defaults).forEach(function (key) {
if (!hasKey(obj, key.split('.'))) {
@@ -588,6 +657,10 @@ function parse (args, opts) {
if (!configuration['dot-notation']) keys = [keys.join('.')]
keys.slice(0, -1).forEach(function (key, index) {
+ // TODO(bcoe): in the next major version of yargs, switch to
+ // Object.create(null) for dot notation:
+ key = sanitizeKey(key)
+
if (typeof o === 'object' && o[key] === undefined) {
o[key] = {}
}
@@ -607,17 +680,27 @@ function parse (args, opts) {
}
})
- var key = keys[keys.length - 1]
+ // TODO(bcoe): in the next major version of yargs, switch to
+ // Object.create(null) for dot notation:
+ const key = sanitizeKey(keys[keys.length - 1])
+
+ const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
+ const isValueArray = Array.isArray(value)
+ let duplicate = configuration['duplicate-arguments-array']
- var isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
- var isValueArray = Array.isArray(value)
- var duplicate = configuration['duplicate-arguments-array']
+ // nargs has higher priority than duplicate
+ if (!duplicate && checkAllAliases(key, flags.nargs)) {
+ duplicate = true
+ if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) {
+ o[key] = undefined
+ }
+ }
if (value === increment) {
o[key] = increment(o[key])
} else if (Array.isArray(o[key])) {
if (duplicate && isTypeArray && isValueArray) {
- o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : [o[key]].concat([value])
+ o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value])
} else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
o[key] = value
} else {
@@ -625,7 +708,7 @@ function parse (args, opts) {
}
} else if (o[key] === undefined && isTypeArray) {
o[key] = isValueArray ? value : [value]
- } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.bools) || checkAllAliases(keys.join('.'), flags.bools) || checkAllAliases(key, flags.counts))) {
+ } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.counts))) {
o[key] = [ o[key], value ]
} else {
o[key] = value
@@ -633,8 +716,8 @@ function parse (args, opts) {
}
// extend the aliases list with inferred aliases.
- function extendAliases () {
- Array.prototype.slice.call(arguments).forEach(function (obj) {
+ function extendAliases (...args) {
+ args.forEach(function (obj) {
Object.keys(obj || {}).forEach(function (key) {
// short-circuit if we've already added a key
// to the aliases array, for example it might
@@ -652,6 +735,16 @@ function parse (args, opts) {
}
}
})
+ // For "--optionName", also set argv['option-name']
+ flags.aliases[key].concat(key).forEach(function (x) {
+ if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) {
+ var c = decamelize(x, '-')
+ if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+ flags.aliases[key].push(c)
+ newAliases[c] = true
+ }
+ }
+ })
flags.aliases[key].forEach(function (x) {
flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
return x !== y
@@ -667,24 +760,89 @@ function parse (args, opts) {
var toCheck = [].concat(flags.aliases[key] || [], key)
toCheck.forEach(function (key) {
- if (flag[key]) isSet = flag[key]
+ if (flag.hasOwnProperty(key)) isSet = flag[key]
})
return isSet
}
- function setDefaulted (key) {
- [].concat(flags.aliases[key] || [], key).forEach(function (k) {
- flags.defaulted[k] = true
+ function hasAnyFlag (key) {
+ // XXX Switch to [].concat(...Object.values(flags)) once node.js 6 is dropped
+ var toCheck = [].concat(...Object.keys(flags).map(k => flags[k]))
+
+ return toCheck.some(function (flag) {
+ return flag[key]
})
}
- function unsetDefaulted (key) {
- [].concat(flags.aliases[key] || [], key).forEach(function (k) {
- delete flags.defaulted[k]
+ function hasFlagsMatching (arg, ...patterns) {
+ var toCheck = [].concat(...patterns)
+ return toCheck.some(function (pattern) {
+ var match = arg.match(pattern)
+ return match && hasAnyFlag(match[1])
})
}
+ // based on a simplified version of the short flag group parsing logic
+ function hasAllShortFlags (arg) {
+ // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group
+ if (arg.match(negative) || !arg.match(/^-[^-]+/)) { return false }
+ var hasAllFlags = true
+ var letters = arg.slice(1).split('')
+ var next
+ for (var j = 0; j < letters.length; j++) {
+ next = arg.slice(j + 2)
+
+ if (!hasAnyFlag(letters[j])) {
+ hasAllFlags = false
+ break
+ }
+
+ if ((letters[j + 1] && letters[j + 1] === '=') ||
+ next === '-' ||
+ (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) ||
+ (letters[j + 1] && letters[j + 1].match(/\W/))) {
+ break
+ }
+ }
+ return hasAllFlags
+ }
+
+ function isUnknownOptionAsArg (arg) {
+ return configuration['unknown-options-as-args'] && isUnknownOption(arg)
+ }
+
+ function isUnknownOption (arg) {
+ // ignore negative numbers
+ if (arg.match(negative)) { return false }
+ // if this is a short option group and all of them are configured, it isn't unknown
+ if (hasAllShortFlags(arg)) { return false }
+ // e.g. '--count=2'
+ const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/
+ // e.g. '-a' or '--arg'
+ const normalFlag = /^-+([^=]+?)$/
+ // e.g. '-a-'
+ const flagEndingInHyphen = /^-+([^=]+?)-$/
+ // e.g. '-abc123'
+ const flagEndingInDigits = /^-+([^=]+?)\d+$/
+ // e.g. '-a/usr/local'
+ const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/
+ // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method
+ return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters)
+ }
+
+ // make a best effor to pick a default value
+ // for an option based on name and type.
+ function defaultValue (key) {
+ if (!checkAllAliases(key, flags.bools) &&
+ !checkAllAliases(key, flags.counts) &&
+ `${key}` in defaults) {
+ return defaults[key]
+ } else {
+ return defaultForType(guessType(key))
+ }
+ }
+
// return a default value, given the type of a flag.,
// e.g., key of type 'string' will default to '', rather than 'true'.
function defaultForType (type) {
@@ -699,20 +857,26 @@ function parse (args, opts) {
}
// given a flag, enforce a default type.
- function guessType (key, flags) {
+ function guessType (key) {
var type = 'boolean'
if (checkAllAliases(key, flags.strings)) type = 'string'
else if (checkAllAliases(key, flags.numbers)) type = 'number'
+ else if (checkAllAliases(key, flags.bools)) type = 'boolean'
else if (checkAllAliases(key, flags.arrays)) type = 'array'
return type
}
function isNumber (x) {
+ if (x === null || x === undefined) return false
+ // if loaded from config, may already be a number.
if (typeof x === 'number') return true
+ // hexadecimal.
if (/^0x[0-9a-f]+$/i.test(x)) return true
- return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
+ // don't treat 0123 as a number; as it drops the leading '0'.
+ if (x.length > 1 && x[0] === '0') return false
+ return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
}
function isUndefined (num) {
@@ -775,20 +939,6 @@ function combineAliases (aliases) {
return combined
}
-function assign (defaults, configuration) {
- var o = {}
- configuration = configuration || {}
-
- Object.keys(defaults).forEach(function (k) {
- o[k] = defaults[k]
- })
- Object.keys(configuration).forEach(function (k) {
- o[k] = configuration[k]
- })
-
- return o
-}
-
// this function should only be called when a count is given as an arg
// it is NOT called to set a default value
// thus we can start the count at 1 instead of 0
@@ -808,4 +958,11 @@ Parser.detailed = function (args, opts) {
return parse(args.slice(), opts)
}
+// TODO(bcoe): in the next major version of yargs, switch to
+// Object.create(null) for dot notation:
+function sanitizeKey (key) {
+ if (key === '__proto__') return '___proto___'
+ return key
+}
+
module.exports = Parser
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-16 11:07:35 +0300