git-format-staged 3.1.2 → 3.1.3

package/git-format-staged

@@ -20,60 +20,93 @@ from gettext import gettext as _
 import os
 import re
 import shlex
+import signal
 import subprocess
 import sys
 
-# The string 3.1.2 is replaced during the publish process.
-VERSION = '3.1.2'
+# The string 3.1.3 is replaced during the publish process.
+VERSION = "3.1.3"
 PROG = sys.argv[0]
 
+
 def info(msg):
     print(msg, file=sys.stdout)
 
-def warn(msg):
-    print('{}: warning: {}'.format(PROG, msg), file=sys.stderr)
+
+def info_stderr(msg: str):
+    print(msg, file=sys.stderr)
+
+
+def warn(msg: str):
+    print("{}: warning: {}".format(PROG, msg), file=sys.stderr)
+
 
 def fatal(msg):
-    print('{}: error: {}'.format(PROG, msg), file=sys.stderr)
+    print("{}: error: {}".format(PROG, msg), file=sys.stderr)
     exit(1)
 
-def format_staged_files(file_patterns, formatter, git_root, update_working_tree=True, write=True, verbose=False):
+
+def format_staged_files(
+    file_patterns,
+    formatter,
+    git_root,
+    update_working_tree=True,
+    write=True,
+    verbose=False,
+):
     common_opts = [
-        '--cached',
-        '--diff-filter=AM', # select only file additions and modifications
-        '--no-renames',
-        'HEAD',
+        "--cached",
+        "--diff-filter=AM",  # select only file additions and modifications
+        "--no-renames",
+        "HEAD",
     ]
 
     try:
         staged_files = {
-            path.decode('utf-8')
-            for path in subprocess.check_output(['git', 'diff', '--name-only'] + common_opts).splitlines()
+            path.decode("utf-8")
+            for path in subprocess.check_output(
+                ["git", "diff", "--name-only"] + common_opts
+            ).splitlines()
         }
 
-        output = subprocess.check_output(['git', 'diff-index'] + common_opts)
+        output = subprocess.check_output(["git", "diff-index"] + common_opts)
         for line in output.splitlines():
-            entry = parse_diff(line.decode('utf-8'))
-            entry_path = normalize_path(entry['src_path'], relative_to=git_root)
-            if entry['dst_mode'] == '120000':
+            entry = parse_diff(line.decode("utf-8"))
+            entry_path = normalize_path(entry["src_path"], relative_to=git_root)
+            if entry["dst_mode"] == "120000":
                 # Do not process symlinks
                 continue
             if not (matches_some_path(file_patterns, entry_path)):
                 continue
-            if entry['src_mode'] is None and object_is_empty(entry['dst_hash']) and entry['src_path'] not in staged_files:
+            if (
+                entry["src_mode"] is None
+                and object_is_empty(entry["dst_hash"])
+                and entry["src_path"] not in staged_files
+            ):
                 # File is not staged, it's tracked only with `--intent-to-add` and won't get committed
                 continue
-            if format_file_in_index(formatter, entry, update_working_tree=update_working_tree, write=write, verbose=verbose):
-                info('Reformatted {} with {}'.format(entry['src_path'], formatter))
+            if format_file_in_index(
+                formatter,
+                entry,
+                update_working_tree=update_working_tree,
+                write=write,
+                verbose=verbose,
+            ):
+                info("Reformatted {} with {}".format(entry["src_path"], formatter))
     except Exception as err:
         fatal(str(err))
 
+
 # Run formatter on file in the git index. Creates a new git object with the
 # result, and replaces the content of the file in the index with that object.
 # Returns hash of the new object if formatting produced any changes.
-def format_file_in_index(formatter, diff_entry, update_working_tree=True, write=True, verbose=False):
-    orig_hash = diff_entry['dst_hash']
-    new_hash = format_object(formatter, orig_hash, diff_entry['src_path'], verbose=verbose)
+def format_file_in_index(
+    formatter, diff_entry, update_working_tree=True, write=True, verbose=False
+):
+    orig_hash = diff_entry["dst_hash"]
+    new_hash = format_object(
+        formatter, orig_hash, diff_entry["src_path"], verbose=verbose
+    )
 
     # If the new hash is the same then the formatter did not make any changes.
     if not write or new_hash == orig_hash:
