Add support for include_hidden=False

python · barneygale · Nov 13, 2023 · Jun 18, 2023 · Jul 13, 2023 · Jul 13, 2023
commit 2505590e77dd7ebe56546b4fcdaafb63f1177834
diff --git a/Doc/library/glob.rst b/Doc/library/glob.rst
@@ -146,7 +146,7 @@ default. For example, consider a directory containing :file:`card.gif` and
    ['.card.gif']
 
 
-.. function:: translate(pathname, *, recursive=False, seps=None)
+.. function:: translate(pathname, *, recursive=False, include_hidden=False, seps=None)
 
    Convert the given path specification to a regular expression for use with
    :func:`re.match`. The path specification can contain shell-style wildcards.
@@ -155,7 +155,7 @@ default. For example, consider a directory containing :file:`card.gif` and
 
       >>> import glob, re
       >>>
-      >>> regex = glob.translate('**/*.txt', recursive=True)
+      >>> regex = glob.translate('**/*.txt', recursive=True, include_hidden=True)
       >>> regex
       '(?s:(?:.*/)?[^/]*\\.txt)\\Z'
       >>> reobj = re.compile(regex)
@@ -170,14 +170,12 @@ default. For example, consider a directory containing :file:`card.gif` and
    of path segments. If "``**``" occurs in any position other than a full
    pattern segment, :exc:`ValueError` is raised.
 
+   If *include_hidden* is true, wildcards can match path segments that start
+   with a dot (``.``).
+
    A sequence of path separators may be supplied to the *seps* argument. If
    not given, :data:`os.sep` and :data:`~os.altsep` (if available) are used.
 
-   .. note::
-
-      Filenames that begin with a dot (``.``) are matched by wildcards, unlike
-      :func:`glob`.
-
    .. seealso::
 
      :meth:`pathlib.PurePath.match` and :meth:`pathlib.Path.glob` methods,

diff --git a/Lib/glob.py b/Lib/glob.py
@@ -251,19 +251,19 @@ def escape(pathname):
 _dir_open_flags = os.O_RDONLY | getattr(os, 'O_DIRECTORY', 0)
 
 
-def translate(pat, *, recursive=False, seps=None):
+def translate(pat, *, recursive=False, include_hidden=False, seps=None):
     """Translate a pathname with shell wildcards to a regular expression.
 
     If `recursive` is true, the pattern segment '**' will match any number of
     path segments; if '**' appears outside its own segment, ValueError will be
     raised.
 
+    If `include_hidden` is true, wildcards can match path segments beginning
+    with a dot ('.').
+
     If a sequence of separator characters is given to `seps`, they will be
     used to split the pattern into segments and match path separators. If not
     given, os.path.sep and os.path.altsep (where available) are used.
-
-    Filenames beginning with a dot ('.') are NOT special in this method; they
-    are matched by wildcards, unlike in glob().
     """
     if not seps:
         if os.path.altsep:
@@ -273,9 +273,12 @@ def translate(pat, *, recursive=False, seps=None):
     escaped_seps = ''.join(re.escape(sep) for sep in seps)
     any_sep = f'[{escaped_seps}]' if len(seps) > 1 else escaped_seps
     not_sep = f'[^{escaped_seps}]'
+    not_dot = r'(?!\.)'
     res = []
     add = res.append
     i, n = 0, len(pat)
+    if pat[:1] != '.' and not include_hidden:
+        add(not_dot)
     while i < n:
         c = pat[i]
         i = i+1
@@ -292,14 +295,25 @@ def translate(pat, *, recursive=False, seps=None):
                     add(f'{not_sep}*')
             elif star_count == 2 and is_segment:
                 if i == n:
-                    add('.*')
+                    if include_hidden:
+                        add('.*')
+                    else:
+                        add(fr'(?:{not_dot}{not_sep}+{any_sep})*{not_dot}{not_sep}*')
                 else:
-                    add(f'(?:.*{any_sep})?')
-                    i = i+1
+                    if include_hidden:
+                        add(f'(?:.+{any_sep})?')
+                        i = i+1
+                    else:
+                        add(fr'(?:{not_dot}{not_sep}+{any_sep})*')
+                        i = i+1
+                        if i < n and pat[i] != '.':
+                            add(not_dot)
             else:
                 raise ValueError("Invalid pattern: '**' can only be an entire path component")
         elif c in seps:
             add(any_sep)
