Enhance --verbose

CHANGES.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## Unreleased
+
+### _Black_
+
+- `--verbose` enhancements (project root, how is config found, root relative paths)
+  (#2526)
+
 ## 21.10b0
 
 ### _Black_

src/black/__init__.py

@@ -9,6 +9,7 @@
 from multiprocessing import Manager, freeze_support
 import os
 from pathlib import Path
+from click.core import ParameterSource
 from pathspec.patterns.gitwildmatch import GitWildMatchPatternError
 import regex as re
 import signal
@@ -44,7 +45,7 @@
 from black.cache import read_cache, write_cache, get_cache_info, filter_cached, Cache
 from black.concurrency import cancel, shutdown, maybe_install_uvloop
 from black.output import dump_to_file, ipynb_diff, diff, color_diff, out, err
-from black.report import Report, Changed, NothingChanged
+from black.report import Report, Changed, NothingChanged, root_relative
 from black.files import find_project_root, find_pyproject_toml, parse_pyproject_toml
 from black.files import gen_python_files, get_gitignore, normalize_path_maybe_ignore
 from black.files import wrap_stream_for_windows
@@ -399,7 +400,11 @@ def main(
 ) -> None:
     """The uncompromising code formatter."""
     if config and verbose:
-        out(f"Using configuration from {config}.", bold=False, fg="blue")
+        config_source = ctx.get_parameter_source("config")
+        if config_source in (ParameterSource.DEFAULT, ParameterSource.DEFAULT_MAP):
+            out("Using configuration from project root.", fg="blue")
+        else:
+            out(f"Using configuration in '{config}'.", fg="blue")
 
     error_msg = "Oh no! 💥 💔 💥"
     if required_version and required_version != __version__:
@@ -441,7 +446,7 @@ def main(
         )
     else:
         try:
-            sources = get_sources(
+            sources, root = get_sources(
                 ctx=ctx,
                 src=src,
                 quiet=quiet,
@@ -475,6 +480,7 @@ def main(
         else:
             reformat_many(
                 sources=sources,
+                root=root,
                 fast=fast,
                 write_back=write_back,
                 mode=mode,
@@ -501,10 +507,29 @@ def get_sources(
     force_exclude: Optional[Pattern[str]],
     report: "Report",
     stdin_filename: Optional[str],
-) -> Set[Path]:
-    """Compute the set of files to be formatted."""
+) -> Tuple[Set[Path], Path]:
+    """
+    Compute the set of files to be formatted.
+
+    Returns a tuple, with the first element as a set of paths which are to be
+    checked/formatted by black, and the second element as the project root
+    found out by black.
+    """
+    root, method = find_project_root(src)
+
+    if verbose:
+        if method:
+            out(
+                f"Identified `{root}` as project root containing a {method}.",
+                fg="blue",
+            )
+        else:
+            out(f"Identified `{root}` as project root.", fg="blue")
+        paths = '", "'.join(
+            str(root_relative(Path(source).absolute(), root)) for source in src
+        )
+        out(f'Sources to be formatted: "{paths}"', fg="blue")
 
-    root = find_project_root(src)
     sources: Set[Path] = set()
     path_empty(src, "No Path provided. Nothing to do 😴", quiet, verbose, ctx)
 
@@ -534,7 +559,9 @@ def get_sources(
             else:
                 force_exclude_match = None
             if force_exclude_match and force_exclude_match.group(0):
-                report.path_ignored(p, "matches the --force-exclude regular expression")
+                report.path_ignored(
+                    p, "matches the --force-exclude regular expression", root
+                )
                 continue
 
             if is_stdin:
@@ -564,8 +591,8 @@ def get_sources(
         elif s == "-":
             sources.add(p)
         else:
-            err(f"invalid path: {s}")
-    return sources
+            out(f"Invalid path: {root_relative(p, root)}", fg="red")
+    return sources, root
 
 
 def path_empty(
@@ -612,6 +639,8 @@ def reformat_one(
     `fast`, `write_back`, and `mode` options are passed to
     :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
     """
+    root, _ = find_project_root(str(src))
+
     try:
         changed = Changed.NO
 
@@ -648,15 +677,16 @@ def reformat_one(
                 write_back is WriteBack.CHECK and changed is Changed.NO
             ):
                 write_cache(cache, [src], mode)
-        report.done(src, changed)
+        report.done(src, changed, root)
     except Exception as exc:
         if report.verbose:
             traceback.print_exc()
-        report.failed(src, str(exc))
+        report.failed(src, str(exc), root)
 
 
 def reformat_many(
     sources: Set[Path],
+    root: Path,
     fast: bool,
     write_back: WriteBack,
     mode: Mode,
@@ -683,6 +713,7 @@ def reformat_many(
         loop.run_until_complete(
             schedule_formatting(
                 sources=sources,
+                root=root,
                 fast=fast,
                 write_back=write_back,
                 mode=mode,
@@ -699,6 +730,7 @@ def reformat_many(
 
 async def schedule_formatting(
     sources: Set[Path],
+    root: Path,
     fast: bool,
     write_back: WriteBack,
     mode: Mode,
@@ -718,7 +750,7 @@ async def schedule_formatting(
         cache = read_cache(mode)
         sources, cached = filter_cached(cache, sources)
         for src in sorted(cached):
-            report.done(src, Changed.CACHED)
+            report.done(src, Changed.CACHED, root)
     if not sources:
         return
 
@@ -761,7 +793,7 @@ async def schedule_formatting(
                     write_back is WriteBack.CHECK and changed is Changed.NO
                 ):
                     sources_to_cache.append(src)
-                report.done(src, changed)
+                report.done(src, changed, root)
     if cancelled:
         if sys.version_info >= (3, 7):
             await asyncio.gather(*cancelled, return_exceptions=True)

src/black/files.py

@@ -30,14 +30,19 @@
 
 
 @lru_cache()
-def find_project_root(srcs: Sequence[str]) -> Path:
+def find_project_root(srcs: Sequence[str]) -> Tuple[Path, Optional[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 tuple with the first element as the project root path and the
+    second element as a string which describes the method by which black
+    found out the project root (None, if `None` of the registered method
+    was used).
     """
     if not srcs:
         srcs = [str(Path.cwd().resolve())]
@@ -57,20 +62,20 @@ def find_project_root(srcs: Sequence[str]) -> Path:
 
     for directory in (common_base, *common_base.parents):
         if (directory / ".git").exists():
-            return directory
+            return directory, ".git directory"
 
         if (directory / ".hg").is_dir():
-            return directory
+            return directory, ".hg directory"
 
         if (directory / "pyproject.toml").is_file():
-            return directory
+            return directory, "pyproject.toml"
 
-    return directory
+    return directory, None
 
 
 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_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)
@@ -191,7 +196,7 @@ def gen_python_files(
 
         # First ignore files matching .gitignore, if passed
         if gitignore is not None and gitignore.match_file(normalized_path):
-            report.path_ignored(child, "matches the .gitignore file content")
+            report.path_ignored(child, "matches the .gitignore file content", root)
             continue
 
         # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
@@ -200,17 +205,19 @@ def gen_python_files(
             normalized_path += "/"
 
         if path_is_excluded(normalized_path, exclude):
-            report.path_ignored(child, "matches the --exclude regular expression")
+            report.path_ignored(child, "matches the --exclude regular expression", root)
             continue
 
         if path_is_excluded(normalized_path, extend_exclude):
             report.path_ignored(
-                child, "matches the --extend-exclude regular expression"
+                child, "matches the --extend-exclude regular expression", root
             )
             continue
 
         if path_is_excluded(normalized_path, force_exclude):
-            report.path_ignored(child, "matches the --force-exclude regular expression")
+            report.path_ignored(
+                child, "matches the --force-exclude regular expression", root
+            )
             continue
 
         if child.is_dir():

src/black/report.py

@@ -1,6 +1,9 @@
 """
 Summarize Black runs to users.
 """
+import os
+from typing import Optional
+
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -10,6 +13,12 @@
 from black.output import out, err
 
 
+def root_relative(path: Path, root: Optional[Path]) -> Path:
+    if not root:
+        return path
+    return Path(os.path.relpath(path, start=Path(f"{root}/../")))
+
+
 class Changed(Enum):
     NO = 0
     CACHED = 1
@@ -32,30 +41,32 @@ class Report:
     same_count: int = 0
     failure_count: int = 0
 
-    def done(self, src: Path, changed: Changed) -> None:
+    def done(self, src: Path, changed: Changed, root: Optional[Path] = None) -> None:
         """Increment the counter for successful reformatting. Write out a message."""
         if changed is Changed.YES:
             reformatted = "would reformat" if self.check or self.diff else "reformatted"
             if self.verbose or not self.quiet:
-                out(f"{reformatted} {src}")
+                out(f"{reformatted} {root_relative(src, root)}")
             self.change_count += 1
         else:
             if self.verbose:
                 if changed is Changed.NO:
-                    msg = f"{src} already well formatted, good job."
+                    msg = "already well formatted, good job."
                 else:
-                    msg = f"{src} wasn't modified on disk since last run."
-                out(msg, bold=False)
+                    msg = "wasn't modified on disk since last run."
+                out(f"{root_relative(src, root)} {msg}", bold=False)
             self.same_count += 1
 
-    def failed(self, src: Path, message: str) -> None:
+    def failed(self, src: Path, message: str, root: Optional[Path] = None) -> None:
         """Increment the counter for failed reformatting. Write out a message."""
-        err(f"error: cannot format {src}: {message}")
+        err(f"error: cannot format {root_relative(src, root)}: {message}")
         self.failure_count += 1
 
-    def path_ignored(self, path: Path, message: str) -> None:
+    def path_ignored(
+        self, path: Path, message: str, root: Optional[Path] = None
+    ) -> None:
         if self.verbose:
-            out(f"{path} ignored: {message}", bold=False)
+            out(f"{root_relative(path, root)} ignored: {message}", bold=False)
 
     @property
     def return_code(self) -> int: