chore: use tm2/pkg/commands

misc/autocounterd/cmd/cmd_start.go

@@ -2,46 +2,78 @@ package main
 
 import (
 	"context"
+	"flag"
 	"fmt"
 	"time"
 
-	ff "github.com/peterbourgon/ff/v4"
-
 	"github.com/gnolang/gno/gno.land/pkg/gnoclient"
 	rpcclient "github.com/gnolang/gno/tm2/pkg/bft/rpc/client"
+	"github.com/gnolang/gno/tm2/pkg/commands"
 )
 
-func (s *service) NewStartCmd() *ff.Command {
-	rootFlags := ff.NewFlagSet("autocounterd")
-	s.rpcURL = rootFlags.StringLong("rpc", "127.0.0.1:26657", "rpc url endpoint")
-	s.chainID = rootFlags.StringLong("chain-id", "dev", "chain-id")
-	s.mnemonic = rootFlags.StringLong("mnemonic", "", "mnemonic")
-	s.realmPath = rootFlags.StringLong("realm", "gno.land/r/portal/counter", "realm path")
-	s.incrementInterval = rootFlags.DurationLong("interval", 15*time.Second, "Increment counter interval")
+type startCfg struct {
+	rpcURL            string
+	chainID           string
+	mnemonic          string
+	realmPath         string
+	incrementInterval time.Duration
+}
 
-	cmd := &ff.Command{
-		Name:  "start",
-		Flags: rootFlags,
-		Exec:  s.execStart,
+func (cfg *startCfg) Validate() error {
+	switch {
+	case cfg.rpcURL == "":
+		return fmt.Errorf("rpc url cannot be empty")
+	case cfg.chainID == "":
+		return fmt.Errorf("chainID cannot be empty")
+	case cfg.mnemonic == "":
+		return fmt.Errorf("mnemonic cannot be empty")
+	case cfg.realmPath == "":
+		return fmt.Errorf("realmPath cannot be empty")
+	case cfg.incrementInterval == 0:
+		return fmt.Errorf("interval cannot be empty")
 	}
 
-	return cmd
+	return nil
+}
+
+func NewStartCmd(io commands.IO) *commands.Command {
+	cfg := &startCfg{}
+
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "lint",
+			ShortUsage: "lint [flags] <package> [<package>...]",
+			ShortHelp:  "Runs the linter for the specified packages",
+		},
+		cfg,
+		func(_ context.Context, args []string) error {
+			return execStart(cfg, args, io)
+		},
+	)
+}
+
+func (c *startCfg) RegisterFlags(fs *flag.FlagSet) {
+	fs.StringVar(&c.rpcURL, "rpc", "127.0.0.1:26657", "rpc url endpoint")
+	fs.StringVar(&c.chainID, "chain-id", "dev", "chain-id")
+	fs.StringVar(&c.mnemonic, "mnemonic", "", "mnemonic")
+	fs.StringVar(&c.realmPath, "realm", "gno.land/r/portal/counter", "realm path")
+	fs.DurationVar(&c.incrementInterval, "interval", 15*time.Second, "Increment counter interval")
 }
 
-func (s *service) execStart(ctx context.Context, args []string) error {
-	if err := s.Validate(); err != nil {
+func execStart(cfg *startCfg, args []string, io commands.IO) error {
+	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
-	signer, err := gnoclient.SignerFromBip39(s.MustGetMnemonic(), s.MustGetChainID(), "", uint32(0), uint32(0))
+	signer, err := gnoclient.SignerFromBip39(cfg.mnemonic, cfg.chainID, "", uint32(0), uint32(0))
 	if err != nil {
 		return err
 	}
 	if err := signer.Validate(); err != nil {
 		return err
 	}
 
-	rpcClient := rpcclient.NewHTTP(s.MustGetRPC(), "/websocket")
+	rpcClient := rpcclient.NewHTTP(cfg.rpcURL, "/websocket")
 
 	client := gnoclient.Client{
 		Signer:    signer,
@@ -50,7 +82,7 @@ func (s *service) execStart(ctx context.Context, args []string) error {
 
 	for {
 		res, err := client.Call(gnoclient.CallCfg{
-			PkgPath:   s.MustGetRealmPath(),
+			PkgPath:   cfg.realmPath,
 			FuncName:  "Incr",
 			GasFee:    "10000000ugnot",
 			GasWanted: 800000,
@@ -59,10 +91,10 @@ func (s *service) execStart(ctx context.Context, args []string) error {
 		_ = res
 
 		if err != nil {
-			fmt.Printf("[ERROR] Failed to call Incr on %s, %+v\n", s.MustGetRealmPath(), err.Error())
+			fmt.Printf("[ERROR] Failed to call Incr on %s, %+v\n", cfg.realmPath, err.Error())
 		} else {
 			fmt.Println("[INFO] Counter incremented with success")
 		}
-		time.Sleep(s.MustGetIncrementInterval())
+		time.Sleep(cfg.incrementInterval)
 	}
 }

misc/autocounterd/cmd/main.go

@@ -2,61 +2,13 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"os"
-	"time"
 
-	ff "github.com/peterbourgon/ff/v4"
-	"github.com/peterbourgon/ff/v4/ffhelp"
+	"github.com/gnolang/gno/tm2/pkg/commands"
 )
 
-type service struct {
-	rpcURL            *string
-	chainID           *string
-	mnemonic          *string
-	realmPath         *string
-	incrementInterval *time.Duration
-}
-
-func (s service) Validate() error {
-	if s.mnemonic != nil && *s.mnemonic == "" {
-		return fmt.Errorf("mnemonic is missing")
-	} else if s.rpcURL != nil && *s.rpcURL == "" {
-		return fmt.Errorf("rpc url is missing")
-	} else if s.chainID != nil && *s.chainID == "" {
-		return fmt.Errorf("chain_id is missing")
-	} else if s.incrementInterval == nil {
-		return fmt.Errorf("interval is missing")
-	} else if s.realmPath != nil && *s.realmPath == "" {
-		return fmt.Errorf("realm path is missing")
-	}
-	return nil
-}
-
-func (s service) MustGetRPC() string                      { return *s.rpcURL }
-func (s service) MustGetChainID() string                  { return *s.chainID }
-func (s service) MustGetMnemonic() string                 { return *s.mnemonic }
-func (s service) MustGetRealmPath() string                { return *s.realmPath }
-func (s service) MustGetIncrementInterval() time.Duration { return *s.incrementInterval }
-
 func main() {
-	s := &service{}
-
-	rootCmd := &ff.Command{
-		Name: "autocounterd",
-		Subcommands: []*ff.Command{
-			s.NewStartCmd(),
-		},
-	}
-
-	err := rootCmd.ParseAndRun(
-		context.Background(),
-		os.Args[1:],
-		ff.WithEnvVarPrefix("COUNTER"))
+	cmd := NewStartCmd(commands.NewDefaultIO())
 
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%s\n", ffhelp.Command(rootCmd))
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
-		os.Exit(1)
-	}
+	cmd.Execute(context.Background(), os.Args[1:])
 }

misc/autocounterd/go.mod

@@ -34,6 +34,7 @@ require (
 	github.com/libp2p/go-buffer-pool v0.1.0 // indirect
 	github.com/linxGnu/grocksdb v1.8.11 // indirect
 	github.com/pelletier/go-toml v1.9.5 // indirect
+	github.com/peterbourgon/ff/v3 v3.4.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rs/cors v1.10.1 // indirect
@@ -47,6 +48,7 @@ require (
 	golang.org/x/mod v0.14.0 // indirect
 	golang.org/x/net v0.20.0 // indirect
 	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/term v0.16.0 // indirect
 	golang.org/x/tools v0.17.0 // indirect
 	google.golang.org/protobuf v1.31.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect