feat(gnovm): Executable Markdown

gnovm/cmd/gno/doctest.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	dt "github.com/gnolang/gno/gnovm/pkg/doctest"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+)
+
+type doctestCfg struct {
+	markdownPath string
+	runPattern   string
+	timeout      time.Duration
+}
+
+func newDoctestCmd(io commands.IO) *commands.Command {
+	cfg := &doctestCfg{}
+
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "doctest",
+			ShortUsage: "doctest -path <markdown_file_path> [-run <pattern>] [-timeout <duration>]",
+			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",
+	)
+	fs.DurationVar(
+		&c.timeout,
+		"timeout",
+		time.Second*30,
+		"timeout for code execution (e.g., 30s, 1m)",
+	)
+}
+
+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)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cfg.timeout)
+	defer cancel()
+
+	resultChan := make(chan []string)
+	errChan := make(chan error)
+
+	go func() {
+		results, err := dt.ExecuteMatchingCodeBlock(ctx, content, cfg.runPattern)
+		if err != nil {
+			errChan <- err
+		} else {
+			resultChan <- results
+		}
+	}()
+
+	select {
+	case results := <-resultChan:
+		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"))
+	case err := <-errChan:
+		return fmt.Errorf("failed to execute code block: %w", err)
+	case <-ctx.Done():
+		return fmt.Errorf("execution timed out after %v", cfg.timeout)
+	}
+
+	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,97 @@
+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", "-path", mdFilePath, "-run", "StringReversal"},
+			stdoutShouldContain: "=== StringReversal ===\n\n!oG ,olleH",
+		},
+		{
+			args:                []string{"doctest", "-path", mdFilePath, "-run", "StdPackage"},
+			stdoutShouldContain: "=== StdPackage ===\n\ng14ch5q26mhx3jk5cxl88t278nper264ces4m8nt",
+		},
+	}
+
+	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/pkg/doctest/README.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.
+
+## Basic Usage
+
+To use Gno Doctest, run the following command:
+
+gno doctest -path <markdown_file_path> -run <code_block_name | "">
+
+- `<markdown_file_path>`: Path to the markdown file containing Gno code blocks
+- `<code_block_name>`: Name of the code block to run (optional)
+
+For example, to run the code block named "print hello world" in the file "foo.md", use the following command:
+
+gno doctest -path foo.md -run "print hello world"
+
+## Features
+
+### 1. Basic Code Execution
+
+Gno Doctest can execute simple code blocks:
+
+```go
+package main
+
+func main() {
+    println("Hello, World!")
+}
+
+// Output:
+// 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
+// @test: print hello world
+package main
+
+func main() {
+    println("Hello, World!")
+}
+
+// Output:
+// Hello, World!
+```
+
+Running this code will output "Hello, World!".
+
+### 3. Execution Options
+
+Doctest supports special execution options:
+Ignore Option
+Use the ignore tag to skip execution of a code block:
+
+**Ignore Option**
+
+Use the ignore tag to skip execution of a code block:
+
+```go,ignore
+// @ignore
+package main
+
+func main() {
+    println("This won't be executed")
+}
+```
+
+## Conclusion
+
+Gno Doctest simplifies the process of executing and testing Gno code snippets.
+
+```go
+// @test: slice
+package main
+
+type ints []int
+
+func main() {
+    a := ints{1,2,3}
+    println(a)
+}
+
+// Output:
+// (slice[(1 int),(2 int),(3 int)] gno.land/r/g14ch5q26mhx3jk5cxl88t278nper264ces4m8nt/run.ints)
+```

gnovm/pkg/doctest/cache.go

@@ -0,0 +1,51 @@
+package doctest
+
+import (
+	"container/list"
+)
+
+const maxCacheSize = 25
+
+type cacheItem struct {
+	key   string
+	value string
+}
+
+type lruCache struct {
+	capacity int
+	items    map[string]*list.Element
+	order    *list.List
+}
+
+func newCache(capacity int) *lruCache {
+	return &lruCache{
+		capacity: capacity,
+		items:    make(map[string]*list.Element),
+		order:    list.New(),
+	}
+}
+
+func (c *lruCache) get(key string) (string, bool) {
+	if elem, ok := c.items[key]; ok {
+		c.order.MoveToFront(elem)
+		return elem.Value.(cacheItem).value, true
+	}
+	return "", false
+}
+
+func (c *lruCache) set(key, value string) {
+	if elem, ok := c.items[key]; ok {
+		c.order.MoveToFront(elem)
+		elem.Value = cacheItem{key, value}
+	} else {
+		if c.order.Len() >= c.capacity {
+			oldest := c.order.Back()
+			if oldest != nil {
+				delete(c.items, oldest.Value.(cacheItem).key)
+				c.order.Remove(oldest)
+			}
+		}
+		elem := c.order.PushFront(cacheItem{key, value})
+		c.items[key] = elem
+	}
+}