cli-kiss 0.2.7 → 0.2.9

package/tests/unit.Reader.shortBig.ts

@@ -1,5 +1,5 @@
 import { expect, it } from "@jest/globals";
-import { ReaderArgs, ReaderOptionParsing } from "../src";
+import { ReaderArgs, ReaderOptionNextGuard } from "../src";
 
 it("run", async function () {
   const stream = new ReaderArgs([
@@ -19,136 +19,110 @@ it("run", async function () {
 
   expect(stream.consumePositional()).toStrictEqual("positional-0");
 
-  const kSofUnset = stream.registerOption({
-    longs: [],
-    shorts: ["sof-unset"],
-    parsing: optionFlagParsing,
+  const kSofUnset = stream.registerOptionShort({
+    key: "sof-unset",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kSofNormal = stream.registerOption({
-    shorts: ["sof-normal"],
-    longs: [],
-    parsing: optionFlagParsing,
+  const kSofNormal = stream.registerOptionShort({
+    key: "sof-normal",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kSofPositive = stream.registerOption({
-    longs: [],
-    shorts: ["sof-positive"],
-    parsing: optionFlagParsing,
+  const kSofPositive = stream.registerOptionShort({
+    key: "sof-positive",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kSofNegative = stream.registerOption({
-    longs: [],
-    shorts: ["sof-negative"],
-    parsing: optionFlagParsing,
+  const kSofNegative = stream.registerOptionShort({
+    key: "sof-negative",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
-  const kAa = stream.registerOption({
-    longs: [],
-    shorts: ["aa"],
-    parsing: optionFlagParsing,
+  const kAa = stream.registerOptionShort({
+    key: "aa",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kBb = stream.registerOption({
-    longs: [],
-    shorts: ["bb"],
-    parsing: optionFlagParsing,
+  const kBb = stream.registerOptionShort({
+    key: "bb",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kCc = stream.registerOption({
-    longs: [],
-    shorts: ["cc"],
-    parsing: optionFlagParsing,
+  const kCc = stream.registerOptionShort({
+    key: "cc",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-1");
 
-  const kSovSplit = stream.registerOption({
-    longs: [],
-    shorts: ["sov-split"],
-    parsing: optionValueFixedUniqueParsing,
+  const kSovSplit = stream.registerOptionShort({
+    key: "sov-split",
+    nextGuard: optionValuedNextGuard,
+    consumeGroupRestAsValue: true,
   });
-  const kSovJoin = stream.registerOption({
-    longs: [],
-    shorts: ["sov-join"],
-    parsing: optionValueFixedUniqueParsing,
+  const kSovJoin = stream.registerOptionShort({
+    key: "sov-join",
+    nextGuard: optionValuedNextGuard,
+    consumeGroupRestAsValue: true,
   });
-  const kSovUnset = stream.registerOption({
-    longs: [],
-    shorts: ["sov-unset"],
-    parsing: optionValueFixedUniqueParsing,
+  const kSovUnset = stream.registerOptionShort({
+    key: "sov-unset",
+    nextGuard: optionValuedNextGuard,
+    consumeGroupRestAsValue: true,
   });
 
-  const kDd = stream.registerOption({
-    longs: [],
-    shorts: ["dd"],
-    parsing: optionFlagParsing,
+  const kDd = stream.registerOptionShort({
+    key: "dd",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kEe = stream.registerOption({
-    longs: [],
-    shorts: ["ee"],
-    parsing: optionFlagParsing,
+  const kEe = stream.registerOptionShort({
+    key: "ee",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kFf = stream.registerOption({
-    longs: [],
-    shorts: ["ff"],
-    parsing: optionFlagParsing,
+
+  const kFf = stream.registerOptionShort({
+    key: "ff",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
-  const kGg = stream.registerOption({
-    longs: [],
-    shorts: ["gg"],
-    parsing: optionFlagParsing,
+  const kGg = stream.registerOptionShort({
+    key: "gg",
+    nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-2");
 
-  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(kSofUnset()).toStrictEqual([]);
+  expect(kSofNormal()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kSofPositive()).toStrictEqual([{ inlined: "true", separated: [] }]);
+  expect(kSofNegative()).toStrictEqual([{ inlined: "false", separated: [] }]);
 
-  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(kAa()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kBb()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kCc()).toStrictEqual([{ inlined: null, separated: [] }]);
 
-  expect(stream.getOptionValues(kSovUnset)).toStrictEqual([]);
-  expect(stream.getOptionValues(kSovSplit)).toStrictEqual([
+  expect(kSovUnset()).toStrictEqual([]);
+  expect(kSovSplit()).toStrictEqual([
     { inlined: null, separated: ["1.1"] },
     { inlined: null, separated: ["1.2"] },
   ]);
-  expect(stream.getOptionValues(kSovJoin)).toStrictEqual([
+  expect(kSovJoin()).toStrictEqual([
     { inlined: "2.1", separated: [] },
     { inlined: "2.2", separated: [] },
   ]);
 
-  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: [] },
-  ]);
+  expect(kDd()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kEe()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kFf()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(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,
-};
+const optionFlagNextGuard: ReaderOptionNextGuard = () => false;
+const optionValuedNextGuard: ReaderOptionNextGuard = (value) =>
+  value.inlined === null && value.separated.length === 0;

package/tests/unit.command.aliases.ts

@@ -0,0 +1,88 @@
+import { expect, it } from "@jest/globals";
+import {
+  command,
+  operation,
+  optionFlag,
+  optionRepeatable,
+  optionSingleValue,
+  ReaderArgs,
+  typeString,
+} from "../src";
+
+it("run", async function () {
+  const cmd = command(
+    { description: "Description" },
+    operation(
+      {
+        options: {
+          option: optionRepeatable({
+            long: "option",
+            type: typeString(),
+            aliases: {
+              longs: ["option-alias1", "option-alias2"],
+              shorts: ["pts", "o"],
+            },
+          }),
+          flag1: optionFlag({
+            long: "flag1",
+            aliases: { longs: ["flag1-alias"], shorts: ["fa"] },
+          }),
+          flag2: optionFlag({
+            long: "flag2",
+            aliases: { longs: ["flag2-alias"], shorts: ["fb"] },
+          }),
+          weird: optionRepeatable({
+            long: "2",
+            aliases: { shorts: ["2o"] },
+            type: typeString(),
+          }),
+          v1: optionSingleValue({
+            long: "v1",
+            aliases: { shorts: ["va"] },
+            type: typeString(),
+            impliedValueIfNotInlined: () => "bypass",
+            fallbackValueIfAbsent: () => undefined,
+          }),
+          v2: optionSingleValue({
+            long: "v2",
+            aliases: { shorts: ["vb"] },
+            type: typeString(),
+            impliedValueIfNotInlined: () => "bypass",
+            fallbackValueIfAbsent: () => undefined,
+          }),
+        },
+        positionals: [],
+      },
+      async function (_context, inputs) {
+        return inputs;
+      },
+    ),
+  );
+  const readerArgs = new ReaderArgs([
+    "--option=1.1",
+    "--option-alias1=1.2",
+    "--option-alias2",
+    "1.3",
+    "-pts=1.4",
+    "-vbva=42",
+    "-o",
+    "1.5",
+    "--flag1-alias",
+    "--2=woops",
+    "-fb2o=1.6",
+  ]);
+  const decoder = cmd.consumeAndMakeDecoder(readerArgs);
+  const interpreter = decoder.decodeAndMakeInterpreter();
+  const output = await interpreter.executeWithContext({});
+  expect(output).toStrictEqual({
+    options: {
+      option: ["1.1", "1.2", "1.3", "1.4", "1.5"],
+      flag1: true,
+      flag2: true,
+      weird: ["woops", "1.6"],
+      v1: "42",
+      v2: "bypass",
+    },
+    positionals: [],
+  });
+});

package/tests/unit.command.execute.ts

@@ -12,9 +12,9 @@ import {
   positionalRequired,
   positionalVariadics,
   ReaderArgs,
-  type,
   typeList,
   typeNumber,
+  typeString,
 } from "../src";
 
 const rootCommand = commandChained(
@@ -46,8 +46,8 @@ const rootCommand = commandChained(
         options: {
           string: optionSingleValue({
             long: "string-option",
-            type: type(),
-            defaultIfNotSpecified: () => undefined,
+            type: typeString(),
+            fallbackValueIfAbsent: () => undefined,
           }),
           number: optionRepeatable({
             long: "number-option",
@@ -66,7 +66,7 @@ const rootCommand = commandChained(
         operation(
           {
             options: {},
-            positionals: [positionalRequired({ type: type() })],
+            positionals: [positionalRequired({ type: typeString() })],
           },
           async function (context, inputs) {
             return { at: "sub1", context, inputs };
@@ -80,8 +80,8 @@ const rootCommand = commandChained(
             options: {},
             positionals: [
               positionalRequired({ type: typeNumber() }),
-              positionalOptional({ type: type(), default: () => "42" }),
-              positionalVariadics({ type: type() }),
+              positionalOptional({ type: typeString(), default: () => "42" }),
+              positionalVariadics({ type: typeString() }),
             ],
           },
           async function (context, inputs) {

package/tests/unit.command.usage.ts

@@ -1,4 +1,4 @@
-import { it } from "@jest/globals";
+import { expect, it } from "@jest/globals";
 import {
   command,
   Command,
@@ -12,10 +12,10 @@ import {
   positionalRequired,
   positionalVariadics,
   ReaderArgs,
-  type,
   typeChoice,
   typeList,
   typeNumber,
+  typeString,
   typeTuple,
   TypoSupport,
   usageToStyledLines,
@@ -37,10 +37,9 @@ const rootCommand = commandChained<any, any, any>(
       options: {
         choiceOption: optionSingleValue({
           long: "choice-option",
-          type: typeChoice("choice", ["unset", "empty", "choice1", "choice2"]),
+          type: typeChoice("choice", ["unset", "choice1", "choice2"]),
           description: "choice-option description",
-          valueIfNothingInlined: () => "empty",
-          defaultIfNotSpecified: () => "unset",
+          fallbackValueIfAbsent: () => "unset",
         }),
         booleanFlag: optionFlag({
           short: "b",
@@ -80,13 +79,13 @@ const rootCommand = commandChained<any, any, any>(
           stringOption: optionSingleValue({
             short: "s",
             long: "string-option",
-            type: type("cool-stuff"),
-            defaultIfNotSpecified: () => undefined,
+            type: typeString("cool-stuff"),
+            fallbackValueIfAbsent: () => undefined,
             description: "string-option description",
           }),
           complexOption: optionRepeatable({
             long: "complex-option",
-            type: typeTuple([typeNumber(), typeList(type("string"))]),
+            type: typeTuple([typeNumber(), typeList(typeString("string"))]),
             description: "complex-option description",
           }),
         },
@@ -128,7 +127,7 @@ const rootCommand = commandChained<any, any, any>(
             positionals: [
               positionalRequired({
                 description: "Required positional string",
-                type: type("pos-3.1"),
+                type: typeString("pos-3.1"),
               }),
             ],
           },
@@ -173,11 +172,17 @@ const rootCommand = commandChained<any, any, any>(
             options: {
               duduValue: optionSingleValue({
                 long: "dudu",
-                type: type("dudu-value"),
-                defaultIfNotSpecified: () => "duduDefault",
+                type: typeString("dudu-value"),
+                fallbackValueIfAbsent: () => "duduDefault",
                 hint: "Dudu option hint",
                 description: "Dudu option description",
               }),
+              impliable: optionSingleValue({
+                long: "impliable",
+                type: typeString("text"),
+                impliedValueIfNotInlined: () => "implied",
+                fallbackValueIfAbsent: () => "absent",
+              }),
             },
             positionals: [
               positionalRequired({
@@ -187,12 +192,12 @@ const rootCommand = commandChained<any, any, any>(
               positionalOptional({
                 description: "Optional positional string",
                 hint: "Optional positional hint",
-                type: type("pos-4"),
+                type: typeString("pos-4"),
                 default: () => "42",
               }),
               positionalVariadics({
                 description: "Variadic positionals strings",
-                type: type("pos-5"),
+                type: typeString("pos-5"),
               }),
             ],
           },
@@ -308,6 +313,7 @@ it("run", async function () {
     "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<cool-stuff>}@darkBlue}+                      string-option description",
     "      {{--complex-option}@darkCyan}+ {{<number,string[,string]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
     "      {{--dudu}@darkCyan}+ {{<dudu-value>}@darkBlue}+                               Dudu option description {{(Dudu option hint)}-}*",
+    "      {{--impliable}@darkCyan}+{{[=text]}-}*",
     "",
     "{{Examples:}@darkGreen}+",
     " {{# Example usage of subcommand 2}-}*",

package/tests/unit.fuzzed.alternatives.ts

@@ -1,34 +1,43 @@
-import { it } from "@jest/globals";
-import { similaritySort } from "../src/lib/Similarity";
+import { expect, it } from "@jest/globals";
+import { TypoString, TypoText } from "../src";
+import { suggestTextPushMessage } from "../src/lib/Suggest";
 
 it("run", async function () {
-  expect(
-    orderBySimilarity("--inst", ["--flag", "--blah", "--install"]),
-  ).toStrictEqual(["--install", "--flag", "--blah"]);
+  expectReasonables(["--flag", "--blah", "--install"], "--inst", ["--install"]);
+  expectReasonables(["install", "dudu", "--blah"], "instlal", ["install"]);
+  expectReasonables(["hello", "kat", "cats"], "cat", ["cats", "kat"]);
+  expectReasonables(["cut", "kat"], "cat", ["cut", "kat"]);
+  expectReasonables(["abc", "ac", "ab"], "acb", ["abc", "ac", "ab"]);
 
-  expect(
-    orderBySimilarity("instlal", ["install", "dudu", "--blah"]),
-  ).toStrictEqual(["install", "--blah", "dudu"]);
-
-  expect(
-    orderBySimilarity("cat", ["cats", "catz", "cut", "kat", "hello", "world"]),
-  ).toStrictEqual(["cats", "catz", "cut", "kat", "hello", "world"]);
-
-  expect(orderBySimilarity("cat", ["cut", "kat"])).toStrictEqual([
-    "cut",
-    "kat",
-  ]);
-
-  expect(orderBySimilarity("acb", ["abc", "ac", "ab"])).toStrictEqual([
-    "abc",
-    "ac",
-    "ab",
+  const library = [
+    "install",
+    "install-package",
+    "install-package-latest",
+    "uninstall",
+    "update",
+    "list",
+  ];
+  expectReasonables(library, "instal", ["install", "uninstall"]);
+  expectReasonables(library, "insta-package", ["install-package"]);
+  expectReasonables(library, "insta-package-lates", ["install-package-latest"]);
+  expectReasonables(library, "install-package-lat", [
+    "install-package-latest",
+    "install-package",
   ]);
 });
 
-function orderBySimilarity(reference: string, candidates: Array<string>) {
-  return similaritySort(
-    reference,
-    candidates.map((key) => ({ key, value: key })),
+function expectReasonables(
+  references: Array<string>,
+  query: string,
+  reasonables: Array<string>,
+) {
+  const text = new TypoText();
+  suggestTextPushMessage(
+    text,
+    query,
+    references.map((key) => ({ reference: key, hint: new TypoString(key) })),
+  );
+  expect(text.computeRawString()).toStrictEqual(
+    " Did you mean: " + reasonables.join(", ") + " ?",
   );
 }

package/tests/unit.runner.colors.ts

@@ -1,4 +1,4 @@
-import { it } from "@jest/globals";
+import { expect, it } from "@jest/globals";
 import {
   command,
   operation,
@@ -33,12 +33,12 @@ const usageTty = usageToStyledLines({
 }).join("\n");
 
 const unknownOptionNone =
-  'Error: Unknown option: "--color": did you mean: --help, --version ?';
+  'Error: Unknown option: "--color". Did you mean: --help, --version ?';
 const unknownOptionMock =
-  '{{Error:}@darkRed}+ Unknown option: {{"--color"}@darkYellow}+: did you mean: {{--help}@darkCyan}+, {{--version}@darkCyan}+ ?';
+  '{{Error:}@darkRed}+ Unknown option: {{"--color"}@darkYellow}+. Did you mean: {{--help}@darkCyan}+, {{--version}@darkCyan}+ ?';
 
 it("run", async function () {
-  await withEnv("FORCE_COLOR", "false", async () => {
+  await withEnv("FORCE_COLOR", "", async () => {
     if (process.stdout.isTTY) {
       await testAllHelpsSuccesses(usageTty);
     } else {
@@ -55,9 +55,6 @@ it("run", async function () {
       await withEnv("NO_COLOR", "", async () => {
         await testAllHelpsSuccesses(usageTty);
       });
-      await withEnv("MOCK_COLOR", "", async () => {
-        await testAllHelpsSuccesses(usageTty);
-      });
       await withEnv("TERM", "dumb", async () => {
         await testAllHelpsSuccesses(usageTty);
       });
@@ -72,32 +69,12 @@ it("run", async function () {
     await withEnv("FORCE_COLOR", "0", async () => {
       await testAllHelpsSuccesses(usageNone);
     });
-    await withEnv("MOCK_COLOR", "true", async () => {
-      await testAllHelpsSuccesses(usageMock);
-    });
-
-    await withEnv("MOCK_COLOR", "1", async () => {
-      await testCase(
-        "flag",
-        ["--color=42"],
-        [],
-        [
-          usageMock,
-          '{{Error:}@darkRed}+ {{--color}@darkCyan}+: {{<color-mode>}@darkBlue}+: Unknown value: {{"42"}@darkYellow}+: did you mean: {{"auto"}@darkYellow}+, {{"always"}@darkYellow}+, {{"never"}@darkYellow}+ ?',
-        ],
-        1,
-      );
-    });
 
-    await withEnv("MOCK_COLOR", "1", async () => {
-      await testAllFlagsFailures("env", usageMock, unknownOptionMock);
-    });
+    await testAllFlagsFailures("mock", usageMock, unknownOptionMock);
+    await testAllFlagsFailures("never", usageNone, unknownOptionNone);
     await withEnv("FORCE_COLOR", "0", async () => {
       await testAllFlagsFailures("env", usageNone, unknownOptionNone);
     });
-
-    await testAllFlagsFailures("mock", usageMock, unknownOptionMock);
-    await testAllFlagsFailures("never", usageNone, unknownOptionNone);
   });
 });
 
@@ -106,24 +83,22 @@ async function testAllFlagsFailures(
   usageErr: string,
   message: string,
 ) {
+  await testCase(colorSetup, ["--color"], [], [usageErr, message], 1);
   await testCase(colorSetup, ["--color=auto"], [], [usageErr, message], 1);
   await testCase(colorSetup, ["--color=always"], [], [usageErr, message], 1);
   await testCase(colorSetup, ["--color=never"], [], [usageErr, message], 1);
-  await testCase(colorSetup, ["--color=mock"], [], [usageErr, message], 1);
-  await testCase(colorSetup, ["--color"], [], [usageErr, message], 1);
 }
 
 async function testAllHelpsSuccesses(usageFromEnv: string) {
   await testCase("flag", ["--color=auto", "--help"], [usageFromEnv], [], 0);
   await testCase("flag", ["--color=always", "--help"], [usageTty], [], 0);
   await testCase("flag", ["--color=never", "--help"], [usageNone], [], 0);
-  await testCase("flag", ["--color=mock", "--help"], [usageMock], [], 0);
   await testCase("flag", ["--color", "--help"], [usageTty], [], 0);
   await testCase("flag", ["--help"], [usageFromEnv], [], 0);
-  await testCase("env", ["--help"], [usageFromEnv], [], 0);
   await testCase("always", ["--help"], [usageTty], [], 0);
   await testCase("never", ["--help"], [usageNone], [], 0);
   await testCase("mock", ["--help"], [usageMock], [], 0);
+  await testCase("env", ["--help"], [usageFromEnv], [], 0);
 }
 
 async function testCase(