.vim/bundle/black/src/black/files.py

   1 from functools import lru_cache
   2 import io
   3 import os
   4 from pathlib import Path
   5 import sys
   6 from typing import (
   7     Any,
   8     Dict,
   9     Iterable,
  10     Iterator,
  11     List,
  12     Optional,
  13     Pattern,
  14     Sequence,
  15     Tuple,
  16     Union,
  17     TYPE_CHECKING,
  18 )
  19
  20 from pathspec import PathSpec
  21 from pathspec.patterns.gitwildmatch import GitWildMatchPatternError
  22 import tomli
  23
  24 from black.output import err
  25 from black.report import Report
  26 from black.handle_ipynb_magics import jupyter_dependencies_are_installed
  27
  28 if TYPE_CHECKING:
  29     import colorama  # noqa: F401
  30
  31
  32 @lru_cache()
  33 def find_project_root(srcs: Sequence[str]) -> Path:
  34     """Return a directory containing .git, .hg, or pyproject.toml.
  35
  36     That directory will be a common parent of all files and directories
  37     passed in `srcs`.
  38
  39     If no directory in the tree contains a marker that would specify it's the
  40     project root, the root of the file system is returned.
  41     """
  42     if not srcs:
  43         srcs = [str(Path.cwd().resolve())]
  44
  45     path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
  46
  47     # A list of lists of parents for each 'src'. 'src' is included as a
  48     # "parent" of itself if it is a directory
  49     src_parents = [
  50         list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
  51     ]
  52
  53     common_base = max(
  54         set.intersection(*(set(parents) for parents in src_parents)),
  55         key=lambda path: path.parts,
  56     )
  57
  58     for directory in (common_base, *common_base.parents):
  59         if (directory / ".git").exists():
  60             return directory
  61
  62         if (directory / ".hg").is_dir():
  63             return directory
  64
  65         if (directory / "pyproject.toml").is_file():
  66             return directory
  67
  68     return directory
  69
  70
  71 def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
  72     """Find the absolute filepath to a pyproject.toml if it exists"""
  73     path_project_root = find_project_root(path_search_start)
  74     path_pyproject_toml = path_project_root / "pyproject.toml"
  75     if path_pyproject_toml.is_file():
  76         return str(path_pyproject_toml)
  77
  78     try:
  79         path_user_pyproject_toml = find_user_pyproject_toml()
  80         return (
  81             str(path_user_pyproject_toml)
  82             if path_user_pyproject_toml.is_file()
  83             else None
  84         )
  85     except PermissionError as e:
  86         # We do not have access to the user-level config directory, so ignore it.
  87         err(f"Ignoring user configuration directory due to {e!r}")
  88         return None
  89
  90
  91 def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
  92     """Parse a pyproject toml file, pulling out relevant parts for Black
  93
  94     If parsing fails, will raise a tomli.TOMLDecodeError
  95     """
  96     with open(path_config, encoding="utf8") as f:
  97         pyproject_toml = tomli.load(f)  # type: ignore  # due to deprecated API usage
  98     config = pyproject_toml.get("tool", {}).get("black", {})
  99     return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
 100
 101
 102 @lru_cache()
 103 def find_user_pyproject_toml() -> Path:
 104     r"""Return the path to the top-level user configuration for black.
 105
 106     This looks for ~\.black on Windows and ~/.config/black on Linux and other
 107     Unix systems.
 108     """
 109     if sys.platform == "win32":
 110         # Windows
 111         user_config_path = Path.home() / ".black"
 112     else:
 113         config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")
 114         user_config_path = Path(config_root).expanduser() / "black"
 115     return user_config_path.resolve()
 116
 117
 118 @lru_cache()
 119 def get_gitignore(root: Path) -> PathSpec:
 120     """Return a PathSpec matching gitignore content if present."""
 121     gitignore = root / ".gitignore"
 122     lines: List[str] = []
 123     if gitignore.is_file():
 124         with gitignore.open(encoding="utf-8") as gf:
 125             lines = gf.readlines()
 126     try:
 127         return PathSpec.from_lines("gitwildmatch", lines)
 128     except GitWildMatchPatternError as e:
 129         err(f"Could not parse {gitignore}: {e}")
 130         raise
 131
 132
 133 def normalize_path_maybe_ignore(
 134     path: Path, root: Path, report: Report
 135 ) -> Optional[str]:
 136     """Normalize `path`. May return `None` if `path` was ignored.
 137
 138     `report` is where "path ignored" output goes.
 139     """
 140     try:
 141         abspath = path if path.is_absolute() else Path.cwd() / path
 142         normalized_path = abspath.resolve().relative_to(root).as_posix()
 143     except OSError as e:
 144         report.path_ignored(path, f"cannot be read because {e}")
 145         return None
 146
 147     except ValueError:
 148         if path.is_symlink():
 149             report.path_ignored(path, f"is a symbolic link that points outside {root}")
 150             return None
 151
 152         raise
 153
 154     return normalized_path
 155
 156
 157 def path_is_excluded(
 158     normalized_path: str,
 159     pattern: Optional[Pattern[str]],
 160 ) -> bool:
 161     match = pattern.search(normalized_path) if pattern else None
 162     return bool(match and match.group(0))
 163
 164
 165 def gen_python_files(
 166     paths: Iterable[Path],
 167     root: Path,
 168     include: Pattern[str],
 169     exclude: Pattern[str],
 170     extend_exclude: Optional[Pattern[str]],
 171     force_exclude: Optional[Pattern[str]],
 172     report: Report,
 173     gitignore: Optional[PathSpec],
 174     *,
 175     verbose: bool,
 176     quiet: bool,
 177 ) -> Iterator[Path]:
 178     """Generate all files under `path` whose paths are not excluded by the
 179     `exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
 180     but are included by the `include` regex.
 181
 182     Symbolic links pointing outside of the `root` directory are ignored.
 183
 184     `report` is where output about exclusions goes.
 185     """
 186     assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
 187     for child in paths:
 188         normalized_path = normalize_path_maybe_ignore(child, root, report)
 189         if normalized_path is None:
 190             continue
 191
 192         # First ignore files matching .gitignore, if passed
 193         if gitignore is not None and gitignore.match_file(normalized_path):
 194             report.path_ignored(child, "matches the .gitignore file content")
 195             continue
 196
 197         # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
 198         normalized_path = "/" + normalized_path
 199         if child.is_dir():
 200             normalized_path += "/"
 201
 202         if path_is_excluded(normalized_path, exclude):
 203             report.path_ignored(child, "matches the --exclude regular expression")
 204             continue
 205
 206         if path_is_excluded(normalized_path, extend_exclude):
 207             report.path_ignored(
 208                 child, "matches the --extend-exclude regular expression"
 209             )
 210             continue
 211
 212         if path_is_excluded(normalized_path, force_exclude):
 213             report.path_ignored(child, "matches the --force-exclude regular expression")
 214             continue
 215
 216         if child.is_dir():
 217             # If gitignore is None, gitignore usage is disabled, while a Falsey
 218             # gitignore is when the directory doesn't have a .gitignore file.
 219             yield from gen_python_files(
 220                 child.iterdir(),
 221                 root,
 222                 include,
 223                 exclude,
 224                 extend_exclude,
 225                 force_exclude,
 226                 report,
 227                 gitignore + get_gitignore(child) if gitignore is not None else None,
 228                 verbose=verbose,
 229                 quiet=quiet,
 230             )
 231
 232         elif child.is_file():
 233             if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(
 234                 verbose=verbose, quiet=quiet
 235             ):
 236                 continue
 237             include_match = include.search(normalized_path) if include else True
 238             if include_match:
 239                 yield child
 240
 241
 242 def wrap_stream_for_windows(
 243     f: io.TextIOWrapper,
 244 ) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
 245     """
 246     Wrap stream with colorama's wrap_stream so colors are shown on Windows.
 247
 248     If `colorama` is unavailable, the original stream is returned unmodified.
 249     Otherwise, the `wrap_stream()` function determines whether the stream needs
 250     to be wrapped for a Windows environment and will accordingly either return
 251     an `AnsiToWin32` wrapper or the original stream.
 252     """
 253     try:
 254         from colorama.initialise import wrap_stream
 255     except ImportError:
 256         return f
 257     else:
 258         # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
 259         return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)