cli-kiss 0.2.6 → 0.2.7

package/tests/unit.fuzzed.alternatives.ts

@@ -0,0 +1,34 @@
+import { it } from "@jest/globals";
+import { similaritySort } from "../src/lib/Similarity";
+
+it("run", async function () {
+  expect(
+    orderBySimilarity("--inst", ["--flag", "--blah", "--install"]),
+  ).toStrictEqual(["--install", "--flag", "--blah"]);
+
+  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",
+  ]);
+});
+
+function orderBySimilarity(reference: string, candidates: Array<string>) {
+  return similaritySort(
+    reference,
+    candidates.map((key) => ({ key, value: key })),
+  );
+}

package/tests/unit.runner.colors.ts

@@ -32,9 +32,10 @@ const usageTty = usageToStyledLines({
   typoSupport: TypoSupport.tty(),
 }).join("\n");
 
-const unexpectedNone = "Error: Unexpected unknown option: --color";
-const unexpectedMock =
-  "{{Error:}@darkRed}+ Unexpected unknown option: {{--color}@darkYellow}+";
+const unknownOptionNone =
+  'Error: Unknown option: "--color": did you mean: --help, --version ?';
+const unknownOptionMock =
+  '{{Error:}@darkRed}+ Unknown option: {{"--color"}@darkYellow}+: did you mean: {{--help}@darkCyan}+, {{--version}@darkCyan}+ ?';
 
 it("run", async function () {
   await withEnv("FORCE_COLOR", "false", async () => {
@@ -82,21 +83,21 @@ it("run", async function () {
         [],
         [
           usageMock,
-          '{{Error:}@darkRed}+ {{--color}@darkCyan}+: {{<color-mode>}@darkBlue}+: Invalid value: {{"42"}@darkYellow}+ (expected one of: {{"auto"}@darkYellow}+ | {{"always"}@darkYellow}+ | {{"never"}@darkYellow}+...)',
+          '{{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, unexpectedMock);
+      await testAllFlagsFailures("env", usageMock, unknownOptionMock);
     });
     await withEnv("FORCE_COLOR", "0", async () => {
-      await testAllFlagsFailures("env", usageNone, unexpectedNone);
+      await testAllFlagsFailures("env", usageNone, unknownOptionNone);
     });
 
-    await testAllFlagsFailures("mock", usageMock, unexpectedMock);
-    await testAllFlagsFailures("never", usageNone, unexpectedNone);
+    await testAllFlagsFailures("mock", usageMock, unknownOptionMock);
+    await testAllFlagsFailures("never", usageNone, unknownOptionNone);
   });
 });
 

package/tests/unit.runner.cycle.ts

@@ -29,9 +29,9 @@ it("run", async function () {
     "  subcommand  Subcommand Description",
     "",
     "Options:",
-    "  --flag[=no]                    Option flag description",
-    "  --repeatable <string> [*]      Option repeatable description",
-    "  --single-value <enum(number)>  Option single value description",
+    "  -ff, --flag[=no]                    Option flag description",
+    "  -r,  --repeatable <string> [*]      Option repeatable description",
+    "  -s,  --single-value <enum(number)>  Option single value description",
     "",
   ].join("\n");
   const subcommandUsage = [
@@ -46,10 +46,10 @@ it("run", async function () {
     "  [variadic]...  Variadics positional description",
     "",
     "Options:",
-    "  --flag[=no]                    Option flag description",
-    "  --repeatable <string> [*]      Option repeatable description",
-    "  --single-value <enum(number)>  Option single value description",
-    "  --url <url> [*]                Option url description",
+    "  -ff, --flag[=no]                    Option flag description",
+    "  -r,  --repeatable <string> [*]      Option repeatable description",
+    "  -s,  --single-value <enum(number)>  Option single value description",
+    "  -u,  --url <url> [*]                Option url description",
     "",
   ].join("\n");
 
@@ -115,13 +115,19 @@ it("run", async function () {
   await testCase(
     ["--invalid1", "--invalid2", "required1", "--invalid3"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --invalid1"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--invalid1": did you mean: --single-value, --help, --version ?',
+    ],
     1,
   );
   await testCase(
     ["required1", "unknown", "-wut", "--flag", "--single-value"],
     [],
-    [rootUsage, 'Error: <subcommand>: Invalid value: "unknown"'],
+    [
+      rootUsage,
+      'Error: <subcommand>: Unknown name: "unknown": did you mean: subcommand ?',
+    ],
     1,
   );
 
@@ -149,13 +155,19 @@ it("run", async function () {
   await testCase(
     ["--url", "https://example.com"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --url"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--url": did you mean: --help, -r, --version ?',
+    ],
     1,
   );
   await testCase(
     ["required1", "--url", "https://example.com"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --url"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--url": did you mean: --help, -r, --version ?',
+    ],
     1,
   );
   await testCase(
@@ -207,13 +219,19 @@ it("run", async function () {
   await testCase(
     ["--invalid", "required1", "subcommand", "required2"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --invalid"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--invalid": did you mean: --single-value, --help, --flag ?',
+    ],
     1,
   );
   await testCase(
     ["required1", "subcommand", "required2", "--nope"],
     [],
-    [subcommandUsage, "Error: Unexpected unknown option: --nope"],
+    [
+      subcommandUsage,
+      'Error: Unknown option: "--nope": did you mean: --help, --flag, --repeatable ?',
+    ],
     1,
   );
   await testCase(
@@ -247,7 +265,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      'Error: <required1>: Unknown value: "invalid": did you mean: "required1-bis", "required1" ?',
     ],
     1,
   );
@@ -256,7 +274,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      'Error: <required1>: Unknown value: "invalid": did you mean: "required1-bis", "required1" ?',
     ],
     1,
   );
@@ -265,7 +283,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <required2>: Invalid value: "invalid" (expected one of: "required2" | "required2-bis")',
+      'Error: <required2>: Unknown value: "invalid": did you mean: "required2-bis", "required2" ?',
     ],
     1,
   );
@@ -274,7 +292,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      'Error: <required1>: Unknown value: "invalid": did you mean: "required1-bis", "required1" ?',
     ],
     1,
   );
@@ -285,7 +303,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: --single-value: <enum(number)>: from: enum(string): Invalid value: "dodo" (expected one of: "42" | "43")',
+      'Error: --single-value: <enum(number)>: from: enum(string): Unknown value: "dodo": did you mean: "42", "43" ?',
     ],
     1,
   );
@@ -294,7 +312,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: --single-value: <enum(number)>: from: enum(string): Invalid value: "44" (expected one of: "42" | "43")',
+      'Error: --single-value: <enum(number)>: from: enum(string): Unknown value: "44": did you mean: "42", "43" ?',
     ],
     1,
   );
