cli-kiss 0.2.7 → 0.2.9

package/tests/unit.runner.errors.ts

@@ -1,4 +1,4 @@
-import { it } from "@jest/globals";
+import { expect, it } from "@jest/globals";
 import {
   command,
   operation,
@@ -13,39 +13,43 @@ import {
 it("run", async function () {
   await testCase(
     ["hello"],
-    '{{Error:}@darkRed}+ Unexpected argument: {{"hello"}@darkYellow}+',
+    '{{Error:}@darkRed}+ Unexpected argument: {{"hello"}@darkYellow}+.', // TODO - should we recommend help here ?
   );
   await testCase(
     ["--nope"],
-    '{{Error:}@darkRed}+ Unknown option: {{"--nope"}@darkYellow}+: did you mean: {{--help}@darkCyan}+, {{--flag}@darkCyan}+, {{--repeatable}@darkCyan}+ ?',
+    '{{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"],
-    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set multiple times",
-  );
-  await testCase(
-    ["--flag=invalid"],
-    '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{value}@darkMagenta}+: Not a boolean: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ Unknown option: {{"--repeat"}@darkYellow}+. Did you mean: {{--repeatable}@darkCyan}+ ?',
   );
   await testCase(
     ["--single-value=a", "--single-value=b"],
-    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Must not be set multiple times",
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Must not be set multiple times.",
   );
   await testCase(
     ["--single-value"],
-    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a value, but got end of input",
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a value, but got end of input.",
+  );
+  await testCase(
+    [],
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Is required, but was not set.",
   );
   await testCase(
     ["--single-value=invalid"],
-    '{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Not an URL: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Not an URL: {{"invalid"}@darkYellow}+.',
   );
   await testCase(
     ["--repeatable=invalid"],
-    '{{Error:}@darkRed}+ {{--repeatable}@darkCyan}+: {{<index>}@darkBlue}+: Not a number: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ {{--repeatable}@darkCyan}+: {{<index>}@darkBlue}+: Not a number: {{"invalid"}@darkYellow}+.',
+  );
+  await testCase(
+    ["--flag", "-f"],
+    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+, {{-f}@darkCyan}+: Must not be set multiple times.",
+  );
+  await testCase(
+    ["--flag=invalid"],
+    '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{value}@darkMagenta}+: Not a boolean: {{"invalid"}@darkYellow}+.',
   );
 });
 
@@ -58,16 +62,15 @@ async function testCase(args: Array<string>, error: string) {
     operation(
       {
         options: {
-          optionFlag: optionFlag({ long: "flag" }),
-          optionSingleValue: optionSingleValue({
-            long: "single-value",
-            type: typeUrl("location"),
-            defaultIfNotSpecified: () => undefined,
-          }),
+          optionFlag: optionFlag({ long: "flag", short: "f" }),
           optionRepeatable: optionRepeatable({
             long: "repeatable",
             type: typeNumber("index"),
           }),
+          optionSingleValue: optionSingleValue({
+            long: "single-value",
+            type: typeUrl("location"),
+          }),
         },
         positionals: [],
       },

package/src/lib/Similarity.ts

@@ -1,41 +0,0 @@
-export function similaritySort<Value>(
-  reference: string,
-  candidates: { [key: string]: Value } | Array<{ key: string; value: Value }>,
-): Array<Value> {
-  let entries = Array.isArray(candidates)
-    ? candidates.map(({ key, value }) => [key, value] as const)
-    : Object.entries(candidates);
-  const ranked = entries.map(([key, value]) => {
-    const score =
-      damerauLevenshtein(reference, key) /
-      Math.max(reference.length, key.length);
-    return { key, value, score };
-  });
-  return ranked.sort((a, b) => a.score - b.score).map((v) => v.value);
-}
-
-function damerauLevenshtein(a: string, b: string): number {
-  const m = a.length;
-  const n = b.length;
-  const dp = Array.from({ length: m + 1 }, () => Array<number>(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) {
-    dp[i]![0] = i;
-  }
-  for (let j = 0; j <= n; j++) {
-    dp[0]![j] = j;
-  }
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      dp[i]![j] = Math.min(
-        dp[i - 1]![j]! + 1,
-        dp[i]![j - 1]! + 1,
-        dp[i - 1]![j - 1]! + cost,
-      );
-      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-        dp[i]![j] = Math.min(dp[i]![j]!, dp[i - 2]![j - 2]! + cost);
-      }
-    }
-  }
-  return dp[m]![n]!;
-}

package/tests/unit.Reader.aliases.ts

@@ -1,62 +0,0 @@
-import { expect, it } from "@jest/globals";
-import { ReaderArgs, ReaderOptionParsing } from "../src";
-
-it("run", async function () {
-  const readerArgs = new ReaderArgs([
-    "--option=1.1",
-    "--option-alias1=1.2",
-    "--option-alias2",
-    "1.3",
-    "-pts=1.4",
-    "-o",
-    "1.5",
-    "--flag1-alias",
-    "-fa2=woops",
-    "-fa2o=1.6",
-  ]);
-
-  const kOption = readerArgs.registerOption({
-    longs: ["option", "option-alias1", "option-alias2"],
-    shorts: ["pts", "o"],
-    parsing: optionValueFixedUniqueParsing,
-  });
-  const kFlag1 = readerArgs.registerOption({
-    longs: ["flag1", "flag1-alias"],
-    shorts: [],
-    parsing: optionFlagParsing,
-  });
-  const kFlag2 = readerArgs.registerOption({
-    longs: ["flag2"],
-    shorts: ["fa2"],
-    parsing: optionFlagParsing,
-  });
-
-  expect(readerArgs.consumePositional()).toStrictEqual(undefined);
-
-  expect(readerArgs.getOptionValues(kOption)).toStrictEqual([
-    { inlined: "1.1", separated: [] },
-    { inlined: "1.2", separated: [] },
-    { inlined: null, separated: ["1.3"] },
-    { inlined: "1.4", separated: [] },
-    { inlined: null, separated: ["1.5"] },
-    { inlined: "1.6", separated: [] },
-  ]);
-  expect(readerArgs.getOptionValues(kFlag1)).toStrictEqual([
-    { inlined: null, separated: [] },
-  ]);
-  expect(readerArgs.getOptionValues(kFlag2)).toStrictEqual([
-    { inlined: "woops", separated: [] },
-    { inlined: null, separated: [] },
-  ]);
-});
-
-const optionFlagParsing: ReaderOptionParsing = {
-  consumeShortGroup: false,
-  consumeNextArg: () => false,
-};
-
-const optionValueFixedUniqueParsing: ReaderOptionParsing = {
-  consumeShortGroup: true,
-  consumeNextArg: (inlined, separated) =>
-    inlined === null && separated.length === 0,
-};