1161 lines
34 KiB
JavaScript
1161 lines
34 KiB
JavaScript
/**
|
|
* class ArgumentParser
|
|
*
|
|
* Object for parsing command line strings into js objects.
|
|
*
|
|
* Inherited from [[ActionContainer]]
|
|
**/
|
|
'use strict';
|
|
|
|
var util = require('util');
|
|
var format = require('util').format;
|
|
var Path = require('path');
|
|
var sprintf = require('sprintf-js').sprintf;
|
|
|
|
// Constants
|
|
var c = require('./const');
|
|
|
|
var $$ = require('./utils');
|
|
|
|
var ActionContainer = require('./action_container');
|
|
|
|
// Errors
|
|
var argumentErrorHelper = require('./argument/error');
|
|
|
|
var HelpFormatter = require('./help/formatter');
|
|
|
|
var Namespace = require('./namespace');
|
|
|
|
|
|
/**
|
|
* new ArgumentParser(options)
|
|
*
|
|
* Create a new ArgumentParser object.
|
|
*
|
|
* ##### Options:
|
|
* - `prog` The name of the program (default: Path.basename(process.argv[1]))
|
|
* - `usage` A usage message (default: auto-generated from arguments)
|
|
* - `description` A description of what the program does
|
|
* - `epilog` Text following the argument descriptions
|
|
* - `parents` Parsers whose arguments should be copied into this one
|
|
* - `formatterClass` HelpFormatter class for printing help messages
|
|
* - `prefixChars` Characters that prefix optional arguments
|
|
* - `fromfilePrefixChars` Characters that prefix files containing additional arguments
|
|
* - `argumentDefault` The default value for all arguments
|
|
* - `addHelp` Add a -h/-help option
|
|
* - `conflictHandler` Specifies how to handle conflicting argument names
|
|
* - `debug` Enable debug mode. Argument errors throw exception in
|
|
* debug mode and process.exit in normal. Used for development and
|
|
* testing (default: false)
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#argumentparser-objects
|
|
**/
|
|
function ArgumentParser(options) {
|
|
if (!(this instanceof ArgumentParser)) {
|
|
return new ArgumentParser(options);
|
|
}
|
|
var self = this;
|
|
options = options || {};
|
|
|
|
options.description = (options.description || null);
|
|
options.argumentDefault = (options.argumentDefault || null);
|
|
options.prefixChars = (options.prefixChars || '-');
|
|
options.conflictHandler = (options.conflictHandler || 'error');
|
|
ActionContainer.call(this, options);
|
|
|
|
options.addHelp = typeof options.addHelp === 'undefined' || !!options.addHelp;
|
|
options.parents = options.parents || [];
|
|
// default program name
|
|
options.prog = (options.prog || Path.basename(process.argv[1]));
|
|
this.prog = options.prog;
|
|
this.usage = options.usage;
|
|
this.epilog = options.epilog;
|
|
this.version = options.version;
|
|
|
|
this.debug = (options.debug === true);
|
|
|
|
this.formatterClass = (options.formatterClass || HelpFormatter);
|
|
this.fromfilePrefixChars = options.fromfilePrefixChars || null;
|
|
this._positionals = this.addArgumentGroup({ title: 'Positional arguments' });
|
|
this._optionals = this.addArgumentGroup({ title: 'Optional arguments' });
|
|
this._subparsers = null;
|
|
|
|
// register types
|
|
function FUNCTION_IDENTITY(o) {
|
|
return o;
|
|
}
|
|
this.register('type', 'auto', FUNCTION_IDENTITY);
|
|
this.register('type', null, FUNCTION_IDENTITY);
|
|
this.register('type', 'int', function (x) {
|
|
var result = parseInt(x, 10);
|
|
if (isNaN(result)) {
|
|
throw new Error(x + ' is not a valid integer.');
|
|
}
|
|
return result;
|
|
});
|
|
this.register('type', 'float', function (x) {
|
|
var result = parseFloat(x);
|
|
if (isNaN(result)) {
|
|
throw new Error(x + ' is not a valid float.');
|
|
}
|
|
return result;
|
|
});
|
|
this.register('type', 'string', function (x) {
|
|
return '' + x;
|
|
});
|
|
|
|
// add help and version arguments if necessary
|
|
var defaultPrefix = (this.prefixChars.indexOf('-') > -1) ? '-' : this.prefixChars[0];
|
|
if (options.addHelp) {
|
|
this.addArgument(
|
|
[ defaultPrefix + 'h', defaultPrefix + defaultPrefix + 'help' ],
|
|
{
|
|
action: 'help',
|
|
defaultValue: c.SUPPRESS,
|
|
help: 'Show this help message and exit.'
|
|
}
|
|
);
|
|
}
|
|
if (typeof this.version !== 'undefined') {
|
|
this.addArgument(
|
|
[ defaultPrefix + 'v', defaultPrefix + defaultPrefix + 'version' ],
|
|
{
|
|
action: 'version',
|
|
version: this.version,
|
|
defaultValue: c.SUPPRESS,
|
|
help: "Show program's version number and exit."
|
|
}
|
|
);
|
|
}
|
|
|
|
// add parent arguments and defaults
|
|
options.parents.forEach(function (parent) {
|
|
self._addContainerActions(parent);
|
|
if (typeof parent._defaults !== 'undefined') {
|
|
for (var defaultKey in parent._defaults) {
|
|
if (parent._defaults.hasOwnProperty(defaultKey)) {
|
|
self._defaults[defaultKey] = parent._defaults[defaultKey];
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
util.inherits(ArgumentParser, ActionContainer);
|
|
|
|
/**
|
|
* ArgumentParser#addSubparsers(options) -> [[ActionSubparsers]]
|
|
* - options (object): hash of options see [[ActionSubparsers.new]]
|
|
*
|
|
* See also [subcommands][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#sub-commands
|
|
**/
|
|
ArgumentParser.prototype.addSubparsers = function (options) {
|
|
if (this._subparsers) {
|
|
this.error('Cannot have multiple subparser arguments.');
|
|
}
|
|
|
|
options = options || {};
|
|
options.debug = (this.debug === true);
|
|
options.optionStrings = [];
|
|
options.parserClass = (options.parserClass || ArgumentParser);
|
|
|
|
|
|
if (!!options.title || !!options.description) {
|
|
|
|
this._subparsers = this.addArgumentGroup({
|
|
title: (options.title || 'subcommands'),
|
|
description: options.description
|
|
});
|
|
delete options.title;
|
|
delete options.description;
|
|
|
|
} else {
|
|
this._subparsers = this._positionals;
|
|
}
|
|
|
|
// prog defaults to the usage message of this parser, skipping
|
|
// optional arguments and with no "usage:" prefix
|
|
if (!options.prog) {
|
|
var formatter = this._getFormatter();
|
|
var positionals = this._getPositionalActions();
|
|
var groups = this._mutuallyExclusiveGroups;
|
|
formatter.addUsage(this.usage, positionals, groups, '');
|
|
options.prog = formatter.formatHelp().trim();
|
|
}
|
|
|
|
// create the parsers action and add it to the positionals list
|
|
var ParsersClass = this._popActionClass(options, 'parsers');
|
|
var action = new ParsersClass(options);
|
|
this._subparsers._addAction(action);
|
|
|
|
// return the created parsers action
|
|
return action;
|
|
};
|
|
|
|
ArgumentParser.prototype._addAction = function (action) {
|
|
if (action.isOptional()) {
|
|
this._optionals._addAction(action);
|
|
} else {
|
|
this._positionals._addAction(action);
|
|
}
|
|
return action;
|
|
};
|
|
|
|
ArgumentParser.prototype._getOptionalActions = function () {
|
|
return this._actions.filter(function (action) {
|
|
return action.isOptional();
|
|
});
|
|
};
|
|
|
|
ArgumentParser.prototype._getPositionalActions = function () {
|
|
return this._actions.filter(function (action) {
|
|
return action.isPositional();
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* ArgumentParser#parseArgs(args, namespace) -> Namespace|Object
|
|
* - args (array): input elements
|
|
* - namespace (Namespace|Object): result object
|
|
*
|
|
* Parsed args and throws error if some arguments are not recognized
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#the-parse-args-method
|
|
**/
|
|
ArgumentParser.prototype.parseArgs = function (args, namespace) {
|
|
var argv;
|
|
var result = this.parseKnownArgs(args, namespace);
|
|
|
|
args = result[0];
|
|
argv = result[1];
|
|
if (argv && argv.length > 0) {
|
|
this.error(
|
|
format('Unrecognized arguments: %s.', argv.join(' '))
|
|
);
|
|
}
|
|
return args;
|
|
};
|
|
|
|
/**
|
|
* ArgumentParser#parseKnownArgs(args, namespace) -> array
|
|
* - args (array): input options
|
|
* - namespace (Namespace|Object): result object
|
|
*
|
|
* Parse known arguments and return tuple of result object
|
|
* and unknown args
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#partial-parsing
|
|
**/
|
|
ArgumentParser.prototype.parseKnownArgs = function (args, namespace) {
|
|
var self = this;
|
|
|
|
// args default to the system args
|
|
args = args || process.argv.slice(2);
|
|
|
|
// default Namespace built from parser defaults
|
|
namespace = namespace || new Namespace();
|
|
|
|
self._actions.forEach(function (action) {
|
|
if (action.dest !== c.SUPPRESS) {
|
|
if (!$$.has(namespace, action.dest)) {
|
|
if (action.defaultValue !== c.SUPPRESS) {
|
|
var defaultValue = action.defaultValue;
|
|
if (typeof action.defaultValue === 'string') {
|
|
defaultValue = self._getValue(action, defaultValue);
|
|
}
|
|
namespace[action.dest] = defaultValue;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
Object.keys(self._defaults).forEach(function (dest) {
|
|
namespace[dest] = self._defaults[dest];
|
|
});
|
|
|
|
// parse the arguments and exit if there are any errors
|
|
try {
|
|
var res = this._parseKnownArgs(args, namespace);
|
|
|
|
namespace = res[0];
|
|
args = res[1];
|
|
if ($$.has(namespace, c._UNRECOGNIZED_ARGS_ATTR)) {
|
|
args = $$.arrayUnion(args, namespace[c._UNRECOGNIZED_ARGS_ATTR]);
|
|
delete namespace[c._UNRECOGNIZED_ARGS_ATTR];
|
|
}
|
|
return [ namespace, args ];
|
|
} catch (e) {
|
|
this.error(e);
|
|
}
|
|
};
|
|
|
|
ArgumentParser.prototype._parseKnownArgs = function (argStrings, namespace) {
|
|
var self = this;
|
|
|
|
var extras = [];
|
|
|
|
// replace arg strings that are file references
|
|
if (this.fromfilePrefixChars !== null) {
|
|
argStrings = this._readArgsFromFiles(argStrings);
|
|
}
|
|
// map all mutually exclusive arguments to the other arguments
|
|
// they can't occur with
|
|
// Python has 'conflicts = action_conflicts.setdefault(mutex_action, [])'
|
|
// though I can't conceive of a way in which an action could be a member
|
|
// of two different mutually exclusive groups.
|
|
|
|
function actionHash(action) {
|
|
// some sort of hashable key for this action
|
|
// action itself cannot be a key in actionConflicts
|
|
// I think getName() (join of optionStrings) is unique enough
|
|
return action.getName();
|
|
}
|
|
|
|
var conflicts, key;
|
|
var actionConflicts = {};
|
|
|
|
this._mutuallyExclusiveGroups.forEach(function (mutexGroup) {
|
|
mutexGroup._groupActions.forEach(function (mutexAction, i, groupActions) {
|
|
key = actionHash(mutexAction);
|
|
if (!$$.has(actionConflicts, key)) {
|
|
actionConflicts[key] = [];
|
|
}
|
|
conflicts = actionConflicts[key];
|
|
conflicts.push.apply(conflicts, groupActions.slice(0, i));
|
|
conflicts.push.apply(conflicts, groupActions.slice(i + 1));
|
|
});
|
|
});
|
|
|
|
// find all option indices, and determine the arg_string_pattern
|
|
// which has an 'O' if there is an option at an index,
|
|
// an 'A' if there is an argument, or a '-' if there is a '--'
|
|
var optionStringIndices = {};
|
|
|
|
var argStringPatternParts = [];
|
|
|
|
argStrings.forEach(function (argString, argStringIndex) {
|
|
if (argString === '--') {
|
|
argStringPatternParts.push('-');
|
|
while (argStringIndex < argStrings.length) {
|
|
argStringPatternParts.push('A');
|
|
argStringIndex++;
|
|
}
|
|
} else {
|
|
// otherwise, add the arg to the arg strings
|
|
// and note the index if it was an option
|
|
var pattern;
|
|
var optionTuple = self._parseOptional(argString);
|
|
if (!optionTuple) {
|
|
pattern = 'A';
|
|
} else {
|
|
optionStringIndices[argStringIndex] = optionTuple;
|
|
pattern = 'O';
|
|
}
|
|
argStringPatternParts.push(pattern);
|
|
}
|
|
});
|
|
var argStringsPattern = argStringPatternParts.join('');
|
|
|
|
var seenActions = [];
|
|
var seenNonDefaultActions = [];
|
|
|
|
|
|
function takeAction(action, argumentStrings, optionString) {
|
|
seenActions.push(action);
|
|
var argumentValues = self._getValues(action, argumentStrings);
|
|
|
|
// error if this argument is not allowed with other previously
|
|
// seen arguments, assuming that actions that use the default
|
|
// value don't really count as "present"
|
|
if (argumentValues !== action.defaultValue) {
|
|
seenNonDefaultActions.push(action);
|
|
if (actionConflicts[actionHash(action)]) {
|
|
actionConflicts[actionHash(action)].forEach(function (actionConflict) {
|
|
if (seenNonDefaultActions.indexOf(actionConflict) >= 0) {
|
|
throw argumentErrorHelper(
|
|
action,
|
|
format('Not allowed with argument "%s".', actionConflict.getName())
|
|
);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
if (argumentValues !== c.SUPPRESS) {
|
|
action.call(self, namespace, argumentValues, optionString);
|
|
}
|
|
}
|
|
|
|
function consumeOptional(startIndex) {
|
|
// get the optional identified at this index
|
|
var optionTuple = optionStringIndices[startIndex];
|
|
var action = optionTuple[0];
|
|
var optionString = optionTuple[1];
|
|
var explicitArg = optionTuple[2];
|
|
|
|
// identify additional optionals in the same arg string
|
|
// (e.g. -xyz is the same as -x -y -z if no args are required)
|
|
var actionTuples = [];
|
|
|
|
var args, argCount, start, stop;
|
|
|
|
for (;;) {
|
|
if (!action) {
|
|
extras.push(argStrings[startIndex]);
|
|
return startIndex + 1;
|
|
}
|
|
if (explicitArg) {
|
|
argCount = self._matchArgument(action, 'A');
|
|
|
|
// if the action is a single-dash option and takes no
|
|
// arguments, try to parse more single-dash options out
|
|
// of the tail of the option string
|
|
var chars = self.prefixChars;
|
|
if (argCount === 0 && chars.indexOf(optionString[1]) < 0) {
|
|
actionTuples.push([ action, [], optionString ]);
|
|
optionString = optionString[0] + explicitArg[0];
|
|
var newExplicitArg = explicitArg.slice(1) || null;
|
|
var optionalsMap = self._optionStringActions;
|
|
|
|
if (Object.keys(optionalsMap).indexOf(optionString) >= 0) {
|
|
action = optionalsMap[optionString];
|
|
explicitArg = newExplicitArg;
|
|
} else {
|
|
throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg));
|
|
}
|
|
} else if (argCount === 1) {
|
|
// if the action expect exactly one argument, we've
|
|
// successfully matched the option; exit the loop
|
|
stop = startIndex + 1;
|
|
args = [ explicitArg ];
|
|
actionTuples.push([ action, args, optionString ]);
|
|
break;
|
|
} else {
|
|
// error if a double-dash option did not use the
|
|
// explicit argument
|
|
throw argumentErrorHelper(action, sprintf('ignored explicit argument %r', explicitArg));
|
|
}
|
|
} else {
|
|
// if there is no explicit argument, try to match the
|
|
// optional's string arguments with the following strings
|
|
// if successful, exit the loop
|
|
|
|
start = startIndex + 1;
|
|
var selectedPatterns = argStringsPattern.substr(start);
|
|
|
|
argCount = self._matchArgument(action, selectedPatterns);
|
|
stop = start + argCount;
|
|
|
|
|
|
args = argStrings.slice(start, stop);
|
|
|
|
actionTuples.push([ action, args, optionString ]);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
// add the Optional to the list and return the index at which
|
|
// the Optional's string args stopped
|
|
if (actionTuples.length < 1) {
|
|
throw new Error('length should be > 0');
|
|
}
|
|
for (var i = 0; i < actionTuples.length; i++) {
|
|
takeAction.apply(self, actionTuples[i]);
|
|
}
|
|
return stop;
|
|
}
|
|
|
|
// the list of Positionals left to be parsed; this is modified
|
|
// by consume_positionals()
|
|
var positionals = self._getPositionalActions();
|
|
|
|
function consumePositionals(startIndex) {
|
|
// match as many Positionals as possible
|
|
var selectedPattern = argStringsPattern.substr(startIndex);
|
|
var argCounts = self._matchArgumentsPartial(positionals, selectedPattern);
|
|
|
|
// slice off the appropriate arg strings for each Positional
|
|
// and add the Positional and its args to the list
|
|
for (var i = 0; i < positionals.length; i++) {
|
|
var action = positionals[i];
|
|
var argCount = argCounts[i];
|
|
if (typeof argCount === 'undefined') {
|
|
continue;
|
|
}
|
|
var args = argStrings.slice(startIndex, startIndex + argCount);
|
|
|
|
startIndex += argCount;
|
|
takeAction(action, args);
|
|
}
|
|
|
|
// slice off the Positionals that we just parsed and return the
|
|
// index at which the Positionals' string args stopped
|
|
positionals = positionals.slice(argCounts.length);
|
|
return startIndex;
|
|
}
|
|
|
|
// consume Positionals and Optionals alternately, until we have
|
|
// passed the last option string
|
|
var startIndex = 0;
|
|
var position;
|
|
|
|
var maxOptionStringIndex = -1;
|
|
|
|
Object.keys(optionStringIndices).forEach(function (position) {
|
|
maxOptionStringIndex = Math.max(maxOptionStringIndex, parseInt(position, 10));
|
|
});
|
|
|
|
var positionalsEndIndex, nextOptionStringIndex;
|
|
|
|
while (startIndex <= maxOptionStringIndex) {
|
|
// consume any Positionals preceding the next option
|
|
nextOptionStringIndex = null;
|
|
for (position in optionStringIndices) {
|
|
if (!optionStringIndices.hasOwnProperty(position)) { continue; }
|
|
|
|
position = parseInt(position, 10);
|
|
if (position >= startIndex) {
|
|
if (nextOptionStringIndex !== null) {
|
|
nextOptionStringIndex = Math.min(nextOptionStringIndex, position);
|
|
} else {
|
|
nextOptionStringIndex = position;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (startIndex !== nextOptionStringIndex) {
|
|
positionalsEndIndex = consumePositionals(startIndex);
|
|
// only try to parse the next optional if we didn't consume
|
|
// the option string during the positionals parsing
|
|
if (positionalsEndIndex > startIndex) {
|
|
startIndex = positionalsEndIndex;
|
|
continue;
|
|
} else {
|
|
startIndex = positionalsEndIndex;
|
|
}
|
|
}
|
|
|
|
// if we consumed all the positionals we could and we're not
|
|
// at the index of an option string, there were extra arguments
|
|
if (!optionStringIndices[startIndex]) {
|
|
var strings = argStrings.slice(startIndex, nextOptionStringIndex);
|
|
extras = extras.concat(strings);
|
|
startIndex = nextOptionStringIndex;
|
|
}
|
|
// consume the next optional and any arguments for it
|
|
startIndex = consumeOptional(startIndex);
|
|
}
|
|
|
|
// consume any positionals following the last Optional
|
|
var stopIndex = consumePositionals(startIndex);
|
|
|
|
// if we didn't consume all the argument strings, there were extras
|
|
extras = extras.concat(argStrings.slice(stopIndex));
|
|
|
|
// if we didn't use all the Positional objects, there were too few
|
|
// arg strings supplied.
|
|
if (positionals.length > 0) {
|
|
self.error('too few arguments');
|
|
}
|
|
|
|
// make sure all required actions were present
|
|
self._actions.forEach(function (action) {
|
|
if (action.required) {
|
|
if (seenActions.indexOf(action) < 0) {
|
|
self.error(format('Argument "%s" is required', action.getName()));
|
|
}
|
|
}
|
|
});
|
|
|
|
// make sure all required groups have one option present
|
|
var actionUsed = false;
|
|
self._mutuallyExclusiveGroups.forEach(function (group) {
|
|
if (group.required) {
|
|
actionUsed = group._groupActions.some(function (action) {
|
|
return seenNonDefaultActions.indexOf(action) !== -1;
|
|
});
|
|
|
|
// if no actions were used, report the error
|
|
if (!actionUsed) {
|
|
var names = [];
|
|
group._groupActions.forEach(function (action) {
|
|
if (action.help !== c.SUPPRESS) {
|
|
names.push(action.getName());
|
|
}
|
|
});
|
|
names = names.join(' ');
|
|
var msg = 'one of the arguments ' + names + ' is required';
|
|
self.error(msg);
|
|
}
|
|
}
|
|
});
|
|
|
|
// return the updated namespace and the extra arguments
|
|
return [ namespace, extras ];
|
|
};
|
|
|
|
ArgumentParser.prototype._readArgsFromFiles = function (argStrings) {
|
|
// expand arguments referencing files
|
|
var self = this;
|
|
var fs = require('fs');
|
|
var newArgStrings = [];
|
|
argStrings.forEach(function (argString) {
|
|
if (self.fromfilePrefixChars.indexOf(argString[0]) < 0) {
|
|
// for regular arguments, just add them back into the list
|
|
newArgStrings.push(argString);
|
|
} else {
|
|
// replace arguments referencing files with the file content
|
|
try {
|
|
var argstrs = [];
|
|
var filename = argString.slice(1);
|
|
var content = fs.readFileSync(filename, 'utf8');
|
|
content = content.trim().split('\n');
|
|
content.forEach(function (argLine) {
|
|
self.convertArgLineToArgs(argLine).forEach(function (arg) {
|
|
argstrs.push(arg);
|
|
});
|
|
argstrs = self._readArgsFromFiles(argstrs);
|
|
});
|
|
newArgStrings.push.apply(newArgStrings, argstrs);
|
|
} catch (error) {
|
|
return self.error(error.message);
|
|
}
|
|
}
|
|
});
|
|
return newArgStrings;
|
|
};
|
|
|
|
ArgumentParser.prototype.convertArgLineToArgs = function (argLine) {
|
|
return [ argLine ];
|
|
};
|
|
|
|
ArgumentParser.prototype._matchArgument = function (action, regexpArgStrings) {
|
|
|
|
// match the pattern for this action to the arg strings
|
|
var regexpNargs = new RegExp('^' + this._getNargsPattern(action));
|
|
var matches = regexpArgStrings.match(regexpNargs);
|
|
var message;
|
|
|
|
// throw an exception if we weren't able to find a match
|
|
if (!matches) {
|
|
switch (action.nargs) {
|
|
/*eslint-disable no-undefined*/
|
|
case undefined:
|
|
case null:
|
|
message = 'Expected one argument.';
|
|
break;
|
|
case c.OPTIONAL:
|
|
message = 'Expected at most one argument.';
|
|
break;
|
|
case c.ONE_OR_MORE:
|
|
message = 'Expected at least one argument.';
|
|
break;
|
|
default:
|
|
message = 'Expected %s argument(s)';
|
|
}
|
|
|
|
throw argumentErrorHelper(
|
|
action,
|
|
format(message, action.nargs)
|
|
);
|
|
}
|
|
// return the number of arguments matched
|
|
return matches[1].length;
|
|
};
|
|
|
|
ArgumentParser.prototype._matchArgumentsPartial = function (actions, regexpArgStrings) {
|
|
// progressively shorten the actions list by slicing off the
|
|
// final actions until we find a match
|
|
var self = this;
|
|
var result = [];
|
|
var actionSlice, pattern, matches;
|
|
var i, j;
|
|
|
|
function getLength(string) {
|
|
return string.length;
|
|
}
|
|
|
|
for (i = actions.length; i > 0; i--) {
|
|
pattern = '';
|
|
actionSlice = actions.slice(0, i);
|
|
for (j = 0; j < actionSlice.length; j++) {
|
|
pattern += self._getNargsPattern(actionSlice[j]);
|
|
}
|
|
|
|
pattern = new RegExp('^' + pattern);
|
|
matches = regexpArgStrings.match(pattern);
|
|
|
|
if (matches && matches.length > 0) {
|
|
// need only groups
|
|
matches = matches.splice(1);
|
|
result = result.concat(matches.map(getLength));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// return the list of arg string counts
|
|
return result;
|
|
};
|
|
|
|
ArgumentParser.prototype._parseOptional = function (argString) {
|
|
var action, optionString, argExplicit, optionTuples;
|
|
|
|
// if it's an empty string, it was meant to be a positional
|
|
if (!argString) {
|
|
return null;
|
|
}
|
|
|
|
// if it doesn't start with a prefix, it was meant to be positional
|
|
if (this.prefixChars.indexOf(argString[0]) < 0) {
|
|
return null;
|
|
}
|
|
|
|
// if the option string is present in the parser, return the action
|
|
if (this._optionStringActions[argString]) {
|
|
return [ this._optionStringActions[argString], argString, null ];
|
|
}
|
|
|
|
// if it's just a single character, it was meant to be positional
|
|
if (argString.length === 1) {
|
|
return null;
|
|
}
|
|
|
|
// if the option string before the "=" is present, return the action
|
|
if (argString.indexOf('=') >= 0) {
|
|
optionString = argString.split('=', 1)[0];
|
|
argExplicit = argString.slice(optionString.length + 1);
|
|
|
|
if (this._optionStringActions[optionString]) {
|
|
action = this._optionStringActions[optionString];
|
|
return [ action, optionString, argExplicit ];
|
|
}
|
|
}
|
|
|
|
// search through all possible prefixes of the option string
|
|
// and all actions in the parser for possible interpretations
|
|
optionTuples = this._getOptionTuples(argString);
|
|
|
|
// if multiple actions match, the option string was ambiguous
|
|
if (optionTuples.length > 1) {
|
|
var optionStrings = optionTuples.map(function (optionTuple) {
|
|
return optionTuple[1];
|
|
});
|
|
this.error(format(
|
|
'Ambiguous option: "%s" could match %s.',
|
|
argString, optionStrings.join(', ')
|
|
));
|
|
// if exactly one action matched, this segmentation is good,
|
|
// so return the parsed action
|
|
} else if (optionTuples.length === 1) {
|
|
return optionTuples[0];
|
|
}
|
|
|
|
// if it was not found as an option, but it looks like a negative
|
|
// number, it was meant to be positional
|
|
// unless there are negative-number-like options
|
|
if (argString.match(this._regexpNegativeNumber)) {
|
|
if (!this._hasNegativeNumberOptionals.some(Boolean)) {
|
|
return null;
|
|
}
|
|
}
|
|
// if it contains a space, it was meant to be a positional
|
|
if (argString.search(' ') >= 0) {
|
|
return null;
|
|
}
|
|
|
|
// it was meant to be an optional but there is no such option
|
|
// in this parser (though it might be a valid option in a subparser)
|
|
return [ null, argString, null ];
|
|
};
|
|
|
|
ArgumentParser.prototype._getOptionTuples = function (optionString) {
|
|
var result = [];
|
|
var chars = this.prefixChars;
|
|
var optionPrefix;
|
|
var argExplicit;
|
|
var action;
|
|
var actionOptionString;
|
|
|
|
// option strings starting with two prefix characters are only split at
|
|
// the '='
|
|
if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) >= 0) {
|
|
if (optionString.indexOf('=') >= 0) {
|
|
var optionStringSplit = optionString.split('=', 1);
|
|
|
|
optionPrefix = optionStringSplit[0];
|
|
argExplicit = optionStringSplit[1];
|
|
} else {
|
|
optionPrefix = optionString;
|
|
argExplicit = null;
|
|
}
|
|
|
|
for (actionOptionString in this._optionStringActions) {
|
|
if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
|
|
action = this._optionStringActions[actionOptionString];
|
|
result.push([ action, actionOptionString, argExplicit ]);
|
|
}
|
|
}
|
|
|
|
// single character options can be concatenated with their arguments
|
|
// but multiple character options always have to have their argument
|
|
// separate
|
|
} else if (chars.indexOf(optionString[0]) >= 0 && chars.indexOf(optionString[1]) < 0) {
|
|
optionPrefix = optionString;
|
|
argExplicit = null;
|
|
var optionPrefixShort = optionString.substr(0, 2);
|
|
var argExplicitShort = optionString.substr(2);
|
|
|
|
for (actionOptionString in this._optionStringActions) {
|
|
if (!$$.has(this._optionStringActions, actionOptionString)) continue;
|
|
|
|
action = this._optionStringActions[actionOptionString];
|
|
if (actionOptionString === optionPrefixShort) {
|
|
result.push([ action, actionOptionString, argExplicitShort ]);
|
|
} else if (actionOptionString.substr(0, optionPrefix.length) === optionPrefix) {
|
|
result.push([ action, actionOptionString, argExplicit ]);
|
|
}
|
|
}
|
|
|
|
// shouldn't ever get here
|
|
} else {
|
|
throw new Error(format('Unexpected option string: %s.', optionString));
|
|
}
|
|
// return the collected option tuples
|
|
return result;
|
|
};
|
|
|
|
ArgumentParser.prototype._getNargsPattern = function (action) {
|
|
// in all examples below, we have to allow for '--' args
|
|
// which are represented as '-' in the pattern
|
|
var regexpNargs;
|
|
|
|
switch (action.nargs) {
|
|
// the default (null) is assumed to be a single argument
|
|
case undefined:
|
|
case null:
|
|
regexpNargs = '(-*A-*)';
|
|
break;
|
|
// allow zero or more arguments
|
|
case c.OPTIONAL:
|
|
regexpNargs = '(-*A?-*)';
|
|
break;
|
|
// allow zero or more arguments
|
|
case c.ZERO_OR_MORE:
|
|
regexpNargs = '(-*[A-]*)';
|
|
break;
|
|
// allow one or more arguments
|
|
case c.ONE_OR_MORE:
|
|
regexpNargs = '(-*A[A-]*)';
|
|
break;
|
|
// allow any number of options or arguments
|
|
case c.REMAINDER:
|
|
regexpNargs = '([-AO]*)';
|
|
break;
|
|
// allow one argument followed by any number of options or arguments
|
|
case c.PARSER:
|
|
regexpNargs = '(-*A[-AO]*)';
|
|
break;
|
|
// all others should be integers
|
|
default:
|
|
regexpNargs = '(-*' + $$.repeat('-*A', action.nargs) + '-*)';
|
|
}
|
|
|
|
// if this is an optional action, -- is not allowed
|
|
if (action.isOptional()) {
|
|
regexpNargs = regexpNargs.replace(/-\*/g, '');
|
|
regexpNargs = regexpNargs.replace(/-/g, '');
|
|
}
|
|
|
|
// return the pattern
|
|
return regexpNargs;
|
|
};
|
|
|
|
//
|
|
// Value conversion methods
|
|
//
|
|
|
|
ArgumentParser.prototype._getValues = function (action, argStrings) {
|
|
var self = this;
|
|
|
|
// for everything but PARSER args, strip out '--'
|
|
if (action.nargs !== c.PARSER && action.nargs !== c.REMAINDER) {
|
|
argStrings = argStrings.filter(function (arrayElement) {
|
|
return arrayElement !== '--';
|
|
});
|
|
}
|
|
|
|
var value, argString;
|
|
|
|
// optional argument produces a default when not present
|
|
if (argStrings.length === 0 && action.nargs === c.OPTIONAL) {
|
|
|
|
value = (action.isOptional()) ? action.constant : action.defaultValue;
|
|
|
|
if (typeof (value) === 'string') {
|
|
value = this._getValue(action, value);
|
|
this._checkValue(action, value);
|
|
}
|
|
|
|
// when nargs='*' on a positional, if there were no command-line
|
|
// args, use the default if it is anything other than None
|
|
} else if (argStrings.length === 0 && action.nargs === c.ZERO_OR_MORE &&
|
|
action.optionStrings.length === 0) {
|
|
|
|
value = (action.defaultValue || argStrings);
|
|
this._checkValue(action, value);
|
|
|
|
// single argument or optional argument produces a single value
|
|
} else if (argStrings.length === 1 &&
|
|
(!action.nargs || action.nargs === c.OPTIONAL)) {
|
|
|
|
argString = argStrings[0];
|
|
value = this._getValue(action, argString);
|
|
this._checkValue(action, value);
|
|
|
|
// REMAINDER arguments convert all values, checking none
|
|
} else if (action.nargs === c.REMAINDER) {
|
|
value = argStrings.map(function (v) {
|
|
return self._getValue(action, v);
|
|
});
|
|
|
|
// PARSER arguments convert all values, but check only the first
|
|
} else if (action.nargs === c.PARSER) {
|
|
value = argStrings.map(function (v) {
|
|
return self._getValue(action, v);
|
|
});
|
|
this._checkValue(action, value[0]);
|
|
|
|
// all other types of nargs produce a list
|
|
} else {
|
|
value = argStrings.map(function (v) {
|
|
return self._getValue(action, v);
|
|
});
|
|
value.forEach(function (v) {
|
|
self._checkValue(action, v);
|
|
});
|
|
}
|
|
|
|
// return the converted value
|
|
return value;
|
|
};
|
|
|
|
ArgumentParser.prototype._getValue = function (action, argString) {
|
|
var result;
|
|
|
|
var typeFunction = this._registryGet('type', action.type, action.type);
|
|
if (typeof typeFunction !== 'function') {
|
|
var message = format('%s is not callable', typeFunction);
|
|
throw argumentErrorHelper(action, message);
|
|
}
|
|
|
|
// convert the value to the appropriate type
|
|
try {
|
|
result = typeFunction(argString);
|
|
|
|
// ArgumentTypeErrors indicate errors
|
|
// If action.type is not a registered string, it is a function
|
|
// Try to deduce its name for inclusion in the error message
|
|
// Failing that, include the error message it raised.
|
|
} catch (e) {
|
|
var name = null;
|
|
if (typeof action.type === 'string') {
|
|
name = action.type;
|
|
} else {
|
|
name = action.type.name || action.type.displayName || '<function>';
|
|
}
|
|
var msg = format('Invalid %s value: %s', name, argString);
|
|
if (name === '<function>') { msg += '\n' + e.message; }
|
|
throw argumentErrorHelper(action, msg);
|
|
}
|
|
// return the converted value
|
|
return result;
|
|
};
|
|
|
|
ArgumentParser.prototype._checkValue = function (action, value) {
|
|
// converted value must be one of the choices (if specified)
|
|
var choices = action.choices;
|
|
if (choices) {
|
|
// choise for argument can by array or string
|
|
if ((typeof choices === 'string' || Array.isArray(choices)) &&
|
|
choices.indexOf(value) !== -1) {
|
|
return;
|
|
}
|
|
// choise for subparsers can by only hash
|
|
if (typeof choices === 'object' && !Array.isArray(choices) && choices[value]) {
|
|
return;
|
|
}
|
|
|
|
if (typeof choices === 'string') {
|
|
choices = choices.split('').join(', ');
|
|
} else if (Array.isArray(choices)) {
|
|
choices = choices.join(', ');
|
|
} else {
|
|
choices = Object.keys(choices).join(', ');
|
|
}
|
|
var message = format('Invalid choice: %s (choose from [%s])', value, choices);
|
|
throw argumentErrorHelper(action, message);
|
|
}
|
|
};
|
|
|
|
//
|
|
// Help formatting methods
|
|
//
|
|
|
|
/**
|
|
* ArgumentParser#formatUsage -> string
|
|
*
|
|
* Return usage string
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
|
|
**/
|
|
ArgumentParser.prototype.formatUsage = function () {
|
|
var formatter = this._getFormatter();
|
|
formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
|
|
return formatter.formatHelp();
|
|
};
|
|
|
|
/**
|
|
* ArgumentParser#formatHelp -> string
|
|
*
|
|
* Return help
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
|
|
**/
|
|
ArgumentParser.prototype.formatHelp = function () {
|
|
var formatter = this._getFormatter();
|
|
|
|
// usage
|
|
formatter.addUsage(this.usage, this._actions, this._mutuallyExclusiveGroups);
|
|
|
|
// description
|
|
formatter.addText(this.description);
|
|
|
|
// positionals, optionals and user-defined groups
|
|
this._actionGroups.forEach(function (actionGroup) {
|
|
formatter.startSection(actionGroup.title);
|
|
formatter.addText(actionGroup.description);
|
|
formatter.addArguments(actionGroup._groupActions);
|
|
formatter.endSection();
|
|
});
|
|
|
|
// epilog
|
|
formatter.addText(this.epilog);
|
|
|
|
// determine help from format above
|
|
return formatter.formatHelp();
|
|
};
|
|
|
|
ArgumentParser.prototype._getFormatter = function () {
|
|
var FormatterClass = this.formatterClass;
|
|
var formatter = new FormatterClass({ prog: this.prog });
|
|
return formatter;
|
|
};
|
|
|
|
//
|
|
// Print functions
|
|
//
|
|
|
|
/**
|
|
* ArgumentParser#printUsage() -> Void
|
|
*
|
|
* Print usage
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
|
|
**/
|
|
ArgumentParser.prototype.printUsage = function () {
|
|
this._printMessage(this.formatUsage());
|
|
};
|
|
|
|
/**
|
|
* ArgumentParser#printHelp() -> Void
|
|
*
|
|
* Print help
|
|
*
|
|
* See also [original guide][1]
|
|
*
|
|
* [1]:http://docs.python.org/dev/library/argparse.html#printing-help
|
|
**/
|
|
ArgumentParser.prototype.printHelp = function () {
|
|
this._printMessage(this.formatHelp());
|
|
};
|
|
|
|
ArgumentParser.prototype._printMessage = function (message, stream) {
|
|
if (!stream) {
|
|
stream = process.stdout;
|
|
}
|
|
if (message) {
|
|
stream.write('' + message);
|
|
}
|
|
};
|
|
|
|
//
|
|
// Exit functions
|
|
//
|
|
|
|
/**
|
|
* ArgumentParser#exit(status=0, message) -> Void
|
|
* - status (int): exit status
|
|
* - message (string): message
|
|
*
|
|
* Print message in stderr/stdout and exit program
|
|
**/
|
|
ArgumentParser.prototype.exit = function (status, message) {
|
|
if (message) {
|
|
if (status === 0) {
|
|
this._printMessage(message);
|
|
} else {
|
|
this._printMessage(message, process.stderr);
|
|
}
|
|
}
|
|
|
|
process.exit(status);
|
|
};
|
|
|
|
/**
|
|
* ArgumentParser#error(message) -> Void
|
|
* - err (Error|string): message
|
|
*
|
|
* Error method Prints a usage message incorporating the message to stderr and
|
|
* exits. If you override this in a subclass,
|
|
* it should not return -- it should
|
|
* either exit or throw an exception.
|
|
*
|
|
**/
|
|
ArgumentParser.prototype.error = function (err) {
|
|
var message;
|
|
if (err instanceof Error) {
|
|
if (this.debug === true) {
|
|
throw err;
|
|
}
|
|
message = err.message;
|
|
} else {
|
|
message = err;
|
|
}
|
|
var msg = format('%s: error: %s', this.prog, message) + c.EOL;
|
|
|
|
if (this.debug === true) {
|
|
throw new Error(msg);
|
|
}
|
|
|
|
this.printUsage(process.stderr);
|
|
|
|
return this.exit(2, msg);
|
|
};
|
|
|
|
module.exports = ArgumentParser;
|