cli-kiss 0.2.5 → 0.2.7

package/tests/unit.runner.colors.ts

@@ -2,133 +2,132 @@ import { it } from "@jest/globals";
 import {
   command,
   operation,
-  optionRepeatable,
-  positionalVariadics,
   runAndExit,
-  type,
+  RunColorMode,
   TypoSupport,
   usageToStyledLines,
 } from "../src";
 
 const cliName = "my-cli";
+const usageBase = {
+  segments: [],
+  information: { description: "Description" },
+  subcommands: [],
+  options: [],
+  positionals: [],
+};
+const usageNone = usageToStyledLines({
+  cliName,
+  usage: usageBase,
+  typoSupport: TypoSupport.none(),
+}).join("\n");
+const usageMock = usageToStyledLines({
+  cliName,
+  usage: usageBase,
+  typoSupport: TypoSupport.mock(),
+}).join("\n");
+const usageTty = usageToStyledLines({
+  cliName,
+  usage: usageBase,
+  typoSupport: TypoSupport.tty(),
+}).join("\n");
+
+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 () {
-  const usage = {
-    segments: [{ positional: "[string]..." }],
-    information: { description: "Description" },
-    subcommands: [],
-    options: [{ long: "option", label: "<string>", annotation: " [*]" }],
-    positionals: [{ label: "[string]...", description: "Variadics" }],
-  };
-  const usageNone = usageToStyledLines({
-    cliName,
-    usage,
-    typoSupport: TypoSupport.none(),
-  }).join("\n");
-  const usageMock = usageToStyledLines({
-    cliName,
-    usage,
-    typoSupport: TypoSupport.mock(),
-  }).join("\n");
-  const usageTty = usageToStyledLines({
-    cliName,
-    usage,
-    typoSupport: TypoSupport.tty(),
-  }).join("\n");
+  await withEnv("FORCE_COLOR", "false", async () => {
+    if (process.stdout.isTTY) {
+      await testAllHelpsSuccesses(usageTty);
+    } else {
+      await testAllHelpsSuccesses(usageNone);
+    }
 
-  await testCase("flag", ["--color=auto", "--help"], [usageTty], [], 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", ["--help"], [usageTty], [], 0);
-  await testCase("env", ["--help"], [usageTty], [], 0);
-  await testCase("always", ["--help"], [usageTty], [], 0);
-  await testCase("never", ["--help"], [usageNone], [], 0);
-  await testCase("mock", ["--help"], [usageMock], [], 0);
+    await withEnv("FORCE_COLOR", "1", async () => {
+      await withEnv("NO_COLOR", "1", async () => {
+        await testAllHelpsSuccesses(usageNone);
+      });
+      await withEnv("NO_COLOR", "true", async () => {
+        await testAllHelpsSuccesses(usageNone);
+      });
+      await withEnv("NO_COLOR", "", async () => {
+        await testAllHelpsSuccesses(usageTty);
+      });
+      await withEnv("MOCK_COLOR", "", async () => {
+        await testAllHelpsSuccesses(usageTty);
+      });
+      await withEnv("TERM", "dumb", async () => {
+        await testAllHelpsSuccesses(usageTty);
+      });
+    });
 
-  process.env["NO_COLOR"] = "";
-  await testCase("flag", ["--color=auto", "--help"], [usageNone], [], 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", ["--help"], [usageNone], [], 0);
-  await testCase("env", ["--help"], [usageNone], [], 0);
-  await testCase("always", ["--help"], [usageTty], [], 0);
-  await testCase("never", ["--help"], [usageNone], [], 0);
-  await testCase("mock", ["--help"], [usageMock], [], 0);
-  delete process.env["NO_COLOR"];
+    await withEnv("FORCE_COLOR", "2", async () => {
+      await testAllHelpsSuccesses(usageTty);
+    });
+    await withEnv("FORCE_COLOR", "1", async () => {
+      await testAllHelpsSuccesses(usageTty);
+    });
+    await withEnv("FORCE_COLOR", "0", async () => {
+      await testAllHelpsSuccesses(usageNone);
+    });
+    await withEnv("MOCK_COLOR", "true", async () => {
+      await testAllHelpsSuccesses(usageMock);
+    });
 
-  process.env["FORCE_COLOR"] = "";
-  await testCase("flag", ["--color=auto", "--help"], [usageTty], [], 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", ["--help"], [usageTty], [], 0);
-  await testCase("env", ["--help"], [usageTty], [], 0);
-  await testCase("always", ["--help"], [usageTty], [], 0);
-  await testCase("never", ["--help"], [usageNone], [], 0);
-  await testCase("mock", ["--help"], [usageMock], [], 0);
-  delete process.env["FORCE_COLOR"];
+    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,
+      );
+    });
 
-  process.env["FORCE_COLOR"] = "0";
-  await testCase("flag", ["--color=auto", "--help"], [usageNone], [], 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", ["--help"], [usageNone], [], 0);
-  await testCase("env", ["--help"], [usageNone], [], 0);
-  await testCase("always", ["--help"], [usageTty], [], 0);
-  await testCase("never", ["--help"], [usageNone], [], 0);
-  await testCase("mock", ["--help"], [usageMock], [], 0);
-  delete process.env["FORCE_COLOR"];
+    await withEnv("MOCK_COLOR", "1", async () => {
+      await testAllFlagsFailures("env", usageMock, unknownOptionMock);
+    });
+    await withEnv("FORCE_COLOR", "0", async () => {
+      await testAllFlagsFailures("env", usageNone, unknownOptionNone);
+    });
+
+    await testAllFlagsFailures("mock", usageMock, unknownOptionMock);
+    await testAllFlagsFailures("never", usageNone, unknownOptionNone);
+  });
+});
+
+async function testAllFlagsFailures(
+  colorSetup: "flag" | RunColorMode,
+  usageErr: string,
+  message: string,
+) {
+  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);
+}
 
