Reverted the change of fs.wildcard that was done to introduce the *_glob parameters.

Instead, fs.glob was extended to offer the same functionality.

Author: atollk

fs/base.py

@@ -21,7 +21,7 @@
 
 import six
 
-from . import copy, errors, fsencode, iotools, move, tools, walk, wildcard
+from . import copy, errors, fsencode, iotools, move, tools, walk, wildcard, glob
 from .copy import copy_modified_time
 from .glob import BoundGlobber
 from .mode import validate_open_mode
@@ -1658,6 +1658,49 @@ def match(self, patterns, name, accept_prefix=False):
         be case sensitive (``*.py`` and ``*.PY`` will match different
         names).
 
+        Arguments:
+            patterns (list, optional): A list of patterns, e.g.
+                ``['*.py']``, or `None` to match everything.
+            name (str): A file or directory name (not a path)
+
+        Returns:
+            bool: `True` if ``name`` matches any of the patterns.
+
+        Raises:
+            TypeError: If ``patterns`` is a single string instead of
+                a list (or `None`).
+
+        Example:
+            >>> my_fs.match(['*.py'], '__init__.py')
+            True
+            >>> my_fs.match(['*.jpg', '*.png'], 'foo.gif')
+            False
+
+        Note:
+            If ``patterns`` is `None` (or ``['*']``), then this
+            method will always return `True`.
+
+        """
+        if patterns is None:
+            return True
+        if isinstance(patterns, six.text_type):
+            raise TypeError("patterns must be a list or sequence")
+        case_sensitive = not typing.cast(
+            bool, self.getmeta().get("case_insensitive", False)
+        )
+        matcher = wildcard.get_matcher(patterns, case_sensitive)
+        return matcher(name)
+
+    def match_glob(self, patterns, name, accept_prefix=False):
+        # type: (Optional[Iterable[Text]], Text, bool) -> bool
+        """Check if a path matches any of a list of glob patterns.
+
+        If a filesystem is case *insensitive* (such as Windows) then
+        this method will perform a case insensitive match (i.e. ``*.py``
+        will match the same names as ``*.PY``). Otherwise the match will
+        be case sensitive (``*.py`` and ``*.PY`` will match different
+        names).
+
         Arguments:
             patterns (list, optional): A list of patterns, e.g.
                 ``['*.py']``, or `None` to match everything.
@@ -1674,13 +1717,13 @@ def match(self, patterns, name, accept_prefix=False):
                 a list (or `None`).
 
         Example:
-            >>> my_fs.match(['*.py'], '__init__.py')
+            >>> my_fs.match_glob(['*.py'], '__init__.py')
             True
-            >>> my_fs.match(['*.jpg', '*.png'], 'foo.gif')
+            >>> my_fs.match_glob(['*.jpg', '*.png'], 'foo.gif')
             False
-            >>> my_fs.match(['dir/file.txt'], 'dir/', accept_prefix=True)
+            >>> my_fs.match_glob(['dir/file.txt'], 'dir/', accept_prefix=True)
             True
-            >>> my_fs.match(['dir/file.txt'], 'dir/gile.txt', accept_prefix=True)
+            >>> my_fs.match_glob(['dir/file.txt'], 'dir/gile.txt', accept_prefix=True)
             False
 
         Note:
@@ -1695,7 +1738,7 @@ def match(self, patterns, name, accept_prefix=False):
         case_sensitive = not typing.cast(
             bool, self.getmeta().get("case_insensitive", False)
         )
-        matcher = wildcard.get_matcher(
+        matcher = glob.get_matcher(
             patterns, case_sensitive, accept_prefix=accept_prefix
         )
         return matcher(name)

fs/glob.py

@@ -6,6 +6,7 @@
 from collections import namedtuple
 import re
 import typing
+from functools import partial
 
 from .lrucache import LRUCache
 from ._repr import make_repr
@@ -17,7 +18,16 @@
 LineCounts = namedtuple("LineCounts", ["lines", "non_blank"])
 
 if typing.TYPE_CHECKING:
-    from typing import Iterator, List, Optional, Pattern, Text, Tuple
+    from typing import (
+        Iterator,
+        List,
+        Optional,
+        Pattern,
+        Text,
+        Tuple,
+        Iterable,
+        Callable,
+    )
     from .base import FS
 
 
@@ -26,6 +36,26 @@
 )  # type: LRUCache[Tuple[Text, bool], Tuple[int, bool, Pattern]]
 
 
