rename toPreset.. default output function.. more tests

Author: 75lb

dist/index.cjs

@@ -92,7 +92,7 @@ function getFromIndex (arr, find) {
   const fromFns = arrayBack(find).map(convertToFunction);
 
   if (fromFns.length === 0) {
-    throw new Error('from required')
+    throw new Error('from/single required') // TODO: obviously broken semantically
   }
 
   let fromIndex;
@@ -132,6 +132,8 @@ function positional (arr, fromIndex, options = {}) {
   return output
 }
 
+function defaultOutput (val) { return val }
+
 /* TODO: factor out into a FromTo Extractor-derived class as relevant only to from-to. */
 const toPresets = {
   singleOptionValue (arg, index, argv, valueIndex) {
@@ -161,13 +163,11 @@ class CommandLineArgs {
 
     const notPositionals = optionDefinitions.filter(d => d.extractor !== 'positional');
     for (const def of notPositionals) {
+      def.output ||= defaultOutput;
       let extraction;
       if (def.extractor === 'fromTo') {
-        extraction = fromTo(this.argv, {
-          from: def.from,
-          to: toPresets[def.to],
-          remove: true
-        });
+        const to = def.toPreset ? toPresets[def.toPreset] : def.to;
+        extraction = fromTo(this.argv, { from: def.from, to, remove: true });
       } else if (def.extractor === 'single') {
         extraction = single(this.argv, def.single, { remove: true });
       } else {
@@ -187,6 +187,7 @@ class CommandLineArgs {
 
     if (positionals.length) {
       for (const def of positionals) {
+        def.output ||= defaultOutput;
         const extraction = positional(this.argv, def.position - 1, { remove: true });
         if (extraction.length) {
           result[def.name] = def.output(extraction);

index.js

@@ -1,5 +1,7 @@
 import { fromTo, single, positional } from './lib/from-to.js'
 
+function defaultOutput (val) { return val }
+
 /* TODO: factor out into a FromTo Extractor-derived class as relevant only to from-to. */
 const toPresets = {
   singleOptionValue (arg, index, argv, valueIndex) {
@@ -29,13 +31,11 @@ class CommandLineArgs {
 
     const notPositionals = optionDefinitions.filter(d => d.extractor !== 'positional')
     for (const def of notPositionals) {
+      def.output ||= defaultOutput
       let extraction
       if (def.extractor === 'fromTo') {
-        extraction = fromTo(this.argv, {
-          from: def.from,
-          to: toPresets[def.to],
-          remove: true
-        })
+        const to = def.toPreset ? toPresets[def.toPreset] : def.to
+        extraction = fromTo(this.argv, { from: def.from, to, remove: true })
       } else if (def.extractor === 'single') {
         extraction = single(this.argv, def.single, { remove: true })
       } else {
@@ -55,6 +55,7 @@ class CommandLineArgs {
 
     if (positionals.length) {
       for (const def of positionals) {
+        def.output ||= defaultOutput
         const extraction = positional(this.argv, def.position - 1, { remove: true })
         if (extraction.length) {
           result[def.name] = def.output(extraction)

lib/from-to.js

@@ -90,7 +90,7 @@ function getFromIndex (arr, find) {
   const fromFns = arrayBack(find).map(convertToFunction)
 
   if (fromFns.length === 0) {
-    throw new Error('from required')
+    throw new Error('from/single required') // TODO: obviously broken semantically
   }
 
   let fromIndex

test/from-to.js

@@ -13,11 +13,29 @@ test.set('from and to: string inputs', async function () {
   a.deepEqual(arr, ['one', 'here', '--', '--', '--', 'here', '--', '--', '--', 'there'])
 })
 
+test.set('from and to: from array', async function () {
+  const arr = ['one', '-o', 'two', '-v']
+  const result = fromTo(arr, {
+    from: ['--option', '-o'],
+    to: ['--version', '-v']
+  })
+  a.deepEqual(result, [ '-o', 'two' ])
+})
+
+test.set('from and to: from array 2', async function () {
+  const arr = ['one', '-o', 'two', '--version']
+  const result = fromTo(arr, {
+    from: ['--option', '-o'],
+    to: ['--version', '-v']
+  })
+  a.deepEqual(result, [ '-o', 'two' ])
+})
+
 test.set('from and to: function inputs', async function () {
   const arr = ['one', 'here', '--', '--', '--', 'here', '--', '--', '--', 'there']
   const result = fromTo(arr, {
     from: (val) => val === 'here',
-    to: (val) => val === 'here' || val === 'there'
+    to: (val) => val === 'here' || val === 'there' // equivalent to [here, there]
   })
   a.deepEqual(result, ['here', '--', '--', '--'])
   a.deepEqual(arr, ['one', 'here', '--', '--', '--', 'here', '--', '--', '--', 'there'])

test/test.js

@@ -10,8 +10,8 @@ test.set('Input argv is not mutated', async function () {
       name: 'one',
       extractor: 'fromTo',
       from: '--one',
-      to: 'singleOptionValue', // TODO: Rename as "toPreset" to be more explicit we're using a preset.
-      output: extraction => extraction[1] // TODO: Define a FromToExtractor derived class which already includes this specific output value by default.
+      toPreset: 'singleOptionValue',
+      output: extraction => extraction[1]
     }
   ]
   const cla = new CommandLineArgs(argv)
@@ -28,7 +28,7 @@ test.set('--option <no value>', async function () {
       name: 'one',
       extractor: 'fromTo',
       from: '--one',
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: extraction => extraction[1]
     }
   ]
@@ -38,7 +38,7 @@ test.set('--option <no value>', async function () {
   a.deepEqual(cla.argv, ['one', 'two', '--two', 'three'])
 })
 
-test.set('--option flag', async function () {
+test.set('single --option flag', async function () {
   const argv = ['one', 'two', '--one', '--two']
   const optionDefinitions = [
     {
@@ -54,6 +54,28 @@ test.set('--option flag', async function () {
   a.deepEqual(cla.argv, ['one', 'two', '--two'])
 })
 
+test.set('single regex', async function () {
+  const argv = ['one', 'two', '--one', '--two']
+  const optionDefinitions = [
+    {
+      name: 'one',
+      extractor: 'single',
+      single: /--o[n]+e/,
+      output: extraction => true
+    }
+  ]
+  const cla = new CommandLineArgs(argv)
+  const result = cla.parse(optionDefinitions)
+  a.deepEqual(result, { one: true })
+  a.deepEqual(cla.argv, ['one', 'two', '--two'])
+
+  const argv2 = ['one', 'two', '--onnnnne', '--two']
+  const cla2 = new CommandLineArgs(argv2)
+  const result2 = cla2.parse(optionDefinitions)
+  a.deepEqual(result, { one: true })
+  a.deepEqual(cla.argv, ['one', 'two', '--two'])
+})
+
 test.set('--option flag not present', async function () {
   const argv = ['one', 'two', '--not-one', '--two']
   const optionDefinitions = [
@@ -90,7 +112,7 @@ test.set('Positionals must be args 1 and 2, with options following', async funct
       name: 'option',
       extractor: 'fromTo',
       from: ['--option', '-o'],
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: extraction => extraction[1]
     },
     {
@@ -157,7 +179,7 @@ test.set('Positional, one single, one from-to', async function () {
       name: 'exchange',
       extractor: 'fromTo',
       from: '--exchange',
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: extraction => extraction[1]
     },
   ])
@@ -216,7 +238,7 @@ test.set('Magic arg values: file1 file2 extra-large verbose output final', async
       name: 'output',
       extractor: 'fromTo',
       from: 'output',
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: extraction => extraction[1]
     }
     // {
@@ -265,29 +287,29 @@ test.set('self-defining options', async function () {
     '3000'
   ]
 
-  /* Instead of "dynamic definition" magic, just run the parser over argv multiple times, one for each desire result object */
+  /* Instead of "dynamic definition" magic, just run the parser over argv multiple times, one for each desired result object */
   /* Parse the args first for `--configName.optionName.optionValueType` format args, creating option definitions */
 
   const optionDefinitions = [
     {
       name: 'one',
       extractor: 'fromTo',
       from: /^--server\.string\[\]/,
-      to: 'multipleOptionValue',
+      toPreset: 'multipleOptionValue',
       output: e => e.slice(1)
     },
     {
       name: 'two',
       extractor: 'fromTo',
       from: /^--server\.number\./,
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: e => e[1]
     },
     {
       name: 'broke',
       extractor: 'fromTo',
       from: /^--server\.number\./,
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: e => Number(e[1])
     },
     {
@@ -300,7 +322,7 @@ test.set('self-defining options', async function () {
       name: 'four',
       extractor: 'fromTo',
       from: /^--server\.string\./,
-      to: 'singleOptionValue',
+      toPreset: 'singleOptionValue',
       output: e => e[1]
     }
   ]
@@ -365,4 +387,29 @@ skip.set('to not found: no args matched', async function () {
   })
 })
 
+test.set('Multiple parses to consume all args', async function () {
+  const argv = ['server', '--option', 'value', 'clive', 'server', '--verbose']
+  const commandLineArgs = new CommandLineArgs(argv)
+  const result1 = commandLineArgs.parse([
+    {
+      name: 'extraction',
+      extractor: 'fromTo',
+      from: 'server',
+      to: 'server'
+    }
+  ])
+  const result2 = commandLineArgs.parse([
+    {
+      name: 'extraction',
+      extractor: 'fromTo',
+      from: 'server',
+      to: 'server'
+    }
+  ])
+  // this.data = { result1, result2 }
+
+  a.deepEqual(result1, { extraction: [ 'server', '--option', 'value', 'clive' ] })
+  a.deepEqual(result2, { extraction: [ 'server', '--verbose'] })
+})
+
 export { test, only, skip }