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

 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 {
 	}
 }
 
-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)
 	}
 	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)
 }
 
 //
 	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)
 }
 
 //
 	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)
 }
 
 //
 	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

 		Stdin:  os.Stdin,
 	}
 }
+
+type ActionResult struct {
+	Code       ActionResultCode
+	ExitStatus ExitStatus
+}
+type ActionResultCode uint8
+
+const (
+	ActionResultCodeNoop ActionResultCode = iota
+	ActionResultCodeBuiltinCommand
+	ActionResultCodeExternalCommand
+)

app/main.go

 			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

 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 {
 	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
 	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 {
 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)
 	}
 	}
 	//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
 	}
 	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,
+	}
+}