Skip to content
GitLab
Commit 4806fefb authored by Rosanny Sihombing's avatar Rosanny Sihombing
Browse files

Merge branch 'cherry-pick-5b932c11' into 'testing' 

MLAB-677: Update required modules

See merge request !169
parents b807a4c1 d7204587
testing
1 merge request!169MLAB-677: Update required modules
Pipeline #6896 passed with stage
in 5 seconds
Hide whitespace changes
Inline Side-by-side
Showing
with 18 additions and 2668 deletions
+18 -2668
node_modules/argparse/lib/argument/error.js deleted 100644 → 0
+ 0
- 50
View file @ b807a4c1
'use strict';
var format = require('util').format;
var ERR_CODE = 'ARGError';
/*:nodoc:*
* argumentError(argument, message) -> TypeError
* - argument (Object): action with broken argument
* - message (String): error message
*
* Error format helper. An error from creating or using an argument
* (optional or positional). The string value of this exception
* is the message, augmented with information
* about the argument that caused it.
*
* #####Example
*
* var argumentErrorHelper = require('./argument/error');
* if (conflictOptionals.length > 0) {
* throw argumentErrorHelper(
* action,
* format('Conflicting option string(s): %s', conflictOptionals.join(', '))
* );
* }
*
**/
module.exports = function (argument, message) {
var argumentName = null;
var errMessage;
var err;
if (argument.getName) {
argumentName = argument.getName();
} else {
argumentName = '' + argument;
}
if (!argumentName) {
errMessage = message;
} else {
errMessage = format('argument "%s": %s', argumentName, message);
}
err = new TypeError(errMessage);
err.code = ERR_CODE;
return err;
};
node_modules/argparse/lib/argument/exclusive.js deleted 100644 → 0
+ 0
- 54
View file @ b807a4c1
/** internal
* class MutuallyExclusiveGroup
*
* Group arguments.
* By default, ArgumentParser groups command-line arguments
* into “positional arguments” and “optional arguments”
* when displaying help messages. When there is a better
* conceptual grouping of arguments than this default one,
* appropriate groups can be created using the addArgumentGroup() method
*
* This class inherited from [[ArgumentContainer]]
**/
'use strict';
var util = require('util');
var ArgumentGroup = require('./group');
/**
* new MutuallyExclusiveGroup(container, options)
* - container (object): main container
* - options (object): options.required -> true/false
*
* `required` could be an argument itself, but making it a property of
* the options argument is more consistent with the JS adaptation of the Python)
**/
var MutuallyExclusiveGroup = module.exports = function MutuallyExclusiveGroup(container, options) {
var required;
options = options || {};
required = options.required || false;
ArgumentGroup.call(this, container);
this.required = required;
};
util.inherits(MutuallyExclusiveGroup, ArgumentGroup);
MutuallyExclusiveGroup.prototype._addAction = function (action) {
var msg;
if (action.required) {
msg = 'mutually exclusive arguments must be optional';
throw new Error(msg);
}
action = this._container._addAction(action);
this._groupActions.push(action);
return action;
};
MutuallyExclusiveGroup.prototype._removeAction = function (action) {
this._container._removeAction(action);
this._groupActions.remove(action);
};
node_modules/argparse/lib/argument/group.js deleted 100644 → 0
+ 0
- 75
View file @ b807a4c1
/** internal
* class ArgumentGroup
*
* Group arguments.
* By default, ArgumentParser groups command-line arguments
* into “positional arguments” and “optional arguments”
* when displaying help messages. When there is a better
* conceptual grouping of arguments than this default one,
* appropriate groups can be created using the addArgumentGroup() method
*
* This class inherited from [[ArgumentContainer]]
**/
'use strict';
var util = require('util');
var ActionContainer = require('../action_container');
/**
* new ArgumentGroup(container, options)
* - container (object): main container
* - options (object): hash of group options
*
* #### options
* - **prefixChars** group name prefix
* - **argumentDefault** default argument value
* - **title** group title
* - **description** group description
*
**/
var ArgumentGroup = module.exports = function ArgumentGroup(container, options) {
options = options || {};
// add any missing keyword arguments by checking the container
options.conflictHandler = (options.conflictHandler || container.conflictHandler);
options.prefixChars = (options.prefixChars || container.prefixChars);
options.argumentDefault = (options.argumentDefault || container.argumentDefault);
ActionContainer.call(this, options);
// group attributes
this.title = options.title;
this._groupActions = [];
// share most attributes with the container
this._container = container;
this._registries = container._registries;
this._actions = container._actions;
this._optionStringActions = container._optionStringActions;
this._defaults = container._defaults;
this._hasNegativeNumberOptionals = container._hasNegativeNumberOptionals;
this._mutuallyExclusiveGroups = container._mutuallyExclusiveGroups;
};
util.inherits(ArgumentGroup, ActionContainer);
ArgumentGroup.prototype._addAction = function (action) {
// Parent add action
action = ActionContainer.prototype._addAction.call(this, action);
this._groupActions.push(action);
return action;
};
ArgumentGroup.prototype._removeAction = function (action) {
// Parent remove action
ActionContainer.prototype._removeAction.call(this, action);
var actionIndex = this._groupActions.indexOf(action);
if (actionIndex >= 0) {
this._groupActions.splice(actionIndex, 1);
}
};
node_modules/argparse/lib/argument_parser.js deleted 100644 → 0
+ 0
- 1161
View file @ b807a4c1
/**
* 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;
node_modules/argparse/lib/const.js deleted 100644 → 0
+ 0
- 21
View file @ b807a4c1
//
// Constants
//
'use strict';
module.exports.EOL = '\n';
module.exports.SUPPRESS = '==SUPPRESS==';
module.exports.OPTIONAL = '?';
module.exports.ZERO_OR_MORE = '*';
module.exports.ONE_OR_MORE = '+';
module.exports.PARSER = 'A...';
module.exports.REMAINDER = '...';
module.exports._UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args';
node_modules/argparse/lib/help/added_formatters.js deleted 100644 → 0
+ 0
- 87
View file @ b807a4c1
'use strict';
var util = require('util');
// Constants
var c = require('../const');
var $$ = require('../utils');
var HelpFormatter = require('./formatter.js');
/**
* new RawDescriptionHelpFormatter(options)
* new ArgumentParser({formatterClass: argparse.RawDescriptionHelpFormatter, ...})
*
* Help message formatter which adds default values to argument help.
*
* Only the name of this class is considered a public API. All the methods
* provided by the class are considered an implementation detail.
**/
function ArgumentDefaultsHelpFormatter(options) {
HelpFormatter.call(this, options);
}
util.inherits(ArgumentDefaultsHelpFormatter, HelpFormatter);
ArgumentDefaultsHelpFormatter.prototype._getHelpString = function (action) {
var help = action.help;
if (action.help.indexOf('%(defaultValue)s') === -1) {
if (action.defaultValue !== c.SUPPRESS) {
var defaulting_nargs = [ c.OPTIONAL, c.ZERO_OR_MORE ];
if (action.isOptional() || (defaulting_nargs.indexOf(action.nargs) >= 0)) {
help += ' (default: %(defaultValue)s)';
}
}
}
return help;
};
module.exports.ArgumentDefaultsHelpFormatter = ArgumentDefaultsHelpFormatter;
/**
* new RawDescriptionHelpFormatter(options)
* new ArgumentParser({formatterClass: argparse.RawDescriptionHelpFormatter, ...})
*
* Help message formatter which retains any formatting in descriptions.
*
* Only the name of this class is considered a public API. All the methods
* provided by the class are considered an implementation detail.
**/
function RawDescriptionHelpFormatter(options) {
HelpFormatter.call(this, options);
}
util.inherits(RawDescriptionHelpFormatter, HelpFormatter);
RawDescriptionHelpFormatter.prototype._fillText = function (text, width, indent) {
var lines = text.split('\n');
lines = lines.map(function (line) {
return $$.trimEnd(indent + line);
});
return lines.join('\n');
};
module.exports.RawDescriptionHelpFormatter = RawDescriptionHelpFormatter;
/**
* new RawTextHelpFormatter(options)
* new ArgumentParser({formatterClass: argparse.RawTextHelpFormatter, ...})
*
* Help message formatter which retains formatting of all help text.
*
* Only the name of this class is considered a public API. All the methods
* provided by the class are considered an implementation detail.
**/
function RawTextHelpFormatter(options) {
RawDescriptionHelpFormatter.call(this, options);
}
util.inherits(RawTextHelpFormatter, RawDescriptionHelpFormatter);
RawTextHelpFormatter.prototype._splitLines = function (text) {
return text.split('\n');
};
module.exports.RawTextHelpFormatter = RawTextHelpFormatter;
node_modules/argparse/lib/help/formatter.js deleted 100644 → 0
+ 0
- 795
View file @ b807a4c1
/**
* class HelpFormatter
*
* Formatter for generating usage messages and argument help strings. Only the
* name of this class is considered a public API. All the methods provided by
* the class are considered an implementation detail.
*
* Do not call in your code, use this class only for inherits your own forvatter
*
* ToDo add [additonal formatters][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#formatter-class
**/
'use strict';
var sprintf = require('sprintf-js').sprintf;
// Constants
var c = require('../const');
var $$ = require('../utils');
/*:nodoc:* internal
* new Support(parent, heding)
* - parent (object): parent section
* - heading (string): header string
*
**/
function Section(parent, heading) {
this._parent = parent;
this._heading = heading;
this._items = [];
}
/*:nodoc:* internal
* Section#addItem(callback) -> Void
* - callback (array): tuple with function and args
*
* Add function for single element
**/
Section.prototype.addItem = function (callback) {
this._items.push(callback);
};
/*:nodoc:* internal
* Section#formatHelp(formatter) -> string
* - formatter (HelpFormatter): current formatter
*
* Form help section string
*
**/
Section.prototype.formatHelp = function (formatter) {
var itemHelp, heading;
// format the indented section
if (this._parent) {
formatter._indent();
}
itemHelp = this._items.map(function (item) {
var obj, func, args;
obj = formatter;
func = item[0];
args = item[1];
return func.apply(obj, args);
});
itemHelp = formatter._joinParts(itemHelp);
if (this._parent) {
formatter._dedent();
}
// return nothing if the section was empty
if (!itemHelp) {
return '';
}
// add the heading if the section was non-empty
heading = '';
if (this._heading && this._heading !== c.SUPPRESS) {
var currentIndent = formatter.currentIndent;
heading = $$.repeat(' ', currentIndent) + this._heading + ':' + c.EOL;
}
// join the section-initialize newline, the heading and the help
return formatter._joinParts([ c.EOL, heading, itemHelp, c.EOL ]);
};
/**
* new HelpFormatter(options)
*
* #### Options:
* - `prog`: program name
* - `indentIncriment`: indent step, default value 2
* - `maxHelpPosition`: max help position, default value = 24
* - `width`: line width
*
**/
var HelpFormatter = module.exports = function HelpFormatter(options) {
options = options || {};
this._prog = options.prog;
this._maxHelpPosition = options.maxHelpPosition || 24;
this._width = (options.width || ((process.env.COLUMNS || 80) - 2));
this._currentIndent = 0;
this._indentIncriment = options.indentIncriment || 2;
this._level = 0;
this._actionMaxLength = 0;
this._rootSection = new Section(null);
this._currentSection = this._rootSection;
this._whitespaceMatcher = new RegExp('\\s+', 'g');
this._longBreakMatcher = new RegExp(c.EOL + c.EOL + c.EOL + '+', 'g');
};
HelpFormatter.prototype._indent = function () {
this._currentIndent += this._indentIncriment;
this._level += 1;
};
HelpFormatter.prototype._dedent = function () {
this._currentIndent -= this._indentIncriment;
this._level -= 1;
if (this._currentIndent < 0) {
throw new Error('Indent decreased below 0.');
}
};
HelpFormatter.prototype._addItem = function (func, args) {
this._currentSection.addItem([ func, args ]);
};
//
// Message building methods
//
/**
* HelpFormatter#startSection(heading) -> Void
* - heading (string): header string
*
* Start new help section
*
* See alse [code example][1]
*
* ##### Example
*
* formatter.startSection(actionGroup.title);
* formatter.addText(actionGroup.description);
* formatter.addArguments(actionGroup._groupActions);
* formatter.endSection();
*
**/
HelpFormatter.prototype.startSection = function (heading) {
this._indent();
var section = new Section(this._currentSection, heading);
var func = section.formatHelp.bind(section);
this._addItem(func, [ this ]);
this._currentSection = section;
};
/**
* HelpFormatter#endSection -> Void
*
* End help section
*
* ##### Example
*
* formatter.startSection(actionGroup.title);
* formatter.addText(actionGroup.description);
* formatter.addArguments(actionGroup._groupActions);
* formatter.endSection();
**/
HelpFormatter.prototype.endSection = function () {
this._currentSection = this._currentSection._parent;
this._dedent();
};
/**
* HelpFormatter#addText(text) -> Void
* - text (string): plain text
*
* Add plain text into current section
*
* ##### Example
*
* formatter.startSection(actionGroup.title);
* formatter.addText(actionGroup.description);
* formatter.addArguments(actionGroup._groupActions);
* formatter.endSection();
*
**/
HelpFormatter.prototype.addText = function (text) {
if (text && text !== c.SUPPRESS) {
this._addItem(this._formatText, [ text ]);
}
};
/**
* HelpFormatter#addUsage(usage, actions, groups, prefix) -> Void
* - usage (string): usage text
* - actions (array): actions list
* - groups (array): groups list
* - prefix (string): usage prefix
*
* Add usage data into current section
*
* ##### Example
*
* formatter.addUsage(this.usage, this._actions, []);
* return formatter.formatHelp();
*
**/
HelpFormatter.prototype.addUsage = function (usage, actions, groups, prefix) {
if (usage !== c.SUPPRESS) {
this._addItem(this._formatUsage, [ usage, actions, groups, prefix ]);
}
};
/**
* HelpFormatter#addArgument(action) -> Void
* - action (object): action
*
* Add argument into current section
*
* Single variant of [[HelpFormatter#addArguments]]
**/
HelpFormatter.prototype.addArgument = function (action) {
if (action.help !== c.SUPPRESS) {
var self = this;
// find all invocations
var invocations = [ this._formatActionInvocation(action) ];
var invocationLength = invocations[0].length;
var actionLength;
if (action._getSubactions) {
this._indent();
action._getSubactions().forEach(function (subaction) {
var invocationNew = self._formatActionInvocation(subaction);
invocations.push(invocationNew);
invocationLength = Math.max(invocationLength, invocationNew.length);
});
this._dedent();
}
// update the maximum item length
actionLength = invocationLength + this._currentIndent;
this._actionMaxLength = Math.max(this._actionMaxLength, actionLength);
// add the item to the list
this._addItem(this._formatAction, [ action ]);
}
};
/**
* HelpFormatter#addArguments(actions) -> Void
* - actions (array): actions list
*
* Mass add arguments into current section
*
* ##### Example
*
* formatter.startSection(actionGroup.title);
* formatter.addText(actionGroup.description);
* formatter.addArguments(actionGroup._groupActions);
* formatter.endSection();
*
**/
HelpFormatter.prototype.addArguments = function (actions) {
var self = this;
actions.forEach(function (action) {
self.addArgument(action);
});
};
//
// Help-formatting methods
//
/**
* HelpFormatter#formatHelp -> string
*
* Format help
*
* ##### Example
*
* formatter.addText(this.epilog);
* return formatter.formatHelp();
*
**/
HelpFormatter.prototype.formatHelp = function () {
var help = this._rootSection.formatHelp(this);
if (help) {
help = help.replace(this._longBreakMatcher, c.EOL + c.EOL);
help = $$.trimChars(help, c.EOL) + c.EOL;
}
return help;
};
HelpFormatter.prototype._joinParts = function (partStrings) {
return partStrings.filter(function (part) {
return (part && part !== c.SUPPRESS);
}).join('');
};
HelpFormatter.prototype._formatUsage = function (usage, actions, groups, prefix) {
if (!prefix && typeof prefix !== 'string') {
prefix = 'usage: ';
}
actions = actions || [];
groups = groups || [];
// if usage is specified, use that
if (usage) {
usage = sprintf(usage, { prog: this._prog });
// if no optionals or positionals are available, usage is just prog
} else if (!usage && actions.length === 0) {
usage = this._prog;
// if optionals and positionals are available, calculate usage
} else if (!usage) {
var prog = this._prog;
var optionals = [];
var positionals = [];
var actionUsage;
var textWidth;
// split optionals from positionals
actions.forEach(function (action) {
if (action.isOptional()) {
optionals.push(action);
} else {
positionals.push(action);
}
});
// build full usage string
actionUsage = this._formatActionsUsage([].concat(optionals, positionals), groups);
usage = [ prog, actionUsage ].join(' ');
// wrap the usage parts if it's too long
textWidth = this._width - this._currentIndent;
if ((prefix.length + usage.length) > textWidth) {
// break usage into wrappable parts
var regexpPart = new RegExp('\\(.*?\\)+|\\[.*?\\]+|\\S+', 'g');
var optionalUsage = this._formatActionsUsage(optionals, groups);
var positionalUsage = this._formatActionsUsage(positionals, groups);
var optionalParts = optionalUsage.match(regexpPart);
var positionalParts = positionalUsage.match(regexpPart) || [];
if (optionalParts.join(' ') !== optionalUsage) {
throw new Error('assert "optionalParts.join(\' \') === optionalUsage"');
}
if (positionalParts.join(' ') !== positionalUsage) {
throw new Error('assert "positionalParts.join(\' \') === positionalUsage"');
}
// helper for wrapping lines
/*eslint-disable func-style*/ // node 0.10 compat
var _getLines = function (parts, indent, prefix) {
var lines = [];
var line = [];
var lineLength = prefix ? prefix.length - 1 : indent.length - 1;
parts.forEach(function (part) {
if (lineLength + 1 + part.length > textWidth) {
lines.push(indent + line.join(' '));
line = [];
lineLength = indent.length - 1;
}
line.push(part);
lineLength += part.length + 1;
});
if (line) {
lines.push(indent + line.join(' '));
}
if (prefix) {
lines[0] = lines[0].substr(indent.length);
}
return lines;
};
var lines, indent, parts;
// if prog is short, follow it with optionals or positionals
if (prefix.length + prog.length <= 0.75 * textWidth) {
indent = $$.repeat(' ', (prefix.length + prog.length + 1));
if (optionalParts) {
lines = [].concat(
_getLines([ prog ].concat(optionalParts), indent, prefix),
_getLines(positionalParts, indent)
);
} else if (positionalParts) {
lines = _getLines([ prog ].concat(positionalParts), indent, prefix);
} else {
lines = [ prog ];
}
// if prog is long, put it on its own line
} else {
indent = $$.repeat(' ', prefix.length);
parts = optionalParts.concat(positionalParts);
lines = _getLines(parts, indent);
if (lines.length > 1) {
lines = [].concat(
_getLines(optionalParts, indent),
_getLines(positionalParts, indent)
);
}
lines = [ prog ].concat(lines);
}
// join lines into usage
usage = lines.join(c.EOL);
}
}
// prefix with 'usage:'
return prefix + usage + c.EOL + c.EOL;
};
HelpFormatter.prototype._formatActionsUsage = function (actions, groups) {
// find group indices and identify actions in groups
var groupActions = [];
var inserts = [];
var self = this;
groups.forEach(function (group) {
var end;
var i;
var start = actions.indexOf(group._groupActions[0]);
if (start >= 0) {
end = start + group._groupActions.length;
//if (actions.slice(start, end) === group._groupActions) {
if ($$.arrayEqual(actions.slice(start, end), group._groupActions)) {
group._groupActions.forEach(function (action) {
groupActions.push(action);
});
if (!group.required) {
if (inserts[start]) {
inserts[start] += ' [';
} else {
inserts[start] = '[';
}
inserts[end] = ']';
} else {
if (inserts[start]) {
inserts[start] += ' (';
} else {
inserts[start] = '(';
}
inserts[end] = ')';
}
for (i = start + 1; i < end; i += 1) {
inserts[i] = '|';
}
}
}
});
// collect all actions format strings
var parts = [];
actions.forEach(function (action, actionIndex) {
var part;
var optionString;
var argsDefault;
var argsString;
// suppressed arguments are marked with None
// remove | separators for suppressed arguments
if (action.help === c.SUPPRESS) {
parts.push(null);
if (inserts[actionIndex] === '|') {
inserts.splice(actionIndex, actionIndex);
} else if (inserts[actionIndex + 1] === '|') {
inserts.splice(actionIndex + 1, actionIndex + 1);
}
// produce all arg strings
} else if (!action.isOptional()) {
part = self._formatArgs(action, action.dest);
// if it's in a group, strip the outer []
if (groupActions.indexOf(action) >= 0) {
if (part[0] === '[' && part[part.length - 1] === ']') {
part = part.slice(1, -1);
}
}
// add the action string to the list
parts.push(part);
// produce the first way to invoke the option in brackets
} else {
optionString = action.optionStrings[0];
// if the Optional doesn't take a value, format is: -s or --long
if (action.nargs === 0) {
part = '' + optionString;
// if the Optional takes a value, format is: -s ARGS or --long ARGS
} else {
argsDefault = action.dest.toUpperCase();
argsString = self._formatArgs(action, argsDefault);
part = optionString + ' ' + argsString;
}
// make it look optional if it's not required or in a group
if (!action.required && groupActions.indexOf(action) < 0) {
part = '[' + part + ']';
}
// add the action string to the list
parts.push(part);
}
});
// insert things at the necessary indices
for (var i = inserts.length - 1; i >= 0; --i) {
if (inserts[i] !== null) {
parts.splice(i, 0, inserts[i]);
}
}
// join all the action items with spaces
var text = parts.filter(function (part) {
return !!part;
}).join(' ');
// clean up separators for mutually exclusive groups
text = text.replace(/([\[(]) /g, '$1'); // remove spaces
text = text.replace(/ ([\])])/g, '$1');
text = text.replace(/\[ *\]/g, ''); // remove empty groups
text = text.replace(/\( *\)/g, '');
text = text.replace(/\(([^|]*)\)/g, '$1'); // remove () from single action groups
text = text.trim();
// return the text
return text;
};
HelpFormatter.prototype._formatText = function (text) {
text = sprintf(text, { prog: this._prog });
var textWidth = this._width - this._currentIndent;
var indentIncriment = $$.repeat(' ', this._currentIndent);
return this._fillText(text, textWidth, indentIncriment) + c.EOL + c.EOL;
};
HelpFormatter.prototype._formatAction = function (action) {
var self = this;
var helpText;
var helpLines;
var parts;
var indentFirst;
// determine the required width and the entry label
var helpPosition = Math.min(this._actionMaxLength + 2, this._maxHelpPosition);
var helpWidth = this._width - helpPosition;
var actionWidth = helpPosition - this._currentIndent - 2;
var actionHeader = this._formatActionInvocation(action);
// no help; start on same line and add a final newline
if (!action.help) {
actionHeader = $$.repeat(' ', this._currentIndent) + actionHeader + c.EOL;
// short action name; start on the same line and pad two spaces
} else if (actionHeader.length <= actionWidth) {
actionHeader = $$.repeat(' ', this._currentIndent) +
actionHeader +
' ' +
$$.repeat(' ', actionWidth - actionHeader.length);
indentFirst = 0;
// long action name; start on the next line
} else {
actionHeader = $$.repeat(' ', this._currentIndent) + actionHeader + c.EOL;
indentFirst = helpPosition;
}
// collect the pieces of the action help
parts = [ actionHeader ];
// if there was help for the action, add lines of help text
if (action.help) {
helpText = this._expandHelp(action);
helpLines = this._splitLines(helpText, helpWidth);
parts.push($$.repeat(' ', indentFirst) + helpLines[0] + c.EOL);
helpLines.slice(1).forEach(function (line) {
parts.push($$.repeat(' ', helpPosition) + line + c.EOL);
});
// or add a newline if the description doesn't end with one
} else if (actionHeader.charAt(actionHeader.length - 1) !== c.EOL) {
parts.push(c.EOL);
}
// if there are any sub-actions, add their help as well
if (action._getSubactions) {
this._indent();
action._getSubactions().forEach(function (subaction) {
parts.push(self._formatAction(subaction));
});
this._dedent();
}
// return a single string
return this._joinParts(parts);
};
HelpFormatter.prototype._formatActionInvocation = function (action) {
if (!action.isOptional()) {
var format_func = this._metavarFormatter(action, action.dest);
var metavars = format_func(1);
return metavars[0];
}
var parts = [];
var argsDefault;
var argsString;
// if the Optional doesn't take a value, format is: -s, --long
if (action.nargs === 0) {
parts = parts.concat(action.optionStrings);
// if the Optional takes a value, format is: -s ARGS, --long ARGS
} else {
argsDefault = action.dest.toUpperCase();
argsString = this._formatArgs(action, argsDefault);
action.optionStrings.forEach(function (optionString) {
parts.push(optionString + ' ' + argsString);
});
}
return parts.join(', ');
};
HelpFormatter.prototype._metavarFormatter = function (action, metavarDefault) {
var result;
if (action.metavar || action.metavar === '') {
result = action.metavar;
} else if (action.choices) {
var choices = action.choices;
if (typeof choices === 'string') {
choices = choices.split('').join(', ');
} else if (Array.isArray(choices)) {
choices = choices.join(',');
} else {
choices = Object.keys(choices).join(',');
}
result = '{' + choices + '}';
} else {
result = metavarDefault;
}
return function (size) {
if (Array.isArray(result)) {
return result;
}
var metavars = [];
for (var i = 0; i < size; i += 1) {
metavars.push(result);
}
return metavars;
};
};
HelpFormatter.prototype._formatArgs = function (action, metavarDefault) {
var result;
var metavars;
var buildMetavar = this._metavarFormatter(action, metavarDefault);
switch (action.nargs) {
/*eslint-disable no-undefined*/
case undefined:
case null:
metavars = buildMetavar(1);
result = '' + metavars[0];
break;
case c.OPTIONAL:
metavars = buildMetavar(1);
result = '[' + metavars[0] + ']';
break;
case c.ZERO_OR_MORE:
metavars = buildMetavar(2);
result = '[' + metavars[0] + ' [' + metavars[1] + ' ...]]';
break;
case c.ONE_OR_MORE:
metavars = buildMetavar(2);
result = '' + metavars[0] + ' [' + metavars[1] + ' ...]';
break;
case c.REMAINDER:
result = '...';
break;
case c.PARSER:
metavars = buildMetavar(1);
result = metavars[0] + ' ...';
break;
default:
metavars = buildMetavar(action.nargs);
result = metavars.join(' ');
}
return result;
};
HelpFormatter.prototype._expandHelp = function (action) {
var params = { prog: this._prog };
Object.keys(action).forEach(function (actionProperty) {
var actionValue = action[actionProperty];
if (actionValue !== c.SUPPRESS) {
params[actionProperty] = actionValue;
}
});
if (params.choices) {
if (typeof params.choices === 'string') {
params.choices = params.choices.split('').join(', ');
} else if (Array.isArray(params.choices)) {
params.choices = params.choices.join(', ');
} else {
params.choices = Object.keys(params.choices).join(', ');
}
}
return sprintf(this._getHelpString(action), params);
};
HelpFormatter.prototype._splitLines = function (text, width) {
var lines = [];
var delimiters = [ ' ', '.', ',', '!', '?' ];
var re = new RegExp('[' + delimiters.join('') + '][^' + delimiters.join('') + ']*$');
text = text.replace(/[\n\|\t]/g, ' ');
text = text.trim();
text = text.replace(this._whitespaceMatcher, ' ');
// Wraps the single paragraph in text (a string) so every line
// is at most width characters long.
text.split(c.EOL).forEach(function (line) {
if (width >= line.length) {
lines.push(line);
return;
}
var wrapStart = 0;
var wrapEnd = width;
var delimiterIndex = 0;
while (wrapEnd <= line.length) {
if (wrapEnd !== line.length && delimiters.indexOf(line[wrapEnd] < -1)) {
delimiterIndex = (re.exec(line.substring(wrapStart, wrapEnd)) || {}).index;
wrapEnd = wrapStart + delimiterIndex + 1;
}
lines.push(line.substring(wrapStart, wrapEnd));
wrapStart = wrapEnd;
wrapEnd += width;
}
if (wrapStart < line.length) {
lines.push(line.substring(wrapStart, wrapEnd));
}
});
return lines;
};
HelpFormatter.prototype._fillText = function (text, width, indent) {
var lines = this._splitLines(text, width);
lines = lines.map(function (line) {
return indent + line;
});
return lines.join(c.EOL);
};
HelpFormatter.prototype._getHelpString = function (action) {
return action.help;
};
node_modules/argparse/lib/namespace.js deleted 100644 → 0
+ 0
- 76
View file @ b807a4c1
/**
* class Namespace
*
* Simple object for storing attributes. Implements equality by attribute names
* and values, and provides a simple string representation.
*
* See also [original guide][1]
*
* [1]:http://docs.python.org/dev/library/argparse.html#the-namespace-object
**/
'use strict';
var $$ = require('./utils');
/**
* new Namespace(options)
* - options(object): predefined propertis for result object
*
**/
var Namespace = module.exports = function Namespace(options) {
$$.extend(this, options);
};
/**
* Namespace#isset(key) -> Boolean
* - key (string|number): property name
*
* Tells whenever `namespace` contains given `key` or not.
**/
Namespace.prototype.isset = function (key) {
return $$.has(this, key);
};
/**
* Namespace#set(key, value) -> self
* -key (string|number|object): propery name
* -value (mixed): new property value
*
* Set the property named key with value.
* If key object then set all key properties to namespace object
**/
Namespace.prototype.set = function (key, value) {
if (typeof (key) === 'object') {
$$.extend(this, key);
} else {
this[key] = value;
}
return this;
};
/**
* Namespace#get(key, defaultValue) -> mixed
* - key (string|number): property name
* - defaultValue (mixed): default value
*
* Return the property key or defaulValue if not set
**/
Namespace.prototype.get = function (key, defaultValue) {
return !this[key] ? defaultValue : this[key];
};
/**
* Namespace#unset(key, defaultValue) -> mixed
* - key (string|number): property name
* - defaultValue (mixed): default value
*
* Return data[key](and delete it) or defaultValue
**/
Namespace.prototype.unset = function (key, defaultValue) {
var value = this[key];
if (value !== null) {
delete this[key];
return value;
}
return defaultValue;
};
node_modules/argparse/lib/utils.js deleted 100644 → 0
+ 0
- 57
View file @ b807a4c1
'use strict';
exports.repeat = function (str, num) {
var result = '';
for (var i = 0; i < num; i++) { result += str; }
return result;
};
exports.arrayEqual = function (a, b) {
if (a.length !== b.length) { return false; }
for (var i = 0; i < a.length; i++) {
if (a[i] !== b[i]) { return false; }
}
return true;
};
exports.trimChars = function (str, chars) {
var start = 0;
var end = str.length - 1;
while (chars.indexOf(str.charAt(start)) >= 0) { start++; }
while (chars.indexOf(str.charAt(end)) >= 0) { end--; }
return str.slice(start, end + 1);
};
exports.capitalize = function (str) {
return str.charAt(0).toUpperCase() + str.slice(1);
};
exports.arrayUnion = function () {
var result = [];
for (var i = 0, values = {}; i < arguments.length; i++) {
var arr = arguments[i];
for (var j = 0; j < arr.length; j++) {
if (!values[arr[j]]) {
values[arr[j]] = true;
result.push(arr[j]);
}
}
}
return result;
};
function has(obj, key) {
return Object.prototype.hasOwnProperty.call(obj, key);
}
exports.has = has;
exports.extend = function (dest, src) {
for (var i in src) {
if (has(src, i)) { dest[i] = src[i]; }
}
};
exports.trimEnd = function (str) {
return str.replace(/\s+$/g, '');
};
node_modules/argparse/package.json deleted 100644 → 0
+ 0
- 34
View file @ b807a4c1
{
"name": "argparse",
"description": "Very powerful CLI arguments parser. Native port of argparse - python's options parsing library",
"version": "1.0.10",
"keywords": [
"cli",
"parser",
"argparse",
"option",
"args"
],
"contributors": [
"Eugene Shkuropat",
"Paul Jacobson"
],
"files": [
"index.js",
"lib/"
],
"license": "MIT",
"repository": "nodeca/argparse",
"scripts": {
"test": "make test"
},
"dependencies": {
"sprintf-js": "~1.0.2"
},
"devDependencies": {
"eslint": "^2.13.1",
"istanbul": "^0.4.5",
"mocha": "^3.1.0",
"ndoc": "^5.0.1"
}
}
node_modules/astral-regex/index.d.ts deleted 100644 → 0
+ 0
- 28
View file @ b807a4c1
declare namespace astralRegex {
interface Options {
/**
Only match an exact string. Useful with `RegExp#test()` to check if a string is a astral symbol. Default: `false` _(Matches any astral symbols in a string)_
*/
readonly exact?: boolean;
}
}
/**
Regular expression for matching [astral symbols](https://everything2.com/title/astral+plane).
@returns A `RegExp` for matching astral symbols.
@example
```
import astralRegex = require('astral-regex');
astralRegex({exact: true}).test('🦄');
//=> true
'foo 🦄 💩 bar'.match(astralRegex());
//=> ['🦄', '💩']
```
*/
declare function astralRegex(options?: astralRegex.Options): RegExp;
export = astralRegex;
node_modules/astral-regex/index.js deleted 100644 → 0
+ 0
- 6
View file @ b807a4c1
'use strict';
const regex = '[\uD800-\uDBFF][\uDC00-\uDFFF]';
const astralRegex = options => options && options.exact ? new RegExp(`^${regex}$`) : new RegExp(regex, 'g');
module.exports = astralRegex;
node_modules/astral-regex/license deleted 100644 → 0
+ 0
- 9
View file @ b807a4c1
MIT License
Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
node_modules/astral-regex/package.json deleted 100644 → 0
+ 0
- 33
View file @ b807a4c1
{
"name": "astral-regex",
"version": "2.0.0",
"description": "Regular expression for matching astral symbols",
"license": "MIT",
"repository": "kevva/astral-regex",
"author": {
"name": "Kevin Mårtensson",
"email": "kevinmartensson@gmail.com",
"url": "github.com/kevva"
},
"engines": {
"node": ">=8"
},
"scripts": {
"test": "xo && ava && tsd"
},
"files": [
"index.js",
"index.d.ts"
],
"keywords": [
"astral",
"emoji",
"regex",
"surrogate"
],
"devDependencies": {
"ava": "^1.4.1",
"tsd": "^0.7.2",
"xo": "^0.24.0"
}
}
node_modules/astral-regex/readme.md deleted 100644 → 0
+ 0
- 46
View file @ b807a4c1
# astral-regex [![Build Status](https://travis-ci.org/kevva/astral-regex.svg?branch=master)](https://travis-ci.org/kevva/astral-regex)
> Regular expression for matching [astral symbols](https://everything2.com/title/astral+plane)
## Install
```
$ npm install astral-regex
```
## Usage
```js
const astralRegex = require('astral-regex');
astralRegex({exact: true}).test('🦄');
//=> true
'foo 🦄 💩 bar'.match(astralRegex());
//=> ['🦄', '💩']
```
## API
### astralRegex([options])
Returns a `RegExp` for matching astral symbols.
#### options
Type: `Object`
##### exact
Type: `boolean`<br>
Default: `false` *(Matches any astral symbols in a string)*
Only match an exact string. Useful with `RegExp#test()` to check if a string is a astral symbol.
## License
MIT © [Kevin Mårtensson](https://github.com/kevva)
node_modules/body-parser/HISTORY.md
+ 0
- 42
View file @ 4806fefb
1.20.0 / 2022-04-02
===================
* Fix error message for json parse whitespace in `strict`
* Fix internal error when inflated body exceeds limit
* Prevent loss of async hooks context
* Prevent hanging when request already read
* deps: depd@2.0.0
- Replace internal `eval` usage with `Function` constructor
- Use instance methods on `process` to check for listeners
* deps: http-errors@2.0.0
- deps: depd@2.0.0
- deps: statuses@2.0.1
* deps: on-finished@2.4.1
* deps: qs@6.10.3
* deps: raw-body@2.5.1
- deps: http-errors@2.0.0
1.19.2 / 2022-02-15
===================
* deps: bytes@3.1.2
* deps: qs@6.9.7
* Fix handling of `__proto__` keys
* deps: raw-body@2.4.3
- deps: bytes@3.1.2
1.19.1 / 2021-12-10
===================
* deps: bytes@3.1.1
* deps: http-errors@1.8.1
- deps: inherits@2.0.4
- deps: toidentifier@1.0.1
- deps: setprototypeof@1.2.0
* deps: qs@6.9.6
* deps: raw-body@2.4.2
- deps: bytes@3.1.1
- deps: http-errors@1.8.1
* deps: safe-buffer@5.2.1
* deps: type-is@~1.6.18
1.19.0 / 2019-04-25
===================
......
node_modules/body-parser/README.md
+ 12
- 33
View file @ 4806fefb
......@@ -2,7 +2,7 @@
[![NPM Version][npm-image]][npm-url]
[![NPM Downloads][downloads-image]][downloads-url]
[![Build Status][github-actions-ci-image]][github-actions-ci-url]
[![Build Status][travis-image]][travis-url]
[![Test Coverage][coveralls-image]][coveralls-url]
Node.js body parsing middleware.
......@@ -49,6 +49,8 @@ $ npm install body-parser
## API
<!-- eslint-disable no-unused-vars -->
```js
var bodyParser = require('body-parser')
```
......@@ -279,15 +281,14 @@ encoding of the request. The parsing can be aborted by throwing an error.
## Errors
The middlewares provided by this module create errors using the
[`http-errors` module](https://www.npmjs.com/package/http-errors). The errors
will typically have a `status`/`statusCode` property that contains the suggested
HTTP response code, an `expose` property to determine if the `message` property
should be displayed to the client, a `type` property to determine the type of
error without matching against the `message`, and a `body` property containing
the read body, if available.
The middlewares provided by this module create errors depending on the error
condition during parsing. The errors will typically have a `status`/`statusCode`
property that contains the suggested HTTP response code, an `expose` property
to determine if the `message` property should be displayed to the client, a
`type` property to determine the type of error without matching against the
`message`, and a `body` property containing the read body, if available.
The following are the common errors created, though any error can come through
The following are the common errors emitted, though any error can come through
for various reasons.
### content encoding unsupported
......@@ -298,20 +299,6 @@ contained an encoding but the "inflation" option was set to `false`. The
`'encoding.unsupported'`, and the `charset` property will be set to the
encoding that is unsupported.
### entity parse failed
This error will occur when the request contained an entity that could not be
parsed by the middleware. The `status` property is set to `400`, the `type`
property is set to `'entity.parse.failed'`, and the `body` property is set to
the entity value that failed parsing.
### entity verify failed
This error will occur when the request contained an entity that could not be
failed verification by the defined `verify` option. The `status` property is
set to `403`, the `type` property is set to `'entity.verify.failed'`, and the
`body` property is set to the entity value that failed verification.
### request aborted
This error will occur when the request is aborted by the client before reading
......@@ -342,14 +329,6 @@ to this middleware. This module operates directly on bytes only and you cannot
call `req.setEncoding` when using this module. The `status` property is set to
`500` and the `type` property is set to `'stream.encoding.set'`.
### stream is not readable
This error will occur when the request is no longer readable when this middleware
attempts to read it. This typically means something other than a middleware from
this module read the reqest body already and the middleware was also configured to
read the same request. The `status` property is set to `500` and the `type`
property is set to `'stream.not.readable'`.
### too many parameters
This error will occur when the content of the request exceeds the configured
......@@ -456,9 +435,9 @@ app.use(bodyParser.text({ type: 'text/html' }))
[npm-image]: https://img.shields.io/npm/v/body-parser.svg
[npm-url]: https://npmjs.org/package/body-parser
[travis-image]: https://img.shields.io/travis/expressjs/body-parser/master.svg
[travis-url]: https://travis-ci.org/expressjs/body-parser
[coveralls-image]: https://img.shields.io/coveralls/expressjs/body-parser/master.svg
[coveralls-url]: https://coveralls.io/r/expressjs/body-parser?branch=master
[downloads-image]: https://img.shields.io/npm/dm/body-parser.svg
[downloads-url]: https://npmjs.org/package/body-parser
[github-actions-ci-image]: https://img.shields.io/github/workflow/status/expressjs/body-parser/ci/master?label=ci
[github-actions-ci-url]: https://github.com/expressjs/body-parser/actions/workflows/ci.yml
node_modules/body-parser/SECURITY.md deleted 100644 → 0
+ 0
- 25
View file @ b807a4c1
# Security Policies and Procedures
## Reporting a Bug
The Express team and community take all security bugs seriously. Thank you
for improving the security of Express. We appreciate your efforts and
responsible disclosure and will make every effort to acknowledge your
contributions.
Report security bugs by emailing the current owner(s) of `body-parser`. This
information can be found in the npm registry using the command
`npm owner ls body-parser`.
If unsure or unable to get the information from the above, open an issue
in the [project issue tracker](https://github.com/expressjs/body-parser/issues)
asking for the current contact information.
To ensure the timely response to your report, please ensure that the entirety
of the report is contained within the email body and not solely behind a web
link or an attachment.
At least one owner will acknowledge your email within 48 hours, and will send a
more detailed response within 48 hours indicating the next steps in handling
your report. After the initial reply to your report, the owners will
endeavor to keep you informed of the progress towards a fix and full
announcement, and may ask for additional information or guidance.
node_modules/body-parser/lib/read.js
+ 2
- 26
View file @ 4806fefb
......@@ -12,11 +12,9 @@
*/
var createError = require('http-errors')
var destroy = require('destroy')
var getBody = require('raw-body')
var iconv = require('iconv-lite')
var onFinished = require('on-finished')
var unpipe = require('unpipe')
var zlib = require('zlib')
/**
......@@ -91,14 +89,9 @@ function read (req, res, next, parse, debug, options) {
_error = createError(400, error)
}
// unpipe from stream and destroy
if (stream !== req) {
unpipe(req)
destroy(stream, true)
}
// read off entire request
dump(req, function onfinished () {
stream.resume()
onFinished(req, function onfinished () {
next(createError(400, _error))
})
return
......@@ -186,20 +179,3 @@ function contentstream (req, debug, inflate) {
return stream
}
/**
* Dump the contents of a request.
*
* @param {object} req
* @param {function} callback
* @api private
*/
function dump (req, callback) {
if (onFinished.isFinished(req)) {
callback(null)
} else {
onFinished(req, callback)
req.resume()
}
}
node_modules/body-parser/lib/types/json.js
+ 4
- 10
View file @ 4806fefb
......@@ -37,7 +37,7 @@ module.exports = json
* %x0D ) ; Carriage return
*/
var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/ // eslint-disable-line no-control-regex
var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*(.)/ // eslint-disable-line no-control-regex
/**
* Create a middleware to parse JSON bodies.
......@@ -122,7 +122,7 @@ function json (options) {
// assert charset per RFC 7159 sec 8.1
var charset = getCharset(req) || 'utf-8'
if (charset.slice(0, 4) !== 'utf-') {
if (charset.substr(0, 4) !== 'utf-') {
debug('invalid charset')
next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
charset: charset,
......@@ -152,9 +152,7 @@ function json (options) {
function createStrictSyntaxError (str, char) {
var index = str.indexOf(char)
var partial = index !== -1
? str.substring(0, index) + '#'
: ''
var partial = str.substring(0, index) + '#'
try {
JSON.parse(partial); /* istanbul ignore next */ throw new SyntaxError('strict violation')
......@@ -175,11 +173,7 @@ function createStrictSyntaxError (str, char) {
*/
function firstchar (str) {
var match = FIRST_CHAR_REGEXP.exec(str)
return match
? match[1]
: undefined
return FIRST_CHAR_REGEXP.exec(str)[1]
}
/**
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Dies ist die Gitlab-Instanz des Transferportals der Hochschule für Technik Stuttgart. Hier geht es zurück zum Portal