gitpane 1.0.0__py3-none-any.whl

gitpane/transport/remote_config.py

@@ -0,0 +1,544 @@
+"""Read the exact remote configuration of a repository from Git's config output.
+
+Each value keeps the scope and the file Git read it from, and the remotes, the branch tracking settings and the rewrite
+rules are interpreted the way Git itself interprets them, so the edits and the transfers work on what Git will use.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from gitpane.config import LOCAL_PREFIX, REFERENCE_ROOT_PREFIX, REMOTE_PREFIX, TAG_PREFIX
+from gitpane.reference.reference_snapshot import REFERENCE_LINE_TERMINATOR, parse_reference_read
+
+if TYPE_CHECKING:
+    from gitpane.history.repository_value import RepositoryContext
+
+
+class GitConfigScope(Enum):
+    """The source of a Git setting as Git names it, in what GitPane reads back as in what it writes.
+
+    The value is Git's word: the one ``git config --show-scope`` prints before each value, and the one GitPane puts
+    after "--" to choose the file a write goes to. The first members are the scopes Git's documentation of --show-scope
+    lists, in its order; ``UNKNOWN`` stands for any other word Git prints, and is never a scope GitPane writes to.
+    """
+
+    WORKTREE = "worktree"
+    LOCAL = "local"
+    GLOBAL = "global"
+    SYSTEM = "system"
+    COMMAND = "command"
+    UNKNOWN = "unknown"
+    """A scope word outside those the documentation of --show-scope lists, such as ``submodule``; ``unknown`` is Git's own
+    word for a source it cannot name. A setting is never written to it: the settings window only writes the global and
+    the local scopes."""
+
+
+def config_scope(text: str) -> GitConfigScope:
+    """Read the scope word Git printed before a configuration value.
+
+    A word Git does not document reads as ``UNKNOWN`` instead of failing the whole read; the word as printed stays in
+    ``ConfigRecord.scope_text``, which the console trace shows.
+    """
+    try:
+        return GitConfigScope(text)
+    except ValueError:
+        return GitConfigScope.UNKNOWN
+
+
+@dataclass(frozen=True)
+class RemoteValue:
+    """Keep every config value with its native scope and source filename."""
+
+    key: str
+    value: str
+    scope: GitConfigScope
+    origin: str
+    has_value: bool = True
+
+
+@dataclass(frozen=True)
+class ConfigRecord:
+    """One record of a NUL-delimited configuration listing, as the texts Git printed.
+
+    ``scope_text`` is the scope word as printed, before any reading of it; ``has_value`` tells a key Git listed with a
+    value, even an empty one, from a key it listed without any.
+    """
+
+    scope_text: str
+    origin: str
+    key: str
+    value: str
+    has_value: bool
+
+
+@dataclass(frozen=True)
+class RemoteEntry:
+    """Separate directly configured strings from Git's rewritten destinations."""
+
+    name: str
+    values: tuple[RemoteValue, ...]
+    fetch_urls: tuple[str, ...] = ()
+    push_urls: tuple[str, ...] = ()
+    active: bool = True
+    collision: bool = False
+
+
+@dataclass(frozen=True)
+class BranchTracking:
+    """Keep a local branch identity and Git's upstream independently of config multiplicity."""
+
+    full_ref: str
+    oid: str
+    values: tuple[RemoteValue, ...]
+    upstream: str = ""
+    observed: bool = False
+
+
+@dataclass(frozen=True)
+class RemoteSnapshot:
+    """Bind config entries and their source fingerprints to one repository view.
+
+    ``head_oid`` and ``head_ref`` are HEAD as the capture itself observed it, between the same reference signatures
+    as the branches: ``head_ref`` is a full branch name when HEAD is on a branch, born or not, and an empty string
+    when HEAD is detached. None means no observation was made, never a detached HEAD.
+    """
+
+    context: RepositoryContext
+    git_filename: str
+    generation: int
+    entry_by_name: dict[str, RemoteEntry]
+    values: tuple[RemoteValue, ...]
+    direct_values: tuple[RemoteValue, ...]
+    signature: tuple
+    references: bytes = b""
+    tracking_by_ref: dict[str, BranchTracking] = field(default_factory=dict)
+    reference_state: tuple = ()
+    head_oid: str | None = None
+    head_ref: str | None = None
+
+
+INACTIVE_REMOTE_SECTION = "-remote."
+# The two tracking settings of a branch, also the last part of its ``branch.<name>.<field>`` configuration keys.
+REMOTE_TRACKING_FIELD = "remote"
+MERGE_TRACKING_FIELD = "merge"
+# Git only accepts a remote named on the command line when one of its keys comes from the repository's own files.
+REPOSITORY_CONFIG_SCOPES = (GitConfigScope.LOCAL, GitConfigScope.WORKTREE)
+REMOTE_TRANSPORT_FIELDS = ("proxy", "proxyauthmethod", "receivepack", "uploadpack")
+GIT_BOOLEAN_MAXIMUM_INT = 2147483647
+GIT_INTEGER_PATTERN = re.compile(r"[ \t\n\r\v\f]*(?P<sign>[+-]?)(?P<digits>0x[0-9a-f]+|0[0-7]*|[1-9][0-9]*)(?P<unit>[kmg]?)")
+GIT_INTEGER_FACTOR_BY_UNIT = {"": 1, "k": 1024, "m": 1024 ** 2, "g": 1024 ** 3}
+# Two integer spellings mean different things to different Git builds, whatever their version number says. Git parses
+# numbers with the C library's strtoimax: one that follows C23 (glibc 2.38 and later, as on Ubuntu 26) reads a 0b
+# prefix as a binary number, while others stop at the 0 and refuse the rest. And recent Git releases accept the most
+# negative int that older ones (Git for Windows 2.47) refuse. GitPane cannot have one grammar that matches both, so it
+# refuses these spellings as invalid booleans rather than guess what the installed Git makes of them.
+GIT_BINARY_INTEGER_PREFIX_PATTERN = re.compile(r"[ \t\n\r\v\f]*[+-]?0b")
+
+
+def selected_endpoint_arguments(snapshot: RemoteSnapshot, name: str, endpoint: str, alias: str) -> list[str]:
+    """Build a private single-URL remote preserving only its effective transport settings."""
+    arguments = ["-c", "remote." + alias + ".url=" + endpoint, "-c", "remote." + alias + ".pushurl=" + endpoint,
+                 "-c", "remote." + alias + ".mirror=false"]
+    for field_name in REMOTE_TRANSPORT_FIELDS:
+        values = field_values(snapshot, name, field_name) if name else ()
+        if values:
+            *_, value = values
+            arguments.extend(["-c", "remote." + alias + "." + field_name + "=" + value.value])
+    return arguments
+
+
+def tracking_values(snapshot: RemoteSnapshot, full_ref: str, field: str) -> tuple[RemoteValue, ...]:
+    """Return every occurrence of one exact branch field, including inherited entries."""
+    key = "branch." + full_ref.removeprefix(LOCAL_PREFIX) + "." + field
+    return tuple(value for value in snapshot.values if value.key == key)
+
+
+def remote_section(snapshot: RemoteSnapshot, name: str) -> str:
+    """Choose the captured section without inferring state from widget presentation."""
+    entry = snapshot.entry_by_name.get(name)
+    return (INACTIVE_REMOTE_SECTION if entry is not None and not entry.active else "remote.") + name
+
+
+def field_values(snapshot: RemoteSnapshot, name: str, field: str, *, direct: bool = False) -> tuple[RemoteValue, ...]:
+    """Select all occurrences of a field without dropping scope or source identity."""
+    values: list[RemoteValue] = []
+    for value in snapshot.direct_values if direct else snapshot.values:
+        if value.key == remote_section(snapshot, name) + "." + field:
+            values.append(value)
+    return tuple(values)
+
+
+def parse_config_boolean(value: RemoteValue, description: str) -> bool:
+    """Interpret native boolean syntax without losing valueless keys or the caller's diagnostic.
+
+    A spelling whose meaning depends on how the installed Git was built (a binary ``0b`` number, or the most negative
+    int) is refused as an invalid boolean.
+    """
+    if not value.has_value:
+        return True
+    # Native Git compares ASCII bytes; Unicode case folding would accept lookalike keywords and suffixes.
+    if not value.value.isascii():
+        raise ValueError("Invalid boolean for " + description)
+    text = value.value.casefold()
+    if text in ("true", "yes", "on"):
+        return True
+    if text in ("", "false", "no", "off"):
+        return False
+    if GIT_BINARY_INTEGER_PREFIX_PATTERN.match(text):
+        raise ValueError("Invalid boolean for " + description)
+    match = GIT_INTEGER_PATTERN.fullmatch(text)
+    if match is None:
+        raise ValueError("Invalid boolean for " + description)
+    digits = match.group("digits")
+    base = 16 if digits.startswith("0x") else 8 if digits.startswith("0") else 10
+    # Git parses C integers with base detection and a signed-int bound before accepting a boolean.
+    try:
+        number = int(digits, base) * GIT_INTEGER_FACTOR_BY_UNIT[match.group("unit")]
+    except ValueError as error:
+        raise ValueError("Invalid boolean for " + description) from error
+    # The most negative int is past this bound too, so it is refused like the other spellings Git builds disagree on.
+    if number > GIT_BOOLEAN_MAXIMUM_INT:
+        raise ValueError("Invalid boolean for " + description)
+    return number != 0
+
+
+def remote_boolean(snapshot: RemoteSnapshot, name: str, field: str, *, aliases: tuple[str, ...] = ()) -> bool:
+    """Read the last native boolean occurrence, including aliases in their original config order."""
+    key_set: set[str] = set()
+    for field_name in (field, *aliases):
+        key_set.add(remote_section(snapshot, name) + "." + field_name)
+    values: list[RemoteValue] = []
+    for value in snapshot.values:
+        if value.key in key_set:
+            values.append(value)
+    if not values:
+        return False
+    last_index = len(values) - 1
+    return parse_config_boolean(values[last_index], "remote " + name + ": " + field)
+
+
+def fetch_branch_refspecs(snapshot: RemoteSnapshot, name: str) -> tuple[str, ...]:
+    """Keep configured branch mappings inside their remote namespace and exclude local tags."""
+    if remote_boolean(snapshot, name, "mirror"):
+        raise ValueError("Remote " + name + " is configured as a mirror. Adjust its configuration before fetching branches.")
+    refspecs: list[str] = []
+    namespace = REMOTE_PREFIX + name + "/"
+    for other_name in snapshot.entry_by_name:
+        if other_name != name and (other_name.startswith(name + "/") or name.startswith(other_name + "/")):
+            raise ValueError("Remote " + name + " overlaps the reference namespace of " + other_name + ". Adjust these remote names before fetching.")
+    for value in field_values(snapshot, name, "fetch"):
+        refspec = value.value
+        source, separator, destination = refspec.removeprefix("+").partition(":")
+        if source.startswith(TAG_PREFIX) and destination.startswith(TAG_PREFIX):
+            continue
+        negative = source.startswith("^")
+        if negative:
+            source = source.removeprefix("^")
+        if (not source.startswith(LOCAL_PREFIX) or any(character in refspec for character in ("\0", "\n", "\r"))
+                or (negative and separator) or (not negative and (not separator or not destination.startswith(namespace)))
+                or source.count("*") > 1 or (not negative and source.count("*") != destination.count("*"))):
+            raise ValueError("Remote " + name + " has an incompatible Fetch refspec. Adjust it to map branches only into " + namespace)
+        if refspec not in refspecs:
+            refspecs.append(refspec)
+    if not any(not refspec.startswith("^") for refspec in refspecs):
+        raise ValueError("Remote " + name + " has no configured branch Fetch refspec. Adjust it in Git configuration before fetching.")
+    return tuple(sorted(refspecs))
+
+
+def refspec_pattern_match(pattern: str, full_ref: str) -> str | None:
+    """Match one refspec side the way Git does: exact name, or one '*' standing for any text; return that text or None."""
+    if "*" not in pattern:
+        return "" if pattern == full_ref else None
+    prefix, _star, suffix = pattern.partition("*")
+    if len(full_ref) < len(prefix) + len(suffix) or not full_ref.startswith(prefix) or not full_ref.endswith(suffix):
+        return None
+    return full_ref[len(prefix):len(full_ref) - len(suffix)]
+
+
+def remote_tracking_ref(snapshot: RemoteSnapshot, remote_name: str, server_ref: str) -> str:
+    """Name the local remote-tracking branch that Git keeps for one server branch, or "" when there is none.
+
+    Git maps a server branch through the remote's Fetch refspecs: a matching negative refspec excludes it, otherwise the
+    first matching refspec in configuration order wins. Only a remote whose refspecs map branches inside its own
+    refs/remotes/<name>/ namespace is used, so the result can never point at a local branch or a tag.
+    """
+    if not remote_name or not server_ref.startswith(LOCAL_PREFIX):
+        return ""
+    try:
+        fetch_branch_refspecs(snapshot, remote_name)
+    except ValueError:
+        return ""
+    refspecs: list[str] = []
+    for value in field_values(snapshot, remote_name, "fetch"):
+        refspecs.append(value.value)
+    for refspec in refspecs:
+        if refspec.startswith("^") and refspec_pattern_match(refspec.removeprefix("^"), server_ref) is not None:
+            return ""
+    for refspec in refspecs:
+        if refspec.startswith("^"):
+            continue
+        source, separator, destination = refspec.removeprefix("+").partition(":")
+        if not separator or not destination.startswith(REMOTE_PREFIX + remote_name + "/"):
+            continue
+        matched = refspec_pattern_match(source, server_ref)
+        if matched is not None:
+            return destination.replace("*", matched, 1)
+    return ""
+
+
+def remote_reference_oid(snapshot: RemoteSnapshot, full_ref: str) -> str:
+    """Return the object a captured remote-tracking reference points to, or "" when it is absent."""
+    target = full_ref.encode("utf-8", "surrogateescape")
+    for record in snapshot.references.splitlines():
+        name, _separator, rest = record.partition(b"\0")
+        if name == target:
+            oid, _separator, _symref = rest.partition(b"\0")
+            return oid.decode("ascii")
+    return ""
+
+
+def refspec_write_refs(refspecs: tuple[str, ...]) -> tuple[str, ...]:
+    """Capture local destinations conservatively when a mapping cannot be understood."""
+    reference_set = set()
+    for refspec in refspecs:
+        if refspec.startswith("^"):
+            continue
+        source, separator, destination = refspec.removeprefix("+").partition(":")
+        if (not separator or not source.startswith(REFERENCE_ROOT_PREFIX) or not destination.startswith(REFERENCE_ROOT_PREFIX)
+                or source.count("*") > 1 or source.count("*") != destination.count("*")
+                or any(character in refspec for character in ("\0", "\n", "\r"))):
+            return ("refs/*",)
+        reference_set.add(destination)
+    return tuple(sorted(reference_set))
+
+
+def fetch_remote_name(snapshot: RemoteSnapshot, branch_ref: str | None) -> str:
+    """Resolve branch tracking or Git's origin fallback without choosing an arbitrary remote."""
+    names: list[str] = []
+    for name in sorted(snapshot.entry_by_name):
+        if snapshot.entry_by_name[name].active:
+            names.append(name)
+    if branch_ref and branch_ref.startswith(LOCAL_PREFIX):
+        values = tracking_values(snapshot, branch_ref, REMOTE_TRACKING_FIELD)
+        if values:
+            name_set = {value.value for value in values}
+            if len(name_set) == 1:
+                name = next(iter(name_set))
+                return name if name in names else ""
+            return ""
+    if branch_ref and branch_ref.startswith(REMOTE_PREFIX):
+        matches = []
+        for name in names:
+            if branch_ref.startswith(REMOTE_PREFIX + name + "/"):
+                matches.append(name)
+        if len(matches) == 1:
+            name, = matches
+            return name
+        return ""
+    if "origin" in names:
+        return "origin"
+    if len(names) == 1:
+        name, = names
+        return name
+    return ""
+
+
+def default_push_destination_name(snapshot: RemoteSnapshot, source_ref: str | None, remote_name: str | None) -> str:
+    """Name the remote branch Push proposes for a local branch: the branch it tracks on that remote, or its own name when it tracks nothing.
+
+    A branch that tracks something else (another remote, several branches, a remote without a branch) gets no
+    proposal, so the user chooses. The Push window and Commit & push both read their proposal here, so they agree.
+    """
+    if not source_ref or not source_ref.startswith(LOCAL_PREFIX):
+        return ""
+    merges = tracking_values(snapshot, source_ref, MERGE_TRACKING_FIELD)
+    remotes = tracking_values(snapshot, source_ref, REMOTE_TRACKING_FIELD)
+    if not merges and not remotes:
+        return source_ref.removeprefix(LOCAL_PREFIX)
+    if len(merges) != 1 or len(remotes) != 1:
+        return ""
+    merge, = merges
+    remote, = remotes
+    if remote.value != remote_name or not merge.value.startswith(LOCAL_PREFIX):
+        return ""
+    return merge.value.removeprefix(LOCAL_PREFIX)
+
+
+def matched_rewrite(url: str, values: tuple[RemoteValue, ...], suffix: str = ".insteadof") -> str | None:
+    """Apply Git's longest matching rewrite prefix, or answer None when no rule of that kind matches the URL."""
+    matching_values: list[RemoteValue] = []
+    for value in values:
+        if value.key.startswith("url.") and value.key.endswith(suffix) and url.startswith(value.value):
+            matching_values.append(value)
+    if not matching_values:
+        return None
+    longest = max(len(value.value) for value in matching_values)
+    destination_set: set[str] = set()
+    for value in matching_values:
+        if len(value.value) == longest:
+            destination_set.add(value.key.removeprefix("url.").removesuffix(suffix) + url[len(value.value):])
+    if len(destination_set) != 1:
+        raise ValueError("Conflicting URL rewrite rules; review Git configuration before saving")
+    return destination_set.pop()
+
+
+def rewrite_url(url: str, values: tuple[RemoteValue, ...], suffix: str = ".insteadof") -> str:
+    """Apply Git's longest insteadOf prefix to compare raw and expanded URL identities."""
+    rewritten = matched_rewrite(url, values, suffix)
+    return url if rewritten is None else rewritten
+
+
+def active_remote_urls(name: str, entry_values: tuple[RemoteValue, ...], values: tuple[RemoteValue, ...]) -> tuple[tuple[str, ...], tuple[str, ...]] | None:
+    """Answer what ``git remote get-url --all`` and ``--push --all`` print for one active remote, from its config values.
+
+    Git only knows a remote named on its command line when one of its keys comes from the repository's own files, so
+    a remote defined only globally or on the command line has no destination. An empty URL clears the URLs listed
+    before it, Fetch URLs go through the longest insteadOf rule and explicit Push URLs too; without an explicit Push
+    URL, the Fetch URLs a pushInsteadOf rule matches become the Push URLs, and failing any match the Fetch URLs are
+    used. Answers None for the cases whose result only Git can establish: a valueless URL or rewrite rule, which Git
+    refuses, no URL left, where Git falls back to the remote's name or to legacy remote files, a name Git ignores,
+    and two equally long rewrite rules with different destinations, where Git applies its own rule order.
+    """
+    if name.startswith("/"):
+        return None
+    if not any(value.scope in REPOSITORY_CONFIG_SCOPES for value in entry_values):
+        return (), ()
+    url_by_field: dict[str, list[str]] = {"url": [], "pushurl": []}
+    prefix = "remote." + name + "."
+    for value in entry_values:
+        urls = url_by_field.get(value.key.removeprefix(prefix))
+        if urls is None:
+            continue
+        if not value.has_value:
+            return None
+        if value.value:
+            urls.append(value.value)
+        else:
+            urls.clear()
+    fetch_raw_urls, push_raw_urls = url_by_field["url"], url_by_field["pushurl"]
+    if not fetch_raw_urls:
+        return None
+    for value in values:
+        if value.key.startswith("url.") and value.key.endswith((".insteadof", ".pushinsteadof")) and not value.has_value:
+            return None
+    try:
+        fetch_urls: list[str] = []
+        for url in fetch_raw_urls:
+            fetch_urls.append(rewrite_url(url, values))
+        push_urls: list[str] = []
+        if push_raw_urls:
+            for url in push_raw_urls:
+                push_urls.append(rewrite_url(url, values))
+        else:
+            for url in fetch_raw_urls:
+                rewritten = matched_rewrite(url, values, ".pushinsteadof")
+                if rewritten is not None:
+                    push_urls.append(rewritten)
+            if not push_urls:
+                push_urls = fetch_urls
+    except ValueError:
+        return None
+    return tuple(fetch_urls), tuple(push_urls)
+
+
+def parse_remote_reference_output(output: bytes) -> tuple[bytes, dict[str, tuple[str, str]], str | None, str | None]:
+    """Split one REFERENCE_FORMAT listing of branches and remote-tracking branches, whatever its line order.
+
+    The listing goes through the shared reference parser, so a cut, duplicated or doubly marked listing is refused
+    exactly as it is for the reference views, and HEAD is only named when that parser proves it; each local branch's
+    upstream comes from that same parse. Answers the remote-tracking branches in their historical
+    ``name NUL object NUL symbolic target`` lines sorted by name, each local branch's object and upstream (empty when it
+    has none), and HEAD's commit and branch or None for both.
+    """
+    read = parse_reference_read(output)
+    remote_record_by_name: dict[bytes, bytes] = {}
+    branch_state_by_ref: dict[str, tuple[str, str]] = {}
+    for reference in read.references:
+        object_oid = read.object_oid_by_name[reference.full_name]
+        if reference.full_name.startswith(REMOTE_PREFIX):
+            encoded_name = reference.full_name.encode("utf-8", "surrogateescape")
+            symbolic_target = (reference.symbolic_target or "").encode("utf-8", "surrogateescape")
+            remote_record_by_name[encoded_name] = encoded_name + b"\0" + object_oid.encode("ascii") + b"\0" + symbolic_target + REFERENCE_LINE_TERMINATOR
+        elif reference.full_name.startswith(LOCAL_PREFIX):
+            branch_state_by_ref[reference.full_name] = (object_oid, read.upstream_by_name.get(reference.full_name, ""))
+        else:
+            raise ValueError("Git listed a reference outside branches and remote-tracking branches")
+    remote_records: list[bytes] = []
+    # Git sorts by the bytes of the full name; sorting here keeps the historical stream independent of the listing order.
+    for encoded_name in sorted(remote_record_by_name):
+        remote_records.append(remote_record_by_name[encoded_name])
+    sorted_branch_state_by_ref: dict[str, tuple[str, str]] = {}
+    for full_ref in sorted(branch_state_by_ref):
+        sorted_branch_state_by_ref[full_ref] = branch_state_by_ref[full_ref]
+    return b"".join(remote_records), sorted_branch_state_by_ref, read.head_oid, read.head_ref
+
+
+def config_records(output: bytes) -> tuple[ConfigRecord, ...]:
+    """Split NUL-delimited scope, origin and key/value records into their texts, without deduplication."""
+    if not output:
+        return ()
+    if not output.endswith(b"\0"):
+        raise ValueError("Incomplete remote configuration")
+    fields = iter(output.removesuffix(b"\0").split(b"\0"))
+    records: list[ConfigRecord] = []
+    try:
+        for scope in fields:
+            origin, record = next(fields), next(fields)
+            key, separator, value = record.partition(b"\n")
+            records.append(ConfigRecord(scope.decode("utf-8", "surrogateescape"), origin.decode("utf-8", "surrogateescape"), key.decode("utf-8", "surrogateescape"),
+                                        value.decode("utf-8", "surrogateescape") if separator else "", bool(separator)))
+    except StopIteration as error:
+        raise ValueError("Incomplete remote configuration record") from error
+    return tuple(records)
+
+
+def parse_config(output: bytes) -> tuple[RemoteValue, ...]:
+    """Decode NUL-delimited scope, origin and key/value records without deduplication, each scope read as its member."""
+    values: list[RemoteValue] = []
+    for record in config_records(output):
+        values.append(RemoteValue(record.key, record.value, config_scope(record.scope_text), record.origin, record.has_value))
+    return tuple(values)
+
+
+def config_signature(context: RepositoryContext, values: tuple[RemoteValue, ...]) -> tuple:
+    """Detect changed or newly created config sources while a write is queued."""
+    filename_set = {os.path.join(context.common_git_dir, "config"), os.path.join(context.git_dir, "config.worktree")}
+    identity_records: list[tuple] = []
+    for directory in (context.repository_dir, context.git_dir, context.common_git_dir):
+        metadata = os.stat(directory)
+        identity_records.append((os.path.realpath(directory), metadata.st_dev, metadata.st_ino))
+    dot_git_filename = os.path.join(context.repository_dir, ".git")
+    if os.path.isfile(dot_git_filename):
+        filename_set.add(dot_git_filename)
+    for variable in ("GIT_CONFIG_GLOBAL", "GIT_CONFIG_SYSTEM"):
+        filename = os.environ.get(variable)
+        if filename:
+            filename_set.add(filename)
+    if not os.environ.get("GIT_CONFIG_GLOBAL"):
+        for filename in (os.path.join(os.path.expanduser("~"), ".gitconfig"), os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.join(os.path.expanduser("~"), ".config")), "git", "config")):
+            filename_set.add(filename)
+    for value in values:
+        if not value.origin.startswith("file:"):
+            continue
+        filename = value.origin.removeprefix("file:")
+        if not os.path.isabs(filename):
+            filename = os.path.join(context.repository_dir, filename)
+        filename_set.add(filename)
+        if (value.key == "include.path" or value.key.startswith("includeif.") and value.key.endswith(".path")) and value.value:
+            included_filename = os.path.expanduser(value.value)
+            if not os.path.isabs(included_filename):
+                included_filename = os.path.join(os.path.dirname(filename), included_filename)
+            filename_set.add(included_filename)
+    records: list[tuple] = []
+    for filename in sorted(filename_set):
+        try:
+            with open(filename, "rb") as stream:
+                records.append((filename, os.fstat(stream.fileno()).st_ino, stream.read()))
+        except FileNotFoundError:
+            records.append((filename, None, None))
+    return tuple(identity_records), tuple(records)