-  process.env["MOCK_COLOR"] = "";
-  await testCase("flag", ["--color=auto", "--help"], [usageMock], [], 0);
+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", ["--help"], [usageMock], [], 0);
-  await testCase("env", ["--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);
-  delete process.env["MOCK_COLOR"];
-
-  process.env["MOCK_COLOR"] = "";
-  await testCase(
-    "flag",
-    ["--color=42"],
-    [],
-    [
-      usageMock,
-      '{{Error:}@darkRed}+ {{--color}@darkCyan}+: {{<color-mode>}@darkBlue}+: Invalid value: {{"42"}@darkYellow}+ (expected one of: {{"auto"}@darkYellow}+ | {{"always"}@darkYellow}+ | {{"never"}@darkYellow}+...)',
-    ],
-    1,
-  );
-  delete process.env["MOCK_COLOR"];
-
-  const unexpected1 = "Error: Unexpected unknown option: --color";
-  await testCase("never", ["--color=auto"], [], [usageNone, unexpected1], 1);
-  await testCase("never", ["--color=always"], [], [usageNone, unexpected1], 1);
-  await testCase("never", ["--color=never"], [], [usageNone, unexpected1], 1);
-  await testCase("never", ["--color=mock"], [], [usageNone, unexpected1], 1);
-  process.env["FORCE_COLOR"] = "0";
-  await testCase("env", ["--color=auto"], [], [usageNone, unexpected1], 1);
-  await testCase("env", ["--color=always"], [], [usageNone, unexpected1], 1);
-  await testCase("env", ["--color=never"], [], [usageNone, unexpected1], 1);
-  await testCase("env", ["--color=mock"], [], [usageNone, unexpected1], 1);
-  delete process.env["FORCE_COLOR"];
-
-  const unexpected2 =
-    "{{Error:}@darkRed}+ Unexpected unknown option: {{--color}@darkYellow}+";
-  await testCase("mock", ["--color=auto"], [], [usageMock, unexpected2], 1);
-  await testCase("mock", ["--color=always"], [], [usageMock, unexpected2], 1);
-  await testCase("mock", ["--color=never"], [], [usageMock, unexpected2], 1);
-  await testCase("mock", ["--color=mock"], [], [usageMock, unexpected2], 1);
-});
+}
 
 async function testCase(
-  colorSetup: "flag" | "env" | "always" | "never" | "mock",
+  colorSetup: "flag" | RunColorMode,
   cliArgs: Array<string>,
   expectStdOut: Array<string>,
   expectStdErr: Array<string>,
@@ -145,21 +144,7 @@ async function testCase(
   const onExit = makeMocked<number, never>([null as never]);
   const cmd = command<null, void>(
     { description: "Description" },
-    operation(
-      {
-        options: {
-          value: optionRepeatable({ long: "option", type: type() }),
-        },
-        positionals: [
-          positionalVariadics({ type: type(), description: "Variadics" }),
-        ],
-      },
-      async function (_, { options: { value }, positionals: [rest] }) {
-        console.log(
-          `Has executed: ${JSON.stringify(value)}, ${JSON.stringify(rest)}`,
-        );
-      },
-    ),
+    operation({ options: {}, positionals: [] }, async function () {}),
   );
   console.log = onLogStdOut.call;
   console.error = onLogStdErr.call;
@@ -195,3 +180,21 @@ function makeMocked<P, R>(returns: Array<R>) {
     },
   };
 }
+
+async function withEnv(
+  envName: string,
+  envValue: string,
+  callback: () => Promise<void>,
+) {
+  let beforeEnvValue = undefined;
+  if (envName in process.env) {
+    beforeEnvValue = process.env[envName];
+  }
+  process.env[envName] = envValue;
+  await callback();
+  if (beforeEnvValue === undefined) {
+    delete process.env[envName];
+  } else {
+    process.env[envName] = beforeEnvValue;
+  }
+}

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",