feat: Do not filter tracked files even if they match gitignore ...

Author: PeterSchafer

pkg/utils/file_filter.go

@@ -10,6 +10,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/rs/zerolog"
 	gitignore "github.com/sabhiram/go-gitignore"
 	"golang.org/x/sync/semaphore"
@@ -112,6 +114,10 @@ func (fw *FileFilter) GetFilteredFiles(filesCh chan string, globs []string) chan
 
 	// create pattern matcher used to match filesToFilter to glob patterns
 	globPatternMatcher := gitignore.CompileIgnoreLines(globs...)
+
+	// get git-tracked files to avoid filtering them out
+	gitTrackedFiles := fw.getGitTrackedFiles()
+
 	go func() {
 		ctx := context.Background()
 		availableThreads := semaphore.NewWeighted(fw.max_threads)
@@ -126,6 +132,11 @@ func (fw *FileFilter) GetFilteredFiles(filesCh chan string, globs []string) chan
 			}
 			go func(f string) {
 				defer availableThreads.Release(1)
+				// files tracked in git should not be filtered, even if they match gitignore patterns
+				if gitTrackedFiles[f] {
+					filteredFilesCh <- f
+					return
+				}
 				// filesToFilter that do not match the glob pattern are filtered
 				if !globPatternMatcher.MatchesPath(f) {
 					filteredFilesCh <- f
@@ -143,6 +154,61 @@ func (fw *FileFilter) GetFilteredFiles(filesCh chan string, globs []string) chan
 	return filteredFilesCh
 }
 
+// getGitTrackedFiles returns a map of absolute file paths that are tracked in git
+func (fw *FileFilter) getGitTrackedFiles() map[string]bool {
+	trackedFiles := make(map[string]bool)
+
+	// open the git repository
+	repo, err := git.PlainOpenWithOptions(fw.path, &git.PlainOpenOptions{
+		DetectDotGit: true,
+	})
+	if err != nil {
+		fw.logger.Debug().Msgf("failed to open git repository: %v", err)
+		return trackedFiles
+	}
+
+	// get the HEAD reference
+	ref, err := repo.Head()
+	if err != nil {
+		fw.logger.Debug().Msgf("failed to get HEAD reference: %v", err)
+		return trackedFiles
+	}
+
+	// get the commit object
+	commit, err := repo.CommitObject(ref.Hash())
+	if err != nil {
+		fw.logger.Debug().Msgf("failed to get commit object: %v", err)
+		return trackedFiles
+	}
+
+	// get the tree from the commit
+	tree, err := commit.Tree()
+	if err != nil {
+		fw.logger.Debug().Msgf("failed to get tree from commit: %v", err)
+		return trackedFiles
+	}
+
+	// get the worktree to find the root path
+	worktree, err := repo.Worktree()
+	if err != nil {
+		fw.logger.Debug().Msgf("failed to get worktree: %v", err)
+		return trackedFiles
+	}
+	repoRoot := worktree.Filesystem.Root()
+
+	// iterate through all files in the tree
+	err = tree.Files().ForEach(func(f *object.File) error {
+		absolutePath := filepath.Join(repoRoot, f.Name)
+		trackedFiles[absolutePath] = true
+		return nil
+	})
+	if err != nil {
+		fw.logger.Debug().Msgf("failed to iterate tree files: %v", err)
+	}
+
+	return trackedFiles
+}
+
 // buildGlobs iterates a list of ignore filesToFilter and returns a list of glob patterns that can be used to test for ignored filesToFilter
 func (fw *FileFilter) buildGlobs(ignoreFiles []string) ([]string, error) {
 	var globs = make([]string, 0)

pkg/utils/file_filter_test.go

@@ -7,7 +7,10 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing/object"
 	"github.com/rs/zerolog/log"
 	"github.com/stretchr/testify/assert"
 )
@@ -707,3 +710,73 @@ func TestDotSnykExclude_isExpired(t *testing.T) {
 		})
 	}
 }
+
+func TestFileFilter_GitTrackedFilesNotFiltered(t *testing.T) {
+	t.Run("git tracked files are not filtered even if they match gitignore", func(t *testing.T) {
+		tempDir := t.TempDir()
+
+		// Initialize a git repository
+		repo, err := git.PlainInit(tempDir, false)
+		assert.NoError(t, err)
+
+		// Create a file that will be tracked and matches gitignore pattern
+		trackedIgnoredFile := filepath.Join(tempDir, "ignored.log")
+		createFileInPath(t, trackedIgnoredFile, []byte("tracked but ignored"))
+
+		// Create another file that will NOT be tracked and matches gitignore pattern
+		untrackedIgnoredFile := filepath.Join(tempDir, "untracked.log")
+		createFileInPath(t, untrackedIgnoredFile, []byte("untracked and ignored"))
+
+		// Create a regular file that doesn't match gitignore
+		regularFile := filepath.Join(tempDir, "regular.txt")
+		createFileInPath(t, regularFile, []byte("regular file"))
+
+		// Add and commit the tracked file BEFORE creating gitignore
+		worktree, err := repo.Worktree()
+		assert.NoError(t, err)
+
+		_, err = worktree.Add("ignored.log")
+		assert.NoError(t, err)
+		_, err = worktree.Add("regular.txt")
+		assert.NoError(t, err)
+
+		_, err = worktree.Commit("initial commit", &git.CommitOptions{
+			Author: &object.Signature{
+				Name:  "Test",
+				Email: "test@test.com",
+				When:  time.Now(),
+			},
+		})
+		assert.NoError(t, err)
+
+		// Now create .gitignore that ignores *.log files
+		gitignorePath := filepath.Join(tempDir, ".gitignore")
+		createFileInPath(t, gitignorePath, []byte("*.log\n"))
+
+		// Create file filter and get filtered files
+		fileFilter := NewFileFilter(tempDir, &log.Logger)
+		rules, err := fileFilter.GetRules([]string{".gitignore"})
+		assert.NoError(t, err)
+
+		allFiles := fileFilter.GetAllFiles()
+		filteredFiles := fileFilter.GetFilteredFiles(allFiles, rules)
+
+		// Collect filtered files
+		var filteredFilesList []string
+		for file := range filteredFiles {
+			filteredFilesList = append(filteredFilesList, file)
+		}
+
+		// The tracked file (ignored.log) should NOT be filtered out
+		assert.Contains(t, filteredFilesList, trackedIgnoredFile, "git tracked file should not be filtered even if it matches gitignore")
+
+		// The untracked file (untracked.log) SHOULD be filtered out
+		assert.NotContains(t, filteredFilesList, untrackedIgnoredFile, "untracked file matching gitignore should be filtered")
+
+		// The regular file should be present
+		assert.Contains(t, filteredFilesList, regularFile, "regular file should not be filtered")
+
+		// The gitignore file should be present
+		assert.Contains(t, filteredFilesList, gitignorePath, ".gitignore should not be filtered")
+	})
+}