Add a recursive function to the glob package

Lib/glob.py

 """Filename globbing utility."""
 
 import os
 import re
 import fnmatch
 
 __all__ = ["glob", "iglob"]
+
 
 def glob(pathname):
     """Return a list of paths matching a pathname pattern.
 
     The pattern may contain simple shell-style wildcards a la fnmatch.
 

[storchaka, 2012/11/04 18:43:53]

The pattern may also contain '**' to denote a recursion root.

     """
     return list(iglob(pathname))
 
+
 def iglob(pathname):
+    """Return an iterator which yields the paths matching a pathname pattern.
+
+    The pattern may contain simple shell-style wildcards a la fnmatch.
+
+    The pattern may also contain '**' to denote a recursion root.
+
+    """
+    if '**' in pathname:
+        # More than one appearance of '**' is redundant as we would
+        # walk there anyway
+        recurse_root, pattern = pathname.split('**', 1)

[storchaka, 2012/11/04 18:43:53]

What if ** happened inside a component name? I.e. 'a**b'.

+        recurse_root += '*/'
+        recurse_dirs = _glob_simple(recurse_root)
+        for path in recurse_dirs:
+            # Cases:
+            # pattern is '', prefix a '*' to match anything
+            # pattern is 'asdf/*asdf**/asdf', prefix a '*' to match any base
+            # path.
+            # pattern is '/asdf', in this case we started with 'base**/asdf' so
+            # we don't want to require a level of separation
+            # like 'base/*/asdf'.
+            pattern = '*' + pattern.lstrip('/')

[storchaka, 2012/11/04 18:43:53]

This can be moved outside a loop.

+            yield from _rglob(os.path.join(path, pattern), path)
+    else:
+        yield from _glob_simple(pathname)
+
+
+def _glob_simple(pathname):
     """Return an iterator which yields the paths matching a pathname pattern.
 
     The pattern may contain simple shell-style wildcards a la fnmatch.
 
     """
     if not has_magic(pathname):
         if os.path.lexists(pathname):
             yield pathname
         return
     dirname, basename = os.path.split(pathname)
     if not dirname:
-        for name in glob1(None, basename):
+        for name in _listdir_pattern(None, basename):
             yield name
         return
     if has_magic(dirname):
-        dirs = iglob(dirname)
+        dirs = _glob_simple(dirname)
     else:
         dirs = [dirname]
     if has_magic(basename):
-        glob_in_dir = glob1
+        glob_in_dir = _listdir_pattern
     else:
-        glob_in_dir = glob0
+        glob_in_dir = _listdir_basename
     for dirname in dirs:
         for name in glob_in_dir(dirname, basename):
             yield os.path.join(dirname, name)
 
-# These 2 helper functions non-recursively glob inside a literal directory.

[storchaka, 2012/11/04 18:43:53]

Why are you removed this comment?

-# They return a list of basenames. `glob1` accepts a pattern while `glob0`
-# takes a literal basename (so it only has to check for its existence).
 
-def glob1(dirname, pattern):
+def _rglob(pattern, dirbase):
+    """Recursively walk dirbase and yield pattern matches"""
+    for root, dirnames, filenames in os.walk(dirbase):
+        for fname in filenames:
+            fullpath = os.path.normpath(os.path.join(root, fname))

[storchaka, 2012/11/04 18:43:53]

os.path.normpath('///etc') is '/etc', but glob.glob('///etc/*/') preserves
initial slashes.  Therefore pattern can contains multiple slashes, but fullpath
does not.

+            if fnmatch.fnmatch(fullpath, pattern):
+                yield fullpath
+
+
+def _listdir_pattern(dirname, pattern):
     if not dirname:
         if isinstance(pattern, bytes):
             dirname = bytes(os.curdir, 'ASCII')
         else:
             dirname = os.curdir
     try:
         names = os.listdir(dirname)
     except os.error:
         return []
     if pattern[0] != '.':
         names = [x for x in names if x[0] != '.']
     return fnmatch.filter(names, pattern)
 
-def glob0(dirname, basename):
+
+def _listdir_basename(dirname, basename):
     if basename == '':
         # `os.path.split()` returns an empty basename for paths ending with a
         # directory separator.  'q*x/' should match only directories.
         if os.path.isdir(dirname):
             return [basename]
     else:
         if os.path.lexists(os.path.join(dirname, basename)):
             return [basename]
     return []
 
 
 magic_check = re.compile('[*?[]')
 magic_check_bytes = re.compile(b'[*?[]')
+
 
 def has_magic(s):
     if isinstance(s, bytes):
         match = magic_check_bytes.search(s)
     else:
         match = magic_check.search(s)
     return match is not None