feat: add 'gno env' subcommand

gno.land/cmd/gnokey/main.go

@@ -5,12 +5,21 @@
 	"fmt"
 	"os"
 
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys/client"
 )
 
 func main() {
-	cmd := client.NewRootCmd(commands.NewDefaultIO())
+	baseCfg := client.BaseOptions{
+		Home:                  gnoenv.HomeDir(),
+		Remote:                "127.0.0.1:26657",
+		Quiet:                 false,
+		InsecurePasswordStdin: false,
+		Config:                "",
+	}
+
+	cmd := client.NewRootCmdWithBaseConfig(commands.NewDefaultIO(), baseCfg)
 
 	if err := cmd.ParseAndRun(context.Background(), os.Args[1:]); err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "%+v\n", err)

gno.land/cmd/gnoland/start.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/gnolang/gno/gno.land/pkg/gnoland"
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
 	"github.com/gnolang/gno/tm2/pkg/bft/config"
 	"github.com/gnolang/gno/tm2/pkg/bft/node"
@@ -59,7 +60,7 @@ func newStartCmd(io *commands.IO) *commands.Command {
 }
 
 func (c *startCfg) RegisterFlags(fs *flag.FlagSet) {
-	gnoroot := gnoland.MustGuessGnoRootDir()
+	gnoroot := gnoenv.MustGuessGnoRootDir()
 	defaultGenesisBalancesFile := filepath.Join(gnoroot, "gno.land", "genesis", "genesis_balances.txt")
 	defaultGenesisTxsFile := filepath.Join(gnoroot, "gno.land", "genesis", "genesis_txs.txt")
 

gno.land/cmd/gnoweb/main_test.go

@@ -7,8 +7,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	"github.com/gnolang/gno/gno.land/pkg/integration"
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	"github.com/gnolang/gno/tm2/pkg/log"
 	"github.com/gotuna/gotuna/test/assert"
 )
@@ -44,7 +44,7 @@ func TestRoutes(t *testing.T) {
 		{"/404-not-found", notFound, "/404-not-found"},
 	}
 
-	config, _ := integration.TestingNodeConfig(t, gnoland.MustGuessGnoRootDir())
+	config, _ := integration.TestingNodeConfig(t, gnoenv.MustGuessGnoRootDir())
 	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNopLogger(), config)
 	defer node.Stop()
 
@@ -92,7 +92,7 @@ func TestAnalytics(t *testing.T) {
 		"/404-not-found",
 	}
 
-	config, _ := integration.TestingNodeConfig(t, gnoland.MustGuessGnoRootDir())
+	config, _ := integration.TestingNodeConfig(t, gnoenv.MustGuessGnoRootDir())
 	node, remoteAddr := integration.TestingInMemoryNode(t, log.NewNopLogger(), config)
 	defer node.Stop()
 

gno.land/pkg/gnoland/app.go

@@ -1,15 +1,12 @@
 package gnoland
 
 import (
-	"errors"
 	"fmt"
-	"os"
-	"os/exec"
 	"path/filepath"
-	"runtime"
 	"strings"
 
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	"github.com/gnolang/gno/tm2/pkg/amino"
 	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
 	"github.com/gnolang/gno/tm2/pkg/crypto"
@@ -38,7 +35,7 @@
 	return &AppOptions{
 		Logger:     log.NewNopLogger(),
 		DB:         dbm.NewMemDB(),
-		GnoRootDir: MustGuessGnoRootDir(),
+		GnoRootDir: gnoenv.MustGuessGnoRootDir(),
 	}
 }
 
@@ -197,45 +194,3 @@
 		return abci.ResponseEndBlock{}
 	}
 }
-
-// XXX: all the method bellow should be removed in favor of
-// https://github.com/gnolang/gno/pull/1233
-func MustGuessGnoRootDir() string {
-	root, err := GuessGnoRootDir()
-	if err != nil {
-		panic(err)
-	}
-
-	return root
-}
-
-func GuessGnoRootDir() (string, error) {
-	// First try to get the root directory from the GNOROOT environment variable.
-	if rootdir := os.Getenv("GNOROOT"); rootdir != "" {
-		return filepath.Clean(rootdir), nil
-	}
-
-	// Try to guess GNOROOT using the nearest go.mod.
-	if gobin, err := exec.LookPath("go"); err == nil {
-		// If GNOROOT is not set, try to guess the root directory using the `go list` command.
-		cmd := exec.Command(gobin, "list", "-m", "-mod=mod", "-f", "{{.Dir}}", "github.com/gnolang/gno")
-		out, err := cmd.CombinedOutput()
-		if err == nil {
-			return strings.TrimSpace(string(out)), nil
-		}
-	}
-
-	// Try to guess GNOROOT using caller stack.
-	if _, filename, _, ok := runtime.Caller(1); ok && filepath.IsAbs(filename) {
-		if currentDir := filepath.Dir(filename); currentDir != "" {
-			// Gno root directory relative from `app.go` path:
-			// gno/ .. /gno.land/ .. /pkg/ .. /gnoland/app.go
-			rootdir, err := filepath.Abs(filepath.Join(currentDir, "..", "..", ".."))
-			if err == nil {
-				return rootdir, nil
-			}
-		}
-	}
-
-	return "", errors.New("unable to guess gno's root-directory")
-}

gno.land/pkg/integration/testing_integration.go

@@ -11,7 +11,7 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/gnolang/gno/gno.land/pkg/gnoland"
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	"github.com/gnolang/gno/tm2/pkg/bft/node"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
@@ -41,7 +41,7 @@ func SetupGnolandTestScript(t *testing.T, txtarDir string) testscript.Params {
 
 	// `gnoRootDir` should point to the local location of the gno repository.
 	// It serves as the gno equivalent of GOROOT.
-	gnoRootDir := gnoland.MustGuessGnoRootDir()
+	gnoRootDir := gnoenv.MustGuessGnoRootDir()
 
 	// `gnoHomeDir` should be the local directory where gnokey stores keys.
 	gnoHomeDir := filepath.Join(tmpdir, "gno")

gnovm/Makefile

@@ -1,17 +1,22 @@
+GNOROOT_DIR ?= $(abspath $(lastword $(MAKEFILE_LIST))/../../)
+
 .PHONY: help
 help:
 	@echo "Available make commands:"
 	@cat Makefile | grep '^[a-z][^:]*:' | cut -d: -f1 | sort | sed 's/^/  /'
 
 rundep=go run -modfile ../misc/devdeps/go.mod
 
+# We can't use '-trimpath' yet as amino use absolute path from call stack
+# to find some directory: see #1236
+GOBUILD_FLAGS := -ldflags "-X github.com/gnolang/gno/gnovm/pkg/gnoenv._GNOROOT=$(GNOROOT_DIR)"
 .PHONY: build
 build:
-	go build -o build/gno ./cmd/gno
+	go build $(GOBUILD_FLAGS) -o build/gno ./cmd/gno
 
 .PHONY: install
 install:
-	go install ./cmd/gno
+	go install $(GOBUILD_FLAGS) ./cmd/gno
 
 .PHONY: clean
 clean:

gnovm/cmd/gno/clean.go

@@ -9,9 +9,9 @@
 	"path/filepath"
 	"strings"
 
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	"github.com/gnolang/gno/gnovm/pkg/gnomod"
 	"github.com/gnolang/gno/tm2/pkg/commands"
-	"github.com/gnolang/gno/tm2/pkg/crypto/keys/client"
 )
 
 type cleanCfg struct {
@@ -82,7 +82,7 @@
 	}
 
 	if cfg.modCache {
-		modCacheDir := filepath.Join(client.HomeDir(), "pkg", "mod")
+		modCacheDir := filepath.Join(gnoenv.HomeDir(), "pkg", "mod")
 		if !cfg.dryRun {
 			if err := os.RemoveAll(modCacheDir); err != nil {
 				return err

gnovm/cmd/gno/doc.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 
 	"github.com/gnolang/gno/gnovm/pkg/doc"
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
 	"github.com/gnolang/gno/gnovm/pkg/gnomod"
 	"github.com/gnolang/gno/tm2/pkg/commands"
 )
@@ -77,7 +78,7 @@ func (c *docCfg) RegisterFlags(fs *flag.FlagSet) {
 func execDoc(cfg *docCfg, args []string, io *commands.IO) error {
 	// guess opts.RootDir
 	if cfg.rootDir == "" {
-		cfg.rootDir = guessRootDir()
+		cfg.rootDir = gnoenv.MustGuessGnoRootDir()
 	}
 
 	wd, err := os.Getwd()

gnovm/cmd/gno/env.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"context"
+	"flag"
+
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+)
+
+type envCfg struct {
+	json bool
+}
+
+func newEnvCmd(io *commands.IO) *commands.Command {
+	c := &envCfg{}
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "env",
+			ShortUsage: "env [flags] <pkgsym>",
+			ShortHelp:  "`env` prints Gno environment information",
+		},
+		c,
+		func(_ context.Context, args []string) error {
+			return execEnv(c, args, io)
+		},
+	)
+}
+
+func (c *envCfg) RegisterFlags(fs *flag.FlagSet) {
+	fs.BoolVar(
+		&c.json,
+		"json",
+		false,
+		"Prints the environment in JSON format instead of as a shell script.",
+	)
+}
+
+type envVar struct {
+	Key   string
+	Value string
+}
+
+func getEnvVar(vars []envVar, key string) string {
+	for _, env := range vars {
+		if env.Key == key {
+			return env.Value
+		}
+	}
+	return ""
+}
+
+func findEnv(env []envVar, name string) string {
+	for _, e := range env {
+		if e.Key == name {
+			return e.Value
+		}
+	}
+	return ""
+}
+
+type envPrinter func(vars []envVar, io *commands.IO)
+
+func execEnv(cfg *envCfg, args []string, io *commands.IO) error {
+	envs := []envVar{
+		// GNOROOT Should point to the local location of the GNO repository.
+		// It serves as the gno equivalent of `GOROOT`.
+		{Key: "GNOROOT", Value: gnoenv.MustGuessGnoRootDir()},
+		// GNOHOME Should point to the user local configuration.
+		// The most common place for this should be $HOME/gno.
+		{Key: "GNOHOME", Value: gnoenv.HomeDir()},
+	}
+
+	// Setup filters
+	filters := make([]envVar, len(args))
+	for i, arg := range args {
+		filters[i] = envVar{Key: arg, Value: findEnv(envs, arg)}
+	}
+
+	// Setup printer
+	var printerEnv envPrinter
+	if cfg.json {
+		printerEnv = printJSON
+	} else {
+		printerEnv = getPrinterShell(len(args) == 0)
+	}
+
+	// Print environements
+	if len(filters) > 0 {
+		printerEnv(filters, io)
+	} else {
+		printerEnv(envs, io)
+	}
+
+	return nil
+}
+
+func getPrinterShell(printkeys bool) envPrinter {
+	return func(vars []envVar, io *commands.IO) {
+		for _, env := range vars {
+			if printkeys {
+				io.Printf("%s=%q\n", env.Key, env.Value)
+			} else {
+				io.Printf("%s\n", env.Value)
+			}
+		}
+	}
+}
+
+func printJSON(vars []envVar, io *commands.IO) {
+	io.Println("{")
+	for i, env := range vars {
+		io.Printf("\t%q: %q", env.Key, env.Value)
+		if i != len(vars)-1 {
+			io.Printf(",")
+		}
+
+		// Jump to next line
+		io.Printf("\n")
+	}
+	io.Println("}")
+}

gnovm/cmd/gno/env_test.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestEnvApp(t *testing.T) {
+	const (
+		testGnoRootEnv = "/faster/better/stronger"
+		testGnoHomeEnv = "/around/the/world"
+	)
+
+	t.Setenv("GNOROOT", testGnoRootEnv)
+	t.Setenv("GNOHOME", testGnoHomeEnv)
+	tc := []testMainCase{
+		// shell
+		{args: []string{"env", "foo"}, stdoutShouldBe: "\n"},
+		{args: []string{"env", "foo", "bar"}, stdoutShouldBe: "\n\n"},
+		{args: []string{"env", "GNOROOT"}, stdoutShouldBe: testGnoRootEnv + "\n"},
+		{args: []string{"env", "GNOHOME", "storm"}, stdoutShouldBe: testGnoHomeEnv + "\n\n"},
+		{args: []string{"env"}, stdoutShouldContain: fmt.Sprintf("GNOROOT=%q", testGnoRootEnv)},
+		{args: []string{"env"}, stdoutShouldContain: fmt.Sprintf("GNOHOME=%q", testGnoHomeEnv)},
+
+		// json
+		{args: []string{"env", "-json"}, stdoutShouldContain: fmt.Sprintf("\"GNOROOT\": %q", testGnoRootEnv)},
+		{args: []string{"env", "-json"}, stdoutShouldContain: fmt.Sprintf("\"GNOHOME\": %q", testGnoHomeEnv)},
+		{
+			args:           []string{"env", "-json", "GNOROOT"},
+			stdoutShouldBe: fmt.Sprintf("{\n\t\"GNOROOT\": %q\n}\n", testGnoRootEnv),
+		},
+		{
+			args:           []string{"env", "-json", "GNOROOT", "storm"},
+			stdoutShouldBe: fmt.Sprintf("{\n\t\"GNOROOT\": %q,\n\t\"storm\": \"\"\n}\n", testGnoRootEnv),
+		},
+		{
+			args:           []string{"env", "-json", "storm"},
+			stdoutShouldBe: "{\n\t\"storm\": \"\"\n}\n",
+		},
+	}
+
+	testMainCaseRun(t, tc)
+}