164 lines
3.8 KiB
JavaScript
164 lines
3.8 KiB
JavaScript
'use strict'
|
|
|
|
/**
|
|
* Some useful tools for working with `process.argv`.
|
|
*
|
|
* @module argv-tools
|
|
* @typicalName argvTools
|
|
* @example
|
|
* const argvTools = require('argv-tools')
|
|
*/
|
|
|
|
/**
|
|
* Regular expressions for matching option formats.
|
|
* @static
|
|
*/
|
|
const re = {
|
|
short: /^-([^\d-])$/,
|
|
long: /^--(\S+)/,
|
|
combinedShort: /^-[^\d-]{2,}$/,
|
|
optEquals: /^(--\S+?)=(.*)/
|
|
}
|
|
|
|
/**
|
|
* Array subclass encapsulating common operations on `process.argv`.
|
|
* @static
|
|
*/
|
|
class ArgvArray extends Array {
|
|
/**
|
|
* Clears the array has loads the supplied input.
|
|
* @param {string[]} argv - The argv list to load. Defaults to `process.argv`.
|
|
*/
|
|
load (argv) {
|
|
const arrayify = require('array-back')
|
|
this.clear()
|
|
if (argv && argv !== process.argv) {
|
|
argv = arrayify(argv)
|
|
} else {
|
|
/* if no argv supplied, assume we are parsing process.argv */
|
|
argv = process.argv.slice(0)
|
|
argv.splice(0, 2)
|
|
}
|
|
argv.forEach(arg => this.push(String(arg)))
|
|
}
|
|
|
|
/**
|
|
* Clear the array.
|
|
*/
|
|
clear () {
|
|
this.length = 0
|
|
}
|
|
|
|
/**
|
|
* expand ``--option=value` style args.
|
|
*/
|
|
expandOptionEqualsNotation () {
|
|
if (this.some(arg => re.optEquals.test(arg))) {
|
|
const expandedArgs = []
|
|
this.forEach(arg => {
|
|
const matches = arg.match(re.optEquals)
|
|
if (matches) {
|
|
expandedArgs.push(matches[1], matches[2])
|
|
} else {
|
|
expandedArgs.push(arg)
|
|
}
|
|
})
|
|
this.clear()
|
|
this.load(expandedArgs)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* expand getopt-style combinedShort options.
|
|
*/
|
|
expandGetoptNotation () {
|
|
if (this.hasCombinedShortOptions()) {
|
|
const findReplace = require('find-replace')
|
|
findReplace(this, re.combinedShort, expandCombinedShortArg)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the array contains combined short options (e.g. `-ab`).
|
|
* @returns {boolean}
|
|
*/
|
|
hasCombinedShortOptions () {
|
|
return this.some(arg => re.combinedShort.test(arg))
|
|
}
|
|
|
|
static from (argv) {
|
|
const result = new this()
|
|
result.load(argv)
|
|
return result
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Expand a combined short option.
|
|
* @param {string} - the string to expand, e.g. `-ab`
|
|
* @returns {string[]}
|
|
* @static
|
|
*/
|
|
function expandCombinedShortArg (arg) {
|
|
/* remove initial hypen */
|
|
arg = arg.slice(1)
|
|
return arg.split('').map(letter => '-' + letter)
|
|
}
|
|
|
|
/**
|
|
* Returns true if the supplied arg matches `--option=value` notation.
|
|
* @param {string} - the arg to test, e.g. `--one=something`
|
|
* @returns {boolean}
|
|
* @static
|
|
*/
|
|
function isOptionEqualsNotation (arg) {
|
|
return re.optEquals.test(arg)
|
|
}
|
|
|
|
/**
|
|
* Returns true if the supplied arg is in either long (`--one`) or short (`-o`) format.
|
|
* @param {string} - the arg to test, e.g. `--one`
|
|
* @returns {boolean}
|
|
* @static
|
|
*/
|
|
function isOption (arg) {
|
|
return (re.short.test(arg) || re.long.test(arg)) && !re.optEquals.test(arg)
|
|
}
|
|
|
|
/**
|
|
* Returns true if the supplied arg is in long (`--one`) format.
|
|
* @param {string} - the arg to test, e.g. `--one`
|
|
* @returns {boolean}
|
|
* @static
|
|
*/
|
|
function isLongOption (arg) {
|
|
return re.long.test(arg) && !isOptionEqualsNotation(arg)
|
|
}
|
|
|
|
/**
|
|
* Returns the name from a long, short or `--options=value` arg.
|
|
* @param {string} - the arg to inspect, e.g. `--one`
|
|
* @returns {string}
|
|
* @static
|
|
*/
|
|
function getOptionName (arg) {
|
|
if (re.short.test(arg)) {
|
|
return arg.match(re.short)[1]
|
|
} else if (isLongOption(arg)) {
|
|
return arg.match(re.long)[1]
|
|
} else if (isOptionEqualsNotation(arg)) {
|
|
return arg.match(re.optEquals)[1].replace(/^--/, '')
|
|
} else {
|
|
return null
|
|
}
|
|
}
|
|
|
|
exports.expandCombinedShortArg = expandCombinedShortArg
|
|
exports.re = re
|
|
exports.ArgvArray = ArgvArray
|
|
exports.getOptionName = getOptionName
|
|
exports.isOption = isOption
|
|
exports.isLongOption = isLongOption
|
|
exports.isOptionEqualsNotation = isOptionEqualsNotation
|
|
exports.isValue = arg => !(isOption(arg) || re.combinedShort.test(arg) || re.optEquals.test(arg))
|