| /** |
| * 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; |