+def _split_pattern_by_rec(pattern):
+    # type: (Text) -> List[Text]
+    """Split a glob pattern at its directory seperators (/).
+
+    Takes into account escaped cases like [/].
+    """
+    indices = [-1]
+    bracket_open = False
+    for i, c in enumerate(pattern):
+        if c == "/" and not bracket_open:
+            indices.append(i)
+        elif c == "[":
+            bracket_open = True
+        elif c == "]":
+            bracket_open = False
+
+    indices.append(len(pattern))
+    return [pattern[i + 1 : j] for i, j in zip(indices[:-1], indices[1:])]
+
+
 def _translate(pattern, case_sensitive=True):
     # type: (Text, bool) -> Text
     """Translate a wildcard pattern to a regular expression.
@@ -43,14 +73,14 @@ def _translate(pattern, case_sensitive=True):
     if not case_sensitive:
         pattern = pattern.lower()
     i, n = 0, len(pattern)
-    res = ""
+    res = []
     while i < n:
         c = pattern[i]
         i = i + 1
         if c == "*":
-            res = res + "[^/]*"
+            res.append("[^/]*")
         elif c == "?":
-            res = res + "."
+            res.append("[^/]")
         elif c == "[":
             j = i
             if j < n and pattern[j] == "!":
@@ -60,28 +90,30 @@ def _translate(pattern, case_sensitive=True):
             while j < n and pattern[j] != "]":
                 j = j + 1
             if j >= n:
-                res = res + "\\["
+                res.append("\\[")
             else:
                 stuff = pattern[i:j].replace("\\", "\\\\")
                 i = j + 1
                 if stuff[0] == "!":
                     stuff = "^" + stuff[1:]
                 elif stuff[0] == "^":
                     stuff = "\\" + stuff
-                res = "%s[%s]" % (res, stuff)
+                res.append("[%s]" % stuff)
         else:
-            res = res + re.escape(c)
-    return res
+            res.append(re.escape(c))
+    return "".join(res)
 
 
 def _translate_glob(pattern, case_sensitive=True):
     levels = 0
     recursive = False
     re_patterns = [""]
     for component in iteratepath(pattern):
-        if component == "**":
-            re_patterns.append(".*/?")
+        if "**" in component:
             recursive = True
+            split = component.split("**")
+            split_re = [_translate(s, case_sensitive=case_sensitive) for s in split]
+            re_patterns.append("/?" + ".*/?".join(split_re))
         else:
             re_patterns.append(
                 "/" + _translate(component, case_sensitive=case_sensitive)
@@ -141,6 +173,88 @@ def imatch(pattern, path):
     return bool(re_pattern.match(path))
 
 
+def match_any(patterns, path):
+    # type: (Iterable[Text], Text) -> bool
+    """Test if a path matches any of a list of patterns.
+
+    Will return `True` if ``patterns`` is an empty list.
+
+    Arguments:
+        patterns (list): A list of wildcard pattern, e.g ``["*.py",
+            "*.pyc"]``
+        name (str): A filename.
+
+    Returns:
+        bool: `True` if the path matches at least one of the patterns.
+
+    """
+    if not patterns:
+        return True
+    return any(match(pattern, path) for pattern in patterns)
+
+
+def imatch_any(patterns, path):
+    # type: (Iterable[Text], Text) -> bool
+    """Test if a path matches any of a list of patterns (case insensitive).
+
+    Will return `True` if ``patterns`` is an empty list.
+
+    Arguments:
+        patterns (list): A list of wildcard pattern, e.g ``["*.py",
+            "*.pyc"]``
+        name (str): A filename.
+
+    Returns:
+        bool: `True` if the path matches at least one of the patterns.
+
+    """
+    if not patterns:
+        return True
+    return any(imatch(pattern, path) for pattern in patterns)
+
+
+def get_matcher(patterns, case_sensitive, accept_prefix=False):
+    # type: (Iterable[Text], bool, bool) -> Callable[[Text], bool]
+    """Get a callable that matches paths against the given patterns.
+
+    Arguments:
+        patterns (list): A list of wildcard pattern. e.g. ``["*.py",
+            "*.pyc"]``
+        case_sensitive (bool): If ``True``, then the callable will be case
+            sensitive, otherwise it will be case insensitive.
+        accept_prefix (bool): If ``True``, the name is
+            not required to match the wildcards themselves
+            but only need to be a prefix of a string that does.
+
+    Returns:
+        callable: a matcher that will return `True` if the paths given as
+        an argument matches any of the given patterns.
+
+    Example:
+        >>> from fs import wildcard
+        >>> is_python = wildcard.get_matcher(['*.py'], True)
+        >>> is_python('__init__.py')
+        True
+        >>> is_python('foo.txt')
+        False
+
+    """
+    if not patterns:
+        return lambda name: True
+
+    if accept_prefix:
+        new_patterns = []
+        for pattern in patterns:
+            split = _split_pattern_by_rec(pattern)
+            for i in range(len(split)):
+                new_pattern = "/".join(split[: i + 1])
+                new_patterns.append(new_pattern)
+        patterns = new_patterns
+
+    matcher = match_any if case_sensitive else imatch_any
+    return partial(matcher, patterns)
+
+
 class Globber(object):
     """A generator of glob results."""
 

fs/walk.py

@@ -218,13 +218,13 @@ def _check_open_dir(self, fs, path, info):
         full_path = ("" if path == "/" else path) + "/" + info.name
         if self.exclude_dirs is not None and fs.match(self.exclude_dirs, info.name):
             return False
-        if self.exclude_glob is not None and fs.match(self.exclude_glob, full_path):
-            return False
-        if self.filter_dirs is not None and not fs.match(
-            self.filter_dirs, info.name, accept_prefix=True
+        if self.exclude_glob is not None and fs.match_glob(
+            self.exclude_glob, full_path
         ):
             return False
-        if self.filter_glob is not None and not fs.match(
+        if self.filter_dirs is not None and not fs.match(self.filter_dirs, info.name):
+            return False
+        if self.filter_glob is not None and not fs.match_glob(
             self.filter_glob, full_path, accept_prefix=True
         ):
             return False
@@ -281,13 +281,13 @@ def _check_file(self, fs, dir_path, info):
         if Walker._check_file == type(self)._check_file:
             if self.exclude is not None and fs.match(self.exclude, info.name):
                 return False
-            if self.exclude_glob is not None and fs.match(
+            if self.exclude_glob is not None and fs.match_glob(
                 self.exclude_glob, dir_path + "/" + info.name
             ):
                 return False
             if self.filter is not None and not fs.match(self.filter, info.name):
                 return False
-            if self.filter_glob is not None and not fs.match(
+            if self.filter_glob is not None and not fs.match_glob(
                 self.filter_glob, dir_path + "/" + info.name, accept_prefix=True
             ):
                 return False