Import fnmatch translate, so it can be modified.

dulwich/ignore.py

@@ -23,10 +23,56 @@
 # TODO(jelmer): Handle ** in patterns
 # TODO(jelmer): Compile patterns
 
-import fnmatch
+import re
 import posixpath
 
 
+def translate(pat):
+    """Translate a shell PATTERN to a regular expression.
+
+    There is no way to quote meta-characters.
+
+    Originally copied from fnmatch in Python 2.7.
+    """
+
+    res = ''
+
+    if not '/' in pat:
+        res = '(.*\/)?'
+
+    pat = pat.lstrip('/')
+    i, n = 0, len(pat)
+
+    while i < n:
+        c = pat[i]
+        i = i+1
+        if c == '*':
+            res = res + '.*'
+        elif c == '?':
+            res = res + '.'
+        elif c == '[':
+            j = i
+            if j < n and pat[j] == '!':
+                j = j+1
+            if j < n and pat[j] == ']':
+                j = j+1
+            while j < n and pat[j] != ']':
+                j = j+1
+            if j >= n:
+                res = res + '\\['
+            else:
+                stuff = pat[i:j].replace('\\','\\\\')
+                i = j+1
+                if stuff[0] == '!':
+                    stuff = '^' + stuff[1:]
+                elif stuff[0] == '^':
+                    stuff = '\\' + stuff
+                res = '%s[%s]' % (res, stuff)
+        else:
+            res = res + re.escape(c)
+    return res + '\Z(?ms)'
+
+
 def read_ignore_patterns(f):
     """Read a git ignore file.
 
@@ -60,10 +106,10 @@ def match_pattern(path, pattern):
     :param pattern: Pattern to match
     :return: bool indicating whether the pattern matched
     """
+    re_pattern = translate(pattern)
     if b'/' not in pattern:
-        return fnmatch.fnmatch(posixpath.basename(path), pattern)
-    pattern = pattern.lstrip(b'/')
-    return fnmatch.fnmatch(path, pattern)
+        return re.match(re_pattern, posixpath.basename(path))
+    return re.match(re_pattern, path)
 
 
 class IgnoreFilter(object):

dulwich/tests/test_ignore.py

@@ -27,6 +27,7 @@ from dulwich.ignore import (
     IgnoreFilter,
     match_pattern,
     read_ignore_patterns,
+    translate,
     )
 
 
@@ -46,12 +47,31 @@ POSITIVE_MATCH_TESTS = [
 NEGATIVE_MATCH_TESTS = [
     ("foo.c", "foo.[dh]"),
     ("foo/foo.c", "/foo.c"),
+    ("foo/foo.c", "/*.c"),
 ]
 
 
-KNOWNFAIL_NEGATIVE_MATCH_TESTS = [
-    ("foo/foo.c", "/*.c"),
-    ]
+TRANSLATE_TESTS = [
+    ("*.c", '[^\\/]+\\.c$(?ms)'),
+    ("foo.c", 'foo\\.c$(?ms)'),
+    ("/*.c", '\\/[^\\/]+\\.c$(?ms)'),
+    ("/foo.c", '\\/foo\\.c$(?ms)'),
+    ("foo.c", 'foo\\.c$(?ms)'),
+    ("foo.[ch]",  'foo\\.[ch]$(?ms)'),
+    ("foo/**", 'foo\\/.*?$(?ms)'),
+    ("foo/**/blie.c", 'foo\\/.*?\\/blie\\.c$(?ms)'),
+    ("**/bla.c", '.*?\\/bla\\.c$(?ms)'),
+]
+
+
+class TranslateTests(unittest.TestCase):
+
+    def test_translate(self):
+        for (pattern, regex) in TRANSLATE_TESTS:
+            self.assertEqual(
+                regex, translate(pattern),
+                "orig pattern: %r, regex: %r, expected: %r" %
+                (pattern, translate(pattern), regex))
 
 
 class ReadIgnorePatterns(unittest.TestCase):
@@ -100,3 +120,4 @@ class IgnoreFilterTests(unittest.TestCase):
     def test_excluded(self):
         filter = IgnoreFilter(['a.c', 'b.c', '!c.c'])
         self.assertFalse(filter.is_ignored('c.c'))
+        self.assertIs(None, filter.is_ignored('d.c'))