minimist
Advanced tools
Comparing version 1.2.7 to 1.2.8
@@ -8,2 +8,48 @@ # Changelog | ||
| ## [v1.2.8](https://github.com/minimistjs/minimist/compare/v1.2.7...v1.2.8) - 2023-02-09 | ||
| ### Merged | ||
| - [Fix] Fix long option followed by single dash [`#17`](https://github.com/minimistjs/minimist/pull/17) | ||
| - [Tests] Remove duplicate test [`#12`](https://github.com/minimistjs/minimist/pull/12) | ||
| - [Fix] opt.string works with multiple aliases [`#10`](https://github.com/minimistjs/minimist/pull/10) | ||
| ### Fixed | ||
| - [Fix] Fix long option followed by single dash (#17) [`#15`](https://github.com/minimistjs/minimist/issues/15) | ||
| - [Tests] Remove duplicate test (#12) [`#8`](https://github.com/minimistjs/minimist/issues/8) | ||
| - [Fix] Fix long option followed by single dash [`#15`](https://github.com/minimistjs/minimist/issues/15) | ||
| - [Fix] opt.string works with multiple aliases (#10) [`#9`](https://github.com/minimistjs/minimist/issues/9) | ||
| - [Fix] Fix handling of short option with non-trivial equals [`#5`](https://github.com/minimistjs/minimist/issues/5) | ||
| - [Tests] Remove duplicate test [`#8`](https://github.com/minimistjs/minimist/issues/8) | ||
| - [Fix] opt.string works with multiple aliases [`#9`](https://github.com/minimistjs/minimist/issues/9) | ||
| ### Commits | ||
| - Merge tag 'v0.2.3' [`a026794`](https://github.com/minimistjs/minimist/commit/a0267947c7870fc5847cf2d437fbe33f392767da) | ||
| - [eslint] fix indentation and whitespace [`5368ca4`](https://github.com/minimistjs/minimist/commit/5368ca4147e974138a54cc0dc4cea8f756546b70) | ||
| - [eslint] fix indentation and whitespace [`e5f5067`](https://github.com/minimistjs/minimist/commit/e5f5067259ceeaf0b098d14bec910f87e58708c7) | ||
| - [eslint] more cleanup [`62fde7d`](https://github.com/minimistjs/minimist/commit/62fde7d935f83417fb046741531a9e2346a36976) | ||
| - [eslint] more cleanup [`36ac5d0`](https://github.com/minimistjs/minimist/commit/36ac5d0d95e4947d074e5737d94814034ca335d1) | ||
| - [meta] add `auto-changelog` [`73923d2`](https://github.com/minimistjs/minimist/commit/73923d223553fca08b1ba77e3fbc2a492862ae4c) | ||
| - [actions] add reusable workflows [`d80727d`](https://github.com/minimistjs/minimist/commit/d80727df77bfa9e631044d7f16368d8f09242c91) | ||
| - [eslint] add eslint; rules to enable later are warnings [`48bc06a`](https://github.com/minimistjs/minimist/commit/48bc06a1b41f00e9cdf183db34f7a51ba70e98d4) | ||
| - [eslint] fix indentation [`34b0f1c`](https://github.com/minimistjs/minimist/commit/34b0f1ccaa45183c3c4f06a91f9b405180a6f982) | ||
| - [readme] rename and add badges [`5df0fe4`](https://github.com/minimistjs/minimist/commit/5df0fe49211bd09a3636f8686a7cb3012c3e98f0) | ||
| - [Dev Deps] switch from `covert` to `nyc` [`a48b128`](https://github.com/minimistjs/minimist/commit/a48b128fdb8d427dfb20a15273f83e38d97bef07) | ||
| - [Dev Deps] update `covert`, `tape`; remove unnecessary `tap` [`f0fb958`](https://github.com/minimistjs/minimist/commit/f0fb958e9a1fe980cdffc436a211b0bda58f621b) | ||
| - [meta] create FUNDING.yml; add `funding` in package.json [`3639e0c`](https://github.com/minimistjs/minimist/commit/3639e0c819359a366387e425ab6eabf4c78d3caa) | ||
| - [meta] use `npmignore` to autogenerate an npmignore file [`be2e038`](https://github.com/minimistjs/minimist/commit/be2e038c342d8333b32f0fde67a0026b79c8150e) | ||
| - Only apps should have lockfiles [`282b570`](https://github.com/minimistjs/minimist/commit/282b570e7489d01b03f2d6d3dabf79cd3e5f84cf) | ||
| - isConstructorOrProto adapted from PR [`ef9153f`](https://github.com/minimistjs/minimist/commit/ef9153fc52b6cea0744b2239921c5dcae4697f11) | ||
| - [Dev Deps] update `@ljharb/eslint-config`, `aud` [`098873c`](https://github.com/minimistjs/minimist/commit/098873c213cdb7c92e55ae1ef5aa1af3a8192a79) | ||
| - [Dev Deps] update `@ljharb/eslint-config`, `aud` [`3124ed3`](https://github.com/minimistjs/minimist/commit/3124ed3e46306301ebb3c834874ce0241555c2c4) | ||
| - [meta] add `safe-publish-latest` [`4b927de`](https://github.com/minimistjs/minimist/commit/4b927de696d561c636b4f43bf49d4597cb36d6d6) | ||
| - [Tests] add `aud` in `posttest` [`b32d9bd`](https://github.com/minimistjs/minimist/commit/b32d9bd0ab340f4e9f8c3a97ff2a4424f25fab8c) | ||
| - [meta] update repo URLs [`f9fdfc0`](https://github.com/minimistjs/minimist/commit/f9fdfc032c54884d9a9996a390c63cd0719bbe1a) | ||
| - [actions] Avoid 0.6 tests due to build failures [`ba92fe6`](https://github.com/minimistjs/minimist/commit/ba92fe6ebbdc0431cca9a2ea8f27beb492f5e4ec) | ||
| - [Dev Deps] update `tape` [`950eaa7`](https://github.com/minimistjs/minimist/commit/950eaa74f112e04d23e9c606c67472c46739b473) | ||
| - [Dev Deps] add missing `npmignore` dev dep [`3226afa`](https://github.com/minimistjs/minimist/commit/3226afaf09e9d127ca369742437fe6e88f752d6b) | ||
| - Merge tag 'v0.2.2' [`980d7ac`](https://github.com/minimistjs/minimist/commit/980d7ac61a0b4bd552711251ac107d506b23e41f) | ||
| ## [v1.2.7](https://github.com/minimistjs/minimist/compare/v1.2.6...v1.2.7) - 2022-10-10 | ||
@@ -113,3 +159,3 @@ | ||
| ## [v1.0.0](https://github.com/minimistjs/minimist/compare/v0.2.1...v1.0.0) - 2014-08-10 | ||
| ## [v1.0.0](https://github.com/minimistjs/minimist/compare/v0.2.3...v1.0.0) - 2014-08-10 | ||
@@ -121,2 +167,42 @@ ### Commits | ||
| ## [v0.2.3](https://github.com/minimistjs/minimist/compare/v0.2.2...v0.2.3) - 2023-02-09 | ||
| ### Merged | ||
| - [Fix] Fix long option followed by single dash [`#17`](https://github.com/minimistjs/minimist/pull/17) | ||
| - [Tests] Remove duplicate test [`#12`](https://github.com/minimistjs/minimist/pull/12) | ||
| - [Fix] opt.string works with multiple aliases [`#10`](https://github.com/minimistjs/minimist/pull/10) | ||
| ### Fixed | ||
| - [Fix] Fix long option followed by single dash (#17) [`#15`](https://github.com/minimistjs/minimist/issues/15) | ||
| - [Tests] Remove duplicate test (#12) [`#8`](https://github.com/minimistjs/minimist/issues/8) | ||
| - [Fix] opt.string works with multiple aliases (#10) [`#9`](https://github.com/minimistjs/minimist/issues/9) | ||
| ### Commits | ||
| - [eslint] fix indentation and whitespace [`e5f5067`](https://github.com/minimistjs/minimist/commit/e5f5067259ceeaf0b098d14bec910f87e58708c7) | ||
| - [eslint] more cleanup [`36ac5d0`](https://github.com/minimistjs/minimist/commit/36ac5d0d95e4947d074e5737d94814034ca335d1) | ||
| - [eslint] fix indentation [`34b0f1c`](https://github.com/minimistjs/minimist/commit/34b0f1ccaa45183c3c4f06a91f9b405180a6f982) | ||
| - isConstructorOrProto adapted from PR [`ef9153f`](https://github.com/minimistjs/minimist/commit/ef9153fc52b6cea0744b2239921c5dcae4697f11) | ||
| - [Dev Deps] update `@ljharb/eslint-config`, `aud` [`098873c`](https://github.com/minimistjs/minimist/commit/098873c213cdb7c92e55ae1ef5aa1af3a8192a79) | ||
| - [Dev Deps] add missing `npmignore` dev dep [`3226afa`](https://github.com/minimistjs/minimist/commit/3226afaf09e9d127ca369742437fe6e88f752d6b) | ||
| ## [v0.2.2](https://github.com/minimistjs/minimist/compare/v0.2.1...v0.2.2) - 2022-10-10 | ||
| ### Commits | ||
| - [meta] add `auto-changelog` [`73923d2`](https://github.com/minimistjs/minimist/commit/73923d223553fca08b1ba77e3fbc2a492862ae4c) | ||
| - [actions] add reusable workflows [`d80727d`](https://github.com/minimistjs/minimist/commit/d80727df77bfa9e631044d7f16368d8f09242c91) | ||
| - [eslint] add eslint; rules to enable later are warnings [`48bc06a`](https://github.com/minimistjs/minimist/commit/48bc06a1b41f00e9cdf183db34f7a51ba70e98d4) | ||
| - [readme] rename and add badges [`5df0fe4`](https://github.com/minimistjs/minimist/commit/5df0fe49211bd09a3636f8686a7cb3012c3e98f0) | ||
| - [Dev Deps] switch from `covert` to `nyc` [`a48b128`](https://github.com/minimistjs/minimist/commit/a48b128fdb8d427dfb20a15273f83e38d97bef07) | ||
| - [Dev Deps] update `covert`, `tape`; remove unnecessary `tap` [`f0fb958`](https://github.com/minimistjs/minimist/commit/f0fb958e9a1fe980cdffc436a211b0bda58f621b) | ||
| - [meta] create FUNDING.yml; add `funding` in package.json [`3639e0c`](https://github.com/minimistjs/minimist/commit/3639e0c819359a366387e425ab6eabf4c78d3caa) | ||
| - [meta] use `npmignore` to autogenerate an npmignore file [`be2e038`](https://github.com/minimistjs/minimist/commit/be2e038c342d8333b32f0fde67a0026b79c8150e) | ||
| - Only apps should have lockfiles [`282b570`](https://github.com/minimistjs/minimist/commit/282b570e7489d01b03f2d6d3dabf79cd3e5f84cf) | ||
| - [meta] add `safe-publish-latest` [`4b927de`](https://github.com/minimistjs/minimist/commit/4b927de696d561c636b4f43bf49d4597cb36d6d6) | ||
| - [Tests] add `aud` in `posttest` [`b32d9bd`](https://github.com/minimistjs/minimist/commit/b32d9bd0ab340f4e9f8c3a97ff2a4424f25fab8c) | ||
| - [meta] update repo URLs [`f9fdfc0`](https://github.com/minimistjs/minimist/commit/f9fdfc032c54884d9a9996a390c63cd0719bbe1a) | ||
| ## [v0.2.1](https://github.com/minimistjs/minimist/compare/v0.2.0...v0.2.1) - 2020-03-12 | ||
@@ -123,0 +209,0 @@ |
@@ -0,2 +1,4 @@ | ||
| 'use strict'; | ||
| var argv = require('../')(process.argv.slice(2)); | ||
| console.log(argv); |
476
index.js
@@ -0,249 +1,263 @@ | ||
| 'use strict'; | ||
| function hasKey(obj, keys) { | ||
| var o = obj; | ||
| keys.slice(0, -1).forEach(function (key) { | ||
| o = o[key] || {}; | ||
| }); | ||
| var key = keys[keys.length - 1]; | ||
| return key in o; | ||
| } | ||
| function isNumber(x) { | ||
| if (typeof x === 'number') { return true; } | ||
| if ((/^0x[0-9a-f]+$/i).test(x)) { return true; } | ||
| return (/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/).test(x); | ||
| } | ||
| function isConstructorOrProto(obj, key) { | ||
| return (key === 'constructor' && typeof obj[key] === 'function') || key === '__proto__'; | ||
| } | ||
| module.exports = function (args, opts) { | ||
| if (!opts) opts = {}; | ||
| var flags = { bools : {}, strings : {}, unknownFn: null }; | ||
| if (!opts) { opts = {}; } | ||
| if (typeof opts['unknown'] === 'function') { | ||
| flags.unknownFn = opts['unknown']; | ||
| } | ||
| var flags = { | ||
| bools: {}, | ||
| strings: {}, | ||
| unknownFn: null, | ||
| }; | ||
| if (typeof opts['boolean'] === 'boolean' && opts['boolean']) { | ||
| flags.allBools = true; | ||
| } else { | ||
| [].concat(opts['boolean']).filter(Boolean).forEach(function (key) { | ||
| flags.bools[key] = true; | ||
| }); | ||
| } | ||
| var aliases = {}; | ||
| Object.keys(opts.alias || {}).forEach(function (key) { | ||
| aliases[key] = [].concat(opts.alias[key]); | ||
| aliases[key].forEach(function (x) { | ||
| aliases[x] = [key].concat(aliases[key].filter(function (y) { | ||
| return x !== y; | ||
| })); | ||
| }); | ||
| }); | ||
| if (typeof opts.unknown === 'function') { | ||
| flags.unknownFn = opts.unknown; | ||
| } | ||
| [].concat(opts.string).filter(Boolean).forEach(function (key) { | ||
| flags.strings[key] = true; | ||
| if (aliases[key]) { | ||
| flags.strings[aliases[key]] = true; | ||
| } | ||
| }); | ||
| if (typeof opts.boolean === 'boolean' && opts.boolean) { | ||
| flags.allBools = true; | ||
| } else { | ||
| [].concat(opts.boolean).filter(Boolean).forEach(function (key) { | ||
| flags.bools[key] = true; | ||
| }); | ||
| } | ||
| var defaults = opts['default'] || {}; | ||
| var argv = { _ : [] }; | ||
| Object.keys(flags.bools).forEach(function (key) { | ||
| setArg(key, defaults[key] === undefined ? false : defaults[key]); | ||
| }); | ||
| var notFlags = []; | ||
| var aliases = {}; | ||
| if (args.indexOf('--') !== -1) { | ||
| notFlags = args.slice(args.indexOf('--')+1); | ||
| args = args.slice(0, args.indexOf('--')); | ||
| } | ||
| function aliasIsBoolean(key) { | ||
| return aliases[key].some(function (x) { | ||
| return flags.bools[x]; | ||
| }); | ||
| } | ||
| function argDefined(key, arg) { | ||
| return (flags.allBools && /^--[^=]+$/.test(arg)) || | ||
| flags.strings[key] || flags.bools[key] || aliases[key]; | ||
| } | ||
| Object.keys(opts.alias || {}).forEach(function (key) { | ||
| aliases[key] = [].concat(opts.alias[key]); | ||
| aliases[key].forEach(function (x) { | ||
| aliases[x] = [key].concat(aliases[key].filter(function (y) { | ||
| return x !== y; | ||
| })); | ||
| }); | ||
| }); | ||
| function setArg (key, val, arg) { | ||
| if (arg && flags.unknownFn && !argDefined(key, arg)) { | ||
| if (flags.unknownFn(arg) === false) return; | ||
| } | ||
| [].concat(opts.string).filter(Boolean).forEach(function (key) { | ||
| flags.strings[key] = true; | ||
| if (aliases[key]) { | ||
| [].concat(aliases[key]).forEach(function (k) { | ||
| flags.strings[k] = true; | ||
| }); | ||
| } | ||
| }); | ||
| var value = !flags.strings[key] && isNumber(val) | ||
| ? Number(val) : val | ||
| ; | ||
| setKey(argv, key.split('.'), value); | ||
| (aliases[key] || []).forEach(function (x) { | ||
| setKey(argv, x.split('.'), value); | ||
| }); | ||
| } | ||
| var defaults = opts.default || {}; | ||
| function setKey (obj, keys, value) { | ||
| var o = obj; | ||
| for (var i = 0; i < keys.length-1; i++) { | ||
| var key = keys[i]; | ||
| if (isConstructorOrProto(o, key)) return; | ||
| if (o[key] === undefined) o[key] = {}; | ||
| if (o[key] === Object.prototype || o[key] === Number.prototype | ||
| || o[key] === String.prototype) o[key] = {}; | ||
| if (o[key] === Array.prototype) o[key] = []; | ||
| o = o[key]; | ||
| } | ||
| var argv = { _: [] }; | ||
| var key = keys[keys.length - 1]; | ||
| if (isConstructorOrProto(o, key)) return; | ||
| if (o === Object.prototype || o === Number.prototype | ||
| || o === String.prototype) o = {}; | ||
| if (o === Array.prototype) o = []; | ||
| if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') { | ||
| o[key] = value; | ||
| } | ||
| else if (Array.isArray(o[key])) { | ||
| o[key].push(value); | ||
| } | ||
| else { | ||
| o[key] = [ o[key], value ]; | ||
| } | ||
| } | ||
| function aliasIsBoolean(key) { | ||
| return aliases[key].some(function (x) { | ||
| return flags.bools[x]; | ||
| }); | ||
| } | ||
| function argDefined(key, arg) { | ||
| return (flags.allBools && (/^--[^=]+$/).test(arg)) | ||
| || flags.strings[key] | ||
| || flags.bools[key] | ||
| || aliases[key]; | ||
| } | ||
| for (var i = 0; i < args.length; i++) { | ||
| var arg = args[i]; | ||
| if (/^--.+=/.test(arg)) { | ||
| // Using [\s\S] instead of . because js doesn't support the | ||
| // 'dotall' regex modifier. See: | ||
| // http://stackoverflow.com/a/1068308/13216 | ||
| var m = arg.match(/^--([^=]+)=([\s\S]*)$/); | ||
| var key = m[1]; | ||
| var value = m[2]; | ||
| if (flags.bools[key]) { | ||
| value = value !== 'false'; | ||
| } | ||
| setArg(key, value, arg); | ||
| } | ||
| else if (/^--no-.+/.test(arg)) { | ||
| var key = arg.match(/^--no-(.+)/)[1]; | ||
| setArg(key, false, arg); | ||
| } | ||
| else if (/^--.+/.test(arg)) { | ||
| var key = arg.match(/^--(.+)/)[1]; | ||
| var next = args[i + 1]; | ||
| if (next !== undefined && !/^-/.test(next) | ||
| && !flags.bools[key] | ||
| && !flags.allBools | ||
| && (aliases[key] ? !aliasIsBoolean(key) : true)) { | ||
| setArg(key, next, arg); | ||
| i++; | ||
| } | ||
| else if (/^(true|false)$/.test(next)) { | ||
| setArg(key, next === 'true', arg); | ||
| i++; | ||
| } | ||
| else { | ||
| setArg(key, flags.strings[key] ? '' : true, arg); | ||
| } | ||
| } | ||
| else if (/^-[^-]+/.test(arg)) { | ||
| var letters = arg.slice(1,-1).split(''); | ||
| var broken = false; | ||
| for (var j = 0; j < letters.length; j++) { | ||
| var next = arg.slice(j+2); | ||
| if (next === '-') { | ||
| setArg(letters[j], next, arg) | ||
| continue; | ||
| } | ||
| if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) { | ||
| setArg(letters[j], next.split('=')[1], arg); | ||
| broken = true; | ||
| break; | ||
| } | ||
| if (/[A-Za-z]/.test(letters[j]) | ||
| && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) { | ||
| setArg(letters[j], next, arg); | ||
| broken = true; | ||
| break; | ||
| } | ||
| if (letters[j+1] && letters[j+1].match(/\W/)) { | ||
| setArg(letters[j], arg.slice(j+2), arg); | ||
| broken = true; | ||
| break; | ||
| } | ||
| else { | ||
| setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg); | ||
| } | ||
| } | ||
| var key = arg.slice(-1)[0]; | ||
| if (!broken && key !== '-') { | ||
| if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1]) | ||
| && !flags.bools[key] | ||
| && (aliases[key] ? !aliasIsBoolean(key) : true)) { | ||
| setArg(key, args[i+1], arg); | ||
| i++; | ||
| } | ||
| else if (args[i+1] && /^(true|false)$/.test(args[i+1])) { | ||
| setArg(key, args[i+1] === 'true', arg); | ||
| i++; | ||
| } | ||
| else { | ||
| setArg(key, flags.strings[key] ? '' : true, arg); | ||
| } | ||
| } | ||
| } | ||
| else { | ||
| if (!flags.unknownFn || flags.unknownFn(arg) !== false) { | ||
| argv._.push( | ||
| flags.strings['_'] || !isNumber(arg) ? arg : Number(arg) | ||
| ); | ||
| } | ||
| if (opts.stopEarly) { | ||
| argv._.push.apply(argv._, args.slice(i + 1)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| Object.keys(defaults).forEach(function (key) { | ||
| if (!hasKey(argv, key.split('.'))) { | ||
| setKey(argv, key.split('.'), defaults[key]); | ||
| (aliases[key] || []).forEach(function (x) { | ||
| setKey(argv, x.split('.'), defaults[key]); | ||
| }); | ||
| } | ||
| }); | ||
| if (opts['--']) { | ||
| argv['--'] = new Array(); | ||
| notFlags.forEach(function(key) { | ||
| argv['--'].push(key); | ||
| }); | ||
| } | ||
| else { | ||
| notFlags.forEach(function(key) { | ||
| argv._.push(key); | ||
| }); | ||
| } | ||
| function setKey(obj, keys, value) { | ||
| var o = obj; | ||
| for (var i = 0; i < keys.length - 1; i++) { | ||
| var key = keys[i]; | ||
| if (isConstructorOrProto(o, key)) { return; } | ||
| if (o[key] === undefined) { o[key] = {}; } | ||
| if ( | ||
| o[key] === Object.prototype | ||
| || o[key] === Number.prototype | ||
| || o[key] === String.prototype | ||
| ) { | ||
| o[key] = {}; | ||
| } | ||
| if (o[key] === Array.prototype) { o[key] = []; } | ||
| o = o[key]; | ||
| } | ||
| return argv; | ||
| }; | ||
| var lastKey = keys[keys.length - 1]; | ||
| if (isConstructorOrProto(o, lastKey)) { return; } | ||
| if ( | ||
| o === Object.prototype | ||
| || o === Number.prototype | ||
| || o === String.prototype | ||
| ) { | ||
| o = {}; | ||
| } | ||
| if (o === Array.prototype) { o = []; } | ||
| if (o[lastKey] === undefined || flags.bools[lastKey] || typeof o[lastKey] === 'boolean') { | ||
| o[lastKey] = value; | ||
| } else if (Array.isArray(o[lastKey])) { | ||
| o[lastKey].push(value); | ||
| } else { | ||
| o[lastKey] = [o[lastKey], value]; | ||
| } | ||
| } | ||
| function hasKey (obj, keys) { | ||
| var o = obj; | ||
| keys.slice(0,-1).forEach(function (key) { | ||
| o = (o[key] || {}); | ||
| }); | ||
| function setArg(key, val, arg) { | ||
| if (arg && flags.unknownFn && !argDefined(key, arg)) { | ||
| if (flags.unknownFn(arg) === false) { return; } | ||
| } | ||
| var key = keys[keys.length - 1]; | ||
| return key in o; | ||
| } | ||
| var value = !flags.strings[key] && isNumber(val) | ||
| ? Number(val) | ||
| : val; | ||
| setKey(argv, key.split('.'), value); | ||
| function isNumber (x) { | ||
| if (typeof x === 'number') return true; | ||
| if (/^0x[0-9a-f]+$/i.test(x)) return true; | ||
| return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); | ||
| } | ||
| (aliases[key] || []).forEach(function (x) { | ||
| setKey(argv, x.split('.'), value); | ||
| }); | ||
| } | ||
| Object.keys(flags.bools).forEach(function (key) { | ||
| setArg(key, defaults[key] === undefined ? false : defaults[key]); | ||
| }); | ||
| function isConstructorOrProto (obj, key) { | ||
| return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__'; | ||
| } | ||
| 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]; | ||
| var key; | ||
| var next; | ||
| if ((/^--.+=/).test(arg)) { | ||
| // Using [\s\S] instead of . because js doesn't support the | ||
| // 'dotall' regex modifier. See: | ||
| // http://stackoverflow.com/a/1068308/13216 | ||
| var m = arg.match(/^--([^=]+)=([\s\S]*)$/); | ||
| key = m[1]; | ||
| var value = m[2]; | ||
| if (flags.bools[key]) { | ||
| value = value !== 'false'; | ||
| } | ||
| setArg(key, value, arg); | ||
| } else if ((/^--no-.+/).test(arg)) { | ||
| key = arg.match(/^--no-(.+)/)[1]; | ||
| setArg(key, false, arg); | ||
| } else if ((/^--.+/).test(arg)) { | ||
| key = arg.match(/^--(.+)/)[1]; | ||
| next = args[i + 1]; | ||
| if ( | ||
| next !== undefined | ||
| && !(/^(-|--)[^-]/).test(next) | ||
| && !flags.bools[key] | ||
| && !flags.allBools | ||
| && (aliases[key] ? !aliasIsBoolean(key) : true) | ||
| ) { | ||
| setArg(key, next, arg); | ||
| i += 1; | ||
| } else if ((/^(true|false)$/).test(next)) { | ||
| setArg(key, next === 'true', arg); | ||
| i += 1; | ||
| } else { | ||
| setArg(key, flags.strings[key] ? '' : true, arg); | ||
| } | ||
| } else if ((/^-[^-]+/).test(arg)) { | ||
| var letters = arg.slice(1, -1).split(''); | ||
| var broken = false; | ||
| for (var j = 0; j < letters.length; j++) { | ||
| next = arg.slice(j + 2); | ||
| if (next === '-') { | ||
| setArg(letters[j], next, arg); | ||
| continue; | ||
| } | ||
| if ((/[A-Za-z]/).test(letters[j]) && next[0] === '=') { | ||
| setArg(letters[j], next.slice(1), arg); | ||
| broken = true; | ||
| break; | ||
| } | ||
| if ( | ||
| (/[A-Za-z]/).test(letters[j]) | ||
| && (/-?\d+(\.\d*)?(e-?\d+)?$/).test(next) | ||
| ) { | ||
| setArg(letters[j], next, arg); | ||
| broken = true; | ||
| break; | ||
| } | ||
| if (letters[j + 1] && letters[j + 1].match(/\W/)) { | ||
| setArg(letters[j], arg.slice(j + 2), arg); | ||
| broken = true; | ||
| break; | ||
| } else { | ||
| setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg); | ||
| } | ||
| } | ||
| key = arg.slice(-1)[0]; | ||
| if (!broken && key !== '-') { | ||
| if ( | ||
| args[i + 1] | ||
| && !(/^(-|--)[^-]/).test(args[i + 1]) | ||
| && !flags.bools[key] | ||
| && (aliases[key] ? !aliasIsBoolean(key) : true) | ||
| ) { | ||
| setArg(key, args[i + 1], arg); | ||
| i += 1; | ||
| } else if (args[i + 1] && (/^(true|false)$/).test(args[i + 1])) { | ||
| setArg(key, args[i + 1] === 'true', arg); | ||
| i += 1; | ||
| } else { | ||
| setArg(key, flags.strings[key] ? '' : true, arg); | ||
| } | ||
| } | ||
| } else { | ||
| if (!flags.unknownFn || flags.unknownFn(arg) !== false) { | ||
| argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg)); | ||
| } | ||
| if (opts.stopEarly) { | ||
| argv._.push.apply(argv._, args.slice(i + 1)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| Object.keys(defaults).forEach(function (k) { | ||
| if (!hasKey(argv, k.split('.'))) { | ||
| setKey(argv, k.split('.'), defaults[k]); | ||
| (aliases[k] || []).forEach(function (x) { | ||
| setKey(argv, x.split('.'), defaults[k]); | ||
| }); | ||
| } | ||
| }); | ||
| if (opts['--']) { | ||
| argv['--'] = notFlags.slice(); | ||
| } else { | ||
| notFlags.forEach(function (k) { | ||
| argv._.push(k); | ||
| }); | ||
| } | ||
| return argv; | ||
| }; |
146
package.json
| { | ||
| "name": "minimist", | ||
| "version": "1.2.7", | ||
| "description": "parse argument options", | ||
| "main": "index.js", | ||
| "devDependencies": { | ||
| "@ljharb/eslint-config": "^21.0.0", | ||
| "aud": "^2.0.1", | ||
| "auto-changelog": "^2.4.0", | ||
| "eslint": "=8.8.0", | ||
| "in-publish": "^2.0.1", | ||
| "npmignore": "^0.3.0", | ||
| "nyc": "^10.3.2", | ||
| "safe-publish-latest": "^2.0.0", | ||
| "tape": "^5.6.1" | ||
| }, | ||
| "scripts": { | ||
| "prepack": "npmignore --auto --commentLines=auto", | ||
| "prepublishOnly": "safe-publish-latest", | ||
| "prepublish": "not-in-publish || npm run prepublishOnly", | ||
| "lint": "eslint --ext=js,mjs .", | ||
| "pretest": "npm run lint", | ||
| "tests-only": "nyc tape test/*.js", | ||
| "test": "npm run tests-only", | ||
| "posttest": "aud --production", | ||
| "version": "auto-changelog && git add CHANGELOG.md", | ||
| "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" | ||
| }, | ||
| "testling": { | ||
| "files": "test/*.js", | ||
| "browsers": [ | ||
| "ie/6..latest", | ||
| "ff/5", | ||
| "firefox/latest", | ||
| "chrome/10", | ||
| "chrome/latest", | ||
| "safari/5.1", | ||
| "safari/latest", | ||
| "opera/12" | ||
| ] | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "git://github.com/minimistjs/minimist.git" | ||
| }, | ||
| "homepage": "https://github.com/minimistjs/minimist", | ||
| "keywords": [ | ||
| "argv", | ||
| "getopt", | ||
| "parser", | ||
| "optimist" | ||
| ], | ||
| "author": { | ||
| "name": "James Halliday", | ||
| "email": "mail@substack.net", | ||
| "url": "http://substack.net" | ||
| }, | ||
| "funding": { | ||
| "url": "https://github.com/sponsors/ljharb" | ||
| }, | ||
| "license": "MIT", | ||
| "auto-changelog": { | ||
| "output": "CHANGELOG.md", | ||
| "template": "keepachangelog", | ||
| "unreleased": false, | ||
| "commitLimit": false, | ||
| "backfillLimit": false, | ||
| "hideCredit": true | ||
| }, | ||
| "publishConfig": { | ||
| "ignore": [ | ||
| ".github/workflows" | ||
| ] | ||
| } | ||
| "name": "minimist", | ||
| "version": "1.2.8", | ||
| "description": "parse argument options", | ||
| "main": "index.js", | ||
| "devDependencies": { | ||
| "@ljharb/eslint-config": "^21.0.1", | ||
| "aud": "^2.0.2", | ||
| "auto-changelog": "^2.4.0", | ||
| "eslint": "=8.8.0", | ||
| "in-publish": "^2.0.1", | ||
| "npmignore": "^0.3.0", | ||
| "nyc": "^10.3.2", | ||
| "safe-publish-latest": "^2.0.0", | ||
| "tape": "^5.6.3" | ||
| }, | ||
| "scripts": { | ||
| "prepack": "npmignore --auto --commentLines=auto", | ||
| "prepublishOnly": "safe-publish-latest", | ||
| "prepublish": "not-in-publish || npm run prepublishOnly", | ||
| "lint": "eslint --ext=js,mjs .", | ||
| "pretest": "npm run lint", | ||
| "tests-only": "nyc tape 'test/**/*.js'", | ||
| "test": "npm run tests-only", | ||
| "posttest": "aud --production", | ||
| "version": "auto-changelog && git add CHANGELOG.md", | ||
| "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" | ||
| }, | ||
| "testling": { | ||
| "files": "test/*.js", | ||
| "browsers": [ | ||
| "ie/6..latest", | ||
| "ff/5", | ||
| "firefox/latest", | ||
| "chrome/10", | ||
| "chrome/latest", | ||
| "safari/5.1", | ||
| "safari/latest", | ||
| "opera/12" | ||
| ] | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "git://github.com/minimistjs/minimist.git" | ||
| }, | ||
| "homepage": "https://github.com/minimistjs/minimist", | ||
| "keywords": [ | ||
| "argv", | ||
| "getopt", | ||
| "parser", | ||
| "optimist" | ||
| ], | ||
| "author": { | ||
| "name": "James Halliday", | ||
| "email": "mail@substack.net", | ||
| "url": "http://substack.net" | ||
| }, | ||
| "funding": { | ||
| "url": "https://github.com/sponsors/ljharb" | ||
| }, | ||
| "license": "MIT", | ||
| "auto-changelog": { | ||
| "output": "CHANGELOG.md", | ||
| "template": "keepachangelog", | ||
| "unreleased": false, | ||
| "commitLimit": false, | ||
| "backfillLimit": false, | ||
| "hideCredit": true | ||
| }, | ||
| "publishConfig": { | ||
| "ignore": [ | ||
| ".github/workflows" | ||
| ] | ||
| } | ||
| } |
@@ -29,10 +29,12 @@ # minimist <sup>[![Version Badge][npm-version-svg]][package-url]</sup> | ||
| $ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz | ||
| { _: [ 'foo', 'bar', 'baz' ], | ||
| x: 3, | ||
| y: 4, | ||
| n: 5, | ||
| a: true, | ||
| b: true, | ||
| c: true, | ||
| beep: 'boop' } | ||
| { | ||
| _: ['foo', 'bar', 'baz'], | ||
| x: 3, | ||
| y: 4, | ||
| n: 5, | ||
| a: true, | ||
| b: true, | ||
| c: true, | ||
| beep: 'boop' | ||
| } | ||
| ``` | ||
@@ -85,4 +87,6 @@ | ||
| > require('./')('one two three -- four five --six'.split(' '), { '--': true }) | ||
| { _: [ 'one', 'two', 'three' ], | ||
| '--': [ 'four', 'five', '--six' ] } | ||
| { | ||
| _: ['one', 'two', 'three'], | ||
| '--': ['four', 'five', '--six'] | ||
| } | ||
| ``` | ||
@@ -89,0 +93,0 @@ |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,29 +7,29 @@ var test = require('tape'); | ||
| test('flag boolean true (default all --args to boolean)', function (t) { | ||
| var argv = parse(['moo', '--honk', 'cow'], { | ||
| boolean: true | ||
| }); | ||
| t.deepEqual(argv, { | ||
| honk: true, | ||
| _: ['moo', 'cow'] | ||
| }); | ||
| t.deepEqual(typeof argv.honk, 'boolean'); | ||
| t.end(); | ||
| var argv = parse(['moo', '--honk', 'cow'], { | ||
| boolean: true, | ||
| }); | ||
| t.deepEqual(argv, { | ||
| honk: true, | ||
| _: ['moo', 'cow'], | ||
| }); | ||
| t.deepEqual(typeof argv.honk, 'boolean'); | ||
| t.end(); | ||
| }); | ||
| test('flag boolean true only affects double hyphen arguments without equals signs', function (t) { | ||
| var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], { | ||
| boolean: true | ||
| }); | ||
| t.deepEqual(argv, { | ||
| honk: true, | ||
| tacos: 'good', | ||
| p: 55, | ||
| _: ['moo', 'cow'] | ||
| }); | ||
| t.deepEqual(typeof argv.honk, 'boolean'); | ||
| t.end(); | ||
| var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], { | ||
| boolean: true, | ||
| }); | ||
| t.deepEqual(argv, { | ||
| honk: true, | ||
| tacos: 'good', | ||
| p: 55, | ||
| _: ['moo', 'cow'], | ||
| }); | ||
| t.deepEqual(typeof argv.honk, 'boolean'); | ||
| t.end(); | ||
| }); |
281
test/bool.js
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,175 +7,172 @@ var test = require('tape'); | ||
| test('flag boolean default false', function (t) { | ||
| var argv = parse(['moo'], { | ||
| boolean: ['t', 'verbose'], | ||
| default: { verbose: false, t: false } | ||
| }); | ||
| t.deepEqual(argv, { | ||
| verbose: false, | ||
| t: false, | ||
| _: ['moo'] | ||
| }); | ||
| t.deepEqual(typeof argv.verbose, 'boolean'); | ||
| t.deepEqual(typeof argv.t, 'boolean'); | ||
| t.end(); | ||
| var argv = parse(['moo'], { | ||
| boolean: ['t', 'verbose'], | ||
| default: { verbose: false, t: false }, | ||
| }); | ||
| t.deepEqual(argv, { | ||
| verbose: false, | ||
| t: false, | ||
| _: ['moo'], | ||
| }); | ||
| t.deepEqual(typeof argv.verbose, 'boolean'); | ||
| t.deepEqual(typeof argv.t, 'boolean'); | ||
| t.end(); | ||
| }); | ||
| test('boolean groups', function (t) { | ||
| var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], { | ||
| boolean: ['x','y','z'] | ||
| }); | ||
| t.deepEqual(argv, { | ||
| x : true, | ||
| y : false, | ||
| z : true, | ||
| _ : [ 'one', 'two', 'three' ] | ||
| }); | ||
| t.deepEqual(typeof argv.x, 'boolean'); | ||
| t.deepEqual(typeof argv.y, 'boolean'); | ||
| t.deepEqual(typeof argv.z, 'boolean'); | ||
| t.end(); | ||
| var argv = parse(['-x', '-z', 'one', 'two', 'three'], { | ||
| boolean: ['x', 'y', 'z'], | ||
| }); | ||
| t.deepEqual(argv, { | ||
| x: true, | ||
| y: false, | ||
| z: true, | ||
| _: ['one', 'two', 'three'], | ||
| }); | ||
| t.deepEqual(typeof argv.x, 'boolean'); | ||
| t.deepEqual(typeof argv.y, 'boolean'); | ||
| t.deepEqual(typeof argv.z, 'boolean'); | ||
| t.end(); | ||
| }); | ||
| test('boolean and alias with chainable api', function (t) { | ||
| var aliased = [ '-h', 'derp' ]; | ||
| var regular = [ '--herp', 'derp' ]; | ||
| var opts = { | ||
| herp: { alias: 'h', boolean: true } | ||
| }; | ||
| var aliasedArgv = parse(aliased, { | ||
| boolean: 'herp', | ||
| alias: { h: 'herp' } | ||
| }); | ||
| var propertyArgv = parse(regular, { | ||
| boolean: 'herp', | ||
| alias: { h: 'herp' } | ||
| }); | ||
| var expected = { | ||
| herp: true, | ||
| h: true, | ||
| '_': [ 'derp' ] | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.end(); | ||
| var aliased = ['-h', 'derp']; | ||
| var regular = ['--herp', 'derp']; | ||
| var aliasedArgv = parse(aliased, { | ||
| boolean: 'herp', | ||
| alias: { h: 'herp' }, | ||
| }); | ||
| var propertyArgv = parse(regular, { | ||
| boolean: 'herp', | ||
| alias: { h: 'herp' }, | ||
| }); | ||
| var expected = { | ||
| herp: true, | ||
| h: true, | ||
| _: ['derp'], | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.end(); | ||
| }); | ||
| test('boolean and alias with options hash', function (t) { | ||
| var aliased = [ '-h', 'derp' ]; | ||
| var regular = [ '--herp', 'derp' ]; | ||
| var opts = { | ||
| alias: { 'h': 'herp' }, | ||
| boolean: 'herp' | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var expected = { | ||
| herp: true, | ||
| h: true, | ||
| '_': [ 'derp' ] | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.end(); | ||
| var aliased = ['-h', 'derp']; | ||
| var regular = ['--herp', 'derp']; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| boolean: 'herp', | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var expected = { | ||
| herp: true, | ||
| h: true, | ||
| _: ['derp'], | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.end(); | ||
| }); | ||
| test('boolean and alias array with options hash', function (t) { | ||
| var aliased = [ '-h', 'derp' ]; | ||
| var regular = [ '--herp', 'derp' ]; | ||
| var alt = [ '--harp', 'derp' ]; | ||
| var opts = { | ||
| alias: { 'h': ['herp', 'harp'] }, | ||
| boolean: 'h' | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var altPropertyArgv = parse(alt, opts); | ||
| var expected = { | ||
| harp: true, | ||
| herp: true, | ||
| h: true, | ||
| '_': [ 'derp' ] | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.same(altPropertyArgv, expected); | ||
| t.end(); | ||
| var aliased = ['-h', 'derp']; | ||
| var regular = ['--herp', 'derp']; | ||
| var alt = ['--harp', 'derp']; | ||
| var opts = { | ||
| alias: { h: ['herp', 'harp'] }, | ||
| boolean: 'h', | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var altPropertyArgv = parse(alt, opts); | ||
| var expected = { | ||
| harp: true, | ||
| herp: true, | ||
| h: true, | ||
| _: ['derp'], | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.same(altPropertyArgv, expected); | ||
| t.end(); | ||
| }); | ||
| test('boolean and alias using explicit true', function (t) { | ||
| var aliased = [ '-h', 'true' ]; | ||
| var regular = [ '--herp', 'true' ]; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| boolean: 'h' | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var expected = { | ||
| herp: true, | ||
| h: true, | ||
| '_': [ ] | ||
| }; | ||
| var aliased = ['-h', 'true']; | ||
| var regular = ['--herp', 'true']; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| boolean: 'h', | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var expected = { | ||
| herp: true, | ||
| h: true, | ||
| _: [], | ||
| }; | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.end(); | ||
| t.same(aliasedArgv, expected); | ||
| t.same(propertyArgv, expected); | ||
| t.end(); | ||
| }); | ||
| // regression, see https://github.com/substack/node-optimist/issues/71 | ||
| test('boolean and --x=true', function(t) { | ||
| var parsed = parse(['--boool', '--other=true'], { | ||
| boolean: 'boool' | ||
| }); | ||
| test('boolean and --x=true', function (t) { | ||
| var parsed = parse(['--boool', '--other=true'], { | ||
| boolean: 'boool', | ||
| }); | ||
| t.same(parsed.boool, true); | ||
| t.same(parsed.other, 'true'); | ||
| t.same(parsed.boool, true); | ||
| t.same(parsed.other, 'true'); | ||
| parsed = parse(['--boool', '--other=false'], { | ||
| boolean: 'boool' | ||
| }); | ||
| t.same(parsed.boool, true); | ||
| t.same(parsed.other, 'false'); | ||
| t.end(); | ||
| parsed = parse(['--boool', '--other=false'], { | ||
| boolean: 'boool', | ||
| }); | ||
| t.same(parsed.boool, true); | ||
| t.same(parsed.other, 'false'); | ||
| t.end(); | ||
| }); | ||
| test('boolean --boool=true', function (t) { | ||
| var parsed = parse(['--boool=true'], { | ||
| default: { | ||
| boool: false | ||
| }, | ||
| boolean: ['boool'] | ||
| }); | ||
| var parsed = parse(['--boool=true'], { | ||
| default: { | ||
| boool: false, | ||
| }, | ||
| boolean: ['boool'], | ||
| }); | ||
| t.same(parsed.boool, true); | ||
| t.end(); | ||
| t.same(parsed.boool, true); | ||
| t.end(); | ||
| }); | ||
| test('boolean --boool=false', function (t) { | ||
| var parsed = parse(['--boool=false'], { | ||
| default: { | ||
| boool: true | ||
| }, | ||
| boolean: ['boool'] | ||
| }); | ||
| var parsed = parse(['--boool=false'], { | ||
| default: { | ||
| boool: true, | ||
| }, | ||
| boolean: ['boool'], | ||
| }); | ||
| t.same(parsed.boool, false); | ||
| t.end(); | ||
| t.same(parsed.boool, false); | ||
| t.end(); | ||
| }); | ||
| test('boolean using something similar to true', function (t) { | ||
| var opts = { boolean: 'h' }; | ||
| var result = parse(['-h', 'true.txt'], opts); | ||
| var expected = { | ||
| h: true, | ||
| '_': ['true.txt'] | ||
| }; | ||
| var opts = { boolean: 'h' }; | ||
| var result = parse(['-h', 'true.txt'], opts); | ||
| var expected = { | ||
| h: true, | ||
| _: ['true.txt'], | ||
| }; | ||
| t.same(result, expected); | ||
| t.end(); | ||
| }); | ||
| t.same(result, expected); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,28 +7,38 @@ var test = require('tape'); | ||
| test('-', function (t) { | ||
| t.plan(5); | ||
| t.deepEqual(parse([ '-n', '-' ]), { n: '-', _: [] }); | ||
| t.deepEqual(parse([ '-' ]), { _: [ '-' ] }); | ||
| t.deepEqual(parse([ '-f-' ]), { f: '-', _: [] }); | ||
| t.deepEqual( | ||
| parse([ '-b', '-' ], { boolean: 'b' }), | ||
| { b: true, _: [ '-' ] } | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '-s', '-' ], { string: 's' }), | ||
| { s: '-', _: [] } | ||
| ); | ||
| t.plan(6); | ||
| t.deepEqual(parse(['-n', '-']), { n: '-', _: [] }); | ||
| t.deepEqual(parse(['--nnn', '-']), { nnn: '-', _: [] }); | ||
| t.deepEqual(parse(['-']), { _: ['-'] }); | ||
| t.deepEqual(parse(['-f-']), { f: '-', _: [] }); | ||
| t.deepEqual( | ||
| parse(['-b', '-'], { boolean: 'b' }), | ||
| { b: true, _: ['-'] } | ||
| ); | ||
| t.deepEqual( | ||
| parse(['-s', '-'], { string: 's' }), | ||
| { s: '-', _: [] } | ||
| ); | ||
| }); | ||
| test('-a -- b', function (t) { | ||
| t.plan(3); | ||
| t.deepEqual(parse([ '-a', '--', 'b' ]), { a: true, _: [ 'b' ] }); | ||
| t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] }); | ||
| t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] }); | ||
| t.plan(2); | ||
| t.deepEqual(parse(['-a', '--', 'b']), { a: true, _: ['b'] }); | ||
| t.deepEqual(parse(['--a', '--', 'b']), { a: true, _: ['b'] }); | ||
| }); | ||
| test('move arguments after the -- into their own `--` array', function(t) { | ||
| t.plan(1); | ||
| t.deepEqual( | ||
| parse([ '--name', 'John', 'before', '--', 'after' ], { '--': true }), | ||
| { name: 'John', _: [ 'before' ], '--': [ 'after' ] }); | ||
| test('move arguments after the -- into their own `--` array', function (t) { | ||
| t.plan(1); | ||
| t.deepEqual( | ||
| parse(['--name', 'John', 'before', '--', 'after'], { '--': true }), | ||
| { name: 'John', _: ['before'], '--': ['after'] } | ||
| ); | ||
| }); | ||
| test('--- option value', function (t) { | ||
| // A multi-dash value is largely an edge case, but check the behaviour is as expected, | ||
| // and in particular the same for short option and long option (as made consistent in Jan 2023). | ||
| t.plan(2); | ||
| t.deepEqual(parse(['-n', '---']), { n: '---', _: [] }); | ||
| t.deepEqual(parse(['--nnn', '---']), { nnn: '---', _: [] }); | ||
| }); | ||
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var test = require('tape'); | ||
@@ -5,32 +7,32 @@ var parse = require('../'); | ||
| test('boolean default true', function (t) { | ||
| var argv = parse([], { | ||
| boolean: 'sometrue', | ||
| default: { sometrue: true } | ||
| }); | ||
| t.equal(argv.sometrue, true); | ||
| t.end(); | ||
| var argv = parse([], { | ||
| boolean: 'sometrue', | ||
| default: { sometrue: true }, | ||
| }); | ||
| t.equal(argv.sometrue, true); | ||
| t.end(); | ||
| }); | ||
| test('boolean default false', function (t) { | ||
| var argv = parse([], { | ||
| boolean: 'somefalse', | ||
| default: { somefalse: false } | ||
| }); | ||
| t.equal(argv.somefalse, false); | ||
| t.end(); | ||
| var argv = parse([], { | ||
| boolean: 'somefalse', | ||
| default: { somefalse: false }, | ||
| }); | ||
| t.equal(argv.somefalse, false); | ||
| t.end(); | ||
| }); | ||
| test('boolean default to null', function (t) { | ||
| var argv = parse([], { | ||
| boolean: 'maybe', | ||
| default: { maybe: null } | ||
| }); | ||
| t.equal(argv.maybe, null); | ||
| var argv = parse(['--maybe'], { | ||
| boolean: 'maybe', | ||
| default: { maybe: null } | ||
| }); | ||
| t.equal(argv.maybe, true); | ||
| t.end(); | ||
| var argv = parse([], { | ||
| boolean: 'maybe', | ||
| default: { maybe: null }, | ||
| }); | ||
| t.equal(argv.maybe, null); | ||
| }) | ||
| var argvLong = parse(['--maybe'], { | ||
| boolean: 'maybe', | ||
| default: { maybe: null }, | ||
| }); | ||
| t.equal(argvLong.maybe, true); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,19 +7,19 @@ var test = require('tape'); | ||
| test('dotted alias', function (t) { | ||
| var argv = parse(['--a.b', '22'], {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}}); | ||
| t.equal(argv.a.b, 22); | ||
| t.equal(argv.aa.bb, 22); | ||
| t.end(); | ||
| var argv = parse(['--a.b', '22'], { default: { 'a.b': 11 }, alias: { 'a.b': 'aa.bb' } }); | ||
| t.equal(argv.a.b, 22); | ||
| t.equal(argv.aa.bb, 22); | ||
| t.end(); | ||
| }); | ||
| test('dotted default', function (t) { | ||
| var argv = parse('', {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}}); | ||
| t.equal(argv.a.b, 11); | ||
| t.equal(argv.aa.bb, 11); | ||
| t.end(); | ||
| var argv = parse('', { default: { 'a.b': 11 }, alias: { 'a.b': 'aa.bb' } }); | ||
| t.equal(argv.a.b, 11); | ||
| t.equal(argv.aa.bb, 11); | ||
| t.end(); | ||
| }); | ||
| test('dotted default with no alias', function (t) { | ||
| var argv = parse('', {default: {'a.b': 11}}); | ||
| t.equal(argv.a.b, 11); | ||
| t.end(); | ||
| var argv = parse('', { default: { 'a.b': 11 } }); | ||
| t.equal(argv.a.b, 11); | ||
| t.end(); | ||
| }); |
@@ -0,16 +1,32 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
| var test = require('tape'); | ||
| test('short -k=v' , function (t) { | ||
| t.plan(1); | ||
| var argv = parse([ '-b=123' ]); | ||
| t.deepEqual(argv, { b: 123, _: [] }); | ||
| test('short -k=v', function (t) { | ||
| t.plan(1); | ||
| var argv = parse(['-b=123']); | ||
| t.deepEqual(argv, { b: 123, _: [] }); | ||
| }); | ||
| test('multi short -k=v' , function (t) { | ||
| t.plan(1); | ||
| var argv = parse([ '-a=whatever', '-b=robots' ]); | ||
| t.deepEqual(argv, { a: 'whatever', b: 'robots', _: [] }); | ||
| test('multi short -k=v', function (t) { | ||
| t.plan(1); | ||
| var argv = parse(['-a=whatever', '-b=robots']); | ||
| t.deepEqual(argv, { a: 'whatever', b: 'robots', _: [] }); | ||
| }); | ||
| test('short with embedded equals -k=a=b', function (t) { | ||
| t.plan(1); | ||
| var argv = parse(['-k=a=b']); | ||
| t.deepEqual(argv, { k: 'a=b', _: [] }); | ||
| }); | ||
| test('short with later equals like -ab=c', function (t) { | ||
| t.plan(1); | ||
| var argv = parse(['-ab=c']); | ||
| t.deepEqual(argv, { a: true, b: 'c', _: [] }); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var test = require('tape'); | ||
@@ -5,28 +7,28 @@ var parse = require('../'); | ||
| test('long opts', function (t) { | ||
| t.deepEqual( | ||
| parse([ '--bool' ]), | ||
| { bool : true, _ : [] }, | ||
| 'long boolean' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '--pow', 'xixxle' ]), | ||
| { pow : 'xixxle', _ : [] }, | ||
| 'long capture sp' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '--pow=xixxle' ]), | ||
| { pow : 'xixxle', _ : [] }, | ||
| 'long capture eq' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '--host', 'localhost', '--port', '555' ]), | ||
| { host : 'localhost', port : 555, _ : [] }, | ||
| 'long captures sp' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '--host=localhost', '--port=555' ]), | ||
| { host : 'localhost', port : 555, _ : [] }, | ||
| 'long captures eq' | ||
| ); | ||
| t.end(); | ||
| t.deepEqual( | ||
| parse(['--bool']), | ||
| { bool: true, _: [] }, | ||
| 'long boolean' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['--pow', 'xixxle']), | ||
| { pow: 'xixxle', _: [] }, | ||
| 'long capture sp' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['--pow=xixxle']), | ||
| { pow: 'xixxle', _: [] }, | ||
| 'long capture eq' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['--host', 'localhost', '--port', '555']), | ||
| { host: 'localhost', port: 555, _: [] }, | ||
| 'long captures sp' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['--host=localhost', '--port=555']), | ||
| { host: 'localhost', port: 555, _: [] }, | ||
| 'long captures eq' | ||
| ); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,33 +7,33 @@ var test = require('tape'); | ||
| test('nums', function (t) { | ||
| var argv = parse([ | ||
| '-x', '1234', | ||
| '-y', '5.67', | ||
| '-z', '1e7', | ||
| '-w', '10f', | ||
| '--hex', '0xdeadbeef', | ||
| '789' | ||
| ]); | ||
| t.deepEqual(argv, { | ||
| x : 1234, | ||
| y : 5.67, | ||
| z : 1e7, | ||
| w : '10f', | ||
| hex : 0xdeadbeef, | ||
| _ : [ 789 ] | ||
| }); | ||
| t.deepEqual(typeof argv.x, 'number'); | ||
| t.deepEqual(typeof argv.y, 'number'); | ||
| t.deepEqual(typeof argv.z, 'number'); | ||
| t.deepEqual(typeof argv.w, 'string'); | ||
| t.deepEqual(typeof argv.hex, 'number'); | ||
| t.deepEqual(typeof argv._[0], 'number'); | ||
| t.end(); | ||
| var argv = parse([ | ||
| '-x', '1234', | ||
| '-y', '5.67', | ||
| '-z', '1e7', | ||
| '-w', '10f', | ||
| '--hex', '0xdeadbeef', | ||
| '789', | ||
| ]); | ||
| t.deepEqual(argv, { | ||
| x: 1234, | ||
| y: 5.67, | ||
| z: 1e7, | ||
| w: '10f', | ||
| hex: 0xdeadbeef, | ||
| _: [789], | ||
| }); | ||
| t.deepEqual(typeof argv.x, 'number'); | ||
| t.deepEqual(typeof argv.y, 'number'); | ||
| t.deepEqual(typeof argv.z, 'number'); | ||
| t.deepEqual(typeof argv.w, 'string'); | ||
| t.deepEqual(typeof argv.hex, 'number'); | ||
| t.deepEqual(typeof argv._[0], 'number'); | ||
| t.end(); | ||
| }); | ||
| test('already a number', function (t) { | ||
| var argv = parse([ '-x', 1234, 789 ]); | ||
| t.deepEqual(argv, { x : 1234, _ : [ 789 ] }); | ||
| t.deepEqual(typeof argv.x, 'number'); | ||
| t.deepEqual(typeof argv._[0], 'number'); | ||
| t.end(); | ||
| var argv = parse(['-x', 1234, 789]); | ||
| t.deepEqual(argv, { x: 1234, _: [789] }); | ||
| t.deepEqual(typeof argv.x, 'number'); | ||
| t.deepEqual(typeof argv._[0], 'number'); | ||
| t.end(); | ||
| }); |
@@ -0,9 +1,11 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
| var test = require('tape'); | ||
| test('parse with modifier functions' , function (t) { | ||
| t.plan(1); | ||
| var argv = parse([ '-b', '123' ], { boolean: 'b' }); | ||
| t.deepEqual(argv, { b: true, _: [123] }); | ||
| test('parse with modifier functions', function (t) { | ||
| t.plan(1); | ||
| var argv = parse(['-b', '123'], { boolean: 'b' }); | ||
| t.deepEqual(argv, { b: true, _: [123] }); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,194 +7,204 @@ var test = require('tape'); | ||
| test('parse args', function (t) { | ||
| t.deepEqual( | ||
| parse([ '--no-moo' ]), | ||
| { moo : false, _ : [] }, | ||
| 'no' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]), | ||
| { v : ['a','b','c'], _ : [] }, | ||
| 'multi' | ||
| ); | ||
| t.end(); | ||
| t.deepEqual( | ||
| parse(['--no-moo']), | ||
| { moo: false, _: [] }, | ||
| 'no' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['-v', 'a', '-v', 'b', '-v', 'c']), | ||
| { v: ['a', 'b', 'c'], _: [] }, | ||
| 'multi' | ||
| ); | ||
| t.end(); | ||
| }); | ||
| test('comprehensive', function (t) { | ||
| t.deepEqual( | ||
| parse([ | ||
| '--name=meowmers', 'bare', '-cats', 'woo', | ||
| '-h', 'awesome', '--multi=quux', | ||
| '--key', 'value', | ||
| '-b', '--bool', '--no-meep', '--multi=baz', | ||
| '--', '--not-a-flag', 'eek' | ||
| ]), | ||
| { | ||
| c : true, | ||
| a : true, | ||
| t : true, | ||
| s : 'woo', | ||
| h : 'awesome', | ||
| b : true, | ||
| bool : true, | ||
| key : 'value', | ||
| multi : [ 'quux', 'baz' ], | ||
| meep : false, | ||
| name : 'meowmers', | ||
| _ : [ 'bare', '--not-a-flag', 'eek' ] | ||
| } | ||
| ); | ||
| t.end(); | ||
| t.deepEqual( | ||
| parse([ | ||
| '--name=meowmers', 'bare', '-cats', 'woo', | ||
| '-h', 'awesome', '--multi=quux', | ||
| '--key', 'value', | ||
| '-b', '--bool', '--no-meep', '--multi=baz', | ||
| '--', '--not-a-flag', 'eek', | ||
| ]), | ||
| { | ||
| c: true, | ||
| a: true, | ||
| t: true, | ||
| s: 'woo', | ||
| h: 'awesome', | ||
| b: true, | ||
| bool: true, | ||
| key: 'value', | ||
| multi: ['quux', 'baz'], | ||
| meep: false, | ||
| name: 'meowmers', | ||
| _: ['bare', '--not-a-flag', 'eek'], | ||
| } | ||
| ); | ||
| t.end(); | ||
| }); | ||
| test('flag boolean', function (t) { | ||
| var argv = parse([ '-t', 'moo' ], { boolean: 't' }); | ||
| t.deepEqual(argv, { t : true, _ : [ 'moo' ] }); | ||
| t.deepEqual(typeof argv.t, 'boolean'); | ||
| t.end(); | ||
| var argv = parse(['-t', 'moo'], { boolean: 't' }); | ||
| t.deepEqual(argv, { t: true, _: ['moo'] }); | ||
| t.deepEqual(typeof argv.t, 'boolean'); | ||
| t.end(); | ||
| }); | ||
| test('flag boolean value', function (t) { | ||
| var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], { | ||
| boolean: [ 't', 'verbose' ], | ||
| default: { verbose: true } | ||
| }); | ||
| t.deepEqual(argv, { | ||
| verbose: false, | ||
| t: true, | ||
| _: ['moo'] | ||
| }); | ||
| t.deepEqual(typeof argv.verbose, 'boolean'); | ||
| t.deepEqual(typeof argv.t, 'boolean'); | ||
| t.end(); | ||
| var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], { | ||
| boolean: ['t', 'verbose'], | ||
| default: { verbose: true }, | ||
| }); | ||
| t.deepEqual(argv, { | ||
| verbose: false, | ||
| t: true, | ||
| _: ['moo'], | ||
| }); | ||
| t.deepEqual(typeof argv.verbose, 'boolean'); | ||
| t.deepEqual(typeof argv.t, 'boolean'); | ||
| t.end(); | ||
| }); | ||
| test('newlines in params' , function (t) { | ||
| var args = parse([ '-s', "X\nX" ]) | ||
| t.deepEqual(args, { _ : [], s : "X\nX" }); | ||
| // reproduce in bash: | ||
| // VALUE="new | ||
| // line" | ||
| // node program.js --s="$VALUE" | ||
| args = parse([ "--s=X\nX" ]) | ||
| t.deepEqual(args, { _ : [], s : "X\nX" }); | ||
| t.end(); | ||
| test('newlines in params', function (t) { | ||
| var args = parse(['-s', 'X\nX']); | ||
| t.deepEqual(args, { _: [], s: 'X\nX' }); | ||
| // reproduce in bash: | ||
| // VALUE="new | ||
| // line" | ||
| // node program.js --s="$VALUE" | ||
| args = parse(['--s=X\nX']); | ||
| t.deepEqual(args, { _: [], s: 'X\nX' }); | ||
| t.end(); | ||
| }); | ||
| test('strings' , function (t) { | ||
| var s = parse([ '-s', '0001234' ], { string: 's' }).s; | ||
| t.equal(s, '0001234'); | ||
| t.equal(typeof s, 'string'); | ||
| var x = parse([ '-x', '56' ], { string: 'x' }).x; | ||
| t.equal(x, '56'); | ||
| t.equal(typeof x, 'string'); | ||
| t.end(); | ||
| test('strings', function (t) { | ||
| var s = parse(['-s', '0001234'], { string: 's' }).s; | ||
| t.equal(s, '0001234'); | ||
| t.equal(typeof s, 'string'); | ||
| var x = parse(['-x', '56'], { string: 'x' }).x; | ||
| t.equal(x, '56'); | ||
| t.equal(typeof x, 'string'); | ||
| t.end(); | ||
| }); | ||
| test('stringArgs', function (t) { | ||
| var s = parse([ ' ', ' ' ], { string: '_' })._; | ||
| t.same(s.length, 2); | ||
| t.same(typeof s[0], 'string'); | ||
| t.same(s[0], ' '); | ||
| t.same(typeof s[1], 'string'); | ||
| t.same(s[1], ' '); | ||
| t.end(); | ||
| var s = parse([' ', ' '], { string: '_' })._; | ||
| t.same(s.length, 2); | ||
| t.same(typeof s[0], 'string'); | ||
| t.same(s[0], ' '); | ||
| t.same(typeof s[1], 'string'); | ||
| t.same(s[1], ' '); | ||
| t.end(); | ||
| }); | ||
| test('empty strings', function(t) { | ||
| var s = parse([ '-s' ], { string: 's' }).s; | ||
| t.equal(s, ''); | ||
| t.equal(typeof s, 'string'); | ||
| test('empty strings', function (t) { | ||
| var s = parse(['-s'], { string: 's' }).s; | ||
| t.equal(s, ''); | ||
| t.equal(typeof s, 'string'); | ||
| var str = parse([ '--str' ], { string: 'str' }).str; | ||
| t.equal(str, ''); | ||
| t.equal(typeof str, 'string'); | ||
| var str = parse(['--str'], { string: 'str' }).str; | ||
| t.equal(str, ''); | ||
| t.equal(typeof str, 'string'); | ||
| var letters = parse([ '-art' ], { | ||
| string: [ 'a', 't' ] | ||
| }); | ||
| var letters = parse(['-art'], { | ||
| string: ['a', 't'], | ||
| }); | ||
| t.equal(letters.a, ''); | ||
| t.equal(letters.r, true); | ||
| t.equal(letters.t, ''); | ||
| t.equal(letters.a, ''); | ||
| t.equal(letters.r, true); | ||
| t.equal(letters.t, ''); | ||
| t.end(); | ||
| t.end(); | ||
| }); | ||
| test('string and alias', function (t) { | ||
| var x = parse(['--str', '000123'], { | ||
| string: 's', | ||
| alias: { s: 'str' }, | ||
| }); | ||
| test('string and alias', function(t) { | ||
| var x = parse([ '--str', '000123' ], { | ||
| string: 's', | ||
| alias: { s: 'str' } | ||
| }); | ||
| t.equal(x.str, '000123'); | ||
| t.equal(typeof x.str, 'string'); | ||
| t.equal(x.s, '000123'); | ||
| t.equal(typeof x.s, 'string'); | ||
| t.equal(x.str, '000123'); | ||
| t.equal(typeof x.str, 'string'); | ||
| t.equal(x.s, '000123'); | ||
| t.equal(typeof x.s, 'string'); | ||
| var y = parse(['-s', '000123'], { | ||
| string: 'str', | ||
| alias: { str: 's' }, | ||
| }); | ||
| var y = parse([ '-s', '000123' ], { | ||
| string: 'str', | ||
| alias: { str: 's' } | ||
| }); | ||
| t.equal(y.str, '000123'); | ||
| t.equal(typeof y.str, 'string'); | ||
| t.equal(y.s, '000123'); | ||
| t.equal(typeof y.s, 'string'); | ||
| t.equal(y.str, '000123'); | ||
| t.equal(typeof y.str, 'string'); | ||
| t.equal(y.s, '000123'); | ||
| t.equal(typeof y.s, 'string'); | ||
| t.end(); | ||
| var z = parse(['-s123'], { | ||
| alias: { str: ['s', 'S'] }, | ||
| string: ['str'], | ||
| }); | ||
| t.deepEqual( | ||
| z, | ||
| { _: [], s: '123', S: '123', str: '123' }, | ||
| 'opt.string works with multiple aliases' | ||
| ); | ||
| t.end(); | ||
| }); | ||
| test('slashBreak', function (t) { | ||
| t.same( | ||
| parse([ '-I/foo/bar/baz' ]), | ||
| { I : '/foo/bar/baz', _ : [] } | ||
| ); | ||
| t.same( | ||
| parse([ '-xyz/foo/bar/baz' ]), | ||
| { x : true, y : true, z : '/foo/bar/baz', _ : [] } | ||
| ); | ||
| t.end(); | ||
| t.same( | ||
| parse(['-I/foo/bar/baz']), | ||
| { I: '/foo/bar/baz', _: [] } | ||
| ); | ||
| t.same( | ||
| parse(['-xyz/foo/bar/baz']), | ||
| { x: true, y: true, z: '/foo/bar/baz', _: [] } | ||
| ); | ||
| t.end(); | ||
| }); | ||
| test('alias', function (t) { | ||
| var argv = parse([ '-f', '11', '--zoom', '55' ], { | ||
| alias: { z: 'zoom' } | ||
| }); | ||
| t.equal(argv.zoom, 55); | ||
| t.equal(argv.z, argv.zoom); | ||
| t.equal(argv.f, 11); | ||
| t.end(); | ||
| var argv = parse(['-f', '11', '--zoom', '55'], { | ||
| alias: { z: 'zoom' }, | ||
| }); | ||
| t.equal(argv.zoom, 55); | ||
| t.equal(argv.z, argv.zoom); | ||
| t.equal(argv.f, 11); | ||
| t.end(); | ||
| }); | ||
| test('multiAlias', function (t) { | ||
| var argv = parse([ '-f', '11', '--zoom', '55' ], { | ||
| alias: { z: [ 'zm', 'zoom' ] } | ||
| }); | ||
| t.equal(argv.zoom, 55); | ||
| t.equal(argv.z, argv.zoom); | ||
| t.equal(argv.z, argv.zm); | ||
| t.equal(argv.f, 11); | ||
| t.end(); | ||
| var argv = parse(['-f', '11', '--zoom', '55'], { | ||
| alias: { z: ['zm', 'zoom'] }, | ||
| }); | ||
| t.equal(argv.zoom, 55); | ||
| t.equal(argv.z, argv.zoom); | ||
| t.equal(argv.z, argv.zm); | ||
| t.equal(argv.f, 11); | ||
| t.end(); | ||
| }); | ||
| test('nested dotted objects', function (t) { | ||
| var argv = parse([ | ||
| '--foo.bar', '3', '--foo.baz', '4', | ||
| '--foo.quux.quibble', '5', '--foo.quux.o_O', | ||
| '--beep.boop' | ||
| ]); | ||
| t.same(argv.foo, { | ||
| bar : 3, | ||
| baz : 4, | ||
| quux : { | ||
| quibble : 5, | ||
| o_O : true | ||
| } | ||
| }); | ||
| t.same(argv.beep, { boop : true }); | ||
| t.end(); | ||
| var argv = parse([ | ||
| '--foo.bar', '3', '--foo.baz', '4', | ||
| '--foo.quux.quibble', '5', '--foo.quux.o_O', | ||
| '--beep.boop', | ||
| ]); | ||
| t.same(argv.foo, { | ||
| bar: 3, | ||
| baz: 4, | ||
| quux: { | ||
| quibble: 5, | ||
| o_O: true, | ||
| }, | ||
| }); | ||
| t.same(argv.beep, { boop: true }); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,5 @@ | ||
| 'use strict'; | ||
| /* eslint no-proto: 0 */ | ||
| var parse = require('../'); | ||
@@ -5,49 +9,49 @@ var test = require('tape'); | ||
| test('proto pollution', function (t) { | ||
| var argv = parse(['--__proto__.x','123']); | ||
| t.equal({}.x, undefined); | ||
| t.equal(argv.__proto__.x, undefined); | ||
| t.equal(argv.x, undefined); | ||
| t.end(); | ||
| var argv = parse(['--__proto__.x', '123']); | ||
| t.equal({}.x, undefined); | ||
| t.equal(argv.__proto__.x, undefined); | ||
| t.equal(argv.x, undefined); | ||
| t.end(); | ||
| }); | ||
| test('proto pollution (array)', function (t) { | ||
| var argv = parse(['--x','4','--x','5','--x.__proto__.z','789']); | ||
| t.equal({}.z, undefined); | ||
| t.deepEqual(argv.x, [4,5]); | ||
| t.equal(argv.x.z, undefined); | ||
| t.equal(argv.x.__proto__.z, undefined); | ||
| t.end(); | ||
| var argv = parse(['--x', '4', '--x', '5', '--x.__proto__.z', '789']); | ||
| t.equal({}.z, undefined); | ||
| t.deepEqual(argv.x, [4, 5]); | ||
| t.equal(argv.x.z, undefined); | ||
| t.equal(argv.x.__proto__.z, undefined); | ||
| t.end(); | ||
| }); | ||
| test('proto pollution (number)', function (t) { | ||
| var argv = parse(['--x','5','--x.__proto__.z','100']); | ||
| t.equal({}.z, undefined); | ||
| t.equal((4).z, undefined); | ||
| t.equal(argv.x, 5); | ||
| t.equal(argv.x.z, undefined); | ||
| t.end(); | ||
| var argv = parse(['--x', '5', '--x.__proto__.z', '100']); | ||
| t.equal({}.z, undefined); | ||
| t.equal((4).z, undefined); | ||
| t.equal(argv.x, 5); | ||
| t.equal(argv.x.z, undefined); | ||
| t.end(); | ||
| }); | ||
| test('proto pollution (string)', function (t) { | ||
| var argv = parse(['--x','abc','--x.__proto__.z','def']); | ||
| t.equal({}.z, undefined); | ||
| t.equal('...'.z, undefined); | ||
| t.equal(argv.x, 'abc'); | ||
| t.equal(argv.x.z, undefined); | ||
| t.end(); | ||
| var argv = parse(['--x', 'abc', '--x.__proto__.z', 'def']); | ||
| t.equal({}.z, undefined); | ||
| t.equal('...'.z, undefined); | ||
| t.equal(argv.x, 'abc'); | ||
| t.equal(argv.x.z, undefined); | ||
| t.end(); | ||
| }); | ||
| test('proto pollution (constructor)', function (t) { | ||
| var argv = parse(['--constructor.prototype.y','123']); | ||
| t.equal({}.y, undefined); | ||
| t.equal(argv.y, undefined); | ||
| t.end(); | ||
| var argv = parse(['--constructor.prototype.y', '123']); | ||
| t.equal({}.y, undefined); | ||
| t.equal(argv.y, undefined); | ||
| t.end(); | ||
| }); | ||
| test('proto pollution (constructor function)', function (t) { | ||
| var argv = parse(['--_.concat.constructor.prototype.y', '123']); | ||
| function fnToBeTested() {} | ||
| t.equal(fnToBeTested.y, undefined); | ||
| t.equal(argv.y, undefined); | ||
| t.end(); | ||
| var argv = parse(['--_.concat.constructor.prototype.y', '123']); | ||
| function fnToBeTested() {} | ||
| t.equal(fnToBeTested.y, undefined); | ||
| t.equal(argv.y, undefined); | ||
| t.end(); | ||
| }); | ||
@@ -57,6 +61,6 @@ | ||
| test('proto pollution (constructor function) snyk', function (t) { | ||
| var argv = parse('--_.constructor.constructor.prototype.foo bar'.split(' ')); | ||
| t.equal((function(){}).foo, undefined); | ||
| t.equal(argv.y, undefined); | ||
| t.end(); | ||
| }) | ||
| var argv = parse('--_.constructor.constructor.prototype.foo bar'.split(' ')); | ||
| t.equal(function () {}.foo, undefined); | ||
| t.equal(argv.y, undefined); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,64 +7,64 @@ var test = require('tape'); | ||
| test('numeric short args', function (t) { | ||
| t.plan(2); | ||
| t.deepEqual(parse([ '-n123' ]), { n: 123, _: [] }); | ||
| t.deepEqual( | ||
| parse([ '-123', '456' ]), | ||
| { 1: true, 2: true, 3: 456, _: [] } | ||
| ); | ||
| t.plan(2); | ||
| t.deepEqual(parse(['-n123']), { n: 123, _: [] }); | ||
| t.deepEqual( | ||
| parse(['-123', '456']), | ||
| { 1: true, 2: true, 3: 456, _: [] } | ||
| ); | ||
| }); | ||
| test('short', function (t) { | ||
| t.deepEqual( | ||
| parse([ '-b' ]), | ||
| { b : true, _ : [] }, | ||
| 'short boolean' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ 'foo', 'bar', 'baz' ]), | ||
| { _ : [ 'foo', 'bar', 'baz' ] }, | ||
| 'bare' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '-cats' ]), | ||
| { c : true, a : true, t : true, s : true, _ : [] }, | ||
| 'group' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '-cats', 'meow' ]), | ||
| { c : true, a : true, t : true, s : 'meow', _ : [] }, | ||
| 'short group next' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '-h', 'localhost' ]), | ||
| { h : 'localhost', _ : [] }, | ||
| 'short capture' | ||
| ); | ||
| t.deepEqual( | ||
| parse([ '-h', 'localhost', '-p', '555' ]), | ||
| { h : 'localhost', p : 555, _ : [] }, | ||
| 'short captures' | ||
| ); | ||
| t.end(); | ||
| t.deepEqual( | ||
| parse(['-b']), | ||
| { b: true, _: [] }, | ||
| 'short boolean' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['foo', 'bar', 'baz']), | ||
| { _: ['foo', 'bar', 'baz'] }, | ||
| 'bare' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['-cats']), | ||
| { c: true, a: true, t: true, s: true, _: [] }, | ||
| 'group' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['-cats', 'meow']), | ||
| { c: true, a: true, t: true, s: 'meow', _: [] }, | ||
| 'short group next' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['-h', 'localhost']), | ||
| { h: 'localhost', _: [] }, | ||
| 'short capture' | ||
| ); | ||
| t.deepEqual( | ||
| parse(['-h', 'localhost', '-p', '555']), | ||
| { h: 'localhost', p: 555, _: [] }, | ||
| 'short captures' | ||
| ); | ||
| t.end(); | ||
| }); | ||
| test('mixed short bool and capture', function (t) { | ||
| t.same( | ||
| parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]), | ||
| { | ||
| f : true, p : 555, h : 'localhost', | ||
| _ : [ 'script.js' ] | ||
| } | ||
| ); | ||
| t.end(); | ||
| t.same( | ||
| parse(['-h', 'localhost', '-fp', '555', 'script.js']), | ||
| { | ||
| f: true, p: 555, h: 'localhost', | ||
| _: ['script.js'], | ||
| } | ||
| ); | ||
| t.end(); | ||
| }); | ||
| test('short and long', function (t) { | ||
| t.deepEqual( | ||
| parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]), | ||
| { | ||
| f : true, p : 555, h : 'localhost', | ||
| _ : [ 'script.js' ] | ||
| } | ||
| ); | ||
| t.end(); | ||
| t.deepEqual( | ||
| parse(['-h', 'localhost', '-fp', '555', 'script.js']), | ||
| { | ||
| f: true, p: 555, h: 'localhost', | ||
| _: ['script.js'], | ||
| } | ||
| ); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,12 +7,12 @@ var test = require('tape'); | ||
| test('stops parsing on the first non-option when stopEarly is set', function (t) { | ||
| var argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], { | ||
| stopEarly: true | ||
| }); | ||
| var argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], { | ||
| stopEarly: true, | ||
| }); | ||
| t.deepEqual(argv, { | ||
| aaa: 'bbb', | ||
| _: ['ccc', '--ddd'] | ||
| }); | ||
| t.deepEqual(argv, { | ||
| aaa: 'bbb', | ||
| _: ['ccc', '--ddd'], | ||
| }); | ||
| t.end(); | ||
| t.end(); | ||
| }); |
@@ -0,1 +1,3 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
@@ -5,99 +7,99 @@ var test = require('tape'); | ||
| test('boolean and alias is not unknown', function (t) { | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = [ '-h', 'true', '--derp', 'true' ]; | ||
| var regular = [ '--herp', 'true', '-d', 'true' ]; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| boolean: 'h', | ||
| unknown: unknownFn | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = ['-h', 'true', '--derp', 'true']; | ||
| var regular = ['--herp', 'true', '-d', 'true']; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| boolean: 'h', | ||
| unknown: unknownFn, | ||
| }; | ||
| parse(aliased, opts); | ||
| parse(regular, opts); | ||
| t.same(unknown, ['--derp', '-d']); | ||
| t.end(); | ||
| t.same(unknown, ['--derp', '-d']); | ||
| t.end(); | ||
| }); | ||
| test('flag boolean true any double hyphen argument is not unknown', function (t) { | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], { | ||
| boolean: true, | ||
| unknown: unknownFn | ||
| }); | ||
| t.same(unknown, ['--tacos=good', 'cow', '-p']); | ||
| t.same(argv, { | ||
| honk: true, | ||
| _: [] | ||
| }); | ||
| t.end(); | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], { | ||
| boolean: true, | ||
| unknown: unknownFn, | ||
| }); | ||
| t.same(unknown, ['--tacos=good', 'cow', '-p']); | ||
| t.same(argv, { | ||
| honk: true, | ||
| _: [], | ||
| }); | ||
| t.end(); | ||
| }); | ||
| test('string and alias is not unknown', function (t) { | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = [ '-h', 'hello', '--derp', 'goodbye' ]; | ||
| var regular = [ '--herp', 'hello', '-d', 'moon' ]; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| string: 'h', | ||
| unknown: unknownFn | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = ['-h', 'hello', '--derp', 'goodbye']; | ||
| var regular = ['--herp', 'hello', '-d', 'moon']; | ||
| var opts = { | ||
| alias: { h: 'herp' }, | ||
| string: 'h', | ||
| unknown: unknownFn, | ||
| }; | ||
| parse(aliased, opts); | ||
| parse(regular, opts); | ||
| t.same(unknown, ['--derp', '-d']); | ||
| t.end(); | ||
| t.same(unknown, ['--derp', '-d']); | ||
| t.end(); | ||
| }); | ||
| test('default and alias is not unknown', function (t) { | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = [ '-h', 'hello' ]; | ||
| var regular = [ '--herp', 'hello' ]; | ||
| var opts = { | ||
| default: { 'h': 'bar' }, | ||
| alias: { 'h': 'herp' }, | ||
| unknown: unknownFn | ||
| }; | ||
| var aliasedArgv = parse(aliased, opts); | ||
| var propertyArgv = parse(regular, opts); | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = ['-h', 'hello']; | ||
| var regular = ['--herp', 'hello']; | ||
| var opts = { | ||
| default: { h: 'bar' }, | ||
| alias: { h: 'herp' }, | ||
| unknown: unknownFn, | ||
| }; | ||
| parse(aliased, opts); | ||
| parse(regular, opts); | ||
| t.same(unknown, []); | ||
| t.end(); | ||
| unknownFn(); // exercise fn for 100% coverage | ||
| t.same(unknown, []); | ||
| t.end(); | ||
| unknownFn(); // exercise fn for 100% coverage | ||
| }); | ||
| test('value following -- is not unknown', function (t) { | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = [ '--bad', '--', 'good', 'arg' ]; | ||
| var opts = { | ||
| '--': true, | ||
| unknown: unknownFn | ||
| }; | ||
| var argv = parse(aliased, opts); | ||
| var unknown = []; | ||
| function unknownFn(arg) { | ||
| unknown.push(arg); | ||
| return false; | ||
| } | ||
| var aliased = ['--bad', '--', 'good', 'arg']; | ||
| var opts = { | ||
| '--': true, | ||
| unknown: unknownFn, | ||
| }; | ||
| var argv = parse(aliased, opts); | ||
| t.same(unknown, ['--bad']); | ||
| t.same(argv, { | ||
| '--': ['good', 'arg'], | ||
| '_': [] | ||
| }) | ||
| t.end(); | ||
| t.same(unknown, ['--bad']); | ||
| t.same(argv, { | ||
| '--': ['good', 'arg'], | ||
| _: [], | ||
| }); | ||
| t.end(); | ||
| }); |
@@ -0,8 +1,10 @@ | ||
| 'use strict'; | ||
| var parse = require('../'); | ||
| var test = require('tape'); | ||
| test('whitespace should be whitespace' , function (t) { | ||
| t.plan(1); | ||
| var x = parse([ '-x', '\t' ]).x; | ||
| t.equal(x, '\t'); | ||
| test('whitespace should be whitespace', function (t) { | ||
| t.plan(1); | ||
| var x = parse(['-x', '\t']).x; | ||
| t.equal(x, '\t'); | ||
| }); |
Sorry, the diff of this file is not supported yet
Fixed alerts
New author
Supply chain riskA new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by7.36%
54477
- Lines of code
- increased by5.63%
1013
- Number of lines in readme file
- increased by3.39%
122
- Number of medium supply chain risk alerts
- decreased by-100%
0
No dependency changes