@@ -89,130 +122,210 @@ def format_file_in_index(formatter, diff_entry, update_working_tree=True, write=
 
     if update_working_tree:
         try:
-            patch_working_file(diff_entry['src_path'], orig_hash, new_hash)
+            patch_working_file(diff_entry["src_path"], orig_hash, new_hash)
         except Exception as err:
             # Errors patching working tree files are not fatal
             warn(str(err))
 
     return new_hash
 
+
 # Match {}, and to avoid breaking quoting from shlex also match and remove surrounding quotes. This
 # is important for backward compatibility because previous version of git-format-staged did not use
 # shlex quoting, and required manual quoting.
 file_path_placeholder = re.compile(r"(['\"]?)\{\}(\1)")
 
+
 # Run formatter on a git blob identified by its hash. Writes output to a new git
 # blob, and returns the hash of the new blob.
 def format_object(formatter, object_hash, file_path, verbose=False):
     get_content = subprocess.Popen(
-            ['git', 'cat-file', '-p', object_hash],
-            stdout=subprocess.PIPE
-            )
+        ["git", "cat-file", "-p", object_hash], stdout=subprocess.PIPE
+    )
+
     command = re.sub(file_path_placeholder, shlex.quote(file_path), formatter)
     if verbose:
-        info(command)
+        info_stderr(command)
     format_content = subprocess.Popen(
-            command,
-            shell=True,
-            stdin=get_content.stdout,
-            stdout=subprocess.PIPE
-            )
-    write_object = subprocess.Popen(
-            ['git', 'hash-object', '-w', '--stdin'],
-            stdin=format_content.stdout,
-            stdout=subprocess.PIPE
-            )
+        command, shell=True, stdin=get_content.stdout, stdout=subprocess.PIPE
+    )
 
-    # Read output from the final process first to avoid deadlock if intermediate processes produce
-    # large outputs that would fill pipe buffers
-    new_hash, _ = write_object.communicate()
+    write_object = subprocess.Popen(
+        ["git", "hash-object", "-w", "--stdin"],
+        stdin=format_content.stdout,
+        stdout=subprocess.PIPE,
+    )
+
+    # Close the parent process reference to stdout, leaving only references in the child processes.
+    # This way if the downstream process terminates while format_content is still running,
+    # format_content will be terminated with a SIGPIPE signal.
+    format_content.stdout.close()  # pyright: ignore[reportOptionalMemberAccess]
+
+    # On the other hand we don't close get_content.stdout() so that we can check if there is unread
+    # data left after the formatter has finished.
+
+    # Read output from the last process in the pipe, and block until that process has completed.
+    # It's important to block on the last process completing before waiting for the other sub
+    # processes to finish.
+    new_hash, _err = write_object.communicate()
+
+    # The first two pipe processes should have completed by now. Block to verify that we have exit
+    # statuses from them.
+    try:
+        # Use communicate() to check for any unread output from get_content.
+        get_content_unread_stdout, _ = get_content.communicate(timeout=5)
+        get_content.stdout.close()  # pyright: ignore[reportOptionalMemberAccess]
+        format_content_exit_status = format_content.wait(timeout=5)
+    except subprocess.TimeoutExpired as exception:
+        raise Exception(
+            "the formatter command did not terminate as expected"
+        ) from exception
+
+    # An error from format_content is most relevant to the user, so prioritize displaying this error
+    # message in case multiple things went wrong.
+    if format_content_exit_status != 0:
+        raise Exception(
+            f"formatter exited with non-zero status ({format_content_exit_status}) while processing {file_path}"
+        )
 
