Merge pull request #588 from numtide/fix/default-tree-root-cmd

Fix defaulting of `tree-root-cmd`.

Author: brianmcgee

cmd/root_test.go

@@ -502,6 +502,10 @@ func TestConfigFile(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			tempDir := test.TempExamples(t)
 
+			// change to a temp directory to avoid interference with config file and auto walk detection from
+			// the treefmt repository
+			test.ChangeWorkDir(t, t.TempDir())
+
 			// use a config file in a different temp directory
 			configPath := filepath.Join(t.TempDir(), name)
 

config/config.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/charmbracelet/log"
 	"github.com/google/shlex"
+	"github.com/numtide/treefmt/v2/git"
 	"github.com/numtide/treefmt/v2/walk"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
@@ -290,58 +291,68 @@ func determineTreeRoot(v *viper.Viper, cfg *Config, logger *log.Logger) error {
 		return errors.New("at most one of tree-root, tree-root-cmd or tree-root-file can be specified")
 	}
 
-	// set git-based tree root command if the walker is git and no tree root has been specified
-	if cfg.Walk == walk.Git.String() && count == 0 {
-		cfg.TreeRootCmd = "git rev-parse --show-toplevel"
-
-		logger.Infof(
-			"git walker enabled and tree root has not been specified: defaulting tree-root-cmd to '%s'",
-			cfg.TreeRootCmd,
-		)
-	}
-
 	switch {
 	case cfg.TreeRoot != "":
-		logger.Debugf("tree root specified explicitly: %s", cfg.TreeRoot)
+		logger.Infof("tree root specified explicitly: %s", cfg.TreeRoot)
 
 	case cfg.TreeRootFile != "":
-		logger.Debugf("searching for tree root using tree-root-file: %s", cfg.TreeRootFile)
+		logger.Infof("searching for tree root using tree-root-file: %s", cfg.TreeRootFile)
 
 		_, cfg.TreeRoot, err = FindUp(cfg.WorkingDirectory, cfg.TreeRootFile)
 		if err != nil {
 			return fmt.Errorf("failed to find tree-root based on tree-root-file: %w", err)
 		}
 
 	case cfg.TreeRootCmd != "":
-		logger.Debugf("searching for tree root using tree-root-cmd: %s", cfg.TreeRootCmd)
+		logger.Infof("searching for tree root using tree-root-cmd: %s", cfg.TreeRootCmd)
 
-		if cfg.TreeRoot, err = execTreeRootCmd(cfg); err != nil {
+		if cfg.TreeRoot, err = execTreeRootCmd(cfg.TreeRootCmd, cfg.WorkingDirectory); err != nil {
 			return err
 		}
 
 	default:
 		// no tree root was specified
-		logger.Debugf(
-			"no tree root specified, defaulting to the directory containing the config file: %s",
-			v.ConfigFileUsed(),
-		)
+		logger.Infof("no tree root specified")
+
+		// attempt to resolve with git
+		if cfg.Walk == walk.Auto.String() || cfg.Walk == walk.Git.String() {
+			logger.Infof("attempting to resolve tree root using git: %s", git.TreeRootCmd)
+
+			// attempt to resolve the tree root with git
+			cfg.TreeRoot, err = execTreeRootCmd(git.TreeRootCmd, cfg.WorkingDirectory)
+			if err != nil && cfg.Walk == walk.Git.String() {
+				return fmt.Errorf("failed to resolve tree root with git: %w", err)
+			}
 
-		cfg.TreeRoot = filepath.Dir(v.ConfigFileUsed())
+			if err != nil {
+				logger.Infof("failed to resolve tree root with git: %v", err)
+			}
+		}
+
+		if cfg.TreeRoot == "" {
+			// fallback to the directory containing the config file
+			logger.Infof(
+				"setting tree root to the directory containing the config file: %s",
+				v.ConfigFileUsed(),
+			)
+
+			cfg.TreeRoot = filepath.Dir(v.ConfigFileUsed())
+		}
 	}
 
 	// resolve tree root to an absolute path
 	if cfg.TreeRoot, err = filepath.Abs(cfg.TreeRoot); err != nil {
 		return fmt.Errorf("failed to get absolute path for tree root: %w", err)
 	}
 
-	logger.Debugf("tree root: %s", cfg.TreeRoot)
+	logger.Infof("tree root: %s", cfg.TreeRoot)
 
 	return nil
 }
 
-func execTreeRootCmd(cfg *Config) (string, error) {
+func execTreeRootCmd(treeRootCmd string, workingDir string) (string, error) {
 	// split the command first, resolving any '' and "" entries
-	parts, splitErr := shlex.Split(cfg.TreeRootCmd)
+	parts, splitErr := shlex.Split(treeRootCmd)
 	if splitErr != nil {
 		return "", fmt.Errorf("failed to parse tree-root-cmd: %w", splitErr)
 	}
@@ -356,7 +367,7 @@ func execTreeRootCmd(cfg *Config) (string, error) {
 	// construct the command, setting the correct working directory
 	//nolint:gosec
 	cmd := exec.CommandContext(ctx, parts[0], parts[1:]...)
-	cmd.Dir = cfg.WorkingDirectory
+	cmd.Dir = workingDir
 
 	// setup some pipes to capture stdout and stderr
 	stdout, err := cmd.StdoutPipe()
@@ -428,13 +439,13 @@ func execTreeRootCmd(cfg *Config) (string, error) {
 
 	case 0:
 		// no output was received on stdout
-		return "", fmt.Errorf("empty output received after executing tree-root-cmd: %s", cfg.TreeRootCmd)
+		return "", fmt.Errorf("empty output received after executing tree-root-cmd: %s", treeRootCmd)
 
 	default:
 		// multiple lines received on stdout, dump the output to make it clear what happened and throw an error
 		log.WithPrefix("tree-root-cmd | stdout").Errorf("\n%s", outputStr)
 
-		return "", fmt.Errorf("tree-root-cmd cannot output multiple lines: %s", cfg.TreeRootCmd)
+		return "", fmt.Errorf("tree-root-cmd cannot output multiple lines: %s", treeRootCmd)
 	}
 }
 

config/config_test.go

@@ -617,12 +617,14 @@ func TestWorkingDirectory(t *testing.T) {
 	checkValue(cwd)
 
 	// env override
-	t.Setenv("TREEFMT_WORKING_DIR", "/fizz/buzz/..")
-	checkValue("/fizz")
+	cwd = t.TempDir()
+	t.Setenv("TREEFMT_WORKING_DIR", cwd+"/buzz/..")
+	checkValue(cwd)
 
 	// flag override
-	as.NoError(flags.Set("working-dir", "/flip/flop"))
-	checkValue("/flip/flop")
+	cwd = t.TempDir()
+	as.NoError(flags.Set("working-dir", cwd))
+	checkValue(cwd)
 }
 
 func TestStdin(t *testing.T) {

docs/site/getting-started/configure.md

@@ -306,6 +306,38 @@ Defaults to the directory containing the config file.
     tree-root = "/tmp/foo"
     ```
 
+### `tree-root-cmd`
+
+Command to run to find the tree root.
+It is parsed using [shlex](https://github.com/google/shlex/tree/master), to allow quoting arguments that contain whitespace.
+If you wish to pass arguments containing quotes, you should use nested quotes e.g. `"'"` or `'"'`.
+
+!!!note
+
+    If [walk](#walk) is set to `git` and no tree root option has been defined, `tree-root-cmd` will be defaulted to
+    `git rev-parse --show-toplevel`.
+
+    if [walk](#walk) is set to `auto` (the default), `treefmt` will check if the [working directory](#working-dir) is
+    inside a git worktree. If it is, `tree-root-cmd` will be defaulted as described above for `git`.
+
+=== "Flag"
+
+    ```console
+    treefmt --tree-root-cmd "git rev-parse --show-toplevel"
+    ```
+
+=== "Env"
+
+    ```console
+    TREEFMT_TREE_ROOT_CMD="git rev-parse --show-toplevel" treefmt
+    ```
+
+=== "Config"
+
+    ```toml
+    tree-root-cmd = "git rev-parse --show-toplevel"
+    ```
+
 ### `tree-root-file`
 
 File to search for to find the tree root (if `tree-root` is not set)

git/git.go

@@ -0,0 +1,34 @@
+package git
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+const TreeRootCmd = "git rev-parse --show-toplevel"
+
+func IsInsideWorktree(path string) (bool, error) {
+	// check if the root is a git repository
+	cmd := exec.Command("git", "rev-parse", "--is-inside-work-tree")
+	cmd.Dir = path
+
+	out, err := cmd.Output()
+	if err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) && strings.Contains(string(exitErr.Stderr), "not a git repository") {
+			return false, nil
+		}
+
+		return false, fmt.Errorf("failed to check if %s is a git repository: %w", path, err)
+	}
+
+	if strings.Trim(string(out), "\n") != "true" {
+		// not a git repo
+		return false, nil
+	}
+
+	// is a git repo
+	return true, nil
+}

walk/git.go

@@ -9,9 +9,9 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strconv"
-	"strings"
 
 	"github.com/charmbracelet/log"
+	"github.com/numtide/treefmt/v2/git"
 	"github.com/numtide/treefmt/v2/stats"
 	"golang.org/x/sync/errgroup"
 )
@@ -143,12 +143,12 @@ func NewGitReader(
 	statz *stats.Stats,
 ) (*GitReader, error) {
 	// check if the root is a git repository
-	cmd := exec.Command("git", "rev-parse", "--is-inside-work-tree")
-	cmd.Dir = root
-
-	if out, err := cmd.Output(); err != nil {
+	isGit, err := git.IsInsideWorktree(root)
+	if err != nil {
 		return nil, fmt.Errorf("failed to check if %s is a git repository: %w", root, err)
-	} else if strings.Trim(string(out), "\n") != "true" {
+	}
+
+	if !isGit {
 		return nil, fmt.Errorf("%s is not a git repository", root)
 	}