fileutils: add ShouldDescendExcludedDir for wildcard negation patterns

Signed-off-by: Jan Rodák <hony.com@seznam.cz>

Author: Honny1

storage/pkg/archive/archive.go

@@ -1012,24 +1012,9 @@ func tarWithOptionsTo(dest io.WriteCloser, srcPath string, options *TarOptions)
 					return nil
 				}
 
-				// No exceptions (!...) in patterns so just skip dir
-				if !pm.Exclusions() {
-					return filepath.SkipDir
-				}
-
-				dirSlash := relFilePath + string(filepath.Separator)
-
-				for _, pat := range pm.Patterns() {
-					if !pat.Exclusion() {
-						continue
-					}
-					if strings.HasPrefix(pat.String()+string(filepath.Separator), dirSlash) {
-						// found a match - so can't skip this dir
-						return nil
-					}
+				if fileutils.ShouldDescendExcludedDir(relFilePath, pm) {
+					return nil
 				}
-
-				// No matching exclusion dir so just skip dir
 				return filepath.SkipDir
 			}
 

storage/pkg/fileutils/fileutils.go

@@ -299,6 +299,44 @@ func Matches(file string, patterns []string) (bool, error) {
 	return pm.IsMatch(file)
 }
 
+// ShouldDescendExcludedDir returns true if a directory that would otherwise be
+// skipped (excluded) should still be descended into because a negation pattern
+// (e.g. !cmd/main.go, !**/*.go) might re-include files underneath it.
+//
+// The check is intentionally conservative: it may return true for directories
+// that ultimately contain no re-included files, but actual file-level matching
+// via pm.IsMatch happens later and filters those out. Returning a false
+// positive only costs an extra directory walk; returning a false negative would
+// silently drop files the user asked to keep.
+func ShouldDescendExcludedDir(dirPath string, pm *PatternMatcher) bool {
+	if pm == nil || !pm.Exclusions() {
+		return false
+	}
+	dir := filepath.ToSlash(strings.Trim(dirPath, string(os.PathSeparator)))
+	for _, pattern := range pm.Patterns() {
+		if !pattern.Exclusion() {
+			continue
+		}
+		slashPattern := filepath.ToSlash(strings.Trim(pattern.String(), string(os.PathSeparator)))
+		if strings.HasPrefix(slashPattern, dir+"/") {
+			return true
+		}
+		if firstWild := strings.IndexAny(slashPattern, "*?["); firstWild >= 0 {
+			var literalPrefix string
+			if idx := strings.LastIndex(slashPattern[:firstWild], "/"); idx >= 0 {
+				literalPrefix = slashPattern[:idx]
+			}
+			if literalPrefix == "" {
+				return true
+			}
+			if dir == literalPrefix || strings.HasPrefix(dir, literalPrefix+"/") {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // CopyFile copies from src to dst until either EOF is reached
 // on src or an error occurs. It verifies src exists and removes
 // the dst if it exists.

storage/pkg/fileutils/fileutils_test.go

@@ -617,3 +617,147 @@ func TestMatchesAmount(t *testing.T) {
 		assert.Equal(t, testCase.isMatch, isMatch, desc)
 	}
 }
+
+func TestShouldDescendExcludedDir(t *testing.T) {
+	tests := []struct {
+		name     string
+		dir      string
+		patterns []string
+		expected bool
+	}{
+		{
+			name:     "nil PatternMatcher",
+			dir:      "cmd",
+			patterns: nil,
+			expected: false,
+		},
+		{
+			name:     "no exclusions",
+			dir:      "cmd",
+			patterns: []string{"*.go"},
+			expected: false,
+		},
+		{
+			name:     "literal prefix match",
+			dir:      "cmd",
+			patterns: []string{"*.go", "!cmd/main.go"},
+			expected: true,
+		},
+		{
+			name:     "literal prefix nested",
+			dir:      "cmd/sub",
+			patterns: []string{"*.go", "!cmd/sub/main.go"},
+			expected: true,
+		},
+		{
+			name:     "literal prefix partial non-match",
+			dir:      "cmds",
+			patterns: []string{"*.go", "!cmd/main.go"},
+			expected: false,
+		},
+		{
+			name:     "double-star wildcard at root",
+			dir:      "cmd",
+			patterns: []string{"*.go", "!**/*.go"},
+			expected: true,
+		},
+		{
+			name:     "double-star wildcard deeply nested",
+			dir:      "a/b/c",
+			patterns: []string{"*", "!**/*.txt"},
+			expected: true,
+		},
+		{
+			name:     "single-star wildcard",
+			dir:      "cmd",
+			patterns: []string{"*", "!*/*.go"},
+			expected: true,
+		},
+		{
+			name:     "question-mark wildcard",
+			dir:      "cmd",
+			patterns: []string{"*", "!cm?/main.go"},
+			expected: true,
+		},
+		{
+			name:     "bracket expression wildcard",
+			dir:      "cmd",
+			patterns: []string{"*", "!cm[d]/main.go"},
+			expected: true,
+		},
+		{
+			name:     "mid-segment wildcard",
+			dir:      "cmd",
+			patterns: []string{"*", "!cmd/image*/main.go"},
+			expected: true,
+		},
+		{
+			name:     "mid-segment wildcard nested dir",
+			dir:      "cmd/imager",
+			patterns: []string{"*", "!cmd/image*/main.go"},
+			expected: true,
+		},
+		{
+			name:     "leading slash stripped",
+			dir:      "cmd",
+			patterns: []string{"*", "!/cmd/main.go"},
+			expected: true,
+		},
+		{
+			name:     "dir matches literal prefix exactly",
+			dir:      "vendor",
+			patterns: []string{"*", "!vendor/github.com/foo"},
+			expected: true,
+		},
+		{
+			name:     "dir is child of literal prefix",
+			dir:      "vendor/github.com",
+			patterns: []string{"*", "!vendor/github.com/foo"},
+			expected: true,
+		},
+		{
+			name:     "dir is parent of literal prefix",
+			dir:      "vendor",
+			patterns: []string{"*", "!vendor/github.com/foo"},
+			expected: true,
+		},
+		{
+			name:     "no matching exclusion pattern",
+			dir:      "docs",
+			patterns: []string{"*", "!cmd/main.go"},
+			expected: false,
+		},
+		{
+			name:     "unrelated wildcard pattern",
+			dir:      "docs",
+			patterns: []string{"*", "!cmd/*/*.go"},
+			expected: false,
+		},
+		{
+			name:     "root-level glob matches any dir",
+			dir:      "anything",
+			patterns: []string{"*", "!*.go"},
+			expected: true,
+		},
+		{
+			name:     "trailing slash on dir path",
+			dir:      "cmd/",
+			patterns: []string{"*", "!cmd/main.go"},
+			expected: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			if tc.patterns == nil {
+				result := ShouldDescendExcludedDir(tc.dir, nil)
+				assert.Equal(t, tc.expected, result)
+				return
+			}
+			pm, err := NewPatternMatcher(tc.patterns)
+			require.NoError(t, err)
+			result := ShouldDescendExcludedDir(tc.dir, pm)
+			assert.Equal(t, tc.expected, result, "dir=%q patterns=%v", tc.dir, tc.patterns)
+		})
+	}
+}