-    if get_content.wait() != 0:
-        raise ValueError('unable to read file content from object database: ' + object_hash)
+    # If the formatter exited before reading all input then get_content might have been terminated
+    # by a SIGPIPE signal. This is probably incorrect behavior from the formatter command, but is
+    # allowed by design (for now). So we emit a warning, but will not fail.
+
+    # If there was unread output from get_content that's an indication that the formatter command is
+    # probably not configured correctly. But program design allows the formatter command do do what
+    # it wants. So this is a warning, not a hard error.
+    #
+    # A SIGPIPE termination to get_content would also indicate unread output. This should not
+    # happen, but it doesn't hurt to check.
+    if len(get_content_unread_stdout) > 0 or get_content.returncode == -signal.SIGPIPE:
+        warn(
+            f"the formatter command exited before reading all content from {file_path}"
+        )
 
-    if format_content.wait() != 0:
-        raise Exception('formatter exited with non-zero status')
+    if get_content.returncode != 0 and get_content.returncode != -signal.SIGPIPE:
+        if verbose:
+            info_stderr(
+                f"non-zero exit status from `git cat-file -p {object_hash}`\n"
+                + f"exit status: {get_content.returncode}\n"
+                + f"file path: {file_path}\n"
+            )
+        raise ValueError(
+            f"unable to read file content for {file_path} from object database."
+        )
 
     if write_object.returncode != 0:
-        raise Exception('unable to write formatted content to object database')
+        if verbose:
+            info_stderr(
+                f"non-zero exit status from `git hash-object -w --stdin`\n"
+                + f"exit status: {write_object.returncode}\n"
+                + f"file path: {file_path}\n"
+            )
+        raise Exception("unable to write formatted content to object database")
+
+    return new_hash.decode("utf-8").rstrip()
 
-    return new_hash.decode('utf-8').rstrip()
 
 def object_is_empty(object_hash):
     get_content = subprocess.Popen(
-            ['git', 'cat-file', '-p', object_hash],
-            stdout=subprocess.PIPE
-        )
+        ["git", "cat-file", "-p", object_hash], stdout=subprocess.PIPE
+    )
     content, err = get_content.communicate()
 
     if get_content.returncode != 0:
-        raise Exception('unable to verify content of formatted object')
+        raise Exception("unable to verify content of formatted object")
 
     return not content
 
+
 def replace_file_in_index(diff_entry, new_object_hash):
-    subprocess.check_call(['git', 'update-index',
-        '--cacheinfo', '{},{},{}'.format(
-            diff_entry['dst_mode'],
-            new_object_hash,
-            diff_entry['src_path']
-            )])
+    subprocess.check_call(
+        [
+            "git",
+            "update-index",
+            "--cacheinfo",
+            "{},{},{}".format(
+                diff_entry["dst_mode"], new_object_hash, diff_entry["src_path"]
+            ),
+        ]
+    )
+
 
 def patch_working_file(path, orig_object_hash, new_object_hash):
     patch = subprocess.check_output(
-            ['git', 'diff', '--no-ext-diff', '--color=never', orig_object_hash, new_object_hash]
-            )
+        [
+            "git",
+            "diff",
+            "--no-ext-diff",
+            "--color=never",
+            orig_object_hash,
+            new_object_hash,
+        ]
+    )
 
     # Substitute object hashes in patch header with path to working tree file
