fix up arg validation

Signed-off-by: shmck <shawn.j.mckay@gmail.com>

Author: ShMcK

src/utils/args.ts

@@ -1,32 +1,64 @@
-type ArgValueParams = { name: string; alias?: string; param?: boolean };
+type ArgValueParams = {
+  name: string;
+  alias?: string;
+  type?: "string" | "bool" | "number";
+};
 
-const checkValue = (
+function checkValue<T>(
   args: string[],
   string: string,
-  options: ArgValueParams
-) => {
+  isBool: boolean
+): string | null {
   const nameIndex = args.indexOf(string);
-  if (nameIndex > -1) {
-    if (options.param) {
-      const value = args[nameIndex + 1];
-      if (!value) {
-        throw new Error(`Argument ${string} is missing a parameter value`);
+  if (nameIndex >= 0) {
+    const nextArg = args[nameIndex + 1];
+
+    if (nextArg !== undefined) {
+      const nextIsCommand = !!nextArg.match(/^\-/);
+      if (nextIsCommand) {
+        return isBool ? "true" : null;
       }
-      return value;
+      return nextArg;
+    } else {
+      // no secondary set value
+      return isBool ? "true" : null;
     }
   }
   return null;
-};
+}
 
-export function getArg(args: string[], options: ArgValueParams): string | null {
-  let value: null | string = null;
+export function getArg<T>(
+  args: string[],
+  options: ArgValueParams
+): string | boolean | number | null {
+  let stringValue: null | string = null;
+  const isBool = options.type === "bool";
 
-  const aliasString = `-${options.alias}`;
-  value = checkValue(args, aliasString, options);
-  if (!value) {
+  if (options.alias) {
+    const aliasString = `-${options.alias}`;
+    stringValue = checkValue(args, aliasString, isBool);
+  }
+  if (!stringValue) {
     const nameString = `--${options.name}`;
-    value = checkValue(args, nameString, options);
+    stringValue = checkValue(args, nameString, isBool);
+  }
+
+  if (stringValue === null) {
+    return null;
   }
 
-  return value;
+  if (!options.type) {
+    options.type = "string";
+  }
+
+  // coerce type
+  switch (options.type) {
+    case "bool":
+      return (stringValue || "").toLowerCase() !== "false";
+    case "number":
+      return Number(stringValue);
+    case "string":
+    default:
+      return stringValue;
+  }
 }

src/validate.ts

@@ -10,17 +10,30 @@ import {
 } from "./utils/exec";
 import { getCommits, CommitLogObject } from "./utils/commits";
 
+interface Options {
+  yaml: string;
+  clean: boolean;
+}
+
 async function validate(args: string[]) {
   // dir - default .
   const dir = !args.length || args[0].match(/^-/) ? "." : args[0];
   const localDir = path.join(process.cwd(), dir);
 
   // -y --yaml - default coderoad-config.yml
-  const options = {
-    yaml: getArg(args, { name: "yaml", alias: "y" }) || "coderoad.yaml",
+  const options: Options = {
+    // @ts-ignore
+    yaml:
+      getArg(args, { name: "yaml", alias: "y", type: "string" }) ||
+      "coderoad.yaml",
+    // @ts-ignore
+    clean: getArg(args, { name: "clean", alias: "c", type: "bool" }),
   };
 
-  const _yaml = await fs.readFile(path.join(localDir, options.yaml), "utf8");
+  const _yaml: string = await fs.readFile(
+    path.join(localDir, options.yaml),
+    "utf8"
+  );
 
   // parse yaml config
   let skeleton;
@@ -158,7 +171,10 @@ async function validate(args: string[]) {
     console.error(e.message);
   } finally {
     // cleanup
-    await fs.emptyDir(tmpDir);
+    console.log("options.clean", options.clean);
+    if (options.clean) {
+      await fs.emptyDir(tmpDir);
+    }
   }
 }
 

tests/args.test.ts

@@ -21,6 +21,24 @@ describe("args", () => {
     const result = getArg(args, { name: "name", alias: "n" });
     expect(result).toBe("value");
   });
+  it("should convert bool string to true", () => {
+    const args = ["--someBool", "true"];
+    const result = getArg(args, {
+      name: "someBool",
+      alias: "sb",
+      type: "bool",
+    });
+    expect(result).toBe(true);
+  });
+  it("should convert bool string to false", () => {
+    const args = ["--someBool", "false"];
+    const result = getArg(args, {
+      name: "someBool",
+      alias: "sb",
+      type: "bool",
+    });
+    expect(result).toBe(false);
+  });
   it("should default value to true if no next value", () => {
     const args = ["--someBool"];
     const result = getArg(args, {
@@ -30,7 +48,7 @@ describe("args", () => {
     });
     expect(result).toBe(true);
   });
-  it("should default value to true if next value is param", () => {
+  it("should default value to true if next value is --name", () => {
     const args = ["--someBool", "--someOtherBool"];
     const result = getArg(args, {
       name: "someBool",
@@ -39,4 +57,13 @@ describe("args", () => {
     });
     expect(result).toBe(true);
   });
+  it("should default value to true if next value is -alias", () => {
+    const args = ["--someBool", "-a"];
+    const result = getArg(args, {
+      name: "someBool",
+      alias: "sb",
+      type: "bool",
+    });
+    expect(result).toBe(true);
+  });
 });