Respect gitignore files from more places

core.excludesFile and .git/info/exclude are other paths that can include
patterns we want to ignore. Failing to fetch these doesn't cause overall
failures, it only logs.

Author: keith

internal/godemon/godemon.go

@@ -357,6 +357,24 @@ func addGitignorePatterns(cfg *Config, path string) error {
 	}
 	repoPath := *optRepoPath
 	debugf("git repo path for %q: %q", path, repoPath)
+
+	globalExcludesPath, err := gitConfigPath(repoPath, "core.excludesFile")
+	if err != nil {
+		debugf("Could not determine global Git excludes file: %s", err)
+	} else if globalExcludesPath != "" {
+		if err := addGitignoreFilePatterns(cfg, globalExcludesPath, repoPath); err != nil {
+			return err
+		}
+	}
+	infoExcludesPath, err := gitPath(repoPath, "info/exclude")
+	if err != nil {
+		debugf("Could not determine repository Git excludes file: %s", err)
+	} else {
+		if err := addGitignoreFilePatterns(cfg, infoExcludesPath, repoPath); err != nil {
+			return err
+		}
+	}
+
 	ls := exec.Command("git", "ls-files", "--cached", "--modified", "--others")
 	ls.Dir = repoPath
 	stdout := bytes.NewBuffer(nil)
@@ -375,24 +393,56 @@ func addGitignorePatterns(cfg *Config, path string) error {
 		}
 	}
 	for _, gitignoreRelPath := range gitignorePaths {
-		// TODO: Use `git ls-files` to find all .gitignore paths in the repo, and
-		// incorporate those too.
 		gitignorePath := filepath.Join(repoPath, gitignoreRelPath)
-		b, err := os.ReadFile(gitignorePath)
-		if err != nil {
-			if os.IsNotExist(err) {
-				return nil
-			}
+		if err := addGitignoreFilePatterns(cfg, gitignorePath, filepath.Dir(gitignorePath)); err != nil {
 			return err
 		}
-		debugf("Reading .gitignore patterns from %s", gitignorePath)
-		debugf("Raw .gitignore contents: %s", string(b))
-		patterns := parseGitignore(b, filepath.Dir(gitignorePath))
-		cfg.ignorePatterns = append(cfg.ignorePatterns, patterns...)
 	}
 	return nil
 }
 
+func gitConfigPath(repoPath, key string) (string, error) {
+	cmd := exec.Command("git", "config", "--path", "--get", key)
+	cmd.Dir = repoPath
+	out, err := cmd.Output()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 1 {
+			return "", nil
+		}
+		return "", fmt.Errorf("git config --get %s failed: %w", key, err)
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+func gitPath(repoPath, path string) (string, error) {
+	cmd := exec.Command("git", "rev-parse", "--git-path", path)
+	cmd.Dir = repoPath
+	out, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("git rev-parse --git-path %s failed: %w", path, err)
+	}
+	gitPath := strings.TrimSpace(string(out))
+	if !filepath.IsAbs(gitPath) {
+		gitPath = filepath.Join(repoPath, gitPath)
+	}
+	return gitPath, nil
+}
+
+func addGitignoreFilePatterns(cfg *Config, path, parentDirPath string) error {
+	b, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+	debugf("Reading git ignore patterns from %s", path)
+	debugf("Raw git ignore contents: %s", string(b))
+	patterns := parseGitignore(b, parentDirPath)
+	cfg.ignorePatterns = append(cfg.ignorePatterns, patterns...)
+	return nil
+}
+
 func parseGitignore(b []byte, parentDirPath string) []*pattern {
 	var patterns []*pattern
 	lines := strings.Split(string(b), "\n")

internal/godemon/godemon_test.go

@@ -699,6 +699,33 @@ func TestGitignoreInChildDirectory(t *testing.T) {
 	expectRunCount(t, ctx, ws, 1)
 }
 
+func TestGlobalGitignore(t *testing.T) {
+	root := t.TempDir()
+	globalIgnorePath := filepath.Join(root, "global-ignore")
+	writeFile(t, root, "global-ignore", "tags\n")
+
+	globalConfigPath := filepath.Join(root, "global-gitconfig")
+	config := exec.Command("git", "config", "--file", globalConfigPath, "core.excludesFile", globalIgnorePath)
+	if out, err := config.CombinedOutput(); err != nil {
+		t.Fatalf("configure global excludes file: %s: %s", err, out)
+	}
+	t.Setenv("GIT_CONFIG_GLOBAL", globalConfigPath)
+	t.Setenv("GIT_CONFIG_NOSYSTEM", "1")
+
+	ws := newTestWorkspace(t)
+	cfg, err := parseConfig([]string{"godemon", "--watch", ws, "true"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	g := &godemon{cfg: cfg}
+	if !g.shouldIgnore(filepath.Join(ws, "tags")) {
+		t.Fatal("global core.excludesFile pattern did not ignore tags")
+	}
+	if g.shouldIgnore(filepath.Join(ws, "watched.go")) {
+		t.Fatal("global core.excludesFile ignored an unrelated path")
+	}
+}
+
 func TestSendSIGINTToSleepCommandTerminates(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()