mirror of
https://code.forgejo.org/actions/setup-node.git
synced 2025-05-21 13:34:46 +00:00
.
This commit is contained in:
eric sciple
parent
9fff29ba6c
commit
00c3b50fca
7278 changed files with 0 additions and 1778943 deletions
451
node_modules/verror/lib/verror.js
generated
vendored
451
node_modules/verror/lib/verror.js
generated
vendored
|
|
@ -1,451 +0,0 @@
|
|||
/*
|
||||
* verror.js: richer JavaScript errors
|
||||
*/
|
||||
|
||||
var mod_assertplus = require('assert-plus');
|
||||
var mod_util = require('util');
|
||||
|
||||
var mod_extsprintf = require('extsprintf');
|
||||
var mod_isError = require('core-util-is').isError;
|
||||
var sprintf = mod_extsprintf.sprintf;
|
||||
|
||||
/*
|
||||
* Public interface
|
||||
*/
|
||||
|
||||
/* So you can 'var VError = require('verror')' */
|
||||
module.exports = VError;
|
||||
/* For compatibility */
|
||||
VError.VError = VError;
|
||||
/* Other exported classes */
|
||||
VError.SError = SError;
|
||||
VError.WError = WError;
|
||||
VError.MultiError = MultiError;
|
||||
|
||||
/*
|
||||
* Common function used to parse constructor arguments for VError, WError, and
|
||||
* SError. Named arguments to this function:
|
||||
*
|
||||
* strict force strict interpretation of sprintf arguments, even
|
||||
* if the options in "argv" don't say so
|
||||
*
|
||||
* argv error's constructor arguments, which are to be
|
||||
* interpreted as described in README.md. For quick
|
||||
* reference, "argv" has one of the following forms:
|
||||
*
|
||||
* [ sprintf_args... ] (argv[0] is a string)
|
||||
* [ cause, sprintf_args... ] (argv[0] is an Error)
|
||||
* [ options, sprintf_args... ] (argv[0] is an object)
|
||||
*
|
||||
* This function normalizes these forms, producing an object with the following
|
||||
* properties:
|
||||
*
|
||||
* options equivalent to "options" in third form. This will never
|
||||
* be a direct reference to what the caller passed in
|
||||
* (i.e., it may be a shallow copy), so it can be freely
|
||||
* modified.
|
||||
*
|
||||
* shortmessage result of sprintf(sprintf_args), taking options.strict
|
||||
* into account as described in README.md.
|
||||
*/
|
||||
function parseConstructorArguments(args)
|
||||
{
|
||||
var argv, options, sprintf_args, shortmessage, k;
|
||||
|
||||
mod_assertplus.object(args, 'args');
|
||||
mod_assertplus.bool(args.strict, 'args.strict');
|
||||
mod_assertplus.array(args.argv, 'args.argv');
|
||||
argv = args.argv;
|
||||
|
||||
/*
|
||||
* First, figure out which form of invocation we've been given.
|
||||
*/
|
||||
if (argv.length === 0) {
|
||||
options = {};
|
||||
sprintf_args = [];
|
||||
} else if (mod_isError(argv[0])) {
|
||||
options = { 'cause': argv[0] };
|
||||
sprintf_args = argv.slice(1);
|
||||
} else if (typeof (argv[0]) === 'object') {
|
||||
options = {};
|
||||
for (k in argv[0]) {
|
||||
options[k] = argv[0][k];
|
||||
}
|
||||
sprintf_args = argv.slice(1);
|
||||
} else {
|
||||
mod_assertplus.string(argv[0],
|
||||
'first argument to VError, SError, or WError ' +
|
||||
'constructor must be a string, object, or Error');
|
||||
options = {};
|
||||
sprintf_args = argv;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now construct the error's message.
|
||||
*
|
||||
* extsprintf (which we invoke here with our caller's arguments in order
|
||||
* to construct this Error's message) is strict in its interpretation of
|
||||
* values to be processed by the "%s" specifier. The value passed to
|
||||
* extsprintf must actually be a string or something convertible to a
|
||||
* String using .toString(). Passing other values (notably "null" and
|
||||
* "undefined") is considered a programmer error. The assumption is
|
||||
* that if you actually want to print the string "null" or "undefined",
|
||||
* then that's easy to do that when you're calling extsprintf; on the
|
||||
* other hand, if you did NOT want that (i.e., there's actually a bug
|
||||
* where the program assumes some variable is non-null and tries to
|
||||
* print it, which might happen when constructing a packet or file in
|
||||
* some specific format), then it's better to stop immediately than
|
||||
* produce bogus output.
|
||||
*
|
||||
* However, sometimes the bug is only in the code calling VError, and a
|
||||
* programmer might prefer to have the error message contain "null" or
|
||||
* "undefined" rather than have the bug in the error path crash the
|
||||
* program (making the first bug harder to identify). For that reason,
|
||||
* by default VError converts "null" or "undefined" arguments to their
|
||||
* string representations and passes those to extsprintf. Programmers
|
||||
* desiring the strict behavior can use the SError class or pass the
|
||||
* "strict" option to the VError constructor.
|
||||
*/
|
||||
mod_assertplus.object(options);
|
||||
if (!options.strict && !args.strict) {
|
||||
sprintf_args = sprintf_args.map(function (a) {
|
||||
return (a === null ? 'null' :
|
||||
a === undefined ? 'undefined' : a);
|
||||
});
|
||||
}
|
||||
|
||||
if (sprintf_args.length === 0) {
|
||||
shortmessage = '';
|
||||
} else {
|
||||
shortmessage = sprintf.apply(null, sprintf_args);
|
||||
}
|
||||
|
||||
return ({
|
||||
'options': options,
|
||||
'shortmessage': shortmessage
|
||||
});
|
||||
}
|
||||
|
||||
/*
|
||||
* See README.md for reference documentation.
|
||||
*/
|
||||
function VError()
|
||||
{
|
||||
var args, obj, parsed, cause, ctor, message, k;
|
||||
|
||||
args = Array.prototype.slice.call(arguments, 0);
|
||||
|
||||
/*
|
||||
* This is a regrettable pattern, but JavaScript's built-in Error class
|
||||
* is defined to work this way, so we allow the constructor to be called
|
||||
* without "new".
|
||||
*/
|
||||
if (!(this instanceof VError)) {
|
||||
obj = Object.create(VError.prototype);
|
||||
VError.apply(obj, arguments);
|
||||
return (obj);
|
||||
}
|
||||
|
||||
/*
|
||||
* For convenience and backwards compatibility, we support several
|
||||
* different calling forms. Normalize them here.
|
||||
*/
|
||||
parsed = parseConstructorArguments({
|
||||
'argv': args,
|
||||
'strict': false
|
||||
});
|
||||
|
||||
/*
|
||||
* If we've been given a name, apply it now.
|
||||
*/
|
||||
if (parsed.options.name) {
|
||||
mod_assertplus.string(parsed.options.name,
|
||||
'error\'s "name" must be a string');
|
||||
this.name = parsed.options.name;
|
||||
}
|
||||
|
||||
/*
|
||||
* For debugging, we keep track of the original short message (attached
|
||||
* this Error particularly) separately from the complete message (which
|
||||
* includes the messages of our cause chain).
|
||||
*/
|
||||
this.jse_shortmsg = parsed.shortmessage;
|
||||
message = parsed.shortmessage;
|
||||
|
||||
/*
|
||||
* If we've been given a cause, record a reference to it and update our
|
||||
* message appropriately.
|
||||
*/
|
||||
cause = parsed.options.cause;
|
||||
if (cause) {
|
||||
mod_assertplus.ok(mod_isError(cause), 'cause is not an Error');
|
||||
this.jse_cause = cause;
|
||||
|
||||
if (!parsed.options.skipCauseMessage) {
|
||||
message += ': ' + cause.message;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If we've been given an object with properties, shallow-copy that
|
||||
* here. We don't want to use a deep copy in case there are non-plain
|
||||
* objects here, but we don't want to use the original object in case
|
||||
* the caller modifies it later.
|
||||
*/
|
||||
this.jse_info = {};
|
||||
if (parsed.options.info) {
|
||||
for (k in parsed.options.info) {
|
||||
this.jse_info[k] = parsed.options.info[k];
|
||||
}
|
||||
}
|
||||
|
||||
this.message = message;
|
||||
Error.call(this, message);
|
||||
|
||||
if (Error.captureStackTrace) {
|
||||
ctor = parsed.options.constructorOpt || this.constructor;
|
||||
Error.captureStackTrace(this, ctor);
|
||||
}
|
||||
|
||||
return (this);
|
||||
}
|
||||
|
||||
mod_util.inherits(VError, Error);
|
||||
VError.prototype.name = 'VError';
|
||||
|
||||
VError.prototype.toString = function ve_toString()
|
||||
{
|
||||
var str = (this.hasOwnProperty('name') && this.name ||
|
||||
this.constructor.name || this.constructor.prototype.name);
|
||||
if (this.message)
|
||||
str += ': ' + this.message;
|
||||
|
||||
return (str);
|
||||
};
|
||||
|
||||
/*
|
||||
* This method is provided for compatibility. New callers should use
|
||||
* VError.cause() instead. That method also uses the saner `null` return value
|
||||
* when there is no cause.
|
||||
*/
|
||||
VError.prototype.cause = function ve_cause()
|
||||
{
|
||||
var cause = VError.cause(this);
|
||||
return (cause === null ? undefined : cause);
|
||||
};
|
||||
|
||||
/*
|
||||
* Static methods
|
||||
*
|
||||
* These class-level methods are provided so that callers can use them on
|
||||
* instances of Errors that are not VErrors. New interfaces should be provided
|
||||
* only using static methods to eliminate the class of programming mistake where
|
||||
* people fail to check whether the Error object has the corresponding methods.
|
||||
*/
|
||||
|
||||
VError.cause = function (err)
|
||||
{
|
||||
mod_assertplus.ok(mod_isError(err), 'err must be an Error');
|
||||
return (mod_isError(err.jse_cause) ? err.jse_cause : null);
|
||||
};
|
||||
|
||||
VError.info = function (err)
|
||||
{
|
||||
var rv, cause, k;
|
||||
|
||||
mod_assertplus.ok(mod_isError(err), 'err must be an Error');
|
||||
cause = VError.cause(err);
|
||||
if (cause !== null) {
|
||||
rv = VError.info(cause);
|
||||
} else {
|
||||
rv = {};
|
||||
}
|
||||
|
||||
if (typeof (err.jse_info) == 'object' && err.jse_info !== null) {
|
||||
for (k in err.jse_info) {
|
||||
rv[k] = err.jse_info[k];
|
||||
}
|
||||
}
|
||||
|
||||
return (rv);
|
||||
};
|
||||
|
||||
VError.findCauseByName = function (err, name)
|
||||
{
|
||||
var cause;
|
||||
|
||||
mod_assertplus.ok(mod_isError(err), 'err must be an Error');
|
||||
mod_assertplus.string(name, 'name');
|
||||
mod_assertplus.ok(name.length > 0, 'name cannot be empty');
|
||||
|
||||
for (cause = err; cause !== null; cause = VError.cause(cause)) {
|
||||
mod_assertplus.ok(mod_isError(cause));
|
||||
if (cause.name == name) {
|
||||
return (cause);
|
||||
}
|
||||
}
|
||||
|
||||
return (null);
|
||||
};
|
||||
|
||||
VError.hasCauseWithName = function (err, name)
|
||||
{
|
||||
return (VError.findCauseByName(err, name) !== null);
|
||||
};
|
||||
|
||||
VError.fullStack = function (err)
|
||||
{
|
||||
mod_assertplus.ok(mod_isError(err), 'err must be an Error');
|
||||
|
||||
var cause = VError.cause(err);
|
||||
|
||||
if (cause) {
|
||||
return (err.stack + '\ncaused by: ' + VError.fullStack(cause));
|
||||
}
|
||||
|
||||
return (err.stack);
|
||||
};
|
||||
|
||||
VError.errorFromList = function (errors)
|
||||
{
|
||||
mod_assertplus.arrayOfObject(errors, 'errors');
|
||||
|
||||
if (errors.length === 0) {
|
||||
return (null);
|
||||
}
|
||||
|
||||
errors.forEach(function (e) {
|
||||
mod_assertplus.ok(mod_isError(e));
|
||||
});
|
||||
|
||||
if (errors.length == 1) {
|
||||
return (errors[0]);
|
||||
}
|
||||
|
||||
return (new MultiError(errors));
|
||||
};
|
||||
|
||||
VError.errorForEach = function (err, func)
|
||||
{
|
||||
mod_assertplus.ok(mod_isError(err), 'err must be an Error');
|
||||
mod_assertplus.func(func, 'func');
|
||||
|
||||
if (err instanceof MultiError) {
|
||||
err.errors().forEach(function iterError(e) { func(e); });
|
||||
} else {
|
||||
func(err);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* SError is like VError, but stricter about types. You cannot pass "null" or
|
||||
* "undefined" as string arguments to the formatter.
|
||||
*/
|
||||
function SError()
|
||||
{
|
||||
var args, obj, parsed, options;
|
||||
|
||||
args = Array.prototype.slice.call(arguments, 0);
|
||||
if (!(this instanceof SError)) {
|
||||
obj = Object.create(SError.prototype);
|
||||
SError.apply(obj, arguments);
|
||||
return (obj);
|
||||
}
|
||||
|
||||
parsed = parseConstructorArguments({
|
||||
'argv': args,
|
||||
'strict': true
|
||||
});
|
||||
|
||||
options = parsed.options;
|
||||
VError.call(this, options, '%s', parsed.shortmessage);
|
||||
|
||||
return (this);
|
||||
}
|
||||
|
||||
/*
|
||||
* We don't bother setting SError.prototype.name because once constructed,
|
||||
* SErrors are just like VErrors.
|
||||
*/
|
||||
mod_util.inherits(SError, VError);
|
||||
|
||||
|
||||
/*
|
||||
* Represents a collection of errors for the purpose of consumers that generally
|
||||
* only deal with one error. Callers can extract the individual errors
|
||||
* contained in this object, but may also just treat it as a normal single
|
||||
* error, in which case a summary message will be printed.
|
||||
*/
|
||||
function MultiError(errors)
|
||||
{
|
||||
mod_assertplus.array(errors, 'list of errors');
|
||||
mod_assertplus.ok(errors.length > 0, 'must be at least one error');
|
||||
this.ase_errors = errors;
|
||||
|
||||
VError.call(this, {
|
||||
'cause': errors[0]
|
||||
}, 'first of %d error%s', errors.length, errors.length == 1 ? '' : 's');
|
||||
}
|
||||
|
||||
mod_util.inherits(MultiError, VError);
|
||||
MultiError.prototype.name = 'MultiError';
|
||||
|
||||
MultiError.prototype.errors = function me_errors()
|
||||
{
|
||||
return (this.ase_errors.slice(0));
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* See README.md for reference details.
|
||||
*/
|
||||
function WError()
|
||||
{
|
||||
var args, obj, parsed, options;
|
||||
|
||||
args = Array.prototype.slice.call(arguments, 0);
|
||||
if (!(this instanceof WError)) {
|
||||
obj = Object.create(WError.prototype);
|
||||
WError.apply(obj, args);
|
||||
return (obj);
|
||||
}
|
||||
|
||||
parsed = parseConstructorArguments({
|
||||
'argv': args,
|
||||
'strict': false
|
||||
});
|
||||
|
||||
options = parsed.options;
|
||||
options['skipCauseMessage'] = true;
|
||||
VError.call(this, options, '%s', parsed.shortmessage);
|
||||
|
||||
return (this);
|
||||
}
|
||||
|
||||
mod_util.inherits(WError, VError);
|
||||
WError.prototype.name = 'WError';
|
||||
|
||||
WError.prototype.toString = function we_toString()
|
||||
{
|
||||
var str = (this.hasOwnProperty('name') && this.name ||
|
||||
this.constructor.name || this.constructor.prototype.name);
|
||||
if (this.message)
|
||||
str += ': ' + this.message;
|
||||
if (this.jse_cause && this.jse_cause.message)
|
||||
str += '; caused by ' + this.jse_cause.toString();
|
||||
|
||||
return (str);
|
||||
};
|
||||
|
||||
/*
|
||||
* For purely historical reasons, WError's cause() function allows you to set
|
||||
* the cause.
|
||||
*/
|
||||
WError.prototype.cause = function we_cause(c)
|
||||
{
|
||||
if (mod_isError(c))
|
||||
this.jse_cause = c;
|
||||
|
||||
return (this.jse_cause);
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue