3291458763

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/psf/black/commit/<a class=hub.com/psf/black/commit/86ead04ad038e9275a66387f076b5cbea1ed70ca">86ead04ad<a href="https://github.com/psf/black/commit/86ead04ad038e9275a66387f076b5cbea1ed70ca">">Merge </a><a class="double-link" href="https://github.com/psf/black/commit/<a class="double-link" href="https://github.com/psf/black/commit/50d45b0c208e28bbd5cb227db7597b4ac12135e7">50d45b0c2</a>">50d45b0c2</a><a href="https://github.com/psf/black/commit/86ead04ad038e9275a66387f076b5cbea1ed70ca"> into f22273a72">f22273a72</a>

Pull Request Pull Request #3338: Compare each .gitignore found with an appropiate relative path

Run Details

35 of 36 new or added lines in 3 files covered. (97.22%)

5974 of 6235 relevant lines covered (95.81%)

5.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.49

/src/black/files.py

import io
import os
import sys
from functools import lru_cache
from pathlib import Path
from typing import (
    TYPE_CHECKING,
    Any,
    Dict,
    Iterable,
    Iterator,
    List,
    Optional,
    Pattern,
    Sequence,
    Tuple,
    Union,
)

from mypy_extensions import mypyc_attr
from pathspec import PathSpec
from pathspec.patterns.gitwildmatch import GitWildMatchPatternError

if sys.version_info >= (3, 11):
    try:
        import tomllib
    except ImportError:
        # Help users on older alphas
        if not TYPE_CHECKING:
            import tomli as tomllib
else:
    import tomli as tomllib

from black.handle_ipynb_magics import jupyter_dependencies_are_installed
from black.output import err
from black.report import Report

if TYPE_CHECKING:
    import colorama  # noqa: F401


@lru_cache()
def find_project_root(
    srcs: Sequence[str], stdin_filename: Optional[str] = None
) -> Tuple[Path, str]:
    """Return a directory containing .git, .hg, or pyproject.toml.

    That directory will be a common parent of all files and directories
    passed in `srcs`.

    If no directory in the tree contains a marker that would specify it's the
    project root, the root of the file system is returned.

    Returns a two-tuple with the first element as the project root path and
    the second element as a string describing the method by which the
    project root was discovered.
    """
    if stdin_filename is not None:
        srcs = tuple(stdin_filename if s == "-" else s for s in srcs)
    if not srcs:
        srcs = [str(Path.cwd().resolve())]

    path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]

    # A list of lists of parents for each 'src'. 'src' is included as a
    # "parent" of itself if it is a directory
    src_parents = [
        list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
    ]

    common_base = max(
        set.intersection(*(set(parents) for parents in src_parents)),
        key=lambda path: path.parts,
    )

    for directory in (common_base, *common_base.parents):
        if (directory / ".git").exists():
            return directory, ".git directory"

        if (directory / ".hg").is_dir():
            return directory, ".hg directory"

        if (directory / "pyproject.toml").is_file():
            return directory, "pyproject.toml"

    return directory, "file system root"


def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
    """Find the absolute filepath to a pyproject.toml if it exists"""
    path_project_root, _ = find_project_root(path_search_start)
    path_pyproject_toml = path_project_root / "pyproject.toml"
    if path_pyproject_toml.is_file():
        return str(path_pyproject_toml)

    try:
        path_user_pyproject_toml = find_user_pyproject_toml()
        return (
            str(path_user_pyproject_toml)
            if path_user_pyproject_toml.is_file()
            else None
        )
    except (PermissionError, RuntimeError) as e:
        # We do not have access to the user-level config directory, so ignore it.
        err(f"Ignoring user configuration directory due to {e!r}")
        return None


@mypyc_attr(patchable=True)
def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
    """Parse a pyproject toml file, pulling out relevant parts for Black

    If parsing fails, will raise a tomllib.TOMLDecodeError
    """
    with open(path_config, "rb") as f:
        pyproject_toml = tomllib.load(f)
    config = pyproject_toml.get("tool", {}).get("black", {})
    return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}


@lru_cache()
def find_user_pyproject_toml() -> Path:
    r"""Return the path to the top-level user configuration for black.

    This looks for ~\.black on Windows and ~/.config/black on Linux and other
    Unix systems.

    May raise:
    - RuntimeError: if the current user has no homedir
    - PermissionError: if the current process cannot access the user's homedir
    """
    if sys.platform == "win32":
        # Windows
        user_config_path = Path.home() / ".black"
    else:
        config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")
        user_config_path = Path(config_root).expanduser() / "black"
    return user_config_path.resolve()


