noodleseed-cli 0.1.15 → 0.1.17

package/node_modules/object-inspect/test/indent-option.js

@@ -1,271 +0,0 @@
-var test = require('tape');
-var forEach = require('for-each');
-
-var inspect = require('../');
-
-test('bad indent options', function (t) {
-    forEach([
-        undefined,
-        true,
-        false,
-        -1,
-        1.2,
-        Infinity,
-        -Infinity,
-        NaN
-    ], function (indent) {
-        t['throws'](
-            function () { inspect('', { indent: indent }); },
-            TypeError,
-            inspect(indent) + ' is invalid'
-        );
-    });
-
-    t.end();
-});
-
-test('simple object with indent', function (t) {
-    t.plan(2);
-
-    var obj = { a: 1, b: 2 };
-
-    var expectedSpaces = [
-        '{',
-        '  a: 1,',
-        '  b: 2',
-        '}'
-    ].join('\n');
-    var expectedTabs = [
-        '{',
-        '	a: 1,',
-        '	b: 2',
-        '}'
-    ].join('\n');
-
-    t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
-    t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
-});
-
-test('two deep object with indent', function (t) {
-    t.plan(2);
-
-    var obj = { a: 1, b: { c: 3, d: 4 } };
-
-    var expectedSpaces = [
-        '{',
-        '  a: 1,',
-        '  b: {',
-        '    c: 3,',
-        '    d: 4',
-        '  }',
-        '}'
-    ].join('\n');
-    var expectedTabs = [
-        '{',
-        '	a: 1,',
-        '	b: {',
-        '		c: 3,',
-        '		d: 4',
-        '	}',
-        '}'
-    ].join('\n');
-
-    t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
-    t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
-});
-
-test('simple array with all single line elements', function (t) {
-    t.plan(2);
-
-    var obj = [1, 2, 3, 'asdf\nsdf'];
-
-    var expected = '[ 1, 2, 3, \'asdf\\nsdf\' ]';
-
-    t.equal(inspect(obj, { indent: 2 }), expected, 'two');
-    t.equal(inspect(obj, { indent: '\t' }), expected, 'tabs');
-});
-
-test('array with complex elements', function (t) {
-    t.plan(2);
-
-    var obj = [1, { a: 1, b: { c: 1 } }, 'asdf\nsdf'];
-
-    var expectedSpaces = [
-        '[',
-        '  1,',
-        '  {',
-        '    a: 1,',
-        '    b: {',
-        '      c: 1',
-        '    }',
-        '  },',
-        '  \'asdf\\nsdf\'',
-        ']'
-    ].join('\n');
-    var expectedTabs = [
-        '[',
-        '	1,',
-        '	{',
-        '		a: 1,',
-        '		b: {',
-        '			c: 1',
-        '		}',
-        '	},',
-        '	\'asdf\\nsdf\'',
-        ']'
-    ].join('\n');
-
-    t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
-    t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
-});
-
-test('values', function (t) {
-    t.plan(2);
-    var obj = [{}, [], { 'a-b': 5 }];
-
-    var expectedSpaces = [
-        '[',
-        '  {},',
-        '  [],',
-        '  {',
-        '    \'a-b\': 5',
-        '  }',
-        ']'
-    ].join('\n');
-    var expectedTabs = [
-        '[',
-        '	{},',
-        '	[],',
-        '	{',
-        '		\'a-b\': 5',
-        '	}',
-        ']'
-    ].join('\n');
-
-    t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
-    t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
-});
-
-test('Map', { skip: typeof Map !== 'function' }, function (t) {
-    var map = new Map();
-    map.set({ a: 1 }, ['b']);
-    map.set(3, NaN);
-
-    var expectedStringSpaces = [
-        'Map (2) {',
-        '  { a: 1 } => [ \'b\' ],',
-        '  3 => NaN',
-        '}'
-    ].join('\n');
-    var expectedStringTabs = [
-        'Map (2) {',
-        '	{ a: 1 } => [ \'b\' ],',
-        '	3 => NaN',
-        '}'
-    ].join('\n');
-    var expectedStringTabsDoubleQuotes = [
-        'Map (2) {',
-        '	{ a: 1 } => [ "b" ],',
-        '	3 => NaN',
-        '}'
-    ].join('\n');
-
-    t.equal(
-        inspect(map, { indent: 2 }),
-        expectedStringSpaces,
-        'Map keys are not indented (two)'
-    );
-    t.equal(
-        inspect(map, { indent: '\t' }),
-        expectedStringTabs,
-        'Map keys are not indented (tabs)'
-    );
-    t.equal(
-        inspect(map, { indent: '\t', quoteStyle: 'double' }),
-        expectedStringTabsDoubleQuotes,
-        'Map keys are not indented (tabs + double quotes)'
-    );
-
-    t.equal(inspect(new Map(), { indent: 2 }), 'Map (0) {}', 'empty Map should show as empty (two)');
-    t.equal(inspect(new Map(), { indent: '\t' }), 'Map (0) {}', 'empty Map should show as empty (tabs)');
-
-    var nestedMap = new Map();
-    nestedMap.set(nestedMap, map);
-    var expectedNestedSpaces = [
-        'Map (1) {',
-        '  [Circular] => Map (2) {',
-        '    { a: 1 } => [ \'b\' ],',
-        '    3 => NaN',
-        '  }',
-        '}'
-    ].join('\n');
-    var expectedNestedTabs = [
-        'Map (1) {',
-        '	[Circular] => Map (2) {',
-        '		{ a: 1 } => [ \'b\' ],',
-        '		3 => NaN',
-        '	}',
-        '}'
-    ].join('\n');
-    t.equal(inspect(nestedMap, { indent: 2 }), expectedNestedSpaces, 'Map containing a Map should work (two)');
-    t.equal(inspect(nestedMap, { indent: '\t' }), expectedNestedTabs, 'Map containing a Map should work (tabs)');
-
-    t.end();
-});
-
-test('Set', { skip: typeof Set !== 'function' }, function (t) {
-    var set = new Set();
-    set.add({ a: 1 });
-    set.add(['b']);
-    var expectedStringSpaces = [
-        'Set (2) {',
-        '  {',
-        '    a: 1',
-        '  },',
-        '  [ \'b\' ]',
-        '}'
-    ].join('\n');
-    var expectedStringTabs = [
-        'Set (2) {',
-        '	{',
-        '		a: 1',
-        '	},',
-        '	[ \'b\' ]',
-        '}'
-    ].join('\n');
-    t.equal(inspect(set, { indent: 2 }), expectedStringSpaces, 'new Set([{ a: 1 }, ["b"]]) should show size and contents (two)');
-    t.equal(inspect(set, { indent: '\t' }), expectedStringTabs, 'new Set([{ a: 1 }, ["b"]]) should show size and contents (tabs)');
-
-    t.equal(inspect(new Set(), { indent: 2 }), 'Set (0) {}', 'empty Set should show as empty (two)');
-    t.equal(inspect(new Set(), { indent: '\t' }), 'Set (0) {}', 'empty Set should show as empty (tabs)');
-
-    var nestedSet = new Set();
-    nestedSet.add(set);
-    nestedSet.add(nestedSet);
-    var expectedNestedSpaces = [
-        'Set (2) {',
-        '  Set (2) {',
-        '    {',
-        '      a: 1',
-        '    },',
-        '    [ \'b\' ]',
-        '  },',
-        '  [Circular]',
-        '}'
-    ].join('\n');
-    var expectedNestedTabs = [
-        'Set (2) {',
-        '	Set (2) {',
-        '		{',
-        '			a: 1',
-        '		},',
-        '		[ \'b\' ]',
-        '	},',
-        '	[Circular]',
-        '}'
-    ].join('\n');
-    t.equal(inspect(nestedSet, { indent: 2 }), expectedNestedSpaces, 'Set containing a Set should work (two)');
-    t.equal(inspect(nestedSet, { indent: '\t' }), expectedNestedTabs, 'Set containing a Set should work (tabs)');
-
-    t.end();
-});

