Ignore scoped files anywhere in a repo

When checking if an Addition belongs to any scopes, we should compare
just the basename of the Addition instead of using the standard
filename/path matching logic.

Authored-by: Owen Nelson <[email protected]>

Author: tw-owen-nelson

gitrepo/gitrepo.go

@@ -187,19 +187,27 @@ func (repo GitRepo) CheckIfFileExists(fileName string) bool {
 	return true
 }
 
-// Matches states whether the addition matches the given pattern.
-// If the pattern ends in a path separator, then all files inside a directory with that name are matched. However, files with that name itself will not be matched.
-// If a pattern contains the path separator in any other location, the match works according to the pattern logic of the default golang glob mechanism
-// If there are other special characters in the pattern, the pattern is matched against the base name of the file. Thus, the pattern will match files with that pattern anywhere in the repository.
-// If there are no special characters in the pattern, then it means exact filename is provided as pattern like file.txt. Thus, the pattern is matched against the file path so that not all files with the same name in the repo are not returned.
+// Matches reports whether the addition matches the given pattern.
+//
+// If the pattern ends in a path separator, then all files inside a directory with that name are matched.
+// However, files with that name itself will not be matched.
+//
+// If a pattern contains the path separator in any other location,
+// the match works according to the pattern logic of the default golang glob mechanism.
+//
+// If there are other special characters in the pattern, the pattern is matched against the base name of the file.
+// Thus, the pattern will match files with that pattern anywhere in the repository.
+//
+// If there are no special characters in the pattern, then it means exact filename is provided as pattern like file.txt.
+// Thus, the pattern is matched against the file path so that not all files with the same name in the repo are not returned.
 func (a Addition) Matches(pattern string) bool {
 	var result bool
 	if pattern[len(pattern)-1] == '/' { // If the pattern ends in a path separator, then all files inside a directory with that name are matched. However, files with that name itself will not be matched.
 		result = strings.HasPrefix(string(a.Path), pattern)
 	} else if strings.ContainsRune(pattern, '/') { // If a pattern contains the path separator in any other location, the match works according to the pattern logic of the default golang glob mechanism
 		result, _ = path.Match(pattern, string(a.Path))
 	} else if strings.ContainsAny(pattern, "*?[]\\") { // If there are other special characters in the pattern, the pattern is matched against the base name of the file. Thus, the pattern will match files with that pattern anywhere in the repository.
-		result, _ = path.Match(pattern, string(a.Name))
+		result = a.NameMatches(pattern)
 	} else { // If there are no special characters in the pattern, then it means exact filename is provided as pattern like file.txt. Thus, the pattern is matched against the file path so that not all files with the same name in the repo are not returned.
 		result = strings.Compare(string(a.Path), pattern) == 0
 	}
@@ -211,6 +219,12 @@ func (a Addition) Matches(pattern string) bool {
 	return result
 }
 
+// NameMatches reports whether the basename of the Addition matches the given pattern
+func (a Addition) NameMatches(pattern string) bool {
+	result, _ := path.Match(pattern, string(a.Name))
+	return result
+}
+
 // TrackedFilesAsAdditions returns all of the tracked files in a GitRepo as Additions
 func (repo GitRepo) TrackedFilesAsAdditions() []Addition {
 	trackedFilePaths := repo.trackedFilePaths()

gitrepo/gitrepo_test.go

@@ -2,7 +2,6 @@ package gitrepo
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path"
@@ -44,9 +43,9 @@ func TestGetDiffForStagedFiles(t *testing.T) {
 		modifiedAddition := additions[0]
 		createdAddition := additions[1]
 
-		aTxtFileContents, err := ioutil.ReadFile(path.Join(cloneLocation, "a.txt"))
+		aTxtFileContents, err := os.ReadFile(path.Join(cloneLocation, "a.txt"))
 		assert.NoError(t, err)
-		newTxtFileContents, err := ioutil.ReadFile(path.Join(cloneLocation, "new.txt"))
+		newTxtFileContents, err := os.ReadFile(path.Join(cloneLocation, "new.txt"))
 		assert.NoError(t, err)
 
 		expectedModifiedAddition := Addition{
@@ -81,7 +80,7 @@ func TestGetDiffForStagedFilesWithSpacesInPath(t *testing.T) {
 	if assert.Len(t, additions, 1) {
 		modifiedAddition := additions[0]
 
-		aTxtFileContents, err := ioutil.ReadFile(path.Join(cloneLocation, "folder b/c.txt"))
+		aTxtFileContents, err := os.ReadFile(path.Join(cloneLocation, "folder b/c.txt"))
 		assert.NoError(t, err)
 
 		expectedModifiedAddition := Addition{
@@ -204,17 +203,6 @@ func TestStagedAdditionsShouldNotIncludeDeletedFiles(t *testing.T) {
 	assert.Len(t, stagedAdditions, 0)
 }
 
-func TestMatchShouldAllowWildcardPatternMatches(t *testing.T) {
-	file1 := Addition{Path: "bigfile", Name: "bigfile"}
-	file2 := Addition{Path: "anotherbigfile", Name: "anotherbigfile"}
-	file3 := Addition{Path: "somefile", Name: "somefile"}
-	pattern := "*bigfile"
-
-	assert.True(t, file1.Matches(pattern))
-	assert.True(t, file2.Matches(pattern))
-	assert.False(t, file3.Matches(pattern))
-}
-
 func TestMatchShouldMatchExactFileIfNoPatternIsProvided(t *testing.T) {
 	file1 := Addition{Path: "bigfile", Name: "bigfile"}
 	file2 := Addition{Path: "subfolder/bigfile", Name: "bigfile"}
@@ -226,49 +214,39 @@ func TestMatchShouldMatchExactFileIfNoPatternIsProvided(t *testing.T) {
 	assert.False(t, file3.Matches(pattern))
 }
 
-func TestMatchShouldAllowStarPattern(t *testing.T) {
-	file1 := Addition{Path: "GitRepoPath1/File1.txt", Name: "File1.txt"}
-	file2 := Addition{Path: "GitRepoPath1/File2.txt", Name: "File2.txt"}
-	file3 := Addition{Path: "GitRepoPath1/somefile", Name: "somefile"}
-	file4 := Addition{Path: "somefile.jpg", Name: "somefile.jpg"}
-	file5 := Addition{Path: "somefile.txt", Name: "somefile.txt"}
-	file6 := Addition{Path: "File1.txt", Name: "File1.txt"}
-	file7 := Addition{Path: "File3.txt", Name: "File3.txt"}
+func TestMatchingWithPatterns(t *testing.T) {
+	files := []Addition{
+		NewAddition("GitRepoPath1/File1.txt", nil),
+		NewAddition("GitRepoPath1/File2.txt", nil),
+		NewAddition("GitRepoPath1/somefile", nil),
+		NewAddition("somefile.jpg", nil),
+		NewAddition("somefile.txt", nil),
+		NewAddition("File1.txt", nil),
+		NewAddition("File3.txt", nil),
+	}
 
-	pattern := "GitRepoPath1/*.txt"
+	expectedToMatch := map[string][]bool{
+		"GitRepoPath1/*.txt": {true, true, false, false, false, false, false},
+		"*.txt":              {true, true, false, false, true, true, true},
+		"File?.txt":          {true, true, false, false, false, true, true},
+		"File[1].txt":        {true, false, false, false, false, true, false},
+		"File[1-2].txt":      {true, true, false, false, false, true, false},
+		"File\\1.txt":        {true, false, false, false, false, true, false},
+	}
 
-	assert.True(t, file1.Matches(pattern))
-	assert.True(t, file2.Matches(pattern))
-	assert.False(t, file3.Matches(pattern))
-	assert.False(t, file4.Matches(pattern))
-	assert.False(t, file5.Matches(pattern))
-
-	pattern1 := "*.txt"
-	assert.True(t, file1.Matches(pattern1))
-	assert.True(t, file2.Matches(pattern1))
-	assert.False(t, file3.Matches(pattern1))
-	assert.False(t, file4.Matches(pattern1))
-	assert.True(t, file5.Matches(pattern1))
-
-	pattern2 := "File?.txt"
-	assert.True(t, file1.Matches(pattern2))
-	assert.True(t, file2.Matches(pattern2))
-	assert.True(t, file6.Matches(pattern2))
-
-	pattern3 := "File[1].txt"
-	assert.True(t, file1.Matches(pattern3))
-	assert.False(t, file2.Matches(pattern3))
-	assert.True(t, file6.Matches(pattern3))
-
-	pattern4 := "File[1-2].txt"
-	assert.True(t, file1.Matches(pattern4))
-	assert.True(t, file2.Matches(pattern4))
-	assert.True(t, file6.Matches(pattern4))
-	assert.False(t, file7.Matches(pattern4))
-
-	pattern5 := "File\\1.txt"
-	assert.True(t, file1.Matches(pattern5))
-	assert.True(t, file6.Matches(pattern5))
+	for pattern, expectedResults := range expectedToMatch {
+		t.Run(fmt.Sprintf("Testing matches for pattern %s", pattern), func(t *testing.T) {
+			for i := range files {
+				assert.Equal(t, expectedResults[i], files[i].Matches(pattern))
+			}
+		})
+	}
+}
+
+func TestMatchingAdditionBasename(t *testing.T) {
+	addition := NewAddition("subdirectory/nested-file", nil)
+	assert.False(t, addition.Matches("nested-file"))
+	assert.True(t, addition.NameMatches("nested-file"))
 }
 
 func setupOriginAndClones(originLocation, cloneLocation string) (*git_testing.GitTesting, GitRepo) {

talismanrc/scopes.go

@@ -1,11 +1,12 @@
 package talismanrc
 
+// Mapping of language scopes to names of files that should be ignored anywhere in a repository
 var knownScopes = map[string][]string{
 	"node":      {"pnpm-lock.yaml", "yarn.lock", "package-lock.json"},
 	"go":        {"makefile", "go.mod", "go.sum", "Gopkg.toml", "Gopkg.lock", "glide.yaml", "glide.lock"},
 	"images":    {"*.jpeg", "*.jpg", "*.png", "*.tiff", "*.bmp"},
 	"bazel":     {"*.bzl"},
-	"terraform": {".terraform.lock.hcl", "*.terraform.lock.hcl"},
+	"terraform": {".terraform.lock.hcl"},
 	"php":       {"composer.lock"},
 	"python":    {"poetry.lock", "Pipfile.lock", "requirements.txt"},
 }

talismanrc/talismanrc.go

@@ -44,7 +44,7 @@ func (tRC *TalismanRC) RemoveScopedFiles(additions []gitrepo.Addition) []gitrepo
 	for _, addition := range additions {
 		isFilePresentInScope := false
 		for _, fileName := range applicableScopeFileNames {
-			if addition.Matches(fileName) {
+			if addition.NameMatches(fileName) {
 				isFilePresentInScope = true
 				break
 			}

talismanrc/talismanrc_test.go

@@ -90,13 +90,19 @@ func TestIgnoreAdditionsByScope(t *testing.T) {
 		"node": {
 			testAddition("yarn.lock"),
 			testAddition("pnpm-lock.yaml"),
-			testAddition("package-lock.json")},
+			testAddition("package-lock.json"),
+		},
 		"go": {
 			testAddition("Gopkg.lock"),
 			testAddition("makefile"),
-			testAddition("go.mod"), testAddition("go.sum"),
-			testAddition("Gopkg.toml"), testAddition("Gopkg.lock"),
-			testAddition("glide.yaml"), testAddition("glide.lock"),
+			testAddition("go.mod"),
+			testAddition("go.sum"),
+			testAddition("submodule/go.mod"),
+			testAddition("submodule/go.sum"),
+			testAddition("Gopkg.toml"),
+			testAddition("Gopkg.lock"),
+			testAddition("glide.yaml"),
+			testAddition("glide.lock"),
 		},
 		"images": {
 			testAddition("img.jpeg"),
@@ -105,7 +111,9 @@ func TestIgnoreAdditionsByScope(t *testing.T) {
 			testAddition("img.tiff"),
 			testAddition("img.bmp"),
 		},
-		"bazel": {testAddition("bazelfile.bzl")},
+		"bazel": {
+			testAddition("bazelfile.bzl"),
+		},
 		"terraform": {
 			testAddition(".terraform.lock.hcl"),
 			testAddition("foo/.terraform.lock.hcl"),