feat: support gno.mod

.github/workflows/unit-tests.yml

@@ -41,4 +41,6 @@ jobs:
           go-version: ${{ matrix.go-version }}
       - uses: actions/checkout@v3
       - name: test
-        run: make ${{ matrix.args }}
+        run: |
+          export GOPATH=$HOME/go
+          make ${{ matrix.args }}

cmd/gnodev/main.go

@@ -37,6 +37,12 @@ var mainApps AppList = []AppItem{
 		Desc:     "build a gno package",
 		Defaults: defaultBuildOptions,
 	},
+	{
+		App:      modApp,
+		Name:     "mod",
+		Desc:     "manage gno.mod",
+		Defaults: defaultModFlags,
+	},
 	{
 		App:      precompileApp,
 		Name:     "precompile",

cmd/gnodev/main_test.go

@@ -3,6 +3,8 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -12,7 +14,9 @@ import (
 
 func TestMain(t *testing.T) {
 	tc := []struct {
-		args []string
+		args                 []string
+		testDir              string
+		simulateExternalRepo bool
 
 		// for the following FooContain+FooBe expected couples, if both are empty,
 		// then the test suite will require that the "got" is not empty.
@@ -30,13 +34,15 @@ func TestMain(t *testing.T) {
 		{args: []string{"test"}, errShouldBe: "invalid args", stderrShouldBe: "Usage: test [test flags] [packages]\n"},
 		{args: []string{"build"}, errShouldBe: "invalid args", stderrShouldBe: "Usage: build [build flags] [packages]\n"},
 		{args: []string{"precompile"}, errShouldBe: "invalid args", stderrShouldBe: "Usage: precompile [precompile flags] [packages]\n"},
+		{args: []string{"mod"}, errShouldBe: "invalid command", stderrShouldBe: "Usage: mod [flags] <command>\n"},
 		// {args: []string{"repl"}},
 
 		// --help
 		{args: []string{"build", "--help"}, stdoutShouldContain: "# buildOptions options\n-"},
 		{args: []string{"test", "--help"}, stdoutShouldContain: "# testOptions options\n-"},
 		{args: []string{"precompile", "--help"}, stdoutShouldContain: "# precompileFlags options\n-"},
 		{args: []string{"repl", "--help"}, stdoutShouldContain: "# replOptions options\n-"},
+		{args: []string{"mod", "--help"}, stdoutShouldContain: "# modFlags options\n-"},
 
 		// custom
 		{args: []string{"test", "../../examples/gno.land/p/demo/rand"}, stderrShouldContain: "ok      ./../../examples/gno.land/p/demo/rand \t"},
@@ -85,16 +91,28 @@ func TestMain(t *testing.T) {
 		{args: []string{"test", "../../examples/gno.land/p/demo/ufmt", "--verbose", "--run", "Sprintf/hello"}, stderrShouldContain: "ok      ./../../examples/gno.land/p/demo/ufmt"},
 		{args: []string{"test", "../../examples/gno.land/p/demo/ufmt", "--verbose", "--timeout", "100000000000" /* 100s */}, stderrShouldContain: "ok      ./../../examples/gno.land/p/demo/ufmt"},
 		// {args: []string{"test", "../../examples/gno.land/p/demo/ufmt", "--verbose", "--timeout", "10000" /* 10µs */}, recoverShouldContain: "test timed out after"}, // FIXME: should be testable
+
+		// test gno.mod
+		{args: []string{"mod", "download"}, testDir: "../../tests/integ/empty-dir", simulateExternalRepo: true, errShouldBe: "mod download: gno.mod not found"},
+		{args: []string{"mod", "download"}, testDir: "../../tests/integ/empty-gnomod", simulateExternalRepo: true, errShouldBe: "mod download: validate: requires module"},
+		{args: []string{"mod", "download"}, testDir: "../../tests/integ/invalid-module-name", simulateExternalRepo: true, errShouldContain: "usage: module module/path"},
+		{args: []string{"mod", "download"}, testDir: "../../tests/integ/minimalist-gnomod", simulateExternalRepo: true},
+		{args: []string{"mod", "download"}, testDir: "../../tests/integ/require-remote-module", simulateExternalRepo: true},
+		{args: []string{"mod", "download"}, testDir: "../../tests/integ/require-invalid-module", simulateExternalRepo: true, errShouldContain: "mod download: fetch: writepackage: querychain:"},
 	}
 
+	workingDir, err := os.Getwd()
+	require.Nil(t, err)
+
 	for _, test := range tc {
 		errShouldBeEmpty := test.errShouldContain == "" && test.errShouldBe == ""
 		stdoutShouldBeEmpty := test.stdoutShouldContain == "" && test.stdoutShouldBe == ""
 		stderrShouldBeEmpty := test.stderrShouldContain == "" && test.stderrShouldBe == ""
 		recoverShouldBeEmpty := test.recoverShouldContain == "" && test.recoverShouldBe == ""
 
 		testName := strings.Join(test.args, " ")
-		testName = strings.ReplaceAll(testName, "/", "~")
+		testName = strings.ReplaceAll(testName+test.testDir, "/", "~")
+
 		t.Run(testName, func(t *testing.T) {
 			cmd := command.NewMockCommand()
 			mockOut := bytes.NewBufferString("")
@@ -152,6 +170,22 @@ func TestMain(t *testing.T) {
 					require.True(t, recoverShouldBeEmpty, "should not panic")
 				}
 			}()
+
+			if test.simulateExternalRepo {
+				// create external dir
+				tmpDir, cleanUpFn := createTmpDir(t)
+				defer cleanUpFn()
+
+				// copy to external dir
+				absTestDir, err := filepath.Abs(test.testDir)
+				require.Nil(t, err)
+				require.Nil(t, copyDir(absTestDir, tmpDir))
+
+				// cd to tmp directory
+				os.Chdir(tmpDir)
+				defer os.Chdir(workingDir)
+			}
+
 			err := runMain(cmd, exec, test.args)
 
 			if errShouldBeEmpty {

cmd/gnodev/mod.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gnolang/gno/pkgs/command"
+	"github.com/gnolang/gno/pkgs/errors"
+	"github.com/gnolang/gno/pkgs/gnolang/gnomod"
+)
+
+type modFlags struct {
+	Verbose bool `flag:"verbose" help:"verbose"`
+}
+
+var defaultModFlags = modFlags{
+	Verbose: false,
+}
+
+func modApp(cmd *command.Command, args []string, iopts interface{}) error {
+	opts := iopts.(modFlags)
+
+	if len(args) != 1 {
+		cmd.ErrPrintfln("Usage: mod [flags] <command>")
+		return errors.New("invalid command")
+	}
+
+	switch args[0] {
+	case "download":
+		if err := runModDownload(&opts); err != nil {
+			return fmt.Errorf("mod download: %w", err)
+		}
+	default:
+		return fmt.Errorf("invalid command: %s", args[0])
+	}
+
+	return nil
+}
+
+func runModDownload(opts *modFlags) error {
+	path, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	modPath := filepath.Join(path, "gno.mod")
+	if !isFileExist(modPath) {
+		return errors.New("gno.mod not found")
+	}
+
+	// read gno.mod
+	data, err := os.ReadFile(modPath)
+	if err != nil {
+		return fmt.Errorf("readfile %q: %w", modPath, err)
+	}
+
+	// parse gno.mod
+	gnoMod, err := gnomod.Parse(modPath, data)
+	if err != nil {
+		return fmt.Errorf("parse: %w", err)
+	}
+
+	// validate gno.mod
+	if err := gnoMod.Validate(); err != nil {
+		return fmt.Errorf("validate: %w", err)
+	}
+
+	// fetch dependencies
+	if err := gnoMod.FetchDeps(); err != nil {
+		return fmt.Errorf("fetch: %w", err)
+	}
+
+	if err := gnomod.Sanitize(gnoMod); err != nil {
+		return fmt.Errorf("sanitize: %w", err)
+	}
+
+	// write go.mod file
+	err = gnoMod.WriteToPath(path)
+	if err != nil {
+		return fmt.Errorf("write go.mod file: %w", err)
+	}
+
+	return nil
+}

cmd/gnodev/testutil.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"os"
+	"testing"
+)
+
+func createTmpDir(t *testing.T) (string, func()) {
+	t.Helper()
+
+	tmpDir, err := os.MkdirTemp("", "gno-mod-test")
+	if err != nil {
+		t.Error("Failed to create tmp dir for mod:", err)
+	}
+
+	cleanUpFn := func() {
+		err := os.RemoveAll(tmpDir)
+		if err != nil {
+			t.Logf("Failed to clean up test %s: %v", t.Name(), err)
+		}
+	}
+
+	return tmpDir, cleanUpFn
+}

cmd/gnodev/util.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"go/ast"
+	"io"
 	"io/fs"
 	"log"
 	"os"
@@ -19,6 +20,11 @@ func isGnoFile(f fs.DirEntry) bool {
 	return !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".gno") && !f.IsDir()
 }
 
+func isFileExist(absModPath string) bool {
+	_, err := os.Stat(absModPath)
+	return err == nil
+}
+
 func gnoFilesFromArgs(args []string) ([]string, error) {
 	paths := []string{}
 	for _, arg := range args {
@@ -159,3 +165,72 @@ func WriteDirFile(pathWithName string, data []byte) error {
 
 	return os.WriteFile(pathWithName, data, 0o644)
 }
+
+// copyDir copies the dir from src to dst, the paths have to be
+// absolute to ensure consistent behavior.
+func copyDir(src, dst string) error {
+	if !filepath.IsAbs(src) || !filepath.IsAbs(dst) {
+		return fmt.Errorf("src or dst path not abosulte, src: %s dst: %s", src, dst)
+	}
+
+	entries, err := os.ReadDir(src)
+	if err != nil {
+		return fmt.Errorf("cannot read dir: %s", src)
+	}
+
+	if err := os.MkdirAll(dst, 0755); err != nil {
+		return fmt.Errorf("failed to create directory: '%s', error: '%w'", dst, err)
+	}
+
+	for _, entry := range entries {
+		srcPath := filepath.Join(src, entry.Name())
+		dstPath := filepath.Join(dst, entry.Name())
+
+		if entry.Type().IsDir() {
+			copyDir(srcPath, dstPath)
+		} else if entry.Type().IsRegular() {
+			copyFile(srcPath, dstPath)
+		}
+	}
+
+	return nil
+}
+
+// copyFile copies the file from src to dst, the paths have
+// to be absolute to ensure consistent behavior.
+func copyFile(src, dst string) error {
+	if !filepath.IsAbs(src) || !filepath.IsAbs(dst) {
+		return fmt.Errorf("src or dst path not abosulte, src: %s dst: %s", src, dst)
+	}
+
+	// verify if it's regular flile
+	srcStat, err := os.Stat(src)
+	if err != nil {
+		return fmt.Errorf("cannot copy file: %w", err)
+	}
+	if !srcStat.Mode().IsRegular() {
+		return fmt.Errorf("%s not a regular file", src)
+	}
+
+	// create dst file
+	dstFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer dstFile.Close()
+
+	// open src file
+	srcFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+
+	// copy srcFile -> dstFile
+	_, err = io.Copy(dstFile, srcFile)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

pkgs/gnolang/gnomod/fetch.go

@@ -0,0 +1,26 @@
+package gnomod
+
+import (
+	"fmt"
+
+	abci "github.com/gnolang/gno/pkgs/bft/abci/types"
+	"github.com/gnolang/gno/pkgs/bft/rpc/client"
+)
+
+func queryChain(qpath string, data []byte) (res *abci.ResponseQuery, err error) {
+	opts2 := client.ABCIQueryOptions{
+		// Height: height, XXX
+		// Prove: false, XXX
+	}
+	cli := client.NewHTTP(remote, "/websocket")
+	qres, err := cli.ABCIQueryWithOptions(qpath, data, opts2)
+	if err != nil {
+		return nil, err
+	}
+	if qres.Response.Error != nil {
+		fmt.Printf("Log: %s\n", qres.Response.Log)
+		return nil, qres.Response.Error
+	}
+
+	return &qres.Response, nil
+}