wip

tools/confix/cmd/condiff/main.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"os"
+
+	confixcmd "cosmossdk.io/tools/confix/cmd"
+)
+
+func main() {
+	if err := confixcmd.DiffCommand().Execute(); err != nil {
+		os.Exit(1)
+	}
+}

tools/confix/cmd/config.go

@@ -12,12 +12,10 @@ func ConfigCommand() *cobra.Command {
 		Short: "Utilities for managing application configuration",
 	}
 
-	// add subcommands
 	cmd.AddCommand(
 		MigrateCommand(),
 		GetCommand(),
 		SetCommand(),
-		DiffCommand(),
 	)
 
 	return cmd

tools/confix/cmd/diff.go

@@ -1,22 +1,13 @@
 package cmd
 
 import (
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"sort"
-	"strings"
-
-	"github.com/creachadair/tomledit"
-	"github.com/creachadair/tomledit/parser"
-	"github.com/creachadair/tomledit/transform"
+	"cosmossdk.io/tools/confix"
 	"github.com/spf13/cobra"
 )
 
 func DiffCommand() *cobra.Command {
 	return &cobra.Command{
-		Use:   "diff f1 f2",
+		Use:   "condiff f1 f2",
 		Short: "Diff the keyspaces of the TOML documents in files f1 and f2",
 		Long: `Diff the keyspaces of the TOML documents in files f1 and f2.
 The output prints one line per key that differs:
@@ -28,103 +19,19 @@ The output prints one line per key that differs:
 
 Comments, order, and values are ignored for comparison purposes.`,
 		Args: cobra.ExactArgs(2),
-		Run: func(cmd *cobra.Command, args []string) {
-			lhs := mustParse(args[0])
-			rhs := mustParse(args[1])
-			diffDocs(os.Stdout, lhs, rhs)
+		RunE: func(cmd *cobra.Command, args []string) error {
+			lhs, err := confix.LoadConfig(args[0])
+			if err != nil {
+				return err
+			}
+
+			rhs, err := confix.LoadConfig(args[1])
+			if err != nil {
+				return err
+			}
+
+			confix.PrintDiff(cmd.OutOrStdout(), confix.DiffDocs(lhs, rhs))
+			return nil
 		},
 	}
 }
-
-func mustParse(path string) *tomledit.Document {
-	f, err := os.Open(path)
-	if err != nil {
-		log.Fatalf("Opening TOML input: %v", err)
-	}
-	defer f.Close()
-	doc, err := tomledit.Parse(f)
-	if err != nil {
-		log.Fatalf("Parsing %q: %v", path, err)
-	}
-	return doc
-}
-
-func allKeys(s *tomledit.Section) []string {
-	var keys []string
-	s.Scan(func(key parser.Key, _ *tomledit.Entry) bool {
-		keys = append(keys, key.String())
-		return true
-	})
-	return keys
-}
-
-const (
-	delSection = "-S"
-	delMapping = "-M"
-	addSection = "+S"
-	addMapping = "+M"
-
-	delMapSep = "\n" + delMapping + " "
-	addMapSep = "\n" + addMapping + " "
-)
-
-func diffDocs(w io.Writer, lhs, rhs *tomledit.Document) {
-	diffSections(w, lhs.Global, rhs.Global)
-	lsec, rsec := lhs.Sections, rhs.Sections
-	transform.SortSectionsByName(lsec)
-	transform.SortSectionsByName(rsec)
-
-	i, j := 0, 0
-	for i < len(lsec) && j < len(rsec) {
-		if lsec[i].Name.Before(rsec[j].Name) {
-			fmt.Fprintln(w, delSection, lsec[i].Name)
-			fmt.Fprintln(w, delMapping, strings.Join(allKeys(lsec[i]), delMapSep))
-			i++
-		} else if rsec[j].Name.Before(lsec[i].Name) {
-			fmt.Fprintln(w, addSection, rsec[j].Name)
-			fmt.Fprintln(w, addMapping, strings.Join(allKeys(rsec[j]), addMapSep))
-			j++
-		} else {
-			diffSections(w, lsec[i], rsec[j])
-			i++
-			j++
-		}
-	}
-	for ; i < len(lsec); i++ {
-		fmt.Fprintln(w, delSection, lsec[i].Name)
-		fmt.Fprintln(w, delMapping, strings.Join(allKeys(lsec[i]), delMapSep))
-	}
-	for ; j < len(rsec); j++ {
-		fmt.Fprintln(w, addSection, rsec[j].Name)
-		fmt.Fprintln(w, addMapping, strings.Join(allKeys(rsec[j]), addMapSep))
-	}
-}
-
-func diffSections(w io.Writer, lhs, rhs *tomledit.Section) {
-	diffKeys(w, allKeys(lhs), allKeys(rhs))
-}
-
-func diffKeys(w io.Writer, lhs, rhs []string) {
-	sort.Strings(lhs)
-	sort.Strings(rhs)
-
-	i, j := 0, 0
-	for i < len(lhs) && j < len(rhs) {
-		if lhs[i] < rhs[j] {
-			fmt.Fprintln(w, delMapping, lhs[i])
-			i++
-		} else if lhs[i] > rhs[j] {
-			fmt.Fprintln(w, addMapping, rhs[j])
-			j++
-		} else {
-			i++
-			j++
-		}
-	}
-	for ; i < len(lhs); i++ {
-		fmt.Fprintln(w, delMapping, lhs[i])
-	}
-	for ; j < len(rhs); j++ {
-		fmt.Fprintln(w, addMapping, rhs[j])
-	}
-}

tools/confix/cmd/migrate.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
 
 	"cosmossdk.io/tools/confix"
@@ -20,7 +19,7 @@ var (
 
 func MigrateCommand() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "migrate [target-version] [app-toml-path] (options)",
+		Use:   "migrate [target-version] <app-toml-path> (options)",
 		Short: "Migrate Cosmos SDK app configuration file to the specified version",
 		Long: `Migrate the contents of the Cosmos SDK app configuration (app.toml) to the specified version.
 The output is written in-place unless --stdout is provided.
@@ -31,10 +30,10 @@ In case of any error in updating the file, no output is written.`,
 			targetVersion := args[0]
 
 			clientCtx := client.GetClientContextFromCmd(cmd)
-			if clientCtx.HomeDir != "" {
-				filename = fmt.Sprintf("%s/config/app.toml", clientCtx.HomeDir)
-			} else if len(args) > 1 {
+			if len(args) > 1 {
 				filename = args[1]
+			} else if clientCtx.HomeDir != "" {
+				filename = fmt.Sprintf("%s/config/app.toml", clientCtx.HomeDir)
 			} else {
 				return fmt.Errorf("must provide a path to the app.toml file")
 			}
@@ -44,6 +43,11 @@ In case of any error in updating the file, no output is written.`,
 				return fmt.Errorf("unknown version %q, supported versions are: %q", targetVersion, maps.Keys(confix.Migrations))
 			}
 
+			rawFile, err := confix.LoadConfig(filename)
+			if err != nil {
+				return fmt.Errorf("failed to load config: %v", err)
+			}
+
 			ctx := context.Background()
 			if FlagVerbose {
 				ctx = confix.WithLogWriter(ctx, os.Stderr)
@@ -54,8 +58,8 @@ In case of any error in updating the file, no output is written.`,
 				outputPath = ""
 			}
 
-			if err := confix.Upgrade(ctx, plan(filename, targetVersion), filename, outputPath, FlagSkipValidate); err != nil {
-				log.Fatalf("Failed to migrate config: %v", err)
+			if err := confix.Upgrade(ctx, plan(rawFile, targetVersion), filename, outputPath, FlagSkipValidate); err != nil {
+				return fmt.Errorf("failed to migrate config: %w", err)
 			}
 
 			return nil
@@ -64,7 +68,7 @@ In case of any error in updating the file, no output is written.`,
 
 	cmd.Flags().BoolVar(&FlagStdOut, "stdout", false, "print the updated config to stdout")
 	cmd.Flags().BoolVar(&FlagVerbose, "verbose", false, "log changes to stderr")
-	cmd.Flags().BoolVar(&FlagSkipValidate, "skip-validate", false, "skip configuration validation (allows to mutate unknown configurations)")
+	cmd.Flags().BoolVar(&FlagSkipValidate, "skip-validate", false, "skip configuration validation (allows to migrate unknown configurations)")
 
 	return cmd
 }

tools/confix/cmd/migrate_test.go

@@ -1,7 +1,35 @@
 package cmd_test
 
-import "testing"
+import (
+	"testing"
+
+	"cosmossdk.io/tools/confix/cmd"
+	"github.com/cosmos/cosmos-sdk/client"
+	clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
+	"gotest.tools/v3/assert"
+)
 
 func TestMigradeCmd(t *testing.T) {
+	clientCtx, cleanup := initClientContext(t)
+	defer func() {
+		cleanup()
+	}()
+
+	_, err := clitestutil.ExecTestCLICmd(client.Context{}, cmd.MigrateCommand(), []string{"v0.0"})
+	assert.ErrorContains(t, err, "must provide a path to the app.toml file")
+
+	_, err = clitestutil.ExecTestCLICmd(clientCtx, cmd.MigrateCommand(), []string{"v0.0"})
+	assert.ErrorContains(t, err, "unknown version")
+
+	// clientCtx does not create app.toml, so this should fail
+	_, err = clitestutil.ExecTestCLICmd(clientCtx, cmd.MigrateCommand(), []string{"v0.45"})
+	assert.ErrorContains(t, err, "no such file or directory")
+
+	// // try to migrate from client.toml it should fail without --skip-validate
+	// _, err = clitestutil.ExecTestCLICmd(clientCtx, cmd.MigrateCommand(), []string{"v0.45", fmt.Sprintf("%s/config/client.toml", t.TempDir())})
+	// assert.ErrorContains(t, err, "failed to migrate config")
 
+	// // try to migrate from client.toml - it should work and give us a big diff
+	// _, err = clitestutil.ExecTestCLICmd(clientCtx, cmd.MigrateCommand(), []string{"v0.45", fmt.Sprintf("%s/config/client.toml", t.TempDir()), "--skip-validate"})
+	// assert.NilError(t, err)
 }

tools/confix/diff.go

@@ -0,0 +1,127 @@
+package confix
+
+import (
+	"fmt"
+	"io"
+	"sort"
+
+	"github.com/creachadair/tomledit"
+	"github.com/creachadair/tomledit/parser"
+	"github.com/creachadair/tomledit/transform"
+)
+
+const (
+	Section = "S"
+	Mapping = "M"
+)
+
+type Diff struct {
+	Type    string // "section" or "mapping"
+	Deleted bool
+
+	Key string
+	// TODO store value change as well
+	Value string
+}
+
+// DiffDocs diffs the keyspaces of the TOML documents in files lhs and rhs.
+// Comments, order, and values are ignored for comparison purposes.
+func DiffDocs(lhs, rhs *tomledit.Document) []Diff {
+	diff := diffSections(lhs.Global, rhs.Global)
+
+	lsec, rsec := lhs.Sections, rhs.Sections
+	transform.SortSectionsByName(lsec)
+	transform.SortSectionsByName(rsec)
+
+	i, j := 0, 0
+	for i < len(lsec) && j < len(rsec) {
+		if lsec[i].Name.Before(rsec[j].Name) {
+			diff = append(diff, Diff{Type: Section, Deleted: true, Key: lsec[i].Name.String()})
+			for _, key := range allKeys(lsec[i]) {
+				diff = append(diff, Diff{Type: Mapping, Deleted: true, Key: key})
+			}
+			i++
+		} else if rsec[j].Name.Before(lsec[i].Name) {
+			diff = append(diff, Diff{Type: Section, Key: rsec[j].Name.String()})
+			for _, key := range allKeys(rsec[j]) {
+				diff = append(diff, Diff{Type: Mapping, Key: key})
+			}
+			j++
+		} else {
+			diff = append(diff, diffSections(lsec[i], rsec[j])...)
+			i++
+			j++
+		}
+	}
+	for ; i < len(lsec); i++ {
+		diff = append(diff, Diff{Type: Section, Deleted: true, Key: lsec[i].Name.String()})
+		for _, key := range allKeys(lsec[i]) {
+			diff = append(diff, Diff{Type: Mapping, Deleted: true, Key: key})
+		}
+	}
+	for ; j < len(rsec); j++ {
+		diff = append(diff, Diff{Type: Section, Key: rsec[j].Name.String()})
+		for _, key := range allKeys(rsec[j]) {
+			diff = append(diff, Diff{Type: Mapping, Key: key})
+		}
+	}
+
+	return diff
+}
+
+func allKeys(s *tomledit.Section) []string {
+	var keys []string
+	s.Scan(func(key parser.Key, _ *tomledit.Entry) bool {
+		keys = append(keys, key.String())
+		return true
+	})
+	return keys
+}
+
+func diffSections(lhs, rhs *tomledit.Section) []Diff {
+	return diffKeys(allKeys(lhs), allKeys(rhs))
+}
+
+func diffKeys(lhs, rhs []string) []Diff {
+	diff := []Diff{}
+
+	sort.Strings(lhs)
+	sort.Strings(rhs)
+
+	i, j := 0, 0
+	for i < len(lhs) && j < len(rhs) {
+		if lhs[i] < rhs[j] {
+			diff = append(diff, Diff{Type: Mapping, Deleted: true, Key: lhs[i]})
+			i++
+		} else if lhs[i] > rhs[j] {
+			diff = append(diff, Diff{Type: Mapping, Key: rhs[j]})
+			j++
+		} else {
+			i++
+			j++
+		}
+	}
+	for ; i < len(lhs); i++ {
+		diff = append(diff, Diff{Type: Mapping, Deleted: true, Key: lhs[i]})
+	}
+	for ; j < len(rhs); j++ {
+		diff = append(diff, Diff{Type: Mapping, Key: rhs[j]})
+	}
+
+	return diff
+}
+
+// PrintDiff output prints one line per key that differs:
+// -S name    -- section exists in lhs but not rhs
+// +S name    -- section exists in rhs but not lhs
+// -M name    -- mapping exists in lhs but not f2
+// +M name    -- mapping exists in rhs but not lhs
+func PrintDiff(w io.Writer, diffs []Diff) {
+	for _, diff := range diffs {
+		if diff.Deleted {
+			fmt.Fprintln(w, fmt.Sprintf("-%s", diff.Type), diff.Key)
+		} else {
+			fmt.Fprintln(w, fmt.Sprintf("+%s", diff.Type), diff.Key)
+		}
+	}
+}