bash v5: working version

javascript/barg.js

@@ -0,0 +1,316 @@
+/**
+ * TODO:
+ * - Add logic for repeatable attribute
+ */
+
+function log(text) {
+  console.log(JSON.stringify(text, null, 2));
+}
+
+function join(...rest) {
+  return rest.filter((v) => !!v).join(".");
+}
+
+function takeOne(list) {
+  return list.shift();
+}
+
+function takeAll(list) {
+  const all = list.slice();
+  list.length = 0;
+  return all;
+}
+
+function map(key, cases, options = { error: true }) {
+  const DEFAULT = "_";
+  const hasKey = key != null && cases.hasOwnProperty(key);
+  const hasDefault = cases.hasOwnProperty(DEFAULT);
+
+  if (!hasKey && !hasDefault) {
+    if (options.error) {
+      throw new Error(`Invalid map key "${key}". Valid keys: ${Object.keys(cases).join(", ")}`);
+    }
+    return null;
+  }
+
+  return cases[hasKey ? key : DEFAULT];
+}
+
+function tokenize(input) {
+  const args = input.trim().split(/\s+/);
+  const root = args.shift();
+  const tokens = [`root::${root}`];
+
+  while (args.length) {
+    const token = takeOne(args);
+
+    // Rest
+    if (token === "--") {
+      tokens.push(`rest::${takeAll(args).join(" ")}`);
+      break;
+    }
+
+    // Named Argument + Value: Option or Flag (long variant)
+    if (token.startsWith("--")) {
+      const [key, value] = token.slice(2).split("=");
+      tokens.push(`narg::${key}`);
+      if (value) tokens.push(`value::${value}`);
+      continue;
+    }
+
+    // Named Argument + Value: Option or Flag (short variant)
+    if (token.startsWith("-")) {
+      const [flags, value] = token.slice(1).split("=");
+      tokens.push(...flags.split("").map((f) => `narg::${f}`));
+      if (value) tokens.push(`value::${value}`);
+      continue;
+    }
+
+    // Unknown: Command, Positional or Value
+    tokens.push(`unk::${token}`);
+  }
+
+  return tokens;
+}
+
+function parseInput(spec, input) {
+  const tokens = tokenize(input);
+  const s = {};
+  const a = {};
+
+  let _id = 100;
+  let level = -1;
+  let pos = [];
+  let cmds = [];
+
+  function generateSchema() {
+    for (const entry of spec) {
+      const elements = entry.split(";");
+      const type = elements.shift();
+
+      map(type, {
+        command: () => {
+          const id = String(_id++);
+          const aliases = elements.shift().split(",");
+          const help = elements.shift();
+
+          // Schema
+          s[join(id, "entryType")] = "command";
+          s[join(id, "name")] = aliases[0];
+          s[join(id, "help")] = help;
+          s[join(id, "args")] = "";
+
+          // Alias
+          if (cmds.length === 0) {
+            a[`cmd::root`] = id;
+          } else {
+            aliases.forEach((alias) => (a[join(cmds.at(-1), `cmd::${alias}`)] = id));
+          }
+
+          // Control
+          level += 1;
+          cmds.push(id);
+          pos.push(0);
+        },
+        end: () => {
+          level -= 1;
+          cmds.pop();
+          pos.pop();
+        },
+        argument: () => {
+          const id = String(_id++);
+          const aliases = elements.shift().split(",");
+          const name = aliases[0];
+
+          // Attributes
+          const entry = { name, dest: name, required: false, type: "positional" };
+          for (const element of elements) {
+            const [key, value = true] = element.split(":");
+            entry[key === "default" ? "value" : key] = value;
+          }
+
+          // Schema
+          s[join(id, "entryType")] = "argument";
+          Object.entries(entry).forEach(([key, value]) => {
+            s[join(id, key)] = value;
+          });
+
+          // Register to command
+          const cmdArgs = join(cmds.at(-1), "args");
+          s[cmdArgs] += s[cmdArgs] ? `,${id}` : id;
+
+          // Alias
+          map(entry.type, {
+            positional: () => [`pos::${pos[level]++}`],
+            rest: () => ["rest"],
+            option: () => aliases.map((a) => `narg::${a}`),
+            flag: () => aliases.map((a) => `narg::${a}`),
+          })().forEach((alias) => (a[join(cmds.at(-1), alias)] = id));
+        },
+        _: () => {
+          throw new Error(`Invalid entry type: "${type}"`);
+        },
+      })();
+    }
+
+    level = 0;
+    pos = [];
+    cmds = [];
+  }
+
+  generateSchema();
+  // log({ s, a });
+
+  while (tokens.length > 0) {
+    const taggedToken = takeOne(tokens);
+    const [tokenTag, token] = taggedToken.split("::");
+
+    // Bubble up arguments -> Loop over all command levels starting by the latest
+    let found = false;
+    for (level = Math.max(0, cmds.length - 1); level >= 0; level--) {
+      const entryId = map(tokenTag, {
+        root: () => a["cmd::root"],
+        rest: () => a[join(cmds[level], "rest")],
+        narg: () => a[join(cmds[level], taggedToken)],
+        unk: () => {
+          // check: Command
+          let id = a[join(cmds[level], `cmd::${token}`)];
+
+          // check: Positionl. Valid only on last command level
+          if (!id && level === pos.length - 1) {
+            id = a[join(cmds[level], `pos::${pos[level]}`)];
+            if (id) pos[level]++;
+          }
+
+          return id;
+        },
+      })();
+
+      // Try with parent command
+      if (!entryId) continue;
+
+      // Add
+      const entryType = s[join(entryId, "entryType")];
+      map(entryType, {
+        command: () => {
+          cmds.push(entryId);
+          pos.push(0);
+          if (tokenTag === "root") {
+            s[join(entryId, "name")] = token;
+          }
+        },
+        argument: () => {
+          const attrType = s[join(entryId, "type")];
+          const value = map(attrType, {
+            rest: () => token,
+            positional: () => token,
+            flag: () => true,
+            option: () => {
+              const nTaggedToken = tokens[0];
+              if (!nTaggedToken) {
+                throw new Error(`No value provided for option argument: "${token}"`);
+              }
+              const [nTokenTag, nToken] = nTaggedToken.split("::");
+              if (nTokenTag !== "value" && nTokenTag !== "unk") {
+                throw new Error(
+                  `Expected option argument, but got: "${nToken}" (${nTokenTag}). Skipping...`,
+                );
+              }
+              tokens.shift();
+              return nToken;
+            },
+          })();
+          s[join(entryId, "value")] = value;
+        },
+      })();
+
+      found = true;
+      break;
+    }
+
+    if (!found) {
+      console.log(`Invalid argument: "${token}" (${tokenTag}). Skipping...`);
+    }
+  }
+
+  // Set values and check required
+  const commands = [];
+  const values = {};
+  for (const cmdId of cmds) {
+    let cmdName = s[join(cmdId, "name")];
+    let cmdArgs = s[join(cmdId, "args")];
+    if (!cmdArgs) continue;
+
+    for (const argId of cmdArgs.split(",")) {
+      const name = s[join(argId, "name")];
+      const dest = s[join(argId, "dest")];
+      const value = s[join(argId, "value")];
+      const required = s[join(argId, "required")];
+
+      if (value == null && required) {
+        throw new Error(`Argument "${name}" is required in command "${cmdName}"`);
+      }
+
+      if (values[dest] != null) {
+        values[`${cmdName}_${dest}`] = value;
+      } else {
+        values[dest] = value;
+      }
+    }
+    commands.push(cmdName);
+  }
+
+  log({ commands, values });
+  return values;
+}
+
+function parseInputWrap(spec, input) {
+  try {
+    parseInput(spec, input);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+  }
+}
+
+const SPEC = [
+  "command;barg;Barg - Bash Argument Parser",
+  "argument;global;type:flag",
+  "command;build;Build a dev container",
+  "argument;from;type:option;dest:fromName;help:Name of the base container",
+  "argument;name;type:positional;required;help:Name of the container",
+  "argument;nametwo;help:Name of the container",
+  "argument;image,i;type:option;required;dest:imageName;help:Base image",
+  "argument;include,I;type:option;repeatable;dest:includePaths;help:Include paths",
+  "argument;verbose,v;type:flag;repeatable;default:0;help:Increase verbosity (-v, -vv, ...)",
+  "argument;quiet,q;type:flag;default:false;help:Suppress all output",
+  "argument;cmd;type:rest;help:Command and args to run inside the container",
+  "argument;name;dest:nameOpt;type:option;help:Building container name",
+  "command;container;Container building",
+  "argument;dev;type:flag;help:Is dev or not",
+  "argument;name;required;help:Building container name",
+  "argument;cmd;type:rest;dest:cmdRest;help:Command and args to run inside the container",
+  "end",
+  "end",
+  "command;stop;Stop a dev container",
+  "argument;name;type:positional;required;help:Name of the container",
+  "argument;kill,k;type:flag;default:false;help:Force kill the container",
+  "end",
+  "end",
+];
+
+const INPUTS = [
+  "dev build -i myimage buildtwo --from base-dev --image node:18 --include src --include test -v -v -q mycontainer -- npm run start",
+  "dev build buildname container -i myimage --dev --name webapp externalContainer",
+  "dev --global build --image debian mybox container --dev --name webapp externalContainer -- echo hi",
+  "dev stop mycontainer --kill",
+  "dev stop mycontainer --kill -- not specified one",
+  "dev build --from alpine --image node:20 mybox -- echo hi",
+  "dev build --aaaaa --from alpine --image node:20 --bbbbb orb mybox ccccc -- echo hi",
+  "dev build mybox --global -qvi=debian",
+];
+
+INPUTS.forEach((input) => {
+  console.log("\n\n------------------------\n");
+  console.log("> ", input);
+  parseInputWrap(SPEC, input);
+});

javascript/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "prettier": {
+    "printWidth": 100
+  }
+}