cli-kiss 0.2.4 → 0.2.5

package/tests/unit.runner.colors.ts

@@ -0,0 +1,197 @@
+import { it } from "@jest/globals";
+import {
+  command,
+  operation,
+  optionRepeatable,
+  positionalVariadics,
+  runAndExit,
+  type,
+  TypoSupport,
+  usageToStyledLines,
+} from "../src";
+
+const cliName = "my-cli";
+
+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 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);
+
+  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"];
+
+  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"];
+
+  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"];
+
+  process.env["MOCK_COLOR"] = "";
+  await testCase("flag", ["--color=auto", "--help"], [usageMock], [], 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("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",
+  cliArgs: Array<string>,
+  expectStdOut: Array<string>,
+  expectStdErr: Array<string>,
+  expectExit: number,
+) {
+  const onLogStdOut = makeMocked<string, void>([
+    null as unknown as void,
+    null as unknown as void,
+  ]);
+  const onLogStdErr = makeMocked<string, void>([
+    null as unknown as void,
+    null as unknown as void,
+  ]);
+  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)}`,
+        );
+      },
+    ),
+  );
+  console.log = onLogStdOut.call;
+  console.error = onLogStdErr.call;
+  await runAndExit(cliName, cliArgs, null, cmd, {
+    buildVersion: "1.0.0",
+    onExit: onExit.call,
+    colorSetup,
+  });
+  expect({
+    stdOut: onLogStdOut.history,
+    stdErr: onLogStdErr.history,
+  }).toEqual({
+    stdOut: expectStdOut,
+    stdErr: expectStdErr,
+  });
+  expect(onExit.history).toEqual([expectExit]);
+}
+
+function makeMocked<P, R>(returns: Array<R>) {
+  const history = new Array<P>();
+  return {
+    history,
+    call(p: P) {
+      history.push(p);
+      if (history.length > returns.length) {
+        throw new Error(
+          `Mocked function called more times than expected. History: ${JSON.stringify(
+            history,
+          )}, returns: ${JSON.stringify(returns)}`,
+        );
+      }
+      return returns[history.length - 1]!;
+    },
+  };
+}

package/tests/unit.runner.cycle.ts

@@ -10,46 +10,46 @@ import {
   positionalRequired,
   positionalVariadics,
   runAndExit,
-  typeMapped,
-  typeOneOf,
-  typeString,
+  type,
+  typeChoice,
+  typeConverted,
   typeUrl,
 } from "../src";
 
 it("run", async function () {
   const rootUsage = [
-    "Usage: my-cli <REQUIRED1> <SUBCOMMAND>",
+    "Usage: my-cli <required1> <subcommand>",
     "",
     "Root Description",
     "",
     "Positionals:",
-    "  <REQUIRED1>  Required1 positional description",
+    "  <required1>  Required1 positional description",
     "",
     "Subcommands:",
     "  subcommand  Subcommand Description",
     "",
     "Options:",
-    "  --flag[=no]                   Option flag description",
-    "  --repeatable <STRING> [*]     Option repeatable description",
-    "  --single-value <NUMBER-ENUM>  Option single value description",
+    "  --flag[=no]                    Option flag description",
+    "  --repeatable <string> [*]      Option repeatable description",
+    "  --single-value <enum(number)>  Option single value description",
     "",
   ].join("\n");
   const subcommandUsage = [
-    "Usage: my-cli <REQUIRED1> subcommand <REQUIRED2> [OPTIONAL] [VARIADICS]...",
+    "Usage: my-cli <required1> subcommand <required2> [optional] [variadic]...",
     "",
     "Subcommand Description",
     "",
     "Positionals:",
-    "  <REQUIRED1>     Required1 positional description",
-    "  <REQUIRED2>     Required2 positional description",
-    "  [OPTIONAL]      Optional positional description",
-    "  [VARIADICS]...  Variadics positional description",
+    "  <required1>    Required1 positional description",
+    "  <required2>    Required2 positional description",
+    "  [optional]     Optional positional description",
+    "  [variadic]...  Variadics positional description",
     "",
     "Options:",
-    "  --flag[=no]                   Option flag description",
-    "  --repeatable <STRING> [*]     Option repeatable description",
-    "  --single-value <NUMBER-ENUM>  Option single value description",
-    "  --url <URL> [*]               Option url description",
+    "  --flag[=no]                    Option flag description",
+    "  --repeatable <string> [*]      Option repeatable description",
+    "  --single-value <enum(number)>  Option single value description",
+    "  --url <url> [*]                Option url description",
     "",
   ].join("\n");
 
@@ -97,6 +97,20 @@ it("run", async function () {
   await testCase(["--version", "--help"], [rootUsage], [], 0);
   await testCase(["--help", "--version"], [rootUsage], [], 0);
 
+  // Weird help/version values inputs
+  await testCase(
+    ["--help=invalid"],
+    [],
+    [rootUsage, `Error: --help: value: Not a boolean: "invalid"`],
+    1,
+  );
+  await testCase(
+    ["--version=invalid"],
+    [],
+    [rootUsage, `Error: --version: value: Not a boolean: "invalid"`],
+    1,
+  );
+
   // Test multiple errors at once (first one should show only)
   await testCase(
     ["--invalid1", "--invalid2", "required1", "--invalid3"],
@@ -107,7 +121,7 @@ it("run", async function () {
   await testCase(
     ["required1", "unknown", "-wut", "--flag", "--single-value"],
     [],
-    [rootUsage, 'Error: <SUBCOMMAND>: Invalid value: "unknown"'],
+    [rootUsage, 'Error: <subcommand>: Invalid value: "unknown"'],
     1,
   );
 
@@ -115,19 +129,19 @@ it("run", async function () {
   await testCase(
     [],
     [],
-    [rootUsage, "Error: <REQUIRED1>: Is required, but was not provided"],
+    [rootUsage, "Error: <required1>: Is required, but was not provided"],
     1,
   );
   await testCase(
     ["required1"],
     [],
-    [rootUsage, "Error: <SUBCOMMAND>: Is required, but was not provided"],
+    [rootUsage, "Error: <subcommand>: Is required, but was not provided"],
     1,
   );
   await testCase(
     ["required1", "subcommand"],
     [],
-    [subcommandUsage, "Error: <REQUIRED2>: Is required, but was not provided"],
+    [subcommandUsage, "Error: <required2>: Is required, but was not provided"],
     1,
   );
 
@@ -147,7 +161,7 @@ it("run", async function () {
   await testCase(
     ["required1", "subcommand", "--url", "https://example.com"],
     [],
-    [subcommandUsage, "Error: <REQUIRED2>: Is required, but was not provided"],
+    [subcommandUsage, "Error: <required2>: Is required, but was not provided"],
     1,
   );
   await testCase(
@@ -167,7 +181,7 @@ it("run", async function () {
   await testCase(
     ["--flag=42", "required1", "subcommand", "required2"],
     [],
-    [subcommandUsage, 'Error: --flag: <BOOLEAN>: Boolean: Invalid value: "42"'],
+    [subcommandUsage, 'Error: --flag: value: Not a boolean: "42"'],
     1,
   );
   await testCase(
@@ -182,6 +196,12 @@ it("run", async function () {
     [],
     0,
   );
+  await testCase(
+    ["--flag", "required1", "subcommand", "required2"],
+    ["Has executed root command", "Has executed subcommand"],
+    [],
+    0,
+  );
 
   // Test option parsing errors
   await testCase(
@@ -219,7 +239,7 @@ it("run", async function () {
   await testCase(
     ["invalid"],
     [],
-    [rootUsage, "Error: <SUBCOMMAND>: Is required, but was not provided"],
+    [rootUsage, "Error: <subcommand>: Is required, but was not provided"],
     1,
   );
   await testCase(
@@ -227,7 +247,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <REQUIRED1>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
     ],
     1,
   );
@@ -236,7 +256,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <REQUIRED1>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
     ],
     1,
   );
@@ -245,7 +265,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <REQUIRED2>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required2" | "required2-bis")',
+      'Error: <required2>: Invalid value: "invalid" (expected one of: "required2" | "required2-bis")',
     ],
     1,
   );
@@ -254,7 +274,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: <REQUIRED1>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
     ],
     1,
   );
@@ -265,7 +285,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: --single-value: <NUMBER-ENUM>: NUMBER-ENUM: from: STRING-ENUM: Invalid value: "dodo" (expected one of: "42" | "43")',
+      'Error: --single-value: <enum(number)>: from: enum(string): Invalid value: "dodo" (expected one of: "42" | "43")',
     ],
     1,
   );
@@ -274,7 +294,7 @@ it("run", async function () {
     [],
     [
       subcommandUsage,
-      'Error: --single-value: <NUMBER-ENUM>: NUMBER-ENUM: from: STRING-ENUM: Invalid value: "44" (expected one of: "42" | "43")',
+      'Error: --single-value: <enum(number)>: from: enum(string): Invalid value: "44" (expected one of: "42" | "43")',
     ],
     1,
   );
@@ -289,7 +309,7 @@ it("run", async function () {
   await testCase(
     ["required1", "subcommand", "required2", "--url", "not-a-url"],
     [],
-    [subcommandUsage, 'Error: --url: <URL>: Url: Unable to parse: "not-a-url"'],
+    [subcommandUsage, 'Error: --url: <url>: Not an URL: "not-a-url"'],
     1,
   );
 
@@ -317,10 +337,7 @@ it("run", async function () {
       "43",
     ],
     [],
-    [
-      subcommandUsage,
-      "Error: --single-value: Requires a single value, but got multiple",
-    ],
+    [subcommandUsage, "Error: --single-value: Must not be set multiple times"],
     1,
   );
 });
@@ -351,29 +368,29 @@ async function testCase(
           }),
           optionRepeatable: optionRepeatable({
             long: "repeatable",
-            type: typeString,
+            type: type(),
             description: "Option repeatable description",
           }),
           optionSingleValue: optionSingleValue({
             long: "single-value",
-            type: typeMapped(typeOneOf("STRING-ENUM", ["42", "43"]), {
-              content: "NUMBER-ENUM",
-              decoder: (value) => Number(value),
-            }),
+            type: typeConverted(
+              "enum(number)",
+              typeChoice("enum(string)", ["42", "43"]),
+              (value) => Number(value),
+            ),
             description: "Option single value description",
-            default: () => 42,
+            defaultWhenNotDefined: () => 42,
           }),
         },
         positionals: [
           positionalRequired({
-            type: typeOneOf("STRING-ENUM", ["required1", "required1-bis"]),
-            label: "REQUIRED1",
+            type: typeChoice("required1", ["required1", "required1-bis"]),
             description: "Required1 positional description",
           }),
         ],
       },
-      async function () {
-        console.log("Has executed root command");
+      async function (_, _inputs) {
+        console.log(`Has executed root command`);
       },
     ),
     {
@@ -385,30 +402,27 @@ async function testCase(
               optionExtra: optionRepeatable({
                 long: "url",
                 description: "Option url description",
-                type: typeUrl,
+                type: typeUrl("url"),
               }),
             },
             positionals: [
               positionalRequired({
-                type: typeOneOf("STRING-ENUM", ["required2", "required2-bis"]),
-                label: "REQUIRED2",
+                type: typeChoice("required2", ["required2", "required2-bis"]),
                 description: "Required2 positional description",
               }),
               positionalOptional({
-                label: "OPTIONAL",
-                type: typeString,
+                type: type("optional"),
                 description: "Optional positional description",
                 default: () => "world !",
               }),
               positionalVariadics({
-                label: "VARIADICS",
-                type: typeString,
+                type: type("variadic"),
                 description: "Variadics positional description",
               }),
             ],
           },
-          async function () {
-            console.log("Has executed subcommand");
+          async function (_, _inputs) {
+            console.log(`Has executed subcommand`);
           },
         ),
       ),
@@ -418,8 +432,8 @@ async function testCase(
   console.error = onLogStdErr.call;
   await runAndExit("my-cli", args, null, cmd, {
     buildVersion: "1.0.0",
-    useTtyColors: false,
     onExit: onExit.call,
+    colorSetup: "never",
   });
   expect({
     stdOut: onLogStdOut.history,

package/tests/unit.runner.errors.ts

@@ -24,28 +24,24 @@ it("run", async function () {
     "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set multiple times",
   );
   await testCase(
-    ["--flag", "--no-flag"],
-    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set in combination with: {{--no-flag}@darkCyan}+",
-  );
-  await testCase(
-    ["--no-flag", "--no-flag"],
-    "{{Error:}@darkRed}+ {{--no-flag}@darkCyan}+: Must not be set multiple times",
+    ["--flag=invalid"],
+    '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{value}@darkMagenta}+: Not a boolean: {{"invalid"}@darkYellow}+',
   );
   await testCase(
     ["--single-value=a", "--single-value=b"],
-    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a single value, but got multiple",
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Must not be set multiple times",
   );
   await testCase(
-    ["--flag=invalid"],
-    '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{<BOOLEAN>}@darkBlue}+: {{Boolean}@darkMagenta}+: Invalid value: {{"invalid"}@darkYellow}+',
+    ["--single-value"],
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a value, but got end of input",
   );
   await testCase(
     ["--single-value=invalid"],
-    '{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<LOCATION>}@darkBlue}+: {{Url}@darkMagenta}+: Unable to parse: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Not an URL: {{"invalid"}@darkYellow}+',
   );
   await testCase(
     ["--repeatable=invalid"],
-    '{{Error:}@darkRed}+ {{--repeatable}@darkCyan}+: {{<INDEX>}@darkBlue}+: {{Number}@darkMagenta}+: Unable to parse: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ {{--repeatable}@darkCyan}+: {{<index>}@darkBlue}+: Not a number: {{"invalid"}@darkYellow}+',
   );
 });
 
@@ -58,19 +54,15 @@ async function testCase(args: Array<string>, error: string) {
     operation(
       {
         options: {
-          optionFlag: optionFlag({
-            long: "flag",
-          }),
+          optionFlag: optionFlag({ long: "flag" }),
           optionSingleValue: optionSingleValue({
-            label: "LOCATION",
             long: "single-value",
-            type: typeUrl,
-            default: () => undefined,
+            type: typeUrl("location"),
+            defaultWhenNotDefined: () => undefined,
           }),
           optionRepeatable: optionRepeatable({
-            label: "INDEX",
             long: "repeatable",
-            type: typeNumber,
+            type: typeNumber("index"),
           }),
         },
         positionals: [],
@@ -83,7 +75,7 @@ async function testCase(args: Array<string>, error: string) {
   await runAndExit("my-cli", args, null, rootCommand, {
     buildVersion: "1.0.0",
     usageOnError: false,
-    useTtyColors: "mock",
+    colorSetup: "mock",
     onExit: onExit.call,
   });
   expect(onLogStdOut.history).toEqual([]);