gitpane 1.0.0__py3-none-any.whl

gitpane/worktree/partial_patch.py

@@ -0,0 +1,435 @@
+"""Build selected changes from canonical Git bytes independently of displayed Unicode."""
+
+from __future__ import annotations
+
+import codecs
+import os
+import re
+import shutil
+import tempfile
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+from gitpane.config import FILE_PREVIEW_LIMIT_BYTES, GIT_MUTATION_TIMEOUT_MS, MUTATION_IDLE_TIMEOUT_MS, WORKTREE_OUTPUT_LIMIT_BYTES
+from gitpane.history.history_parse import CatFileParser
+from gitpane.history.repository_value import validate_oid
+from gitpane.history.revision_file import DiffLineKind
+from gitpane.process.process_runner import LOCAL_WRITE_PROFILE
+from gitpane.worktree.command_sequence import GitCommand
+from gitpane.worktree.worktree_snapshot import StagingSide, read_index
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from gitpane.worktree.worktree_file import FileImage
+    from gitpane.worktree.worktree_snapshot import LocalEntry, WorktreeKey, WorktreeSnapshot
+
+REGULAR_MODE_SET = frozenset(("100644", "100755"))
+ABSENT_MODE = "000000"
+# Hunk header of a patch read as bytes: old start, old count, new start, new count (counts may be absent).
+HUNK_HEADER_BYTES_PATTERN = re.compile(rb"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+LINE_PREFIX_LENGTH = 1
+INDEX_RECORD_TERMINATOR = b"\0"
+INDEX_METADATA_SEPARATOR = b"\t"
+INDEX_METADATA_FIELD_COUNT = 3
+MERGED_STAGE = b"0"
+# Role of a hunk line by the first byte Git writes on it.
+DIFF_LINE_KIND_BY_PREFIX: dict[bytes, DiffLineKind] = {b" ": DiffLineKind.CONTEXT, b"-": DiffLineKind.REMOVED, b"+": DiffLineKind.ADDED}
+
+
+@dataclass(frozen=True)
+class RawChange:
+    """Retain one exact Git line and its original patch and blob coordinates."""
+
+    kind: DiffLineKind
+    content: bytes
+    old_index: int | None
+    new_index: int | None
+    patch_index: int | None
+
+
+@dataclass(frozen=True)
+class RawLineSelection:
+    """Bind selected operations to one worktree, snapshot and original patch."""
+
+    key: WorktreeKey
+    snapshot_generation: int
+    side: StagingSide
+    path: bytes
+    line_ids: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class RawPatch:
+    """Keep complete before/after images and only byte-verified patch operations."""
+
+    snapshot: WorktreeSnapshot
+    entry: LocalEntry
+    before: bytes | None
+    after: bytes | None
+    before_oid: str
+    after_oid: str
+    mode: str
+    patch: bytes
+    changes: tuple[RawChange, ...]
+
+    def selected(self, selection: RawLineSelection) -> frozenset[int]:
+        """Reject forged, empty, non-Unstaged or stale operation identities."""
+        if (selection.key, selection.snapshot_generation, selection.side, selection.path) != (self.snapshot.key, self.snapshot.generation, StagingSide.UNSTAGED, self.entry.path):
+            raise ValueError("The line selection is stale; select the changes again")
+        valid_id_set = {change.patch_index for change in self.changes if change.kind in (DiffLineKind.ADDED, DiffLineKind.REMOVED)}
+        selected_id_set = frozenset(selection.line_ids)
+        if not selected_id_set or not selected_id_set.issubset(valid_id_set):
+            raise ValueError("Select changed lines in the Unstaged comparison")
+        return selected_id_set
+
+    def stage_content(self, selection: RawLineSelection) -> bytes | None:
+        """Replay exactly the selected additions and deletions into the index image."""
+        selected_id_set = self.selected(selection)
+        lines: list[bytes] = []
+        for change in self.changes:
+            chosen = change.patch_index in selected_id_set
+            if change.kind == DiffLineKind.CONTEXT or (change.kind == DiffLineKind.REMOVED and not chosen) or (change.kind == DiffLineKind.ADDED and chosen):
+                lines.append(change.content)
+        content = b"".join(lines)
+        if not content and self.after is None and all(change.kind != DiffLineKind.REMOVED or change.patch_index in selected_id_set for change in self.changes):
+            return None
+        return content
+
+
+def byte_lines(content: bytes) -> list[bytes]:
+    """Split only Git LF boundaries while preserving CR, invalid bytes and missing EOF LF."""
+    pieces = content.split(b"\n")
+    last_index = len(pieces) - 1
+    lines: list[bytes] = []
+    for index, piece in enumerate(pieces):
+        if index != last_index:
+            lines.append(piece + b"\n")
+        elif piece:
+            lines.append(piece)
+    return lines
+
+
+def parse_changes(patch: bytes, before: bytes, after: bytes) -> tuple[RawChange, ...]:
+    """Check every patch byte against both blobs, including omitted context and EOF markers."""
+    old_lines, new_lines = byte_lines(before), byte_lines(after)
+    changes: list[RawChange] = []
+    old_index = new_index = 0
+    in_hunk = False
+    for patch_index, line in enumerate(byte_lines(patch)):
+        match = HUNK_HEADER_BYTES_PATTERN.match(line)
+        if match:
+            old_start, old_count, new_start, new_count = match.groups()
+            old_target = int(old_start) - (0 if old_count == b"0" else 1)
+            new_target = int(new_start) - (0 if new_count == b"0" else 1)
+            while old_index < old_target and new_index < new_target:
+                changes.append(RawChange(DiffLineKind.CONTEXT, old_lines[old_index], old_index, new_index, None))
+                old_index += 1
+                new_index += 1
+            if old_index != old_target or new_index != new_target:
+                raise ValueError("Patch coordinates do not match the captured files")
+            in_hunk = True
+            continue
+        if not in_hunk:
+            continue
+        if line.startswith(b"\"):
+            previous_index = len(changes) - 1
+            if previous_index < 0 or not changes[previous_index].content.endswith(b"\n"):
+                raise ValueError("Invalid patch newline marker")
+            changes[previous_index] = replace(changes[previous_index], content=changes[previous_index].content.removesuffix(b"\n"))
+            continue
+        prefix = line[:LINE_PREFIX_LENGTH]
+        if prefix not in DIFF_LINE_KIND_BY_PREFIX:
+            raise ValueError("Unsupported patch record")
+        kind = DIFF_LINE_KIND_BY_PREFIX[prefix]
+        changes.append(RawChange(kind, line[LINE_PREFIX_LENGTH:], old_index if prefix != b"+" else None, new_index if prefix != b"-" else None, patch_index))
+        old_index += prefix != b"+"
+        new_index += prefix != b"-"
+    while old_index < len(old_lines) and new_index < len(new_lines):
+        changes.append(RawChange(DiffLineKind.CONTEXT, old_lines[old_index], old_index, new_index, None))
+        old_index += 1
+        new_index += 1
+    old_result: list[bytes] = []
+    new_result: list[bytes] = []
+    for change in changes:
+        if change.old_index is not None:
+            old_result.append(change.content)
+        if change.new_index is not None:
+            new_result.append(change.content)
+    if b"".join(old_result) != before or b"".join(new_result) != after:
+        raise ValueError("The patch cannot reproduce the captured bytes")
+    return tuple(changes)
+
+
+def is_null_oid(oid: str) -> bool:
+    """Recognize the all-zero object ID Git writes for a side that has no object."""
+    return bool(oid) and not oid.strip("0")
+
+
+def starting_side(entry: LocalEntry) -> tuple[str, str | None]:
+    """Return the index mode and blob the verified capture names for the selection, or no blob when the index has none.
+
+    The capture listed them from the very index whose bytes the private copy is proven equal to, so listing that copy
+    again would only repeat what is already known. A mode without an object, or an object without a mode, is refused.
+    """
+    oid = entry.old_blob_oid
+    if entry.old_mode == ABSENT_MODE:
+        if oid is not None and not is_null_oid(oid):
+            raise ValueError("The captured index entry names an object without a mode; refresh the changes")
+        return ABSENT_MODE, None
+    if oid is None or is_null_oid(validate_oid(oid)):
+        raise ValueError("The captured index entry has a mode without an object; refresh the changes")
+    return entry.old_mode, oid
+
+
+def parse_final_entry(listing: bytes, path: bytes) -> tuple[str, str] | None:
+    """Read the one merged record of the selected path after the private add; an empty listing means Git removed it."""
+    if not listing:
+        return None
+    if not listing.endswith(INDEX_RECORD_TERMINATOR):
+        raise ValueError("Incomplete Git index entry output")
+    records = listing.removesuffix(INDEX_RECORD_TERMINATOR).split(INDEX_RECORD_TERMINATOR)
+    if len(records) != 1:
+        raise ValueError("The private index lists the selected path more than once")
+    metadata, separator, listed_path = records[0].partition(INDEX_METADATA_SEPARATOR)
+    fields = metadata.split(b" ")
+    if not separator or listed_path != path or len(fields) != INDEX_METADATA_FIELD_COUNT or fields[-1] != MERGED_STAGE:
+        raise ValueError("The private index does not hold one merged entry for the selected path")
+    mode_field, oid_field, _stage = fields
+    mode = mode_field.decode("ascii")
+    oid = validate_oid(oid_field.decode("ascii"))
+    if mode not in REGULAR_MODE_SET or is_null_oid(oid):
+        raise ValueError("Line actions require a regular file")
+    return mode, oid
+
+
+def read_blob_bodies(oids: list[str]) -> Generator[GitCommand, bytes, dict[str, bytes]]:
+    """Read several blobs in one bounded cat-file batch, keeping only complete bodies of exactly the requested objects.
+
+    The strict framing refuses a missing, repeated, foreign or non-blob answer, and a body over the limit arrives as
+    an explicit unavailable marker, which is refused here rather than ever being taken for an empty file.
+    """
+    content_by_oid: dict[str, bytes | None] = {}
+    parser = CatFileParser(oids, object_limit_bytes=WORKTREE_OUTPUT_LIMIT_BYTES, expected_object_type="blob")
+
+    def consume_blobs(chunk: bytes) -> None:
+        """Feed Git's stream to the framing and keep each finished body under its object ID."""
+        for oid, body in parser.feed(chunk):
+            content_by_oid[oid] = body
+
+    yield GitCommand(["cat-file", "--batch"], stdin="".join(oid + "\n" for oid in oids).encode("ascii"), consume=consume_blobs, stdout_limit_bytes=None)
+    parser.finish()
+    body_by_oid: dict[str, bytes] = {}
+    for oid in oids:
+        body = content_by_oid.get(oid)
+        if body is None:
+            raise ValueError("Line actions are unavailable for files this large")
+        body_by_oid[oid] = body
+    return body_by_oid
+
+
+def read_partial(snapshot: WorktreeSnapshot, entry: LocalEntry) -> Generator[GitCommand, bytes, RawPatch]:
+    """Canonicalize only the selected path in a private index and read Git's actual byte diff.
+
+    The index side comes from the verified capture, both blobs come from one object batch, and the empty object is
+    written only when one side is missing, because only then does the comparison need it.
+    """
+    if not snapshot.fresh or entry.side != StagingSide.UNSTAGED or entry not in snapshot.entries or entry.skip_worktree or any(item.conflict_stages for item in snapshot.entries):
+        raise ValueError("A complete current Unstaged comparison is required")
+    if entry.old_mode not in REGULAR_MODE_SET | {ABSENT_MODE} or entry.new_mode not in REGULAR_MODE_SET | {ABSENT_MODE}:
+        raise ValueError("Line actions require a regular text file")
+    before_mode, before_oid = starting_side(entry)
+    # A file added with --intent-to-add is in the index with an empty body but the capture names no object for it:
+    # its index side is present and empty, which is not the same as a file the index does not have.
+    intent_to_add = before_oid is None and entry.old_path is not None
+    with tempfile.TemporaryDirectory(prefix="gitpane-lines-", dir=snapshot.context.git_dir) as operation_dir:
+        candidate_filename = os.path.join(operation_dir, "canonical-index")
+        environment_by_name = {"GIT_INDEX_FILE": candidate_filename}
+        if snapshot.index_content is not None:
+            shutil.copy2(snapshot.index_filename, candidate_filename)
+            if read_index(candidate_filename) != snapshot.index_content:
+                raise ValueError("The index changed while reading the selected lines")
+        else:
+            yield GitCommand(["read-tree", "--empty"], environment_by_name=environment_by_name, profile=LOCAL_WRITE_PROFILE)
+        # This command sits on a reading path but still writes objects and runs the user's clean filters, which must
+        # have finished before the repository is handed back, so it is launched under supervision like any write.
+        yield GitCommand(["add", "--pathspec-from-file=-", "--pathspec-file-nul"], stdin=entry.path + b"\0", environment_by_name=environment_by_name,
+                         timeout_ms=GIT_MUTATION_TIMEOUT_MS, idle_timeout_ms=MUTATION_IDLE_TIMEOUT_MS, profile=LOCAL_WRITE_PROFILE)
+        final_entry = parse_final_entry((yield GitCommand(["ls-files", "--stage", "-z", "--", os.fsdecode(entry.path)], environment_by_name=environment_by_name)), entry.path)
+        after_oid = None if final_entry is None else final_entry[1]
+        if before_oid is None and final_entry is None:
+            raise ValueError("The selected file is neither in the index nor in the working tree")
+        mode = before_mode if before_oid is not None else final_entry[0]
+        requested_oid_set: set[str] = set()
+        for oid in (before_oid, after_oid):
+            if oid is not None:
+                requested_oid_set.add(oid)
+        body_by_oid = yield from read_blob_bodies(sorted(requested_oid_set))
+        before = body_by_oid[before_oid] if before_oid is not None else b"" if intent_to_add else None
+        after = body_by_oid[after_oid] if after_oid is not None else None
+        if b"\0" in (before or b"") or b"\0" in (after or b""):
+            raise ValueError("Line actions are unavailable for binary files")
+        if before_oid is None or after_oid is None:
+            empty_oid = (yield GitCommand(["hash-object", "-w", "--no-filters", "--stdin"], stdin=b"", profile=LOCAL_WRITE_PROFILE)).strip().decode("ascii")
+            before_oid = before_oid or (empty_oid if intent_to_add else None)
+            before_side_oid, after_side_oid = before_oid or empty_oid, after_oid or empty_oid
+        else:
+            before_side_oid, after_side_oid = before_oid, after_oid
+        patch = yield GitCommand(["diff", "--no-ext-diff", "--no-textconv", "--no-color", "--no-renames", "--diff-algorithm=myers", "--no-indent-heuristic", "--unified=3",
+                                  before_side_oid, after_side_oid], stdout_limit_bytes=FILE_PREVIEW_LIMIT_BYTES)
+        return RawPatch(snapshot, entry, before, after, before_oid or "", after_oid or "", mode, patch, parse_changes(patch, before or b"", after or b""))
+
+
+def stage_candidate(model: RawPatch, selection: RawLineSelection, environment_by_name: dict[str, str]) -> Generator[GitCommand, bytes, bytes | None]:
+    """Store already canonical selected bytes once, verify the written object, and return the index record to expect.
+
+    The returned record is written the way ls-files --stage -z lists it: mode, object ID, stage 0, the raw path and a
+    final NUL. None means the path must be absent from the candidate. The caller checks it in the complete listing it
+    already needs for the neighbors. The object is still read back: a listing naming the announced ID does not prove
+    that the written object holds the selected bytes.
+    """
+    content = model.stage_content(selection)
+    if content is None:
+        yield GitCommand(["update-index", "--force-remove", "-z", "--stdin"], stdin=model.entry.path + INDEX_RECORD_TERMINATOR, environment_by_name=environment_by_name,
+                         profile=LOCAL_WRITE_PROFILE)
+        return None
+    oid = (yield GitCommand(["hash-object", "-w", "--no-filters", "--stdin"], stdin=content, profile=LOCAL_WRITE_PROFILE)).strip()
+    validate_oid(oid.decode("ascii"))
+    record = model.mode.encode("ascii") + b" " + oid + INDEX_METADATA_SEPARATOR + model.entry.path + INDEX_RECORD_TERMINATOR
+    yield GitCommand(["update-index", "-z", "--index-info"], stdin=record, environment_by_name=environment_by_name, profile=LOCAL_WRITE_PROFILE)
+    actual = yield GitCommand(["cat-file", "blob", oid.decode("ascii")])
+    if actual != content:
+        raise ValueError("The candidate index does not contain the selected bytes")
+    return model.mode.encode("ascii") + b" " + oid + b" " + MERGED_STAGE + INDEX_METADATA_SEPARATOR + model.entry.path + INDEX_RECORD_TERMINATOR
+
+
+@dataclass(frozen=True)
+class RawSlices:
+    """Retain the original per-line bytes and any encoding prefix separately."""
+
+    prefix: bytes
+    lines: tuple[bytes, ...]
+    codec: str = ""
+
+
+def line_slices(canonical: bytes, raw: bytes, encoding: str = "") -> RawSlices:
+    """Prove an exact LF/CRLF or working-tree-encoding correspondence without rewriting untouched bytes."""
+    prefix = b""
+    codec = ""
+    lines = byte_lines(raw)
+    comparisons = lines
+    if encoding:
+        normalized_encoding = encoding.lower().replace("-", "")
+        encoding_by_marker = ((codecs.BOM_UTF32_LE, "utf-32-le"), (codecs.BOM_UTF32_BE, "utf-32-be"),
+                              (codecs.BOM_UTF16_LE, "utf-16-le"), (codecs.BOM_UTF16_BE, "utf-16-be"), (codecs.BOM_UTF8, "utf-8"))
+        codec = encoding
+        for marker, candidate in encoding_by_marker:
+            if raw.startswith(marker) and normalized_encoding.startswith(candidate.replace("-", "").removesuffix("le").removesuffix("be")):
+                prefix = marker
+                codec = candidate
+                break
+        try:
+            text = raw[len(prefix):].decode(codec, "strict")
+            utf8_lines = byte_lines(text.encode("utf-8"))
+            lines = []
+            comparisons = []
+            for line in utf8_lines:
+                lines.append(line.decode("utf-8").encode(codec))
+                comparisons.append(line)
+        except (LookupError, UnicodeError) as error:
+            raise ValueError("Working-tree encoding has no exact line correspondence") from error
+        if prefix + b"".join(lines) != raw:
+            raise ValueError("Working-tree encoding cannot preserve the original bytes")
+    canonical_lines = byte_lines(canonical)
+    if len(canonical_lines) != len(comparisons):
+        raise ValueError("Git conversion has no exact line correspondence")
+    for expected, actual in zip(canonical_lines, comparisons, strict=True):
+        normalized = actual.removesuffix(b"\r\n") + b"\n" if actual.endswith(b"\r\n") else actual
+        if expected != actual and expected != normalized:
+            raise ValueError("Git conversion has no exact line correspondence")
+    return RawSlices(prefix, tuple(lines), codec)
+
+
+def filtered_line_slices(canonical: bytes, raw: bytes, materialized: bytes, path: bytes) -> Generator[GitCommand, bytes, RawSlices]:
+    """Allow reversible line filters only when full round-trip and individual line transforms agree."""
+    if raw != materialized:
+        raise ValueError("The Git filter is not reversible for these working bytes; partial reset is unavailable")
+    canonical_lines, raw_lines = byte_lines(canonical), byte_lines(raw)
+    if len(canonical_lines) != len(raw_lines):
+        raise ValueError("The Git filter changes line boundaries; partial reset is unavailable")
+    for expected, actual in zip(canonical_lines, raw_lines, strict=True):
+        expected_oid = yield GitCommand(["hash-object", "--no-filters", "--stdin"], stdin=expected)
+        # With a path, Git runs the user's clean filter, an outside program that must have finished before the
+        # repository is handed back, so this command is supervised even though it writes nothing itself.
+        actual_oid = yield GitCommand(["hash-object", "--path=" + os.fsdecode(path), "--stdin"], stdin=actual,
+                                      timeout_ms=GIT_MUTATION_TIMEOUT_MS, idle_timeout_ms=MUTATION_IDLE_TIMEOUT_MS, profile=LOCAL_WRITE_PROFILE)
+        if expected_oid != actual_oid:
+            raise ValueError("The Git filter depends on surrounding lines; partial reset is unavailable")
+    return RawSlices(b"", tuple(raw_lines))
+
+
+def reset_content(model: RawPatch, selection: RawLineSelection, working: FileImage, restored: FileImage,
+                  materialized_working: FileImage | None, encoding: str = "", has_filter: bool = False) -> Generator[GitCommand, bytes, bytes | None]:
+    """Invert selected operations using original working slices and Git-materialized index slices."""
+    selected_id_set = model.selected(selection)
+    old_content, work_content = model.before or b"", model.after or b""
+    if has_filter:
+        old_slices = yield from filtered_line_slices(old_content, restored.read(), restored.read(), model.entry.path)
+        work_slices = yield from filtered_line_slices(work_content, working.read(), materialized_working.read(), model.entry.path)
+    else:
+        old_slices = line_slices(old_content, restored.read(), encoding)
+        work_slices = line_slices(work_content, working.read(), encoding)
+    if old_slices.codec and work_slices.codec and old_slices.codec != work_slices.codec:
+        # Git's UTF-16 materialization may choose the other byte order; encode restored lines to the existing working BOM.
+        restored_lines: list[bytes] = []
+        for line in old_slices.lines:
+            restored_lines.append(line.decode(old_slices.codec).encode(work_slices.codec))
+        old_slices = RawSlices(work_slices.prefix, tuple(restored_lines), work_slices.codec)
+    raw_lines: list[bytes] = []
+    canonical_lines: list[bytes] = []
+    for change in reset_order(model.changes):
+        chosen = change.patch_index in selected_id_set
+        if change.kind == DiffLineKind.CONTEXT or (change.kind == DiffLineKind.ADDED and not chosen):
+            raw_lines.append(work_slices.lines[change.new_index])
+            canonical_lines.append(change.content)
+        elif change.kind == DiffLineKind.REMOVED and chosen:
+            raw_lines.append(old_slices.lines[change.old_index])
+            canonical_lines.append(change.content)
+    prefix = work_slices.prefix if working.exists else old_slices.prefix
+    candidate = prefix + b"".join(raw_lines)
+    expected_oid = yield GitCommand(["hash-object", "--no-filters", "--stdin"], stdin=b"".join(canonical_lines))
+    actual_oid = yield GitCommand(["hash-object", "--path=" + os.fsdecode(model.entry.path), "--stdin"], stdin=candidate,
+                                  timeout_ms=GIT_MUTATION_TIMEOUT_MS, idle_timeout_ms=MUTATION_IDLE_TIMEOUT_MS, profile=LOCAL_WRITE_PROFILE)
+    if actual_oid != expected_oid:
+        raise ValueError("The reset candidate cannot preserve the unselected changes through Git conversion")
+    if not canonical_lines and model.before is None:
+        return None
+    return candidate
+
+
+def reset_order(changes: tuple[RawChange, ...]) -> tuple[RawChange, ...]:
+    """Anchor restored replacement lines beside their working counterparts instead of moving neighboring edits."""
+    ordered_changes: list[RawChange] = []
+    removed_changes: list[RawChange] = []
+    added_changes: list[RawChange] = []
+
+    def flush() -> None:
+        """Interleave one replacement run while retaining both original line orders."""
+        for index in range(max(len(removed_changes), len(added_changes))):
+            if index < len(removed_changes):
+                ordered_changes.append(removed_changes[index])
+            if index < len(added_changes):
+                ordered_changes.append(added_changes[index])
+        removed_changes.clear()
+        added_changes.clear()
+
+    for change in changes:
+        if change.kind == DiffLineKind.CONTEXT:
+            flush()
+            ordered_changes.append(change)
+        elif change.kind == DiffLineKind.REMOVED:
+            removed_changes.append(change)
+        else:
+            added_changes.append(change)
+    flush()
+    return tuple(ordered_changes)