Rewritten path matching and added unittests.

peteruhnak · peteruhnak · commit 05c1ada51872 · 2012-02-20T19:05:01.000+01:00
diff --git a/git-ftp-test.py b/git-ftp-test.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+#
+import unittest
+
+git_ftp = __import__('git-ftp', globals(), locals(), ['parse_ftpignore', 'is_ignored', 'split_pattern'], -1)
+parse_ftpignore = git_ftp.parse_ftpignore
+is_ignored = git_ftp.is_ignored
+split_pattern = git_ftp.split_pattern
+
+class TestGitFtp(unittest.TestCase):
+    
+    def test_parse_ftpignore(self):
+        patterns = '''
+# comment and blank line
+
+# negate patterns behaviour (not supported)
+!fileX.txt
+# directory match
+config/
+# shell glob (without /)
+*swp
+BasePresenter.php
+# with /
+css/*less
+# beginning of path
+/.htaccess
+        '''
+        self.assertEqual(parse_ftpignore(patterns.split("\n")),
+            ['!fileX.txt', 'config/', '*swp', 'BasePresenter.php', 'css/*less', '/.htaccess']
+        )
+    pass
+
+    def test_split_pattern(self):
+        self.assertEqual(split_pattern('/foo/rand[/]om/dir/'), ['', 'foo\\Z(?ms)', 'rand[/]om\\Z(?ms)', 'dir\\Z(?ms)', '\\Z(?ms)'])
+        self.assertEqual(split_pattern('/ano[/]her/bar/file[.-0]txt'), ['', 'ano[/]her\\Z(?ms)', 'bar\\Z(?ms)', 'file[.-0]txt\\Z(?ms)'])
+        self.assertEqual(split_pattern('left[/right'), ['left\\[\\Z(?ms)', 'right\\Z(?ms)'])
+        self.assertEqual(split_pattern('left[/notright]'), ['left[/notright]\\Z(?ms)'])
+    pass
+    
+    def test_is_ignored(self):
+        self.assertTrue(is_ignored('/foo/bar/', 'bar/'), 'Ending slash matches only dir.')
+        self.assertFalse(is_ignored('/foo/bar', 'bar/'), 'Ending slash matches only dir.')
+        self.assertTrue(is_ignored('/foo/bar/baz', 'bar/'), 'Ending slash matches only dir and path underneath it.')
+
+        self.assertFalse(is_ignored('foo/bar', 'foo?*bar'), 'Slash must be matched explicitly.')
+
+        self.assertTrue(is_ignored('/foo/bar/', 'bar'))
+        self.assertTrue(is_ignored('/foo/bar', 'bar'))
+        self.assertTrue(is_ignored('/foo/bar/baz', 'bar'))
+
+        self.assertTrue(is_ignored('/foo/bar/file.txt', 'bar/*.txt'))
+        self.assertFalse(is_ignored('/foo/bar/file.txt', '/*.txt'), 'Leading slash matches against root dir.')
+        self.assertTrue(is_ignored('/file.txt', '/*.txt'), 'Leading slash matches against root dir.')
+
+        self.assertTrue(is_ignored('/foo/bar/output.o', 'bar/*.[oa]'), 'Character group.')
+        self.assertFalse(is_ignored('/aaa/bbb/ccc', 'aaa/[!b]*'), 'Character ignore.')
+        self.assertTrue(is_ignored('/aaa/bbb/ccc', '[a-z][a-c][!b-d]'), 'Character range.')
+    pass
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/git-ftp.py b/git-ftp.py
@@ -40,6 +40,7 @@
 import optparse
 import logging
 import textwrap
+import fnmatch
 
 # Note about Tree.path/Blob.path: *real* Git trees and blobs don't
 # actually provide path information, but the git-python bindings, as a
@@ -64,68 +65,48 @@ class FtpDataOldVersion(Exception):
 class FtpSslNotSupported(Exception):
     pass
 
-# Unfortunately Python's fnmatch don't support FNM_PATHNAME
-# so we have to roll our own
-class fnmatch2:
-    _cache = {}
-
-    @classmethod
-    def fnmatch(cls, name, pat):
-        name = os.path.normcase(name)
-        pat = os.path.normcase(pat)
-        return cls.fnmatchcase(name, pat)
-
-    @classmethod
-    def fnmatchcase(cls, name, pat):
-        if not pat in cls._cache:
-            res = cls.translate(pat)
-            cls._cache[pat] = re.compile(res)
-        return cls._cache[pat].search(name) is not None
-
-    @classmethod
-    def translate(cls, pat):
-        '''
-        *       matches everything 
-        ?       matches any single character
-        [seq]   matches any character in seq
-        [!seq]  matches any character not in seq
-
-        Slash (/) won't be matched by any wildcard.
-        '''
-        i, n = 0, len(pat)
-        res = ''
-
-        if pat.startswith('/'):
-            res = res + '^/'
-            i = i+1
-        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
+def split_pattern(path):
+    path = fnmatch.translate(path).split('\\/')
+    for i,p in enumerate(path[:-1]):
+        if p:
+            path[i] = p + '\\Z(?ms)'
+    return path
+
+
+def is_ignored(path, regex):
+    regex = split_pattern(os.path.normcase(regex))
+    path = os.path.normcase(path).split('/')
+
+    regex_pos = path_pos = 0
+    if regex[0] == '': # leading slash - root dir must match
+        if path[0] != '' or not re.match(regex[1], path[1]):
+            return False
+        regex_pos = path_pos = 2
+    
+    if not regex_pos: # find beginning of regex
+        for i,p in enumerate(path):
+            if re.match(regex[0], p):
+                regex_pos = 1
+                path_pos = i + 1
+                break
+        else:
+            return False
+    
+    if len(path[path_pos:]) < len(regex[regex_pos:]):
+        return False
+
+    n = len(regex)
+    for r in regex[regex_pos:]: # match the rest
+        if regex_pos + 1 == n: # last item; if empty match anything
+            if re.match(r, ''):
+                return True
+
+        if not re.match(r, path[path_pos]):
+            return False
+        path_pos += 1
+        regex_pos += 1
+    
+    return True
 
 def main():
     Git.git_binary = 'git' # Windows doesn't like env
@@ -420,7 +401,7 @@ def is_ignored_path(path, patterns, quiet = False):
     if is_special_file(path):
         return True
     for pat in patterns:
-        if fnmatch2.fnmatch(path, pat):
+        if is_ignored(path, pat):
             return True
     return False
 
