cli-kiss 0.2.3 → 0.2.5

package/tests/unit.Reader.parsings.ts

@@ -0,0 +1,50 @@
+import { expect, it } from "@jest/globals";
+import { ReaderArgs } from "../src";
+
+it("run", async function () {
+  const readerArgs1 = new ReaderArgs(["--val=1", "A", "B", "STOP", "C"]);
+  const kOptionVariadicStop = readerArgs1.registerOption({
+    longs: ["val"],
+    shorts: [],
+    parsing: {
+      consumeShortGroup: true,
+      consumeNextArg: (_inlined, separated, nextArg) =>
+        nextArg !== undefined && separated[separated.length - 1] !== "STOP",
+    },
+  });
+  expect(readerArgs1.consumePositional()).toStrictEqual("C");
+  expect(readerArgs1.consumePositional()).toStrictEqual(undefined);
+  expect(readerArgs1.getOptionValues(kOptionVariadicStop)).toStrictEqual([
+    { inlined: "1", separated: ["A", "B", "STOP"] },
+  ]);
+
+  const readerArgs2 = new ReaderArgs(["--val=1", "A", "B", "C"]);
+  const kOptionVariadicFull = readerArgs2.registerOption({
+    longs: ["val"],
+    shorts: [],
+    parsing: {
+      consumeShortGroup: true,
+      consumeNextArg: (_inlined, _separated, nextArg) => nextArg !== undefined,
+    },
+  });
+  expect(readerArgs2.consumePositional()).toStrictEqual(undefined);
+  expect(readerArgs2.getOptionValues(kOptionVariadicFull)).toStrictEqual([
+    { inlined: "1", separated: ["A", "B", "C"] },
+  ]);
+
+  const readerArgs3 = new ReaderArgs(["--val=2", "A", "B", "--val=1", "C"]);
+  const kOptionVariadicKeyed = readerArgs3.registerOption({
+    longs: ["val"],
+    shorts: [],
+    parsing: {
+      consumeShortGroup: true,
+      consumeNextArg: (inlined, separated) =>
+        separated.length < Number(inlined ?? "0"),
+    },
+  });
+  expect(readerArgs3.consumePositional()).toStrictEqual(undefined);
+  expect(readerArgs3.getOptionValues(kOptionVariadicKeyed)).toStrictEqual([
+    { inlined: "2", separated: ["A", "B"] },
+    { inlined: "1", separated: ["C"] },
+  ]);
+});

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

@@ -12,19 +12,30 @@ import {
   positionalRequired,
   positionalVariadics,
   ReaderArgs,
+  type,
   typeList,
   typeNumber,
-  typeString,
 } from "../src";
 
 const rootCommand = commandChained(
   { description: "?" },
   operation(
     {
-      options: { flag: optionFlag({ short: "b", long: "boolean-flag" }) },
-      positionals: [positionalRequired({ label: "POS-1", type: typeNumber })],
+      options: {
+        flagPositive: optionFlag({
+          short: "fp",
+          long: "flag-positive",
+          default: true,
+        }),
+        flagNegative: optionFlag({
+          short: "fn",
+          long: "flag-negative",
+          default: false,
+        }),
+      },
+      positionals: [positionalRequired({ type: typeNumber() })],
     },
-    async (context, inputs) => {
+    async function (context, inputs) {
       return { at: "root", context, inputs };
     },
   ),
@@ -35,17 +46,17 @@ const rootCommand = commandChained(
         options: {
           string: optionSingleValue({
             long: "string-option",
-            type: typeString,
-            default: () => undefined,
+            type: type(),
+            defaultWhenNotDefined: () => undefined,
           }),
           number: optionRepeatable({
             long: "number-option",
-            type: typeList(typeNumber),
+            type: typeList(typeNumber()),
           }),
         },
-        positionals: [positionalRequired({ type: typeNumber })],
+        positionals: [positionalRequired({ type: typeNumber() })],
       },
-      async (context, inputs) => {
+      async function (context, inputs) {
         return { at: "mid", context, inputs };
       },
     ),
@@ -55,9 +66,9 @@ const rootCommand = commandChained(
         operation(
           {
             options: {},
-            positionals: [positionalRequired({ type: typeString })],
+            positionals: [positionalRequired({ type: type() })],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub1", context, inputs };
           },
         ),
@@ -68,12 +79,12 @@ const rootCommand = commandChained(
           {
             options: {},
             positionals: [
-              positionalRequired({ type: typeNumber }),
-              positionalOptional({ type: typeString, default: () => "42" }),
-              positionalVariadics({ type: typeString }),
+              positionalRequired({ type: typeNumber() }),
+              positionalOptional({ type: type(), default: () => "42" }),
+              positionalVariadics({ type: type() }),
             ],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub2", context, inputs };
           },
         ),
@@ -82,13 +93,14 @@ const rootCommand = commandChained(
   ),
 );
 
-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: {
       at: "mid",
@@ -96,7 +108,7 @@ it("run", async () => {
         at: "root",
         context: "Run Context Input",
         inputs: {
-          options: { flag: false },
+          options: { flagPositive: true, flagNegative: true },
           positionals: [50],
         },
       },
@@ -111,25 +123,56 @@ it("run", async () => {
     },
   });
 
-  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: {
+      at: "mid",
+      context: {
+        at: "root",
+        context: "Run Context Input",
+        inputs: {
+          options: { flagPositive: true, flagNegative: false },
+          positionals: [50],
+        },
+      },
+      inputs: {
+        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",
+        "--flag-positive=NO",
+        "--flag-negative=false",
+      ],
+      "Run Context Input",
+      rootCommand,
+    ),
+  ).toStrictEqual({
     at: "sub2",
     context: {
       at: "mid",
@@ -137,7 +180,7 @@ it("run", async () => {
         at: "root",
         context: "Run Context Input",
         inputs: {
-          options: { flag: true },
+          options: { flagPositive: false, flagNegative: false },
           positionals: [40],
         },
       },