feat(gnovm): Add Basic Code Indentation in REPL

gnovm/cmd/gno/repl.go

@@ -8,13 +8,28 @@
  "fmt"
  "go/scanner"
  "os"
+ "os/exec"
+ "runtime"
  "strings"
 
  "github.com/gnolang/gno/gnovm/pkg/gnoenv"
  "github.com/gnolang/gno/gnovm/pkg/repl"
  "github.com/gnolang/gno/tm2/pkg/commands"
 )
 
+const indentSize = 4
+
+const (
+ srcCommand = "/src"
+ editorCommand = "/editor"
+ resetCommand = "/reset"
+ exitCommand = "/exit"
+ clearCommand = "/clear"
+ helpCommand = "/help"
+ gnoREPL = "gno> "
+ inEditMode = "... "
+)
+
 type replCfg struct {
  verbose bool
  rootDir string
@@ -86,15 +101,7 @@
  }
 
  if !cfg.skipUsage {
- fmt.Fprint(os.Stderr, `// Usage:
-// gno> import "gno.land/p/demo/avl" // import the p/demo/avl package
-// gno> func a() string { return "a" } // declare a new function named a
-// gno> /src // print current generated source
-// gno> /editor // enter in multi-line mode, end with ';'
-// gno> /reset // remove all previously inserted code
-// gno> println(a()) // print the result of calling a()
-// gno> /exit // alternative to <Ctrl-D>
-`)
+ printHelp()
  }
 
  return runRepl(cfg)
@@ -107,68 +114,176 @@
  handleInput(r, cfg.initialCommand)
  }
 
- fmt.Fprint(os.Stdout, "gno> ")
+ fmt.Fprint(os.Stdout, gnoREPL)
+
+ var (
+ inEdit bool
+ prev string
+ indentLevel int
+ )
 
- inEdit := false
- prev := ""
  liner := bufio.NewScanner(os.Stdin)
 
  for liner.Scan() {
  line := liner.Text()
 
- if l := strings.TrimSpace(line); l == ";" {
- line, inEdit = "", false
- } else if l == "/editor" {
- line, inEdit = "", true
- fmt.Fprintln(os.Stdout, "// enter a single ';' to quit and commit")
- }
+ trimmedLine := strings.TrimSpace(line)
+
+ indentLevel = updateIndentLevel(trimmedLine, indentLevel)
+ line, inEdit = handleEditor(line)
+
  if prev != "" {
  line = prev + "\n" + line
  prev = ""
  }
+
  if inEdit {
- fmt.Fprint(os.Stdout, "... ")
+ fmt.Fprint(os.Stdout, inEditMode)
  prev = line
+
  continue
  }
 
  if err := handleInput(r, line); err != nil {
  var goScanError scanner.ErrorList
  if errors.As(err, &goScanError) {
- // We assune that a Go scanner error indicates an incomplete Go statement.
+ // We assume that a Go scanner error indicates an incomplete Go statement.
  // Append next line and retry.
  prev = line
  } else {
  fmt.Fprintln(os.Stderr, err)
  }
  }
 
- if prev == "" {
- fmt.Fprint(os.Stdout, "gno> ")
- } else {
- fmt.Fprint(os.Stdout, "... ")
- }
+ printPrompt(indentLevel, prev)
  }
+
  return nil
 }
 
