diff -Nru node-yargs-parser-4.1.0/appveyor.yml node-yargs-parser-8.0.0/appveyor.yml
--- node-yargs-parser-4.1.0/appveyor.yml 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/appveyor.yml 2017-10-05 06:20:38.000000000 +0000
@@ -2,7 +2,7 @@
matrix:
- nodejs_version: '5'
- nodejs_version: '4'
- - nodejs_version: '0.12'
+ - nodejs_version: '7'
install:
- ps: Install-Product node $env:nodejs_version
- set CI=true
diff -Nru node-yargs-parser-4.1.0/CHANGELOG.md node-yargs-parser-8.0.0/CHANGELOG.md
--- node-yargs-parser-4.1.0/CHANGELOG.md 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/CHANGELOG.md 2017-10-05 06:20:38.000000000 +0000
@@ -2,6 +2,121 @@
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+# [8.0.0](https://github.com/yargs/yargs-parser/compare/v7.0.0...v8.0.0) (2017-10-05)
+
+
+### Bug Fixes
+
+* Ignore multiple spaces between arguments. ([#100](https://github.com/yargs/yargs-parser/issues/100)) ([d137227](https://github.com/yargs/yargs-parser/commit/d137227))
+
+
+### Features
+
+* allow configuration of prefix for boolean negation ([#94](https://github.com/yargs/yargs-parser/issues/94)) ([00bde7d](https://github.com/yargs/yargs-parser/commit/00bde7d))
+* reworking how numbers are parsed ([#104](https://github.com/yargs/yargs-parser/issues/104)) ([fba00eb](https://github.com/yargs/yargs-parser/commit/fba00eb))
+
+
+### BREAKING CHANGES
+
+* strings that fail `Number.isSafeInteger()` are no longer coerced into numbers.
+
+
+
+
+# [7.0.0](https://github.com/yargs/yargs-parser/compare/v6.0.1...v7.0.0) (2017-05-02)
+
+
+### Chores
+
+* revert populate-- logic ([#91](https://github.com/yargs/yargs-parser/issues/91)) ([6003e6d](https://github.com/yargs/yargs-parser/commit/6003e6d))
+
+
+### BREAKING CHANGES
+
+* populate-- now defaults to false.
+
+
+
+
+## [6.0.1](https://github.com/yargs/yargs-parser/compare/v6.0.0...v6.0.1) (2017-05-01)
+
+
+### Bug Fixes
+
+* default '--' to undefined when not provided; this is closer to the array API ([#90](https://github.com/yargs/yargs-parser/issues/90)) ([4e739cc](https://github.com/yargs/yargs-parser/commit/4e739cc))
+
+
+
+
+# [6.0.0](https://github.com/yargs/yargs-parser/compare/v4.2.1...v6.0.0) (2017-05-01)
+
+
+### Bug Fixes
+
+* environment variables should take precedence over config file ([#81](https://github.com/yargs/yargs-parser/issues/81)) ([76cee1f](https://github.com/yargs/yargs-parser/commit/76cee1f))
+* parsing hints should apply for dot notation keys ([#86](https://github.com/yargs/yargs-parser/issues/86)) ([3e47d62](https://github.com/yargs/yargs-parser/commit/3e47d62))
+
+
+### Chores
+
+* upgrade to newest version of camelcase ([#87](https://github.com/yargs/yargs-parser/issues/87)) ([f1903aa](https://github.com/yargs/yargs-parser/commit/f1903aa))
+
+
+### Features
+
+* add -- option which allows arguments after the -- flag to be returned separated from positional arguments ([#84](https://github.com/yargs/yargs-parser/issues/84)) ([2572ca8](https://github.com/yargs/yargs-parser/commit/2572ca8))
+* when parsing stops, we now populate "--" by default ([#88](https://github.com/yargs/yargs-parser/issues/88)) ([cd666db](https://github.com/yargs/yargs-parser/commit/cd666db))
+
+
+### BREAKING CHANGES
+
+* rather than placing arguments in "_", when parsing is stopped via "--"; we now populate an array called "--" by default.
+* camelcase now requires Node 4+.
+* environment variables will now override config files (args, env, config-file, config-object)
+
+
+
+
+# [5.0.0](https://github.com/yargs/yargs-parser/compare/v4.2.1...v5.0.0) (2017-02-18)
+
+
+### Bug Fixes
+
+* environment variables should take precedence over config file ([#81](https://github.com/yargs/yargs-parser/issues/81)) ([76cee1f](https://github.com/yargs/yargs-parser/commit/76cee1f))
+
+
+### BREAKING CHANGES
+
+* environment variables will now override config files (args, env, config-file, config-object)
+
+
+
+
+## [4.2.1](https://github.com/yargs/yargs-parser/compare/v4.2.0...v4.2.1) (2017-01-02)
+
+
+### Bug Fixes
+
+* flatten/duplicate regression ([#75](https://github.com/yargs/yargs-parser/issues/75)) ([68d68a0](https://github.com/yargs/yargs-parser/commit/68d68a0))
+
+
+
+
+# [4.2.0](https://github.com/yargs/yargs-parser/compare/v4.1.0...v4.2.0) (2016-12-01)
+
+
+### Bug Fixes
+
+* inner objects in configs had their keys appended to top-level key when dot-notation was disabled ([#72](https://github.com/yargs/yargs-parser/issues/72)) ([0b1b5f9](https://github.com/yargs/yargs-parser/commit/0b1b5f9))
+
+
+### Features
+
+* allow multiple arrays to be provided, rather than always combining ([#71](https://github.com/yargs/yargs-parser/issues/71)) ([0f0fb2d](https://github.com/yargs/yargs-parser/commit/0f0fb2d))
+
+
+
# [4.1.0](https://github.com/yargs/yargs-parser/compare/v4.0.2...v4.1.0) (2016-11-07)
diff -Nru node-yargs-parser-4.1.0/debian/changelog node-yargs-parser-8.0.0/debian/changelog
--- node-yargs-parser-4.1.0/debian/changelog 2016-11-26 11:06:29.000000000 +0000
+++ node-yargs-parser-8.0.0/debian/changelog 2017-12-04 15:56:02.000000000 +0000
@@ -1,3 +1,10 @@
+node-yargs-parser (8.0.0-1) unstable; urgency=medium
+
+ * Team upload
+ * New upstream release
+
+ -- Pirate Praveen Mon, 04 Dec 2017 21:26:02 +0530
+
node-yargs-parser (4.1.0-1) unstable; urgency=medium
* Team upload
diff -Nru node-yargs-parser-4.1.0/debian/control node-yargs-parser-8.0.0/debian/control
--- node-yargs-parser-4.1.0/debian/control 2016-11-26 11:06:29.000000000 +0000
+++ node-yargs-parser-8.0.0/debian/control 2017-12-04 15:56:02.000000000 +0000
@@ -1,5 +1,5 @@
Source: node-yargs-parser
-Section: web
+Section: javascript
Priority: optional
Maintainer: Debian Javascript Maintainers
Uploaders: Sruthi Chandran
@@ -7,7 +7,7 @@
debhelper (>= 9)
, dh-buildinfo
, nodejs
-Standards-Version: 3.9.8
+Standards-Version: 4.1.1
Homepage: https://github.com/yargs/yargs-parser#readme
Vcs-Git: https://anonscm.debian.org/git/pkg-javascript/node-yargs-parser.git
Vcs-Browser: https://anonscm.debian.org/cgit/pkg-javascript/node-yargs-parser.git
diff -Nru node-yargs-parser-4.1.0/index.js node-yargs-parser-8.0.0/index.js
--- node-yargs-parser-4.1.0/index.js 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/index.js 2017-10-05 06:20:38.000000000 +0000
@@ -15,11 +15,17 @@
'camel-case-expansion': true,
'dot-notation': true,
'parse-numbers': true,
- 'boolean-negation': true
+ 'boolean-negation': true,
+ 'negation-prefix': 'no-',
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': true,
+ 'populate--': false
}, opts.configuration)
var defaults = opts.default || {}
var configObjects = opts.configObjects || []
var envPrefix = opts.envPrefix
+ var notFlagsOption = configuration['populate--']
+ var notFlagsArgv = notFlagsOption ? '--' : '_'
var newAliases = {}
// allow a i18n handler to be passed in, default to a fake one (util.format).
var __ = opts.__ || function (str) {
@@ -40,6 +46,7 @@
coercions: {}
}
var negative = /^-[0-9]+(\.[0-9]+)?/
+ var negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
;[].concat(opts.array).filter(Boolean).forEach(function (key) {
flags.arrays[key] = true
@@ -136,8 +143,8 @@
} else {
setArg(m[1], m[2])
}
- } else if (arg.match(/^--no-.+/) && configuration['boolean-negation']) {
- key = arg.match(/^--no-(.+)/)[1]
+ } else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
+ key = arg.match(negatedBoolean)[1]
setArg(key, false)
// -- seperated by space.
@@ -263,22 +270,20 @@
}
}
} else {
- argv._.push(
- flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
- )
+ argv._.push(maybeCoerceNumber('_', arg))
}
}
// order of precedence:
// 1. command line arg
- // 2. value from config file
- // 3. value from config objects
- // 4. value from env var
+ // 2. value from env var
+ // 3. value from config file
+ // 4. value from config objects
// 5. configured default value
applyEnvVars(argv, true) // special case: check env vars that point to config file
+ applyEnvVars(argv, false)
setConfig(argv)
setConfigObjects()
- applyEnvVars(argv, false)
applyDefaultsAndAliases(argv, flags.aliases, defaults)
applyCoercions(argv)
@@ -287,8 +292,10 @@
if (!hasKey(argv, key.split('.'))) setArg(key, 0)
})
+ // '--' defaults to undefined.
+ if (notFlagsOption && notFlags.length) argv[notFlagsArgv] = []
notFlags.forEach(function (key) {
- argv._.push(key)
+ argv[notFlagsArgv].push(key)
})
// how many arguments should we consume, based
@@ -310,15 +317,27 @@
// 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
}
i = ii
- setArg(key, args[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)
+ })
}
return i
@@ -327,33 +346,11 @@
function setArg (key, val) {
unsetDefaulted(key)
- // handle parsing boolean arguments --foo=true --bar false.
- if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
- if (typeof val === 'string') val = val === 'true'
+ if (/-/.test(key) && configuration['camel-case-expansion']) {
+ addNewAlias(key, camelCase(key))
}
- if (/-/.test(key) && !(flags.aliases[key] && flags.aliases[key].length) && configuration['camel-case-expansion']) {
- var c = camelCase(key)
- flags.aliases[key] = [c]
- newAliases[c] = true
- }
-
- var value = val
- if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.coercions)) {
- if (isNumber(val)) value = Number(val)
- if (!isUndefined(val) && !isNumber(val) && checkAllAliases(key, flags.numbers)) value = NaN
- }
-
- // increment a count given as arg (either no value or value parsed as boolean)
- if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
- value = increment
- }
-
- // Set normalized value when key is in 'normalize' and in 'arrays'
- if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
- if (Array.isArray(val)) value = val.map(path.normalize)
- else value = path.normalize(val)
- }
+ var value = processValue(key, val)
var splitKey = key.split('.')
setKey(argv, splitKey, value)
@@ -395,6 +392,45 @@
}
}
+ function addNewAlias (key, alias) {
+ if (!(flags.aliases[key] && flags.aliases[key].length)) {
+ flags.aliases[key] = [alias]
+ newAliases[alias] = true
+ }
+ if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
+ addNewAlias(alias, key)
+ }
+ }
+
+ function processValue (key, val) {
+ // 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)
+
+ // increment a count given as arg (either no value or value parsed as boolean)
+ if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
+ value = increment
+ }
+
+ // Set normalized value when key is in 'normalize' and in 'arrays'
+ if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
+ if (Array.isArray(val)) value = val.map(path.normalize)
+ else value = path.normalize(val)
+ }
+ return value
+ }
+
+ function maybeCoerceNumber (key, value) {
+ if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.coercions)) {
+ const shouldCoerceNumber = isNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(parseInt(value)))
+ if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) value = Number(value)
+ }
+ return value
+ }
+
// set args from config.json file, this should be
// applied last so that defaults can be applied.
function setConfig (argv) {
@@ -440,7 +476,10 @@
var value = config[key]
var fullKey = prev ? prev + '.' + key : key
- if (Object.prototype.toString.call(value) === '[object Object]') {
+ // if the value is an inner object and we have dot-notation
+ // enabled, treat inner objects in config the same as
+ // heavily nested dot notations (foo.bar.apple).
+ if (typeof value === 'object' && !Array.isArray(value) && configuration['dot-notation']) {
// if the value is an object but not an array, check nested object
setConfigObject(value, fullKey)
} else {
@@ -536,16 +575,26 @@
var key = keys[keys.length - 1]
+ var isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
+ var isValueArray = Array.isArray(value)
+ var duplicate = configuration['duplicate-arguments-array']
+
if (value === increment) {
o[key] = increment(o[key])
- } else if (o[key] === undefined && checkAllAliases(key, flags.arrays)) {
- o[key] = Array.isArray(value) ? value : [value]
- } else if (o[key] === undefined || checkAllAliases(key, flags.bools) || checkAllAliases(keys.join('.'), flags.bools) || checkAllAliases(key, flags.counts)) {
- o[key] = value
} else if (Array.isArray(o[key])) {
- o[key].push(value)
- } else {
+ if (duplicate && isTypeArray && isValueArray) {
+ o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : [o[key]].concat([value])
+ } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
+ o[key] = value
+ } else {
+ o[key] = o[key].concat([value])
+ }
+ } 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))) {
o[key] = [ o[key], value ]
+ } else {
+ o[key] = value
}
}
@@ -563,7 +612,9 @@
flags.aliases[key].concat(key).forEach(function (x) {
if (/-/.test(x) && configuration['camel-case-expansion']) {
var c = camelCase(x)
- flags.aliases[key].push(c)
+ if (flags.aliases[key].indexOf(c) === -1) {
+ flags.aliases[key].push(c)
+ }
newAliases[c] = true
}
})
@@ -625,7 +676,6 @@
}
function isNumber (x) {
- if (!configuration['parse-numbers']) return false
if (typeof x === 'number') return true
if (/^0x[0-9a-f]+$/i.test(x)) return true
return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
diff -Nru node-yargs-parser-4.1.0/lib/tokenize-arg-string.js node-yargs-parser-8.0.0/lib/tokenize-arg-string.js
--- node-yargs-parser-4.1.0/lib/tokenize-arg-string.js 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/lib/tokenize-arg-string.js 2017-10-05 06:20:38.000000000 +0000
@@ -3,16 +3,20 @@
if (Array.isArray(argString)) return argString
var i = 0
+ var prevC = null
var c = null
var opening = null
var args = []
for (var ii = 0; ii < argString.length; ii++) {
+ prevC = c
c = argString.charAt(ii)
// split on spaces unless we're in quotes.
if (c === ' ' && !opening) {
- i++
+ if (!(prevC === ' ')) {
+ i++
+ }
continue
}
diff -Nru node-yargs-parser-4.1.0/package.json node-yargs-parser-8.0.0/package.json
--- node-yargs-parser-4.1.0/package.json 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/package.json 2017-10-05 06:20:38.000000000 +0000
@@ -1,6 +1,6 @@
{
"name": "yargs-parser",
- "version": "4.1.0",
+ "version": "8.0.0",
"description": "the mighty option parser used by yargs",
"main": "index.js",
"scripts": {
@@ -29,12 +29,12 @@
"chai": "^3.5.0",
"coveralls": "^2.11.12",
"mocha": "^3.0.1",
- "nyc": "^8.1.0",
- "standard": "^8.0.0",
- "standard-version": "^3.0.0"
+ "nyc": "^11.2.1",
+ "standard": "^10.0.2",
+ "standard-version": "^4.0.0"
},
"dependencies": {
- "camelcase": "^3.0.0"
+ "camelcase": "^4.1.0"
},
"files": [
"lib",
diff -Nru node-yargs-parser-4.1.0/README.md node-yargs-parser-8.0.0/README.md
--- node-yargs-parser-4.1.0/README.md 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/README.md 2017-10-05 06:20:38.000000000 +0000
@@ -11,7 +11,7 @@
visit the [yargs website](http://yargs.js.org/) for more examples, and thorough usage instructions.
-
+
## Example
@@ -72,12 +72,14 @@
* `opts.string`: keys should be treated as strings (even if they resemble a number `-x 33`).
* `opts.configuration`: provide configuration options to the yargs-parser (see: [configuration](#configuration)).
* `opts.number`: keys should be treated as numbers.
+ * `opts['--']`: arguments after the end-of-options flag `--` will be set to the `argv.['--']` array instead of being set to the `argv._` array.
**returns:**
* `obj`: an object representing the parsed value of `args`
* `key/value`: key value pairs for each argument and their aliases.
* `_`: an array representing the positional arguments.
+ * [optional] `--`: an array with arguments after the end-of-options flag `--`.
### require('yargs-parser').detailed(args, opts={})
@@ -100,6 +102,7 @@
* `configuration`: the configuration loaded from the `yargs` stanza in package.json.
+
### Configuration
The yargs-parser applies several automated transformations on the keys provided
@@ -174,7 +177,7 @@
### parse numbers
* default: `true`
-* key: 'parse-numbers'
+* key: `parse-numbers`
Should keys that look like numbers be treated as such?
@@ -193,7 +196,7 @@
### boolean negation
* default: `true`
-* key: 'boolean-negation'
+* key: `boolean-negation`
Should variables prefixed with `--no` be treated as negations?
@@ -209,6 +212,84 @@
{ _: [], "no-foo": true }
```
+### duplicate arguments array
+
+* default: `true`
+* key: `duplicate-arguments-array`
+
+Should arguments be coerced into an array when duplicated:
+
+```sh
+node example.js -x 1 -x 2
+{ _: [], x: [1, 2] }
+```
+
+_if disabled:_
+
+```sh
+node example.js -x 1 -x 2
+{ _: [], x: 2 }
+```
+
+### flatten duplicate arrays
+
+* default: `true`
+* key: `flatten-duplicate-arrays`
+
+Should array arguments be coerced into a single array when duplicated:
+
+```sh
+node example.js -x 1 2 -x 3 4
+{ _: [], x: [1, 2, 3, 4] }
+```
+
+_if disabled:_
+
+```sh
+node example.js -x 1 2 -x 3 4
+{ _: [], x: [[1, 2], [3, 4]] }
+```
+
+### negation prefix
+
+* default: `no-`
+* key: `negation-prefix`
+
+The prefix to use for negated boolean variables.
+
+```sh
+node example.js --no-foo
+{ _: [], foo: false }
+```
+
+_if set to `quux`:_
+
+```sh
+node example.js --quuxfoo
+{ _: [], foo: false }
+```
+
+### populate --
+
+* default: `false`.
+* key: `populate--`
+
+Should unparsed flags be stored in `--` or `_`.
+
+_If disabled:_
+
+```sh
+node example.js a -b -- x y
+{ _: [ 'a', 'x', 'y' ], b: true }
+```
+
+_If enabled:_
+
+```sh
+node example.js a -b -- x y
+{ _: [ 'a' ], '--': [ 'x', 'y' ], b: true }
+```
+
## Special Thanks
The yargs project evolves from optimist and minimist. It owes its
diff -Nru node-yargs-parser-4.1.0/test/tokenize-arg-string.js node-yargs-parser-8.0.0/test/tokenize-arg-string.js
--- node-yargs-parser-4.1.0/test/tokenize-arg-string.js 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/test/tokenize-arg-string.js 2017-10-05 06:20:38.000000000 +0000
@@ -3,6 +3,7 @@
var tokenizeArgString = require('../lib/tokenize-arg-string')
require('chai').should()
+var expect = require('chai').expect
describe('TokenizeArgString', function () {
it('handles unquoted string', function () {
@@ -37,4 +38,11 @@
args[1].should.equal('hello \'world\'')
args[2].should.equal('--bar=foo "bar"')
})
+
+ it('multiple spaces only counted in quotes', function () {
+ var args = tokenizeArgString('foo bar "foo bar"')
+ args[0].should.equal('foo')
+ expect(args[1]).equal('bar')
+ expect(args[2]).equal('foo bar')
+ })
})
diff -Nru node-yargs-parser-4.1.0/test/yargs-parser.js node-yargs-parser-8.0.0/test/yargs-parser.js
--- node-yargs-parser-4.1.0/test/yargs-parser.js 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/test/yargs-parser.js 2017-10-05 06:20:38.000000000 +0000
@@ -10,12 +10,14 @@
describe('yargs-parser', function () {
it('should parse a "short boolean"', function () {
var parse = parser([ '-b' ])
+ parse.should.not.have.property('--')
parse.should.have.property('b').to.be.ok.and.be.a('boolean')
parse.should.have.property('_').with.length(0)
})
it('should parse a "long boolean"', function () {
var parse = parser('--bool')
+ parse.should.not.have.property('--')
parse.should.have.property('bool', true)
parse.should.have.property('_').with.length(0)
})
@@ -94,7 +96,11 @@
'--key', 'value',
'-b', '--bool', '--no-meep', '--multi=baz',
'--', '--not-a-flag', '-', '-h', '-multi', '--', 'eek'
- ])
+ ], {
+ configuration: {
+ 'populate--': false
+ }
+ })
parse.should.have.property('c', true)
parse.should.have.property('a', true)
parse.should.have.property('t', true)
@@ -955,7 +961,7 @@
boolean: ['b']
})
// Assert
- result.should.have.property('b').that.is.a('boolean').and.is.true
+ result.should.have.property('b').that.is.a('boolean').and.is.true // eslint-disable-line
result.should.have.property('_').and.deep.equal([123])
})
})
@@ -1047,11 +1053,11 @@
}
it('should set true if --flag in arg', function () {
- parser(['--flag'], opts).flag.should.be.true
+ parser(['--flag'], opts).flag.should.be.true // eslint-disable-line
})
it('should set false if --no-flag in arg', function () {
- parser(['--no-flag'], opts).flag.should.be.false
+ parser(['--no-flag'], opts).flag.should.be.false // eslint-disable-line
})
it('should set ' + def + ' if no flag in arg', function () {
@@ -1070,15 +1076,15 @@
})
it('should set true if --flag in arg', function () {
- parser(['--flag'], opts).flag.should.be.true
+ parser(['--flag'], opts).flag.should.be.true // eslint-disable-line
})
it('should set false if --no-flag in arg', function () {
- parser(['--no-flag'], opts).flag.should.be.false
+ parser(['--no-flag'], opts).flag.should.be.false // eslint-disable-line
})
it('should set false if no flag in arg', function () {
- parser([], opts).flag.should.be.false
+ parser([], opts).flag.should.be.false // eslint-disable-line
})
})
@@ -1135,8 +1141,8 @@
it('should provide options with dashes as camelCase properties', function () {
var result = parser(['--some-option'])
- result.should.have.property('some-option').that.is.a('boolean').and.is.true
- result.should.have.property('someOption').that.is.a('boolean').and.is.true
+ result.should.have.property('some-option').that.is.a('boolean').and.is.true // eslint-disable-line
+ result.should.have.property('someOption').that.is.a('boolean').and.is.true // eslint-disable-line
})
}
@@ -1156,8 +1162,8 @@
}
})
- result.should.have.property('some-option').that.is.a('boolean').and.is.true
- result.should.have.property('someOption').that.is.a('boolean').and.is.true
+ result.should.have.property('some-option').that.is.a('boolean').and.is.true // eslint-disable-line
+ result.should.have.property('someOption').that.is.a('boolean').and.is.true // eslint-disable-line
})
it('should provide defaults of options with dashes as camelCase properties', function () {
@@ -1329,13 +1335,13 @@
count: 'v',
default: { v: undefined }
})
- expect(parsed.v).to.be.undefined
+ expect(parsed.v).to.be.undefined // eslint-disable-line
parsed = parser([], {
count: 'v',
default: { v: null }
})
- expect(parsed.v).to.be.null
+ expect(parsed.v).to.be.null // eslint-disable-line
parsed = parser([], {
count: 'v',
@@ -1374,11 +1380,16 @@
})
describe('array', function () {
- it('should group values into an array if the same option is specified multiple times', function () {
- var parse = parser(['-v', 'a', '-v', 'b', '-v', 'c'])
+ it('should group values into an array if the same option is specified multiple times (duplicate-arguments-array=true)', function () {
+ var parse = parser(['-v', 'a', '-v', 'b', '-v', 'c'], {configuration: {'duplicate-arguments-array': true}})
parse.should.have.property('v').and.deep.equal(['a', 'b', 'c'])
parse.should.have.property('_').with.length(0)
})
+ it('should keep only the last value if the same option is specified multiple times (duplicate-arguments-false)', function () {
+ var parse = parser(['-v', 'a', '-v', 'b', '-v', 'c'], {configuration: {'duplicate-arguments-array': false}})
+ parse.should.have.property('v').and.equal('c')
+ parse.should.have.property('_').with.length(0)
+ })
it('should default an array to an empty array if passed as first option followed by another', function () {
var result = parser(['-a', '-b'], {
@@ -1623,8 +1634,8 @@
result.eggs.should.equal('sam')
result.ham.should.equal('iam')
- expect(result.oneFish).to.be.undefined
- expect(result.redFish).to.be.undefined
+ expect(result.oneFish).to.be.undefined // eslint-disable-line
+ expect(result.redFish).to.be.undefined // eslint-disable-line
})
it('should set aliases for options defined by env var', function () {
@@ -1692,7 +1703,7 @@
})
var jsonPath = path.resolve(__dirname, './fixtures/config.json')
- it('should prefer config file value over env var', function () {
+ it('should prefer environment variables over config file', function () {
process.env.CFG_HERP = 'zerp'
var result = parser(['--cfg', jsonPath], {
envPrefix: 'CFG',
@@ -1703,7 +1714,7 @@
}
})
- result.herp.should.equal('derp')
+ result.herp.should.equal('zerp')
})
it('should support an env var value as config file option', function () {
@@ -1886,6 +1897,31 @@
expect(parsed['foo.bar']).to.equal('banana')
expect(parsed).not.to.include.keys('f.bar')
})
+
+ // addresses https://github.com/yargs/yargs/issues/716
+ it('does not append nested-object keys from config to top-level key', function () {
+ var parsed = parser([], {
+ alias: {
+ 'foo': ['f']
+ },
+ configuration: {
+ 'dot-notation': false
+ },
+ configObjects: [
+ {
+ 'website.com': {
+ a: 'b',
+ b: 'c'
+ }
+ }
+ ]
+ })
+
+ parsed['website.com'].should.deep.equal({
+ a: 'b',
+ b: 'c'
+ })
+ })
})
describe('parse numbers', function () {
@@ -1919,6 +1955,17 @@
})
expect(parsed._[0]).to.equal('5')
})
+
+ it('parses number if option explicitly set to number type', function () {
+ var parsed = parser(['--foo', '5', '--bar', '6'], {
+ number: 'bar',
+ configuration: {
+ 'parse-numbers': false
+ }
+ })
+ expect(parsed['foo']).to.equal('5')
+ expect(parsed['bar']).to.equal(6)
+ })
})
describe('boolean negation', function () {
@@ -1932,6 +1979,295 @@
parsed['no-dice'].should.equal(true)
expect(parsed.dice).to.equal(undefined)
})
+
+ it('negates boolean arguments with correct prefix', function () {
+ var parsed = parser(['--foodice'], {
+ configuration: {
+ 'negation-prefix': 'foo'
+ }
+ })
+
+ expect(parsed['dice']).to.equal(false)
+ })
+ })
+
+ describe('duplicate arguments array', function () {
+ it('adds duplicate argument to array', function () {
+ var parsed = parser('-x a -x b', {
+ configuration: {
+ 'duplicate-arguments-array': true
+ }
+ })
+
+ parsed['x'].should.deep.equal(['a', 'b'])
+ })
+ it('keeps only last argument', function () {
+ var parsed = parser('-x a -x b', {
+ configuration: {
+ 'duplicate-arguments-array': false
+ }
+ })
+
+ parsed['x'].should.equal('b')
+ })
+ })
+
+ describe('flatten duplicate arrays', function () {
+ it('flattens duplicate array type', function () {
+ var parsed = parser('-x a b -x c d', {
+ array: ['x'],
+ configuration: {
+ 'flatten-duplicate-arrays': true
+ }
+ })
+
+ parsed['x'].should.deep.equal(['a', 'b', 'c', 'd'])
+ })
+ it('nests duplicate array types', function () {
+ var parsed = parser('-x a b -x c d', {
+ array: ['x'],
+ configuration: {
+ 'flatten-duplicate-arrays': false
+ }
+ })
+
+ parsed['x'].should.deep.equal([['a', 'b'], ['c', 'd']])
+ })
+ it('doesn\'t nests single arrays', function () {
+ var parsed = parser('-x a b', {
+ array: ['x'],
+ configuration: {
+ 'flatten-duplicate-arrays': false
+ }
+ })
+
+ parsed['x'].should.deep.equal(['a', 'b'])
+ })
+
+ it('flattens duplicate array type, when argument uses dot notation', function () {
+ var parsed = parser('-x.foo a -x.foo b', {
+ array: ['x.foo'],
+ configuration: {
+ 'flatten-duplicate-arrays': true
+ }
+ })
+
+ parsed['x'].should.deep.equal({foo: ['a', 'b']})
+ })
+ })
+
+ describe('duplicate-arguments-array VS flatten-duplicate-arrays', function () {
+ /*
+ duplicate=false, flatten=false
+ type=array
+ [-x 1 2 3] => [1, 2, 3]
+ [-x 1 2 3 -x 2 3 4] => [2, 3, 4]
+ type=string/number/etc
+ [-x 1 -x 2 -x 3] => 3
+
+ duplicate=false, flatten=true
+ type=array
+ [-x 1 2 3] => [1, 2, 3]
+ [-x 1 2 3 -x 2 3 4] => [2, 3, 4]
+ type=string/number/etc
+ [-x 1 -x 2 -x 3] => 3
+
+ duplicate=true, flatten=true
+ type=array
+ [-x 1 2 3] => [1, 2, 3]
+ [-x 1 2 3 -x 2 3 4] => [1, 2, 3, 2, 3, 4]
+ type=string/number/etc
+ [-x 1 -x 2 -x 3] => [1, 2, 3]
+
+ duplicate=true, flatten=false
+ type=array
+ [-x 1 2 3] => [1, 2, 3]
+ [-x 1 2 3 -x 2 3 4] => [[1, 2, 3], [2, 3, 4]]
+ type=string/number/etc
+ [-x 1 -x 2 -x 3] => [1, 2, 3]
+ */
+ describe('duplicate=false, flatten=false,', function () {
+ describe('type=array', function () {
+ it('[-x 1 2 3] => [1, 2, 3]', function () {
+ var parsed = parser('-x 1 2 3', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': false,
+ 'flatten-duplicate-arrays': false
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3])
+ })
+ it('[-x 1 2 3 -x 2 3 4] => [2, 3, 4]', function () {
+ var parsed = parser('-x 1 2 3 -x 2 3 4', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': false,
+ 'flatten-duplicate-arrays': false
+ }
+ })
+ parsed['x'].should.deep.equal([2, 3, 4])
+ })
+ })
+ describe('type=number', function () {
+ it('[-x 1 -x 2 -x 3] => 3', function () {
+ var parsed = parser('-x 1 -x 2 -x 3', {
+ number: 'x',
+ configuration: {
+ 'duplicate-arguments-array': false,
+ 'flatten-duplicate-arrays': false
+ }
+ })
+ parsed['x'].should.deep.equal(3)
+ })
+ })
+ })
+ describe('duplicate=false, flatten=true,', function () {
+ describe('type=array', function () {
+ it('[-x 1 2 3] => [1, 2, 3]', function () {
+ var parsed = parser('-x 1 2 3', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': false,
+ 'flatten-duplicate-arrays': true
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3])
+ })
+ it('[-x 1 2 3 -x 2 3 4] => [2, 3, 4]', function () {
+ var parsed = parser('-x 1 2 3 -x 2 3 4', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': false,
+ 'flatten-duplicate-arrays': true
+ }
+ })
+ parsed['x'].should.deep.equal([2, 3, 4])
+ })
+ })
+ describe('type=number', function () {
+ it('[-x 1 -x 2 -x 3] => 3', function () {
+ var parsed = parser('-x 1 -x 2 -x 3', {
+ number: 'x',
+ configuration: {
+ 'duplicate-arguments-array': false,
+ 'flatten-duplicate-arrays': true
+ }
+ })
+ parsed['x'].should.deep.equal(3)
+ })
+ })
+ })
+ describe('duplicate=true, flatten=true,', function () {
+ describe('type=array', function () {
+ it('[-x 1 2 3] => [1, 2, 3]', function () {
+ var parsed = parser('-x 1 2 3', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': true
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3])
+ })
+ it('[-x 1 2 3 -x 2 3 4] => [1, 2, 3, 2, 3, 4]', function () {
+ var parsed = parser('-x 1 2 3 -x 2 3 4', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': true
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3, 2, 3, 4])
+ })
+ })
+ describe('type=number', function () {
+ it('[-x 1 -x 2 -x 3] => [1, 2, 3]', function () {
+ var parsed = parser('-x 1 -x 2 -x 3', {
+ number: 'x',
+ configuration: {
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': true
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3])
+ })
+ })
+ })
+ describe('duplicate=true, flatten=false,', function () {
+ describe('type=array', function () {
+ it('[-x 1 -x 2 -x 3] => [1, 2, 3]', function () {
+ var parsed = parser('-x 1 -x 2 -x 3', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': false
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3])
+ })
+ it('[-x 1 2 3 -x 2 3 4] => [[1, 2, 3], [ 2, 3, 4]]', function () {
+ var parsed = parser('-x 1 2 3 -x 2 3 4', {
+ array: ['x'],
+ configuration: {
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': false
+ }
+ })
+ parsed['x'].should.deep.equal([[1, 2, 3], [2, 3, 4]])
+ })
+ })
+ describe('type=number', function () {
+ it('[-x 1 -x 2 -x 3] => [1, 2, 3]', function () {
+ var parsed = parser('-x 1 -x 2 -x 3', {
+ number: 'x',
+ configuration: {
+ 'duplicate-arguments-array': true,
+ 'flatten-duplicate-arrays': false
+ }
+ })
+ parsed['x'].should.deep.equal([1, 2, 3])
+ })
+ })
+ })
+ })
+
+ describe('populate--', function () {
+ it('should populate "_" by default', function () {
+ var result = parser([
+ 'bare',
+ '--', '-h', 'eek', '--'
+ ])
+ result.should.have.property('_').and.deep.equal(['bare', '-h', 'eek', '--'])
+ result.should.not.have.property('--')
+ })
+
+ it('should populate the "--" if populate-- is "true"', function () {
+ var result = parser([
+ '--name=meowmers', 'bare', '-cats', 'woo', 'moxy',
+ '-h', 'awesome', '--multi=quux',
+ '--key', 'value',
+ '-b', '--bool', '--no-meep', '--multi=baz',
+ '--', '--not-a-flag', '-', '-h', '-multi', '--', 'eek'
+ ], {
+ configuration: {
+ 'populate--': true
+ }
+ })
+ result.should.have.property('c', true)
+ result.should.have.property('a', true)
+ result.should.have.property('t', true)
+ result.should.have.property('s', 'woo')
+ result.should.have.property('h', 'awesome')
+ result.should.have.property('b', true)
+ result.should.have.property('bool', true)
+ result.should.have.property('key', 'value')
+ result.should.have.property('multi').and.deep.equal(['quux', 'baz'])
+ result.should.have.property('meep', false)
+ result.should.have.property('name', 'meowmers')
+ result.should.have.property('_').and.deep.equal(['bare', 'moxy'])
+ result.should.have.property('--').and.deep.equal(['--not-a-flag', '-', '-h', '-multi', '--', 'eek'])
+ })
})
})
@@ -2115,4 +2451,17 @@
})
argv.a.should.deep.equal(['a.txt', 'b.txt'])
})
+
+ // see: https://github.com/yargs/yargs/issues/963
+ it('does not magically convert numeric strings larger than Number.MAX_SAFE_INTEGER', () => {
+ const argv = parser([ '--foo', '93940495950949399948393' ])
+ argv.foo.should.equal('93940495950949399948393')
+ })
+
+ it('converts numeric options larger than Number.MAX_SAFE_INTEGER to number', () => {
+ const argv = parser([ '--foo', '93940495950949399948393' ], {
+ number: ['foo']
+ })
+ argv.foo.should.equal(9.39404959509494e+22)
+ })
})
diff -Nru node-yargs-parser-4.1.0/.travis.yml node-yargs-parser-8.0.0/.travis.yml
--- node-yargs-parser-4.1.0/.travis.yml 2016-11-07 06:30:55.000000000 +0000
+++ node-yargs-parser-8.0.0/.travis.yml 2017-10-05 06:20:38.000000000 +0000
@@ -2,9 +2,8 @@
os:
- linux
node_js:
- - "0.10"
- - "0.12"
- - "4.1"
+ - "4"
+ - "6"
- "node"
after_script: npm run coverage
deploy: