Deployed the page to Github Pages.
This commit is contained in:
parent
1d79754e93
commit
2c89899458
SSH key fingerprint:
SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
53
node_modules/jsprim/CHANGES.md
generated
vendored
Normal file
53
node_modules/jsprim/CHANGES.md
generated
vendored
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
# Changelog
|
||||
|
||||
## not yet released
|
||||
|
||||
None yet.
|
||||
|
||||
## v1.4.2 (2021-11-29)
|
||||
|
||||
* #35 Backport json-schema 0.4.0 to version 1.4.x
|
||||
|
||||
## v1.4.1 (2017-08-02)
|
||||
|
||||
* #21 Update verror dep
|
||||
* #22 Update extsprintf dependency
|
||||
* #23 update contribution guidelines
|
||||
|
||||
## v1.4.0 (2017-03-13)
|
||||
|
||||
* #7 Add parseInteger() function for safer number parsing
|
||||
|
||||
## v1.3.1 (2016-09-12)
|
||||
|
||||
* #13 Incompatible with webpack
|
||||
|
||||
## v1.3.0 (2016-06-22)
|
||||
|
||||
* #14 add safer version of hasOwnProperty()
|
||||
* #15 forEachKey() should ignore inherited properties
|
||||
|
||||
## v1.2.2 (2015-10-15)
|
||||
|
||||
* #11 NPM package shouldn't include any code that does `require('JSV')`
|
||||
* #12 jsl.node.conf missing definition for "module"
|
||||
|
||||
## v1.2.1 (2015-10-14)
|
||||
|
||||
* #8 odd date parsing behaviour
|
||||
|
||||
## v1.2.0 (2015-10-13)
|
||||
|
||||
* #9 want function for returning RFC1123 dates
|
||||
|
||||
## v1.1.0 (2015-09-02)
|
||||
|
||||
* #6 a new suite of hrtime manipulation routines: `hrtimeAdd()`,
|
||||
`hrtimeAccum()`, `hrtimeNanosec()`, `hrtimeMicrosec()` and
|
||||
`hrtimeMillisec()`.
|
||||
|
||||
## v1.0.0 (2015-09-01)
|
||||
|
||||
First tracked release. Includes everything in previous releases, plus:
|
||||
|
||||
* #4 want function for merging objects
|
||||
19
node_modules/jsprim/CONTRIBUTING.md
generated
vendored
Normal file
19
node_modules/jsprim/CONTRIBUTING.md
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
# Contributing
|
||||
|
||||
This repository uses [cr.joyent.us](https://cr.joyent.us) (Gerrit) for new
|
||||
changes. Anyone can submit changes. To get started, see the [cr.joyent.us user
|
||||
guide](https://github.com/joyent/joyent-gerrit/blob/master/docs/user/README.md).
|
||||
This repo does not use GitHub pull requests.
|
||||
|
||||
See the [Joyent Engineering
|
||||
Guidelines](https://github.com/joyent/eng/blob/master/docs/index.md) for general
|
||||
best practices expected in this repository.
|
||||
|
||||
Contributions should be "make prepush" clean. The "prepush" target runs the
|
||||
"check" target, which requires these separate tools:
|
||||
|
||||
* https://github.com/davepacheco/jsstyle
|
||||
* https://github.com/davepacheco/javascriptlint
|
||||
|
||||
If you're changing something non-trivial or user-facing, you may want to submit
|
||||
an issue first.
|
||||
19
node_modules/jsprim/LICENSE
generated
vendored
Normal file
19
node_modules/jsprim/LICENSE
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
Copyright (c) 2012, Joyent, Inc. All rights reserved.
|
||||
|
||||
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
|
||||
287
node_modules/jsprim/README.md
generated
vendored
Normal file
287
node_modules/jsprim/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,287 @@
|
|||
# jsprim: utilities for primitive JavaScript types
|
||||
|
||||
This module provides miscellaneous facilities for working with strings,
|
||||
numbers, dates, and objects and arrays of these basic types.
|
||||
|
||||
|
||||
### deepCopy(obj)
|
||||
|
||||
Creates a deep copy of a primitive type, object, or array of primitive types.
|
||||
|
||||
|
||||
### deepEqual(obj1, obj2)
|
||||
|
||||
Returns whether two objects are equal.
|
||||
|
||||
|
||||
### isEmpty(obj)
|
||||
|
||||
Returns true if the given object has no properties and false otherwise. This
|
||||
is O(1) (unlike `Object.keys(obj).length === 0`, which is O(N)).
|
||||
|
||||
### hasKey(obj, key)
|
||||
|
||||
Returns true if the given object has an enumerable, non-inherited property
|
||||
called `key`. [For information on enumerability and ownership of properties, see
|
||||
the MDN
|
||||
documentation.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties)
|
||||
|
||||
### forEachKey(obj, callback)
|
||||
|
||||
Like Array.forEach, but iterates enumerable, owned properties of an object
|
||||
rather than elements of an array. Equivalent to:
|
||||
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
callback(key, obj[key]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
### flattenObject(obj, depth)
|
||||
|
||||
Flattens an object up to a given level of nesting, returning an array of arrays
|
||||
of length "depth + 1", where the first "depth" elements correspond to flattened
|
||||
columns and the last element contains the remaining object . For example:
|
||||
|
||||
flattenObject({
|
||||
'I': {
|
||||
'A': {
|
||||
'i': {
|
||||
'datum1': [ 1, 2 ],
|
||||
'datum2': [ 3, 4 ]
|
||||
},
|
||||
'ii': {
|
||||
'datum1': [ 3, 4 ]
|
||||
}
|
||||
},
|
||||
'B': {
|
||||
'i': {
|
||||
'datum1': [ 5, 6 ]
|
||||
},
|
||||
'ii': {
|
||||
'datum1': [ 7, 8 ],
|
||||
'datum2': [ 3, 4 ],
|
||||
},
|
||||
'iii': {
|
||||
}
|
||||
}
|
||||
},
|
||||
'II': {
|
||||
'A': {
|
||||
'i': {
|
||||
'datum1': [ 1, 2 ],
|
||||
'datum2': [ 3, 4 ]
|
||||
}
|
||||
}
|
||||
}
|
||||
}, 3)
|
||||
|
||||
becomes:
|
||||
|
||||
[
|
||||
[ 'I', 'A', 'i', { 'datum1': [ 1, 2 ], 'datum2': [ 3, 4 ] } ],
|
||||
[ 'I', 'A', 'ii', { 'datum1': [ 3, 4 ] } ],
|
||||
[ 'I', 'B', 'i', { 'datum1': [ 5, 6 ] } ],
|
||||
[ 'I', 'B', 'ii', { 'datum1': [ 7, 8 ], 'datum2': [ 3, 4 ] } ],
|
||||
[ 'I', 'B', 'iii', {} ],
|
||||
[ 'II', 'A', 'i', { 'datum1': [ 1, 2 ], 'datum2': [ 3, 4 ] } ]
|
||||
]
|
||||
|
||||
This function is strict: "depth" must be a non-negative integer and "obj" must
|
||||
be a non-null object with at least "depth" levels of nesting under all keys.
|
||||
|
||||
|
||||
### flattenIter(obj, depth, func)
|
||||
|
||||
This is similar to `flattenObject` except that instead of returning an array,
|
||||
this function invokes `func(entry)` for each `entry` in the array that
|
||||
`flattenObject` would return. `flattenIter(obj, depth, func)` is logically
|
||||
equivalent to `flattenObject(obj, depth).forEach(func)`. Importantly, this
|
||||
version never constructs the full array. Its memory usage is O(depth) rather
|
||||
than O(n) (where `n` is the number of flattened elements).
|
||||
|
||||
There's another difference between `flattenObject` and `flattenIter` that's
|
||||
related to the special case where `depth === 0`. In this case, `flattenObject`
|
||||
omits the array wrapping `obj` (which is regrettable).
|
||||
|
||||
|
||||
### pluck(obj, key)
|
||||
|
||||
Fetch nested property "key" from object "obj", traversing objects as needed.
|
||||
For example, `pluck(obj, "foo.bar.baz")` is roughly equivalent to
|
||||
`obj.foo.bar.baz`, except that:
|
||||
|
||||
1. If traversal fails, the resulting value is undefined, and no error is
|
||||
thrown. For example, `pluck({}, "foo.bar")` is just undefined.
|
||||
2. If "obj" has property "key" directly (without traversing), the
|
||||
corresponding property is returned. For example,
|
||||
`pluck({ 'foo.bar': 1 }, 'foo.bar')` is 1, not undefined. This is also
|
||||
true recursively, so `pluck({ 'a': { 'foo.bar': 1 } }, 'a.foo.bar')` is
|
||||
also 1, not undefined.
|
||||
|
||||
|
||||
### randElt(array)
|
||||
|
||||
Returns an element from "array" selected uniformly at random. If "array" is
|
||||
empty, throws an Error.
|
||||
|
||||
|
||||
### startsWith(str, prefix)
|
||||
|
||||
Returns true if the given string starts with the given prefix and false
|
||||
otherwise.
|
||||
|
||||
|
||||
### endsWith(str, suffix)
|
||||
|
||||
Returns true if the given string ends with the given suffix and false
|
||||
otherwise.
|
||||
|
||||
|
||||
### parseInteger(str, options)
|
||||
|
||||
Parses the contents of `str` (a string) as an integer. On success, the integer
|
||||
value is returned (as a number). On failure, an error is **returned** describing
|
||||
why parsing failed.
|
||||
|
||||
By default, leading and trailing whitespace characters are not allowed, nor are
|
||||
trailing characters that are not part of the numeric representation. This
|
||||
behaviour can be toggled by using the options below. The empty string (`''`) is
|
||||
not considered valid input. If the return value cannot be precisely represented
|
||||
as a number (i.e., is smaller than `Number.MIN_SAFE_INTEGER` or larger than
|
||||
`Number.MAX_SAFE_INTEGER`), an error is returned. Additionally, the string
|
||||
`'-0'` will be parsed as the integer `0`, instead of as the IEEE floating point
|
||||
value `-0`.
|
||||
|
||||
This function accepts both upper and lowercase characters for digits, similar to
|
||||
`parseInt()`, `Number()`, and [strtol(3C)](https://illumos.org/man/3C/strtol).
|
||||
|
||||
The following may be specified in `options`:
|
||||
|
||||
Option | Type | Default | Meaning
|
||||
------------------ | ------- | ------- | ---------------------------
|
||||
base | number | 10 | numeric base (radix) to use, in the range 2 to 36
|
||||
allowSign | boolean | true | whether to interpret any leading `+` (positive) and `-` (negative) characters
|
||||
allowImprecise | boolean | false | whether to accept values that may have lost precision (past `MAX_SAFE_INTEGER` or below `MIN_SAFE_INTEGER`)
|
||||
allowPrefix | boolean | false | whether to interpret the prefixes `0b` (base 2), `0o` (base 8), `0t` (base 10), or `0x` (base 16)
|
||||
allowTrailing | boolean | false | whether to ignore trailing characters
|
||||
trimWhitespace | boolean | false | whether to trim any leading or trailing whitespace/line terminators
|
||||
leadingZeroIsOctal | boolean | false | whether a leading zero indicates octal
|
||||
|
||||
Note that if `base` is unspecified, and `allowPrefix` or `leadingZeroIsOctal`
|
||||
are, then the leading characters can change the default base from 10. If `base`
|
||||
is explicitly specified and `allowPrefix` is true, then the prefix will only be
|
||||
accepted if it matches the specified base. `base` and `leadingZeroIsOctal`
|
||||
cannot be used together.
|
||||
|
||||
**Context:** It's tricky to parse integers with JavaScript's built-in facilities
|
||||
for several reasons:
|
||||
|
||||
- `parseInt()` and `Number()` by default allow the base to be specified in the
|
||||
input string by a prefix (e.g., `0x` for hex).
|
||||
- `parseInt()` allows trailing nonnumeric characters.
|
||||
- `Number(str)` returns 0 when `str` is the empty string (`''`).
|
||||
- Both functions return incorrect values when the input string represents a
|
||||
valid integer outside the range of integers that can be represented precisely.
|
||||
Specifically, `parseInt('9007199254740993')` returns 9007199254740992.
|
||||
- Both functions always accept `-` and `+` signs before the digit.
|
||||
- Some older JavaScript engines always interpret a leading 0 as indicating
|
||||
octal, which can be surprising when parsing input from users who expect a
|
||||
leading zero to be insignificant.
|
||||
|
||||
While each of these may be desirable in some contexts, there are also times when
|
||||
none of them are wanted. `parseInteger()` grants greater control over what
|
||||
input's permissible.
|
||||
|
||||
### iso8601(date)
|
||||
|
||||
Converts a Date object to an ISO8601 date string of the form
|
||||
"YYYY-MM-DDTHH:MM:SS.sssZ". This format is not customizable.
|
||||
|
||||
|
||||
### parseDateTime(str)
|
||||
|
||||
Parses a date expressed as a string, as either a number of milliseconds since
|
||||
the epoch or any string format that Date accepts, giving preference to the
|
||||
former where these two sets overlap (e.g., strings containing small numbers).
|
||||
|
||||
|
||||
### hrtimeDiff(timeA, timeB)
|
||||
|
||||
Given two hrtime readings (as from Node's `process.hrtime()`), where timeA is
|
||||
later than timeB, compute the difference and return that as an hrtime. It is
|
||||
illegal to invoke this for a pair of times where timeB is newer than timeA.
|
||||
|
||||
### hrtimeAdd(timeA, timeB)
|
||||
|
||||
Add two hrtime intervals (as from Node's `process.hrtime()`), returning a new
|
||||
hrtime interval array. This function does not modify either input argument.
|
||||
|
||||
|
||||
### hrtimeAccum(timeA, timeB)
|
||||
|
||||
Add two hrtime intervals (as from Node's `process.hrtime()`), storing the
|
||||
result in `timeA`. This function overwrites (and returns) the first argument
|
||||
passed in.
|
||||
|
||||
|
||||
### hrtimeNanosec(timeA), hrtimeMicrosec(timeA), hrtimeMillisec(timeA)
|
||||
|
||||
This suite of functions converts a hrtime interval (as from Node's
|
||||
`process.hrtime()`) into a scalar number of nanoseconds, microseconds or
|
||||
milliseconds. Results are truncated, as with `Math.floor()`.
|
||||
|
||||
|
||||
### validateJsonObject(schema, object)
|
||||
|
||||
Uses JSON validation (via JSV) to validate the given object against the given
|
||||
schema. On success, returns null. On failure, *returns* (does not throw) a
|
||||
useful Error object.
|
||||
|
||||
|
||||
### extraProperties(object, allowed)
|
||||
|
||||
Check an object for unexpected properties. Accepts the object to check, and an
|
||||
array of allowed property name strings. If extra properties are detected, an
|
||||
array of extra property names is returned. If no properties other than those
|
||||
in the allowed list are present on the object, the returned array will be of
|
||||
zero length.
|
||||
|
||||
### mergeObjects(provided, overrides, defaults)
|
||||
|
||||
Merge properties from objects "provided", "overrides", and "defaults". The
|
||||
intended use case is for functions that accept named arguments in an "args"
|
||||
object, but want to provide some default values and override other values. In
|
||||
that case, "provided" is what the caller specified, "overrides" are what the
|
||||
function wants to override, and "defaults" contains default values.
|
||||
|
||||
The function starts with the values in "defaults", overrides them with the
|
||||
values in "provided", and then overrides those with the values in "overrides".
|
||||
For convenience, any of these objects may be falsey, in which case they will be
|
||||
ignored. The input objects are never modified, but properties in the returned
|
||||
object are not deep-copied.
|
||||
|
||||
For example:
|
||||
|
||||
mergeObjects(undefined, { 'objectMode': true }, { 'highWaterMark': 0 })
|
||||
|
||||
returns:
|
||||
|
||||
{ 'objectMode': true, 'highWaterMark': 0 }
|
||||
|
||||
For another example:
|
||||
|
||||
mergeObjects(
|
||||
{ 'highWaterMark': 16, 'objectMode': 7 }, /* from caller */
|
||||
{ 'objectMode': true }, /* overrides */
|
||||
{ 'highWaterMark': 0 }); /* default */
|
||||
|
||||
returns:
|
||||
|
||||
{ 'objectMode': true, 'highWaterMark': 16 }
|
||||
|
||||
|
||||
# Contributing
|
||||
|
||||
See separate [contribution guidelines](CONTRIBUTING.md).
|
||||
735
node_modules/jsprim/lib/jsprim.js
generated
vendored
Normal file
735
node_modules/jsprim/lib/jsprim.js
generated
vendored
Normal file
|
|
@ -0,0 +1,735 @@
|
|||
/*
|
||||
* lib/jsprim.js: utilities for primitive JavaScript types
|
||||
*/
|
||||
|
||||
var mod_assert = require('assert-plus');
|
||||
var mod_util = require('util');
|
||||
|
||||
var mod_extsprintf = require('extsprintf');
|
||||
var mod_verror = require('verror');
|
||||
var mod_jsonschema = require('json-schema');
|
||||
|
||||
/*
|
||||
* Public interface
|
||||
*/
|
||||
exports.deepCopy = deepCopy;
|
||||
exports.deepEqual = deepEqual;
|
||||
exports.isEmpty = isEmpty;
|
||||
exports.hasKey = hasKey;
|
||||
exports.forEachKey = forEachKey;
|
||||
exports.pluck = pluck;
|
||||
exports.flattenObject = flattenObject;
|
||||
exports.flattenIter = flattenIter;
|
||||
exports.validateJsonObject = validateJsonObjectJS;
|
||||
exports.validateJsonObjectJS = validateJsonObjectJS;
|
||||
exports.randElt = randElt;
|
||||
exports.extraProperties = extraProperties;
|
||||
exports.mergeObjects = mergeObjects;
|
||||
|
||||
exports.startsWith = startsWith;
|
||||
exports.endsWith = endsWith;
|
||||
|
||||
exports.parseInteger = parseInteger;
|
||||
|
||||
exports.iso8601 = iso8601;
|
||||
exports.rfc1123 = rfc1123;
|
||||
exports.parseDateTime = parseDateTime;
|
||||
|
||||
exports.hrtimediff = hrtimeDiff;
|
||||
exports.hrtimeDiff = hrtimeDiff;
|
||||
exports.hrtimeAccum = hrtimeAccum;
|
||||
exports.hrtimeAdd = hrtimeAdd;
|
||||
exports.hrtimeNanosec = hrtimeNanosec;
|
||||
exports.hrtimeMicrosec = hrtimeMicrosec;
|
||||
exports.hrtimeMillisec = hrtimeMillisec;
|
||||
|
||||
|
||||
/*
|
||||
* Deep copy an acyclic *basic* Javascript object. This only handles basic
|
||||
* scalars (strings, numbers, booleans) and arbitrarily deep arrays and objects
|
||||
* containing these. This does *not* handle instances of other classes.
|
||||
*/
|
||||
function deepCopy(obj)
|
||||
{
|
||||
var ret, key;
|
||||
var marker = '__deepCopy';
|
||||
|
||||
if (obj && obj[marker])
|
||||
throw (new Error('attempted deep copy of cyclic object'));
|
||||
|
||||
if (obj && obj.constructor == Object) {
|
||||
ret = {};
|
||||
obj[marker] = true;
|
||||
|
||||
for (key in obj) {
|
||||
if (key == marker)
|
||||
continue;
|
||||
|
||||
ret[key] = deepCopy(obj[key]);
|
||||
}
|
||||
|
||||
delete (obj[marker]);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
if (obj && obj.constructor == Array) {
|
||||
ret = [];
|
||||
obj[marker] = true;
|
||||
|
||||
for (key = 0; key < obj.length; key++)
|
||||
ret.push(deepCopy(obj[key]));
|
||||
|
||||
delete (obj[marker]);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
/*
|
||||
* It must be a primitive type -- just return it.
|
||||
*/
|
||||
return (obj);
|
||||
}
|
||||
|
||||
function deepEqual(obj1, obj2)
|
||||
{
|
||||
if (typeof (obj1) != typeof (obj2))
|
||||
return (false);
|
||||
|
||||
if (obj1 === null || obj2 === null || typeof (obj1) != 'object')
|
||||
return (obj1 === obj2);
|
||||
|
||||
if (obj1.constructor != obj2.constructor)
|
||||
return (false);
|
||||
|
||||
var k;
|
||||
for (k in obj1) {
|
||||
if (!obj2.hasOwnProperty(k))
|
||||
return (false);
|
||||
|
||||
if (!deepEqual(obj1[k], obj2[k]))
|
||||
return (false);
|
||||
}
|
||||
|
||||
for (k in obj2) {
|
||||
if (!obj1.hasOwnProperty(k))
|
||||
return (false);
|
||||
}
|
||||
|
||||
return (true);
|
||||
}
|
||||
|
||||
function isEmpty(obj)
|
||||
{
|
||||
var key;
|
||||
for (key in obj)
|
||||
return (false);
|
||||
return (true);
|
||||
}
|
||||
|
||||
function hasKey(obj, key)
|
||||
{
|
||||
mod_assert.equal(typeof (key), 'string');
|
||||
return (Object.prototype.hasOwnProperty.call(obj, key));
|
||||
}
|
||||
|
||||
function forEachKey(obj, callback)
|
||||
{
|
||||
for (var key in obj) {
|
||||
if (hasKey(obj, key)) {
|
||||
callback(key, obj[key]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function pluck(obj, key)
|
||||
{
|
||||
mod_assert.equal(typeof (key), 'string');
|
||||
return (pluckv(obj, key));
|
||||
}
|
||||
|
||||
function pluckv(obj, key)
|
||||
{
|
||||
if (obj === null || typeof (obj) !== 'object')
|
||||
return (undefined);
|
||||
|
||||
if (obj.hasOwnProperty(key))
|
||||
return (obj[key]);
|
||||
|
||||
var i = key.indexOf('.');
|
||||
if (i == -1)
|
||||
return (undefined);
|
||||
|
||||
var key1 = key.substr(0, i);
|
||||
if (!obj.hasOwnProperty(key1))
|
||||
return (undefined);
|
||||
|
||||
return (pluckv(obj[key1], key.substr(i + 1)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Invoke callback(row) for each entry in the array that would be returned by
|
||||
* flattenObject(data, depth). This is just like flattenObject(data,
|
||||
* depth).forEach(callback), except that the intermediate array is never
|
||||
* created.
|
||||
*/
|
||||
function flattenIter(data, depth, callback)
|
||||
{
|
||||
doFlattenIter(data, depth, [], callback);
|
||||
}
|
||||
|
||||
function doFlattenIter(data, depth, accum, callback)
|
||||
{
|
||||
var each;
|
||||
var key;
|
||||
|
||||
if (depth === 0) {
|
||||
each = accum.slice(0);
|
||||
each.push(data);
|
||||
callback(each);
|
||||
return;
|
||||
}
|
||||
|
||||
mod_assert.ok(data !== null);
|
||||
mod_assert.equal(typeof (data), 'object');
|
||||
mod_assert.equal(typeof (depth), 'number');
|
||||
mod_assert.ok(depth >= 0);
|
||||
|
||||
for (key in data) {
|
||||
each = accum.slice(0);
|
||||
each.push(key);
|
||||
doFlattenIter(data[key], depth - 1, each, callback);
|
||||
}
|
||||
}
|
||||
|
||||
function flattenObject(data, depth)
|
||||
{
|
||||
if (depth === 0)
|
||||
return ([ data ]);
|
||||
|
||||
mod_assert.ok(data !== null);
|
||||
mod_assert.equal(typeof (data), 'object');
|
||||
mod_assert.equal(typeof (depth), 'number');
|
||||
mod_assert.ok(depth >= 0);
|
||||
|
||||
var rv = [];
|
||||
var key;
|
||||
|
||||
for (key in data) {
|
||||
flattenObject(data[key], depth - 1).forEach(function (p) {
|
||||
rv.push([ key ].concat(p));
|
||||
});
|
||||
}
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
function startsWith(str, prefix)
|
||||
{
|
||||
return (str.substr(0, prefix.length) == prefix);
|
||||
}
|
||||
|
||||
function endsWith(str, suffix)
|
||||
{
|
||||
return (str.substr(
|
||||
str.length - suffix.length, suffix.length) == suffix);
|
||||
}
|
||||
|
||||
function iso8601(d)
|
||||
{
|
||||
if (typeof (d) == 'number')
|
||||
d = new Date(d);
|
||||
mod_assert.ok(d.constructor === Date);
|
||||
return (mod_extsprintf.sprintf('%4d-%02d-%02dT%02d:%02d:%02d.%03dZ',
|
||||
d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate(),
|
||||
d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(),
|
||||
d.getUTCMilliseconds()));
|
||||
}
|
||||
|
||||
var RFC1123_MONTHS = [
|
||||
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
|
||||
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
|
||||
var RFC1123_DAYS = [
|
||||
'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
|
||||
|
||||
function rfc1123(date) {
|
||||
return (mod_extsprintf.sprintf('%s, %02d %s %04d %02d:%02d:%02d GMT',
|
||||
RFC1123_DAYS[date.getUTCDay()], date.getUTCDate(),
|
||||
RFC1123_MONTHS[date.getUTCMonth()], date.getUTCFullYear(),
|
||||
date.getUTCHours(), date.getUTCMinutes(),
|
||||
date.getUTCSeconds()));
|
||||
}
|
||||
|
||||
/*
|
||||
* Parses a date expressed as a string, as either a number of milliseconds since
|
||||
* the epoch or any string format that Date accepts, giving preference to the
|
||||
* former where these two sets overlap (e.g., small numbers).
|
||||
*/
|
||||
function parseDateTime(str)
|
||||
{
|
||||
/*
|
||||
* This is irritatingly implicit, but significantly more concise than
|
||||
* alternatives. The "+str" will convert a string containing only a
|
||||
* number directly to a Number, or NaN for other strings. Thus, if the
|
||||
* conversion succeeds, we use it (this is the milliseconds-since-epoch
|
||||
* case). Otherwise, we pass the string directly to the Date
|
||||
* constructor to parse.
|
||||
*/
|
||||
var numeric = +str;
|
||||
if (!isNaN(numeric)) {
|
||||
return (new Date(numeric));
|
||||
} else {
|
||||
return (new Date(str));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Number.*_SAFE_INTEGER isn't present before node v0.12, so we hardcode
|
||||
* the ES6 definitions here, while allowing for them to someday be higher.
|
||||
*/
|
||||
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
|
||||
var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
|
||||
|
||||
|
||||
/*
|
||||
* Default options for parseInteger().
|
||||
*/
|
||||
var PI_DEFAULTS = {
|
||||
base: 10,
|
||||
allowSign: true,
|
||||
allowPrefix: false,
|
||||
allowTrailing: false,
|
||||
allowImprecise: false,
|
||||
trimWhitespace: false,
|
||||
leadingZeroIsOctal: false
|
||||
};
|
||||
|
||||
var CP_0 = 0x30;
|
||||
var CP_9 = 0x39;
|
||||
|
||||
var CP_A = 0x41;
|
||||
var CP_B = 0x42;
|
||||
var CP_O = 0x4f;
|
||||
var CP_T = 0x54;
|
||||
var CP_X = 0x58;
|
||||
var CP_Z = 0x5a;
|
||||
|
||||
var CP_a = 0x61;
|
||||
var CP_b = 0x62;
|
||||
var CP_o = 0x6f;
|
||||
var CP_t = 0x74;
|
||||
var CP_x = 0x78;
|
||||
var CP_z = 0x7a;
|
||||
|
||||
var PI_CONV_DEC = 0x30;
|
||||
var PI_CONV_UC = 0x37;
|
||||
var PI_CONV_LC = 0x57;
|
||||
|
||||
|
||||
/*
|
||||
* A stricter version of parseInt() that provides options for changing what
|
||||
* is an acceptable string (for example, disallowing trailing characters).
|
||||
*/
|
||||
function parseInteger(str, uopts)
|
||||
{
|
||||
mod_assert.string(str, 'str');
|
||||
mod_assert.optionalObject(uopts, 'options');
|
||||
|
||||
var baseOverride = false;
|
||||
var options = PI_DEFAULTS;
|
||||
|
||||
if (uopts) {
|
||||
baseOverride = hasKey(uopts, 'base');
|
||||
options = mergeObjects(options, uopts);
|
||||
mod_assert.number(options.base, 'options.base');
|
||||
mod_assert.ok(options.base >= 2, 'options.base >= 2');
|
||||
mod_assert.ok(options.base <= 36, 'options.base <= 36');
|
||||
mod_assert.bool(options.allowSign, 'options.allowSign');
|
||||
mod_assert.bool(options.allowPrefix, 'options.allowPrefix');
|
||||
mod_assert.bool(options.allowTrailing,
|
||||
'options.allowTrailing');
|
||||
mod_assert.bool(options.allowImprecise,
|
||||
'options.allowImprecise');
|
||||
mod_assert.bool(options.trimWhitespace,
|
||||
'options.trimWhitespace');
|
||||
mod_assert.bool(options.leadingZeroIsOctal,
|
||||
'options.leadingZeroIsOctal');
|
||||
|
||||
if (options.leadingZeroIsOctal) {
|
||||
mod_assert.ok(!baseOverride,
|
||||
'"base" and "leadingZeroIsOctal" are ' +
|
||||
'mutually exclusive');
|
||||
}
|
||||
}
|
||||
|
||||
var c;
|
||||
var pbase = -1;
|
||||
var base = options.base;
|
||||
var start;
|
||||
var mult = 1;
|
||||
var value = 0;
|
||||
var idx = 0;
|
||||
var len = str.length;
|
||||
|
||||
/* Trim any whitespace on the left side. */
|
||||
if (options.trimWhitespace) {
|
||||
while (idx < len && isSpace(str.charCodeAt(idx))) {
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check the number for a leading sign. */
|
||||
if (options.allowSign) {
|
||||
if (str[idx] === '-') {
|
||||
idx += 1;
|
||||
mult = -1;
|
||||
} else if (str[idx] === '+') {
|
||||
idx += 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Parse the base-indicating prefix if there is one. */
|
||||
if (str[idx] === '0') {
|
||||
if (options.allowPrefix) {
|
||||
pbase = prefixToBase(str.charCodeAt(idx + 1));
|
||||
if (pbase !== -1 && (!baseOverride || pbase === base)) {
|
||||
base = pbase;
|
||||
idx += 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (pbase === -1 && options.leadingZeroIsOctal) {
|
||||
base = 8;
|
||||
}
|
||||
}
|
||||
|
||||
/* Parse the actual digits. */
|
||||
for (start = idx; idx < len; ++idx) {
|
||||
c = translateDigit(str.charCodeAt(idx));
|
||||
if (c !== -1 && c < base) {
|
||||
value *= base;
|
||||
value += c;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* If we didn't parse any digits, we have an invalid number. */
|
||||
if (start === idx) {
|
||||
return (new Error('invalid number: ' + JSON.stringify(str)));
|
||||
}
|
||||
|
||||
/* Trim any whitespace on the right side. */
|
||||
if (options.trimWhitespace) {
|
||||
while (idx < len && isSpace(str.charCodeAt(idx))) {
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check for trailing characters. */
|
||||
if (idx < len && !options.allowTrailing) {
|
||||
return (new Error('trailing characters after number: ' +
|
||||
JSON.stringify(str.slice(idx))));
|
||||
}
|
||||
|
||||
/* If our value is 0, we return now, to avoid returning -0. */
|
||||
if (value === 0) {
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* Calculate our final value. */
|
||||
var result = value * mult;
|
||||
|
||||
/*
|
||||
* If the string represents a value that cannot be precisely represented
|
||||
* by JavaScript, then we want to check that:
|
||||
*
|
||||
* - We never increased the value past MAX_SAFE_INTEGER
|
||||
* - We don't make the result negative and below MIN_SAFE_INTEGER
|
||||
*
|
||||
* Because we only ever increment the value during parsing, there's no
|
||||
* chance of moving past MAX_SAFE_INTEGER and then dropping below it
|
||||
* again, losing precision in the process. This means that we only need
|
||||
* to do our checks here, at the end.
|
||||
*/
|
||||
if (!options.allowImprecise &&
|
||||
(value > MAX_SAFE_INTEGER || result < MIN_SAFE_INTEGER)) {
|
||||
return (new Error('number is outside of the supported range: ' +
|
||||
JSON.stringify(str.slice(start, idx))));
|
||||
}
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Interpret a character code as a base-36 digit.
|
||||
*/
|
||||
function translateDigit(d)
|
||||
{
|
||||
if (d >= CP_0 && d <= CP_9) {
|
||||
/* '0' to '9' -> 0 to 9 */
|
||||
return (d - PI_CONV_DEC);
|
||||
} else if (d >= CP_A && d <= CP_Z) {
|
||||
/* 'A' - 'Z' -> 10 to 35 */
|
||||
return (d - PI_CONV_UC);
|
||||
} else if (d >= CP_a && d <= CP_z) {
|
||||
/* 'a' - 'z' -> 10 to 35 */
|
||||
return (d - PI_CONV_LC);
|
||||
} else {
|
||||
/* Invalid character code */
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Test if a value matches the ECMAScript definition of trimmable whitespace.
|
||||
*/
|
||||
function isSpace(c)
|
||||
{
|
||||
return (c === 0x20) ||
|
||||
(c >= 0x0009 && c <= 0x000d) ||
|
||||
(c === 0x00a0) ||
|
||||
(c === 0x1680) ||
|
||||
(c === 0x180e) ||
|
||||
(c >= 0x2000 && c <= 0x200a) ||
|
||||
(c === 0x2028) ||
|
||||
(c === 0x2029) ||
|
||||
(c === 0x202f) ||
|
||||
(c === 0x205f) ||
|
||||
(c === 0x3000) ||
|
||||
(c === 0xfeff);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Determine which base a character indicates (e.g., 'x' indicates hex).
|
||||
*/
|
||||
function prefixToBase(c)
|
||||
{
|
||||
if (c === CP_b || c === CP_B) {
|
||||
/* 0b/0B (binary) */
|
||||
return (2);
|
||||
} else if (c === CP_o || c === CP_O) {
|
||||
/* 0o/0O (octal) */
|
||||
return (8);
|
||||
} else if (c === CP_t || c === CP_T) {
|
||||
/* 0t/0T (decimal) */
|
||||
return (10);
|
||||
} else if (c === CP_x || c === CP_X) {
|
||||
/* 0x/0X (hexadecimal) */
|
||||
return (16);
|
||||
} else {
|
||||
/* Not a meaningful character */
|
||||
return (-1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function validateJsonObjectJS(schema, input)
|
||||
{
|
||||
var report = mod_jsonschema.validate(input, schema);
|
||||
|
||||
if (report.errors.length === 0)
|
||||
return (null);
|
||||
|
||||
/* Currently, we only do anything useful with the first error. */
|
||||
var error = report.errors[0];
|
||||
|
||||
/* The failed property is given by a URI with an irrelevant prefix. */
|
||||
var propname = error['property'];
|
||||
var reason = error['message'].toLowerCase();
|
||||
var i, j;
|
||||
|
||||
/*
|
||||
* There's at least one case where the property error message is
|
||||
* confusing at best. We work around this here.
|
||||
*/
|
||||
if ((i = reason.indexOf('the property ')) != -1 &&
|
||||
(j = reason.indexOf(' is not defined in the schema and the ' +
|
||||
'schema does not allow additional properties')) != -1) {
|
||||
i += 'the property '.length;
|
||||
if (propname === '')
|
||||
propname = reason.substr(i, j - i);
|
||||
else
|
||||
propname = propname + '.' + reason.substr(i, j - i);
|
||||
|
||||
reason = 'unsupported property';
|
||||
}
|
||||
|
||||
var rv = new mod_verror.VError('property "%s": %s', propname, reason);
|
||||
rv.jsv_details = error;
|
||||
return (rv);
|
||||
}
|
||||
|
||||
function randElt(arr)
|
||||
{
|
||||
mod_assert.ok(Array.isArray(arr) && arr.length > 0,
|
||||
'randElt argument must be a non-empty array');
|
||||
|
||||
return (arr[Math.floor(Math.random() * arr.length)]);
|
||||
}
|
||||
|
||||
function assertHrtime(a)
|
||||
{
|
||||
mod_assert.ok(a[0] >= 0 && a[1] >= 0,
|
||||
'negative numbers not allowed in hrtimes');
|
||||
mod_assert.ok(a[1] < 1e9, 'nanoseconds column overflow');
|
||||
}
|
||||
|
||||
/*
|
||||
* Compute the time elapsed between hrtime readings A and B, where A is later
|
||||
* than B. hrtime readings come from Node's process.hrtime(). There is no
|
||||
* defined way to represent negative deltas, so it's illegal to diff B from A
|
||||
* where the time denoted by B is later than the time denoted by A. If this
|
||||
* becomes valuable, we can define a representation and extend the
|
||||
* implementation to support it.
|
||||
*/
|
||||
function hrtimeDiff(a, b)
|
||||
{
|
||||
assertHrtime(a);
|
||||
assertHrtime(b);
|
||||
mod_assert.ok(a[0] > b[0] || (a[0] == b[0] && a[1] >= b[1]),
|
||||
'negative differences not allowed');
|
||||
|
||||
var rv = [ a[0] - b[0], 0 ];
|
||||
|
||||
if (a[1] >= b[1]) {
|
||||
rv[1] = a[1] - b[1];
|
||||
} else {
|
||||
rv[0]--;
|
||||
rv[1] = 1e9 - (b[1] - a[1]);
|
||||
}
|
||||
|
||||
return (rv);
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a hrtime reading from the array format returned by Node's
|
||||
* process.hrtime() into a scalar number of nanoseconds.
|
||||
*/
|
||||
function hrtimeNanosec(a)
|
||||
{
|
||||
assertHrtime(a);
|
||||
|
||||
return (Math.floor(a[0] * 1e9 + a[1]));
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a hrtime reading from the array format returned by Node's
|
||||
* process.hrtime() into a scalar number of microseconds.
|
||||
*/
|
||||
function hrtimeMicrosec(a)
|
||||
{
|
||||
assertHrtime(a);
|
||||
|
||||
return (Math.floor(a[0] * 1e6 + a[1] / 1e3));
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a hrtime reading from the array format returned by Node's
|
||||
* process.hrtime() into a scalar number of milliseconds.
|
||||
*/
|
||||
function hrtimeMillisec(a)
|
||||
{
|
||||
assertHrtime(a);
|
||||
|
||||
return (Math.floor(a[0] * 1e3 + a[1] / 1e6));
|
||||
}
|
||||
|
||||
/*
|
||||
* Add two hrtime readings A and B, overwriting A with the result of the
|
||||
* addition. This function is useful for accumulating several hrtime intervals
|
||||
* into a counter. Returns A.
|
||||
*/
|
||||
function hrtimeAccum(a, b)
|
||||
{
|
||||
assertHrtime(a);
|
||||
assertHrtime(b);
|
||||
|
||||
/*
|
||||
* Accumulate the nanosecond component.
|
||||
*/
|
||||
a[1] += b[1];
|
||||
if (a[1] >= 1e9) {
|
||||
/*
|
||||
* The nanosecond component overflowed, so carry to the seconds
|
||||
* field.
|
||||
*/
|
||||
a[0]++;
|
||||
a[1] -= 1e9;
|
||||
}
|
||||
|
||||
/*
|
||||
* Accumulate the seconds component.
|
||||
*/
|
||||
a[0] += b[0];
|
||||
|
||||
return (a);
|
||||
}
|
||||
|
||||
/*
|
||||
* Add two hrtime readings A and B, returning the result as a new hrtime array.
|
||||
* Does not modify either input argument.
|
||||
*/
|
||||
function hrtimeAdd(a, b)
|
||||
{
|
||||
assertHrtime(a);
|
||||
|
||||
var rv = [ a[0], a[1] ];
|
||||
|
||||
return (hrtimeAccum(rv, b));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Check an object for unexpected properties. Accepts the object to check, and
|
||||
* an array of allowed property names (strings). Returns an array of key names
|
||||
* that were found on the object, but did not appear in the list of allowed
|
||||
* properties. If no properties were found, the returned array will be of
|
||||
* zero length.
|
||||
*/
|
||||
function extraProperties(obj, allowed)
|
||||
{
|
||||
mod_assert.ok(typeof (obj) === 'object' && obj !== null,
|
||||
'obj argument must be a non-null object');
|
||||
mod_assert.ok(Array.isArray(allowed),
|
||||
'allowed argument must be an array of strings');
|
||||
for (var i = 0; i < allowed.length; i++) {
|
||||
mod_assert.ok(typeof (allowed[i]) === 'string',
|
||||
'allowed argument must be an array of strings');
|
||||
}
|
||||
|
||||
return (Object.keys(obj).filter(function (key) {
|
||||
return (allowed.indexOf(key) === -1);
|
||||
}));
|
||||
}
|
||||
|
||||
/*
|
||||
* Given three sets of properties "provided" (may be undefined), "overrides"
|
||||
* (required), and "defaults" (may be undefined), construct an object containing
|
||||
* the union of these sets with "overrides" overriding "provided", and
|
||||
* "provided" overriding "defaults". None of the input objects are modified.
|
||||
*/
|
||||
function mergeObjects(provided, overrides, defaults)
|
||||
{
|
||||
var rv, k;
|
||||
|
||||
rv = {};
|
||||
if (defaults) {
|
||||
for (k in defaults)
|
||||
rv[k] = defaults[k];
|
||||
}
|
||||
|
||||
if (provided) {
|
||||
for (k in provided)
|
||||
rv[k] = provided[k];
|
||||
}
|
||||
|
||||
if (overrides) {
|
||||
for (k in overrides)
|
||||
rv[k] = overrides[k];
|
||||
}
|
||||
|
||||
return (rv);
|
||||
}
|
||||
6
node_modules/jsprim/node_modules/assert-plus/AUTHORS
generated
vendored
Normal file
6
node_modules/jsprim/node_modules/assert-plus/AUTHORS
generated
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
Dave Eddy <dave@daveeddy.com>
|
||||
Fred Kuo <fred.kuo@joyent.com>
|
||||
Lars-Magnus Skog <ralphtheninja@riseup.net>
|
||||
Mark Cavage <mcavage@gmail.com>
|
||||
Patrick Mooney <pmooney@pfmooney.com>
|
||||
Rob Gulewich <robert.gulewich@joyent.com>
|
||||
14
node_modules/jsprim/node_modules/assert-plus/CHANGES.md
generated
vendored
Normal file
14
node_modules/jsprim/node_modules/assert-plus/CHANGES.md
generated
vendored
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
# assert-plus Changelog
|
||||
|
||||
## 1.0.0
|
||||
|
||||
- *BREAKING* assert.number (and derivatives) now accept Infinity as valid input
|
||||
- Add assert.finite check. Previous assert.number callers should use this if
|
||||
they expect Infinity inputs to throw.
|
||||
|
||||
## 0.2.0
|
||||
|
||||
- Fix `assert.object(null)` so it throws
|
||||
- Fix optional/arrayOf exports for non-type-of asserts
|
||||
- Add optiona/arrayOf exports for Stream/Date/Regex/uuid
|
||||
- Add basic unit test coverage
|
||||
162
node_modules/jsprim/node_modules/assert-plus/README.md
generated
vendored
Normal file
162
node_modules/jsprim/node_modules/assert-plus/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
# assert-plus
|
||||
|
||||
This library is a super small wrapper over node's assert module that has two
|
||||
things: (1) the ability to disable assertions with the environment variable
|
||||
NODE\_NDEBUG, and (2) some API wrappers for argument testing. Like
|
||||
`assert.string(myArg, 'myArg')`. As a simple example, most of my code looks
|
||||
like this:
|
||||
|
||||
```javascript
|
||||
var assert = require('assert-plus');
|
||||
|
||||
function fooAccount(options, callback) {
|
||||
assert.object(options, 'options');
|
||||
assert.number(options.id, 'options.id');
|
||||
assert.bool(options.isManager, 'options.isManager');
|
||||
assert.string(options.name, 'options.name');
|
||||
assert.arrayOfString(options.email, 'options.email');
|
||||
assert.func(callback, 'callback');
|
||||
|
||||
// Do stuff
|
||||
callback(null, {});
|
||||
}
|
||||
```
|
||||
|
||||
# API
|
||||
|
||||
All methods that *aren't* part of node's core assert API are simply assumed to
|
||||
take an argument, and then a string 'name' that's not a message; `AssertionError`
|
||||
will be thrown if the assertion fails with a message like:
|
||||
|
||||
AssertionError: foo (string) is required
|
||||
at test (/home/mark/work/foo/foo.js:3:9)
|
||||
at Object.<anonymous> (/home/mark/work/foo/foo.js:15:1)
|
||||
at Module._compile (module.js:446:26)
|
||||
at Object..js (module.js:464:10)
|
||||
at Module.load (module.js:353:31)
|
||||
at Function._load (module.js:311:12)
|
||||
at Array.0 (module.js:484:10)
|
||||
at EventEmitter._tickCallback (node.js:190:38)
|
||||
|
||||
from:
|
||||
|
||||
```javascript
|
||||
function test(foo) {
|
||||
assert.string(foo, 'foo');
|
||||
}
|
||||
```
|
||||
|
||||
There you go. You can check that arrays are of a homogeneous type with `Arrayof$Type`:
|
||||
|
||||
```javascript
|
||||
function test(foo) {
|
||||
assert.arrayOfString(foo, 'foo');
|
||||
}
|
||||
```
|
||||
|
||||
You can assert IFF an argument is not `undefined` (i.e., an optional arg):
|
||||
|
||||
```javascript
|
||||
assert.optionalString(foo, 'foo');
|
||||
```
|
||||
|
||||
Lastly, you can opt-out of assertion checking altogether by setting the
|
||||
environment variable `NODE_NDEBUG=1`. This is pseudo-useful if you have
|
||||
lots of assertions, and don't want to pay `typeof ()` taxes to v8 in
|
||||
production. Be advised: The standard functions re-exported from `assert` are
|
||||
also disabled in assert-plus if NDEBUG is specified. Using them directly from
|
||||
the `assert` module avoids this behavior.
|
||||
|
||||
The complete list of APIs is:
|
||||
|
||||
* assert.array
|
||||
* assert.bool
|
||||
* assert.buffer
|
||||
* assert.func
|
||||
* assert.number
|
||||
* assert.finite
|
||||
* assert.object
|
||||
* assert.string
|
||||
* assert.stream
|
||||
* assert.date
|
||||
* assert.regexp
|
||||
* assert.uuid
|
||||
* assert.arrayOfArray
|
||||
* assert.arrayOfBool
|
||||
* assert.arrayOfBuffer
|
||||
* assert.arrayOfFunc
|
||||
* assert.arrayOfNumber
|
||||
* assert.arrayOfFinite
|
||||
* assert.arrayOfObject
|
||||
* assert.arrayOfString
|
||||
* assert.arrayOfStream
|
||||
* assert.arrayOfDate
|
||||
* assert.arrayOfRegexp
|
||||
* assert.arrayOfUuid
|
||||
* assert.optionalArray
|
||||
* assert.optionalBool
|
||||
* assert.optionalBuffer
|
||||
* assert.optionalFunc
|
||||
* assert.optionalNumber
|
||||
* assert.optionalFinite
|
||||
* assert.optionalObject
|
||||
* assert.optionalString
|
||||
* assert.optionalStream
|
||||
* assert.optionalDate
|
||||
* assert.optionalRegexp
|
||||
* assert.optionalUuid
|
||||
* assert.optionalArrayOfArray
|
||||
* assert.optionalArrayOfBool
|
||||
* assert.optionalArrayOfBuffer
|
||||
* assert.optionalArrayOfFunc
|
||||
* assert.optionalArrayOfNumber
|
||||
* assert.optionalArrayOfFinite
|
||||
* assert.optionalArrayOfObject
|
||||
* assert.optionalArrayOfString
|
||||
* assert.optionalArrayOfStream
|
||||
* assert.optionalArrayOfDate
|
||||
* assert.optionalArrayOfRegexp
|
||||
* assert.optionalArrayOfUuid
|
||||
* assert.AssertionError
|
||||
* assert.fail
|
||||
* assert.ok
|
||||
* assert.equal
|
||||
* assert.notEqual
|
||||
* assert.deepEqual
|
||||
* assert.notDeepEqual
|
||||
* assert.strictEqual
|
||||
* assert.notStrictEqual
|
||||
* assert.throws
|
||||
* assert.doesNotThrow
|
||||
* assert.ifError
|
||||
|
||||
# Installation
|
||||
|
||||
npm install assert-plus
|
||||
|
||||
## License
|
||||
|
||||
The MIT License (MIT)
|
||||
Copyright (c) 2012 Mark Cavage
|
||||
|
||||
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.
|
||||
|
||||
## Bugs
|
||||
|
||||
See <https://github.com/mcavage/node-assert-plus/issues>.
|
||||
211
node_modules/jsprim/node_modules/assert-plus/assert.js
generated
vendored
Normal file
211
node_modules/jsprim/node_modules/assert-plus/assert.js
generated
vendored
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
// Copyright (c) 2012, Mark Cavage. All rights reserved.
|
||||
// Copyright 2015 Joyent, Inc.
|
||||
|
||||
var assert = require('assert');
|
||||
var Stream = require('stream').Stream;
|
||||
var util = require('util');
|
||||
|
||||
|
||||
///--- Globals
|
||||
|
||||
/* JSSTYLED */
|
||||
var UUID_REGEXP = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/;
|
||||
|
||||
|
||||
///--- Internal
|
||||
|
||||
function _capitalize(str) {
|
||||
return (str.charAt(0).toUpperCase() + str.slice(1));
|
||||
}
|
||||
|
||||
function _toss(name, expected, oper, arg, actual) {
|
||||
throw new assert.AssertionError({
|
||||
message: util.format('%s (%s) is required', name, expected),
|
||||
actual: (actual === undefined) ? typeof (arg) : actual(arg),
|
||||
expected: expected,
|
||||
operator: oper || '===',
|
||||
stackStartFunction: _toss.caller
|
||||
});
|
||||
}
|
||||
|
||||
function _getClass(arg) {
|
||||
return (Object.prototype.toString.call(arg).slice(8, -1));
|
||||
}
|
||||
|
||||
function noop() {
|
||||
// Why even bother with asserts?
|
||||
}
|
||||
|
||||
|
||||
///--- Exports
|
||||
|
||||
var types = {
|
||||
bool: {
|
||||
check: function (arg) { return typeof (arg) === 'boolean'; }
|
||||
},
|
||||
func: {
|
||||
check: function (arg) { return typeof (arg) === 'function'; }
|
||||
},
|
||||
string: {
|
||||
check: function (arg) { return typeof (arg) === 'string'; }
|
||||
},
|
||||
object: {
|
||||
check: function (arg) {
|
||||
return typeof (arg) === 'object' && arg !== null;
|
||||
}
|
||||
},
|
||||
number: {
|
||||
check: function (arg) {
|
||||
return typeof (arg) === 'number' && !isNaN(arg);
|
||||
}
|
||||
},
|
||||
finite: {
|
||||
check: function (arg) {
|
||||
return typeof (arg) === 'number' && !isNaN(arg) && isFinite(arg);
|
||||
}
|
||||
},
|
||||
buffer: {
|
||||
check: function (arg) { return Buffer.isBuffer(arg); },
|
||||
operator: 'Buffer.isBuffer'
|
||||
},
|
||||
array: {
|
||||
check: function (arg) { return Array.isArray(arg); },
|
||||
operator: 'Array.isArray'
|
||||
},
|
||||
stream: {
|
||||
check: function (arg) { return arg instanceof Stream; },
|
||||
operator: 'instanceof',
|
||||
actual: _getClass
|
||||
},
|
||||
date: {
|
||||
check: function (arg) { return arg instanceof Date; },
|
||||
operator: 'instanceof',
|
||||
actual: _getClass
|
||||
},
|
||||
regexp: {
|
||||
check: function (arg) { return arg instanceof RegExp; },
|
||||
operator: 'instanceof',
|
||||
actual: _getClass
|
||||
},
|
||||
uuid: {
|
||||
check: function (arg) {
|
||||
return typeof (arg) === 'string' && UUID_REGEXP.test(arg);
|
||||
},
|
||||
operator: 'isUUID'
|
||||
}
|
||||
};
|
||||
|
||||
function _setExports(ndebug) {
|
||||
var keys = Object.keys(types);
|
||||
var out;
|
||||
|
||||
/* re-export standard assert */
|
||||
if (process.env.NODE_NDEBUG) {
|
||||
out = noop;
|
||||
} else {
|
||||
out = function (arg, msg) {
|
||||
if (!arg) {
|
||||
_toss(msg, 'true', arg);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/* standard checks */
|
||||
keys.forEach(function (k) {
|
||||
if (ndebug) {
|
||||
out[k] = noop;
|
||||
return;
|
||||
}
|
||||
var type = types[k];
|
||||
out[k] = function (arg, msg) {
|
||||
if (!type.check(arg)) {
|
||||
_toss(msg, k, type.operator, arg, type.actual);
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
/* optional checks */
|
||||
keys.forEach(function (k) {
|
||||
var name = 'optional' + _capitalize(k);
|
||||
if (ndebug) {
|
||||
out[name] = noop;
|
||||
return;
|
||||
}
|
||||
var type = types[k];
|
||||
out[name] = function (arg, msg) {
|
||||
if (arg === undefined || arg === null) {
|
||||
return;
|
||||
}
|
||||
if (!type.check(arg)) {
|
||||
_toss(msg, k, type.operator, arg, type.actual);
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
/* arrayOf checks */
|
||||
keys.forEach(function (k) {
|
||||
var name = 'arrayOf' + _capitalize(k);
|
||||
if (ndebug) {
|
||||
out[name] = noop;
|
||||
return;
|
||||
}
|
||||
var type = types[k];
|
||||
var expected = '[' + k + ']';
|
||||
out[name] = function (arg, msg) {
|
||||
if (!Array.isArray(arg)) {
|
||||
_toss(msg, expected, type.operator, arg, type.actual);
|
||||
}
|
||||
var i;
|
||||
for (i = 0; i < arg.length; i++) {
|
||||
if (!type.check(arg[i])) {
|
||||
_toss(msg, expected, type.operator, arg, type.actual);
|
||||
}
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
/* optionalArrayOf checks */
|
||||
keys.forEach(function (k) {
|
||||
var name = 'optionalArrayOf' + _capitalize(k);
|
||||
if (ndebug) {
|
||||
out[name] = noop;
|
||||
return;
|
||||
}
|
||||
var type = types[k];
|
||||
var expected = '[' + k + ']';
|
||||
out[name] = function (arg, msg) {
|
||||
if (arg === undefined || arg === null) {
|
||||
return;
|
||||
}
|
||||
if (!Array.isArray(arg)) {
|
||||
_toss(msg, expected, type.operator, arg, type.actual);
|
||||
}
|
||||
var i;
|
||||
for (i = 0; i < arg.length; i++) {
|
||||
if (!type.check(arg[i])) {
|
||||
_toss(msg, expected, type.operator, arg, type.actual);
|
||||
}
|
||||
}
|
||||
};
|
||||
});
|
||||
|
||||
/* re-export built-in assertions */
|
||||
Object.keys(assert).forEach(function (k) {
|
||||
if (k === 'AssertionError') {
|
||||
out[k] = assert[k];
|
||||
return;
|
||||
}
|
||||
if (ndebug) {
|
||||
out[k] = noop;
|
||||
return;
|
||||
}
|
||||
out[k] = assert[k];
|
||||
});
|
||||
|
||||
/* export ourselves (for unit tests _only_) */
|
||||
out._setExports = _setExports;
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
module.exports = _setExports(process.env.NODE_NDEBUG);
|
||||
23
node_modules/jsprim/node_modules/assert-plus/package.json
generated
vendored
Normal file
23
node_modules/jsprim/node_modules/assert-plus/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
{
|
||||
"author": "Mark Cavage <mcavage@gmail.com>",
|
||||
"name": "assert-plus",
|
||||
"description": "Extra assertions on top of node's assert module",
|
||||
"version": "1.0.0",
|
||||
"license": "MIT",
|
||||
"main": "./assert.js",
|
||||
"devDependencies": {
|
||||
"tape": "4.2.2",
|
||||
"faucet": "0.0.1"
|
||||
},
|
||||
"optionalDependencies": {},
|
||||
"scripts": {
|
||||
"test": "./node_modules/.bin/tape tests/*.js | ./node_modules/.bin/faucet"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/mcavage/node-assert-plus.git"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=0.8"
|
||||
}
|
||||
}
|
||||
20
node_modules/jsprim/package.json
generated
vendored
Normal file
20
node_modules/jsprim/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
{
|
||||
"name": "jsprim",
|
||||
"version": "1.4.2",
|
||||
"description": "utilities for primitive JavaScript types",
|
||||
"main": "./lib/jsprim.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/joyent/node-jsprim.git"
|
||||
},
|
||||
"dependencies": {
|
||||
"assert-plus": "1.0.0",
|
||||
"extsprintf": "1.3.0",
|
||||
"json-schema": "0.4.0",
|
||||
"verror": "1.10.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=0.6.0"
|
||||
},
|
||||
"license": "MIT"
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue