diff --git a/internal/filter/filter.go b/internal/filter/filter.go
index 230155ce0..d48b77ab5 100644
--- a/internal/filter/filter.go
+++ b/internal/filter/filter.go
@@ -28,20 +28,20 @@ func prepareStr(str string) ([]string, error) {
return splitPath(str), nil
}
-func preparePattern(pattern string) Pattern {
- parts := splitPath(filepath.Clean(pattern))
- patterns := make([]patternPart, len(parts))
- for i, part := range parts {
+func preparePattern(patternStr string) Pattern {
+ pathParts := splitPath(filepath.Clean(patternStr))
+ parts := make([]patternPart, len(pathParts))
+ for i, part := range pathParts {
isSimple := !strings.ContainsAny(part, "\\[]*?")
// Replace "**" with the empty string to get faster comparisons
// (length-check only) in hasDoubleWildcard.
if part == "**" {
part = ""
}
- patterns[i] = patternPart{part, isSimple}
+ parts[i] = patternPart{part, isSimple}
}
- return Pattern{patterns}
+ return Pattern{parts}
}
// Split p into path components. Assuming p has been Cleaned, no component
@@ -64,19 +64,19 @@ func splitPath(p string) []string {
// In addition patterns suitable for filepath.Match, pattern accepts a
// recursive wildcard '**', which greedily matches an arbitrary number of
// intermediate directories.
-func Match(pattern, str string) (matched bool, err error) {
- if pattern == "" {
+func Match(patternStr, str string) (matched bool, err error) {
+ if patternStr == "" {
return true, nil
}
- patterns := preparePattern(pattern)
+ pattern := preparePattern(patternStr)
strs, err := prepareStr(str)
if err != nil {
return false, err
}
- return match(patterns, strs)
+ return match(pattern, strs)
}
// ChildMatch returns true if children of str can match the pattern. When the pattern is
@@ -89,28 +89,28 @@ func Match(pattern, str string) (matched bool, err error) {
// In addition patterns suitable for filepath.Match, pattern accepts a
// recursive wildcard '**', which greedily matches an arbitrary number of
// intermediate directories.
-func ChildMatch(pattern, str string) (matched bool, err error) {
- if pattern == "" {
+func ChildMatch(patternStr, str string) (matched bool, err error) {
+ if patternStr == "" {
return true, nil
}
- patterns := preparePattern(pattern)
+ pattern := preparePattern(patternStr)
strs, err := prepareStr(str)
if err != nil {
return false, err
}
- return childMatch(patterns, strs)
+ return childMatch(pattern, strs)
}
-func childMatch(patterns Pattern, strs []string) (matched bool, err error) {
- if patterns.parts[0].pattern != "/" {
+func childMatch(pattern Pattern, strs []string) (matched bool, err error) {
+ if pattern.parts[0].pattern != "/" {
// relative pattern can always be nested down
return true, nil
}
- ok, pos := hasDoubleWildcard(patterns)
+ ok, pos := hasDoubleWildcard(pattern)
if ok && len(strs) >= pos {
// cut off at the double wildcard
strs = strs[:pos]
@@ -118,12 +118,12 @@ func childMatch(patterns Pattern, strs []string) (matched bool, err error) {
// match path against absolute pattern prefix
l := 0
- if len(strs) > len(patterns.parts) {
- l = len(patterns.parts)
+ if len(strs) > len(pattern.parts) {
+ l = len(pattern.parts)
} else {
l = len(strs)
}
- return match(Pattern{patterns.parts[0:l]}, strs)
+ return match(Pattern{pattern.parts[0:l]}, strs)
}
func hasDoubleWildcard(list Pattern) (ok bool, pos int) {
@@ -136,20 +136,20 @@ func hasDoubleWildcard(list Pattern) (ok bool, pos int) {
return false, 0
}
-func match(patterns Pattern, strs []string) (matched bool, err error) {
- if ok, pos := hasDoubleWildcard(patterns); ok {
+func match(pattern Pattern, strs []string) (matched bool, err error) {
+ if ok, pos := hasDoubleWildcard(pattern); ok {
// gradually expand '**' into separate wildcards
newPat := make([]patternPart, len(strs))
// copy static prefix once
- copy(newPat, patterns.parts[:pos])
- for i := 0; i <= len(strs)-len(patterns.parts)+1; i++ {
+ copy(newPat, pattern.parts[:pos])
+ for i := 0; i <= len(strs)-len(pattern.parts)+1; i++ {
// limit to static prefix and already appended '*'
newPat := newPat[:pos+i]
// in the first iteration the wildcard expands to nothing
if i > 0 {
newPat[pos+i-1] = patternPart{"*", false}
}
- newPat = append(newPat, patterns.parts[pos+1:]...)
+ newPat = append(newPat, pattern.parts[pos+1:]...)
matched, err := match(Pattern{newPat}, strs)
if err != nil {
@@ -164,20 +164,20 @@ func match(patterns Pattern, strs []string) (matched bool, err error) {
return false, nil
}
- if len(patterns.parts) == 0 && len(strs) == 0 {
+ if len(pattern.parts) == 0 && len(strs) == 0 {
return true, nil
}
// an empty pattern never matches a non-empty path
- if len(patterns.parts) == 0 {
+ if len(pattern.parts) == 0 {
return false, nil
}
- if len(patterns.parts) <= len(strs) {
+ if len(pattern.parts) <= len(strs) {
minOffset := 0
- maxOffset := len(strs) - len(patterns.parts)
+ maxOffset := len(strs) - len(pattern.parts)
// special case absolute patterns
- if patterns.parts[0].pattern == "/" {
+ if pattern.parts[0].pattern == "/" {
maxOffset = 0
} else if strs[0] == "/" {
// skip absolute path marker if pattern is not rooted
@@ -186,12 +186,12 @@ func match(patterns Pattern, strs []string) (matched bool, err error) {
outer:
for offset := maxOffset; offset >= minOffset; offset-- {
- for i := len(patterns.parts) - 1; i >= 0; i-- {
+ for i := len(pattern.parts) - 1; i >= 0; i-- {
var ok bool
- if patterns.parts[i].isSimple {
- ok = patterns.parts[i].pattern == strs[offset+i]
+ if pattern.parts[i].isSimple {
+ ok = pattern.parts[i].pattern == strs[offset+i]
} else {
- ok, err = filepath.Match(patterns.parts[i].pattern, strs[offset+i])
+ ok, err = filepath.Match(pattern.parts[i].pattern, strs[offset+i])
if err != nil {
return false, errors.Wrap(err, "Match")
}
@@ -210,9 +210,9 @@ func match(patterns Pattern, strs []string) (matched bool, err error) {
}
// ParsePatterns prepares a list of patterns for use with List.
-func ParsePatterns(patterns []string) []Pattern {
+func ParsePatterns(pattern []string) []Pattern {
patpat := make([]Pattern, 0)
- for _, pat := range patterns {
+ for _, pat := range pattern {
if pat == "" {
continue
}