1 | 'use strict'
|
2 | const argsert = require('./lib/argsert')
|
3 | const fs = require('fs')
|
4 | const Command = require('./lib/command')
|
5 | const Completion = require('./lib/completion')
|
6 | const Parser = require('yargs-parser')
|
7 | const path = require('path')
|
8 | const Usage = require('./lib/usage')
|
9 | const Validation = require('./lib/validation')
|
10 | const Y18n = require('y18n')
|
11 | const objFilter = require('./lib/obj-filter')
|
12 | const setBlocking = require('set-blocking')
|
13 | const applyExtends = require('./lib/apply-extends')
|
14 | const { globalMiddlewareFactory } = require('./lib/middleware')
|
15 | const YError = require('./lib/yerror')
|
16 |
|
17 | exports = module.exports = Yargs
|
18 | function Yargs (processArgs, cwd, parentRequire) {
|
19 | processArgs = processArgs || []
|
20 |
|
21 | const self = {}
|
22 | let command = null
|
23 | let completion = null
|
24 | let groups = {}
|
25 | let globalMiddleware = []
|
26 | let output = ''
|
27 | let preservedGroups = {}
|
28 | let usage = null
|
29 | let validation = null
|
30 |
|
31 | const y18n = Y18n({
|
32 | directory: path.resolve(__dirname, './locales'),
|
33 | updateFiles: false
|
34 | })
|
35 |
|
36 | self.middleware = globalMiddlewareFactory(globalMiddleware, self)
|
37 |
|
38 | if (!cwd) cwd = process.cwd()
|
39 |
|
40 | self.scriptName = function scriptName (scriptName) {
|
41 | self.$0 = scriptName
|
42 | return self
|
43 | }
|
44 |
|
45 |
|
46 |
|
47 | if (/\b(node|iojs|electron)(\.exe)?$/.test(process.argv[0])) {
|
48 | self.$0 = process.argv.slice(1, 2)
|
49 | } else {
|
50 | self.$0 = process.argv.slice(0, 1)
|
51 | }
|
52 |
|
53 | self.$0 = self.$0
|
54 | .map((x, i) => {
|
55 | const b = rebase(cwd, x)
|
56 | return x.match(/^(\/|([a-zA-Z]:)?\\)/) && b.length < x.length ? b : x
|
57 | })
|
58 | .join(' ').trim()
|
59 |
|
60 | if (process.env._ !== undefined && process.argv[1] === process.env._) {
|
61 | self.$0 = process.env._.replace(
|
62 | `${path.dirname(process.execPath)}/`, ''
|
63 | )
|
64 | }
|
65 |
|
66 |
|
67 |
|
68 | const context = { resets: -1, commands: [], fullCommands: [], files: [] }
|
69 | self.getContext = () => context
|
70 |
|
71 |
|
72 |
|
73 |
|
74 | let options
|
75 | self.resetOptions = self.reset = function resetOptions (aliases) {
|
76 | context.resets++
|
77 | aliases = aliases || {}
|
78 | options = options || {}
|
79 |
|
80 |
|
81 |
|
82 | const tmpOptions = {}
|
83 | tmpOptions.local = options.local ? options.local : []
|
84 | tmpOptions.configObjects = options.configObjects ? options.configObjects : []
|
85 |
|
86 |
|
87 |
|
88 | const localLookup = {}
|
89 | tmpOptions.local.forEach((l) => {
|
90 | localLookup[l] = true
|
91 | ;(aliases[l] || []).forEach((a) => {
|
92 | localLookup[a] = true
|
93 | })
|
94 | })
|
95 |
|
96 |
|
97 | preservedGroups = Object.keys(groups).reduce((acc, groupName) => {
|
98 | const keys = groups[groupName].filter(key => !(key in localLookup))
|
99 | if (keys.length > 0) {
|
100 | acc[groupName] = keys
|
101 | }
|
102 | return acc
|
103 | }, {})
|
104 |
|
105 | groups = {}
|
106 |
|
107 | const arrayOptions = [
|
108 | 'array', 'boolean', 'string', 'skipValidation',
|
109 | 'count', 'normalize', 'number',
|
110 | 'hiddenOptions'
|
111 | ]
|
112 |
|
113 | const objectOptions = [
|
114 | 'narg', 'key', 'alias', 'default', 'defaultDescription',
|
115 | 'config', 'choices', 'demandedOptions', 'demandedCommands', 'coerce'
|
116 | ]
|
117 |
|
118 | arrayOptions.forEach((k) => {
|
119 | tmpOptions[k] = (options[k] || []).filter(k => !localLookup[k])
|
120 | })
|
121 |
|
122 | objectOptions.forEach((k) => {
|
123 | tmpOptions[k] = objFilter(options[k], (k, v) => !localLookup[k])
|
124 | })
|
125 |
|
126 | tmpOptions.envPrefix = options.envPrefix
|
127 | options = tmpOptions
|
128 |
|
129 |
|
130 |
|
131 | usage = usage ? usage.reset(localLookup) : Usage(self, y18n)
|
132 | validation = validation ? validation.reset(localLookup) : Validation(self, usage, y18n)
|
133 | command = command ? command.reset() : Command(self, usage, validation, globalMiddleware)
|
134 | if (!completion) completion = Completion(self, usage, command)
|
135 |
|
136 | completionCommand = null
|
137 | output = ''
|
138 | exitError = null
|
139 | hasOutput = false
|
140 | self.parsed = false
|
141 |
|
142 | return self
|
143 | }
|
144 | self.resetOptions()
|
145 |
|
146 |
|
147 | let frozen
|
148 | function freeze () {
|
149 | frozen = {}
|
150 | frozen.options = options
|
151 | frozen.configObjects = options.configObjects.slice(0)
|
152 | frozen.exitProcess = exitProcess
|
153 | frozen.groups = groups
|
154 | usage.freeze()
|
155 | validation.freeze()
|
156 | command.freeze()
|
157 | frozen.strict = strict
|
158 | frozen.completionCommand = completionCommand
|
159 | frozen.output = output
|
160 | frozen.exitError = exitError
|
161 | frozen.hasOutput = hasOutput
|
162 | frozen.parsed = self.parsed
|
163 | }
|
164 | function unfreeze () {
|
165 | options = frozen.options
|
166 | options.configObjects = frozen.configObjects
|
167 | exitProcess = frozen.exitProcess
|
168 | groups = frozen.groups
|
169 | output = frozen.output
|
170 | exitError = frozen.exitError
|
171 | hasOutput = frozen.hasOutput
|
172 | self.parsed = frozen.parsed
|
173 | usage.unfreeze()
|
174 | validation.unfreeze()
|
175 | command.unfreeze()
|
176 | strict = frozen.strict
|
177 | completionCommand = frozen.completionCommand
|
178 | parseFn = null
|
179 | parseContext = null
|
180 | frozen = undefined
|
181 | }
|
182 |
|
183 | self.boolean = function (keys) {
|
184 | argsert('<array|string>', [keys], arguments.length)
|
185 | populateParserHintArray('boolean', keys)
|
186 | return self
|
187 | }
|
188 |
|
189 | self.array = function (keys) {
|
190 | argsert('<array|string>', [keys], arguments.length)
|
191 | populateParserHintArray('array', keys)
|
192 | return self
|
193 | }
|
194 |
|
195 | self.number = function (keys) {
|
196 | argsert('<array|string>', [keys], arguments.length)
|
197 | populateParserHintArray('number', keys)
|
198 | return self
|
199 | }
|
200 |
|
201 | self.normalize = function (keys) {
|
202 | argsert('<array|string>', [keys], arguments.length)
|
203 | populateParserHintArray('normalize', keys)
|
204 | return self
|
205 | }
|
206 |
|
207 | self.count = function (keys) {
|
208 | argsert('<array|string>', [keys], arguments.length)
|
209 | populateParserHintArray('count', keys)
|
210 | return self
|
211 | }
|
212 |
|
213 | self.string = function (keys) {
|
214 | argsert('<array|string>', [keys], arguments.length)
|
215 | populateParserHintArray('string', keys)
|
216 | return self
|
217 | }
|
218 |
|
219 | self.requiresArg = function (keys) {
|
220 | argsert('<array|string>', [keys], arguments.length)
|
221 | populateParserHintObject(self.nargs, false, 'narg', keys, 1)
|
222 | return self
|
223 | }
|
224 |
|
225 | self.skipValidation = function (keys) {
|
226 | argsert('<array|string>', [keys], arguments.length)
|
227 | populateParserHintArray('skipValidation', keys)
|
228 | return self
|
229 | }
|
230 |
|
231 | function populateParserHintArray (type, keys, value) {
|
232 | keys = [].concat(keys)
|
233 | keys.forEach((key) => {
|
234 | options[type].push(key)
|
235 | })
|
236 | }
|
237 |
|
238 | self.nargs = function (key, value) {
|
239 | argsert('<string|object|array> [number]', [key, value], arguments.length)
|
240 | populateParserHintObject(self.nargs, false, 'narg', key, value)
|
241 | return self
|
242 | }
|
243 |
|
244 | self.choices = function (key, value) {
|
245 | argsert('<object|string|array> [string|array]', [key, value], arguments.length)
|
246 | populateParserHintObject(self.choices, true, 'choices', key, value)
|
247 | return self
|
248 | }
|
249 |
|
250 | self.alias = function (key, value) {
|
251 | argsert('<object|string|array> [string|array]', [key, value], arguments.length)
|
252 | populateParserHintObject(self.alias, true, 'alias', key, value)
|
253 | return self
|
254 | }
|
255 |
|
256 |
|
257 | self.default = self.defaults = function (key, value, defaultDescription) {
|
258 | argsert('<object|string|array> [*] [string]', [key, value, defaultDescription], arguments.length)
|
259 | if (defaultDescription) options.defaultDescription[key] = defaultDescription
|
260 | if (typeof value === 'function') {
|
261 | if (!options.defaultDescription[key]) options.defaultDescription[key] = usage.functionDescription(value)
|
262 | value = value.call()
|
263 | }
|
264 | populateParserHintObject(self.default, false, 'default', key, value)
|
265 | return self
|
266 | }
|
267 |
|
268 | self.describe = function (key, desc) {
|
269 | argsert('<object|string|array> [string]', [key, desc], arguments.length)
|
270 | populateParserHintObject(self.describe, false, 'key', key, true)
|
271 | usage.describe(key, desc)
|
272 | return self
|
273 | }
|
274 |
|
275 | self.demandOption = function (keys, msg) {
|
276 | argsert('<object|string|array> [string]', [keys, msg], arguments.length)
|
277 | populateParserHintObject(self.demandOption, false, 'demandedOptions', keys, msg)
|
278 | return self
|
279 | }
|
280 |
|
281 | self.coerce = function (keys, value) {
|
282 | argsert('<object|string|array> [function]', [keys, value], arguments.length)
|
283 | populateParserHintObject(self.coerce, false, 'coerce', keys, value)
|
284 | return self
|
285 | }
|
286 |
|
287 | function populateParserHintObject (builder, isArray, type, key, value) {
|
288 | if (Array.isArray(key)) {
|
289 |
|
290 | const temp = {}
|
291 | key.forEach((k) => {
|
292 | temp[k] = value
|
293 | })
|
294 | builder(temp)
|
295 | } else if (typeof key === 'object') {
|
296 |
|
297 | Object.keys(key).forEach((k) => {
|
298 | builder(k, key[k])
|
299 | })
|
300 | } else {
|
301 |
|
302 | if (isArray) {
|
303 | options[type][key] = (options[type][key] || []).concat(value)
|
304 | } else {
|
305 | options[type][key] = value
|
306 | }
|
307 | }
|
308 | }
|
309 |
|
310 | function deleteFromParserHintObject (optionKey) {
|
311 |
|
312 |
|
313 | Object.keys(options).forEach((hintKey) => {
|
314 | const hint = options[hintKey]
|
315 | if (Array.isArray(hint)) {
|
316 | if (~hint.indexOf(optionKey)) hint.splice(hint.indexOf(optionKey), 1)
|
317 | } else if (typeof hint === 'object') {
|
318 | delete hint[optionKey]
|
319 | }
|
320 | })
|
321 |
|
322 | delete usage.getDescriptions()[optionKey]
|
323 | }
|
324 |
|
325 | self.config = function config (key, msg, parseFn) {
|
326 | argsert('[object|string] [string|function] [function]', [key, msg, parseFn], arguments.length)
|
327 |
|
328 | if (typeof key === 'object') {
|
329 | key = applyExtends(key, cwd)
|
330 | options.configObjects = (options.configObjects || []).concat(key)
|
331 | return self
|
332 | }
|
333 |
|
334 |
|
335 | if (typeof msg === 'function') {
|
336 | parseFn = msg
|
337 | msg = null
|
338 | }
|
339 |
|
340 | key = key || 'config'
|
341 | self.describe(key, msg || usage.deferY18nLookup('Path to JSON config file'))
|
342 | ;(Array.isArray(key) ? key : [key]).forEach((k) => {
|
343 | options.config[k] = parseFn || true
|
344 | })
|
345 |
|
346 | return self
|
347 | }
|
348 |
|
349 | self.example = function (cmd, description) {
|
350 | argsert('<string> [string]', [cmd, description], arguments.length)
|
351 | usage.example(cmd, description)
|
352 | return self
|
353 | }
|
354 |
|
355 | self.command = function (cmd, description, builder, handler, middlewares) {
|
356 | argsert('<string|array|object> [string|boolean] [function|object] [function] [array]', [cmd, description, builder, handler, middlewares], arguments.length)
|
357 | command.addHandler(cmd, description, builder, handler, middlewares)
|
358 | return self
|
359 | }
|
360 |
|
361 | self.commandDir = function (dir, opts) {
|
362 | argsert('<string> [object]', [dir, opts], arguments.length)
|
363 | const req = parentRequire || require
|
364 | command.addDirectory(dir, self.getContext(), req, require('get-caller-file')(), opts)
|
365 | return self
|
366 | }
|
367 |
|
368 |
|
369 |
|
370 | self.demand = self.required = self.require = function demand (keys, max, msg) {
|
371 |
|
372 |
|
373 |
|
374 | if (Array.isArray(max)) {
|
375 | max.forEach((key) => {
|
376 | self.demandOption(key, msg)
|
377 | })
|
378 | max = Infinity
|
379 | } else if (typeof max !== 'number') {
|
380 | msg = max
|
381 | max = Infinity
|
382 | }
|
383 |
|
384 | if (typeof keys === 'number') {
|
385 | self.demandCommand(keys, max, msg, msg)
|
386 | } else if (Array.isArray(keys)) {
|
387 | keys.forEach((key) => {
|
388 | self.demandOption(key, msg)
|
389 | })
|
390 | } else {
|
391 | if (typeof msg === 'string') {
|
392 | self.demandOption(keys, msg)
|
393 | } else if (msg === true || typeof msg === 'undefined') {
|
394 | self.demandOption(keys)
|
395 | }
|
396 | }
|
397 |
|
398 | return self
|
399 | }
|
400 |
|
401 | self.demandCommand = function demandCommand (min, max, minMsg, maxMsg) {
|
402 | argsert('[number] [number|string] [string|null|undefined] [string|null|undefined]', [min, max, minMsg, maxMsg], arguments.length)
|
403 |
|
404 | if (typeof min === 'undefined') min = 1
|
405 |
|
406 | if (typeof max !== 'number') {
|
407 | minMsg = max
|
408 | max = Infinity
|
409 | }
|
410 |
|
411 | self.global('_', false)
|
412 |
|
413 | options.demandedCommands._ = {
|
414 | min,
|
415 | max,
|
416 | minMsg,
|
417 | maxMsg
|
418 | }
|
419 |
|
420 | return self
|
421 | }
|
422 |
|
423 | self.getDemandedOptions = () => {
|
424 | argsert([], 0)
|
425 | return options.demandedOptions
|
426 | }
|
427 |
|
428 | self.getDemandedCommands = () => {
|
429 | argsert([], 0)
|
430 | return options.demandedCommands
|
431 | }
|
432 |
|
433 | self.implies = function (key, value) {
|
434 | argsert('<string|object> [number|string|array]', [key, value], arguments.length)
|
435 | validation.implies(key, value)
|
436 | return self
|
437 | }
|
438 |
|
439 | self.conflicts = function (key1, key2) {
|
440 | argsert('<string|object> [string|array]', [key1, key2], arguments.length)
|
441 | validation.conflicts(key1, key2)
|
442 | return self
|
443 | }
|
444 |
|
445 | self.usage = function (msg, description, builder, handler) {
|
446 | argsert('<string|null|undefined> [string|boolean] [function|object] [function]', [msg, description, builder, handler], arguments.length)
|
447 |
|
448 | if (description !== undefined) {
|
449 |
|
450 |
|
451 | if ((msg || '').match(/^\$0( |$)/)) {
|
452 | return self.command(msg, description, builder, handler)
|
453 | } else {
|
454 | throw new YError('.usage() description must start with $0 if being used as alias for .command()')
|
455 | }
|
456 | } else {
|
457 | usage.usage(msg)
|
458 | return self
|
459 | }
|
460 | }
|
461 |
|
462 | self.epilogue = self.epilog = function (msg) {
|
463 | argsert('<string>', [msg], arguments.length)
|
464 | usage.epilog(msg)
|
465 | return self
|
466 | }
|
467 |
|
468 | self.fail = function (f) {
|
469 | argsert('<function>', [f], arguments.length)
|
470 | usage.failFn(f)
|
471 | return self
|
472 | }
|
473 |
|
474 | self.check = function (f, _global) {
|
475 | argsert('<function> [boolean]', [f, _global], arguments.length)
|
476 | validation.check(f, _global !== false)
|
477 | return self
|
478 | }
|
479 |
|
480 | self.global = function global (globals, global) {
|
481 | argsert('<string|array> [boolean]', [globals, global], arguments.length)
|
482 | globals = [].concat(globals)
|
483 | if (global !== false) {
|
484 | options.local = options.local.filter(l => globals.indexOf(l) === -1)
|
485 | } else {
|
486 | globals.forEach((g) => {
|
487 | if (options.local.indexOf(g) === -1) options.local.push(g)
|
488 | })
|
489 | }
|
490 | return self
|
491 | }
|
492 |
|
493 | self.pkgConf = function pkgConf (key, rootPath) {
|
494 | argsert('<string> [string]', [key, rootPath], arguments.length)
|
495 | let conf = null
|
496 |
|
497 |
|
498 |
|
499 | const obj = pkgUp(rootPath || cwd)
|
500 |
|
501 |
|
502 | if (obj[key] && typeof obj[key] === 'object') {
|
503 | conf = applyExtends(obj[key], rootPath || cwd)
|
504 | options.configObjects = (options.configObjects || []).concat(conf)
|
505 | }
|
506 |
|
507 | return self
|
508 | }
|
509 |
|
510 | const pkgs = {}
|
511 | function pkgUp (rootPath) {
|
512 | const npath = rootPath || '*'
|
513 | if (pkgs[npath]) return pkgs[npath]
|
514 | const findUp = require('find-up')
|
515 |
|
516 | let obj = {}
|
517 | try {
|
518 | let startDir = rootPath || require('require-main-filename')(parentRequire || require)
|
519 |
|
520 |
|
521 |
|
522 |
|
523 | if (!rootPath && path.extname(startDir)) {
|
524 | startDir = path.dirname(startDir)
|
525 | }
|
526 |
|
527 | const pkgJsonPath = findUp.sync('package.json', {
|
528 | cwd: startDir
|
529 | })
|
530 | obj = JSON.parse(fs.readFileSync(pkgJsonPath))
|
531 | } catch (noop) {}
|
532 |
|
533 | pkgs[npath] = obj || {}
|
534 | return pkgs[npath]
|
535 | }
|
536 |
|
537 | let parseFn = null
|
538 | let parseContext = null
|
539 | self.parse = function parse (args, shortCircuit, _parseFn) {
|
540 | argsert('[string|array] [function|boolean|object] [function]', [args, shortCircuit, _parseFn], arguments.length)
|
541 | if (typeof args === 'undefined') {
|
542 | return self._parseArgs(processArgs)
|
543 | }
|
544 |
|
545 |
|
546 |
|
547 | if (typeof shortCircuit === 'object') {
|
548 | parseContext = shortCircuit
|
549 | shortCircuit = _parseFn
|
550 | }
|
551 |
|
552 |
|
553 |
|
554 |
|
555 | if (typeof shortCircuit === 'function') {
|
556 | parseFn = shortCircuit
|
557 | shortCircuit = null
|
558 | }
|
559 |
|
560 |
|
561 | if (!shortCircuit) processArgs = args
|
562 |
|
563 | freeze()
|
564 | if (parseFn) exitProcess = false
|
565 |
|
566 | const parsed = self._parseArgs(args, shortCircuit)
|
567 | if (parseFn) parseFn(exitError, parsed, output)
|
568 | unfreeze()
|
569 |
|
570 | return parsed
|
571 | }
|
572 |
|
573 | self._getParseContext = () => parseContext || {}
|
574 |
|
575 | self._hasParseCallback = () => !!parseFn
|
576 |
|
577 | self.option = self.options = function option (key, opt) {
|
578 | argsert('<string|object> [object]', [key, opt], arguments.length)
|
579 | if (typeof key === 'object') {
|
580 | Object.keys(key).forEach((k) => {
|
581 | self.options(k, key[k])
|
582 | })
|
583 | } else {
|
584 | if (typeof opt !== 'object') {
|
585 | opt = {}
|
586 | }
|
587 |
|
588 | options.key[key] = true
|
589 |
|
590 | if (opt.alias) self.alias(key, opt.alias)
|
591 |
|
592 | const demand = opt.demand || opt.required || opt.require
|
593 |
|
594 |
|
595 | if (demand) {
|
596 | self.demand(key, demand)
|
597 | }
|
598 |
|
599 | if (opt.demandOption) {
|
600 | self.demandOption(key, typeof opt.demandOption === 'string' ? opt.demandOption : undefined)
|
601 | }
|
602 |
|
603 | if ('conflicts' in opt) {
|
604 | self.conflicts(key, opt.conflicts)
|
605 | }
|
606 |
|
607 | if ('default' in opt) {
|
608 | self.default(key, opt.default)
|
609 | }
|
610 |
|
611 | if ('implies' in opt) {
|
612 | self.implies(key, opt.implies)
|
613 | }
|
614 |
|
615 | if ('nargs' in opt) {
|
616 | self.nargs(key, opt.nargs)
|
617 | }
|
618 |
|
619 | if (opt.config) {
|
620 | self.config(key, opt.configParser)
|
621 | }
|
622 |
|
623 | if (opt.normalize) {
|
624 | self.normalize(key)
|
625 | }
|
626 |
|
627 | if ('choices' in opt) {
|
628 | self.choices(key, opt.choices)
|
629 | }
|
630 |
|
631 | if ('coerce' in opt) {
|
632 | self.coerce(key, opt.coerce)
|
633 | }
|
634 |
|
635 | if ('group' in opt) {
|
636 | self.group(key, opt.group)
|
637 | }
|
638 |
|
639 | if (opt.boolean || opt.type === 'boolean') {
|
640 | self.boolean(key)
|
641 | if (opt.alias) self.boolean(opt.alias)
|
642 | }
|
643 |
|
644 | if (opt.array || opt.type === 'array') {
|
645 | self.array(key)
|
646 | if (opt.alias) self.array(opt.alias)
|
647 | }
|
648 |
|
649 | if (opt.number || opt.type === 'number') {
|
650 | self.number(key)
|
651 | if (opt.alias) self.number(opt.alias)
|
652 | }
|
653 |
|
654 | if (opt.string || opt.type === 'string') {
|
655 | self.string(key)
|
656 | if (opt.alias) self.string(opt.alias)
|
657 | }
|
658 |
|
659 | if (opt.count || opt.type === 'count') {
|
660 | self.count(key)
|
661 | }
|
662 |
|
663 | if (typeof opt.global === 'boolean') {
|
664 | self.global(key, opt.global)
|
665 | }
|
666 |
|
667 | if (opt.defaultDescription) {
|
668 | options.defaultDescription[key] = opt.defaultDescription
|
669 | }
|
670 |
|
671 | if (opt.skipValidation) {
|
672 | self.skipValidation(key)
|
673 | }
|
674 |
|
675 | const desc = opt.describe || opt.description || opt.desc
|
676 | self.describe(key, desc)
|
677 | if (opt.hidden) {
|
678 | self.hide(key)
|
679 | }
|
680 |
|
681 | if (opt.requiresArg) {
|
682 | self.requiresArg(key)
|
683 | }
|
684 | }
|
685 |
|
686 | return self
|
687 | }
|
688 | self.getOptions = () => options
|
689 |
|
690 | self.positional = function (key, opts) {
|
691 | argsert('<string> <object>', [key, opts], arguments.length)
|
692 | if (context.resets === 0) {
|
693 | throw new YError(".positional() can only be called in a command's builder function")
|
694 | }
|
695 |
|
696 |
|
697 |
|
698 | const supportedOpts = ['default', 'implies', 'normalize',
|
699 | 'choices', 'conflicts', 'coerce', 'type', 'describe',
|
700 | 'desc', 'description', 'alias']
|
701 | opts = objFilter(opts, (k, v) => {
|
702 | let accept = supportedOpts.indexOf(k) !== -1
|
703 |
|
704 | if (k === 'type' && ['string', 'number', 'boolean'].indexOf(v) === -1) accept = false
|
705 | return accept
|
706 | })
|
707 |
|
708 |
|
709 | const fullCommand = context.fullCommands[context.fullCommands.length - 1]
|
710 | const parseOptions = fullCommand ? command.cmdToParseOptions(fullCommand) : {
|
711 | array: [],
|
712 | alias: {},
|
713 | default: {},
|
714 | demand: {}
|
715 | }
|
716 | Object.keys(parseOptions).forEach((pk) => {
|
717 | if (Array.isArray(parseOptions[pk])) {
|
718 | if (parseOptions[pk].indexOf(key) !== -1) opts[pk] = true
|
719 | } else {
|
720 | if (parseOptions[pk][key] && !(pk in opts)) opts[pk] = parseOptions[pk][key]
|
721 | }
|
722 | })
|
723 | self.group(key, usage.getPositionalGroupName())
|
724 | return self.option(key, opts)
|
725 | }
|
726 |
|
727 | self.group = function group (opts, groupName) {
|
728 | argsert('<string|array> <string>', [opts, groupName], arguments.length)
|
729 | const existing = preservedGroups[groupName] || groups[groupName]
|
730 | if (preservedGroups[groupName]) {
|
731 |
|
732 | delete preservedGroups[groupName]
|
733 | }
|
734 |
|
735 | const seen = {}
|
736 | groups[groupName] = (existing || []).concat(opts).filter((key) => {
|
737 | if (seen[key]) return false
|
738 | return (seen[key] = true)
|
739 | })
|
740 | return self
|
741 | }
|
742 |
|
743 | self.getGroups = () => Object.assign({}, groups, preservedGroups)
|
744 |
|
745 |
|
746 |
|
747 | self.env = function (prefix) {
|
748 | argsert('[string|boolean]', [prefix], arguments.length)
|
749 | if (prefix === false) options.envPrefix = undefined
|
750 | else options.envPrefix = prefix || ''
|
751 | return self
|
752 | }
|
753 |
|
754 | self.wrap = function (cols) {
|
755 | argsert('<number|null|undefined>', [cols], arguments.length)
|
756 | usage.wrap(cols)
|
757 | return self
|
758 | }
|
759 |
|
760 | let strict = false
|
761 | self.strict = function (enabled) {
|
762 | argsert('[boolean]', [enabled], arguments.length)
|
763 | strict = enabled !== false
|
764 | return self
|
765 | }
|
766 | self.getStrict = () => strict
|
767 |
|
768 | let parserConfig = {}
|
769 | self.parserConfiguration = function parserConfiguration (config) {
|
770 | argsert('<object>', [config], arguments.length)
|
771 | parserConfig = config
|
772 | return self
|
773 | }
|
774 | self.getParserConfiguration = () => parserConfig
|
775 |
|
776 | self.showHelp = function (level) {
|
777 | argsert('[string|function]', [level], arguments.length)
|
778 | if (!self.parsed) self._parseArgs(processArgs)
|
779 | if (command.hasDefaultCommand()) {
|
780 | context.resets++
|
781 | command.runDefaultBuilderOn(self, true)
|
782 | }
|
783 | usage.showHelp(level)
|
784 | return self
|
785 | }
|
786 |
|
787 | let versionOpt = null
|
788 | self.version = function version (opt, msg, ver) {
|
789 | const defaultVersionOpt = 'version'
|
790 | argsert('[boolean|string] [string] [string]', [opt, msg, ver], arguments.length)
|
791 |
|
792 |
|
793 |
|
794 | if (versionOpt) {
|
795 | deleteFromParserHintObject(versionOpt)
|
796 | usage.version(undefined)
|
797 | versionOpt = null
|
798 | }
|
799 |
|
800 | if (arguments.length === 0) {
|
801 | ver = guessVersion()
|
802 | opt = defaultVersionOpt
|
803 | } else if (arguments.length === 1) {
|
804 | if (opt === false) {
|
805 | return self
|
806 | }
|
807 | ver = opt
|
808 | opt = defaultVersionOpt
|
809 | } else if (arguments.length === 2) {
|
810 | ver = msg
|
811 | msg = null
|
812 | }
|
813 |
|
814 | versionOpt = typeof opt === 'string' ? opt : defaultVersionOpt
|
815 | msg = msg || usage.deferY18nLookup('Show version number')
|
816 |
|
817 | usage.version(ver || undefined)
|
818 | self.boolean(versionOpt)
|
819 | self.describe(versionOpt, msg)
|
820 | return self
|
821 | }
|
822 |
|
823 | function guessVersion () {
|
824 | const obj = pkgUp()
|
825 |
|
826 | return obj.version || 'unknown'
|
827 | }
|
828 |
|
829 | let helpOpt = null
|
830 | self.addHelpOpt = self.help = function addHelpOpt (opt, msg) {
|
831 | const defaultHelpOpt = 'help'
|
832 | argsert('[string|boolean] [string]', [opt, msg], arguments.length)
|
833 |
|
834 |
|
835 |
|
836 | if (helpOpt) {
|
837 | deleteFromParserHintObject(helpOpt)
|
838 | helpOpt = null
|
839 | }
|
840 |
|
841 | if (arguments.length === 1) {
|
842 | if (opt === false) return self
|
843 | }
|
844 |
|
845 |
|
846 | helpOpt = typeof opt === 'string' ? opt : defaultHelpOpt
|
847 | self.boolean(helpOpt)
|
848 | self.describe(helpOpt, msg || usage.deferY18nLookup('Show help'))
|
849 | return self
|
850 | }
|
851 |
|
852 | const defaultShowHiddenOpt = 'show-hidden'
|
853 | options.showHiddenOpt = defaultShowHiddenOpt
|
854 | self.addShowHiddenOpt = self.showHidden = function addShowHiddenOpt (opt, msg) {
|
855 | argsert('[string|boolean] [string]', [opt, msg], arguments.length)
|
856 |
|
857 | if (arguments.length === 1) {
|
858 | if (opt === false) return self
|
859 | }
|
860 |
|
861 | const showHiddenOpt = typeof opt === 'string' ? opt : defaultShowHiddenOpt
|
862 | self.boolean(showHiddenOpt)
|
863 | self.describe(showHiddenOpt, msg || usage.deferY18nLookup('Show hidden options'))
|
864 | options.showHiddenOpt = showHiddenOpt
|
865 | return self
|
866 | }
|
867 |
|
868 | self.hide = function hide (key) {
|
869 | argsert('<string|object>', [key], arguments.length)
|
870 | options.hiddenOptions.push(key)
|
871 | return self
|
872 | }
|
873 |
|
874 | self.showHelpOnFail = function showHelpOnFail (enabled, message) {
|
875 | argsert('[boolean|string] [string]', [enabled, message], arguments.length)
|
876 | usage.showHelpOnFail(enabled, message)
|
877 | return self
|
878 | }
|
879 |
|
880 | var exitProcess = true
|
881 | self.exitProcess = function (enabled) {
|
882 | argsert('[boolean]', [enabled], arguments.length)
|
883 | if (typeof enabled !== 'boolean') {
|
884 | enabled = true
|
885 | }
|
886 | exitProcess = enabled
|
887 | return self
|
888 | }
|
889 | self.getExitProcess = () => exitProcess
|
890 |
|
891 | var completionCommand = null
|
892 | self.completion = function (cmd, desc, fn) {
|
893 | argsert('[string] [string|boolean|function] [function]', [cmd, desc, fn], arguments.length)
|
894 |
|
895 |
|
896 |
|
897 |
|
898 | if (typeof desc === 'function') {
|
899 | fn = desc
|
900 | desc = null
|
901 | }
|
902 |
|
903 |
|
904 | completionCommand = cmd || 'completion'
|
905 | if (!desc && desc !== false) {
|
906 | desc = 'generate completion script'
|
907 | }
|
908 | self.command(completionCommand, desc)
|
909 |
|
910 |
|
911 | if (fn) completion.registerFunction(fn)
|
912 |
|
913 | return self
|
914 | }
|
915 |
|
916 | self.showCompletionScript = function ($0) {
|
917 | argsert('[string]', [$0], arguments.length)
|
918 | $0 = $0 || self.$0
|
919 | _logger.log(completion.generateCompletionScript($0, completionCommand))
|
920 | return self
|
921 | }
|
922 |
|
923 | self.getCompletion = function (args, done) {
|
924 | argsert('<array> <function>', [args, done], arguments.length)
|
925 | completion.getCompletion(args, done)
|
926 | }
|
927 |
|
928 | self.locale = function (locale) {
|
929 | argsert('[string]', [locale], arguments.length)
|
930 | if (arguments.length === 0) {
|
931 | guessLocale()
|
932 | return y18n.getLocale()
|
933 | }
|
934 | detectLocale = false
|
935 | y18n.setLocale(locale)
|
936 | return self
|
937 | }
|
938 |
|
939 | self.updateStrings = self.updateLocale = function (obj) {
|
940 | argsert('<object>', [obj], arguments.length)
|
941 | detectLocale = false
|
942 | y18n.updateLocale(obj)
|
943 | return self
|
944 | }
|
945 |
|
946 | let detectLocale = true
|
947 | self.detectLocale = function (detect) {
|
948 | argsert('<boolean>', [detect], arguments.length)
|
949 | detectLocale = detect
|
950 | return self
|
951 | }
|
952 | self.getDetectLocale = () => detectLocale
|
953 |
|
954 | var hasOutput = false
|
955 | var exitError = null
|
956 |
|
957 |
|
958 | self.exit = (code, err) => {
|
959 | hasOutput = true
|
960 | exitError = err
|
961 | if (exitProcess) process.exit(code)
|
962 | }
|
963 |
|
964 |
|
965 |
|
966 | const _logger = {
|
967 | log () {
|
968 | const args = []
|
969 | for (let i = 0; i < arguments.length; i++) args.push(arguments[i])
|
970 | if (!self._hasParseCallback()) console.log.apply(console, args)
|
971 | hasOutput = true
|
972 | if (output.length) output += '\n'
|
973 | output += args.join(' ')
|
974 | },
|
975 | error () {
|
976 | const args = []
|
977 | for (let i = 0; i < arguments.length; i++) args.push(arguments[i])
|
978 | if (!self._hasParseCallback()) console.error.apply(console, args)
|
979 | hasOutput = true
|
980 | if (output.length) output += '\n'
|
981 | output += args.join(' ')
|
982 | }
|
983 | }
|
984 | self._getLoggerInstance = () => _logger
|
985 |
|
986 |
|
987 | self._hasOutput = () => hasOutput
|
988 |
|
989 | self._setHasOutput = () => {
|
990 | hasOutput = true
|
991 | }
|
992 |
|
993 | let recommendCommands
|
994 | self.recommendCommands = function (recommend) {
|
995 | argsert('[boolean]', [recommend], arguments.length)
|
996 | recommendCommands = typeof recommend === 'boolean' ? recommend : true
|
997 | return self
|
998 | }
|
999 |
|
1000 | self.getUsageInstance = () => usage
|
1001 |
|
1002 | self.getValidationInstance = () => validation
|
1003 |
|
1004 | self.getCommandInstance = () => command
|
1005 |
|
1006 | self.terminalWidth = () => {
|
1007 | argsert([], 0)
|
1008 | return typeof process.stdout.columns !== 'undefined' ? process.stdout.columns : null
|
1009 | }
|
1010 |
|
1011 | Object.defineProperty(self, 'argv', {
|
1012 | get: () => self._parseArgs(processArgs),
|
1013 | enumerable: true
|
1014 | })
|
1015 |
|
1016 | self._parseArgs = function parseArgs (args, shortCircuit, _skipValidation, commandIndex) {
|
1017 | let skipValidation = !!_skipValidation
|
1018 | args = args || processArgs
|
1019 |
|
1020 | options.__ = y18n.__
|
1021 | options.configuration = self.getParserConfiguration()
|
1022 |
|
1023 |
|
1024 | let pkgConfig = pkgUp()['yargs']
|
1025 | if (pkgConfig) {
|
1026 | console.warn('Configuring yargs through package.json is deprecated and will be removed in the next major release, please use the JS API instead.')
|
1027 | options.configuration = Object.assign({}, pkgConfig, options.configuration)
|
1028 | }
|
1029 |
|
1030 | const parsed = Parser.detailed(args, options)
|
1031 | let argv = parsed.argv
|
1032 | if (parseContext) argv = Object.assign({}, argv, parseContext)
|
1033 | const aliases = parsed.aliases
|
1034 |
|
1035 | argv.$0 = self.$0
|
1036 | self.parsed = parsed
|
1037 |
|
1038 | try {
|
1039 | guessLocale()
|
1040 |
|
1041 |
|
1042 |
|
1043 |
|
1044 | if (shortCircuit) {
|
1045 | return argv
|
1046 | }
|
1047 |
|
1048 |
|
1049 |
|
1050 | if (helpOpt) {
|
1051 |
|
1052 |
|
1053 |
|
1054 | const helpCmds = [helpOpt]
|
1055 | .concat(aliases[helpOpt] || [])
|
1056 | .filter(k => k.length > 1)
|
1057 |
|
1058 | if (~helpCmds.indexOf(argv._[argv._.length - 1])) {
|
1059 | argv._.pop()
|
1060 | argv[helpOpt] = true
|
1061 | }
|
1062 | }
|
1063 |
|
1064 | const handlerKeys = command.getCommands()
|
1065 | const requestCompletions = completion.completionKey in argv
|
1066 | const skipRecommendation = argv[helpOpt] || requestCompletions
|
1067 | const skipDefaultCommand = skipRecommendation && (handlerKeys.length > 1 || handlerKeys[0] !== '$0')
|
1068 |
|
1069 | if (argv._.length) {
|
1070 | if (handlerKeys.length) {
|
1071 | let firstUnknownCommand
|
1072 | for (let i = (commandIndex || 0), cmd; argv._[i] !== undefined; i++) {
|
1073 | cmd = String(argv._[i])
|
1074 | if (~handlerKeys.indexOf(cmd) && cmd !== completionCommand) {
|
1075 |
|
1076 |
|
1077 |
|
1078 | return command.runCommand(cmd, self, parsed, i + 1)
|
1079 | } else if (!firstUnknownCommand && cmd !== completionCommand) {
|
1080 | firstUnknownCommand = cmd
|
1081 | break
|
1082 | }
|
1083 | }
|
1084 |
|
1085 |
|
1086 | if (command.hasDefaultCommand() && !skipDefaultCommand) {
|
1087 | return command.runCommand(null, self, parsed)
|
1088 | }
|
1089 |
|
1090 |
|
1091 |
|
1092 | if (recommendCommands && firstUnknownCommand && !skipRecommendation) {
|
1093 | validation.recommendCommands(firstUnknownCommand, handlerKeys)
|
1094 | }
|
1095 | }
|
1096 |
|
1097 |
|
1098 | if (completionCommand && ~argv._.indexOf(completionCommand) && !requestCompletions) {
|
1099 | if (exitProcess) setBlocking(true)
|
1100 | self.showCompletionScript()
|
1101 | self.exit(0)
|
1102 | }
|
1103 | } else if (command.hasDefaultCommand() && !skipDefaultCommand) {
|
1104 | return command.runCommand(null, self, parsed)
|
1105 | }
|
1106 |
|
1107 |
|
1108 |
|
1109 | if (requestCompletions) {
|
1110 | if (exitProcess) setBlocking(true)
|
1111 |
|
1112 |
|
1113 |
|
1114 | const completionArgs = args.slice(args.indexOf(`--${completion.completionKey}`) + 1)
|
1115 | completion.getCompletion(completionArgs, (completions) => {
|
1116 | ;(completions || []).forEach((completion) => {
|
1117 | _logger.log(completion)
|
1118 | })
|
1119 |
|
1120 | self.exit(0)
|
1121 | })
|
1122 | return argv
|
1123 | }
|
1124 |
|
1125 |
|
1126 |
|
1127 | if (!hasOutput) {
|
1128 | Object.keys(argv).forEach((key) => {
|
1129 | if (key === helpOpt && argv[key]) {
|
1130 | if (exitProcess) setBlocking(true)
|
1131 |
|
1132 | skipValidation = true
|
1133 | self.showHelp('log')
|
1134 | self.exit(0)
|
1135 | } else if (key === versionOpt && argv[key]) {
|
1136 | if (exitProcess) setBlocking(true)
|
1137 |
|
1138 | skipValidation = true
|
1139 | usage.showVersion()
|
1140 | self.exit(0)
|
1141 | }
|
1142 | })
|
1143 | }
|
1144 |
|
1145 |
|
1146 | if (!skipValidation && options.skipValidation.length > 0) {
|
1147 | skipValidation = Object.keys(argv).some(key => options.skipValidation.indexOf(key) >= 0 && argv[key] === true)
|
1148 | }
|
1149 |
|
1150 |
|
1151 |
|
1152 | if (!skipValidation) {
|
1153 | if (parsed.error) throw new YError(parsed.error.message)
|
1154 |
|
1155 |
|
1156 |
|
1157 | if (!requestCompletions) {
|
1158 | self._runValidation(argv, aliases, {}, parsed.error)
|
1159 | }
|
1160 | }
|
1161 | } catch (err) {
|
1162 | if (err instanceof YError) usage.fail(err.message, err)
|
1163 | else throw err
|
1164 | }
|
1165 |
|
1166 | return argv
|
1167 | }
|
1168 |
|
1169 | self._runValidation = function runValidation (argv, aliases, positionalMap, parseErrors) {
|
1170 | if (parseErrors) throw new YError(parseErrors.message || parseErrors)
|
1171 | validation.nonOptionCount(argv)
|
1172 | validation.requiredArguments(argv)
|
1173 | if (strict) validation.unknownArguments(argv, aliases, positionalMap)
|
1174 | validation.customChecks(argv, aliases)
|
1175 | validation.limitedChoices(argv)
|
1176 | validation.implications(argv)
|
1177 | validation.conflicting(argv)
|
1178 | }
|
1179 |
|
1180 | function guessLocale () {
|
1181 | if (!detectLocale) return
|
1182 |
|
1183 | try {
|
1184 | const osLocale = require('os-locale')
|
1185 | self.locale(osLocale.sync({ spawn: false }))
|
1186 | } catch (err) {
|
1187 |
|
1188 |
|
1189 | }
|
1190 | }
|
1191 |
|
1192 |
|
1193 |
|
1194 | self.help()
|
1195 | self.version()
|
1196 |
|
1197 | return self
|
1198 | }
|
1199 |
|
1200 |
|
1201 |
|
1202 | exports.rebase = rebase
|
1203 | function rebase (base, dir) {
|
1204 | return path.relative(base, dir)
|
1205 | }
|