index.js 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969
  1. var camelCase = require('camelcase')
  2. var decamelize = require('decamelize')
  3. var path = require('path')
  4. var tokenizeArgString = require('./lib/tokenize-arg-string')
  5. var util = require('util')
  6. function parse (args, opts) {
  7. if (!opts) opts = {}
  8. // allow a string argument to be passed in rather
  9. // than an argv array.
  10. args = tokenizeArgString(args)
  11. // aliases might have transitive relationships, normalize this.
  12. var aliases = combineAliases(opts.alias || {})
  13. var configuration = Object.assign({
  14. 'short-option-groups': true,
  15. 'camel-case-expansion': true,
  16. 'dot-notation': true,
  17. 'parse-numbers': true,
  18. 'boolean-negation': true,
  19. 'negation-prefix': 'no-',
  20. 'duplicate-arguments-array': true,
  21. 'flatten-duplicate-arrays': true,
  22. 'populate--': false,
  23. 'combine-arrays': false,
  24. 'set-placeholder-key': false,
  25. 'halt-at-non-option': false,
  26. 'strip-aliased': false,
  27. 'strip-dashed': false,
  28. 'unknown-options-as-args': false
  29. }, opts.configuration)
  30. var defaults = opts.default || {}
  31. var configObjects = opts.configObjects || []
  32. var envPrefix = opts.envPrefix
  33. var notFlagsOption = configuration['populate--']
  34. var notFlagsArgv = notFlagsOption ? '--' : '_'
  35. var newAliases = {}
  36. // allow a i18n handler to be passed in, default to a fake one (util.format).
  37. var __ = opts.__ || util.format
  38. var error = null
  39. var flags = {
  40. aliases: {},
  41. arrays: {},
  42. bools: {},
  43. strings: {},
  44. numbers: {},
  45. counts: {},
  46. normalize: {},
  47. configs: {},
  48. nargs: {},
  49. coercions: {},
  50. keys: []
  51. }
  52. var negative = /^-[0-9]+(\.[0-9]+)?/
  53. var negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)')
  54. ;[].concat(opts.array).filter(Boolean).forEach(function (opt) {
  55. var key = opt.key || opt
  56. // assign to flags[bools|strings|numbers]
  57. const assignment = Object.keys(opt).map(function (key) {
  58. return ({
  59. boolean: 'bools',
  60. string: 'strings',
  61. number: 'numbers'
  62. })[key]
  63. }).filter(Boolean).pop()
  64. // assign key to be coerced
  65. if (assignment) {
  66. flags[assignment][key] = true
  67. }
  68. flags.arrays[key] = true
  69. flags.keys.push(key)
  70. })
  71. ;[].concat(opts.boolean).filter(Boolean).forEach(function (key) {
  72. flags.bools[key] = true
  73. flags.keys.push(key)
  74. })
  75. ;[].concat(opts.string).filter(Boolean).forEach(function (key) {
  76. flags.strings[key] = true
  77. flags.keys.push(key)
  78. })
  79. ;[].concat(opts.number).filter(Boolean).forEach(function (key) {
  80. flags.numbers[key] = true
  81. flags.keys.push(key)
  82. })
  83. ;[].concat(opts.count).filter(Boolean).forEach(function (key) {
  84. flags.counts[key] = true
  85. flags.keys.push(key)
  86. })
  87. ;[].concat(opts.normalize).filter(Boolean).forEach(function (key) {
  88. flags.normalize[key] = true
  89. flags.keys.push(key)
  90. })
  91. Object.keys(opts.narg || {}).forEach(function (k) {
  92. flags.nargs[k] = opts.narg[k]
  93. flags.keys.push(k)
  94. })
  95. Object.keys(opts.coerce || {}).forEach(function (k) {
  96. flags.coercions[k] = opts.coerce[k]
  97. flags.keys.push(k)
  98. })
  99. if (Array.isArray(opts.config) || typeof opts.config === 'string') {
  100. ;[].concat(opts.config).filter(Boolean).forEach(function (key) {
  101. flags.configs[key] = true
  102. })
  103. } else {
  104. Object.keys(opts.config || {}).forEach(function (k) {
  105. flags.configs[k] = opts.config[k]
  106. })
  107. }
  108. // create a lookup table that takes into account all
  109. // combinations of aliases: {f: ['foo'], foo: ['f']}
  110. extendAliases(opts.key, aliases, opts.default, flags.arrays)
  111. // apply default values to all aliases.
  112. Object.keys(defaults).forEach(function (key) {
  113. (flags.aliases[key] || []).forEach(function (alias) {
  114. defaults[alias] = defaults[key]
  115. })
  116. })
  117. var argv = { _: [] }
  118. var notFlags = []
  119. for (var i = 0; i < args.length; i++) {
  120. var arg = args[i]
  121. var broken
  122. var key
  123. var letters
  124. var m
  125. var next
  126. var value
  127. if (isUnknownOptionAsArg(arg)) {
  128. argv._.push(arg)
  129. // -- separated by =
  130. } else if (arg.match(/^--.+=/) || (
  131. !configuration['short-option-groups'] && arg.match(/^-.+=/)
  132. )) {
  133. // Using [\s\S] instead of . because js doesn't support the
  134. // 'dotall' regex modifier. See:
  135. // http://stackoverflow.com/a/1068308/13216
  136. m = arg.match(/^--?([^=]+)=([\s\S]*)$/)
  137. // nargs format = '--f=monkey washing cat'
  138. if (checkAllAliases(m[1], flags.nargs)) {
  139. args.splice(i + 1, 0, m[2])
  140. i = eatNargs(i, m[1], args)
  141. // arrays format = '--f=a b c'
  142. } else if (checkAllAliases(m[1], flags.arrays)) {
  143. args.splice(i + 1, 0, m[2])
  144. i = eatArray(i, m[1], args)
  145. } else {
  146. setArg(m[1], m[2])
  147. }
  148. } else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
  149. key = arg.match(negatedBoolean)[1]
  150. setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false)
  151. // -- separated by space.
  152. } else if (arg.match(/^--.+/) || (
  153. !configuration['short-option-groups'] && arg.match(/^-[^-]+/)
  154. )) {
  155. key = arg.match(/^--?(.+)/)[1]
  156. // nargs format = '--foo a b c'
  157. // should be truthy even if: flags.nargs[key] === 0
  158. if (checkAllAliases(key, flags.nargs) !== false) {
  159. i = eatNargs(i, key, args)
  160. // array format = '--foo a b c'
  161. } else if (checkAllAliases(key, flags.arrays)) {
  162. i = eatArray(i, key, args)
  163. } else {
  164. next = args[i + 1]
  165. if (next !== undefined && (!next.match(/^-/) ||
  166. next.match(negative)) &&
  167. !checkAllAliases(key, flags.bools) &&
  168. !checkAllAliases(key, flags.counts)) {
  169. setArg(key, next)
  170. i++
  171. } else if (/^(true|false)$/.test(next)) {
  172. setArg(key, next)
  173. i++
  174. } else {
  175. setArg(key, defaultValue(key))
  176. }
  177. }
  178. // dot-notation flag separated by '='.
  179. } else if (arg.match(/^-.\..+=/)) {
  180. m = arg.match(/^-([^=]+)=([\s\S]*)$/)
  181. setArg(m[1], m[2])
  182. // dot-notation flag separated by space.
  183. } else if (arg.match(/^-.\..+/)) {
  184. next = args[i + 1]
  185. key = arg.match(/^-(.\..+)/)[1]
  186. if (next !== undefined && !next.match(/^-/) &&
  187. !checkAllAliases(key, flags.bools) &&
  188. !checkAllAliases(key, flags.counts)) {
  189. setArg(key, next)
  190. i++
  191. } else {
  192. setArg(key, defaultValue(key))
  193. }
  194. } else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
  195. letters = arg.slice(1, -1).split('')
  196. broken = false
  197. for (var j = 0; j < letters.length; j++) {
  198. next = arg.slice(j + 2)
  199. if (letters[j + 1] && letters[j + 1] === '=') {
  200. value = arg.slice(j + 3)
  201. key = letters[j]
  202. // nargs format = '-f=monkey washing cat'
  203. if (checkAllAliases(key, flags.nargs)) {
  204. args.splice(i + 1, 0, value)
  205. i = eatNargs(i, key, args)
  206. // array format = '-f=a b c'
  207. } else if (checkAllAliases(key, flags.arrays)) {
  208. args.splice(i + 1, 0, value)
  209. i = eatArray(i, key, args)
  210. } else {
  211. setArg(key, value)
  212. }
  213. broken = true
  214. break
  215. }
  216. if (next === '-') {
  217. setArg(letters[j], next)
  218. continue
  219. }
  220. // current letter is an alphabetic character and next value is a number
  221. if (/[A-Za-z]/.test(letters[j]) &&
  222. /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
  223. setArg(letters[j], next)
  224. broken = true
  225. break
  226. }
  227. if (letters[j + 1] && letters[j + 1].match(/\W/)) {
  228. setArg(letters[j], next)
  229. broken = true
  230. break
  231. } else {
  232. setArg(letters[j], defaultValue(letters[j]))
  233. }
  234. }
  235. key = arg.slice(-1)[0]
  236. if (!broken && key !== '-') {
  237. // nargs format = '-f a b c'
  238. // should be truthy even if: flags.nargs[key] === 0
  239. if (checkAllAliases(key, flags.nargs) !== false) {
  240. i = eatNargs(i, key, args)
  241. // array format = '-f a b c'
  242. } else if (checkAllAliases(key, flags.arrays)) {
  243. i = eatArray(i, key, args)
  244. } else {
  245. next = args[i + 1]
  246. if (next !== undefined && (!/^(-|--)[^-]/.test(next) ||
  247. next.match(negative)) &&
  248. !checkAllAliases(key, flags.bools) &&
  249. !checkAllAliases(key, flags.counts)) {
  250. setArg(key, next)
  251. i++
  252. } else if (/^(true|false)$/.test(next)) {
  253. setArg(key, next)
  254. i++
  255. } else {
  256. setArg(key, defaultValue(key))
  257. }
  258. }
  259. }
  260. } else if (arg === '--') {
  261. notFlags = args.slice(i + 1)
  262. break
  263. } else if (configuration['halt-at-non-option']) {
  264. notFlags = args.slice(i)
  265. break
  266. } else {
  267. argv._.push(maybeCoerceNumber('_', arg))
  268. }
  269. }
  270. // order of precedence:
  271. // 1. command line arg
  272. // 2. value from env var
  273. // 3. value from config file
  274. // 4. value from config objects
  275. // 5. configured default value
  276. applyEnvVars(argv, true) // special case: check env vars that point to config file
  277. applyEnvVars(argv, false)
  278. setConfig(argv)
  279. setConfigObjects()
  280. applyDefaultsAndAliases(argv, flags.aliases, defaults)
  281. applyCoercions(argv)
  282. if (configuration['set-placeholder-key']) setPlaceholderKeys(argv)
  283. // for any counts either not in args or without an explicit default, set to 0
  284. Object.keys(flags.counts).forEach(function (key) {
  285. if (!hasKey(argv, key.split('.'))) setArg(key, 0)
  286. })
  287. // '--' defaults to undefined.
  288. if (notFlagsOption && notFlags.length) argv[notFlagsArgv] = []
  289. notFlags.forEach(function (key) {
  290. argv[notFlagsArgv].push(key)
  291. })
  292. if (configuration['camel-case-expansion'] && configuration['strip-dashed']) {
  293. Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
  294. delete argv[key]
  295. })
  296. }
  297. if (configuration['strip-aliased']) {
  298. // XXX Switch to [].concat(...Object.values(aliases)) once node.js 6 is dropped
  299. ;[].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => {
  300. if (configuration['camel-case-expansion']) {
  301. delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')]
  302. }
  303. delete argv[alias]
  304. })
  305. }
  306. // how many arguments should we consume, based
  307. // on the nargs option?
  308. function eatNargs (i, key, args) {
  309. var ii
  310. const toEat = checkAllAliases(key, flags.nargs)
  311. if (toEat === 0) {
  312. setArg(key, defaultValue(key))
  313. return i
  314. }
  315. // nargs will not consume flag arguments, e.g., -abc, --foo,
  316. // and terminates when one is observed.
  317. var available = 0
  318. for (ii = i + 1; ii < args.length; ii++) {
  319. if (!args[ii].match(/^-[^0-9]/) || isUnknownOptionAsArg(args[ii])) available++
  320. else break
  321. }
  322. if (available < toEat) error = Error(__('Not enough arguments following: %s', key))
  323. const consumed = Math.min(available, toEat)
  324. for (ii = i + 1; ii < (consumed + i + 1); ii++) {
  325. setArg(key, args[ii])
  326. }
  327. return (i + consumed)
  328. }
  329. // if an option is an array, eat all non-hyphenated arguments
  330. // following it... YUM!
  331. // e.g., --foo apple banana cat becomes ["apple", "banana", "cat"]
  332. function eatArray (i, key, args) {
  333. let argsToSet = []
  334. let next = args[i + 1]
  335. if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
  336. argsToSet.push(true)
  337. } else if (isUndefined(next) || (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) {
  338. // for keys without value ==> argsToSet remains an empty []
  339. // set user default value, if available
  340. if (defaults.hasOwnProperty(key)) {
  341. argsToSet.push(defaults[key])
  342. }
  343. } else {
  344. for (var ii = i + 1; ii < args.length; ii++) {
  345. next = args[ii]
  346. if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) break
  347. i = ii
  348. argsToSet.push(processValue(key, next))
  349. }
  350. }
  351. setArg(key, argsToSet)
  352. return i
  353. }
  354. function setArg (key, val) {
  355. if (/-/.test(key) && configuration['camel-case-expansion']) {
  356. var alias = key.split('.').map(function (prop) {
  357. return camelCase(prop)
  358. }).join('.')
  359. addNewAlias(key, alias)
  360. }
  361. var value = processValue(key, val)
  362. var splitKey = key.split('.')
  363. setKey(argv, splitKey, value)
  364. // handle populating aliases of the full key
  365. if (flags.aliases[key] && flags.aliases[key].forEach) {
  366. flags.aliases[key].forEach(function (x) {
  367. x = x.split('.')
  368. setKey(argv, x, value)
  369. })
  370. }
  371. // handle populating aliases of the first element of the dot-notation key
  372. if (splitKey.length > 1 && configuration['dot-notation']) {
  373. ;(flags.aliases[splitKey[0]] || []).forEach(function (x) {
  374. x = x.split('.')
  375. // expand alias with nested objects in key
  376. var a = [].concat(splitKey)
  377. a.shift() // nuke the old key.
  378. x = x.concat(a)
  379. setKey(argv, x, value)
  380. })
  381. }
  382. // Set normalize getter and setter when key is in 'normalize' but isn't an array
  383. if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
  384. var keys = [key].concat(flags.aliases[key] || [])
  385. keys.forEach(function (key) {
  386. argv.__defineSetter__(key, function (v) {
  387. val = path.normalize(v)
  388. })
  389. argv.__defineGetter__(key, function () {
  390. return typeof val === 'string' ? path.normalize(val) : val
  391. })
  392. })
  393. }
  394. }
  395. function addNewAlias (key, alias) {
  396. if (!(flags.aliases[key] && flags.aliases[key].length)) {
  397. flags.aliases[key] = [alias]
  398. newAliases[alias] = true
  399. }
  400. if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
  401. addNewAlias(alias, key)
  402. }
  403. }
  404. function processValue (key, val) {
  405. // strings may be quoted, clean this up as we assign values.
  406. if (typeof val === 'string' &&
  407. (val[0] === "'" || val[0] === '"') &&
  408. val[val.length - 1] === val[0]
  409. ) {
  410. val = val.substring(1, val.length - 1)
  411. }
  412. // handle parsing boolean arguments --foo=true --bar false.
  413. if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
  414. if (typeof val === 'string') val = val === 'true'
  415. }
  416. var value = Array.isArray(val)
  417. ? val.map(function (v) { return maybeCoerceNumber(key, v) })
  418. : maybeCoerceNumber(key, val)
  419. // increment a count given as arg (either no value or value parsed as boolean)
  420. if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
  421. value = increment
  422. }
  423. // Set normalized value when key is in 'normalize' and in 'arrays'
  424. if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
  425. if (Array.isArray(val)) value = val.map(path.normalize)
  426. else value = path.normalize(val)
  427. }
  428. return value
  429. }
  430. function maybeCoerceNumber (key, value) {
  431. if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
  432. const shouldCoerceNumber = isNumber(value) && configuration['parse-numbers'] && (
  433. Number.isSafeInteger(Math.floor(value))
  434. )
  435. if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) value = Number(value)
  436. }
  437. return value
  438. }
  439. // set args from config.json file, this should be
  440. // applied last so that defaults can be applied.
  441. function setConfig (argv) {
  442. var configLookup = {}
  443. // expand defaults/aliases, in-case any happen to reference
  444. // the config.json file.
  445. applyDefaultsAndAliases(configLookup, flags.aliases, defaults)
  446. Object.keys(flags.configs).forEach(function (configKey) {
  447. var configPath = argv[configKey] || configLookup[configKey]
  448. if (configPath) {
  449. try {
  450. var config = null
  451. var resolvedConfigPath = path.resolve(process.cwd(), configPath)
  452. if (typeof flags.configs[configKey] === 'function') {
  453. try {
  454. config = flags.configs[configKey](resolvedConfigPath)
  455. } catch (e) {
  456. config = e
  457. }
  458. if (config instanceof Error) {
  459. error = config
  460. return
  461. }
  462. } else {
  463. config = require(resolvedConfigPath)
  464. }
  465. setConfigObject(config)
  466. } catch (ex) {
  467. if (argv[configKey]) error = Error(__('Invalid JSON config file: %s', configPath))
  468. }
  469. }
  470. })
  471. }
  472. // set args from config object.
  473. // it recursively checks nested objects.
  474. function setConfigObject (config, prev) {
  475. Object.keys(config).forEach(function (key) {
  476. var value = config[key]
  477. var fullKey = prev ? prev + '.' + key : key
  478. // if the value is an inner object and we have dot-notation
  479. // enabled, treat inner objects in config the same as
  480. // heavily nested dot notations (foo.bar.apple).
  481. if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) {
  482. // if the value is an object but not an array, check nested object
  483. setConfigObject(value, fullKey)
  484. } else {
  485. // setting arguments via CLI takes precedence over
  486. // values within the config file.
  487. if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) {
  488. setArg(fullKey, value)
  489. }
  490. }
  491. })
  492. }
  493. // set all config objects passed in opts
  494. function setConfigObjects () {
  495. if (typeof configObjects === 'undefined') return
  496. configObjects.forEach(function (configObject) {
  497. setConfigObject(configObject)
  498. })
  499. }
  500. function applyEnvVars (argv, configOnly) {
  501. if (typeof envPrefix === 'undefined') return
  502. var prefix = typeof envPrefix === 'string' ? envPrefix : ''
  503. Object.keys(process.env).forEach(function (envVar) {
  504. if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) {
  505. // get array of nested keys and convert them to camel case
  506. var keys = envVar.split('__').map(function (key, i) {
  507. if (i === 0) {
  508. key = key.substring(prefix.length)
  509. }
  510. return camelCase(key)
  511. })
  512. if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) {
  513. setArg(keys.join('.'), process.env[envVar])
  514. }
  515. }
  516. })
  517. }
  518. function applyCoercions (argv) {
  519. var coerce
  520. var applied = {}
  521. Object.keys(argv).forEach(function (key) {
  522. if (!applied.hasOwnProperty(key)) { // If we haven't already coerced this option via one of its aliases
  523. coerce = checkAllAliases(key, flags.coercions)
  524. if (typeof coerce === 'function') {
  525. try {
  526. var value = maybeCoerceNumber(key, coerce(argv[key]))
  527. ;([].concat(flags.aliases[key] || [], key)).forEach(ali => {
  528. applied[ali] = argv[ali] = value
  529. })
  530. } catch (err) {
  531. error = err
  532. }
  533. }
  534. }
  535. })
  536. }
  537. function setPlaceholderKeys (argv) {
  538. flags.keys.forEach((key) => {
  539. // don't set placeholder keys for dot notation options 'foo.bar'.
  540. if (~key.indexOf('.')) return
  541. if (typeof argv[key] === 'undefined') argv[key] = undefined
  542. })
  543. return argv
  544. }
  545. function applyDefaultsAndAliases (obj, aliases, defaults) {
  546. Object.keys(defaults).forEach(function (key) {
  547. if (!hasKey(obj, key.split('.'))) {
  548. setKey(obj, key.split('.'), defaults[key])
  549. ;(aliases[key] || []).forEach(function (x) {
  550. if (hasKey(obj, x.split('.'))) return
  551. setKey(obj, x.split('.'), defaults[key])
  552. })
  553. }
  554. })
  555. }
  556. function hasKey (obj, keys) {
  557. var o = obj
  558. if (!configuration['dot-notation']) keys = [keys.join('.')]
  559. keys.slice(0, -1).forEach(function (key) {
  560. o = (o[key] || {})
  561. })
  562. var key = keys[keys.length - 1]
  563. if (typeof o !== 'object') return false
  564. else return key in o
  565. }
  566. function setKey (obj, keys, value) {
  567. var o = obj
  568. if (!configuration['dot-notation']) keys = [keys.join('.')]
  569. keys.slice(0, -1).forEach(function (key, index) {
  570. // TODO(bcoe): in the next major version of yargs, switch to
  571. // Object.create(null) for dot notation:
  572. key = sanitizeKey(key)
  573. if (typeof o === 'object' && o[key] === undefined) {
  574. o[key] = {}
  575. }
  576. if (typeof o[key] !== 'object' || Array.isArray(o[key])) {
  577. // ensure that o[key] is an array, and that the last item is an empty object.
  578. if (Array.isArray(o[key])) {
  579. o[key].push({})
  580. } else {
  581. o[key] = [o[key], {}]
  582. }
  583. // we want to update the empty object at the end of the o[key] array, so set o to that object
  584. o = o[key][o[key].length - 1]
  585. } else {
  586. o = o[key]
  587. }
  588. })
  589. // TODO(bcoe): in the next major version of yargs, switch to
  590. // Object.create(null) for dot notation:
  591. const key = sanitizeKey(keys[keys.length - 1])
  592. const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays)
  593. const isValueArray = Array.isArray(value)
  594. let duplicate = configuration['duplicate-arguments-array']
  595. // nargs has higher priority than duplicate
  596. if (!duplicate && checkAllAliases(key, flags.nargs)) {
  597. duplicate = true
  598. if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) {
  599. o[key] = undefined
  600. }
  601. }
  602. if (value === increment) {
  603. o[key] = increment(o[key])
  604. } else if (Array.isArray(o[key])) {
  605. if (duplicate && isTypeArray && isValueArray) {
  606. o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value])
  607. } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
  608. o[key] = value
  609. } else {
  610. o[key] = o[key].concat([value])
  611. }
  612. } else if (o[key] === undefined && isTypeArray) {
  613. o[key] = isValueArray ? value : [value]
  614. } else if (duplicate && !(o[key] === undefined || checkAllAliases(key, flags.counts))) {
  615. o[key] = [ o[key], value ]
  616. } else {
  617. o[key] = value
  618. }
  619. }
  620. // extend the aliases list with inferred aliases.
  621. function extendAliases (...args) {
  622. args.forEach(function (obj) {
  623. Object.keys(obj || {}).forEach(function (key) {
  624. // short-circuit if we've already added a key
  625. // to the aliases array, for example it might
  626. // exist in both 'opts.default' and 'opts.key'.
  627. if (flags.aliases[key]) return
  628. flags.aliases[key] = [].concat(aliases[key] || [])
  629. // For "--option-name", also set argv.optionName
  630. flags.aliases[key].concat(key).forEach(function (x) {
  631. if (/-/.test(x) && configuration['camel-case-expansion']) {
  632. var c = camelCase(x)
  633. if (c !== key && flags.aliases[key].indexOf(c) === -1) {
  634. flags.aliases[key].push(c)
  635. newAliases[c] = true
  636. }
  637. }
  638. })
  639. // For "--optionName", also set argv['option-name']
  640. flags.aliases[key].concat(key).forEach(function (x) {
  641. if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) {
  642. var c = decamelize(x, '-')
  643. if (c !== key && flags.aliases[key].indexOf(c) === -1) {
  644. flags.aliases[key].push(c)
  645. newAliases[c] = true
  646. }
  647. }
  648. })
  649. flags.aliases[key].forEach(function (x) {
  650. flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
  651. return x !== y
  652. }))
  653. })
  654. })
  655. })
  656. }
  657. // check if a flag is set for any of a key's aliases.
  658. function checkAllAliases (key, flag) {
  659. var isSet = false
  660. var toCheck = [].concat(flags.aliases[key] || [], key)
  661. toCheck.forEach(function (key) {
  662. if (flag.hasOwnProperty(key)) isSet = flag[key]
  663. })
  664. return isSet
  665. }
  666. function hasAnyFlag (key) {
  667. // XXX Switch to [].concat(...Object.values(flags)) once node.js 6 is dropped
  668. var toCheck = [].concat(...Object.keys(flags).map(k => flags[k]))
  669. return toCheck.some(function (flag) {
  670. return flag[key]
  671. })
  672. }
  673. function hasFlagsMatching (arg, ...patterns) {
  674. var toCheck = [].concat(...patterns)
  675. return toCheck.some(function (pattern) {
  676. var match = arg.match(pattern)
  677. return match && hasAnyFlag(match[1])
  678. })
  679. }
  680. // based on a simplified version of the short flag group parsing logic
  681. function hasAllShortFlags (arg) {
  682. // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group
  683. if (arg.match(negative) || !arg.match(/^-[^-]+/)) { return false }
  684. var hasAllFlags = true
  685. var letters = arg.slice(1).split('')
  686. var next
  687. for (var j = 0; j < letters.length; j++) {
  688. next = arg.slice(j + 2)
  689. if (!hasAnyFlag(letters[j])) {
  690. hasAllFlags = false
  691. break
  692. }
  693. if ((letters[j + 1] && letters[j + 1] === '=') ||
  694. next === '-' ||
  695. (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) ||
  696. (letters[j + 1] && letters[j + 1].match(/\W/))) {
  697. break
  698. }
  699. }
  700. return hasAllFlags
  701. }
  702. function isUnknownOptionAsArg (arg) {
  703. return configuration['unknown-options-as-args'] && isUnknownOption(arg)
  704. }
  705. function isUnknownOption (arg) {
  706. arg = arg.replace(/^-{3,}/, '---')
  707. // ignore negative numbers
  708. if (arg.match(negative)) { return false }
  709. // if this is a short option group and all of them are configured, it isn't unknown
  710. if (hasAllShortFlags(arg)) { return false }
  711. // e.g. '--count=2'
  712. const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/
  713. // e.g. '-a' or '--arg'
  714. const normalFlag = /^-+([^=]+?)$/
  715. // e.g. '-a-'
  716. const flagEndingInHyphen = /^-+([^=]+?)-$/
  717. // e.g. '-abc123'
  718. const flagEndingInDigits = /^-+([^=]+?)\d+$/
  719. // e.g. '-a/usr/local'
  720. const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/
  721. // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method
  722. return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters)
  723. }
  724. // make a best effor to pick a default value
  725. // for an option based on name and type.
  726. function defaultValue (key) {
  727. if (!checkAllAliases(key, flags.bools) &&
  728. !checkAllAliases(key, flags.counts) &&
  729. `${key}` in defaults) {
  730. return defaults[key]
  731. } else {
  732. return defaultForType(guessType(key))
  733. }
  734. }
  735. // return a default value, given the type of a flag.,
  736. // e.g., key of type 'string' will default to '', rather than 'true'.
  737. function defaultForType (type) {
  738. var def = {
  739. boolean: true,
  740. string: '',
  741. number: undefined,
  742. array: []
  743. }
  744. return def[type]
  745. }
  746. // given a flag, enforce a default type.
  747. function guessType (key) {
  748. var type = 'boolean'
  749. if (checkAllAliases(key, flags.strings)) type = 'string'
  750. else if (checkAllAliases(key, flags.numbers)) type = 'number'
  751. else if (checkAllAliases(key, flags.bools)) type = 'boolean'
  752. else if (checkAllAliases(key, flags.arrays)) type = 'array'
  753. return type
  754. }
  755. function isNumber (x) {
  756. if (x === null || x === undefined) return false
  757. // if loaded from config, may already be a number.
  758. if (typeof x === 'number') return true
  759. // hexadecimal.
  760. if (/^0x[0-9a-f]+$/i.test(x)) return true
  761. // don't treat 0123 as a number; as it drops the leading '0'.
  762. if (x.length > 1 && x[0] === '0') return false
  763. return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x)
  764. }
  765. function isUndefined (num) {
  766. return num === undefined
  767. }
  768. return {
  769. argv: argv,
  770. error: error,
  771. aliases: flags.aliases,
  772. newAliases: newAliases,
  773. configuration: configuration
  774. }
  775. }
  776. // if any aliases reference each other, we should
  777. // merge them together.
  778. function combineAliases (aliases) {
  779. var aliasArrays = []
  780. var change = true
  781. var combined = {}
  782. // turn alias lookup hash {key: ['alias1', 'alias2']} into
  783. // a simple array ['key', 'alias1', 'alias2']
  784. Object.keys(aliases).forEach(function (key) {
  785. aliasArrays.push(
  786. [].concat(aliases[key], key)
  787. )
  788. })
  789. // combine arrays until zero changes are
  790. // made in an iteration.
  791. while (change) {
  792. change = false
  793. for (var i = 0; i < aliasArrays.length; i++) {
  794. for (var ii = i + 1; ii < aliasArrays.length; ii++) {
  795. var intersect = aliasArrays[i].filter(function (v) {
  796. return aliasArrays[ii].indexOf(v) !== -1
  797. })
  798. if (intersect.length) {
  799. aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii])
  800. aliasArrays.splice(ii, 1)
  801. change = true
  802. break
  803. }
  804. }
  805. }
  806. }
  807. // map arrays back to the hash-lookup (de-dupe while
  808. // we're at it).
  809. aliasArrays.forEach(function (aliasArray) {
  810. aliasArray = aliasArray.filter(function (v, i, self) {
  811. return self.indexOf(v) === i
  812. })
  813. combined[aliasArray.pop()] = aliasArray
  814. })
  815. return combined
  816. }
  817. // this function should only be called when a count is given as an arg
  818. // it is NOT called to set a default value
  819. // thus we can start the count at 1 instead of 0
  820. function increment (orig) {
  821. return orig !== undefined ? orig + 1 : 1
  822. }
  823. function Parser (args, opts) {
  824. var result = parse(args.slice(), opts)
  825. return result.argv
  826. }
  827. // parse arguments and return detailed
  828. // meta information, aliases, etc.
  829. Parser.detailed = function (args, opts) {
  830. return parse(args.slice(), opts)
  831. }
  832. // TODO(bcoe): in the next major version of yargs, switch to
  833. // Object.create(null) for dot notation:
  834. function sanitizeKey (key) {
  835. if (key === '__proto__') return '___proto___'
  836. return key
  837. }
  838. module.exports = Parser