Wrap Runnable.Run()'s ExitStatus in a more general ActionResult

This helps us get rid of ParseError abuse and thus fix undesired stderr
exit on every empty REPL loop.

app/builtin/builtin.go

@@ -7,10 +7,17 @@ import "strings"
 import "github.com/codecrafters-io/shell-starter-go/app/core"
 
 type Builtin interface {
-	Run(ctx *core.Context) core.ExitStatus
+	Run(ctx *core.Context) core.ActionResult
 	ParseArgs(ctx *core.Context, args []string) error
 }
 
+func wrapEs(es int) core.ActionResult {
+	return core.ActionResult{
+		Code:       core.ActionResultCodeBuiltinCommand,
+		ExitStatus: core.ExitStatus(es),
+	}
+}
+
 func Parse(ctx *core.Context, name string, args []string) (Builtin, error) {
 	selected, err := selectBuiltin(name)
 	if err != nil {
@@ -91,20 +98,20 @@ func (self *CdBuiltin) ParseArgs(ctx *core.Context, args []string) error {
 	}
 }
 
-func (self *CdBuiltin) Run(ctx *core.Context) core.ExitStatus {
-	chdir := func(path string) core.ExitStatus {
+func (self *CdBuiltin) Run(ctx *core.Context) core.ActionResult {
+	chdir := func(path string) core.ActionResult {
 		err := os.Chdir(path)
 		if err != nil {
 			fmt.Fprintf(ctx.Stderr, "cd: %s: No such file or directory\n", path)
-			return 4
+			return wrapEs(4)
 		}
-		return 0
+		return wrapEs(0)
 	}
 	if self.path == "~" || self.path == "" {
 		home_path := os.Getenv("HOME")
 		if len(home_path) == 0 {
 			fmt.Fprintln(ctx.Stderr, "error: $HOME environment variable is empty or unset")
-			return 4
+			return wrapEs(4)
 		}
 		return chdir(home_path)
 	}
@@ -124,9 +131,9 @@ func (self *EchoBuiltin) ParseArgs(ctx *core.Context, args []string) error {
 	return nil
 }
 
-func (self *EchoBuiltin) Run(ctx *core.Context) core.ExitStatus {
+func (self *EchoBuiltin) Run(ctx *core.Context) core.ActionResult {
 	fmt.Fprintln(ctx.Stdout, strings.Join(self.args, " "))
-	return 0
+	return wrapEs(0)
 }
 
 //
@@ -143,9 +150,9 @@ func (self *ExitBuiltin) ParseArgs(ctx *core.Context, args []string) error {
 	return nil
 }
 
-func (self *ExitBuiltin) Run(ctx *core.Context) core.ExitStatus {
+func (self *ExitBuiltin) Run(ctx *core.Context) core.ActionResult {
 	os.Exit(0)
-	return 0
+	return wrapEs(0)
 }
 
 //
@@ -162,13 +169,13 @@ func (self *PwdBuiltin) ParseArgs(ctx *core.Context, args []string) error {
 	return nil
 }
 
-func (self *PwdBuiltin) Run(ctx *core.Context) core.ExitStatus {
+func (self *PwdBuiltin) Run(ctx *core.Context) core.ActionResult {
 	cwd_path, err := os.Getwd()
 	if err != nil {
 		panic("error getting current working directory")
 	}
 	fmt.Fprintln(ctx.Stdout, cwd_path)
-	return 0
+	return wrapEs(0)
 }
 
 //
@@ -187,17 +194,17 @@ func (self *TypeBuiltin) ParseArgs(ctx *core.Context, args []string) error {
 	return nil
 }
 
-func (self *TypeBuiltin) Run(ctx *core.Context) core.ExitStatus {
+func (self *TypeBuiltin) Run(ctx *core.Context) core.ActionResult {
 	_, err := selectBuiltin(self.query)
 	if err == nil {
 		fmt.Fprintf(ctx.Stdout, "%s is a shell builtin\n", self.query)
-		return 0
+		return wrapEs(0)
 	}
 	exec_path, err := exec.LookPath(self.query)
 	if err == nil {
 		fmt.Fprintf(ctx.Stdout, "%s is %s\n", self.query, exec_path)
-		return 0
+		return wrapEs(0)
 	}
 	fmt.Fprintf(ctx.Stderr, "%s: not found\n", self.query)
-	return 0
+	return wrapEs(0)
 }

app/core/core.go

@@ -18,3 +18,15 @@ func MakeContext() Context {
 		Stdin:  os.Stdin,
 	}
 }
+
+type ActionResult struct {
+	Code       ActionResultCode
+	ExitStatus ExitStatus
+}
+type ActionResultCode uint8
+
+const (
+	ActionResultCodeNoop ActionResultCode = iota
+	ActionResultCodeBuiltinCommand
+	ActionResultCodeExternalCommand
+)

app/main.go

@@ -33,7 +33,15 @@ func repl(ctx *core.Context) {
 			continue
 		}
 
-		runnable.Run(ctx)
+		result := runnable.Run(ctx)
+		switch result.Code {
+		case core.ActionResultCodeNoop:
+		case core.ActionResultCodeBuiltinCommand:
+		case core.ActionResultCodeExternalCommand:
+		default:
+			fmt.Fprintf(os.Stderr, "unknown action result code input: %d", result.Code)
+			os.Exit(15)
+		}
 	}
 }
 

app/runnable/runnable.go

@@ -8,7 +8,7 @@ import "github.com/codecrafters-io/shell-starter-go/app/tokenize"
 import "github.com/codecrafters-io/shell-starter-go/app/builtin"
 
 type Runnable interface {
-	Run(ctx *core.Context) core.ExitStatus
+	Run(ctx *core.Context) core.ActionResult
 }
 
 type ExternalCommand struct {
@@ -17,7 +17,13 @@ type ExternalCommand struct {
 	Name     string
 }
 
-func (self ExternalCommand) Run(ctx *core.Context) core.ExitStatus {
+func (self ExternalCommand) Run(ctx *core.Context) core.ActionResult {
+	wrapEs := func(es int) core.ActionResult {
+		return core.ActionResult{
+			Code:       core.ActionResultCodeExternalCommand,
+			ExitStatus: core.ExitStatus(es),
+		}
+	}
 	cmd := exec.Command(self.ExecPath, self.Args...)
 	cmd.Args[0] = self.Name
 	cmd.Stdout = ctx.Stdout
@@ -26,14 +32,14 @@ func (self ExternalCommand) Run(ctx *core.Context) core.ExitStatus {
 	err := cmd.Run()
 	if err != nil {
 		if exiterr, ok := err.(*exec.ExitError); ok {
-			return core.ExitStatus(exiterr.ExitCode())
+			return wrapEs(exiterr.ExitCode())
 			// fmt.Printf("Handle():exiterr=%#v\n", exiterr.ExitCode())
 		} else {
 			fmt.Printf("Handle():err=%#v\n", err)
-			return core.ExitStatus(65535)
+			return wrapEs(65535)
 		}
 	}
-	return 0
+	return wrapEs(0)
 }
 
 type ParseError struct {
@@ -43,16 +49,13 @@ type ParseError struct {
 type ParseErrorCode int
 
 const (
-	ParseErrorCodeNothing ParseErrorCode = iota
-	ParseErrorCodeNotFound
+	ParseErrorCodeNotFound ParseErrorCode = iota
 )
 
 func (e ParseError) Error() string {
 	switch e.code {
 	case ParseErrorCodeNotFound:
 		return fmt.Sprintf("%s: not found", e.value)
-	case ParseErrorCodeNothing:
-		return ""
 	default:
 		return fmt.Sprintf("unknown ParseErrorCode code: %d .value=%q", e.code, e.value)
 	}
@@ -66,9 +69,7 @@ func Parse(ctx *core.Context, command_line string) (Runnable, error) {
 	}
 	//fmt.Printf("Parse():tokens=%#v\n", tokens)
 	if len(tokens) == 0 { // ie. empty or whitespace-only input
-		return nil, ParseError{
-			code: ParseErrorCodeNothing,
-		}
+		return Noop{}, nil
 	}
 	bltn, err := builtin.Parse(ctx, tokens[0], tokens[1:])
 	if err == nil { // it was a builtin
@@ -95,3 +96,12 @@ func Parse(ctx *core.Context, command_line string) (Runnable, error) {
 	}
 	panic("unexpected builtin.Parse(); only builtin.ParseError is expected")
 }
+
+type Noop struct{}
+
+func (self Noop) Run(ctx *core.Context) core.ActionResult {
+	return core.ActionResult{
+		Code:       core.ActionResultCodeNoop,
+		ExitStatus: 0,
+	}
+}