@lru_cache()
def get_gitignore(root: Path) -> PathSpec:
    """Return a PathSpec matching gitignore content if present."""
    gitignore = root / ".gitignore"
    lines: List[str] = []
    if gitignore.is_file():
        with gitignore.open(encoding="utf-8") as gf:
            lines = gf.readlines()
    try:
        return PathSpec.from_lines("gitwildmatch", lines)
    except GitWildMatchPatternError as e:
        err(f"Could not parse {gitignore}: {e}")
        raise


def normalize_path_maybe_ignore(
    path: Path,
    root: Path,
    report: Optional[Report] = None,
) -> Optional[str]:
    """Normalize `path`. May return `None` if `path` was ignored.

    `report` is where "path ignored" output goes.
    """
    try:
        abspath = path if path.is_absolute() else Path.cwd() / path
        normalized_path = abspath.resolve()
        try:
            root_relative_path = normalized_path.relative_to(root).as_posix()
        except ValueError:
            if report:
                report.path_ignored(
                    path, f"is a symbolic link that points outside {root}"
                )
            return None

    except OSError as e:
        if report:
            report.path_ignored(path, f"cannot be read because {e}")
        return None

    return root_relative_path


def path_is_excluded(
    normalized_path: str,
    pattern: Optional[Pattern[str]],
) -> bool:
    match = pattern.search(normalized_path) if pattern else None
    return bool(match and match.group(0))


def gen_python_files(
    paths: Iterable[Path],
    root: Path,
    include: Pattern[str],
    exclude: Pattern[str],
    extend_exclude: Optional[Pattern[str]],
    force_exclude: Optional[Pattern[str]],
    report: Report,
    gitignore: Optional[Dict[Path, PathSpec]],
    *,
    verbose: bool,
    quiet: bool,
) -> Iterator[Path]:
    """Generate all files under `path` whose paths are not excluded by the
    `exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
    but are included by the `include` regex.

    Symbolic links pointing outside of the `root` directory are ignored.

    `report` is where output about exclusions goes.
    """

    def is_ignored(
        gitignore_dict: Dict[Path, PathSpec], child: Path, report: Report
    ) -> bool:
        for _dir, _gitignore in gitignore_dict.items():
            relative_path = normalize_path_maybe_ignore(child, _dir, report)
            if relative_path is None:
                break
            if _gitignore is not None and _gitignore.match_file(relative_path):
                report.path_ignored(child, "matches the .gitignore file content")
                return True
        return False

    assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
    for child in paths:
        normalized_path = normalize_path_maybe_ignore(child, root, report)
        if normalized_path is None:
            continue

        # First ignore files matching .gitignore, if passed
        if gitignore is not None and is_ignored(gitignore, child, report):
            continue

        # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
        normalized_path = "/" + normalized_path
        if child.is_dir():
            normalized_path += "/"

        if path_is_excluded(normalized_path, exclude):
            report.path_ignored(child, "matches the --exclude regular expression")
            continue

        if path_is_excluded(normalized_path, extend_exclude):
            report.path_ignored(
                child, "matches the --extend-exclude regular expression"
            )
            continue

        if path_is_excluded(normalized_path, force_exclude):
            report.path_ignored(child, "matches the --force-exclude regular expression")
            continue

        if child.is_dir():
            # If gitignore is None, gitignore usage is disabled, while a Falsey
            # gitignore is when the directory doesn't have a .gitignore file.
            if gitignore is None:
                _gitignore = None
            else:
                _gitignore = gitignore.copy()
                _gitignore[root / child] = get_gitignore(child)
            yield from gen_python_files(
                child.iterdir(),
                root,
                include,
                exclude,
                extend_exclude,
                force_exclude,
                report,
                _gitignore,
                verbose=verbose,
                quiet=quiet,
            )

        elif child.is_file():
            if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(
                verbose=verbose, quiet=quiet
            ):
                continue
            include_match = include.search(normalized_path) if include else True
            if include_match:
                yield child


def wrap_stream_for_windows(
    f: io.TextIOWrapper,
) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
    """
    Wrap stream with colorama's wrap_stream so colors are shown on Windows.

    If `colorama` is unavailable, the original stream is returned unmodified.
    Otherwise, the `wrap_stream()` function determines whether the stream needs
    to be wrapped for a Windows environment and will accordingly either return
    an `AnsiToWin32` wrapper or the original stream.
    """
    try:
        from colorama.initialise import wrap_stream
    except ImportError:
        return f
    else:
        # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
        return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)

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

psf / black / 3291458763

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous