@tkeron/commands 0.2.1 → 0.3.0

package/.github/workflows/npm_deploy.yml

@@ -0,0 +1,24 @@
+name: commands package
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build-test-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4.0.3
+        with:
+          node-version: 20.x
+          registry-url: "https://registry.npmjs.org/"
+
+      - uses: oven-sh/setup-bun@v2
+
+      - run: |
+          bun i
+          bun test
+          npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 tkeron
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2022 tkeron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/changelog.md

@@ -1,3 +1,7 @@
+# v0.3.0
+
+- migrate project to bun
+
 # v0.1.1
 
 - fixed commands ordered arguments

package/package.json

@@ -1,22 +1,17 @@
 {
   "name": "@tkeron/commands",
-  "version": "0.2.1",
-  "description": "node library for handling command line arguments",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "test": "jest",
-    "lint": "prettier --write ."
-  },
+  "version": "0.3.0",
+  "description": "library for handling command line arguments",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "type": "module",
   "author": "tkeron",
   "license": "MIT",
   "devDependencies": {
-    "@types/jest": "^29.5.6",
-    "@types/node": "^18.11.12",
-    "jest": "^29.3.1",
-    "prettier": "^3.0.3",
-    "ts-jest": "^29.1.1",
-    "typescript": "^4.9.4"
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
   },
   "keywords": [
     "cli",
@@ -25,6 +20,6 @@
     "arguments"
   ],
   "repository": {
-    "url": "git@github.com:tkeron/tkeron.git"
+    "url": "git@github.com:tkeron/commands.git"
   }
 }

package/src/example.e2e.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, spyOn } from "bun:test";
+
+describe("example e2e", () => {
+  const { log } = globalThis.console;
+  let logs: any[] = [];
+  spyOn(globalThis.console, "log").mockImplementation((...args: any) => {
+    logs.push(args);
+  });
+
+  it("should runs ok", (done) => {
+    expect(logs).toHaveLength(0);
+    //@ts-ignore
+    import("./example");
+    const check = () => {
+      // @ts-ignore
+      const { commands } = globalThis;
+      if (!commands) return;
+      expect(logs).toHaveLength(3);
+      expect(logs).toStrictEqual([
+        ["argument 'asdasd' not defined"],
+        ["arguments 'pos0value, pos1value, asdasd' not defined"],
+        [
+          {
+            opt1: "qw111erty",
+            opt2: "as222d",
+            pos0: "pos0value",
+            pos1: "pos1value",
+            pos3: "asdasd",
+          },
+        ],
+      ]);
+      clearInterval(handler);
+      done();
+    };
+    const handler = setInterval(check, 10);
+  });
+});

package/src/example.ts

@@ -0,0 +1,69 @@
+import { getCommands } from ".";
+import type { Commands } from "./types";
+
+const commands = getCommands("test program", "0.0.14")
+  .addCommand("com1")
+  .addAlias("c1")
+  .addOption("opt1")
+  .addOption("opt2")
+  .addDescription("command 001 test...")
+  .addPositionedArgument("pos0")
+  .addPositionedArgument("pos1")
+  .setCallback(console.log)
+
+  .commands()
+
+  .addCommand("com2")
+  .addAlias("c2")
+  .addAlias("a2")
+  .addOption("opt1")
+  .addDescription("command 002 test...")
+  .setCallback(console.log)
+
+  .commands()
+
+  .addCommand("com3")
+  .addAlias("c3")
+  .addOption("opt1")
+  .addOption("opt2", "exOpt2...")
+  .addOption("opt3")
+  .addDescription("command 003 test...")
+  .addPositionedArgument("pos0")
+  .addPositionedArgument("pos1")
+  .addPositionedArgument("pos3")
+  .setCallback(console.log)
+
+  .commands()
+
+  .addHeaderText("header...\n\n")
+  .addFooterText("\n\nFooter...");
+
+commands.start([
+  "",
+  "",
+  ..."com1 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
+    .replace(/\s+/g, " ")
+    .split(" "),
+]);
+
+commands.start([
+  "",
+  "",
+  ..."a2 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
+    .replace(/\s+/g, " ")
+    .split(" "),
+]);
+
+commands.start([
+  "",
+  "",
+  ..."c3 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
+    .replace(/\s+/g, " ")
+    .split(" "),
+]);
+
+declare global {
+  var commands: Commands;
+}
+
+globalThis.commands = commands;

package/src/getCommandsFuncs.test.ts

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import type { CommandFactory, Commands, CommandsCollection } from "./types";
+import {
+  getAddFooterText,
+  getAddHeaderText,
+  getAddOption,
+  getAddPositionedArgument,
+  getCommands,
+  getGetHelpLine,
+  initCommands,
+  initHelpAndVersion,
+} from "./getCommandsFuncs";
+
+describe("main", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+  let commandFactory: CommandFactory;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commandFactory = <CommandFactory>(<unknown>{
+      commands: undefined,
+      name: undefined,
+      addAlias: undefined,
+      addOption: undefined,
+      addPositionedArgument: undefined,
+      addDescription: undefined,
+      setCallback: undefined,
+    });
+    commands = initCommands(commandsCollection, undefined, commandFactory);
+  });
+
+  it("getCommands", () => {
+    const commands = getCommands();
+    expect(commands).toBeTruthy;
+  });
+  it("initHelpAndVersion", () => {
+    expect(commandsCollection).not.toHaveProperty("help");
+    expect(commandsCollection).not.toHaveProperty("version");
+    const { helpCallback, versionCallback } = initHelpAndVersion(
+      commands,
+      commandsCollection
+    );
+    expect(commandsCollection).toHaveProperty("help");
+    expect(commandsCollection).toHaveProperty("version");
+
+    expect(helpCallback).not.toThrow();
+    expect(versionCallback).not.toThrow();
+  });
+  it("getAddOption", () => {
+    commands.addCommand("test");
+    const addOption = getAddOption(commandFactory, commandsCollection);
+    addOption("op001");
+    const { test } = commandsCollection;
+    expect(test.options.includes("op001"));
+  });
+  it("getAddPositionedArgument", () => {
+    commands.addCommand("test");
+    const addPositionedArgument = getAddPositionedArgument(
+      commandFactory,
+      commandsCollection
+    );
+
+    addPositionedArgument("pos001");
+    const { test } = commandsCollection;
+
+    expect(test.positionedArguments.includes("pos001"));
+  });
+  it("getAddHeaderText", () => {
+    const addHeaderText = getAddHeaderText(commands);
+    const txt = "test header text...";
+    addHeaderText(txt);
+    expect(commands.headerText).toBe(txt);
+  });
+  it("getAddFooterText", () => {
+    const addFooterText = getAddFooterText(commands);
+    const txt = "test footer text...";
+    addFooterText(txt);
+    expect(commands.footerText).toBe(txt);
+  });
+  it("getGetHelpLine", () => {
+    commands.addCommand("test");
+    const { test } = commandsCollection;
+    const getHelpLine = getGetHelpLine(test);
+    const hl50 = getHelpLine();
+    expect(hl50).toBe("test  ............................................  \n");
+  });
+  it("", () => {
+    commandFactory.commands = <() => Commands>(<unknown>undefined);
+    initCommands(commandsCollection, commands, commandFactory);
+    expect(commandFactory.commands).toBeTruthy;
+    expect(commandFactory.commands).not.toThrow();
+  });
+});

package/src/getCommandsFuncs.ts

