add nameless options + more tests [skip publish]

chenasraf · chenasraf · commit a45415842ae7 · 2021-07-19T02:52:31.000+03:00
diff --git a/README.md b/README.md
@@ -13,14 +13,14 @@ Yes, there are a lot of arg parsers. But hear us out.
 - Options with flexible parsing
 - Required options
 - Options with multiple values
-- Nameless options (TBD)
+- Nameless options
 - Automatically generated help text:
   - Customizable colors
   - Customizable header and footer text
   - Customizable usage examples
   - Automatic text alignment
   - Add run examples for your args (TBD)
-  - Shows default value and type next to description (customizable) (TBD)
+  - Shows default value and type next to description
 - TypeScript-first package: You will always have strong types
 
 ## Usage
@@ -109,6 +109,10 @@ $ ./mybin --my-string "Some string"
 Commands are activated when their keyword is included in the args. The first command that matches
 will be executed, skipping the rest. Options will still be parsed.
 
+Any arguments that are not taken by options or commands, are automatically passed to
+`options.extra`, which you can access when running a command or when using the return value from
+`parseArgs()`.
+
 #### Options
 
 | Name          | Type                        | Required | Example                                           | Description                                                                                                          |
@@ -149,6 +153,10 @@ $ ./mybin my-command --my-string "Some string"
 Options are variables you can accept via CLI and parse to use in your commands, e.g. `--my-bool`,
 `--my-string string`, `--my-number 1`
 
+Any arguments that are not taken by options or commands, are automatically passed to
+`options.extra`, which you can access when running a command or when using the return value from
+`parseArgs()`.
+
 #### Options
 
 | Name          | Type                              | Required | Default  | Example                               | Description                                                                                                                                                                                                      |
diff --git a/src/index.ts b/src/index.ts
@@ -14,8 +14,10 @@ export class Massarg<Options extends OptionsBase = OptionsBase> {
   private _commands: CommandDef<Options>[] = []
   private _runCommand?: CommandDef<Options>
   private _maxNameLen = 0
-  /** These are the parsed options passed via args. They will only be available after using `parse()` or `printHelp()`. */
-  public data: Options = { help: false } as Options
+  /**
+   * These are the parsed options passed via args. They will only be available after using `parse()` or `printHelp()`,
+   * or when retured by `parseArgs()`. */
+  public data: Options = { help: false, extras: [] as string[] } as Options
 
   private _help: Required<HelpDef> = {
     binName: undefined as any,
@@ -201,6 +203,10 @@ export class Massarg<Options extends OptionsBase = OptionsBase> {
         }
         this._runCommand = command
       }
+
+      if (!option && !command) {
+        this.data.extras.push(arg)
+      }
     }
     return this.data
   }
@@ -229,16 +235,16 @@ export class Massarg<Options extends OptionsBase = OptionsBase> {
       } else if (this._main) {
         this._ensureRequired()
         this._main(this.data)
+      } else {
+        this._ensureRequired()
       }
     } catch (e) {
       if (e.cmdName && e.fieldName) {
         console.log()
         console.error("Error")
         console.error(chalk.red`${e.message}`)
-        process.exit(1)
-      } else {
-        throw e
       }
+      throw e
     }
     return
   }
diff --git a/src/options.d.ts b/src/options.d.ts
@@ -4,6 +4,9 @@ import chalk from "chalk"
 export type OptionsBase = {
   /** When `true`, will output help text and exit the process without error */
   help: boolean
+
+  /** This contains arguments that were not taken by any command or option. */
+  extras: string[]
 }
 
 export type MainDef<Options> = (options: Options) => void
diff --git a/tests/extras.test.ts b/tests/extras.test.ts
@@ -0,0 +1,14 @@
+import massarg from "../src"
+
+describe("Extras", () => {
+  test("should take extra values unparsed", () => {
+    const options = massarg()
+      .option({
+        name: "number",
+        parse: (v) => parseInt(v),
+      })
+      .parseArgs(["--number", "10", "app name"])
+    expect(options).toHaveProperty("number", 10)
+    expect(options).toHaveProperty("extras", ["app name"])
+  })
+})
diff --git a/tests/help.test.ts b/tests/help.test.ts
@@ -23,6 +23,21 @@ describe("Print Help", () => {
         "\n"
     )
   })
