Print exact Python version with build date

[etc/vim.git] / black.py

diff --git a/black.py b/black.py
index e795fa3267e62883bc0811412a673c191d7ebd6b..6dd1e68d184246a886a0d108900000ee5a6d69e1 100644 (file)
--- a/black.py
+++ b/black.py
@@ -200,40 +200,52 @@ def main(
         return
 
     elif len(sources) == 1:
-        return_code = run_single_file_mode(
-            line_length, check, fast, quiet, write_back, sources[0]
-        )
+        return_code = reformat_one(sources[0], line_length, fast, quiet, write_back)
     else:
-        return_code = run_multi_file_mode(line_length, fast, quiet, write_back, sources)
+        loop = asyncio.get_event_loop()
+        executor = ProcessPoolExecutor(max_workers=os.cpu_count())
+        return_code = 1
+        try:
+            return_code = loop.run_until_complete(
+                schedule_formatting(
+                    sources, line_length, write_back, fast, quiet, loop, executor
+                )
+            )
+        finally:
+            shutdown(loop)
     ctx.exit(return_code)
 
 
-def run_single_file_mode(
-    line_length: int,
-    check: bool,
-    fast: bool,
-    quiet: bool,
-    write_back: WriteBack,
-    src: Path,
+def reformat_one(
+    src: Path, line_length: int, fast: bool, quiet: bool, write_back: WriteBack
 ) -> int:
-    report = Report(check=check, quiet=quiet)
+    """Reformat a single file under `src` without spawning child processes.
+
+    If `quiet` is True, non-error messages are not output. `line_length`,
+    `write_back`, and `fast` options are passed to :func:`format_file_in_place`.
+    """
+    report = Report(check=write_back is WriteBack.NO, quiet=quiet)
     try:
+        changed = Changed.NO
         if not src.is_file() and str(src) == "-":
-            changed = format_stdin_to_stdout(
+            if format_stdin_to_stdout(
                 line_length=line_length, fast=fast, write_back=write_back
-            )
+            ):
+                changed = Changed.YES
         else:
-            changed = Changed.NO
             cache: Cache = {}
             if write_back != WriteBack.DIFF:
                 cache = read_cache()
                 src = src.resolve()
                 if src in cache and cache[src] == get_cache_info(src):
                     changed = Changed.CACHED
-            if changed is not Changed.CACHED:
-                changed = format_file_in_place(
+            if (
+                changed is not Changed.CACHED
+                and format_file_in_place(
                     src, line_length=line_length, fast=fast, write_back=write_back
                 )
+            ):
+                changed = Changed.YES
             if write_back != WriteBack.DIFF and changed is not Changed.NO:
                 write_cache(cache, [src])
         report.done(src, changed)
@@ -242,27 +254,6 @@ def run_single_file_mode(
     return report.return_code
 
 
-def run_multi_file_mode(
-    line_length: int,
-    fast: bool,
-    quiet: bool,
-    write_back: WriteBack,
-    sources: List[Path],
-) -> int:
-    loop = asyncio.get_event_loop()
-    executor = ProcessPoolExecutor(max_workers=os.cpu_count())
-    return_code = 1
-    try:
-        return_code = loop.run_until_complete(
-            schedule_formatting(
-                sources, line_length, write_back, fast, quiet, loop, executor
-            )
-        )
-    finally:
-        shutdown(loop)
-        return return_code
-
-
 async def schedule_formatting(
     sources: List[Path],
     line_length: int,
@@ -316,7 +307,7 @@ async def schedule_formatting(
                 report.failed(src, str(task.exception()))
             else:
                 formatted.append(src)
-                report.done(src, task.result())
+                report.done(src, Changed.YES if task.result() else Changed.NO)
 
     if cancelled:
         await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
@@ -337,7 +328,7 @@ def format_file_in_place(
     fast: bool,
     write_back: WriteBack = WriteBack.NO,
     lock: Any = None,  # multiprocessing.Manager().Lock() is some crazy proxy
-) -> Changed:
+) -> bool:
     """Format file under `src` path. Return True if changed.
 
     If `write_back` is True, write reformatted code back to stdout.
@@ -351,7 +342,7 @@ def format_file_in_place(
             src_contents, line_length=line_length, fast=fast
         )
     except NothingChanged:
-        return Changed.NO
+        return False
 
     if write_back == write_back.YES:
         with open(src, "w", encoding=src_buffer.encoding) as f:
@@ -367,12 +358,12 @@ def format_file_in_place(
         finally:
             if lock:
                 lock.release()
-    return Changed.YES
+    return True
 
 
 def format_stdin_to_stdout(
     line_length: int, fast: bool, write_back: WriteBack = WriteBack.NO
-) -> Changed:
+) -> bool:
     """Format file on stdin. Return True if changed.
 
     If `write_back` is True, write reformatted code back to stdout.
@@ -382,10 +373,10 @@ def format_stdin_to_stdout(
     dst = src
     try:
         dst = format_file_contents(src, line_length=line_length, fast=fast)
-        return Changed.YES
+        return True
 
     except NothingChanged:
-        return Changed.NO
+        return False
 
     finally:
         if write_back == WriteBack.YES:
@@ -2174,6 +2165,11 @@ def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
 
 
 def max_delimiter_priority_in_atom(node: LN) -> int:
+    """Return maximum delimiter priority inside `node`.
+
+    This is specific to atoms with contents contained in a pair of parentheses.
+    If `node` isn't an atom or there are no enclosing parentheses, returns 0.
+    """
     if node.type != syms.atom:
         return 0