cli-kiss 0.2.2 → 0.2.4

package/tests/unit.Reader.shortBig.ts

@@ -1,7 +1,7 @@
 import { expect, it } from "@jest/globals";
-import { ReaderArgs } from "../src";
+import { ReaderArgs, ReaderOptionParsing } from "../src";
 
-it("run", async () => {
+it("run", async function () {
   const stream = new ReaderArgs([
     "positional-0",
     "-aasof-normal",
@@ -12,47 +12,48 @@ it("run", async () => {
     "1.1",
     "-eesov-split",
     "1.2",
-    "-ffsov-join=2",
+    "-ffsov-join=2.1",
+    "-ggsov-join=2.2",
     "positional-2",
   ]);
 
   expect(stream.consumePositional()).toStrictEqual("positional-0");
 
+  const kSofUnset = stream.registerOption({
+    longs: [],
+    shorts: ["sof-unset"],
+    parsing: optionFlagParsing,
+  });
   const kSofNormal = stream.registerOption({
     shorts: ["sof-normal"],
     longs: [],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kSofPositive = stream.registerOption({
     longs: [],
     shorts: ["sof-positive"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kSofNegative = stream.registerOption({
     longs: [],
     shorts: ["sof-negative"],
-    valued: false,
-  });
-  const kSofUnset = stream.registerOption({
-    longs: [],
-    shorts: ["sof-unset"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
 
   const kAa = stream.registerOption({
     longs: [],
     shorts: ["aa"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kBb = stream.registerOption({
     longs: [],
     shorts: ["bb"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kCc = stream.registerOption({
     longs: [],
     shorts: ["cc"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-1");
@@ -60,51 +61,94 @@ it("run", async () => {
   const kSovSplit = stream.registerOption({
     longs: [],
     shorts: ["sov-split"],
-    valued: true,
+    parsing: optionValueFixedUniqueParsing,
   });
   const kSovJoin = stream.registerOption({
     longs: [],
     shorts: ["sov-join"],
-    valued: true,
+    parsing: optionValueFixedUniqueParsing,
   });
   const kSovUnset = stream.registerOption({
     longs: [],
     shorts: ["sov-unset"],
-    valued: true,
+    parsing: optionValueFixedUniqueParsing,
   });
 
   const kDd = stream.registerOption({
     longs: [],
     shorts: ["dd"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kEe = stream.registerOption({
     longs: [],
     shorts: ["ee"],
-    valued: false,
+    parsing: optionFlagParsing,
   });
   const kFf = stream.registerOption({
     longs: [],
     shorts: ["ff"],
-    valued: false,
+    parsing: optionFlagParsing,
+  });
+  const kGg = stream.registerOption({
+    longs: [],
+    shorts: ["gg"],
+    parsing: optionFlagParsing,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-2");
 
-  expect(stream.getOptionValues(kSofNormal)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kSofPositive)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kSofNegative)).toStrictEqual(["false"]);
   expect(stream.getOptionValues(kSofUnset)).toStrictEqual([]);
+  expect(stream.getOptionValues(kSofNormal)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kSofPositive)).toStrictEqual([
+    { inlined: "true", separated: [] },
+  ]);
+  expect(stream.getOptionValues(kSofNegative)).toStrictEqual([
+    { inlined: "false", separated: [] },
+  ]);
 
-  expect(stream.getOptionValues(kAa)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kBb)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kCc)).toStrictEqual(["true"]);
+  expect(stream.getOptionValues(kAa)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kBb)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kCc)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
 
   expect(stream.getOptionValues(kSovUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kSovSplit)).toStrictEqual(["1.1", "1.2"]);
-  expect(stream.getOptionValues(kSovJoin)).toStrictEqual(["2"]);
+  expect(stream.getOptionValues(kSovSplit)).toStrictEqual([
+    { inlined: null, separated: ["1.1"] },
+    { inlined: null, separated: ["1.2"] },
+  ]);
+  expect(stream.getOptionValues(kSovJoin)).toStrictEqual([
+    { inlined: "2.1", separated: [] },
+    { inlined: "2.2", separated: [] },
+  ]);
 
-  expect(stream.getOptionValues(kDd)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kEe)).toStrictEqual(["true"]);
-  expect(stream.getOptionValues(kFf)).toStrictEqual(["true"]);
+  expect(stream.getOptionValues(kDd)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kEe)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kFf)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
+  expect(stream.getOptionValues(kGg)).toStrictEqual([
+    { inlined: null, separated: [] },
+  ]);
 });
+
+const optionFlagParsing: ReaderOptionParsing = {
+  consumeShortGroup: false,
+  consumeNextArg: () => false,
+};
+
+const optionValueFixedUniqueParsing: ReaderOptionParsing = {
+  consumeShortGroup: true,
+  consumeNextArg: (inlined, separated) =>
+    inlined === null && separated.length === 0,
+};

package/tests/unit.command.execute.ts

@@ -2,6 +2,7 @@ import { expect, it } from "@jest/globals";
 import {
   command,
   Command,
+  commandChained,
   commandWithSubcommands,
   operation,
   optionFlag,
@@ -16,128 +17,182 @@ import {
   typeString,
 } from "../src";
 
-const rootCommand = commandWithSubcommands<string, any, any>(
-  { description: "Root command description" },
+const rootCommand = commandChained(
+  { description: "?" },
   operation(
     {
       options: {
-        booleanFlag: optionFlag({
-          long: "boolean-flag",
-          default: () => false,
+        flagPositive: optionFlag({
+          short: "fp",
+          long: "flag-positive",
+          default: true,
         }),
-        stringOption: optionSingleValue({
-          long: "string-option",
-          type: typeString,
-          default: () => undefined,
-        }),
-        numberOption: optionRepeatable({
-          long: "number-option",
-          type: typeList(typeNumber),
+        flagNegative: optionFlag({
+          short: "fn",
+          long: "flag-negative",
+          default: false,
         }),
       },
-      positionals: [
-        positionalRequired({ type: typeNumber }),
-        positionalRequired({ type: typeNumber }),
-      ],
+      positionals: [positionalRequired({ label: "POS-1", type: typeNumber })],
     },
-    async (context, inputs) => {
+    async function (context, inputs) {
       return { at: "root", context, inputs };
     },
   ),
-  {
-    sub1: command(
-      { description: "Subcommand 1 description" },
-      operation(
-        {
-          options: {},
-          positionals: [positionalRequired({ type: typeString })],
-        },
-        async (context, inputs) => {
-          return { at: "sub1", context, inputs };
+  commandWithSubcommands<any, any, any>(
+    { description: "?" },
+    operation(
+      {
+        options: {
+          string: optionSingleValue({
+            long: "string-option",
+            type: typeString,
+            default: () => undefined,
+          }),
+          number: optionRepeatable({
+            long: "number-option",
+            type: typeList(typeNumber),
+          }),
         },
-      ),
+        positionals: [positionalRequired({ type: typeNumber })],
+      },
+      async function (context, inputs) {
+        return { at: "mid", context, inputs };
+      },
     ),
-    sub2: command(
-      { description: "Subcommand 2 description" },
-      operation(
-        {
-          options: {},
-          positionals: [
-            positionalRequired({ type: typeNumber }),
-            positionalOptional({ type: typeString, default: () => "42" }),
-            positionalVariadics({ type: typeString }),
-          ],
-        },
-        async (context, inputs) => {
-          return { at: "sub2", context, inputs };
-        },
+    {
+      sub1: command(
+        { description: "?" },
+        operation(
+          {
+            options: {},
+            positionals: [positionalRequired({ type: typeString })],
+          },
+          async function (context, inputs) {
+            return { at: "sub1", context, inputs };
+          },
+        ),
       ),
-    ),
-  },
+      sub2: command(
+        { description: "?" },
+        operation(
+          {
+            options: {},
+            positionals: [
+              positionalRequired({ type: typeNumber }),
+              positionalOptional({ type: typeString, default: () => "42" }),
+              positionalVariadics({ type: typeString }),
+            ],
+          },
+          async function (context, inputs) {
+            return { at: "sub2", context, inputs };
+          },
+        ),
+      ),
+    },
+  ),
 );
 
-it("run", async () => {
-  const res1 = await executeInterpreted(
-    ["50", "51", "sub1", "final"],
-    "Run Context Input",
-    rootCommand,
-  );
-  expect(res1).toStrictEqual({
+it("run", async function () {
+  expect(
+    await executeInterpreted(
+      ["-fn=true", "-fp", "50", "51", "sub1", "final"],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
+    at: "sub1",
     context: {
-      context: "Run Context Input",
-      inputs: {
-        options: {
-          booleanFlag: false,
-          stringOption: undefined,
-          numberOption: [],
+      at: "mid",
+      context: {
+        at: "root",
+        context: "Run Context Input",
+        inputs: {
+          options: { flagPositive: true, flagNegative: true },
+          positionals: [50],
         },
-        positionals: [50, 51],
       },
-      at: "root",
+      inputs: {
+        options: { string: undefined, number: [] },
+        positionals: [51],
+      },
     },
     inputs: {
       options: {},
       positionals: ["final"],
     },
-    at: "sub1",
   });
 
-  const res2 = await executeInterpreted(
-    [
-      "40",
-      "41",
-      "sub2",
-      "--string-option=hello",
-      "--number-option",
-      "123.1,123.2",
-      "--number-option",
-      "123.3",
-      "88.88",
-      "a,b",
-      "final",
-      "--boolean-flag",
-    ],
-    "Run Context Input",
-    rootCommand,
-  );
-  expect(res2).toStrictEqual({
+  expect(
+    await executeInterpreted(
+      ["50", "51", "sub2", "9999.99"],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
+    at: "sub2",
     context: {
-      context: "Run Context Input",
+      at: "mid",
+      context: {
+        at: "root",
+        context: "Run Context Input",
+        inputs: {
+          options: { flagPositive: true, flagNegative: false },
+          positionals: [50],
+        },
+      },
       inputs: {
-        options: {
-          booleanFlag: true,
-          stringOption: "hello",
-          numberOption: [[123.1, 123.2], [123.3]],
+        options: { string: undefined, number: [] },
+        positionals: [51],
+      },
+    },
+    inputs: {
+      options: {},
+      positionals: [9999.99, "42", []],
+    },
+  });
+
+  expect(
+    await executeInterpreted(
+      [
+        "40",
+        "41",
+        "sub2",
+        "--string-option=hello",
+        "--number-option",
+        "123.1,123.2",
+        "--number-option",
+        "123.3",
+        "88.88",
+        "a,b",
+        "final",
+        "--no-flag-positive",
+        "--no-flag-negative",
+      ],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
+    at: "sub2",
+    context: {
+      at: "mid",
+      context: {
+        at: "root",
+        context: "Run Context Input",
+        inputs: {
+          options: { flagPositive: false, flagNegative: false },
+          positionals: [40],
         },
-        positionals: [40, 41],
       },
-      at: "root",
+      inputs: {
+        options: { string: "hello", number: [[123.1, 123.2], [123.3]] },
+        positionals: [41],
+      },
     },
     inputs: {
       options: {},
       positionals: [88.88, "a,b", ["final"]],
     },
-    at: "sub2",
   });
 });
 
@@ -147,7 +202,7 @@ async function executeInterpreted<Context, Result>(
   command: Command<Context, Result>,
 ) {
   const readerArgs = new ReaderArgs(args);
-  const commandFactory = command.createFactory(readerArgs);
-  const commandInstance = commandFactory.createInstance();
-  return await commandInstance.executeWithContext(context);
+  const commandDecoder = command.consumeAndMakeDecoder(readerArgs);
+  const commandInterpreter = commandDecoder.decodeAndMakeInterpreter();
+  return await commandInterpreter.executeWithContext(context);
 }