gitpane 1.0.0__py3-none-any.whl

gitpane/history/revision_file.py

@@ -0,0 +1,182 @@
+"""Parse unified Git patches independently of their Qt presentation."""
+
+from __future__ import annotations
+
+import codecs
+import re
+from dataclasses import dataclass, field
+from difflib import SequenceMatcher
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from gitpane.config import COMMIT_LIMIT_BYTES, DIFF_FRAGMENT_LIMIT_CHARS, FILE_LINE_LIMIT_CHARS, FILE_PREVIEW_LIMIT_BYTES
+from gitpane.history.repository_value import BlobContent, BlobContentKind, FileStatus
+
+if TYPE_CHECKING:
+    from gitpane.history.repository_value import RevisionEntry
+
+
+def decode_blob_display(oid: str, raw_bytes: bytes, size_bytes: int | None = None) -> BlobContent:
+    """Classify a bounded preview without confusing decoded text with exact blob bytes."""
+    size = len(raw_bytes) if size_bytes is None else size_bytes
+    preview = raw_bytes[:FILE_PREVIEW_LIMIT_BYTES]
+    complete = len(preview) == size
+    kind, diagnostic, text = BlobContentKind.TEXT, "", ""
+    encoding = "utf-8"
+    has_bom = False
+    # UTF-32 must precede UTF-16 because their little-endian byte markers overlap.
+    for marker, candidate in ((codecs.BOM_UTF32_LE, "utf-32"), (codecs.BOM_UTF32_BE, "utf-32"), (codecs.BOM_UTF16_LE, "utf-16"),
+                              (codecs.BOM_UTF16_BE, "utf-16"), (codecs.BOM_UTF8, "utf-8-sig")):
+        if preview.startswith(marker):
+            encoding = candidate
+            has_bom = True
+            break
+    if not size:
+        kind, diagnostic = BlobContentKind.EMPTY, "Empty file"
+    elif b"\0" in preview and not has_bom:
+        kind, diagnostic = BlobContentKind.BINARY, f"Binary file — {size} bytes (blob)"
+    else:
+        try:
+            decoder = codecs.getincrementaldecoder(encoding)(errors="strict")
+            text = decoder.decode(preview, final=complete)
+        except UnicodeError:
+            text = preview.decode(encoding, "replace")
+            kind, diagnostic = BlobContentKind.ENCODING, "Unknown or invalid text encoding — replacement preview"
+    display_lines = []
+    for line in text.splitlines(keepends=True):
+        if len(line.rstrip("\r\n")) > FILE_LINE_LIMIT_CHARS:
+            line = line[:FILE_LINE_LIMIT_CHARS] + ("\n" if line.endswith(("\r", "\n")) else "")
+            complete = False
+        display_lines.append(line)
+    if not complete:
+        diagnostic = f"Preview limited — {size} bytes" + (f"; {diagnostic}" if diagnostic else "")
+    return BlobContent(oid, preview, "".join(display_lines), kind, complete, size, diagnostic)
+
+# First old and new line numbers of a hunk header in a text diff.
+HUNK_LINE_NUMBER_PATTERN = re.compile(r"^@@ -(?P<old>\d+)(?:,\d+)? \+(?P<new>\d+)(?:,\d+)? @@")
+
+
+def comparison_metadata(entry: RevisionEntry) -> bytes:
+    """Describe renames and mode-only changes even when identical blobs have no hunk."""
+    lines = []
+    if entry.status == FileStatus.RENAMED:
+        lines.extend([b"rename from " + (entry.old_path or b""), b"rename to " + (entry.new_path or b"")])
+    if entry.old_blob_oid and entry.new_blob_oid and entry.old_mode != entry.new_mode:
+        lines.extend([f"old mode {entry.old_mode}".encode(), f"new mode {entry.new_mode}".encode()])
+    return b"\n".join(lines) + b"\n" if lines else b""
+
+
+def unchanged_context(content: bytes) -> bytes:
+    """Show identical blob content as numbered context below rename or mode metadata."""
+    if not content:
+        return b"Empty file\n"
+    lines = content.split(b"\n")
+    final_linefeed = content.endswith(b"\n")
+    if final_linefeed:
+        lines.pop()
+    line_count = len(lines)
+    patch_lines = [f"@@ -1,{line_count} +1,{line_count} @@".encode()]
+    for line in lines:
+        patch_lines.append(b" " + line)
+    if not final_linefeed:
+        patch_lines.append(b"\")
+    return b"\n".join(patch_lines) + b"\n"
+
+
+class DiffLineKind(Enum):
+    """Role of one displayed line of a diff, shared by the diff reader and the line staging."""
+
+    HEADER = "header"
+    """A line outside any hunk: the diff and index headers, file names, mode or rename lines."""
+    HUNK = "hunk"
+    """A hunk header, ``@@ -old +new @@``, which sets the line numbers of the lines after it."""
+    CONTEXT = "context"
+    """An unchanged line, present on both sides."""
+    REMOVED = "removed"
+    """A line only the old side has."""
+    ADDED = "added"
+    """A line only the new side has."""
+    MARKER = "marker"
+    """Git's ``\`` note about the line before it."""
+
+
+@dataclass
+class DiffLine:
+    """Keep visual numbering and changed fragments outside the original patch text."""
+
+    old_number: int | None
+    new_number: int | None
+    kind: DiffLineKind
+    text: str
+    changed_spans: list[tuple[int, int]] = field(default_factory=list)
+
+
+@dataclass
+class DiffDocument:
+    """Retain the exact displayed lines and their independent comparison metadata."""
+
+    lines: list[DiffLine] = field(default_factory=list)
+
+
+def parse_unified_diff(patch: str) -> DiffDocument:
+    """Parse bounded patch text without interpreting file paths or rewriting its content."""
+    if len(patch.encode("utf-8")) > COMMIT_LIMIT_BYTES:
+        raise ValueError("Diff exceeds the display size limit")
+    document = DiffDocument()
+    old_number = new_number = 0
+    in_hunk = False
+    removed_lines: list[DiffLine] = []
+    added_lines: list[DiffLine] = []
+
+    def accent_pair() -> None:
+        """Compare nearby replacement lines under a fixed per-line work limit."""
+        prefix_length = 1
+        for removed, added in zip(removed_lines, added_lines, strict=False):
+            if max(len(removed.text), len(added.text)) > DIFF_FRAGMENT_LIMIT_CHARS:
+                continue
+            matcher = SequenceMatcher(None, removed.text[prefix_length:], added.text[prefix_length:], autojunk=True)
+            for kind, old_start, old_end, new_start, new_end in matcher.get_opcodes():
+                if kind == "equal":
+                    continue
+                if old_start != old_end:
+                    removed.changed_spans.append((old_start + prefix_length, old_end + prefix_length))
+                if new_start != new_end:
+                    added.changed_spans.append((new_start + prefix_length, new_end + prefix_length))
+        removed_lines.clear()
+        added_lines.clear()
+
+    for text in patch.removesuffix("\n").split("\n") if patch else ():
+        match = HUNK_LINE_NUMBER_PATTERN.match(text)
+        if match is not None:
+            accent_pair()
+            old_number, new_number = int(match.group("old")), int(match.group("new"))
+            in_hunk = True
+            line = DiffLine(None, None, DiffLineKind.HUNK, text)
+        elif text.startswith("\\") and in_hunk:
+            line = DiffLine(None, None, DiffLineKind.MARKER, text)
+        elif in_hunk and text.startswith("-"):
+            line = DiffLine(old_number, None, DiffLineKind.REMOVED, text)
+            old_number += 1
+            removed_lines.append(line)
+        elif in_hunk and text.startswith("+"):
+            line = DiffLine(None, new_number, DiffLineKind.ADDED, text)
+            new_number += 1
+            added_lines.append(line)
+        elif in_hunk and (text.startswith(" ") or not text):
+            accent_pair()
+            line = DiffLine(old_number, new_number, DiffLineKind.CONTEXT, text)
+            old_number += 1
+            new_number += 1
+        else:
+            accent_pair()
+            in_hunk = False
+            line = DiffLine(None, None, DiffLineKind.HEADER, text)
+        document.lines.append(line)
+    accent_pair()
+    return document
+
+
+def utf16_length(text: str) -> int:
+    """Translate Python character offsets to the UTF-16 units used by Qt cursors."""
+    bytes_per_unit = 2
+    return len(text.encode("utf-16-le")) // bytes_per_unit

gitpane/history_rewrite/graph.py

@@ -0,0 +1,210 @@
+"""Calculate commit replacements for a literal history removal."""
+
+from __future__ import annotations
+
+import heapq
+from typing import TYPE_CHECKING
+
+from gitpane.config import COMMIT_SUBJECT_LIMIT_CHARS
+from gitpane.history_rewrite.protocol import check_cancelled, matches_target
+from gitpane.history_rewrite.value import BranchRewrite, HistoryAnalysis, ImportCommit, RewriteRefusal, RewriteRefusalKind, RewriteRow, RewriteStatus
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import BinaryIO
+
+    from gitpane.history_rewrite.value import ExportCommit, RawCommit, RewriteCapture, RewriteTarget
+
+IDENTITY_DATE_FIELD_COUNT = 2
+
+
+def ordered_history(records: list[ExportCommit], raw_by_oid: dict[str, RawCommit], cancelled: Callable[[], bool] | None = None) -> list[ExportCommit]:
+    """Order the complete graph parents first, resolving every tie by full object ID."""
+    record_by_oid = {}
+    oid_by_mark = {}
+    children_by_oid: dict[str, list[str]] = {}
+    pending_by_oid = {}
+    for record in records:
+        check_cancelled(cancelled)
+        record_by_oid[record.oid] = record
+        oid_by_mark[record.mark] = record.oid
+        children_by_oid[record.oid] = []
+    for record in records:
+        check_cancelled(cancelled)
+        raw = raw_by_oid.get(record.oid)
+        if raw is None:
+            raise ValueError(f"Missing raw commit {record.oid}; restore the local object before retrying")
+        export_parents = []
+        for parent_ref in record.parent_refs:
+            export_parents.append(oid_by_mark.get(parent_ref, parent_ref))
+        if tuple(export_parents) != raw.parent_oids:
+            raise ValueError(f"Export ancestry does not match raw commit {raw.oid}; source unchanged")
+        parent_set = set(raw.parent_oids)
+        pending_by_oid[raw.oid] = len(parent_set)
+        for parent_oid in parent_set:
+            if parent_oid not in children_by_oid:
+                raise ValueError(f"Missing parent {parent_oid} of {raw.oid}; restore the local history before retrying")
+            children_by_oid[parent_oid].append(raw.oid)
+    ready_oids = []
+    for oid, pending in pending_by_oid.items():
+        if pending == 0:
+            heapq.heappush(ready_oids, oid)
+    ordered_records = []
+    while ready_oids:
+        check_cancelled(cancelled)
+        oid = heapq.heappop(ready_oids)
+        ordered_records.append(record_by_oid[oid])
+        for child_oid in children_by_oid[oid]:
+            pending_by_oid[child_oid] -= 1
+            if pending_by_oid[child_oid] == 0:
+                heapq.heappush(ready_oids, child_oid)
+    if len(ordered_records) != len(records):
+        raise ValueError("Cyclic or duplicate history records; restore the local history before retrying")
+    return ordered_records
+
+
+def affected_branch_closure(capture: RewriteCapture, target: RewriteTarget, records: list[ExportCommit], raw_by_oid: dict[str, RawCommit],
+                            cancelled: Callable[[], bool] | None = None) -> set[str]:
+    """Include active ancestors plus every local descendant affected by any newly included change."""
+    head_oid = capture.local_ref_by_name.get(capture.head_ref)
+    if head_oid is None:
+        raise ValueError("A named current branch is required; check out a local branch and retry")
+    children_by_oid: dict[str, list[str]] = {}
+    touched_oid_set = set()
+    for record in records:
+        check_cancelled(cancelled)
+        children_by_oid[record.oid] = []
+        if any(matches_target(change.path, target) for change in record.changes):
+            touched_oid_set.add(record.oid)
+    for name, oid in capture.local_ref_by_name.items():
+        check_cancelled(cancelled)
+        if oid not in children_by_oid:
+            raise ValueError(f"Missing branch tip {oid} for {name}; refresh the complete local history before retrying")
+    for record in records:
+        check_cancelled(cancelled)
+        for parent_oid in set(raw_by_oid[record.oid].parent_oids):
+            children_by_oid[parent_oid].append(record.oid)
+    included_oid_set: set[str] = set()
+    changed_oid_set: set[str] = set()
+    pending_include_oids = [head_oid]
+    pending_changed_oids: list[str] = []
+    # Every exported descendant leads to a local tip. Including its parents immediately avoids
+    # repeatedly walking a whole branch when a merge brings another affected ancestry into scope.
+    while pending_include_oids or pending_changed_oids:
+        while pending_include_oids:
+            check_cancelled(cancelled)
+            oid = pending_include_oids.pop()
+            if oid in included_oid_set:
+                continue
+            included_oid_set.add(oid)
+            pending_include_oids.extend(raw_by_oid[oid].parent_oids)
+            if oid in touched_oid_set:
+                pending_changed_oids.append(oid)
+        while pending_changed_oids:
+            check_cancelled(cancelled)
+            oid = pending_changed_oids.pop()
+            if oid in changed_oid_set:
+                continue
+            changed_oid_set.add(oid)
+            pending_include_oids.append(oid)
+            pending_changed_oids.extend(children_by_oid[oid])
+    return included_oid_set
+
+
+def remap_history(target: RewriteTarget, records: list[ExportCommit], raw_by_oid: dict[str, RawCommit],
+                  cancelled: Callable[[], bool] | None = None) -> tuple[dict[str, str | None], tuple[ImportCommit, ...]]:
+    """Rebuild a parent-ordered union once, retaining untouched identities and every merge parent."""
+    replacement_by_oid: dict[str, str | None] = {}
+    commits: list[ImportCommit] = []
+    for record in records:
+        check_cancelled(cancelled)
+        raw = raw_by_oid.get(record.oid)
+        if raw is None:
+            raise ValueError(f"Missing raw commit {record.oid}; restore the local object before retrying")
+        merge = len(raw.parent_oids) > 1
+        parent_refs = []
+        for parent_oid in raw.parent_oids:
+            if parent_oid not in replacement_by_oid:
+                raise ValueError(f"Missing parent {parent_oid} of {raw.oid}; restore the local history before retrying")
+            replacement = replacement_by_oid[parent_oid]
+            if merge and replacement is None:
+                raise RewriteRefusal(RewriteRefusalKind.INVALID_MERGE_PARENTS,
+                                     f"Merge {raw.oid} has no surviving parent for {parent_oid} after removing {target.path!r}; source unchanged, select a narrower target")
+            if replacement is not None:
+                parent_refs.append(replacement)
+        changes = []
+        touched = False
+        for change in record.changes:
+            if matches_target(change.path, target):
+                touched = True
+            else:
+                changes.append(change)
+        deleted = not merge and bool(record.changes) and not changes
+        if deleted:
+            replacement_by_oid[raw.oid] = next(iter(parent_refs), None)
+        elif not touched and tuple(parent_refs) == raw.parent_oids:
+            replacement_by_oid[raw.oid] = raw.oid
+        else:
+            replacement_by_oid[raw.oid] = record.mark
+            commits.append(ImportCommit(raw, record.mark, tuple(parent_refs), tuple(changes)))
+    return replacement_by_oid, tuple(commits)
+
+
+def contribution_rows(target: RewriteTarget, records: list[ExportCommit], raw_by_oid: dict[str, RawCommit], raw_source: BinaryIO, replacement_by_oid: dict[str, str | None],
+                      cancelled: Callable[[], bool] | None = None) -> tuple[RewriteRow, ...]:
+    """Show only changed first-parent contributions, independently of the full rewrite boundary."""
+    rows = []
+    for record in reversed(records):
+        check_cancelled(cancelled)
+        if any(matches_target(change.path, target) for change in record.changes):
+            raw = raw_by_oid[record.oid]
+            first_parent_oid = next(iter(raw.parent_oids), None)
+            deleted = replacement_by_oid[raw.oid] == replacement_by_oid.get(first_parent_oid)
+            raw_source.seek(raw.message_offset)
+            message = raw_source.read(min(raw.message_length, COMMIT_SUBJECT_LIMIT_CHARS))
+            identity, timestamp, timezone = raw.author.rsplit(b" ", IDENTITY_DATE_FIELD_COUNT)
+            author = identity.decode("utf-8", "surrogateescape")
+            date = b" ".join((timestamp, timezone)).decode("ascii", "replace")
+            subject, _separator, _remainder = message.partition(b"\n")
+            rows.append(RewriteRow(raw.oid, RewriteStatus.DELETED if deleted else RewriteStatus.MODIFIED,
+                                   subject.decode("utf-8", "surrogateescape"), author, date, raw.message_offset, raw.message_length))
+    return tuple(rows)
+
+
+def analyze_history(capture: RewriteCapture, target: RewriteTarget, records: list[ExportCommit], raw_by_oid: dict[str, RawCommit], raw_source: BinaryIO,
+                    cancelled: Callable[[], bool] | None = None) -> HistoryAnalysis:
+    """Filter the transitive local branch union while keeping unrelated histories outside the proposal."""
+    ordered_records = ordered_history(records, raw_by_oid, cancelled)
+    included_oid_set = affected_branch_closure(capture, target, ordered_records, raw_by_oid, cancelled)
+    selected_records = []
+    for record in ordered_records:
+        check_cancelled(cancelled)
+        if record.oid in included_oid_set:
+            selected_records.append(record)
+    replacement_by_oid, commits = remap_history(target, selected_records, raw_by_oid, cancelled)
+    rows = contribution_rows(target, selected_records, raw_by_oid, raw_source, replacement_by_oid, cancelled)
+    deleted_oid_set = set()
+    for row in rows:
+        if row.status == RewriteStatus.DELETED:
+            deleted_oid_set.add(row.oid)
+    signed_count = 0
+    for oid, replacement in replacement_by_oid.items():
+        check_cancelled(cancelled)
+        if raw_by_oid[oid].signed and replacement != oid:
+            signed_count += 1
+    branches = []
+    remote_refs_by_oid: dict[str, list[str]] = {}
+    for remote_name, remote_oid in capture.remote_ref_by_name.items():
+        remote_refs_by_oid.setdefault(remote_oid, []).append(remote_name)
+    for name in sorted(capture.local_ref_by_name, key=lambda name: (name != capture.head_ref, name)):
+        check_cancelled(cancelled)
+        old_oid = capture.local_ref_by_name[name]
+        if old_oid not in replacement_by_oid:
+            continue
+        new_oid = replacement_by_oid[old_oid]
+        if new_oid is None:
+            raise RewriteRefusal(RewriteRefusalKind.NO_SURVIVING_TIP,
+                                 f"Branch {name} at {old_oid} has no surviving commit after removing {target.path!r}; source unchanged, select a narrower target")
+        if new_oid != old_oid:
+            branches.append(BranchRewrite(name, old_oid, new_oid, capture.upstream_by_name.get(name), tuple(sorted(remote_refs_by_oid.get(old_oid, ()))), old_oid in deleted_oid_set))
+    return HistoryAnalysis(replacement_by_oid, commits, rows, tuple(branches), signed_count)