refactor: some optimization in searching files

Author: d-biehl

packages/core/src/robotcode/core/utils/glob_path.py

@@ -6,23 +6,19 @@
 import os
 import re
 from pathlib import Path, PurePath
-from typing import Any, Iterable, Iterator, Sequence, Tuple, Union, cast
+from typing import Any, Iterable, Iterator, Optional, Sequence, Union, cast
 
 
-def _glob_pattern_to_re(pattern: str) -> Tuple[str, bool]:
+def _glob_pattern_to_re(pattern: str) -> str:
     result = "(?ms)^"
 
     in_group = False
-    only_dirs = False
 
     i = 0
     while i < len(pattern):
         c = pattern[i]
         if c in "\\/$^+.()=!|":
-            if c == "/" and i == len(pattern) - 1:
-                only_dirs = True
-            else:
-                result += "\\" + c
+            result += "\\" + c
         elif c == "?":
             result += "."
         elif c in "[]":
@@ -64,26 +60,40 @@ def _glob_pattern_to_re(pattern: str) -> Tuple[str, bool]:
 
     result += "$"
 
-    return result, only_dirs
+    return result
 
 
 @functools.lru_cache(maxsize=256)
-def _compile_glob_pattern(pattern: str) -> Tuple[re.Pattern[str], bool]:
-    re_pattern, only_dirs = _glob_pattern_to_re(pattern)
-    return re.compile(re_pattern), only_dirs
+def _compile_glob_pattern(pattern: str) -> re.Pattern[str]:
+    return re.compile(_glob_pattern_to_re(pattern))
 
 
 class Pattern:
     def __init__(self, pattern: str) -> None:
-        self.pattern = pattern
-        self._re_pattern, self.only_dirs = _compile_glob_pattern(pattern)
+        pattern = pattern.strip()
+
+        self.only_dirs = pattern.endswith("/")
+
+        path = PurePath(pattern)
+        if path.is_absolute():
+            self.pattern = path.relative_to(path.anchor).as_posix()
+        else:
+            self.pattern = path.as_posix()
+
+        if "*" in self.pattern or "?" in self.pattern or "[" in self.pattern or "{" in self.pattern:
+            self.re_pattern: Optional[re.Pattern[str]] = _compile_glob_pattern(self.pattern)
+        else:
+            self.re_pattern = None
 
     def matches(self, path: Union[PurePath, str, os.PathLike[str]]) -> bool:
         if isinstance(path, PurePath):
             path = path.as_posix()
         else:
             path = str(os.fspath(path))
-        return self._re_pattern.fullmatch(path) is not None
+        if self.re_pattern is None:
+            return path == self.pattern
+
+        return self.re_pattern.fullmatch(path) is not None
 
     def __str__(self) -> str:
         return self.pattern
@@ -104,56 +114,66 @@ def _is_hidden(entry: os.DirEntry[str]) -> bool:
         return True
 
     if os.name == "nt" and (
-        entry.stat().st_file_attributes & 2 != 0 or entry.name.startswith("$")  # type: ignore[attr-defined]
+        (not entry.is_symlink() and entry.stat().st_file_attributes & 2 != 0)  # type: ignore[attr-defined]
+        or entry.name.startswith("$")
     ):
         return True
 
     return False
 
 
 def iter_files(
-    path: Union[Path, str, os.PathLike[str]],
+    path: Union[PurePath, str, os.PathLike[str]],
     patterns: Union[Sequence[Union[Pattern, str]], Pattern, str, None] = None,
     ignore_patterns: Union[Sequence[Union[Pattern, str]], Pattern, str, None] = None,
     *,
     include_hidden: bool = False,
     absolute: bool = False,
-    _base_path: Union[Path, str, os.PathLike[str], None] = None,
 ) -> Iterator[Path]:
-    if not isinstance(path, Path):
-        path = Path(path or ".")
-
-    if _base_path is None:
-        _base_path = path
-    else:
-        if not isinstance(_base_path, Path):
-            path = Path(_base_path)
+    if not isinstance(path, PurePath):
+        path = PurePath(path or ".")
 
     if patterns is not None and isinstance(patterns, (str, Pattern)):
         patterns = [patterns]
-    if patterns is not None:
-        patterns = [p if isinstance(p, Pattern) else Pattern(p) for p in patterns]
 
     if ignore_patterns is not None and isinstance(ignore_patterns, (str, Pattern)):
         ignore_patterns = [ignore_patterns]
-    if ignore_patterns is not None:
-        ignore_patterns = [p if isinstance(p, Pattern) else Pattern(p) for p in ignore_patterns]
 
+    yield from _iter_files_recursive_re(
+        path=path,
+        patterns=[] if patterns is None else [p if isinstance(p, Pattern) else Pattern(p) for p in patterns],
+        ignore_patterns=[]
+        if ignore_patterns is None
+        else [p if isinstance(p, Pattern) else Pattern(p) for p in ignore_patterns],
+        include_hidden=include_hidden,
+        absolute=absolute,
+        _base_path=path,
+    )
+
+
+def _iter_files_recursive_re(
+    path: PurePath,
+    patterns: Sequence[Pattern],
+    ignore_patterns: Sequence[Pattern],
+    include_hidden: bool,
+    absolute: bool,
+    _base_path: PurePath,
+) -> Iterator[Path]:
     try:
         with os.scandir(path) as it:
             for f in it:
                 if not include_hidden and _is_hidden(f):
                     continue
 
-                relative_path = path / f.name
+                relative_path = (path / f.name).relative_to(_base_path)
 
                 if not ignore_patterns or not any(
                     p.matches(relative_path) and (not p.only_dirs or p.only_dirs and f.is_dir())
                     for p in cast(Iterable[Pattern], ignore_patterns)
                 ):
                     if f.is_dir():
-                        yield from iter_files(
-                            f,
+                        yield from _iter_files_recursive_re(
+                            PurePath(f),
                             patterns,
                             ignore_patterns,
                             include_hidden=include_hidden,