cli-kiss 0.0.3 → 0.0.5

package/src/lib/Usage.ts

@@ -3,7 +3,7 @@ import { GridCell, GridRow, gridToPrintableLines } from "./Grid";
 import { TypoSupport, TypoText, typoPrintableString } from "./Typo";
 
 export function usageToPrintableLines(params: {
-  cliName: string;
+  cliName: Lowercase<string>;
   commandUsage: CommandUsage;
   typoSupport: TypoSupport;
 }) {
@@ -11,42 +11,61 @@ export function usageToPrintableLines(params: {
 
   const lines = new Array<string>();
 
-  lines.push("");
-  lines.push(typoPrintableString(typoSupport, textDesc(commandUsage.title)));
-  if (commandUsage.description) {
-    for (const descriptionLine of commandUsage.description) {
-      lines.push(typoPrintableString(typoSupport, textSubs(descriptionLine)));
+  lines.push(
+    typoPrintableString(typoSupport, textDescription(commandUsage.description)),
+  );
+  if (commandUsage.details) {
+    for (const detailLine of commandUsage.details) {
+      lines.push(typoPrintableString(typoSupport, textDetails(detailLine)));
     }
   }
 
-  const breadcrumbPrefix = typoPrintableString(
-    typoSupport,
-    textTitle("Usage:"),
-  );
-  const breadcrumbsItems = [
-    typoPrintableString(typoSupport, textName(cliName)),
+  lines.push("");
+  lines.push(typoPrintableString(typoSupport, textCategory("Usage:")));
+  const breadcrumbs = [
+    " ",
+    typoPrintableString(typoSupport, textFixed(cliName)),
   ].concat(
     commandUsage.breadcrumbs.map((breadcrumb) => {
-      if (breadcrumb.kind === "argument") {
-        return typoPrintableString(typoSupport, textValue(breadcrumb.value));
+      if ("argument" in breadcrumb) {
+        return typoPrintableString(typoSupport, textInput(breadcrumb.argument));
+      }
+      if ("command" in breadcrumb) {
+        return typoPrintableString(typoSupport, textFixed(breadcrumb.command));
       }
-      return typoPrintableString(typoSupport, textName(breadcrumb.value));
+      throw new Error(`Unknown breadcrumb: ${JSON.stringify(breadcrumb)}`);
     }),
   );
-  lines.push("");
-  lines.push(`${breadcrumbPrefix} ${breadcrumbsItems.join(" ")}`);
+  lines.push(breadcrumbs.join(" "));
 
   if (commandUsage.arguments.length > 0) {
     lines.push("");
-    lines.push(typoPrintableString(typoSupport, textTitle("Arguments:")));
+    lines.push(typoPrintableString(typoSupport, textCategory("Arguments:")));
     const grid = new Array<GridRow>();
     for (const argumentUsage of commandUsage.arguments) {
       const gridRow = new Array<GridCell>();
-      gridRow.push([]);
-      gridRow.push([textValue(argumentUsage.label)]);
-      gridRow.push([]);
+      gridRow.push([textDelimiter()]);
+      gridRow.push([textInput(argumentUsage.label)]);
       if (argumentUsage.description) {
-        gridRow.push([textDesc(argumentUsage.description)]);
+        gridRow.push([textDelimiter()]);
+        gridRow.push([textDescription(argumentUsage.description)]);
+      }
+      grid.push(gridRow);
+    }
+    lines.push(...gridToPrintableLines(grid, typoSupport));
+  }
+
+  if (commandUsage.subcommands.length > 0) {
+    lines.push("");
+    lines.push(typoPrintableString(typoSupport, textCategory("Subcommands:")));
+    const grid = new Array<GridRow>();
+    for (const subcommand of commandUsage.subcommands) {
+      const gridRow = new Array<GridCell>();
+      gridRow.push([textDelimiter()]);
+      gridRow.push([textFixed(subcommand.name)]);
+      if (subcommand.description) {
+        gridRow.push([textDelimiter()]);
+        gridRow.push([textDescription(subcommand.description)]);
       }
       grid.push(gridRow);
     }
@@ -55,72 +74,57 @@ export function usageToPrintableLines(params: {
 
   if (commandUsage.options.length > 0) {
     lines.push("");
-    lines.push(typoPrintableString(typoSupport, textTitle("Options:")));
+    lines.push(typoPrintableString(typoSupport, textCategory("Options:")));
     const grid = new Array<GridRow>();
     for (const optionUsage of commandUsage.options) {
       const gridRow = new Array<GridCell>();
-      gridRow.push([]);
+      gridRow.push([textDelimiter()]);
       if (optionUsage.short) {
-        gridRow.push([textName(`-${optionUsage.short}`), { value: "," }]);
+        gridRow.push([textFixed(`-${optionUsage.short}`), { value: ", " }]);
       } else {
         gridRow.push([]);
       }
       if (optionUsage.label) {
         gridRow.push([
-          textName(`--${optionUsage.long} `),
-          textValue(optionUsage.label),
+          textFixed(`--${optionUsage.long} `),
+          textInput(optionUsage.label),
         ]);
       } else {
-        gridRow.push([
-          textName(`--${optionUsage.long}`),
-          { value: "[=yes|no]", color: "grey" },
-        ]);
+        gridRow.push([textFixed(`--${optionUsage.long}`)]);
       }
-      gridRow.push([]);
       if (optionUsage.description) {
-        gridRow.push([textDesc(optionUsage.description)]);
+        gridRow.push([textDelimiter()]);
+        gridRow.push([textDescription(optionUsage.description)]);
       }
       grid.push(gridRow);
     }
     lines.push(...gridToPrintableLines(grid, typoSupport));
   }
 
-  if (commandUsage.subcommands.length > 0) {
-    lines.push("");
-    lines.push(typoPrintableString(typoSupport, textTitle("Subcommands:")));
-    const grid = new Array<GridRow>();
-    for (const subcommand of commandUsage.subcommands) {
-      const gridRow = new Array<GridCell>();
-      gridRow.push([]);
-      gridRow.push([textName(subcommand.name)]);
-      gridRow.push([]);
-      if (subcommand.title) {
-        gridRow.push([textDesc(subcommand.title)]);
-      }
-      grid.push(gridRow);
-    }
-    lines.push(...gridToPrintableLines(grid, typoSupport));
-  }
   lines.push("");
   return lines;
 }
 
-function textTitle(text: string): TypoText {
-  return { value: text, color: "green", bold: true };
+function textCategory(text: string): TypoText {
+  return { value: text, color: "brightGreen", bold: true };
 }
 
-function textSubs(text: string): TypoText {
-  return { value: text, color: "grey" };
+function textDescription(text: string): TypoText {
+  return { value: text, bold: true };
 }
 
-function textDesc(text: string): TypoText {
-  return { value: text, bold: true };
+function textDetails(text: string): TypoText {
+  return { value: text, color: "brightBlack" };
+}
+
+function textFixed(text: string): TypoText {
+  return { value: text, color: "brightCyan", bold: true };
 }
 
-function textName(text: string): TypoText {
-  return { value: text, color: "cyan", bold: true };
+function textInput(text: string): TypoText {
+  return { value: text, color: "brightBlue" };
 }
 
-function textValue(text: string): TypoText {
-  return { value: text, color: "cyan" };
+function textDelimiter(): TypoText {
+  return { value: "  " };
 }

package/tests/{unit.command.run.ts → unit.command.execute.ts}

@@ -3,19 +3,21 @@ import {
   argumentOptional,
   argumentRequired,
   argumentVariadics,
+  Command,
   command,
   commandWithSubcommands,
   execution,
   optionFlag,
   optionRepeatable,
   optionSingleValue,
-  runWithArgv,
+  ReaderTokenizer,
+  typeCommaList,
   typeNumber,
   typeString,
 } from "../src";
 
-const cmd = commandWithSubcommands<string, any, any>(
-  { title: "Root command title" },
+const rootCommand = commandWithSubcommands<string, any, any>(
+  { description: "Root command description" },
   execution(
     {
       options: {
@@ -27,7 +29,7 @@ const cmd = commandWithSubcommands<string, any, any>(
         }),
         numberOption: optionRepeatable({
           long: "number-option",
-          type: typeNumber,
+          type: typeCommaList(typeNumber),
         }),
       },
       arguments: [
@@ -41,7 +43,7 @@ const cmd = commandWithSubcommands<string, any, any>(
   ),
   {
     sub1: command(
-      { title: "Subcommand 1 title" },
+      { description: "Subcommand 1 description" },
       execution(
         {
           options: {},
@@ -53,7 +55,7 @@ const cmd = commandWithSubcommands<string, any, any>(
       ),
     ),
     sub2: command(
-      { title: "Subcommand 2 title" },
+      { description: "Subcommand 2 description" },
       execution(
         {
           options: {},
@@ -72,10 +74,10 @@ const cmd = commandWithSubcommands<string, any, any>(
 );
 
 it("run", async () => {
-  const res1 = await runWithArgv(
-    ["node", "script", "50", "51", "sub1", "final"],
+  const res1 = await executeInterpreted(
+    ["50", "51", "sub1", "final"],
     "Run Context Input",
-    cmd,
+    rootCommand,
   );
   expect(res1).toStrictEqual({
     context: {
@@ -97,25 +99,23 @@ it("run", async () => {
     at: "sub1",
   });
 
-  const res2 = await runWithArgv(
+  const res2 = await executeInterpreted(
     [
-      "node",
-      "script",
       "40",
       "41",
       "sub2",
       "--string-option=hello",
       "--number-option",
-      "123",
+      "123.1,123.2",
       "--number-option",
-      "1234",
+      "123.3",
       "88.88",
       "a,b",
       "final",
       "--boolean-flag",
     ],
     "Run Context Input",
-    cmd,
+    rootCommand,
   );
   expect(res2).toStrictEqual({
     context: {
@@ -124,7 +124,7 @@ it("run", async () => {
         options: {
           booleanFlag: true,
           stringOption: "hello",
-          numberOption: [123, 1234],
+          numberOption: [[123.1, 123.2], [123.3]],
         },
         arguments: [40, 41],
       },
@@ -137,3 +137,13 @@ it("run", async () => {
     at: "sub2",
   });
 });
+
+async function executeInterpreted<Context, Result>(
+  args: Array<string>,
+  context: Context,
+  command: Command<Context, Result>,
+) {
+  const readerTokenizer = new ReaderTokenizer(args);
+  const commandInterpreter = command.buildInterpreter(readerTokenizer);
+  return await commandInterpreter.execute(context);
+}

package/tests/unit.command.usage.ts

@@ -11,6 +11,8 @@ import {
   optionRepeatable,
   optionSingleValue,
   ReaderTokenizer,
+  typeCommaList,
+  typeCommaTuple,
   typeNumber,
   typeString,
 } from "../src";
@@ -18,11 +20,8 @@ import { usageToPrintableLines } from "../src/lib/Usage";
 
 const cmd = commandWithSubcommands<string, any, any>(
   {
-    title: "Root command title",
-    description: [
-      "Root command description",
-      "Second line of root command description",
-    ],
+    description: "Root command description",
+    details: ["Root command details", "Second line of root command details"],
   },
   execution(
     {
@@ -40,11 +39,10 @@ const cmd = commandWithSubcommands<string, any, any>(
           label: "COOL-STUFF",
           description: "Root string-option description",
         }),
-        numberOption: optionRepeatable({
-          short: "n",
-          long: "number-option",
-          type: typeNumber,
-          description: "Root number-option description",
+        complexOption: optionRepeatable({
+          long: "complex-option",
+          type: typeCommaTuple([typeNumber, typeCommaList(typeString)]),
+          description: "Root complex-option description",
         }),
       },
       arguments: [
@@ -67,10 +65,10 @@ const cmd = commandWithSubcommands<string, any, any>(
   {
     sub1: command(
       {
-        title: "Subcommand 1 title",
-        description: [
-          "Subcommand 1 description",
-          "Second line of subcommand 1 description",
+        description: "Subcommand 1 description",
+        details: [
+          "Subcommand 1 details",
+          "Second line of subcommand 1 details",
         ],
       },
       execution(
@@ -91,10 +89,10 @@ const cmd = commandWithSubcommands<string, any, any>(
     ),
     sub2: command(
       {
-        title: "Subcommand 2 title",
-        description: [
-          "Subcommand 2 description",
-          "Second line of subcommand 2 description",
+        description: "Subcommand 2 description",
+        details: [
+          "Subcommand 2 details",
+          "Second line of subcommand 2 details",
         ],
       },
       execution(
@@ -120,7 +118,7 @@ const cmd = commandWithSubcommands<string, any, any>(
               default: () => "42",
             }),
             argumentVariadics({
-              label: "VARIADIC-POSS",
+              label: "VARIADIC",
               description: "Variadic positional arguments",
               type: typeString,
             }),
@@ -135,57 +133,58 @@ const cmd = commandWithSubcommands<string, any, any>(
 );
 
 it("run", async () => {
-  const usage1 = getUsage([], cmd);
+  const usage1 = await getUsage([], cmd);
+  // console.log(usage1.join("\n"));
   expect(usage1).toStrictEqual([
+    "{Root command description}+",
+    "{Root command details}@brightBlack",
+    "{Second line of root command details}@brightBlack",
     "",
-    "{Root command title}+",
-    "{Root command description}@grey",
-    "{Second line of root command description}@grey",
+    "{Usage:}@brightGreen+",
+    "  {my-cli}@brightCyan+ {<POS-1>}@brightBlue {<POS-2>}@brightBlue {<SUBCOMMAND>}@brightCyan+",
     "",
-    "{Usage:}@green+ {my-cli}@cyan+ {<POS-1>}@cyan {<POS-2>}@cyan {<SUBCOMMAND>}@cyan+",
+    "{Arguments:}@brightGreen+",
+    "{  }{<POS-1>}@brightBlue{  }{First positional argument}+",
+    "{  }{<POS-2>}@brightBlue{  }{Second positional argument}+",
     "",
-    "{Arguments:}@green+",
-    " {<POS-1>}@cyan  {First positional argument}+",
-    " {<POS-2>}@cyan  {Second positional argument}+",
+    "{Subcommands:}@brightGreen+",
+    "{  }{sub1}@brightCyan+{  }{Subcommand 1 description}+",
+    "{  }{sub2}@brightCyan+{  }{Subcommand 2 description}+",
     "",
-    "{Options:}@green+",
-    " {-b}@cyan+{,} {--boolean-flag}@cyan+{[=yes|no]}@grey       {Root boolean-flag description}+",
-    " {-s}@cyan+{,} {--string-option }@cyan+{<COOL-STUFF>}@cyan  {Root string-option description}+",
-    " {-n}@cyan+{,} {--number-option }@cyan+{<NUMBER>}@cyan      {Root number-option description}+",
-    "",
-    "{Subcommands:}@green+",
-    " {sub1}@cyan+  {Subcommand 1 title}+",
-    " {sub2}@cyan+  {Subcommand 2 title}+",
+    "{Options:}@brightGreen+",
+    "{  }{-b}@brightCyan+{, }{--boolean-flag}@brightCyan+                              {  }{Root boolean-flag description}+",
+    "{  }{-s}@brightCyan+{, }{--string-option }@brightCyan+{<COOL-STUFF>}@brightBlue                {  }{Root string-option description}+",
+    "{  }    {--complex-option }@brightCyan+{<NUMBER,STRING[,STRING...]>}@brightBlue{  }{Root complex-option description}+",
     "",
   ]);
 
-  const usage2 = getUsage(["50", "51", "sub1", "final"], cmd);
+  const usage2 = await getUsage(["50", "51", "sub1", "final"], cmd);
   expect(usage2).toStrictEqual([
+    "{Subcommand 1 description}+",
+    "{Subcommand 1 details}@brightBlack",
+    "{Second line of subcommand 1 details}@brightBlack",
     "",
-    "{Subcommand 1 title}+",
-    "{Subcommand 1 description}@grey",
-    "{Second line of subcommand 1 description}@grey",
-    "",
-    "{Usage:}@green+ {my-cli}@cyan+ {<POS-1>}@cyan {<POS-2>}@cyan {sub1}@cyan+ {<POS-STRING>}@cyan",
+    "{Usage:}@brightGreen+",
+    "  {my-cli}@brightCyan+ {<POS-1>}@brightBlue {<POS-2>}@brightBlue {sub1}@brightCyan+ {<POS-STRING>}@brightBlue",
     "",
-    "{Arguments:}@green+",
-    " {<POS-1>}@cyan       {First positional argument}+",
-    " {<POS-2>}@cyan       {Second positional argument}+",
-    " {<POS-STRING>}@cyan  {Positional string argument}+",
+    "{Arguments:}@brightGreen+",
+    "{  }{<POS-1>}@brightBlue     {  }{First positional argument}+",
+    "{  }{<POS-2>}@brightBlue     {  }{Second positional argument}+",
+    "{  }{<POS-STRING>}@brightBlue{  }{Positional string argument}+",
     "",
-    "{Options:}@green+",
-    " {-b}@cyan+{,} {--boolean-flag}@cyan+{[=yes|no]}@grey       {Root boolean-flag description}+",
-    " {-s}@cyan+{,} {--string-option }@cyan+{<COOL-STUFF>}@cyan  {Root string-option description}+",
-    " {-n}@cyan+{,} {--number-option }@cyan+{<NUMBER>}@cyan      {Root number-option description}+",
+    "{Options:}@brightGreen+",
+    "{  }{-b}@brightCyan+{, }{--boolean-flag}@brightCyan+                              {  }{Root boolean-flag description}+",
+    "{  }{-s}@brightCyan+{, }{--string-option }@brightCyan+{<COOL-STUFF>}@brightBlue                {  }{Root string-option description}+",
+    "{  }    {--complex-option }@brightCyan+{<NUMBER,STRING[,STRING...]>}@brightBlue{  }{Root complex-option description}+",
     "",
   ]);
 
-  const usage3 = getUsage(
+  const usage3 = await getUsage(
     [
       "40",
       "41",
       "sub2",
-      "--string-option=hello",
+      "--complex-option=42,hello,world",
       "--number-option",
       "123",
       "--number-option",
@@ -198,37 +197,45 @@ it("run", async () => {
     cmd,
   );
   expect(usage3).toStrictEqual([
-    "",
-    "{Subcommand 2 title}+",
-    "{Subcommand 2 description}@grey",
-    "{Second line of subcommand 2 description}@grey",
-    "",
-    "{Usage:}@green+ {my-cli}@cyan+ {<POS-1>}@cyan {<POS-2>}@cyan {sub2}@cyan+ {<POS-NUMBER>}@cyan {[OPT-POS]}@cyan {[VARIADIC-POSS...]}@cyan",
-    "",
-    "{Arguments:}@green+",
-    " {<POS-1>}@cyan             {First positional argument}+",
-    " {<POS-2>}@cyan             {Second positional argument}+",
-    " {<POS-NUMBER>}@cyan        {Positional number argument}+",
-    " {[OPT-POS]}@cyan           {Optional positional argument}+",
-    " {[VARIADIC-POSS...]}@cyan  {Variadic positional arguments}+",
-    "",
-    "{Options:}@green+",
-    " {-b}@cyan+{,} {--boolean-flag}@cyan+{[=yes|no]}@grey       {Root boolean-flag description}+",
-    " {-s}@cyan+{,} {--string-option }@cyan+{<COOL-STUFF>}@cyan  {Root string-option description}+",
-    " {-n}@cyan+{,} {--number-option }@cyan+{<NUMBER>}@cyan      {Root number-option description}+",
-    "     {--dudu }@cyan+{<STRING>}@cyan               {Dudu option description}+",
+    "{Subcommand 2 description}+",
+    "{Subcommand 2 details}@brightBlack",
+    "{Second line of subcommand 2 details}@brightBlack",
+    "",
+    "{Usage:}@brightGreen+",
+    "  {my-cli}@brightCyan+ {<POS-1>}@brightBlue {<POS-2>}@brightBlue {sub2}@brightCyan+ {<POS-NUMBER>}@brightBlue {[OPT-POS]}@brightBlue {[VARIADIC...]}@brightBlue",
+    "",
+    "{Arguments:}@brightGreen+",
+    "{  }{<POS-1>}@brightBlue      {  }{First positional argument}+",
+    "{  }{<POS-2>}@brightBlue      {  }{Second positional argument}+",
+    "{  }{<POS-NUMBER>}@brightBlue {  }{Positional number argument}+",
+    "{  }{[OPT-POS]}@brightBlue    {  }{Optional positional argument}+",
+    "{  }{[VARIADIC...]}@brightBlue{  }{Variadic positional arguments}+",
+    "",
+    "{Options:}@brightGreen+",
+    "{  }{-b}@brightCyan+{, }{--boolean-flag}@brightCyan+                              {  }{Root boolean-flag description}+",
+    "{  }{-s}@brightCyan+{, }{--string-option }@brightCyan+{<COOL-STUFF>}@brightBlue                {  }{Root string-option description}+",
+    "{  }    {--complex-option }@brightCyan+{<NUMBER,STRING[,STRING...]>}@brightBlue{  }{Root complex-option description}+",
+    "{  }    {--dudu }@brightCyan+{<STRING>}@brightBlue                             {  }{Dudu option description}+",
     "",
   ]);
 });
 
-function getUsage<Context, Result>(
-  argv: Array<string>,
+async function getUsage<Context, Result>(
+  args: Array<string>,
   command: Command<Context, Result>,
 ) {
-  const commandRunner = command.prepareRunner(new ReaderTokenizer(argv));
+  const readerTokenizer = new ReaderTokenizer(args);
+  const commandInterpreter = command.buildInterpreter(readerTokenizer);
+  /*
+  try {
+    console.log(await commandInterpreter.execute({} as Context));
+  } catch (error) {
+    console.error("Error during execution:", error);
+  }
+    */
   return usageToPrintableLines({
     cliName: "my-cli",
-    commandUsage: commandRunner.computeUsage(),
+    commandUsage: commandInterpreter.computeUsage(),
     typoSupport: "mock",
   });
 }