feat(commandpost): use CommandpostError instead of Error

Author: vvakame

lib/argument.ts

@@ -1,3 +1,5 @@
+import { CommandpostError, ErrorReason } from "./error";
+
 // jsdoc, see constructor.
 export default class Argument {
     /** argument name */
@@ -27,7 +29,14 @@ export default class Argument {
                 this.name = arg.slice(1, -1);
                 break;
             default:
-                throw new Error("unsupported format: " + arg);
+                throw new CommandpostError({
+                    message: `unsupported format: ${arg}`,
+                    reason: ErrorReason.UnsupportedFormatArgument,
+                    params: {
+                        origin: this,
+                        arg,
+                    },
+                });
         }
         if (/\.\.\.$/.test(this.name)) {
             this.name = this.name.slice(0, -3);
@@ -57,7 +66,15 @@ export default class Argument {
      */
     parse(opts: any, args: string[]): string[] {
         if (this.required && this.variadic && args.length === 0) {
-            throw new Error(this.name + " is required more than 1 argument");
+            throw new CommandpostError({
+                message: `${this.name} is required more than 1 argument`,
+                reason: ErrorReason.ArgumentsRequired,
+                params: {
+                    origin: this,
+                    opts,
+                    args,
+                },
+            });
         }
         if (this.variadic) {
             opts[this.name] = args;
@@ -66,7 +83,15 @@ export default class Argument {
         }
         let arg = args.shift();
         if (this.required && !arg) {
-            throw new Error(this.name + " is required");
+            throw new CommandpostError({
+                message: `${this.name} is required`,
+                reason: ErrorReason.ArgumentRequired,
+                params: {
+                    origin: this,
+                    opts,
+                    args,
+                },
+            });
         }
         opts[this.name] = arg;
         return args;

lib/command.ts

@@ -1,5 +1,6 @@
 import Option from "./option";
 import Argument from "./argument";
+import { CommandpostError, ErrorReason } from "./error";
 
 import * as utils from "./utils";
 
@@ -122,11 +123,17 @@ export default class Command<Opt, Arg> {
         let findVariadic = false;
         this.args = args.map(argStr => {
             if (findVariadic) {
-                throw new Error("parameter can not placed after variadic parameter");
+                throw new CommandpostError({
+                    message: "parameter can not placed after variadic parameter",
+                    reason: ErrorReason.ParameterCantPlacedAfterVariadic,
+                });
             }
             let arg = new Argument(argStr);
             if (arg.required && findOptional) {
-                throw new Error("required parameter is not placed after optional parameter");
+                throw new CommandpostError({
+                    message: "parameter can not placed after variadic parameter",
+                    reason: ErrorReason.ParameterCannPlacedAfterOptional,
+                });
             }
             if (!arg.required) {
                 findOptional = true;
@@ -354,7 +361,14 @@ export default class Command<Opt, Arg> {
             errMsg += this.unknownOptions.length === 1 ? " " : "s ";
             errMsg += this.unknownOptions.join(", ") + "\n";
             errMsg += this.helpText();
-            throw new Error(errMsg);
+            throw new CommandpostError({
+                message: errMsg,
+                reason: ErrorReason.UnknownOption,
+                params: {
+                    origin: this,
+                    args,
+                },
+            });
         }
         if (this._matchSubCommand(rest)) {
             return rest;

lib/error.ts

@@ -0,0 +1,44 @@
+import * as util from "util";
+
+import Command from "./command";
+import Argument from "./argument";
+import Option from "./option";
+
+export interface ErrorParameters {
+    message?: string;
+    reason: ErrorReason;
+    params?:
+    { origin: Argument; arg: string; } |
+    { origin: Argument; opts: any; args: string[]; } |
+    { origin: Command<any, any>; args: string[]; } |
+    { option: Option; opts: any; args: string[]; };
+}
+
+export const enum ErrorReason {
+    UnsupportedFormatArgument = "unsupported format",
+    ArgumentsRequired = "1 or more arguments required",
+    ArgumentRequired = "argument required",
+    ParameterCantPlacedAfterVariadic = "parameter can not placed after variadic parameter",
+    ParameterCannPlacedAfterOptional = "required parameter is not placed after optional parameter",
+    UnknownOption = "unknown option",
+    OptionNameMismatch = "short or long option name mismatch",
+    OptionValueRequired = "option value required",
+}
+
+export class CommandpostError {
+    stack?: string;
+
+    constructor(public params: ErrorParameters) {
+        Error.captureStackTrace(this, this.constructor);
+    }
+
+    get name() {
+        return this.constructor.name;
+    }
+
+    get message() {
+        return this.params.message;
+    }
+}
+
+util.inherits(CommandpostError, Error);

lib/option.ts

@@ -1,3 +1,4 @@
+import { CommandpostError, ErrorReason } from "./error";
 import * as utils from "./utils";
 
 // jsdoc, see constructor.
@@ -87,13 +88,29 @@ export default class Option {
      */
     parse(opts: any, args: string[]): string[] {
         if (!this.is(args[0])) {
-            throw new Error(args[0] + " is not match " + this.short + " or " + this.long);
+            throw new CommandpostError({
+                message: `${args[0]} is not match ${this.short} or ${this.long}`,
+                reason: ErrorReason.OptionNameMismatch,
+                params: {
+                    option: this,
+                    opts,
+                    args,
+                },
+            });
         }
         let next = args[1];
         let propertyName = utils.kebabToLowerCamelCase(this.name());
         if (this.required) {
             if (next == null) {
-                throw new Error(args[0] + " is required parameter value");
+                throw new CommandpostError({
+                    message: `${args[0]} is required parameter value`,
+                    reason: ErrorReason.OptionValueRequired,
+                    params: {
+                        option: this,
+                        opts,
+                        args,
+                    },
+                });
             }
             opts[propertyName] = opts[propertyName] || [];
             opts[propertyName].push(next);

test/argumentSpec.ts

@@ -1,6 +1,7 @@
 import * as assert from "power-assert";
 
 import Argument from "../lib/argument";
+import { CommandpostError } from "../lib/error";
 
 describe("Argument", () => {
     describe("constructor", () => {
@@ -51,6 +52,10 @@ describe("Argument", () => {
                 arg.parse(parsed, []);
             } catch (e) {
                 caught = true;
+                assert(e instanceof Error);
+                assert(e instanceof CommandpostError);
+                let err = e as CommandpostError;
+                assert(err.params.message === "foobar is required");
             }
 
             assert(caught);