@@ -0,0 +1,204 @@
+import { getStart } from "./getStart";
+import { buildHelpText, getCommandText } from "./textFuncs";
+import type {
+  CommandFactory,
+  Command,
+  Commands,
+  CommandsCollection,
+  Callback,
+} from "./types";
+export * from "./types";
+
+export const getCommands = (
+  programName: string = "program",
+  version: string = "0.0.1"
+): Commands => {
+  const commandsCollection: CommandsCollection = {};
+
+  const commands = initCommands(commandsCollection);
+  commands.programName = programName;
+  commands.version = version;
+
+  initHelpAndVersion(commands, commandsCollection);
+
+  return commands;
+};
+
+export const initCommands = (
+  commandsCollection: CommandsCollection,
+  commands: Commands = <Commands>(<unknown>{
+    programName: "",
+    version: "",
+    footerText: "",
+    headerText: "",
+    addCommand: undefined,
+    start: undefined,
+    addHeaderText: undefined,
+    addFooterText: undefined,
+  }),
+  commandFactory: CommandFactory = <CommandFactory>(<unknown>{
+    commands: undefined,
+    name: undefined,
+    addAlias: undefined,
+    addOption: undefined,
+    addPositionedArgument: undefined,
+    addDescription: undefined,
+    setCallback: undefined,
+  })
+): Commands => {
+  if (!commandFactory.commands) commandFactory.commands = () => commands;
+  commands.addCommand = getAddCommand(commandsCollection, commandFactory);
+  commands.start = getStart(commandsCollection);
+  commands.addHeaderText = getAddHeaderText(commands);
+  commands.addFooterText = getAddFooterText(commands);
+
+  return commands;
+};
+
+export const initHelpAndVersion = (
+  commands: Commands,
+  commandsCollection: CommandsCollection
+) => {
+  const helpCallback = () =>
+    console["log"](buildHelpText(commands, commandsCollection));
+  const versionCallback = () =>
+    console["log"](
+      `${commands.headerText || ""}\n${commands.version}\n${
+        commands.footerText || ""
+      }\n`
+    );
+
+  commands
+    .addCommand("help")
+    .addAlias("-h")
+    .addAlias("--help")
+    .addDescription("show program help")
+    .setCallback(helpCallback);
+  commands
+    .addCommand("version")
+    .addAlias("-v")
+    .addAlias("--version")
+    .addDescription("show program version")
+    .setCallback(versionCallback);
+
+  return { helpCallback, versionCallback };
+};
+
+export const getAddCommand =
+  (commandsCollection: CommandsCollection, commandFactory: CommandFactory) =>
+  (commandName: string) => {
+    commandFactory.name = commandName;
+    const command: Command = <Command>(<unknown>{
+      aliases: [],
+      callback: undefined,
+      description: "",
+      name: commandName,
+      options: [],
+      optionsExamples: [],
+      positionedArguments: [],
+      getHelpLine: undefined,
+    });
+    commandsCollection[commandName] = command;
+    command.getHelpLine = getGetHelpLine(command);
+
+    commandFactory.addAlias = getAddAlias(commandFactory, commandsCollection);
+    commandFactory.addOption = getAddOption(commandFactory, commandsCollection);
+    commandFactory.addDescription = getAddDescription(
+      commandFactory,
+      commandsCollection
+    );
+    commandFactory.setCallback = getSetCallback(
+      commandFactory,
+      commandsCollection
+    );
+    commandFactory.addPositionedArgument = getAddPositionedArgument(
+      commandFactory,
+      commandsCollection
+    );
+
+    return commandFactory;
+  };
+
+export const getAddAlias = (
+  commandFactory: CommandFactory,
+  commandsCollection: CommandsCollection
+) => {
+  return (alias: string) => {
+    commandsCollection[commandFactory.name].aliases.push(alias);
+    commandsCollection[alias] = commandsCollection[commandFactory.name];
+
+    return commandFactory;
+  };
+};
+
+export const getAddOption =
+  (commandFactory: CommandFactory, commandsCollection: CommandsCollection) =>
+  (option: string, example?: string) => {
+    commandsCollection[commandFactory.name].options.push(option);
+    commandsCollection[commandFactory.name].optionsExamples.push(example || "");
+
+    return commandFactory;
+  };
+
+export const getAddPositionedArgument = (
+  commandFactory: CommandFactory,
+  commandsCollection: CommandsCollection
+) => {
+  return (arg: string): CommandFactory => {
+    const positionedArguments =
+      commandsCollection[commandFactory.name].positionedArguments;
+
+    if (!positionedArguments.includes(commandFactory.name)) {
+      positionedArguments.push(arg);
+    }
+
+    return commandFactory;
+  };
+};
+
+export const getSetCallback = (
+  commandFactory: CommandFactory,
+  commandsCollection: CommandsCollection
+) => {
+  return (fn: Callback): CommandFactory => {
+    commandsCollection[commandFactory.name].callback = fn;
+
+    return commandFactory;
+  };
+};
+
+export const getAddDescription = (
+  commandFactory: CommandFactory,
+  commandsCollection: CommandsCollection
+) => {
+  return (description: string) => {
+    commandsCollection[commandFactory.name].description = description;
+    return commandFactory;
+  };
+};
+
+export const getAddHeaderText = (commands: Commands) => {
+  return (text: string) => {
+    commands.headerText = text;
+    return commands;
+  };
+};
+
+export const getAddFooterText = (commands: Commands) => {
+  return (text: string) => {
+    commands.footerText = text;
+    return commands;
+  };
+};
+
+export const getGetHelpLine =
+  (command: Command) =>
+  (width: number = 50) => {
+    let helpLine =
+      getCommandText(command).padEnd(width, ".") +
+      "  " +
+      command.description +
+      "\n";
+
+    return helpLine;
+  };

package/src/getStart.test.ts