+            if i < n and pat[i] != '.' and not include_hidden:
+                add(not_dot)
         elif c == '?':
             add(not_sep)
         elif c == '[':

diff --git a/Lib/pathlib.py b/Lib/pathlib.py
@@ -69,7 +69,7 @@ def _compile_pattern(pat, sep, case_sensitive):
     """Compile given glob pattern to a re.Pattern object (observing case
     sensitivity)."""
     flags = re.NOFLAG if case_sensitive else re.IGNORECASE
-    regex = glob.translate(pat, recursive=True, seps=sep)
+    regex = glob.translate(pat, recursive=True, include_hidden=True, seps=sep)
     return re.compile(regex, flags).match
 
 

diff --git a/Lib/test/test_glob.py b/Lib/test/test_glob.py
@@ -1,5 +1,6 @@
 import glob
 import os
+import re
 import shutil
 import sys
 import unittest
@@ -349,9 +350,43 @@ def test_glob_many_open_files(self):
             for it in iters:
                 self.assertEqual(next(it), p)
 
+
     def test_translate(self):
+        match = re.compile(glob.translate('*')).match
+        self.assertIsNotNone(match('foo'))
+        self.assertIsNotNone(match('foo.bar'))
+        self.assertIsNone(match('.foo'))
+        match = re.compile(glob.translate('.*')).match
+        self.assertIsNotNone(match('.foo'))
+        match = re.compile(glob.translate('**', recursive=True)).match
+        self.assertIsNotNone(match('foo'))
+        self.assertIsNone(match('.foo'))
+        self.assertIsNotNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', 'bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('**/*', recursive=True)).match
+        self.assertIsNotNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', 'bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('*/**', recursive=True)).match
+        self.assertIsNotNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', 'bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('**/.bar', recursive=True)).match
+        self.assertIsNotNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('**/*.*', recursive=True)).match
+        self.assertIsNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNotNone(match(os.path.join('foo', 'bar.txt')))
+        self.assertIsNone(match(os.path.join('foo', '.bar.txt')))
+
+    def test_translate_include_hidden(self):
         def fn(pat):
-            return glob.translate(pat, seps='/')
+            return glob.translate(pat, include_hidden=True, seps='/')
         self.assertEqual(fn('foo'), r'(?s:foo)\Z')
         self.assertEqual(fn('foo/bar'), r'(?s:foo/bar)\Z')
         self.assertEqual(fn('*'), r'(?s:[^/]+)\Z')
@@ -370,20 +405,21 @@ def fn(pat):
 
     def test_translate_recursive(self):
         def fn(pat):
-            return glob.translate(pat, recursive=True, seps='/')
+            return glob.translate(pat, recursive=True, include_hidden=True, seps='/')
         self.assertEqual(fn('*'), r'(?s:[^/]+)\Z')
         self.assertEqual(fn('?'), r'(?s:[^/])\Z')
         self.assertEqual(fn('**'), r'(?s:.*)\Z')
         self.assertRaises(ValueError, fn, '***')
         self.assertRaises(ValueError, fn, 'a**')
         self.assertRaises(ValueError, fn, '**b')
-        self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/(?:.*/)?[^/]+/[^/]*\.[^/]*/.*)\Z')
+        self.assertEqual(fn('/**/*/*.*/**'), r'(?s:/(?:.+/)?[^/]+/[^/]*\.[^/]*/.*)\Z')
 
     def test_translate_seps(self):
         def fn(pat):
-            return glob.translate(pat, recursive=True, seps=['/', '\\'])
+            return glob.translate(pat, recursive=True, include_hidden=True, seps=['/', '\\'])
         self.assertEqual(fn('foo/bar\\baz'), r'(?s:foo[/\\]bar[/\\]baz)\Z')
-        self.assertEqual(fn('**/**'), r'(?s:(?:.*[/\\])?.*)\Z')
+        self.assertEqual(fn('**/**'), r'(?s:(?:.+[/\\])?.*)\Z')
+
 
 @skip_unless_symlink
 class SymlinkLoopGlobTests(unittest.TestCase):