feat(gnoweb): add hyperlinks to import p/*and r/* in source code viewer

gno.land/pkg/gnoweb/webclient_html.go

@@ -1,11 +1,13 @@
 package gnoweb
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"io"
 	"log/slog"
 	gopath "path"
+	"regexp"
 	"strings"
 
 	"github.com/alecthomas/chroma/v2"
@@ -252,6 +254,8 @@
 func (s *HTMLWebClient) FormatSource(w io.Writer, fileName string, src []byte) error {
 	var lexer chroma.Lexer
 
+	const gnolandPrefix = "gno.land/"
+
 	// Determine the lexer to be used based on the file extension.
 	switch strings.ToLower(gopath.Ext(fileName)) {
 	case ".gno":
@@ -268,16 +272,40 @@
 		return fmt.Errorf("unsupported lexer for file %q", fileName)
 	}
 
+	// Format with Chroma
+	var buf bytes.Buffer
 	iterator, err := lexer.Tokenise(nil, string(src))
 	if err != nil {
 		return fmt.Errorf("unable to tokenise %q: %w", fileName, err)
 	}
 
-	if err := s.Formatter.Format(w, s.chromaStyle, iterator); err != nil {
+	if err := s.Formatter.Format(&buf, s.chromaStyle, iterator); err != nil {
 		return fmt.Errorf("unable to format source file %q: %w", fileName, err)
 	}
 
-	return nil
+	formatted := buf.String()
+
+	// Process .gno files to add links
+	if strings.HasSuffix(fileName, ".gno") {
+		pattern := `(<span class="chroma-s">&#34;)(gno\.land/[^&#34;]+)(&#34;</span>)`
+		re := regexp.MustCompile(pattern)
+
+		formatted = re.ReplaceAllStringFunc(formatted, func(match string) string {
+			submatch := re.FindStringSubmatch(match)
+			if len(submatch) < 4 {
+				return match
+			}
+
+			importPath := submatch[2]
+			urlPath := strings.TrimPrefix(importPath, gnolandPrefix)
+
+			return fmt.Sprintf(`<span class="chroma-s"><a href="/%s$source" class="hover:underline">&#34;%s&#34;</a></span>`,
+				urlPath, importPath)
+		})
+	}
+
+	_, err = w.Write([]byte(formatted))
+	return err
 }
 
 func (s *HTMLWebClient) WriteFormatterCSS(w io.Writer) error {

gno.land/pkg/gnoweb/webclient_html_test.go

@@ -0,0 +1,109 @@
+package gnoweb
+
+import (
+	"bytes"
+	"fmt"
+	"log/slog"
+	"testing"
+
+	chromahtml "github.com/alecthomas/chroma/v2/formatters/html"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFormatSource(t *testing.T) {
+	// Setup test client with a no-op logger
+	logger := slog.New(slog.NewTextHandler(bytes.NewBuffer(nil), nil))
+
+	cfg := &HTMLWebClientConfig{
+		Domain:      "gno.land",
+		ChromaStyle: chromaDefaultStyle,
+		ChromaHTMLOptions: []chromahtml.Option{
+			chromahtml.WithClasses(true),
+			chromahtml.ClassPrefix("chroma-"),
+		},
+	}
+	client := NewHTMLClient(logger, cfg)
+
+	cases := []struct {
+		name          string
+		fileName      string
+		input         string
+		expectedPaths []string
+		linkable      bool
+	}{
+		{
+			name:          "single import",
+			fileName:      "test.gno",
+			input:         `import "gno.land/a/b/abc"`,
+			expectedPaths: []string{"a/b/abc"},
+			linkable:      true,
+		},
+		{
+			name:     "multiple imports",
+			fileName: "test.gno",
+			input: `import (
+				"gno.land/a/b/abc"
+				"gno.land/d/e/def"
+			)`,
+			expectedPaths: []string{"a/b/abc", "d/e/def"},
+			linkable:      true,
+		},
+		{
+			name:          "named import",
+			fileName:      "test.gno",
+			input:         `import name "gno.land/x/y/xyz"`,
+			expectedPaths: []string{"x/y/xyz"},
+			linkable:      true,
+		},
+		{
+			name:          "empty name import",
+			fileName:      "test.gno",
+			input:         `import _ "gno.land/a/b/abc"`,
+			expectedPaths: []string{"a/b/abc"},
+			linkable:      true,
+		},
+		{
+			name:     "multiple imports with name and empty name",
+			fileName: "test.gno",
+			input: `import (
+				name "gno.land/x/y/xyz"
+				_ "gno.land/a/b/abc"
+			)`,
+			expectedPaths: []string{"x/y/xyz", "a/b/abc"},
+			linkable:      true,
+		},
+		{
+			name:          "non gno file",
+			fileName:      "test.go",
+			input:         `import "gno.land/a/b/abc"`,
+			expectedPaths: []string{},
+			linkable:      false,
+		},
+	}
+
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			err := client.FormatSource(&buf, tt.fileName, []byte(tt.input))
+			assert.NoError(t, err)
+
+			result := buf.String()
+
+			if tt.linkable {
+				// Check each expected path has a corresponding link
+				for _, path := range tt.expectedPaths {
+					expectedLink := fmt.Sprintf(`<a href="/%s$source"`, path)
+					assert.Contains(t, result, expectedLink,
+						"Should contain link to source for path %s", path)
+					assert.Contains(t, result, `class="hover:underline"`)
+				}
+			} else {
+				assert.NotContains(t, result, `<a href=`,
+					"Should not contain any links")
+			}
+
+			// Check syntax highlighting is present
+			assert.Contains(t, result, `<span class="chroma-`)
+		})
+	}
+}