+func handleEditor(line string) (string, bool) {
+ if l := strings.TrimSpace(line); l == ";" {
+ return "", false
+ } else if l == editorCommand {
+ fmt.Fprintln(os.Stdout, "// enter a single ';' to quit and commit")
+
+ return "", true
+ }
+
+ return line, false
+}
+
+func updateIndentLevel(line string, indentLevel int) int {
+ openCount, closeCount := 0, 0
+ increaseIndent := false
+
+ for i, char := range line {
+ switch char {
+ case '{', '(', '[':
+ openCount++
+
+ if i < len(line)-1 && line[i+1] == '\n' {
+ increaseIndent = true
+ }
+ case '}', ')', ']':
+ closeCount++
+ }
+ }
+
+ indentLevel += openCount - closeCount
+ if indentLevel < 0 {
+ indentLevel = 0
+ }
+
+ if increaseIndent {
+ indentLevel++
+ }
+
+ if strings.HasSuffix(line, ":") {
+ indentLevel++
+ }
+
+ return indentLevel
+}
+
+func printPrompt(indentLevel int, prev string) {
+ if prev == "" {
+ fmt.Fprintf(os.Stdout, "gno> %s", strings.Repeat(" ", indentLevel*indentSize))
+ } else {
+ fmt.Fprintf(os.Stdout, "... %s", strings.Repeat(" ", indentLevel*indentSize))
+ }
+}
+
 // handleInput executes specific "/" commands, or evaluates input as Gno source code.
 func handleInput(r *repl.Repl, input string) error {
- switch strings.TrimSpace(input) {
- case "/reset":
+ input = strings.TrimSpace(input)
+ switch input {
+ case resetCommand:
  r.Reset()
- case "/src":
+ case srcCommand:
  fmt.Fprintln(os.Stdout, r.Src())
- case "/exit":
+ case clearCommand:
+ clearScreen(&RealCommandExecutor{}, RealOSGetter{})
+ case exitCommand:
  os.Exit(0)
+ case helpCommand:
+ printHelp()
  case "":
  // Avoid to increase the repl execution counter if no input.
  default:
  out, err := r.Process(input)
  if err != nil {
  return err
  }
+
  fmt.Fprintln(os.Stdout, out)
  }
+
  return nil
 }
+
+type CommandExecutor interface {
+ Execute(cmd *exec.Cmd) error
+}
+
+type RealCommandExecutor struct{}
+
+func (e *RealCommandExecutor) Execute(cmd *exec.Cmd) error {
+ cmd.Stdout = os.Stdout
+ return cmd.Run()
+}
+
+type OsGetter interface {
+ Get() string
+}
+
+type RealOSGetter struct{}
+
+func (r RealOSGetter) Get() string {
+ return runtime.GOOS
+}
+
+func clearScreen(executor CommandExecutor, osGetter OsGetter) {
+ var cmd *exec.Cmd
+
+ if osGetter.Get() == "windows" {
+ cmd = exec.Command("cmd", "/c", "cls")
+ } else {
+ cmd = exec.Command("clear")
+ }
+
+ executor.Execute(cmd)
+}
+
+func printHelp() {
+ fmt.Fprint(os.Stderr, `// Usage:
+// gno> import "gno.land/p/demo/avl" // import the p/demo/avl package
+// gno> func a() string { return "a" } // declare a new function named a
+// gno> /src // print current generated source
+// gno> /editor // enter in multi-line mode, end with ';'
+// gno> /reset // remove all previously inserted code
+// gno> println(a()) // print the result of calling a()
+// gno> /exit // alternative to <Ctrl-D>
+
+`)
+}

gnovm/cmd/gno/repl_test.go

@@ -1,6 +1,10 @@
 package main
 
-import "testing"
+import (
+ "os/exec"
+ "reflect"
+ "testing"
+)
 
 func TestReplApp(t *testing.T) {
  tc := []testMainCase{
@@ -11,3 +15,127 @@ func TestReplApp(t *testing.T) {
  }
  testMainCaseRun(t, tc)
 }
+
+func TestUpdateIndentLevel(t *testing.T) {
+ tests := []struct {
+ name string
+ line string
+ indentLevel int
+ want int
+ }{
+ {
+ name: "Test with no brackets",
+ line: "Hello, World!",
+ indentLevel: 0,
+ want: 0,
+ },
+ {
+ name: "Test with open brackets",
+ line: "func main() {",
+ indentLevel: 0,
+ want: 1,
+ },
+ {
+ name: "Test with closed brackets",
+ line: "}",
+ indentLevel: 1,
+ want: 0,
+ },
+ {
+ name: "Test with colon",
+ line: "case 'a':",
+ indentLevel: 0,
+ want: 1,
+ },
+ {
+ name: "Test with multiple open brackets",
+ line: "func main() { if true {",
+ indentLevel: 0,
+ want: 2,
+ },
+ {
+ name: "Test with multiple closed brackets",
+ line: "} }",
+ indentLevel: 2,
+ want: 0,
+ },
+ {
+ name: "Test with mixed brackets",
+ line: "} else {",
+ indentLevel: 1,
+ want: 1,
+ },
+ {
+ name: "Test with no change in indent level",
+ line: "fmt.Println(\"Hello, World!\")",
+ indentLevel: 1,
+ want: 1,
+ },
+ {
+ name: "Test with colon and open bracket",
+ line: "case 'a': {",
+ indentLevel: 0,
+ want: 1,
+ },
+ {
+ name: "Test with colon and closed bracket",
+ line: "case 'a': }",
+ indentLevel: 1,
+ want: 0,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := updateIndentLevel(tt.line, tt.indentLevel); got != tt.want {
+ t.Errorf("updateIndentLevel() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+type MockCommandExecutor struct {
+ ExecutedCommand *exec.Cmd
+}
+
+func (e *MockCommandExecutor) Execute(cmd *exec.Cmd) error {
+ e.ExecutedCommand = cmd
+ return nil
+}
+
+type MockOSGetter struct {
+ OS string
+}
+
+func (m MockOSGetter) Get() string {
+ return m.OS
+}
+
+func TestClearScreen(t *testing.T) {
+ tests := []struct {
+ name string
+ osGetter OsGetter
+ expected []string
+ }{
+ {"Windows", MockOSGetter{OS: "windows"}, []string{"cmd", "/c", "cls"}},
+ {"Other", MockOSGetter{OS: "linux"}, []string{"clear"}},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ // Set up the mock executor
+ executor := &MockCommandExecutor{}
+
+ // Call the function under test with the mock OS getter
+ clearScreen(executor, tt.osGetter)
+
+ // Check that the correct command was executed
+ if executor.ExecutedCommand == nil {
+ t.Fatal("Expected a command to be executed, but it was not")
+ }
+ if !reflect.DeepEqual(executor.ExecutedCommand.Args, tt.expected) {
+ t.Errorf("Expected command %v, but got %v", tt.expected, executor.ExecutedCommand.Args)
+ }
+ })
+ }
+}