package/node_modules/object-inspect/test/inspect.js

@@ -1,139 +0,0 @@
-var test = require('tape');
-var hasSymbols = require('has-symbols/shams')();
-var utilInspect = require('../util.inspect');
-var repeat = require('string.prototype.repeat');
-
-var inspect = require('..');
-
-test('inspect', function (t) {
-    t.plan(5);
-
-    var obj = [{ inspect: function xyzInspect() { return '!XYZ¡'; } }, []];
-    var stringResult = '[ !XYZ¡, [] ]';
-    var falseResult = '[ { inspect: [Function: xyzInspect] }, [] ]';
-
-    t.equal(inspect(obj), stringResult);
-    t.equal(inspect(obj, { customInspect: true }), stringResult);
-    t.equal(inspect(obj, { customInspect: 'symbol' }), falseResult);
-    t.equal(inspect(obj, { customInspect: false }), falseResult);
-    t['throws'](
-        function () { inspect(obj, { customInspect: 'not a boolean or "symbol"' }); },
-        TypeError,
-        '`customInspect` must be a boolean or the string "symbol"'
-    );
-});
-
-test('inspect custom symbol', { skip: !hasSymbols || !utilInspect || !utilInspect.custom }, function (t) {
-    t.plan(4);
-
-    var obj = { inspect: function stringInspect() { return 'string'; } };
-    obj[utilInspect.custom] = function custom() { return 'symbol'; };
-
-    var symbolResult = '[ symbol, [] ]';
-    var stringResult = '[ string, [] ]';
-    var falseResult = '[ { inspect: [Function: stringInspect]' + (utilInspect.custom ? ', [' + inspect(utilInspect.custom) + ']: [Function: custom]' : '') + ' }, [] ]';
-
-    var symbolStringFallback = utilInspect.custom ? symbolResult : stringResult;
-    var symbolFalseFallback = utilInspect.custom ? symbolResult : falseResult;
-
-    t.equal(inspect([obj, []]), symbolStringFallback);
-    t.equal(inspect([obj, []], { customInspect: true }), symbolStringFallback);
-    t.equal(inspect([obj, []], { customInspect: 'symbol' }), symbolFalseFallback);
-    t.equal(inspect([obj, []], { customInspect: false }), falseResult);
-});
-
-test('symbols', { skip: !hasSymbols }, function (t) {
-    t.plan(2);
-
-    var obj = { a: 1 };
-    obj[Symbol('test')] = 2;
-    obj[Symbol.iterator] = 3;
-    Object.defineProperty(obj, Symbol('non-enum'), {
-        enumerable: false,
-        value: 4
-    });
-
-    if (typeof Symbol.iterator === 'symbol') {
-        t.equal(inspect(obj), '{ a: 1, [Symbol(test)]: 2, [Symbol(Symbol.iterator)]: 3 }', 'object with symbols');
-        t.equal(inspect([obj, []]), '[ { a: 1, [Symbol(test)]: 2, [Symbol(Symbol.iterator)]: 3 }, [] ]', 'object with symbols in array');
-    } else {
-        // symbol sham key ordering is unreliable
-        t.match(
-            inspect(obj),
-            /^(?:{ a: 1, \[Symbol\(test\)\]: 2, \[Symbol\(Symbol.iterator\)\]: 3 }|{ a: 1, \[Symbol\(Symbol.iterator\)\]: 3, \[Symbol\(test\)\]: 2 })$/,
-            'object with symbols (nondeterministic symbol sham key ordering)'
-        );
-        t.match(
-            inspect([obj, []]),
-            /^\[ (?:{ a: 1, \[Symbol\(test\)\]: 2, \[Symbol\(Symbol.iterator\)\]: 3 }|{ a: 1, \[Symbol\(Symbol.iterator\)\]: 3, \[Symbol\(test\)\]: 2 }), \[\] \]$/,
-            'object with symbols in array (nondeterministic symbol sham key ordering)'
-        );
-    }
-});
-
-test('maxStringLength', function (t) {
-    t['throws'](
-        function () { inspect('', { maxStringLength: -1 }); },
-        TypeError,
-        'maxStringLength must be >= 0, or Infinity, not negative'
-    );
-
-    var str = repeat('a', 1e8);
-
-    t.equal(
-        inspect([str], { maxStringLength: 10 }),
-        '[ \'aaaaaaaaaa\'... 99999990 more characters ]',
-        'maxStringLength option limits output'
-    );
-
-    t.equal(
-        inspect(['f'], { maxStringLength: null }),
-        '[ \'\'... 1 more character ]',
-        'maxStringLength option accepts `null`'
-    );
-
-    t.equal(
-        inspect([str], { maxStringLength: Infinity }),
-        '[ \'' + str + '\' ]',
-        'maxStringLength option accepts ∞'
-    );
-
-    t.end();
-});
-
-test('inspect options', { skip: !utilInspect.custom }, function (t) {
-    var obj = {};
-    obj[utilInspect.custom] = function () {
-        return JSON.stringify(arguments);
-    };
-    t.equal(
-        inspect(obj),
-        utilInspect(obj, { depth: 5 }),
-        'custom symbols will use node\'s inspect'
-    );
-    t.equal(
-        inspect(obj, { depth: 2 }),
-        utilInspect(obj, { depth: 2 }),
-        'a reduced depth will be passed to node\'s inspect'
-    );
-    t.equal(
-        inspect({ d1: obj }, { depth: 3 }),
-        '{ d1: ' + utilInspect(obj, { depth: 2 }) + ' }',
-        'deep objects will receive a reduced depth'
-    );
-    t.equal(
-        inspect({ d1: obj }, { depth: 1 }),
-        '{ d1: [Object] }',
-        'unlike nodejs inspect, customInspect will not be used once the depth is exceeded.'
-    );
-    t.end();
-});
-
-test('inspect URL', { skip: typeof URL === 'undefined' }, function (t) {
-    t.match(
-        inspect(new URL('https://nodejs.org')),
-        /nodejs\.org/, // Different environments stringify it differently
-        'url can be inspected'
-    );
-    t.end();
-});