@@ -303,7 +321,10 @@ it("run", async function () {
   await testCase(
     ["--url", "not-a-url", "required1", "subcommand", "required2"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --url"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--url": did you mean: --help, -r, --version ?',
+    ],
     1,
   );
   await testCase(
@@ -340,6 +361,62 @@ it("run", async function () {
     [subcommandUsage, "Error: --single-value: Must not be set multiple times"],
     1,
   );
+
+  // Test suggestions
+  await testCase(
+    ["required1", "subcommand", "required2", "-f"],
+    [],
+    [
+      subcommandUsage,
+      'Error: Unknown option: "-f": did you mean: -ff, -r, -s ?',
+    ],
+    1,
+  );
+  await testCase(
+    ["required1", "subcommand", "required2", "-flag"],
+    [],
+    [
+      subcommandUsage,
+      'Error: Unknown option: "-flag": did you mean: --flag, -ff, --single-value ?',
+    ],
+    1,
+  );
+  await testCase(
+    ["required1", "subcommand", "required2", "--uri"],
+    [],
+    [
+      subcommandUsage,
+      'Error: Unknown option: "--uri": did you mean: --url, --version, -r ?',
+    ],
+    1,
+  );
+  await testCase(
+    ["required1", "subcommand", "required2", "--single-"],
+    [],
+    [
+      subcommandUsage,
+      'Error: Unknown option: "--single-": did you mean: --single-value, --help, --flag ?',
+    ],
+    1,
+  );
+  await testCase(
+    ["required-bis1", "subcommand", "required2"],
+    [],
+    [
+      subcommandUsage,
+      'Error: <required1>: Unknown value: "required-bis1": did you mean: "required1-bis", "required1" ?',
+    ],
+    1,
+  );
+  await testCase(
+    ["required1", "subcomm"],
+    [],
+    [
+      rootUsage,
+      'Error: <subcommand>: Unknown name: "subcomm": did you mean: subcommand ?',
+    ],
+    1,
+  );
 });
 
 async function testCase(
@@ -364,22 +441,25 @@ async function testCase(
         options: {
           optionFlag: optionFlag({
             long: "flag",
+            short: "ff",
             description: "Option flag description",
           }),
           optionRepeatable: optionRepeatable({
             long: "repeatable",
+            short: "r",
             type: type(),
             description: "Option repeatable description",
           }),
           optionSingleValue: optionSingleValue({
             long: "single-value",
+            short: "s",
             type: typeConverted(
               "enum(number)",
               typeChoice("enum(string)", ["42", "43"]),
               (value) => Number(value),
             ),
             description: "Option single value description",
-            defaultWhenNotDefined: () => 42,
+            defaultIfNotSpecified: () => 42,
           }),
         },
         positionals: [
@@ -401,8 +481,9 @@ async function testCase(
             options: {
               optionExtra: optionRepeatable({
                 long: "url",
+                short: "u",
                 description: "Option url description",
-                type: typeUrl("url"),
+                type: typeUrl(),
               }),
             },
             positionals: [

package/tests/unit.runner.errors.ts

@@ -17,7 +17,11 @@ it("run", async function () {
   );
   await testCase(
     ["--nope"],
-    "{{Error:}@darkRed}+ Unexpected unknown option: {{--nope}@darkYellow}+",
+    '{{Error:}@darkRed}+ Unknown option: {{"--nope"}@darkYellow}+: did you mean: {{--help}@darkCyan}+, {{--flag}@darkCyan}+, {{--repeatable}@darkCyan}+ ?',
+  );
+  await testCase(
+    ["--repeat"],
+    '{{Error:}@darkRed}+ Unknown option: {{"--repeat"}@darkYellow}+: did you mean: {{--repeatable}@darkCyan}+, {{--help}@darkCyan}+, {{--flag}@darkCyan}+ ?',
   );
   await testCase(
     ["--flag", "--flag"],
@@ -58,7 +62,7 @@ async function testCase(args: Array<string>, error: string) {
           optionSingleValue: optionSingleValue({
             long: "single-value",
             type: typeUrl("location"),
-            defaultWhenNotDefined: () => undefined,
+            defaultIfNotSpecified: () => undefined,
           }),
           optionRepeatable: optionRepeatable({
             long: "repeatable",