@@ -0,0 +1,79 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+  spyOn,
+  type Mock,
+} from "bun:test";
+
+import { getStart } from "./getStart";
+import { commandsCollection } from "./testConstants";
+
+describe("getStart", () => {
+  let callback: Mock<any>;
+  let start: (argv?: string[]) => void;
+  let logMock: Mock<any>;
+  let logs: any[] = [];
+
+  beforeEach(() => {
+    callback = mock();
+    commandsCollection.command_1.callback = callback;
+    start = getStart(commandsCollection);
+    logMock = spyOn(console, "log").mockImplementation((...args: any) => {
+      logs.push(args);
+    });
+  });
+  afterEach(() => {
+    callback.mockClear();
+    logMock.mockClear();
+  });
+
+  it("happy path, run command", () => {
+    start(["", "", "command_1"]);
+    expect(callback).toBeCalledTimes(1);
+  });
+  it("run command with option", () => {
+    start(["", "", "command_1", "op1=value1"]);
+    expect(callback).toBeCalledTimes(1);
+  });
+  it("run command with extra positioned arguments", () => {
+    logs = [];
+    start(["", "", "command_1", "pos1", "pos2", "pos3"]);
+    start(["", "", "command_1", "pos1", "pos2", "pos3", "pos4"]);
+    expect(logs).toHaveLength(2);
+    expect(logs[0]).toHaveLength(1);
+    expect(logs[0][0]).toBe("argument 'pos3' not defined");
+    expect(logs[1]).toHaveLength(1);
+    expect(logs[1][0]).toBe("arguments 'pos3, pos4' not defined");
+  });
+  it("run with process.argv", () => {
+    process.argv = ["", ""];
+    start();
+    logs = [];
+    commandsCollection.help.callback();
+    expect(logs).toHaveLength(1);
+  });
+  it("should throw when no args passed", () => {
+    process.argv = <string[]>(<unknown>undefined);
+    expect(start).toThrow(new Error("no arguments passed"));
+  });
+  it("should throw when less than 2 args passed", () => {
+    process.argv = [];
+    expect(start).toThrow(new Error("arguments out of range"));
+  });
+  it("should show message when passed an unexistent commnad", () => {
+    process.argv = ["", "", "fakeCommand"];
+    logs = [];
+    start();
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toHaveLength(1);
+    expect(logs[0][0]).toBe("command 'fakeCommand' not found");
+  });
+  it("run with less positioned arguments", () => {
+    start(["", "", "al1", "arg001"]);
+    expect(callback).toBeCalledWith({ pos1: "arg001" });
+  });
+});

package/src/getStart.ts

@@ -0,0 +1,56 @@
+import type { CommandsCollection } from "./types";
+
+export const getStart =
+  (commandsCollection: CommandsCollection) => (argv?: string[]) => {
+    if (!argv) argv = process.argv;
+    if (!Array.isArray(argv)) throw new Error("no arguments passed");
+    if (argv.length < 2) throw Error("arguments out of range");
+    argv = argv.slice(2);
+    if (argv.length === 0) {
+      commandsCollection.help.callback();
+      return;
+    }
+
+    const commandName = argv[0];
+
+    const command = commandsCollection[commandName];
+    if (!command) {
+      console["log"](`command '${commandName}' not found`);
+      return;
+    }
+
+    const options = argv
+      .slice(1)
+      .filter((arg) => /\=/g.test(arg))
+      .map((arg) => arg.split("="))
+      .reduce((p: any, c) => {
+        p[c[0]] = c[1];
+
+        return p;
+      }, {});
+
+    const positionedArgsValues = argv
+      .slice(1)
+      .filter((arg) => !/\=/g.test(arg));
+
+    if (positionedArgsValues.length <= command.positionedArguments.length) {
+      positionedArgsValues.forEach(
+        (arg, n) => (options[command.positionedArguments[n]] = arg)
+      );
+    }
+
+    if (positionedArgsValues.length > command.positionedArguments.length) {
+      console["log"](
+        `argument${
+          positionedArgsValues.length - command.positionedArguments.length === 1
+            ? ""
+            : "s"
+        } '${positionedArgsValues
+          .slice(command.positionedArguments.length)
+          .join(", ")}' not defined`
+      );
+      return;
+    }
+
+    command.callback(options);
+  };

package/src/testConstants.ts

@@ -0,0 +1,32 @@
+import type { Command, Commands, CommandsCollection } from "./types";
+
+export const command: Command = <Command>(<unknown>{
+  name: "command_1",
+  aliases: ["al1", "al2"],
+  callback: undefined,
+  description: "command 1 description",
+  getHelpLine: () => "help line...\n",
+  options: ["op1", "op2"],
+  optionsExamples: ["opEx1"],
+  positionedArguments: ["pos1", "pos2"],
+});
+export const commands = <Commands>{
+  headerText: "header text...",
+  footerText: "footer text...",
+};
+export const commandsCollection: CommandsCollection = {
+  command_1: command,
+  al1: command,
+  al2: command,
+  command_2: {
+    ...command,
+    name: "command_2",
+    description: "command 2 description",
+    aliases: [],
+  },
+  help: {
+    ...command,
+    name: "help",
+    callback: () => console["log"]("help text..."),
+  },
+};