package/node_modules/object-inspect/test/lowbyte.js

@@ -1,12 +0,0 @@
-var test = require('tape');
-var inspect = require('../');
-
-var obj = { x: 'a\r\nb', y: '\x05! \x1f \x12' };
-
-test('interpolate low bytes', function (t) {
-    t.plan(1);
-    t.equal(
-        inspect(obj),
-        "{ x: 'a\\r\\nb', y: '\\x05! \\x1F \\x12' }"
-    );
-});

package/node_modules/object-inspect/test/number.js

@@ -1,58 +0,0 @@
-var test = require('tape');
-var v = require('es-value-fixtures');
-var forEach = require('for-each');
-
-var inspect = require('../');
-
-test('negative zero', function (t) {
-    t.equal(inspect(0), '0', 'inspect(0) === "0"');
-    t.equal(inspect(Object(0)), 'Object(0)', 'inspect(Object(0)) === "Object(0)"');
-
-    t.equal(inspect(-0), '-0', 'inspect(-0) === "-0"');
-    t.equal(inspect(Object(-0)), 'Object(-0)', 'inspect(Object(-0)) === "Object(-0)"');
-
-    t.end();
-});
-
-test('numericSeparator', function (t) {
-    forEach(v.nonBooleans, function (nonBoolean) {
-        t['throws'](
-            function () { inspect(true, { numericSeparator: nonBoolean }); },
-            TypeError,
-            inspect(nonBoolean) + ' is not a boolean'
-        );
-    });
-
-    t.test('3 digit numbers', function (st) {
-        var failed = false;
-        for (var i = -999; i < 1000; i += 1) {
-            var actual = inspect(i);
-            var actualSepNo = inspect(i, { numericSeparator: false });
-            var actualSepYes = inspect(i, { numericSeparator: true });
-            var expected = String(i);
-            if (actual !== expected || actualSepNo !== expected || actualSepYes !== expected) {
-                failed = true;
-                t.equal(actual, expected);
-                t.equal(actualSepNo, expected);
-                t.equal(actualSepYes, expected);
-            }
-        }
-
-        st.notOk(failed, 'all 3 digit numbers passed');
-
-        st.end();
-    });
-
-    t.equal(inspect(1e3), '1000', '1000');
-    t.equal(inspect(1e3, { numericSeparator: false }), '1000', '1000, numericSeparator false');
-    t.equal(inspect(1e3, { numericSeparator: true }), '1_000', '1000, numericSeparator true');
-    t.equal(inspect(-1e3), '-1000', '-1000');
-    t.equal(inspect(-1e3, { numericSeparator: false }), '-1000', '-1000, numericSeparator false');
-    t.equal(inspect(-1e3, { numericSeparator: true }), '-1_000', '-1000, numericSeparator true');
-
-    t.equal(inspect(1234.5678, { numericSeparator: true }), '1_234.567_8', 'fractional numbers get separators');
-    t.equal(inspect(1234.56789, { numericSeparator: true }), '1_234.567_89', 'fractional numbers get separators');
-    t.equal(inspect(1234.567891, { numericSeparator: true }), '1_234.567_891', 'fractional numbers get separators');
-
-    t.end();
-});

