feat(gnovm): Executable Markdown

gnovm/cmd/gno/doctest.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+
+	dt "github.com/gnolang/gno/gnovm/pkg/doctest"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+)
+
+type doctestCfg struct {
+	markdownPath string
+	// codeIndex    int
+	runPattern string
+}
+
+func newDoctestCmd(io commands.IO) *commands.Command {
+	cfg := &doctestCfg{}
+
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "doctest",
+			ShortUsage: "doctest -path <markdown_file_path> [-run <pattern>]",
+			ShortHelp:  "executes a specific code block from a markdown file",
+		},
+		cfg,
+		func(_ context.Context, args []string) error {
+			return execDoctest(cfg, args, io)
+		},
+	)
+}
+
+func (c *doctestCfg) RegisterFlags(fs *flag.FlagSet) {
+	fs.StringVar(
+		&c.markdownPath,
+		"path",
+		"",
+		"path to the markdown file",
+	)
+	fs.StringVar(
+		&c.runPattern,
+		"run",
+		"",
+		"pattern to match code block names",
+	)
+}
+
+func execDoctest(cfg *doctestCfg, _ []string, io commands.IO) error {
+	if cfg.markdownPath == "" {
+		return fmt.Errorf("markdown file path is required")
+	}
+
+	content, err := fetchMarkdown(cfg.markdownPath)
+	if err != nil {
+		return fmt.Errorf("failed to read markdown file: %w", err)
+	}
+
+	results, err := dt.ExecuteMatchingCodeBlock(content, cfg.runPattern)
+	if err != nil {
+		return fmt.Errorf("failed to execute code block: %w", err)
+	}
+
+	if len(results) == 0 {
+		io.Println("No code blocks matched the pattern")
+		return nil
+	}
+
+	io.Println("Execution Result:")
+	io.Println(strings.Join(results, "\n\n"))
+
+	return nil
+}
+
+// fetchMarkdown reads a markdown file and returns its content
+func fetchMarkdown(path string) (string, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file: %w", err)
+	}
+	return string(content), nil
+}

gnovm/cmd/gno/doctest_test.go

@@ -0,0 +1,105 @@
+package main
+
+// import (
+// 	"os"
+// 	"testing"
+// )
+
+// func TestDoctest(t *testing.T) {
+// 	tempDir, err := os.MkdirTemp("", "doctest-test")
+// 	if err != nil {
+// 		t.Fatalf("failed to create temp directory: %v", err)
+// 	}
+// 	defer os.RemoveAll(tempDir)
+
+// 	markdownContent := `# Go Code Examples
+
+// This document contains two simple examples written in Go.
+
+// ## Example 1: Fibonacci Sequence
+
+// The first example prints the first 10 numbers of the Fibonacci sequence.
+
+// ` + "```go" + `
+// // @test: Fibonacci
+// package main
+
+// func main() {
+//     a, b := 0, 1
+//     for i := 0; i < 10; i++ {
+//         println(a)
+//         a, b = b, a+b
+//     }
+// }
+// ` + "```" + `
+
+// ## Example 2: String Reversal
+
+// The second example reverses a given string and prints it.
+
+// ` + "```go" + `
+// // @test: StringReversal
+// package main
+
+// func main() {
+//     str := "Hello, Go!"
+//     runes := []rune(str)
+//     for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+//         runes[i], runes[j] = runes[j], runes[i]
+//     }
+//     println(string(runes))
+// }
+// ` + "```" + `
+
+// These two examples demonstrate basic Go functionality without using concurrency, generics, or reflect.
+
+// ` + "## std Package" + `
+// ` + "```go" + `
+// // @test: StdPackage
+// package main
+
+// import (
+// 	"std"
+// )
+
+// func main() {
+//     addr := std.GetOrigCaller()
+//     println(addr)
+// }
+// ` + "```" + `
+// `
+
+// 	mdFile, err := os.CreateTemp(tempDir, "sample-*.md")
+// 	if err != nil {
+// 		t.Fatalf("failed to create temp file: %v", err)
+// 	}
+// 	defer mdFile.Close()
+
+// 	_, err = mdFile.WriteString(markdownContent)
+// 	if err != nil {
+// 		t.Fatalf("failed to write to temp file: %v", err)
+// 	}
+
+// 	mdFilePath := mdFile.Name()
+
+// 	tc := []testMainCase{
+// 		{
+// 			args:        []string{"doctest", "-h"},
+// 			errShouldBe: "flag: help requested",
+// 		},
+// 		{
+// 			args:                []string{"doctest", "-path", mdFilePath, "-run", "Fibonacci"},
+// 			stdoutShouldContain: "--- Fibonacci ---\n0\n1\n1\n2\n3\n5\n8\n13\n21\n34\n",
+// 		},
+// 		{
+// 			args:                []string{"doctest", "-path", mdFilePath, "-run", "StringReversal"},
+// 			stdoutShouldContain: "--- StringReversal ---\n!oG ,olleH\n",
+// 		},
+// 		{
+// 			args:                []string{"doctest", "-path", mdFilePath, "-run", "StdPackage"},
+// 			stdoutShouldContain: "--- StdPackage ---\ng14ch5q26mhx3jk5cxl88t278nper264ces4m8nt\n",
+// 		},
+// 	}
+
+// 	testMainCaseRun(t, tc)
+// }

gnovm/cmd/gno/main.go

@@ -34,6 +34,7 @@ func newGnocliCmd(io commands.IO) *commands.Command {
 		newDocCmd(io),
 		newEnvCmd(io),
 		newBugCmd(io),
+		newDoctestCmd(io),
 		newFmtCmd(io),
 		// graph
 		// vendor -- download deps from the chain in vendor/

gnovm/cmd/gno/testdata/doctest/1.md

@@ -0,0 +1,87 @@
+# Gno Doctest: Easy Code Execution and Testing
+
+Gno Doctest is a tool that allows you to easily execute and test code blocks written in the Gno language. This tool offers a range of features, from simple code execution to complex package imports.
+
+## 1. Basic Code Execution
+
+Even the simplest form of code block can be easily executed.
+
+```go
+package main
+
+func main() {
+    println("Hello, World!")
+}
+```
+
+Doctest also recognizes that a block of code is a gno. The code below outputs the same result as the example above.
+
+```go
+package main
+
+func main() {
+    println("Hello, World!")
+}
+```
+
+Running this code will output "Hello, World!".
+
+## 2. Using Standard Library Packages
+
+Gno Doctest automatically recognizes and imports standard library packages.
+
+```go
+package main
+
+import "std"
+
+func main() {
+    addr := std.GetOrigCaller()
+    println(addr)
+}
+```
+
+## 3. Utilizing Various Standard Libraries
+
+You can use multiple standard libraries simultaneously.
+
+```gno
+package main
+
+import "strings"
+
+func main() {
+    println(strings.ToUpper("Hello, World"))
+}
+```
+
+This example uses the ToUpper() function from the strings package to convert a string to uppercase.
+
+## 4. Automatic Package Import
+
+One of the most powerful features of Gno Doctest is its ability to handle package declarations and imports automatically.
+
+```go
+func main() {
+    println(math.Pi)
+    println(strings.ToUpper("Hello, World"))
+}
+```
+
+In this code, the math and strings packages are not explicitly imported, but Doctest automatically recognizes and imports the necessary packages.
+
+## 5. Omitting Package Declaration
+
+Doctest can even handle cases where the package main declaration is omitted.
+
+```go
+func main() {
+    s := strings.ToUpper("Hello, World")
+    println(s)
+}
+```
+
+This code runs normally without package declaration or import statements.
+Using Gno Doctest makes code execution and testing much more convenient.
+
+You can quickly run various Gno code snippets and check the results without complex setups.