Refactor into modules and make builtins polymorphic

app/builtin/builtin.go

@@ -0,0 +1,203 @@
+package builtin
+
+import "fmt"
+import "os"
+import "os/exec"
+import "strings"
+import "github.com/codecrafters-io/shell-starter-go/app/core"
+
+type Builtin interface {
+	Run(ctx *core.Context) core.ExitStatus
+	ParseArgs(ctx *core.Context, args []string) error
+}
+
+func Parse(ctx *core.Context, name string, args []string) (Builtin, error) {
+	selected, err := selectBuiltin(name)
+	if err != nil {
+		return nil, err
+	}
+	if err := selected.ParseArgs(ctx, args); err != nil {
+		return nil, err
+	}
+	return selected, nil
+}
+
+func selectBuiltin(name string) (Builtin, error) {
+	switch name {
+	case "cd":
+		return &CdBuiltin{}, nil
+	case "echo":
+		return &EchoBuiltin{}, nil
+	case "exit":
+		return &ExitBuiltin{}, nil
+	case "pwd":
+		return &PwdBuiltin{}, nil
+	case "type":
+		return &TypeBuiltin{}, nil
+	default:
+		return nil, ParseError{Code: ParseErrorCodeUnknownBuiltin, value: name}
+	}
+}
+
+type ParseError struct {
+	Code  ParseErrorCode
+	value string
+}
+type ParseErrorCode int
+
+func (self ParseError) Error() string {
+	switch self.Code {
+	case ParseErrorCodeUsage:
+		return fmt.Sprintf("usage: %s", self.value)
+	case ParseErrorCodeUnknownBuiltin:
+		// this should not be seen in normal REPL (we fallback to external command)
+		return fmt.Sprintf("unknown built-in: %s", self.value)
+	default:
+		panic(self.Code)
+	}
+}
+
+const (
+	ParseErrorCodeUsage ParseErrorCode = iota
+	ParseErrorCodeUnknownBuiltin
+)
+
+func makeUsage(pattern string) ParseError {
+	return ParseError{
+		Code:  ParseErrorCodeUsage,
+		value: pattern,
+	}
+}
+
+//
+// builtin: "cd"
+//
+
+type CdBuiltin struct {
+	path string
+}
+
+func (self *CdBuiltin) ParseArgs(ctx *core.Context, args []string) error {
+	usage := makeUsage("cd [PATH]")
+	self.path = ""
+	switch len(args) {
+	case 0:
+		return usage
+	case 1:
+		self.path = args[0]
+		return nil
+	default:
+		return usage
+	}
+}
+
+func (self *CdBuiltin) Run(ctx *core.Context) core.ExitStatus {
+	chdir := func(path string) core.ExitStatus {
+		err := os.Chdir(path)
+		if err != nil {
+			fmt.Fprintf(ctx.Stderr, "cd: %s: No such file or directory\n", path)
+			return 4
+		}
+		return 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 chdir(home_path)
+	}
+	return chdir(self.path)
+}
+
+//
+// builtin: "echo"
+//
+
+type EchoBuiltin struct {
+	args []string
+}
+
+func (self *EchoBuiltin) ParseArgs(ctx *core.Context, args []string) error {
+	self.args = args
+	return nil
+}
+
+func (self *EchoBuiltin) Run(ctx *core.Context) core.ExitStatus {
+	fmt.Fprintln(ctx.Stdout, strings.Join(self.args, " "))
+	return 0
+}
+
+//
+// builtin: "exit"
+//
+
+type ExitBuiltin struct {
+}
+
+func (self *ExitBuiltin) ParseArgs(ctx *core.Context, args []string) error {
+	if len(args) != 0 {
+		return makeUsage("exit")
+	}
+	return nil
+}
+
+func (self *ExitBuiltin) Run(ctx *core.Context) core.ExitStatus {
+	os.Exit(0)
+	return 0
+}
+
+//
+// builtin: "pwd"
+//
+
+type PwdBuiltin struct {
+}
+
+func (self *PwdBuiltin) ParseArgs(ctx *core.Context, args []string) error {
+	if len(args) != 0 {
+		return makeUsage("pwd")
+	}
+	return nil
+}
+
+func (self *PwdBuiltin) Run(ctx *core.Context) core.ExitStatus {
+	cwd_path, err := os.Getwd()
+	if err != nil {
+		panic("error getting current working directory")
+	}
+	fmt.Fprintln(ctx.Stdout, cwd_path)
+	return 0
+}
+
+//
+// builtin: "type"
+//
+
+type TypeBuiltin struct {
+	query string
+}
+
+func (self *TypeBuiltin) ParseArgs(ctx *core.Context, args []string) error {
+	if len(args) != 1 {
+		return makeUsage("type COMMAND")
+	}
+	self.query = args[0]
+	return nil
+}
+
+func (self *TypeBuiltin) Run(ctx *core.Context) core.ExitStatus {
+	_, err := selectBuiltin(self.query)
+	if err == nil {
+		fmt.Fprintf(ctx.Stdout, "%s is a shell builtin\n", self.query)
+		return 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
+	}
+	fmt.Fprintf(ctx.Stderr, "%s: not found\n", self.query)
+	return 0
+}

app/core/core.go

@@ -0,0 +1,20 @@
+package core
+
+import "io"
+import "os"
+
+type ExitStatus uint16
+
+type Context struct {
+	Stdout io.Writer
+	Stderr io.Writer
+	Stdin  io.Reader
+}
+
+func MakeContext() Context {
+	return Context{
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+		Stdin:  os.Stdin,
+	}
+}

app/main.go

@@ -3,270 +3,45 @@ package main
 import (
 	"bufio"
 	"fmt"
-	"io"
 	"os"
-	"os/exec"
-	"strings"
 )
 
-type ExitStatus uint16
+import "github.com/codecrafters-io/shell-starter-go/app/runnable"
+import "github.com/codecrafters-io/shell-starter-go/app/core"
 
-type Context struct {
-	stdout io.Writer
-	stderr io.Writer
-	stdin  io.Reader
-}
-
-func makeContext() Context {
-	return Context{
-		stdout: os.Stdout,
-		stderr: os.Stderr,
-		stdin:  os.Stdin,
-	}
-}
-
-type GetCommandResult int
-
-const (
-	GetCommandResultOk GetCommandResult = iota
-	GetCommandResultError
-)
-
-type Command struct {
-	command_type CommandType
-	args         []string
-	exec_path    string
-	name         string
-}
-
-func makeCommandNone() Command {
-	return Command{
-		command_type: CommandTypeNone,
-		args:         nil,
-		exec_path:    "",
-		name:         "",
-	}
-}
-
-func makeCommandBuiltin(command_type CommandType, tokens []string) Command {
-	switch command_type {
-	case CommandTypeNone:
-		panic("invalid usage")
-	case CommandTypeExternal:
-		panic("invalid usage")
-	default:
-		if len(tokens) < 1 {
-			panic("assertion failed: token list must not be empty")
-		}
-		return Command{
-			command_type: command_type,
-			name:         tokens[0],
-			args:         tokens[1:],
-		}
-	}
-}
-
-func makeCommandExternal(tokens []string, exec_path string) Command {
-	if len(tokens) < 1 {
-		panic("assertion failed: token list must not be empty")
-	}
-	return Command{
-		command_type: CommandTypeExternal,
-		name:         tokens[0],
-		args:         tokens[1:],
-		exec_path:    exec_path,
-	}
-}
-
-type CommandType int
-
-const (
-	CommandTypeNone CommandType = iota
-	CommandTypeExternal
-	CommandTypeBuiltinExit
-	CommandTypeBuiltinEcho
-	CommandTypeBuiltinType
-	CommandTypeBuiltinPwd
-	CommandTypeBuiltinCd
-)
-
-func getCommand(ctx *Context) (Command, error) {
+func getInput(ctx *core.Context) (string, error) {
 	fmt.Print("$ ")
-	command_line, err := bufio.NewReader(ctx.stdin).ReadString('\n')
-	if err != nil {
-		return makeCommandNone(), err
-	}
-	command, err := parseCommand(command_line)
-	// fmt.Printf("getCommand():command=%#v\n", command)
-	if err != nil {
-		fmt.Fprintln(ctx.stderr, err)
-		return makeCommandNone(), nil
-	}
-	return command, nil
-}
-
-func tokenize(str string) []string {
-	tokens := strings.Fields(str)
-	return tokens
-}
-
-type ParseCommandError struct {
-	code  ParseCommandErrorCode
-	value string
-}
-type ParseCommandErrorCode int
-
-const (
-	ParseCommandErrorCodeNotFound ParseCommandErrorCode = iota
-)
-
-func (e ParseCommandError) Error() string {
-	switch e.code {
-	case ParseCommandErrorCodeNotFound:
-		return fmt.Sprintf("%s: not found", e.value)
-	default:
-		return fmt.Sprintf("unknown ParseCommandErrorCode code: %d .value=%q", e.code, e.value)
-	}
-}
-
-func parseCommand(command_line string) (Command, error) {
-	tokens := tokenize(command_line)
-	if len(tokens) == 0 {
-		return makeCommandNone(), nil
-	}
-	if tokens[0] == "exit" {
-		return makeCommandBuiltin(CommandTypeBuiltinExit, tokens), nil
-	}
-	if tokens[0] == "pwd" {
-		return makeCommandBuiltin(CommandTypeBuiltinPwd, tokens), nil
-	}
-	if tokens[0] == "cd" {
-		return makeCommandBuiltin(CommandTypeBuiltinCd, tokens), nil
-	}
-	if tokens[0] == "echo" {
-		return makeCommandBuiltin(CommandTypeBuiltinEcho, tokens), nil
-	}
-	if tokens[0] == "type" {
-		return makeCommandBuiltin(CommandTypeBuiltinType, tokens), nil
-	}
-	exec_path, err := exec.LookPath(tokens[0])
+	input, err := bufio.NewReader(ctx.Stdin).ReadString('\n')
 	if err != nil {
-		return makeCommandNone(), ParseCommandError{ParseCommandErrorCodeNotFound, tokens[0]}
+		return "", err
 	}
-	return makeCommandExternal(tokens, exec_path), nil
+	return input, nil
 }
 
-func bltnChdir(ctx Context, path string) ExitStatus {
-	err := os.Chdir(path)
-	if err != nil {
-		fmt.Fprintf(ctx.stderr, "cd: %s: No such file or directory\n", path)
-		return 4
-	}
-	return 0
-}
-
-func handleCommand(ctx Context, command Command) ExitStatus {
-	// fmt.Printf("handleCommand():command=%#v\n", command)
-	switch command.command_type {
-
-	case CommandTypeNone:
-		return 0
-
-	case CommandTypeBuiltinExit:
-		os.Exit(0)
-
-	case CommandTypeBuiltinEcho:
-		fmt.Fprintln(ctx.stdout, strings.Join(command.args, " "))
-		return 0
-
-	case CommandTypeBuiltinCd:
-		switch len(command.args) {
-		case 0:
-			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 bltnChdir(ctx, home_path)
-		case 1:
-			if command.args[0] == "~" {
-				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 bltnChdir(ctx, home_path)
-			}
-			return bltnChdir(ctx, command.args[0])
-		default:
-			fmt.Fprintln(ctx.stderr, "usage: cd PATH")
-			return 2
-		}
-
-	case CommandTypeBuiltinPwd:
-		if len(command.args) != 0 {
-			fmt.Fprintln(ctx.stderr, "usage: pwd")
-			return 2
-		}
-		cwd_path, err := os.Getwd()
-		if err != nil {
-			panic("error getting current working directory")
-		}
-		fmt.Fprintln(ctx.stdout, cwd_path)
-		return 0
-
-	case CommandTypeBuiltinType:
-		if len(command.args) != 1 {
-			fmt.Fprintln(ctx.stderr, "usage: type COMMAND")
-			return 2
-		}
-		parsed, err := parseCommand(command.args[0])
+func repl(ctx *core.Context) {
+	for {
+		input, err := getInput(ctx)
 		if err != nil {
-			fmt.Fprintln(ctx.stderr, err)
-			return 0
-		}
-		switch parsed.command_type {
-		case CommandTypeNone:
-			panic("impossible parseCommand() result")
-		case CommandTypeExternal:
-			fmt.Fprintf(ctx.stdout, "%s is %s\n", parsed.name, parsed.exec_path)
-		default:
-			fmt.Fprintf(ctx.stdout, "%s is a shell builtin\n", parsed.name)
+			fmt.Fprintln(os.Stderr, "Error reading input: ", err)
+			os.Exit(1)
 		}
-		return 0
 
-	case CommandTypeExternal:
-		cmd := exec.Command(command.exec_path, command.args...)
-		cmd.Args[0] = command.name
-		cmd.Stdout = ctx.stdout
-		cmd.Stderr = ctx.stderr
-		cmd.Stdin = ctx.stdin
-		err := cmd.Run()
+		runnable, err := runnable.Parse(ctx, input)
+		// fmt.Printf("main():runnable=%#v\n", runnable)
 		if err != nil {
-			if exiterr, ok := err.(*exec.ExitError); ok {
-				return ExitStatus(exiterr.ExitCode())
-				// fmt.Printf("handleCommand():exiterr=%#v\n", exiterr.ExitCode())
-			} else {
-				fmt.Printf("handleCommand():err=%#v\n", err)
-				return ExitStatus(65535)
-			}
+			fmt.Fprintln(ctx.Stderr, err)
+			continue
 		}
-		return 0
 
-	default:
-		panic("unknown command type")
+		runnable.Run(ctx)
 	}
-	return ExitStatus(65535)
 }
 
 func main() {
-	ctx := makeContext()
-	for {
-		command, err := getCommand(&ctx)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "Error reading input: ", err)
-			os.Exit(1)
-		}
-		_ = handleCommand(ctx, command)
+	ctx := core.Context{
+		Stdout: os.Stdout,
+		Stderr: os.Stderr,
+		Stdin:  os.Stdin,
 	}
+	repl(&ctx)
 }

app/runnable/runnable.go

@@ -0,0 +1,93 @@
+package runnable
+
+import "os/exec"
+import "fmt"
+
+import "github.com/codecrafters-io/shell-starter-go/app/core"
+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
+}
+
+type ExternalCommand struct {
+	Args     []string
+	ExecPath string
+	Name     string
+}
+
+func (self ExternalCommand) Run(ctx *core.Context) core.ExitStatus {
+	cmd := exec.Command(self.ExecPath, self.Args...)
+	cmd.Args[0] = self.Name
+	cmd.Stdout = ctx.Stdout
+	cmd.Stderr = ctx.Stderr
+	cmd.Stdin = ctx.Stdin
+	err := cmd.Run()
+	if err != nil {
+		if exiterr, ok := err.(*exec.ExitError); ok {
+			return core.ExitStatus(exiterr.ExitCode())
+			// fmt.Printf("Handle():exiterr=%#v\n", exiterr.ExitCode())
+		} else {
+			fmt.Printf("Handle():err=%#v\n", err)
+			return core.ExitStatus(65535)
+		}
+	}
+	return 0
+}
+
+type ParseError struct {
+	code  ParseErrorCode
+	value string
+}
+type ParseErrorCode int
+
+const (
+	ParseErrorCodeNothing ParseErrorCode = iota
+	ParseErrorCodeNotFound
+)
+
+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)
+	}
+
+}
+
+func Parse(ctx *core.Context, command_line string) (Runnable, error) {
+	tokens := tokenize.Tokenize(command_line)
+	if len(tokens) == 0 { // ie. empty or whitespace-only input
+		return nil, ParseError{
+			code: ParseErrorCodeNothing,
+		}
+	}
+	bltn, err := builtin.Parse(ctx, tokens[0], tokens[1:])
+	if err == nil { // it was a builtin
+		return bltn, nil
+	}
+	if e, ok := err.(builtin.ParseError); ok {
+		switch e.Code {
+		case builtin.ParseErrorCodeUsage:
+			return nil, err
+		case builtin.ParseErrorCodeUnknownBuiltin:
+			exec_path, err := exec.LookPath(tokens[0])
+			if err != nil { // command not found
+				return nil, ParseError{
+					code:  ParseErrorCodeNotFound,
+					value: tokens[0],
+				}
+			}
+			return ExternalCommand{
+				ExecPath: exec_path,
+				Name:     tokens[0],
+				Args:     tokens[1:],
+			}, nil
+		}
+	}
+	panic("unexpected builtin.Parse(); only builtin.ParseError is expected")
+}

app/tokenize/tokenize.go

@@ -0,0 +1,8 @@
+package tokenize
+
+import "strings"
+
+func Tokenize(str string) []string {
+	tokens := strings.Fields(str)
+	return tokens
+}