package/node_modules/object-inspect/test/quoteStyle.js

@@ -1,26 +0,0 @@
-'use strict';
-
-var inspect = require('../');
-var test = require('tape');
-
-test('quoteStyle option', function (t) {
-    t['throws'](function () { inspect(null, { quoteStyle: false }); }, 'false is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: true }); }, 'true is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: '' }); }, '"" is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: {} }); }, '{} is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: [] }); }, '[] is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: 42 }); }, '42 is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: NaN }); }, 'NaN is not a valid value');
-    t['throws'](function () { inspect(null, { quoteStyle: function () {} }); }, 'a function is not a valid value');
-
-    t.equal(inspect('"', { quoteStyle: 'single' }), '\'"\'', 'double quote, quoteStyle: "single"');
-    t.equal(inspect('"', { quoteStyle: 'double' }), '"\\""', 'double quote, quoteStyle: "double"');
-
-    t.equal(inspect('\'', { quoteStyle: 'single' }), '\'\\\'\'', 'single quote, quoteStyle: "single"');
-    t.equal(inspect('\'', { quoteStyle: 'double' }), '"\'"', 'single quote, quoteStyle: "double"');
-
-    t.equal(inspect('`', { quoteStyle: 'single' }), '\'`\'', 'backtick, quoteStyle: "single"');
-    t.equal(inspect('`', { quoteStyle: 'double' }), '"`"', 'backtick, quoteStyle: "double"');
-
-    t.end();
-});

