initial

node_modules/command-line-args/test/internals/argv-parser.js

@@ -0,0 +1,366 @@
+'use strict'
+const TestRunner = require('test-runner')
+const a = require('assert')
+const runner = new TestRunner()
+const ArgvParser = require('../../lib/argv-parser')
+
+runner.test('argv-parser: long option, string', function () {
+  const optionDefinitions = [
+    { name: 'one' }
+  ]
+  const argv = [ '--one', '1' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' }
+  ])
+})
+
+runner.test('argv-parser: long option, string repeated', function () {
+  const optionDefinitions = [
+    { name: 'one' }
+  ]
+  const argv = [ '--one', '1', '--one', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  a.ok(result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '2', name: 'one', value: '2' }
+  ])
+})
+
+runner.test('argv-parser: long option, string multiple', function () {
+  const optionDefinitions = [
+    { name: 'one', multiple: true }
+  ]
+  const argv = [ '--one', '1', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'set', arg: '2', name: 'one', value: '2' }
+  ])
+})
+
+runner.test('argv-parser: long option, string multiple then boolean', function () {
+  const optionDefinitions = [
+    { name: 'one', multiple: true },
+    { name: 'two', type: Boolean }
+  ]
+  const argv = [ '--one', '1', '2', '--two' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  a.ok(result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'set', arg: '2', name: 'one', value: '2' },
+    { event: 'set', arg: '--two', name: 'two', value: true }
+  ])
+})
+
+runner.test('argv-parser: long option, boolean', function () {
+  const optionDefinitions = [
+    { name: 'one', type: Boolean }
+  ]
+  const argv = [ '--one', '1' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(!result[1].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: true },
+    { event: 'unknown_value', arg: '1', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: simple, with unknown values', function () {
+  const optionDefinitions = [
+    { name: 'one', type: Number }
+  ]
+  const argv = [ 'clive', '--one', '1', 'yeah' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(!result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  a.ok(!result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'unknown_value', arg: 'clive', name: '_unknown', value: undefined },
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'unknown_value', arg: 'yeah', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: simple, with singular defaultOption', function () {
+  const optionDefinitions = [
+    { name: 'one', type: Number },
+    { name: 'two', defaultOption: true }
+  ]
+  const argv = [ 'clive', '--one', '1', 'yeah' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  a.ok(!result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: 'clive', name: 'two', value: 'clive' },
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'unknown_value', arg: 'yeah', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: simple, with multiple defaultOption', function () {
+  const optionDefinitions = [
+    { name: 'one', type: Number },
+    { name: 'two', defaultOption: true, multiple: true }
+  ]
+  const argv = [ 'clive', '--one', '1', 'yeah' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  a.ok(result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: 'clive', name: 'two', value: 'clive' },
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'set', arg: 'yeah', name: 'two', value: 'yeah' }
+  ])
+})
+
+runner.test('argv-parser: long option, string lazyMultiple bad', function () {
+  const optionDefinitions = [
+    { name: 'one', lazyMultiple: true }
+  ]
+  const argv = [ '--one', '1', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(!result[2].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'unknown_value', arg: '2', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: long option, string lazyMultiple good', function () {
+  const optionDefinitions = [
+    { name: 'one', lazyMultiple: true }
+  ]
+  const argv = [ '--one', '1', '--one', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  a.ok(result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '2', name: 'one', value: '2' }
+  ])
+})
+
+runner.test('argv-parser: long option, stopAtFirstUnknown', function () {
+  const optionDefinitions = [
+    { name: 'one' },
+    { name: 'two' }
+  ]
+  const argv = [ '--one', '1', 'asdf', '--two', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv, stopAtFirstUnknown: true })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(!result[2].def)
+  a.ok(!result[3].def)
+  a.ok(!result[4].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'unknown_value', arg: 'asdf', name: '_unknown', value: undefined },
+    { event: 'unknown_value', arg: '--two', name: '_unknown', value: undefined },
+    { event: 'unknown_value', arg: '2', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: long option, stopAtFirstUnknown with defaultOption', function () {
+  const optionDefinitions = [
+    { name: 'one', defaultOption: true },
+    { name: 'two' }
+  ]
+  const argv = [ '1', 'asdf', '--two', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv, stopAtFirstUnknown: true })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(!result[1].def)
+  a.ok(!result[2].def)
+  a.ok(!result[3].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'unknown_value', arg: 'asdf', name: '_unknown', value: undefined },
+    { event: 'unknown_value', arg: '--two', name: '_unknown', value: undefined },
+    { event: 'unknown_value', arg: '2', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: long option, stopAtFirstUnknown with defaultOption 2', function () {
+  const optionDefinitions = [
+    { name: 'one', defaultOption: true },
+    { name: 'two' }
+  ]
+  const argv = [ '--one', '1', '--', '--two', '2' ]
+  const parser = new ArgvParser(optionDefinitions, { argv, stopAtFirstUnknown: true })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(!result[2].def)
+  a.ok(!result[3].def)
+  a.ok(!result[4].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' },
+    { event: 'unknown_value', arg: '--', name: '_unknown', value: undefined },
+    { event: 'unknown_value', arg: '--two', name: '_unknown', value: undefined },
+    { event: 'unknown_value', arg: '2', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: --option=value', function () {
+  const optionDefinitions = [
+    { name: 'one' },
+    { name: 'two' }
+  ]
+  const argv = [ '--one=1', '--two=2', '--two=' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '--one=1', name: 'one', value: '1' },
+    { event: 'set', arg: '--two=2', name: 'two', value: '2' },
+    { event: 'set', arg: '--two=', name: 'two', value: '' }
+  ])
+})
+
+runner.test('argv-parser: --option=value, unknown option', function () {
+  const optionDefinitions = [
+    { name: 'one' }
+  ]
+  const argv = [ '--three=3' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(!result[0].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'unknown_option', arg: '--three=3', name: '_unknown', value: undefined }
+  ])
+})
+
+runner.test('argv-parser: --option=value where option is boolean', function () {
+  const optionDefinitions = [
+    { name: 'one', type: Boolean }
+  ]
+  const argv = [ '--one=1' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'unknown_value', arg: '--one=1', name: '_unknown', value: undefined },
+    { event: 'set', arg: '--one=1', name: 'one', value: true }
+  ])
+})
+
+runner.test('argv-parser: short option, string', function () {
+  const optionDefinitions = [
+    { name: 'one', alias: 'o' }
+  ]
+  const argv = [ '-o', '1' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '-o', name: 'one', value: null },
+    { event: 'set', arg: '1', name: 'one', value: '1' }
+  ])
+})
+
+runner.test('argv-parser: combined short option, string', function () {
+  const optionDefinitions = [
+    { name: 'one', alias: 'o' },
+    { name: 'two', alias: 't' }
+  ]
+  const argv = [ '-ot', '1' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'set', arg: '-ot', subArg: '-o', name: 'one', value: null },
+    { event: 'set', arg: '-ot', subArg: '-t', name: 'two', value: null },
+    { event: 'set', arg: '1', name: 'two', value: '1' }
+  ])
+})
+
+runner.test('argv-parser: combined short option, one unknown', function () {
+  const optionDefinitions = [
+    { name: 'one', alias: 'o' },
+    { name: 'two', alias: 't' }
+  ]
+  const argv = [ '-xt', '1' ]
+  const parser = new ArgvParser(optionDefinitions, { argv })
+  const result = Array.from(parser)
+  a.ok(!result[0].def)
+  a.ok(result[1].def)
+  a.ok(result[2].def)
+  result.forEach(r => delete r.def)
+  a.deepStrictEqual(result, [
+    { event: 'unknown_option', arg: '-xt', subArg: '-x', name: '_unknown', value: undefined },
+    { event: 'set', arg: '-xt', subArg: '-t', name: 'two', value: null },
+    { event: 'set', arg: '1', name: 'two', value: '1' }
+  ])
+})

node_modules/command-line-args/test/internals/option-default.js

@@ -0,0 +1,35 @@
+'use strict'
+const TestRunner = require('test-runner')
+const Option = require('../../lib/option')
+const a = require('assert')
+
+const runner = new TestRunner()
+
+runner.test('option.set(): defaultValue', function () {
+  const option = new Option({ name: 'two', defaultValue: 'two' })
+  a.strictEqual(option.get(), 'two')
+  option.set('zwei')
+  a.strictEqual(option.get(), 'zwei')
+})
+
+runner.test('option.set(): multiple defaultValue', function () {
+  const option = new Option({ name: 'two', multiple: true, defaultValue: [ 'two', 'zwei' ] })
+  a.deepStrictEqual(option.get(), [ 'two', 'zwei' ])
+  option.set('duo')
+  a.deepStrictEqual(option.get(), [ 'duo' ])
+})
+
+runner.test('option.set(): falsy defaultValue', function () {
+  const option = new Option({ name: 'one', defaultValue: 0 })
+  a.strictEqual(option.get(), 0)
+})
+
+runner.test('option.set(): falsy defaultValue 2', function () {
+  const option = new Option({ name: 'two', defaultValue: false })
+  a.strictEqual(option.get(), false)
+})
+
+runner.test('option.set(): falsy defaultValue multiple', function () {
+  const option = new Option({ name: 'one', defaultValue: 0, multiple: true })
+  a.deepStrictEqual(option.get(), [ 0 ])
+})

