Add WithCaseInsensitive GlobOption

This PR adds the `WithCaseInsensitive` `GlobOption` to allow for case
insensitive matches in glob paths.

Author: braydonk

doublestar_test.go

@@ -35,7 +35,7 @@ var matchTests = []MatchTest{
 	{"/*", "/debug/", false, false, nil, false, false, true, false, 0, 0},
 	{"/*", "//", false, false, nil, false, false, true, false, 0, 0},
 	{"abc", "abc", true, true, nil, false, false, true, true, 1, 1},
-	{"*", "abc", true, true, nil, false, false, true, true, 23, 18},
+	{"*", "abc", true, true, nil, false, false, true, true, 24, 18},
 	{"*c", "abc", true, true, nil, false, false, true, true, 2, 2},
 	{"*/", "a/", true, true, nil, false, false, true, false, 0, 0},
 	{"a*", "a", true, true, nil, false, false, true, true, 9, 9},
@@ -63,8 +63,8 @@ var matchTests = []MatchTest{
 	{"a[!a]b", "a☺b", true, true, nil, false, false, false, true, 1, 1},
 	{"a???b", "a☺b", false, false, nil, false, false, true, true, 0, 0},
 	{"a[^a][^a][^a]b", "a☺b", false, false, nil, false, false, true, true, 0, 0},
-	{"[a-ζ]*", "α", true, true, nil, false, false, true, true, 20, 17},
-	{"*[a-ζ]", "A", false, false, nil, false, false, true, true, 20, 17},
+	{"[a-ζ]*", "α", true, true, nil, false, false, true, true, 21, 17},
+	{"*[a-ζ]", "A", false, false, nil, false, false, true, true, 21, 17},
 	{"a?b", "a/b", false, false, nil, false, false, true, true, 1, 1},
 	{"a*b", "a/b", false, false, nil, false, false, true, true, 1, 1},
 	{"[\\]a]", "]", true, true, nil, false, false, true, !onWindows, 2, 2},
@@ -297,8 +297,8 @@ func TestMatchUnvalidated(t *testing.T) {
 		{"[", "a", ErrBadPattern, ErrBadPattern}, // Error right up front, needs to fail whether validate or not
 	}
 	for idx, tt := range unvalidatedTests {
-		_, errValidated := matchWithSeparator(tt.pattern, tt.testPath, '/', true)
-		_, errUnvalidated := matchWithSeparator(tt.pattern, tt.testPath, '/', false)
+		_, errValidated := matchWithSeparator(tt.pattern, tt.testPath, '/', true, false)
+		_, errUnvalidated := matchWithSeparator(tt.pattern, tt.testPath, '/', false, false)
 		if errValidated != tt.expectedErrValidated {
 			t.Errorf("#%v. Validated error of Match(%#q, %#q) = %v want %v", idx, tt.pattern, tt.testPath, errValidated, tt.expectedErrValidated)
 		}
@@ -393,7 +393,7 @@ func testPathMatchFakeWith(t *testing.T, idx int, tt MatchTest) {
 
 	pattern := strings.ReplaceAll(tt.pattern, "/", "\\")
 	testPath := strings.ReplaceAll(tt.testPath, "/", "\\")
-	ok, err := matchWithSeparator(pattern, testPath, '\\', true)
+	ok, err := matchWithSeparator(pattern, testPath, '\\', true, false)
 	if ok != tt.shouldMatch || err != tt.expectedErr {
 		t.Errorf("#%v. PathMatch(%#q, %#q) = %v, %v want %v, %v", idx, pattern, testPath, ok, err, tt.shouldMatch, tt.expectedErr)
 	}
@@ -535,26 +535,36 @@ func testStandardGlob(t *testing.T, idx int, fn string, tt MatchTest, fsys fs.FS
 }
 
 func TestFilepathGlob(t *testing.T) {
-	doFilepathGlobTest(t)
+	doFilepathGlobTest(t, matchTests)
 }
 
 func TestFilepathGlobWithFailOnIOErrors(t *testing.T) {
-	doFilepathGlobTest(t, WithFailOnIOErrors())
+	doFilepathGlobTest(t, matchTests, WithFailOnIOErrors())
 }
 
 func TestFilepathGlobWithFailOnPatternNotExist(t *testing.T) {
-	doFilepathGlobTest(t, WithFailOnPatternNotExist())
+	doFilepathGlobTest(t, matchTests, WithFailOnPatternNotExist())
 }
 
 func TestFilepathGlobWithFilesOnly(t *testing.T) {
-	doFilepathGlobTest(t, WithFilesOnly())
+	doFilepathGlobTest(t, matchTests, WithFilesOnly())
 }
 
 func TestFilepathGlobWithNoFollow(t *testing.T) {
-	doFilepathGlobTest(t, WithNoFollow())
+	doFilepathGlobTest(t, matchTests, WithNoFollow())
 }
 
-func doFilepathGlobTest(t *testing.T, opts ...GlobOption) {
+func TestFilepathGlobWithCaseInsensitive(t *testing.T) {
+	var insensitiveTest, sensitiveTest MatchTest
+	insensitiveTest = MatchTest{"**/test", "cases", false, false, nil, false, false, false, !onWindows, 1, 1}
+	sensitiveTest = insensitiveTest
+	sensitiveTest.numResults = 3
+
+	doFilepathGlobTest(t, []MatchTest{insensitiveTest})
+	doFilepathGlobTest(t, []MatchTest{sensitiveTest}, WithCaseInsensitive())
+}
+
+func doFilepathGlobTest(t *testing.T, tests []MatchTest, opts ...GlobOption) {
 	glob := newGlob(opts...)
 	fsys := os.DirFS("test")
 
@@ -564,7 +574,7 @@ func doFilepathGlobTest(t *testing.T, opts ...GlobOption) {
 	}()
 	os.Chdir("test")
 
-	for idx, tt := range matchTests {
+	for idx, tt := range tests {
 		// Patterns ending with a slash are treated semantically different by
 		// FilepathGlob vs Glob because FilepathGlob runs filepath.Clean, which
 		// will remove the trailing slash.
@@ -822,6 +832,9 @@ func TestMain(m *testing.M) {
 	mkdirp("test", "axbxcxdxexxx")
 	mkdirp("test", "b")
 	mkdirp("test", "e", "[x]", "[y]")
+	mkdirp("test", "cases", "test_a")
+	mkdirp("test", "cases", "test_b")
+	mkdirp("test", "cases", "test_c")
 
 	// create test files
 	touch("test", "1")
@@ -853,6 +866,10 @@ func TestMain(m *testing.M) {
 	touch("test", "e", "[]")
 	touch("test", "e", "[x]", "[y]", "z")
 
+	touch("test", "cases", "test_a", "test")
+	touch("test", "cases", "test_b", "TEST")
+	touch("test", "cases", "test_c", "Test")
+
 	touch("test", "}")
 
 	if !onWindows {

glob.go

@@ -225,7 +225,7 @@ func (g *glob) globDir(fsys fs.FS, dir, pattern string, matches []string, canMat
 	var matched bool
 	for _, info := range dirs {
 		name := info.Name()
-		matched, e = matchWithSeparator(pattern, name, '/', false)
+		matched, e = matchWithSeparator(pattern, name, '/', false, g.alphaCaseInsensitive)
 		if e != nil {
 			return
 		}

globoptions.go

@@ -8,6 +8,7 @@ type glob struct {
 	failOnPatternNotExist bool
 	filesOnly             bool
 	noFollow              bool
+	alphaCaseInsensitive  bool
 }
 
 // GlobOption represents a setting that can be passed to Glob, GlobWalk, and
@@ -28,7 +29,6 @@ func newGlob(opts ...GlobOption) *glob {
 // encountered. Note that if the glob pattern references a path that does not
 // exist (such as `nonexistent/path/*`), this is _not_ considered an IO error:
 // it is considered a pattern with no matches.
-//
 func WithFailOnIOErrors() GlobOption {
 	return func(g *glob) {
 		g.failOnIOErrors = true
@@ -42,7 +42,6 @@ func WithFailOnIOErrors() GlobOption {
 // `{...}`) are expanded before this check. In other words, a pattern such as
 // `{a,b}/*` may fail if either `a` or `b` do not exist but `*/{a,b}` will
 // never fail because the star may match nothing.
-//
 func WithFailOnPatternNotExist() GlobOption {
 	return func(g *glob) {
 		g.failOnPatternNotExist = true
@@ -56,7 +55,6 @@ func WithFailOnPatternNotExist() GlobOption {
 // Note: if combined with the WithNoFollow option, symlinks to directories
 // _will_ be included in the result since no attempt is made to follow the
 // symlink.
-//
 func WithFilesOnly() GlobOption {
 	return func(g *glob) {
 		g.filesOnly = true
@@ -76,17 +74,25 @@ func WithFilesOnly() GlobOption {
 // Note: if combined with the WithFilesOnly option, symlinks to directories
 // _will_ be included in the result since no attempt is made to follow the
 // symlink.
-//
 func WithNoFollow() GlobOption {
 	return func(g *glob) {
 		g.noFollow = true
 	}
 }
 
+// WithCaseInsensitive is an option that can be passed to Glob, GlobWalk, or
+// FilepathGlob. If passed, doublestar will treat all alphabetic characters as
+// case insensitive (i.e. "a" in the pattern would match "a" or "A"). This is
+// useful for platforms like Windows where paths are case insensitive by default.
+func WithCaseInsensitive() GlobOption {
+	return func(g *glob) {
+		g.alphaCaseInsensitive = true
+	}
+}
+
 // forwardErrIfFailOnIOErrors is used to wrap the return values of I/O
 // functions. When failOnIOErrors is enabled, it will return err; otherwise, it
 // always returns nil.
-//
 func (g *glob) forwardErrIfFailOnIOErrors(err error) error {
 	if g.failOnIOErrors {
 		return err
@@ -97,7 +103,6 @@ func (g *glob) forwardErrIfFailOnIOErrors(err error) error {
 // handleErrNotExist handles fs.ErrNotExist errors. If
 // WithFailOnPatternNotExist has been enabled and canFail is true, this will
 // return ErrPatternNotExist. Otherwise, it will return nil.
-//
 func (g *glob) handlePatternNotExist(canFail bool) error {
 	if canFail && g.failOnPatternNotExist {
 		return ErrPatternNotExist

globwalk.go

@@ -50,7 +50,6 @@ type GlobWalkFunc func(path string, d fs.DirEntry) error
 //
 // Note: users should _not_ count on the returned error,
 // doublestar.ErrBadPattern, being equal to path.ErrBadPattern.
-//
 func GlobWalk(fsys fs.FS, pattern string, fn GlobWalkFunc, opts ...GlobOption) error {
 	if !ValidatePattern(pattern) {
 		return ErrBadPattern
@@ -290,7 +289,7 @@ func (g *glob) globDirWalk(fsys fs.FS, dir, pattern string, canMatchFiles, befor
 	var matched bool
 	for _, info := range dirs {
 		name := info.Name()
-		matched, e = matchWithSeparator(pattern, name, '/', false)
+		matched, e = matchWithSeparator(pattern, name, '/', false, g.alphaCaseInsensitive)
 		if e != nil {
 			return
 		}

match.go

@@ -2,30 +2,31 @@ package doublestar
 
 import (
 	"path/filepath"
+	"unicode"
 	"unicode/utf8"
 )
 
 // Match reports whether name matches the shell pattern.
 // The pattern syntax is:
 //
-//  pattern:
-//    { term }
-//  term:
-//    '*'         matches any sequence of non-path-separators
-//    '/**/'      matches zero or more directories
-//    '?'         matches any single non-path-separator character
-//    '[' [ '^' '!' ] { character-range } ']'
-//                character class (must be non-empty)
-//                starting with `^` or `!` negates the class
-//    '{' { term } [ ',' { term } ... ] '}'
-//                alternatives
-//    c           matches character c (c != '*', '?', '\\', '[')
-//    '\\' c      matches character c
+//	pattern:
+//	  { term }
+//	term:
+//	  '*'         matches any sequence of non-path-separators
+//	  '/**/'      matches zero or more directories
+//	  '?'         matches any single non-path-separator character
+//	  '[' [ '^' '!' ] { character-range } ']'
+//	              character class (must be non-empty)
+//	              starting with `^` or `!` negates the class
+//	  '{' { term } [ ',' { term } ... ] '}'
+//	              alternatives
+//	  c           matches character c (c != '*', '?', '\\', '[')
+//	  '\\' c      matches character c
 //
-//  character-range:
-//    c           matches character c (c != '\\', '-', ']')
-//    '\\' c      matches character c
-//    lo '-' hi   matches character c for lo <= c <= hi
+//	character-range:
+//	  c           matches character c (c != '\\', '-', ']')
+//	  '\\' c      matches character c
+//	  lo '-' hi   matches character c for lo <= c <= hi
 //
 // Match returns true if `name` matches the file name `pattern`. `name` and
 // `pattern` are split on forward slash (`/`) characters and may be relative or
@@ -48,9 +49,8 @@ import (
 //
 // Note: users should _not_ count on the returned error,
 // doublestar.ErrBadPattern, being equal to path.ErrBadPattern.
-//
 func Match(pattern, name string) (bool, error) {
-	return matchWithSeparator(pattern, name, '/', true)
+	return matchWithSeparator(pattern, name, '/', true, false)
 }
 
 // MatchUnvalidated can provide a small performance improvement if you don't
@@ -60,7 +60,7 @@ func Match(pattern, name string) (bool, error) {
 // of `name` before reaching the end of `pattern`, such as `Match("a/b/c",
 // "a")`.
 func MatchUnvalidated(pattern, name string) bool {
-	matched, _ := matchWithSeparator(pattern, name, '/', false)
+	matched, _ := matchWithSeparator(pattern, name, '/', false, false)
 	return matched
 }
 
@@ -73,9 +73,8 @@ func MatchUnvalidated(pattern, name string) bool {
 // assumes that both `pattern` and `name` are using the system's path
 // separator. If you can't be sure of that, use filepath.ToSlash() on both
 // `pattern` and `name`, and then use the Match() function instead.
-//
 func PathMatch(pattern, name string) (bool, error) {
-	return matchWithSeparator(pattern, name, filepath.Separator, true)
+	return matchWithSeparator(pattern, name, filepath.Separator, true, false)
 }
 
 // PathMatchUnvalidated can provide a small performance improvement if you
@@ -85,15 +84,15 @@ func PathMatch(pattern, name string) (bool, error) {
 // end of `name` before reaching the end of `pattern`, such as `Match("a/b/c",
 // "a")`.
 func PathMatchUnvalidated(pattern, name string) bool {
-	matched, _ := matchWithSeparator(pattern, name, filepath.Separator, false)
+	matched, _ := matchWithSeparator(pattern, name, filepath.Separator, false, false)
 	return matched
 }
 
-func matchWithSeparator(pattern, name string, separator rune, validate bool) (matched bool, err error) {
-	return doMatchWithSeparator(pattern, name, separator, validate, -1, -1, -1, -1, 0, 0)
+func matchWithSeparator(pattern, name string, separator rune, validate bool, caseInsensitive bool) (matched bool, err error) {
+	return doMatchWithSeparator(pattern, name, separator, validate, caseInsensitive, -1, -1, -1, -1, 0, 0)
 }
 
-func doMatchWithSeparator(pattern, name string, separator rune, validate bool, doublestarPatternBacktrack, doublestarNameBacktrack, starPatternBacktrack, starNameBacktrack, patIdx, nameIdx int) (matched bool, err error) {
+func doMatchWithSeparator(pattern, name string, separator rune, validate bool, caseInsensitive bool, doublestarPatternBacktrack, doublestarNameBacktrack, starPatternBacktrack, starNameBacktrack, patIdx, nameIdx int) (matched bool, err error) {
 	patLen := len(pattern)
 	nameLen := len(name)
 	startOfSegment := true
@@ -194,7 +193,7 @@ MATCH:
 					}
 
 					// check if the rune matches
-					if patRune == nameRune {
+					if matchRune(patRune, nameRune, caseInsensitive) {
 						matched = true
 						break
 					}
@@ -240,14 +239,14 @@ MATCH:
 					}
 					commaIdx += patIdx
 
-					result, err := doMatchWithSeparator(pattern[:beforeIdx]+pattern[patIdx:commaIdx]+pattern[closingIdx+1:], name, separator, validate, doublestarPatternBacktrack, doublestarNameBacktrack, starPatternBacktrack, starNameBacktrack, beforeIdx, nameIdx)
+					result, err := doMatchWithSeparator(pattern[:beforeIdx]+pattern[patIdx:commaIdx]+pattern[closingIdx+1:], name, separator, validate, caseInsensitive, doublestarPatternBacktrack, doublestarNameBacktrack, starPatternBacktrack, starNameBacktrack, beforeIdx, nameIdx)
 					if result || err != nil {
 						return result, err
 					}
 
 					patIdx = commaIdx + 1
 				}
-				return doMatchWithSeparator(pattern[:beforeIdx]+pattern[patIdx:closingIdx]+pattern[closingIdx+1:], name, separator, validate, doublestarPatternBacktrack, doublestarNameBacktrack, starPatternBacktrack, starNameBacktrack, beforeIdx, nameIdx)
+				return doMatchWithSeparator(pattern[:beforeIdx]+pattern[patIdx:closingIdx]+pattern[closingIdx+1:], name, separator, validate, caseInsensitive, doublestarPatternBacktrack, doublestarNameBacktrack, starPatternBacktrack, starNameBacktrack, beforeIdx, nameIdx)
 
 			case '\\':
 				if separator != '\\' {
@@ -262,7 +261,7 @@ MATCH:
 			default:
 				patRune, patRuneLen := utf8.DecodeRuneInString(pattern[patIdx:])
 				nameRune, nameRuneLen := utf8.DecodeRuneInString(name[nameIdx:])
-				if patRune != nameRune {
+				if !matchRune(patRune, nameRune, caseInsensitive) {
 					if separator != '\\' && patIdx > 0 && pattern[patIdx-1] == '\\' {
 						// if this rune was meant to be escaped, we need to move patIdx
 						// back to the backslash before backtracking or validating below
@@ -317,6 +316,13 @@ MATCH:
 	return isZeroLengthPattern(pattern[patIdx:], separator, validate)
 }
 
+func matchRune(a, b rune, caseInsensitive bool) bool {
+	if caseInsensitive {
+		return unicode.ToLower(a) == unicode.ToLower(b)
+	}
+	return a == b
+}
+
 func isZeroLengthPattern(pattern string, separator rune, validate bool) (ret bool, err error) {
 	// `/**`, `**/`, and `/**/` are special cases - a pattern such as `path/to/a/**` or `path/to/a/**/`
 	// *should* match `path/to/a` because `a` might be a directory