package/node_modules/object-inspect/test/toStringTag.js

@@ -1,40 +0,0 @@
-'use strict';
-
-var test = require('tape');
-var hasToStringTag = require('has-tostringtag/shams')();
-
-var inspect = require('../');
-
-test('Symbol.toStringTag', { skip: !hasToStringTag }, function (t) {
-    t.plan(4);
-
-    var obj = { a: 1 };
-    t.equal(inspect(obj), '{ a: 1 }', 'object, no Symbol.toStringTag');
-
-    obj[Symbol.toStringTag] = 'foo';
-    t.equal(inspect(obj), '{ a: 1, [Symbol(Symbol.toStringTag)]: \'foo\' }', 'object with Symbol.toStringTag');
-
-    t.test('null objects', { skip: 'toString' in { __proto__: null } }, function (st) {
-        st.plan(2);
-
-        var dict = { __proto__: null, a: 1 };
-        st.equal(inspect(dict), '[Object: null prototype] { a: 1 }', 'null object with Symbol.toStringTag');
-
-        dict[Symbol.toStringTag] = 'Dict';
-        st.equal(inspect(dict), '[Dict: null prototype] { a: 1, [Symbol(Symbol.toStringTag)]: \'Dict\' }', 'null object with Symbol.toStringTag');
-    });
-
-    t.test('instances', function (st) {
-        st.plan(4);
-
-        function C() {
-            this.a = 1;
-        }
-        st.equal(Object.prototype.toString.call(new C()), '[object Object]', 'instance, no toStringTag, Object.prototype.toString');
-        st.equal(inspect(new C()), 'C { a: 1 }', 'instance, no toStringTag');
-
-        C.prototype[Symbol.toStringTag] = 'Class!';
-        st.equal(Object.prototype.toString.call(new C()), '[object Class!]', 'instance, with toStringTag, Object.prototype.toString');
-        st.equal(inspect(new C()), 'C [Class!] { a: 1 }', 'instance, with toStringTag');
-    });
-});

package/node_modules/object-inspect/test/undef.js

@@ -1,12 +0,0 @@
-var test = require('tape');
-var inspect = require('../');
-
-var obj = { a: 1, b: [3, 4, undefined, null], c: undefined, d: null };
-
-test('undef and null', function (t) {
-    t.plan(1);
-    t.equal(
-        inspect(obj),
-        '{ a: 1, b: [ 3, 4, undefined, null ], c: undefined, d: null }'
-    );
-});