octoleo/syncthing
1
0
Fork 0
mirror of https://github.com/octoleo/syncthing.git synced 2025-04-05 01:01:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

golint: FNM_FOOBAR -> fnmatch.FooBar

Browse Source
This commit is contained in:
Jakob Borg 2015-04-04 22:03:03 +02:00
parent b08ee3ff81
commit 6e317896e9
3 changed files with 22 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
internal/fnmatch/fnmatch.go
View File

@ -14,9 +14,9 @@ import (
) )
const ( const (
FNM_NOESCAPE = (1 << iota) NoEscape = (1 << iota)
FNM_PATHNAME PathName
FNM_CASEFOLD CaseFold
) )
func Convert(pattern string, flags int) (*regexp.Regexp, error) { func Convert(pattern string, flags int) (*regexp.Regexp, error) {
@ -24,16 +24,16 @@ func Convert(pattern string, flags int) (*regexp.Regexp, error) {
switch runtime.GOOS { switch runtime.GOOS {
case "windows": case "windows":
flags |= FNM_NOESCAPE | FNM_CASEFOLD flags |= NoEscape | CaseFold
pattern = filepath.FromSlash(pattern) pattern = filepath.FromSlash(pattern)
if flags&FNM_PATHNAME != 0 { if flags&PathName != 0 {
any = "[^\\\\]" any = "[^\\\\]"
} }
case "darwin": case "darwin":
flags |= FNM_CASEFOLD flags |= CaseFold
fallthrough fallthrough
default: default:
if flags&FNM_PATHNAME != 0 { if flags&PathName != 0 {
any = "[^/]" any = "[^/]"
} }
} }
@ -41,11 +41,11 @@ func Convert(pattern string, flags int) (*regexp.Regexp, error) {
// Support case insensitive ignores // Support case insensitive ignores
ignore := strings.TrimPrefix(pattern, "(?i)") ignore := strings.TrimPrefix(pattern, "(?i)")
if ignore != pattern { if ignore != pattern {
flags |= FNM_CASEFOLD flags |= CaseFold
pattern = ignore pattern = ignore
} }
if flags&FNM_NOESCAPE != 0 { if flags&NoEscape != 0 {
pattern = strings.Replace(pattern, "\\", "\\\\", -1) pattern = strings.Replace(pattern, "\\", "\\\\", -1)
} else { } else {
pattern = strings.Replace(pattern, "\\*", "[:escapedstar:]", -1) pattern = strings.Replace(pattern, "\\*", "[:escapedstar:]", -1)
@ -69,7 +69,7 @@ func Convert(pattern string, flags int) (*regexp.Regexp, error) {
pattern = strings.Replace(pattern, "[:escapeddot:]", "\\.", -1) pattern = strings.Replace(pattern, "[:escapeddot:]", "\\.", -1)
pattern = "^" + pattern + "$" pattern = "^" + pattern + "$"
if flags&FNM_CASEFOLD != 0 { if flags&CaseFold != 0 {
pattern = "(?i)" + pattern pattern = "(?i)" + pattern
} }
return regexp.Compile(pattern) return regexp.Compile(pattern)

14
internal/fnmatch/fnmatch_test.go
View File

@ -41,18 +41,18 @@ var testcases = []testcase{
{"f[ab]o.txt", "fco.txt", 0, false}, {"f[ab]o.txt", "fco.txt", 0, false},
{"f[ab]o.txt", "fabo.txt", 0, false}, {"f[ab]o.txt", "fabo.txt", 0, false},
{"f[ab]o.txt", "f[ab]o.txt", 0, false}, {"f[ab]o.txt", "f[ab]o.txt", 0, false},
{"f\\[ab\\]o.txt", "f[ab]o.txt", FNM_NOESCAPE, false}, {"f\\[ab\\]o.txt", "f[ab]o.txt", NoEscape, false},
{"*foo.txt", "bar/foo.txt", 0, true}, {"*foo.txt", "bar/foo.txt", 0, true},
{"*foo.txt", "bar/foo.txt", FNM_PATHNAME, false}, {"*foo.txt", "bar/foo.txt", PathName, false},
{"*/foo.txt", "bar/foo.txt", 0, true}, {"*/foo.txt", "bar/foo.txt", 0, true},
{"*/foo.txt", "bar/foo.txt", FNM_PATHNAME, true}, {"*/foo.txt", "bar/foo.txt", PathName, true},
{"*/foo.txt", "bar/baz/foo.txt", 0, true}, {"*/foo.txt", "bar/baz/foo.txt", 0, true},
{"*/foo.txt", "bar/baz/foo.txt", FNM_PATHNAME, false}, {"*/foo.txt", "bar/baz/foo.txt", PathName, false},
{"**/foo.txt", "bar/baz/foo.txt", 0, true}, {"**/foo.txt", "bar/baz/foo.txt", 0, true},
{"**/foo.txt", "bar/baz/foo.txt", FNM_PATHNAME, true}, {"**/foo.txt", "bar/baz/foo.txt", PathName, true},
{"foo.txt", "foo.TXT", FNM_CASEFOLD, true}, {"foo.txt", "foo.TXT", CaseFold, true},
{"foo.txt", "foo.TXT", 0, false}, {"foo.txt", "foo.TXT", 0, false},
{"(?i)foo.txt", "foo.TXT", 0, true}, {"(?i)foo.txt", "foo.TXT", 0, true},
@ -78,7 +78,7 @@ func TestMatch(t *testing.T) {
testcases = append(testcases, testcase{"f\\[ab\\]o.txt", "f[ab]o.txt", 0, true}) testcases = append(testcases, testcase{"f\\[ab\\]o.txt", "f[ab]o.txt", 0, true})
testcases = append(testcases, testcase{"foo\\.txt", "foo.txt", 0, true}) testcases = append(testcases, testcase{"foo\\.txt", "foo.txt", 0, true})
testcases = append(testcases, testcase{"foo\\*.txt", "foo*.txt", 0, true}) testcases = append(testcases, testcase{"foo\\*.txt", "foo*.txt", 0, true})
testcases = append(testcases, testcase{"foo\\.txt", "foo.txt", FNM_NOESCAPE, false}) testcases = append(testcases, testcase{"foo\\.txt", "foo.txt", NoEscape, false})
testcases = append(testcases, testcase{"f\\\\\\[ab\\\\\\]o.txt", "f\\[ab\\]o.txt", 0, true}) testcases = append(testcases, testcase{"f\\\\\\[ab\\\\\\]o.txt", "f\\[ab\\]o.txt", 0, true})
} }

10
internal/ignore/ignore.go
View File

@ -200,20 +200,20 @@ func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) ([]
if strings.HasPrefix(line, "/") { if strings.HasPrefix(line, "/") {
// Pattern is rooted in the current dir only // Pattern is rooted in the current dir only
exp, err := fnmatch.Convert(line[1:], fnmatch.FNM_PATHNAME) exp, err := fnmatch.Convert(line[1:], fnmatch.PathName)
if err != nil { if err != nil {
return fmt.Errorf("Invalid pattern %q in ignore file", line) return fmt.Errorf("Invalid pattern %q in ignore file", line)
} }
patterns = append(patterns, Pattern{exp, include}) patterns = append(patterns, Pattern{exp, include})
} else if strings.HasPrefix(line, "**/") { } else if strings.HasPrefix(line, "**/") {
// Add the pattern as is, and without **/ so it matches in current dir // Add the pattern as is, and without **/ so it matches in current dir
exp, err := fnmatch.Convert(line, fnmatch.FNM_PATHNAME) exp, err := fnmatch.Convert(line, fnmatch.PathName)
if err != nil { if err != nil {
return fmt.Errorf("Invalid pattern %q in ignore file", line) return fmt.Errorf("Invalid pattern %q in ignore file", line)
} }
patterns = append(patterns, Pattern{exp, include}) patterns = append(patterns, Pattern{exp, include})
exp, err = fnmatch.Convert(line[3:], fnmatch.FNM_PATHNAME) exp, err = fnmatch.Convert(line[3:], fnmatch.PathName)
if err != nil { if err != nil {
return fmt.Errorf("Invalid pattern %q in ignore file", line) return fmt.Errorf("Invalid pattern %q in ignore file", line)
} }
@ -228,13 +228,13 @@ func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) ([]
} else { } else {
// Path name or pattern, add it so it matches files both in // Path name or pattern, add it so it matches files both in
// current directory and subdirs. // current directory and subdirs.
exp, err := fnmatch.Convert(line, fnmatch.FNM_PATHNAME) exp, err := fnmatch.Convert(line, fnmatch.PathName)
if err != nil { if err != nil {
return fmt.Errorf("Invalid pattern %q in ignore file", line) return fmt.Errorf("Invalid pattern %q in ignore file", line)
} }
patterns = append(patterns, Pattern{exp, include}) patterns = append(patterns, Pattern{exp, include})
exp, err = fnmatch.Convert("**/"+line, fnmatch.FNM_PATHNAME) exp, err = fnmatch.Convert("**/"+line, fnmatch.PathName)
if err != nil { if err != nil {
return fmt.Errorf("Invalid pattern %q in ignore file", line) return fmt.Errorf("Invalid pattern %q in ignore file", line)
} }