+
+  test("should not throw when passing args", () => {
+    expect(() =>
+      massarg()
+        .help({ binName: "test", useColors: false })
+        .option({
+          name: "number",
+          description: "Number value",
+          parse: (v) => parseInt(v),
+        })
+        .getHelpString(["--help"])
+        .join("\n")
+    ).not.toThrow()
+  })
+
   test("should print help correctly with only global options", () => {
     const helpStr = massarg()
       .help({ binName: "test", useColors: false })
diff --git a/tests/options.test.ts b/tests/options.test.ts
@@ -2,78 +2,150 @@ import massarg from "../src"
 import { OptionDef } from "../src/options"
 
 describe("Options", () => {
-  test("should parse properly", () => {
-    const options = massarg()
-      .option({
-        name: "number",
-        parse: (v) => parseInt(v),
-      })
-      .parseArgs(["--number", "10"])
-    expect(options).toHaveProperty("number", 10)
-  })
+  describe("basics", () => {
+    test("should parse properly", () => {
+      const options = massarg()
+        .option({
+          name: "number",
+          parse: (v) => parseInt(v),
+        })
+        .parseArgs(["--number", "10"])
+      expect(options).toHaveProperty("number", 10)
+    })
 
-  test("should read from alias", () => {
-    const options = massarg()
-      .option({
-        name: "number",
-        aliases: ["n"],
-        parse: (v) => parseInt(v),
-      })
-      .parseArgs(["-n", "10"])
-    expect(options).toHaveProperty("number", 10)
-    expect(options).toHaveProperty("n", 10)
+    test("should read from alias", () => {
+      const options = massarg()
+        .option({
+          name: "number",
+          aliases: ["n"],
+          parse: (v) => parseInt(v),
+        })
+        .parseArgs(["-n", "10"])
+      expect(options).toHaveProperty("number", 10)
+      expect(options).toHaveProperty("n", 10)
+    })
   })
 
-  test("should camelCase names", () => {
-    const options = massarg()
-      .option({
-        name: "is-number",
-        aliases: ["n"],
-        parse: (v) => parseInt(v),
-      })
-      .parseArgs(["--is-number", "10"])
+  describe("parsing", () => {
+    test("should camelCase names", () => {
+      const options = massarg()
+        .option({
+          name: "is-number",
+          aliases: ["n"],
+          parse: (v) => parseInt(v),
+        })
+        .parseArgs(["--is-number", "10"])
 
-    expect(options).toHaveProperty("isNumber", 10)
-    expect(options).toHaveProperty("is-number", 10)
-    expect(options).toHaveProperty("n", 10)
-  })
+      expect(options).toHaveProperty("isNumber", 10)
+      expect(options).toHaveProperty("is-number", 10)
+      expect(options).toHaveProperty("n", 10)
+    })
 
-  test("should parse bool in correct forms", () => {
-    const opts = {
-      name: "bool",
-      boolean: true,
-    } as OptionDef<any, any>
-    const noArg = massarg().option(opts).parseArgs(["--bool"])
-    expect(noArg).toHaveProperty("bool", true)
+    describe("bool", () => {
+      test("should parse bool in correct forms", () => {
+        const opts = {
+          name: "bool",
+          boolean: true,
+        } as OptionDef<any, any>
 
-    const truthyNumArg = massarg().option(opts).parseArgs(["--bool", "1"])
-    expect(truthyNumArg).toHaveProperty("bool", true)
+        const noArg = massarg().option(opts).parseArgs(["--bool"])
+        expect(noArg).toHaveProperty("bool", true)
 
-    const falsyNumArg = massarg().option(opts).parseArgs(["--bool", "0"])
-    expect(falsyNumArg).toHaveProperty("bool", false)
-  })
+        const truthyNumArg = massarg().option(opts).parseArgs(["--bool", "1"])
+        expect(truthyNumArg).toHaveProperty("bool", true)
 
-  test("should expect value when not bool", () => {
-    const opts = {
-      name: "number",
-      parse: (v) => parseInt(v),
-    } as OptionDef<any, any>
-    expect(() => massarg().option(opts).parseArgs(["--number"])).toThrow("Missing value for: number")
-  })
+        const falsyNumArg = massarg().option(opts).parseArgs(["--bool", "0"])
+        expect(falsyNumArg).toHaveProperty("bool", false)
+      })
+    })
 
-  test("should parse array in correct forms", () => {
-    const opts = {
-      name: "array",
-      array: true,
-    } as OptionDef<any, any>
+    describe("array", () => {
+      test("should parse array in correct forms", () => {
+        const opts = {
+          name: "array",
+          array: true,
+        } as OptionDef<any, any>
 
-    const arr0el = massarg().option(opts).parseArgs([])
-    expect(arr0el).toHaveProperty("array", [])
+        const arr0el = massarg().option(opts).parseArgs([])
+        expect(arr0el).toHaveProperty("array", [])
 
-    const arr1el = massarg().option(opts).parseArgs(["--array", "something"])
-    expect(arr1el).toHaveProperty("array", ["something"])
+        const arr1el = massarg().option(opts).parseArgs(["--array", "something"])
+        expect(arr1el).toHaveProperty("array", ["something"])
 
-    const arr2el = massarg().option(opts).parseArgs(["--array", "something", "--array", "another"])
-    expect(arr2el).toHaveProperty("array", ["something", "another"])
+        const arr2el = massarg().option(opts).parseArgs(["--array", "something", "--array", "another"])
+        expect(arr2el).toHaveProperty("array", ["something", "another"])
+      })
+    })
+
+    test("should expect value when not bool", () => {
+      expect(() =>
+        massarg()
+          .option({
+            name: "number",
+            parse: (v) => parseInt(v),
+          })
+          .parseArgs(["--number"])
+      ).toThrow("Missing value for: number")
+    })
+
+    describe("required", () => {
+      test("should throw on missing required value", () => {
+        const mockConsoleError = jest.spyOn(console, "error").mockImplementation(() => void 0)
+        const mockConsoleLog = jest.spyOn(console, "log").mockImplementation(() => void 0)
+        expect(() =>
+          massarg()
+            .option({
+              name: "number",
+              parse: (v) => parseInt(v),
+              required: true,
+            })
+            .parse(["--not-number", "abcdefg"])
+        ).toThrow("number is required, but was not defined")
+        mockConsoleError.mockRestore()
+        mockConsoleLog.mockRestore()
+      })
+
+      test("should not throw on existing required value for command", () => {
+        const mockConsoleError = jest.spyOn(console, "error").mockImplementation(() => void 0)
+        const mockConsoleLog = jest.spyOn(console, "log").mockImplementation(() => void 0)
+        expect(() =>
+          massarg()
+            .option({
+              name: "number",
+              parse: (v) => parseInt(v),
+              commands: "cmd",
+              required: true,
+            })
+            .command({
+              name: "cmd",
+              run: () => void 0,
+            })
+            .parse(["cmd", "--number", "10"])
+        ).not.toThrow("number is required, but was not defined")
+        mockConsoleError.mockRestore()
+        mockConsoleLog.mockRestore()
+      })
+
+      test("should throw on missing required value for command", () => {
+        const mockConsoleError = jest.spyOn(console, "error").mockImplementation(() => void 0)
+        const mockConsoleLog = jest.spyOn(console, "log").mockImplementation(() => void 0)
+        expect(() =>
+          massarg()
+            .option({
+              name: "number",
+              parse: (v) => parseInt(v),
+              commands: "cmd",
+              required: true,
+            })
+            .command({
+              name: "cmd",
+              run: () => void 0,
+            })
+            .parse(["cmd"])
+        ).toThrow("number is required, but was not defined")
+        mockConsoleError.mockRestore()
+        mockConsoleLog.mockRestore()
+      })
+    })
   })
 })

Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,10 @@ export class Massarg<Options extends OptionsBase = OptionsBase> {`
`14`	`14`	`private _commands: CommandDef<Options>[] = []`
`15`	`15`	`private _runCommand?: CommandDef<Options>`
`16`	`16`	`private _maxNameLen = 0`
`17`		- /** These are the parsed options passed via args. They will only be available after using `parse()` or `printHelp()`. */
`18`		`- public data: Options = { help: false } as Options`
	`17`	`+ /**`
	`18`	+ * These are the parsed options passed via args. They will only be available after using `parse()` or `printHelp()`,
	`19`	+ * or when retured by `parseArgs()`. */
	`20`	`+ public data: Options = { help: false, extras: [] as string[] } as Options`
`19`	`21`
`20`	`22`	`private _help: Required<HelpDef> = {`
`21`	`23`	`binName: undefined as any,`
`@@ -201,6 +203,10 @@ export class Massarg<Options extends OptionsBase = OptionsBase> {`
`201`	`203`	`}`
`202`	`204`	`this._runCommand = command`
`203`	`205`	`}`
	`206`	`+`
	`207`	`+ if (!option && !command) {`
	`208`	`+ this.data.extras.push(arg)`
	`209`	`+ }`
`204`	`210`	`}`
`205`	`211`	`return this.data`
`206`	`212`	`}`
`@@ -229,16 +235,16 @@ export class Massarg<Options extends OptionsBase = OptionsBase> {`
`229`	`235`	`} else if (this._main) {`
`230`	`236`	`this._ensureRequired()`
`231`	`237`	`this._main(this.data)`
	`238`	`+ } else {`
	`239`	`+ this._ensureRequired()`
`232`	`240`	`}`
`233`	`241`	`} catch (e) {`
`234`	`242`	`if (e.cmdName && e.fieldName) {`
`235`	`243`	`console.log()`
`236`	`244`	`console.error("Error")`
`237`	`245`	console.error(chalk.red`${e.message}`)
`238`		`- process.exit(1)`
`239`		`- } else {`
`240`		`- throw e`
`241`	`246`	`}`
	`247`	`+ throw e`
`242`	`248`	`}`
`243`	`249`	`return`
`244`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,9 @@ import chalk from "chalk"`
`4`	`4`	`export type OptionsBase = {`
`5`	`5`	/** When `true`, will output help text and exit the process without error */
`6`	`6`	`help: boolean`
	`7`	`+`
	`8`	`+ /** This contains arguments that were not taken by any command or option. */`
	`9`	`+ extras: string[]`
`7`	`10`	`}`
`8`	`11`
`9`	`12`	`export type MainDef<Options> = (options: Options) => void`