ahmad-module 1.0.0

package/json-stringify-safe/stringify.js

@@ -0,0 +1,27 @@
+exports = module.exports = stringify
+exports.getSerialize = serializer
+
+function stringify(obj, replacer, spaces, cycleReplacer) {
+  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)
+}
+
+function serializer(replacer, cycleReplacer) {
+  var stack = [], keys = []
+
+  if (cycleReplacer == null) cycleReplacer = function(key, value) {
+    if (stack[0] === value) return "[Circular ~]"
+    return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]"
+  }
+
+  return function(key, value) {
+    if (stack.length > 0) {
+      var thisPos = stack.indexOf(this)
+      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)
+      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)
+      if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)
+    }
+    else stack.push(value)
+
+    return replacer == null ? value : replacer.call(this, key, value)
+  }
+}

package/json-stringify-safe/test/mocha.opts

@@ -0,0 +1,2 @@
+--recursive
+--require must

package/json-stringify-safe/test/stringify_test.js

@@ -0,0 +1,246 @@
+var Sinon = require("sinon")
+var stringify = require("..")
+function jsonify(obj) { return JSON.stringify(obj, null, 2) }
+
+describe("Stringify", function() {
+  it("must stringify circular objects", function() {
+    var obj = {name: "Alice"}
+    obj.self = obj
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify({name: "Alice", self: "[Circular ~]"}))
+  })
+
+  it("must stringify circular objects with intermediaries", function() {
+    var obj = {name: "Alice"}
+    obj.identity = {self: obj}
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify({name: "Alice", identity: {self: "[Circular ~]"}}))
+  })
+
+  it("must stringify circular objects deeper", function() {
+    var obj = {name: "Alice", child: {name: "Bob"}}
+    obj.child.self = obj.child
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice",
+      child: {name: "Bob", self: "[Circular ~.child]"}
+    }))
+  })
+
+  it("must stringify circular objects deeper with intermediaries", function() {
+    var obj = {name: "Alice", child: {name: "Bob"}}
+    obj.child.identity = {self: obj.child}
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice",
+      child: {name: "Bob", identity: {self: "[Circular ~.child]"}}
+    }))
+  })
+
+  it("must stringify circular objects in an array", function() {
+    var obj = {name: "Alice"}
+    obj.self = [obj, obj]
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice", self: ["[Circular ~]", "[Circular ~]"]
+    }))
+  })
+
+  it("must stringify circular objects deeper in an array", function() {
+    var obj = {name: "Alice", children: [{name: "Bob"}, {name: "Eve"}]}
+    obj.children[0].self = obj.children[0]
+    obj.children[1].self = obj.children[1]
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      name: "Alice",
+      children: [
+        {name: "Bob", self: "[Circular ~.children.0]"},
+        {name: "Eve", self: "[Circular ~.children.1]"}
+      ]
+    }))
+  })
+
+  it("must stringify circular arrays", function() {
+    var obj = []
+    obj.push(obj)
+    obj.push(obj)
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify(["[Circular ~]", "[Circular ~]"]))
+  })
+
+  it("must stringify circular arrays with intermediaries", function() {
+    var obj = []
+    obj.push({name: "Alice", self: obj})
+    obj.push({name: "Bob", self: obj})
+
+    stringify(obj, null, 2).must.eql(jsonify([
+      {name: "Alice", self: "[Circular ~]"},
+      {name: "Bob", self: "[Circular ~]"}
+    ]))
+  })
+
+  it("must stringify repeated objects in objects", function() {
+    var obj = {}
+    var alice = {name: "Alice"}
+    obj.alice1 = alice
+    obj.alice2 = alice
+
+    stringify(obj, null, 2).must.eql(jsonify({
+      alice1: {name: "Alice"},
+      alice2: {name: "Alice"}
+    }))
+  })
+
+  it("must stringify repeated objects in arrays", function() {
+    var alice = {name: "Alice"}
+    var obj = [alice, alice]
+    var json = stringify(obj, null, 2)
+    json.must.eql(jsonify([{name: "Alice"}, {name: "Alice"}]))
+  })
+
+  it("must call given decycler and use its output", function() {
+    var obj = {}
+    obj.a = obj
+    obj.b = obj
+
+    var decycle = Sinon.spy(function() { return decycle.callCount })
+    var json = stringify(obj, null, 2, decycle)
+    json.must.eql(jsonify({a: 1, b: 2}, null, 2))
+
+    decycle.callCount.must.equal(2)
+    decycle.thisValues[0].must.equal(obj)
+    decycle.args[0][0].must.equal("a")
+    decycle.args[0][1].must.equal(obj)
+    decycle.thisValues[1].must.equal(obj)
+    decycle.args[1][0].must.equal("b")
+    decycle.args[1][1].must.equal(obj)
+  })
+
+  it("must call replacer and use its output", function() {
+    var obj = {name: "Alice", child: {name: "Bob"}}
+
+    var replacer = Sinon.spy(bangString)
+    var json = stringify(obj, replacer, 2)
+    json.must.eql(jsonify({name: "Alice!", child: {name: "Bob!"}}))
+
+    replacer.callCount.must.equal(4)
+    replacer.args[0][0].must.equal("")
+    replacer.args[0][1].must.equal(obj)
+    replacer.thisValues[1].must.equal(obj)
+    replacer.args[1][0].must.equal("name")
+    replacer.args[1][1].must.equal("Alice")
+    replacer.thisValues[2].must.equal(obj)
+    replacer.args[2][0].must.equal("child")
+    replacer.args[2][1].must.equal(obj.child)
+    replacer.thisValues[3].must.equal(obj.child)
+    replacer.args[3][0].must.equal("name")
+    replacer.args[3][1].must.equal("Bob")
+  })
+
+  it("must call replacer after describing circular references", function() {
+    var obj = {name: "Alice"}
+    obj.self = obj
+
+    var replacer = Sinon.spy(bangString)
+    var json = stringify(obj, replacer, 2)
+    json.must.eql(jsonify({name: "Alice!", self: "[Circular ~]!"}))
+
+    replacer.callCount.must.equal(3)
+    replacer.args[0][0].must.equal("")
+    replacer.args[0][1].must.equal(obj)
+    replacer.thisValues[1].must.equal(obj)
+    replacer.args[1][0].must.equal("name")
+    replacer.args[1][1].must.equal("Alice")
+    replacer.thisValues[2].must.equal(obj)
+    replacer.args[2][0].must.equal("self")
+    replacer.args[2][1].must.equal("[Circular ~]")
+  })
+
+  it("must call given decycler and use its output for nested objects",
+    function() {
+    var obj = {}
+    obj.a = obj
+    obj.b = {self: obj}
+
+    var decycle = Sinon.spy(function() { return decycle.callCount })
+    var json = stringify(obj, null, 2, decycle)
+    json.must.eql(jsonify({a: 1, b: {self: 2}}))
+
+    decycle.callCount.must.equal(2)
+    decycle.args[0][0].must.equal("a")
+    decycle.args[0][1].must.equal(obj)
+    decycle.args[1][0].must.equal("self")
+    decycle.args[1][1].must.equal(obj)
+  })
+
+  it("must use decycler's output when it returned null", function() {
+    var obj = {a: "b"}
+    obj.self = obj
+    obj.selves = [obj, obj]
+
+    function decycle() { return null }
+    stringify(obj, null, 2, decycle).must.eql(jsonify({
+      a: "b",
+      self: null,
+      selves: [null, null]
+    }))
+  })
+
+  it("must use decycler's output when it returned undefined", function() {
+    var obj = {a: "b"}
+    obj.self = obj
+    obj.selves = [obj, obj]
+
+    function decycle() {}
+    stringify(obj, null, 2, decycle).must.eql(jsonify({
+      a: "b",
+      selves: [null, null]
+    }))
+  })
+
+  it("must throw given a decycler that returns a cycle", function() {
+    var obj = {}
+    obj.self = obj
+    var err
+    function identity(key, value) { return value }
+    try { stringify(obj, null, 2, identity) } catch (ex) { err = ex }
+    err.must.be.an.instanceof(TypeError)
+  })
+
+  describe(".getSerialize", function() {
+    it("must stringify circular objects", function() {
+      var obj = {a: "b"}
+      obj.circularRef = obj
+      obj.list = [obj, obj]
+
+      var json = JSON.stringify(obj, stringify.getSerialize(), 2)
+      json.must.eql(jsonify({
+        "a": "b",
+        "circularRef": "[Circular ~]",
+        "list": ["[Circular ~]", "[Circular ~]"]
+      }))
+    })
+
+    // This is the behavior as of Mar 3, 2015.
+    // The serializer function keeps state inside the returned function and
+    // so far I'm not sure how to not do that. JSON.stringify's replacer is not
+    // called _after_ serialization.
+    xit("must return a function that could be called twice", function() {
+      var obj = {name: "Alice"}
+      obj.self = obj
+
+      var json
+      var serializer = stringify.getSerialize()
+
+      json = JSON.stringify(obj, serializer, 2)
+      json.must.eql(jsonify({name: "Alice", self: "[Circular ~]"}))
+
+      json = JSON.stringify(obj, serializer, 2)
+      json.must.eql(jsonify({name: "Alice", self: "[Circular ~]"}))
+    })
+  })
+})
+
+function bangString(key, value) {
+  return typeof value == "string" ? value + "!" : value
+}

package/jsprim/CHANGES.md

@@ -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

package/jsprim/CONTRIBUTING.md

@@ -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.

package/jsprim/LICENSE

@@ -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

package/jsprim/README.md

@@ -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).