cli-kiss 0.2.6 → 0.2.8

package/tests/unit.command.execute.ts

@@ -47,7 +47,7 @@ const rootCommand = commandChained(
           string: optionSingleValue({
             long: "string-option",
             type: type(),
-            defaultWhenNotDefined: () => undefined,
+            fallbackValueIfAbsent: () => undefined,
           }),
           number: optionRepeatable({
             long: "number-option",

package/tests/unit.command.usage.ts

@@ -1,4 +1,4 @@
-import { it } from "@jest/globals";
+import { expect, it } from "@jest/globals";
 import {
   command,
   Command,
@@ -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",
-          defaultWhenNotInlined: () => "empty",
-          defaultWhenNotDefined: () => "unset",
+          fallbackValueIfAbsent: () => "unset",
         }),
         booleanFlag: optionFlag({
           short: "b",
@@ -81,7 +80,7 @@ const rootCommand = commandChained<any, any, any>(
             short: "s",
             long: "string-option",
             type: type("cool-stuff"),
-            defaultWhenNotDefined: () => undefined,
+            fallbackValueIfAbsent: () => undefined,
             description: "string-option description",
           }),
           complexOption: optionRepeatable({
@@ -174,10 +173,16 @@ const rootCommand = commandChained<any, any, any>(
               duduValue: optionSingleValue({
                 long: "dudu",
                 type: type("dudu-value"),
-                defaultWhenNotDefined: () => "duduDefault",
+                fallbackValueIfAbsent: () => "duduDefault",
                 hint: "Dudu option hint",
                 description: "Dudu option description",
               }),
+              impliable: optionSingleValue({
+                long: "impliable",
+                type: type("text"),
+                impliedValueIfNotInlined: () => "implied",
+                fallbackValueIfAbsent: () => "absent",
+              }),
             },
             positionals: [
               positionalRequired({
@@ -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

@@ -0,0 +1,43 @@
+import { expect, it } from "@jest/globals";
+import { TypoString, TypoText } from "../src";
+import { suggestTextPushMessage } from "../src/lib/Suggest";
+
+it("run", async function () {
+  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"]);
+
+  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 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,
@@ -32,12 +32,13 @@ 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 () => {
+  await withEnv("FORCE_COLOR", "", async () => {
     if (process.stdout.isTTY) {
       await testAllHelpsSuccesses(usageTty);
     } else {
@@ -54,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);
       });
@@ -71,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}+: Invalid value: {{"42"}@darkYellow}+ (expected one of: {{"auto"}@darkYellow}+ | {{"always"}@darkYellow}+ | {{"never"}@darkYellow}+...)',
-        ],
-        1,
-      );
-    });
-
-    await withEnv("MOCK_COLOR", "1", async () => {
-      await testAllFlagsFailures("env", usageMock, unexpectedMock);
-    });
+    await testAllFlagsFailures("mock", usageMock, unknownOptionMock);
+    await testAllFlagsFailures("never", usageNone, unknownOptionNone);
     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);
   });
 });
 
@@ -105,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(