fix(stats): return filenames instead of Git-quoted spellings

`Commit.stats.files` exposed Git's C-quoted output as dictionary keys. With
`core.quotePath=true`, byte names and many Unicode names were quoted; tabs,
newlines, quotes and backslashes could also produce keys that were not paths.

After parsing the numeric records, unquote filename keys with the existing
diff path decoder and lossless byte/text helpers. Unquoting after framing keeps
tabs and newlines inside filenames from becoming record delimiters. Native
statistics and the existing Gix filename-quoting fallback are unchanged.

The scripted Git 2.54.0 regression covers both quotePath settings, byte and
Unicode names, literal quoting/backslashes, root/update/delete commits and
binary counts. All eight subtests pass with both backends after failing before
the fix; the connected CLI stats/rename selection passes five tests and eight
subtests. Ruff, mypy and whitespace checks pass.

Author: codex

doc/source/changes.rst

@@ -69,7 +69,8 @@ API changes
 * ``Commit.stats`` preserves Unicode line separators in filenames when
   ``core.quotePath=false``. Git's LF-delimited output remains intact for root,
   subsequent and empty commits, including the Gix backend's filename
-  quoting fallback.
+  quoting fallback. File keys contain the actual names, unquoting Git's C-style
+  escapes and preserving undecodable bytes with ``surrogateescape``.
 * Imports from a source checkout now read ``git.__version__`` from ``VERSION``.
   Built wheels and source distributions continue to carry their stamped release
   version.

git/objects/commit.py

@@ -17,8 +17,9 @@
 
 from git import _backend
 from git.cmd import Git
+from git.compat import safe_decode, safe_encode
 from git.exc import BadObject, GitCommandError, UnsafeOptionError
-from git.diff import Diffable
+from git.diff import Diffable, decode_path
 from git.util import Actor, Stats, finalize_process, hex_to_bin
 
 from . import base
@@ -47,7 +48,7 @@
     cast,
 )
 
-from git.types import PathLike
+from git.types import Files_TD, PathLike
 
 if TYPE_CHECKING:
     from git.refs import SymbolicReference
@@ -529,7 +530,14 @@ def process_lines(lines: List[str]) -> str:
                 "diff", self.parents[0].hexsha, self.hexsha, "--", numstat=True, no_renames=True, raw=True
             ).split("\n")
             text = process_lines(lines)
-        return Stats._list_from_string(self.repo, text)
+        stats = Stats._list_from_string(self.repo, text)
+        # Unquote after parsing: filenames themselves may contain tabs and newlines.
+        files: Dict[PathLike, Files_TD] = {
+            safe_decode(cast(bytes, decode_path(safe_encode(os.fspath(path)), has_ab_prefix=False))): values
+            for path, values in stats.files.items()
+        }
+        stats.files = files
+        return stats
 
     @property
     def trailers_list(self) -> List[Tuple[str, str]]:

test/test_commit.py

@@ -15,6 +15,7 @@
 from gitdb import IStream
 
 from git import Actor, Commit, Repo, _backend
+from git.compat import safe_decode, safe_encode
 from git.exc import UnsafeOptionError
 from git.objects.util import tzoffset, utc
 
@@ -225,6 +226,52 @@ def test_stats_preserve_unicode_line_separators(self):
             assert empty_stats.files == {}
             assert empty_stats.total == {"insertions": 0, "deletions": 0, "lines": 0, "files": 0}
 
+    def test_stats_preserve_quoted_filename_bytes(self):
+        paths = (
+            b"byte-\xff",
+            b'"byte-\\377"',
+            "utf8-é".encode(),
+            b"tab\tname",
+            b"line\nname",
+            b'quote"name',
+            b"back\\slash",
+        )
+        for quote_path in ("true", "false"):
+            with self.subTest(quote_path=quote_path), fixture_repo("commit-stats-byte-paths.sh", quote_path) as repo:
+                for revision, kind, added, deleted in (
+                    ("update-1", "A", 1, 0),
+                    ("update-2", "M", 1, 0),
+                    ("HEAD", "D", 0, 2),
+                ):
+                    with self.subTest(revision=revision):
+                        stats = repo.commit(revision).stats
+                        expected = {
+                            safe_decode(path): {
+                                "insertions": added,
+                                "deletions": deleted,
+                                "lines": added + deleted,
+                                "change_type": kind,
+                            }
+                            for path in paths
+                        }
+                        if kind != "M":
+                            expected["binary\tfile"] = {
+                                "insertions": 0,
+                                "deletions": 0,
+                                "lines": 0,
+                                "change_type": kind,
+                            }
+                        assert stats.files == expected
+                        assert {safe_encode(path) for path in stats.files} == set(paths) | (
+                            {b"binary\tfile"} if kind != "M" else set()
+                        )
+                        assert stats.total == {
+                            "insertions": len(paths) * added,
+                            "deletions": len(paths) * deleted,
+                            "lines": len(paths) * (added + deleted),
+                            "files": len(expected),
+                        }
+
     def test_renames(self):
         commit = self.rorepo.commit("185d847ec7647fd2642a82d9205fb3d07ea71715")
         files = commit.stats.files

tests/fixtures/commit-stats-byte-paths.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -eu
+git init --initial-branch=main repo
+cd repo
+git config core.quotePath "$1"
+git config diff.algorithm myers
+# Tree entries avoid filesystem restrictions on byte and control-character paths.
+paths=($'byte-\377' '"byte-\377"' $'utf8-\303\251' $'tab\tname' $'line\nname' 'quote"name' 'back\slash')
+binary=$(printf 'binary\0data' | git hash-object -w --stdin)
+for multiplier in 1 2; do
+    blob=$(for ((line=0; line<multiplier; line++)); do printf 'line\n'; done | git hash-object -w --stdin)
+    tree=$(
+        {
+            for path in "${paths[@]}"; do printf '100644 blob %s\t%s\0' "$blob" "$path"; done
+            printf '100644 blob %s\tbinary\tfile\0' "$binary"
+        } | git mktree -z
+    )
+    if [ "$multiplier" = 1 ]; then
+        commit=$(git commit-tree "$tree" -m initial)
+    else
+        commit=$(git commit-tree "$tree" -p "$commit" -m update)
+    fi
+    git tag "update-$multiplier" "$commit"
+done
+tree=$(git mktree </dev/null)
+commit=$(git commit-tree "$tree" -p "$commit" -m remove)
+git update-ref refs/heads/main "$commit"