node_modules/command-line-args/test/internals/option-definitions.js

@@ -0,0 +1,28 @@
+'use strict'
+const TestRunner = require('test-runner')
+const a = require('assert')
+const Definitions = require('../../lib/option-definitions')
+
+const runner = new TestRunner()
+
+runner.test('.get(long option)', function () {
+  const definitions = Definitions.from([ { name: 'one' } ])
+  a.strictEqual(definitions.get('--one').name, 'one')
+})
+
+runner.test('.get(short option)', function () {
+  const definitions = Definitions.from([ { name: 'one', alias: 'o' } ])
+  a.strictEqual(definitions.get('-o').name, 'one')
+})
+
+runner.test('.get(name)', function () {
+  const definitions = Definitions.from([ { name: 'one' } ])
+  a.strictEqual(definitions.get('one').name, 'one')
+})
+
+runner.test('.validate()', function () {
+  a.throws(function () {
+    const definitions = new Definitions()
+    definitions.load([ { name: 'one' }, { name: 'one' } ])
+  })
+})

node_modules/command-line-args/test/internals/option-flag.js

@@ -0,0 +1,55 @@
+'use strict'
+const TestRunner = require('test-runner')
+const FlagOption = require('../../lib/option-flag')
+const a = require('assert')
+
+const runner = new TestRunner()
+
+runner.test('type-boolean: single set', function () {
+  const option = new FlagOption({ name: 'one', type: Boolean })
+
+  option.set(undefined)
+  a.strictEqual(option.get(), true)
+})
+
+runner.test('type-boolean: single set 2', function () {
+  const option = new FlagOption({ name: 'one', type: Boolean })
+
+  option.set('true')
+  a.strictEqual(option.get(), true)
+})
+
+runner.test('type-boolean: set twice', function () {
+  const option = new FlagOption({ name: 'one', type: Boolean })
+
+  option.set(undefined)
+  a.strictEqual(option.get(), true)
+  a.throws(
+    () => option.set('true'),
+    err => err.name === 'ALREADY_SET'
+  )
+})
+
+const origBoolean = Boolean
+
+/* test in contexts which override the standard global Boolean constructor */
+runner.test('type-boolean: global Boolean overridden', function () {
+  function Boolean () {
+    return origBoolean.apply(origBoolean, arguments)
+  }
+
+  const option = new FlagOption({ name: 'one', type: Boolean })
+
+  option.set()
+  a.strictEqual(option.get(), true)
+})
+
+runner.test('type-boolean-multiple: 1', function () {
+  const option = new FlagOption({ name: 'one', type: Boolean, multiple: true })
+
+  option.set(undefined)
+  option.set(undefined)
+  option.set(undefined)
+
+  a.deepStrictEqual(option.get(), [ true, true, true ])
+})

node_modules/command-line-args/test/internals/option.js

@@ -0,0 +1,98 @@
+'use strict'
+const TestRunner = require('test-runner')
+const Option = require('../../lib/option')
+const a = require('assert')
+
+const runner = new TestRunner()
+
+runner.test('option.set(): simple set string', function () {
+  const option = Option.create({ name: 'two' })
+  a.strictEqual(option.get(), null)
+  a.strictEqual(option.state, 'default')
+  option.set('zwei')
+  a.strictEqual(option.get(), 'zwei')
+  a.strictEqual(option.state, 'set')
+})
+
+runner.test('option.set(): simple set boolean', function () {
+  const option = Option.create({ name: 'two', type: Boolean })
+  a.strictEqual(option.get(), null)
+  a.strictEqual(option.state, 'default')
+  option.set()
+  a.strictEqual(option.get(), true)
+  a.strictEqual(option.state, 'set')
+})
+
+runner.test('option.set(): simple set string twice', function () {
+  const option = Option.create({ name: 'two' })
+  a.strictEqual(option.get(), null)
+  a.strictEqual(option.state, 'default')
+  option.set('zwei')
+  a.strictEqual(option.get(), 'zwei')
+  a.strictEqual(option.state, 'set')
+  a.throws(
+    () => option.set('drei'),
+    err => err.name === 'ALREADY_SET'
+  )
+})
+
+runner.test('option.set(): simple set boolean twice', function () {
+  const option = Option.create({ name: 'two', type: Boolean })
+  a.strictEqual(option.get(), null)
+  a.strictEqual(option.state, 'default')
+  option.set()
+  a.strictEqual(option.get(), true)
+  a.strictEqual(option.state, 'set')
+  a.throws(
+    () => option.set(),
+    err => err.name === 'ALREADY_SET'
+  )
+})
+
+runner.test('option.set(): string multiple', function () {
+  const option = Option.create({ name: 'two', multiple: true })
+  a.deepStrictEqual(option.get(), [])
+  a.strictEqual(option.state, 'default')
+  option.set('1')
+  a.deepStrictEqual(option.get(), [ '1' ])
+  a.strictEqual(option.state, 'set')
+  option.set('2')
+  a.deepStrictEqual(option.get(), [ '1', '2' ])
+  a.strictEqual(option.state, 'set')
+})
+
+runner.test('option.set: lazyMultiple', function () {
+  const option = Option.create({ name: 'one', lazyMultiple: true })
+  a.deepStrictEqual(option.get(), [])
+  a.strictEqual(option.state, 'default')
+  option.set('1')
+  a.deepStrictEqual(option.get(), [ '1' ])
+  a.strictEqual(option.state, 'set')
+  option.set('2')
+  a.deepStrictEqual(option.get(), [ '1', '2' ])
+  a.strictEqual(option.state, 'set')
+})
+
+runner.test('option.set(): string multiple defaultOption', function () {
+  const option = Option.create({ name: 'two', multiple: true, defaultOption: true })
+  a.deepStrictEqual(option.get(), [])
+  a.strictEqual(option.state, 'default')
+  option.set('1')
+  a.deepStrictEqual(option.get(), [ '1' ])
+  a.strictEqual(option.state, 'set')
+  option.set('2')
+  a.deepStrictEqual(option.get(), [ '1', '2' ])
+  a.strictEqual(option.state, 'set')
+})
+
+runner.test('option.set: lazyMultiple defaultOption', function () {
+  const option = Option.create({ name: 'one', lazyMultiple: true, defaultOption: true })
+  a.deepStrictEqual(option.get(), [])
+  a.strictEqual(option.state, 'default')
+  option.set('1')
+  a.deepStrictEqual(option.get(), [ '1' ])
+  a.strictEqual(option.state, 'set')
+  option.set('2')
+  a.deepStrictEqual(option.get(), [ '1', '2' ])
+  a.strictEqual(option.state, 'set')
+})

node_modules/command-line-args/test/internals/output.js

@@ -0,0 +1,26 @@
+'use strict'
+const TestRunner = require('test-runner')
+const a = require('assert')
+const Output = require('../../lib/output')
+
+const runner = new TestRunner()
+
+runner.test('output.toObject(): no defs set', function () {
+  const output = new Output([
+    { name: 'one' }
+  ])
+  a.deepStrictEqual(output.toObject(), {})
+})
+
+runner.test('output.toObject(): one def set', function () {
+  const output = new Output([
+    { name: 'one' }
+  ])
+  const Option = require('../../lib/option')
+  const option = Option.create({ name: 'one' })
+  option.set('yeah')
+  output.set('one', option)
+  a.deepStrictEqual(output.toObject(), {
+    one: 'yeah'
+  })
+})