-    patch_b = patch.replace(orig_object_hash.encode(), path.encode()).replace(new_object_hash.encode(), path.encode())
+    patch_b = patch.replace(orig_object_hash.encode(), path.encode()).replace(
+        new_object_hash.encode(), path.encode()
+    )
 
     apply_patch = subprocess.Popen(
-            ['git', 'apply', '-'],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-            )
+        ["git", "apply", "-"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
 
     output, err = apply_patch.communicate(input=patch_b)
 
     if apply_patch.returncode != 0:
-        raise Exception('could not apply formatting changes to working tree file {}'.format(path))
+        raise Exception(
+            "could not apply formatting changes to working tree file {}".format(path)
+        )
+
 
 # Format: src_mode dst_mode src_hash dst_hash status/score? src_path dst_path?
-diff_pat = re.compile(r'^:(\d+) (\d+) ([a-f0-9]+) ([a-f0-9]+) ([A-Z])(\d+)?\t([^\t]+)(?:\t([^\t]+))?$')
+diff_pat = re.compile(
+    r"^:(\d+) (\d+) ([a-f0-9]+) ([a-f0-9]+) ([A-Z])(\d+)?\t([^\t]+)(?:\t([^\t]+))?$"
+)
+
 
 # Parse output from `git diff-index`
 def parse_diff(diff):
     m = diff_pat.match(diff)
     if not m:
-        raise ValueError('Failed to parse diff-index line: ' + diff)
+        raise ValueError("Failed to parse diff-index line: " + diff)
     return {
-            'src_mode': unless_zeroed(m.group(1)),
-            'dst_mode': unless_zeroed(m.group(2)),
-            'src_hash': unless_zeroed(m.group(3)),
-            'dst_hash': unless_zeroed(m.group(4)),
-            'status': m.group(5),
-            'score': int(m.group(6)) if m.group(6) else None,
-            'src_path': m.group(7),
-            'dst_path': m.group(8)
-            }
-
-zeroed_pat = re.compile(r'^0+$')
+        "src_mode": unless_zeroed(m.group(1)),
+        "dst_mode": unless_zeroed(m.group(2)),
+        "src_hash": unless_zeroed(m.group(3)),
+        "dst_hash": unless_zeroed(m.group(4)),
+        "status": m.group(5),
+        "score": int(m.group(6)) if m.group(6) else None,
+        "src_path": m.group(7),
+        "dst_path": m.group(8),
+    }
+
+
+zeroed_pat = re.compile(r"^0+$")
+
 
 # Returns the argument unless the argument is a string of zeroes, in which case
 # returns `None`
 def unless_zeroed(s):
     return s if not zeroed_pat.match(s) else None
 
+
 def get_git_root():
-    return subprocess.check_output(
-            ['git', 'rev-parse', '--show-toplevel']
-            ).decode('utf-8').rstrip()
+    return (
+        subprocess.check_output(["git", "rev-parse", "--show-toplevel"])
+        .decode("utf-8")
+        .rstrip()
+    )
+
 
 def normalize_path(p, relative_to=None):
-    return os.path.abspath(
-            os.path.join(relative_to, p) if relative_to else p
-            )
+    return os.path.abspath(os.path.join(relative_to, p) if relative_to else p)
+
 
 def matches_some_path(patterns, target):
     is_match = False
@@ -222,70 +335,74 @@ def matches_some_path(patterns, target):
             is_match = is_pattern_positive
     return is_match
 
+
 # Checks for a '!' as the first character of a pattern, returns the rest of the
 # pattern in a tuple. The tuple takes the form (is_pattern_positive, pattern).
 # For example:
 #     from_signed_pattern('!pat') == (False, 'pat')
 #     from_signed_pattern('pat') == (True, 'pat')
 def from_signed_pattern(pattern):
-    if pattern[0] == '!':
+    if pattern[0] == "!":
         return (False, pattern[1:])
     else:
         return (True, pattern)
 
+
 class CustomArgumentParser(argparse.ArgumentParser):
     def parse_args(self, args=None, namespace=None):
         args, argv = self.parse_known_args(args, namespace)
         if argv:
             msg = argparse._(
-                    'unrecognized arguments: %s. Do you need to quote your formatter command?'
-                    )
-            self.error(msg % ' '.join(argv))
+                "unrecognized arguments: %s. Do you need to quote your formatter command?"
+            )
+            self.error(msg % " ".join(argv))
         return args
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     parser = CustomArgumentParser(
-            description='Transform staged files using a formatting command that accepts content via stdin and produces a result via stdout.',
-            epilog='Example: %(prog)s --formatter "prettier --stdin-filepath {}" "src/*.js" "test/*.js"'
-            )
+        description="Transform staged files using a formatting command that accepts content via stdin and produces a result via stdout.",
+        epilog='Example: %(prog)s --formatter "prettier --stdin-filepath {}" "src/*.js" "test/*.js"',
+    )
     parser.add_argument(
-            '--formatter', '-f',
-            required=True,
-            help='Shell command to format files, will run once per file. Occurrences of the placeholder `{}` will be replaced with a path to the file being formatted (with appropriate quoting). (Example: "prettier --stdin-filepath {}")'
-            )
+        "--formatter",
+        "-f",
+        required=True,
+        help='Shell command to format files, will run once per file. Occurrences of the placeholder `{}` will be replaced with a path to the file being formatted (with appropriate quoting). (Example: "prettier --stdin-filepath {}")',
+    )
     parser.add_argument(
-            '--no-update-working-tree',
-            action='store_true',
-            help='By default formatting changes made to staged file content will also be applied to working tree files via a patch. This option disables that behavior, leaving working tree files untouched.'
-            )
+        "--no-update-working-tree",
+        action="store_true",
+        help="By default formatting changes made to staged file content will also be applied to working tree files via a patch. This option disables that behavior, leaving working tree files untouched.",
+    )
     parser.add_argument(
-            '--no-write',
-            action='store_true',
-            help='Prevents %(prog)s from modifying staged or working tree files. You can use this option to check staged changes with a linter instead of formatting. With this option stdout from the formatter command is ignored. Example: %(prog)s --no-write -f "eslint --stdin --stdin-filename {} >&2" "*.js"'
-            )
+        "--no-write",
+        action="store_true",
+        help='Prevents %(prog)s from modifying staged or working tree files. You can use this option to check staged changes with a linter instead of formatting. With this option stdout from the formatter command is ignored. Example: %(prog)s --no-write -f "eslint --stdin --stdin-filename {} >&2" "*.js"',
+    )
     parser.add_argument(
-            '--version',
-            action='version',
-            version='%(prog)s version {}'.format(VERSION),
-            help='Display version of %(prog)s'
-            )
+        "--version",
+        action="version",
+        version="%(prog)s version {}".format(VERSION),
+        help="Display version of %(prog)s",
+    )
     parser.add_argument(
-            '--verbose',
-            help='Show the formatting commands that are running',
-            action='store_true'
-            )
+        "--verbose",
+        help="Show the formatting commands that are running",
+        action="store_true",
+    )
     parser.add_argument(
-            'files',
-            nargs='+',
-            help='Patterns that specify files to format. The formatter will only transform staged files that are given here. Patterns may be literal file paths, or globs which will be tested against staged file paths using Python\'s fnmatch function. For example "src/*.js" will match all files with a .js extension in src/ and its subdirectories. Patterns may be negated to exclude files using a "!" character. Patterns are evaluated left-to-right. (Example: "main.js" "src/*.js" "test/*.js" "!test/todo/*")'
-            )
+        "files",
+        nargs="+",
+        help='Patterns that specify files to format. The formatter will only transform staged files that are given here. Patterns may be literal file paths, or globs which will be tested against staged file paths using Python\'s fnmatch function. For example "src/*.js" will match all files with a .js extension in src/ and its subdirectories. Patterns may be negated to exclude files using a "!" character. Patterns are evaluated left-to-right. (Example: "main.js" "src/*.js" "test/*.js" "!test/todo/*")',
+    )
     args = parser.parse_args()
-    files = vars(args)['files']
+    files = vars(args)["files"]
     format_staged_files(
-            file_patterns=files,
-            formatter=vars(args)['formatter'],
-            git_root=get_git_root(),
-            update_working_tree=not vars(args)['no_update_working_tree'],
-            write=not vars(args)['no_write'],
-            verbose=vars(args)['verbose']
-            )
+        file_patterns=files,
+        formatter=vars(args)["formatter"],
+        git_root=get_git_root(),
+        update_working_tree=not vars(args)["no_update_working_tree"],
+        write=not vars(args)["no_write"],
+        verbose=vars(args)["verbose"],
+    )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-format-staged",
-  "version": "3.1.2",
+  "version": "3.1.3",
   "description": "Git command to transform staged files according to a command that accepts file content on stdin and produces output on stdout.",
   "scripts": {
     "test": "ava",