feat: find tree root via a user-specified command

Signed-off-by: Brian McGee <[email protected]>
Co-authored-by: Matt Sturgeon <[email protected]>
Signed-off-by: Brian McGee <[email protected]>

Author: brianmcgee

cmd/init/init.toml

@@ -28,14 +28,20 @@
 # on-unmatched = "info"
 
 # The root directory from which treefmt will start walking the filesystem
-# Defaults to the directory containing the config file
+# Defaults to the root of the current git worktree.
+# If not in a git repo, defaults to the directory containing the config file.
 # Env $TREEFMT_TREE_ROOT
 # tree-root = "/tmp/foo"
 
 # File to search for to find the tree root (if tree-root is not set)
 # Env $TREEFMT_TREE_ROOT_FILE
 # tree-root-file = ".git/config"
 
+# Command to run to find the tree root. It is parsed using shlex, to allow quoting arguments that contain whitespace.
+# If you wish to pass arguments containing quotes, you should use nested quotes e.g. "'" or '"'
+# Env $TREEFMT_TREE_ROOT_CMD
+# tree-root-cmd = "git rev-parse --show-toplevel"
+
 # Set the verbosity of logs
 # 0 = warn, 1 = info, 2 = debug
 # Env $TREEFMT_VERBOSE

cmd/root_test.go

@@ -1531,6 +1531,118 @@ func TestGit(t *testing.T) {
 	)
 }
 
+func TestTreeRootCmd(t *testing.T) {
+	as := require.New(t)
+
+	tempDir := test.TempExamples(t)
+	configPath := filepath.Join(tempDir, "/treefmt.toml")
+
+	test.ChangeWorkDir(t, tempDir)
+
+	// basic config
+	cfg := &config.Config{
+		FormatterConfigs: map[string]*config.Formatter{
+			"echo": {
+				Command:  "echo", // will not generate any underlying changes in the file
+				Includes: []string{"*"},
+			},
+		},
+	}
+
+	test.WriteConfig(t, configPath, cfg)
+
+	// construct a tree root command with some error logging and dumping output on stdout
+	treeRootCmd := func(output string) string {
+		return fmt.Sprintf("bash -c '>&2 echo -e \"some error text\nsome more error text\" && echo %s'", output)
+	}
+
+	// helper for checking the contents of stderr matches our expected debug output
+	checkStderr := func(buf []byte) {
+		output := string(buf)
+		as.Contains(output, "DEBU tree-root-cmd | stderr: some error text\n")
+		as.Contains(output, "DEBU tree-root-cmd | stderr: some more error text\n")
+	}
+
+	// run treefmt with DEBUG logging enabled and with tree root cmd being the root of the temp directory
+	treefmt(t,
+		withArgs("-vv", "--tree-root-cmd", treeRootCmd(tempDir)),
+		withNoError(t),
+		withStderr(checkStderr),
+		withConfig(configPath, cfg),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 32,
+			stats.Matched:   32,
+			stats.Formatted: 32,
+			stats.Changed:   0,
+		}),
+	)
+
+	// run from a subdirectory, mixing things up by specifying the command via an env variable
+	treefmt(t,
+		withArgs("-vv"),
+		withEnv(map[string]string{
+			"TREEFMT_TREE_ROOT_CMD": treeRootCmd(filepath.Join(tempDir, "go")),
+		}),
+		withNoError(t),
+		withStderr(checkStderr),
+		withConfig(configPath, cfg),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 2,
+			stats.Matched:   2,
+			stats.Formatted: 2,
+			stats.Changed:   0,
+		}),
+	)
+
+	// run from a subdirectory, mixing things up by specifying the command via config
+	cfg.TreeRootCmd = treeRootCmd(filepath.Join(tempDir, "haskell"))
+
+	treefmt(t,
+		withArgs("-vv"),
+		withNoError(t),
+		withStderr(checkStderr),
+		withConfig(configPath, cfg),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 7,
+			stats.Matched:   7,
+			stats.Formatted: 7,
+			stats.Changed:   0,
+		}),
+	)
+
+	// run with a long-running command (2 seconds or more)
+	treefmt(t,
+		withArgs(
+			"-vv",
+			"--tree-root-cmd", fmt.Sprintf(
+				"bash -c 'sleep 2 && echo %s'",
+				tempDir,
+			),
+		),
+		withError(func(as *require.Assertions, err error) {
+			as.ErrorContains(err, "tree-root-cmd was killed after taking more than 2s to execute")
+		}),
+		withConfig(configPath, cfg),
+	)
+
+	// run with a command that outputs multiple lines
+	treefmt(t,
+		withArgs(
+			"--tree-root-cmd", fmt.Sprintf(
+				"bash -c 'echo %s && echo %s'",
+				tempDir, tempDir,
+			),
+		),
+		withStderr(func(buf []byte) {
+			as.Contains(string(buf), fmt.Sprintf("ERRO tree-root-cmd | stdout: \n%s\n%s\n", tempDir, tempDir))
+		}),
+		withError(func(as *require.Assertions, err error) {
+			as.ErrorContains(err, "tree-root-cmd cannot output multiple lines")
+		}),
+		withConfig(configPath, cfg),
+	)
+}
+
 func TestTreeRootExclusivity(t *testing.T) {
 	tempDir := test.TempExamples(t)
 	configPath := filepath.Join(tempDir, "/treefmt.toml")
@@ -1552,7 +1664,7 @@ func TestTreeRootExclusivity(t *testing.T) {
 
 	assertExclusiveConfig := func(as *require.Assertions, err error) {
 		as.ErrorContains(err,
-			"only one of tree-root, tree-root-cmd or tree-root-file can be specified",
+			"at most one of tree-root, tree-root-cmd or tree-root-file can be specified",
 		)
 	}
 
@@ -1580,7 +1692,7 @@ func TestTreeRootExclusivity(t *testing.T) {
 		},
 	}
 
-	permutations := [][]string{
+	invalidCombinations := [][]string{
 		{"tree-root", "tree-root-cmd"},
 		{"tree-root", "tree-root-file"},
 		{"tree-root-cmd", "tree-root-file"},
@@ -1591,11 +1703,11 @@ func TestTreeRootExclusivity(t *testing.T) {
 	// Given that ultimately everything is being reduced into the config object after parsing from viper, I'm fairly
 	// confident if these tests all pass then the mixed methods should yield the same result.
 
-	// test permutations of the same type
-	for _, perm := range permutations {
+	// for each set of invalid args, test them with flags, environment variables, and config entries.
+	for _, combination := range invalidCombinations {
 		// test flags
 		var args []string
-		for _, key := range perm {
+		for _, key := range combination {
 			args = append(args, flagValues[key]...)
 		}
 
@@ -1607,7 +1719,7 @@ func TestTreeRootExclusivity(t *testing.T) {
 		// test env variables
 		env := make(map[string]string)
 
-		for _, key := range perm {
+		for _, key := range combination {
 			entry := envValues[key]
 			env[entry[0]] = entry[1]
 		}
@@ -1622,7 +1734,7 @@ func TestTreeRootExclusivity(t *testing.T) {
 			FormatterConfigs: formatterConfigs,
 		}
 
-		for _, key := range perm {
+		for _, key := range combination {
 			entry := configValues[key]
 			entry(cfg)
 		}