Streamline command prompt string generation

command/command.go

@@ -1,7 +1,7 @@
 package command
 
 import (
-	"fmt"
+	"os"
 	"os/exec"
 	"strings"
 )
@@ -30,15 +30,11 @@ func GetCommand(text string) Command {
 
 // HasArgs returns true if the command has arguments or false if it does not have arguments
 func (c Command) HasArgs() bool {
-	if len(c.Args) == 0 {
-		return false
-	}
-	return true
+	return len(c.Args) > 0
 }
 
 // Execute executes the command
-func (c Command) Execute() {
-
+func (c Command) Execute() error {
 	var cmd *exec.Cmd
 
 	if c.HasArgs() {
@@ -47,7 +43,8 @@ func (c Command) Execute() {
 		cmd = exec.Command(c.Exec)
 	}
 
-	out, _ := cmd.CombinedOutput()
+	cmd.Stderr = os.Stderr
+	cmd.Stdout = os.Stdout
 
-	fmt.Printf("%s\n", out)
+	return cmd.Run()
 }

main.go

@@ -5,7 +5,5 @@ import (
 )
 
 func main() {
-
 	shell.Run()
-
 }

prompt/prompt.go

@@ -0,0 +1,70 @@
+package prompt
+
+import (
+	"fmt"
+	"os"
+	"os/user"
+	"strings"
+)
+
+// Cmdprompt holds all key information for the prompt.
+type Cmdprompt struct {
+	username string
+	hostname string
+	prompt   string
+}
+
+// New returns a Cmdprompt pre-populated with various system-level information
+// such as the username and hostname
+// the string representation of it returns a prompt with the current
+// working directory as well as the cached username and host.
+func New(promptChar string) *Cmdprompt {
+	if len(promptChar) == 0 {
+		promptChar = ":"
+	}
+	return &Cmdprompt{
+		username: username(),
+		hostname: hostname(),
+		prompt:   promptChar,
+	}
+}
+
+func (i *Cmdprompt) String() string {
+	cwd := workdir()
+	return fmt.Sprintf("%s@%s %s %s ", i.username, i.hostname, cwd, i.prompt)
+}
+
+func username() string {
+	fallbackUsername := "unknown" // this should be rare.
+	user, err := user.Current()
+	if err != nil {
+		return fallbackUsername
+	}
+	return user.Username
+}
+
+func hostname() string {
+	fallbackHostname := "localhost"
+	hn, err := os.Hostname()
+	if err != nil {
+		return fallbackHostname
+	}
+	return hn
+}
+
+func workdir() string {
+	fallbackWorkdir := "?" // this should be rare.
+	wd, err := os.Getwd()
+	if err != nil {
+		wd = fallbackWorkdir
+	}
+
+	homedir := os.Getenv("HOME")
+	if homedir == wd {
+		return "~"
+	} else if strings.HasPrefix(wd, homedir) {
+		return "~" + strings.TrimPrefix(wd, homedir)
+	} else {
+		return wd
+	}
+}

shell/interpret.go

@@ -1,32 +1,24 @@
 package shell
 
 import (
-	"fmt"
+	"strings"
 
 	"github.com/cezarmathe/gosh/builtin"
 	"github.com/cezarmathe/gosh/command"
 )
 
-func interpret() {
-	shellPrompt.Print()
-
-	text, err := readInput()
-
-	if err != nil {
-		fmt.Println(err)
-		return
+func interpret(cmd string) error {
+	cmd = strings.TrimRight(cmd, "\r\n")
+	// no command was actually issued.
+	if cmd == "" {
+		return nil
 	}
 
-	com := command.GetCommand(text)
+	com := command.GetCommand(cmd)
 
 	if builtin.BuiltinCommand(com) {
-		return
+		return nil
 	}
 
-	com.Execute()
-
-}
-
-func readInput() (string, error) {
-	return reader.ReadString('\n')
+	return com.Execute()
 }

shell/shell.go

@@ -2,23 +2,30 @@ package shell
 
 import (
 	"bufio"
+	"fmt"
+	"io"
+	"os"
 
-	"github.com/cezarmathe/gosh/shell/prompt"
-)
-
-var (
-	shellPrompt prompt.Prompt
-	reader      *bufio.Reader
+	"github.com/cezarmathe/gosh/prompt"
 )
 
 // Run contains the entire shell lifecycle
 func Run() {
+	reader := bufio.NewReader(os.Stdin)
+	shellPrompt := prompt.New(":")
+	for {
+		fmt.Print(shellPrompt)
+		input, err := reader.ReadString('\n')
 
-	initialize()
-
-	defer terminate()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Fprintln(os.Stderr, err)
+		}
 
-	for {
-		interpret()
+		if err = interpret(input); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
 	}
 }