diff --git a/fnmatch/fnmatch.py b/fnmatch/fnmatch.py index e69de29b..6330b0cf 100644 --- a/fnmatch/fnmatch.py +++ b/fnmatch/fnmatch.py @@ -0,0 +1,109 @@ +"""Filename matching with shell patterns. + +fnmatch(FILENAME, PATTERN) matches according to the local convention. +fnmatchcase(FILENAME, PATTERN) always takes case in account. + +The functions operate by translating the pattern into a regular +expression. They cache the compiled regular expressions for speed. + +The function translate(PATTERN) returns a regular expression +corresponding to PATTERN. (It does not compile it.) +""" +import os +import posixpath +import re +import functools + +__all__ = ["filter", "fnmatch", "fnmatchcase", "translate"] + +def fnmatch(name, pat): + """Test whether FILENAME matches PATTERN. + + Patterns are Unix shell style: + + * matches everything + ? matches any single character + [seq] matches any character in seq + [!seq] matches any char not in seq + + An initial period in FILENAME is not special. + Both FILENAME and PATTERN are first case-normalized + if the operating system requires it. + If you don't want this, use fnmatchcase(FILENAME, PATTERN). + """ + name = os.path.normcase(name) + pat = os.path.normcase(pat) + return fnmatchcase(name, pat) + +@functools.lru_cache(maxsize=256, typed=True) +def _compile_pattern(pat): + if isinstance(pat, bytes): + pat_str = str(pat, 'ISO-8859-1') + res_str = translate(pat_str) + res = bytes(res_str, 'ISO-8859-1') + else: + res = translate(pat) + return re.compile(res).match + +def filter(names, pat): + """Return the subset of the list NAMES that match PAT.""" + result = [] + pat = os.path.normcase(pat) + match = _compile_pattern(pat) + if os.path is posixpath: + # normcase on posix is NOP. Optimize it away from the loop. + for name in names: + if match(name): + result.append(name) + else: + for name in names: + if match(os.path.normcase(name)): + result.append(name) + return result + +def fnmatchcase(name, pat): + """Test whether FILENAME matches PATTERN, including case. + + This is a version of fnmatch() which doesn't case-normalize + its arguments. + """ + match = _compile_pattern(pat) + return match(name) is not None + + +def translate(pat): + """Translate a shell PATTERN to a regular expression. + + There is no way to quote meta-characters. + """ + + i, n = 0, len(pat) + res = '' + 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)' diff --git a/fnmatch/test_fnmatch.py b/fnmatch/test_fnmatch.py new file mode 100644 index 00000000..482835d4 --- /dev/null +++ b/fnmatch/test_fnmatch.py @@ -0,0 +1,89 @@ +"""Test cases for the fnmatch module.""" + +from test import support +import unittest + +from fnmatch import fnmatch, fnmatchcase, translate, filter + +class FnmatchTestCase(unittest.TestCase): + + def check_match(self, filename, pattern, should_match=1, fn=fnmatch): + if should_match: + self.assertTrue(fn(filename, pattern), + "expected %r to match pattern %r" + % (filename, pattern)) + else: + self.assertTrue(not fn(filename, pattern), + "expected %r not to match pattern %r" + % (filename, pattern)) + + def test_fnmatch(self): + check = self.check_match + check('abc', 'abc') + check('abc', '?*?') + check('abc', '???*') + check('abc', '*???') + check('abc', '???') + check('abc', '*') + check('abc', 'ab[cd]') + check('abc', 'ab[!de]') + check('abc', 'ab[de]', 0) + check('a', '??', 0) + check('a', 'b', 0) + + # these test that '\' is handled correctly in character sets; + # see SF bug #409651 + check('\\', r'[\]') + check('a', r'[!\]') + check('\\', r'[!\]', 0) + + # test that filenames with newlines in them are handled correctly. + # http://bugs.python.org/issue6665 + check('foo\nbar', 'foo*') + check('foo\nbar\n', 'foo*') + check('\nfoo', 'foo*', False) + check('\n', '*') + + def test_mix_bytes_str(self): + self.assertRaises(TypeError, fnmatch, 'test', b'*') + self.assertRaises(TypeError, fnmatch, b'test', '*') + self.assertRaises(TypeError, fnmatchcase, 'test', b'*') + self.assertRaises(TypeError, fnmatchcase, b'test', '*') + + def test_fnmatchcase(self): + check = self.check_match + check('AbC', 'abc', 0, fnmatchcase) + check('abc', 'AbC', 0, fnmatchcase) + + def test_bytes(self): + self.check_match(b'test', b'te*') + self.check_match(b'test\xff', b'te*\xff') + self.check_match(b'foo\nbar', b'foo*') + +class TranslateTestCase(unittest.TestCase): + + def test_translate(self): + self.assertEqual(translate('*'), '.*\Z(?ms)') + self.assertEqual(translate('?'), '.\Z(?ms)') + self.assertEqual(translate('a?b*'), 'a.b.*\Z(?ms)') + self.assertEqual(translate('[abc]'), '[abc]\Z(?ms)') + self.assertEqual(translate('[]]'), '[]]\Z(?ms)') + self.assertEqual(translate('[!x]'), '[^x]\Z(?ms)') + self.assertEqual(translate('[^x]'), '[\\^x]\Z(?ms)') + self.assertEqual(translate('[x'), '\\[x\Z(?ms)') + + +class FilterTestCase(unittest.TestCase): + + def test_filter(self): + self.assertEqual(filter(['a', 'b'], 'a'), ['a']) + + +def test_main(): + support.run_unittest(FnmatchTestCase, + TranslateTestCase, + FilterTestCase) + + +if __name__ == "__main__": + test_main()