gitpane 1.0.0__py3-none-any.whl

gitpane/history/graph.py

@@ -0,0 +1,145 @@
+"""Lay out real parent edges in persistent lanes without inferring ancestry."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Set as AbstractSet
+
+
+@dataclass(frozen=True)
+class GraphSegment:
+    """Describe a portion of a direct child-parent edge in logical row coordinates."""
+
+    child_oid: str
+    parent_oid: str
+    start_lane: int
+    end_lane: int
+    start_position: float
+    end_position: float
+    color_index: int
+    kind: str = "parent"
+
+
+@dataclass(frozen=True)
+class GraphRow:
+    """Place exactly one commit node beside its incoming and outgoing edge portions."""
+
+    oid: str
+    lane: int
+    segments: list[GraphSegment]
+    lane_count: int
+    is_tip: bool
+    color_index: int
+
+
+ROW_TOP, ROW_CENTER, ROW_BOTTOM = 0.0, 0.5, 1.0
+
+
+class GraphLayout:
+    """Carry open parent edges across pages while keeping existing lanes stable."""
+
+    def __init__(self) -> None:
+        """Start with no pending ancestry or allocated lanes."""
+        self.lane_by_oid: dict[str, int] = {}
+        self.color_by_oid: dict[str, int] = {}
+        self.next_color_index = 0
+        self.open_edges: list[GraphSegment] = []
+        self.row_by_oid: dict[str, GraphRow] = {}
+
+    def append(self, oid: str, parent_oids: list[str], known_oid_set: AbstractSet[str], index_complete: bool) -> GraphRow:
+        """Extend only direct parent edges, marking missing or unread targets explicitly."""
+        existing = self.row_by_oid.get(oid)
+        if existing is not None:
+            return existing
+        lane = self.lane_by_oid.pop(oid, None)
+        is_tip = lane is None
+        if is_tip:
+            lane = self._right_lane()
+        color_index = self.color_by_oid.pop(oid, None)
+        if color_index is None:
+            color_index = self._new_color()
+        segments = []
+        # Built field by field rather than with dataclasses.replace, which costs several times more and runs for every
+        # open edge of every row of a long history.
+        for edge in self.open_edges:
+            ends_here = edge.parent_oid == oid
+            segments.append(GraphSegment(edge.child_oid, edge.parent_oid, edge.end_lane, lane if ends_here else edge.end_lane, ROW_TOP, ROW_CENTER if ends_here else ROW_BOTTOM,
+                                         edge.color_index, edge.kind))
+        first_parent_index = 0
+        for parent_index, parent_oid in enumerate(dict.fromkeys(parent_oids)):
+            target_lane = self.lane_by_oid.get(parent_oid)
+            if target_lane is None:
+                target_lane = lane if lane not in self.lane_by_oid.values() else self._right_lane()
+            parent_color = self.color_by_oid.get(parent_oid)
+            if parent_color is None:
+                parent_color = color_index if parent_index == first_parent_index else self._new_color()
+            unavailable = index_complete and parent_oid not in known_oid_set
+            kind = "unavailable" if unavailable else "pending" if parent_oid not in self.row_by_oid else "parent"
+            segment = GraphSegment(oid, parent_oid, lane, target_lane, ROW_CENTER, ROW_BOTTOM, parent_color, kind)
+            segments.append(segment)
+            if not unavailable:
+                self.lane_by_oid[parent_oid] = target_lane
+                self.color_by_oid[parent_oid] = parent_color
+        segments = self._compact_lane(segments)
+        lane_count = lane + 1
+        for segment in segments:
+            lane_count = max(lane_count, segment.start_lane + 1, segment.end_lane + 1)
+        row = GraphRow(oid, lane, segments, lane_count, is_tip, color_index)
+        self.row_by_oid[oid] = row
+        return row
+
+    def _right_lane(self) -> int:
+        """Start new branches beyond active ancestry, leaving gaps on its left unused."""
+        empty_lane = -1
+        return max(self.lane_by_oid.values(), default=empty_lane) + 1
+
+    def _new_color(self) -> int:
+        """Assign a branch identity independent of the lane it occupies after a join."""
+        color_index = self.next_color_index
+        self.next_color_index += 1
+        return color_index
+
+    def _compact_lane(self, segments: list[GraphSegment]) -> list[GraphSegment]:
+        """Close empty lanes below the nodes without moving previously published rows."""
+        previous_lanes = sorted(set(self.lane_by_oid.values()))
+        if not previous_lanes or previous_lanes[-1] == len(previous_lanes) - 1:
+            # No lane is empty, which is the common case: every segment and every lane stays where it is.
+            self.open_edges = []
+            for segment in segments:
+                if segment.end_position == ROW_BOTTOM and segment.kind != "unavailable":
+                    self.open_edges.append(segment)
+            return segments
+        lane_by_previous = {}
+        for lane, previous in enumerate(previous_lanes):
+            lane_by_previous[previous] = lane
+        compacted_segments = []
+        for segment in segments:
+            lane = lane_by_previous.get(segment.end_lane, segment.end_lane)
+            if segment.end_position != ROW_BOTTOM or segment.kind == "unavailable" or lane == segment.end_lane:
+                compacted_segments.append(segment)
+                continue
+            if segment.start_position == ROW_TOP:
+                compacted_segments.append(replace(segment, end_lane=segment.start_lane, end_position=ROW_CENTER))
+                segment = replace(segment, start_position=ROW_CENTER)
+            compacted_segments.append(replace(segment, end_lane=lane))
+        compacted_lane_by_oid = {}
+        for oid, lane in self.lane_by_oid.items():
+            compacted_lane_by_oid[oid] = lane_by_previous[lane]
+        self.lane_by_oid = compacted_lane_by_oid
+        self.open_edges = []
+        for segment in compacted_segments:
+            if segment.end_position == ROW_BOTTOM and segment.kind != "unavailable":
+                self.open_edges.append(segment)
+        return compacted_segments
+
+    def finish_index(self, known_oid_set: set[str]) -> None:
+        """Resolve unread boundaries once EOF proves which parent objects are unavailable."""
+        for oid, row in tuple(self.row_by_oid.items()):
+            segments = []
+            for segment in row.segments:
+                kind = "parent" if segment.parent_oid in known_oid_set else "unavailable"
+                segments.append(replace(segment, kind=kind))
+            self.row_by_oid[oid] = replace(row, segments=segments)

gitpane/history/history_filter.py

@@ -0,0 +1,31 @@
+"""Name what the filter of a repository window searches in each commit."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Self
+
+
+class HistoryFilterMode(Enum):
+    """What the filter field of a repository window compares the typed text with: the commit messages or the names of the files each commit changes.
+
+    The mode is never saved: it lives on the window only. The value is only written in diagnostics; the other
+    attributes are the texts the window shows for the mode.
+    """
+
+    MESSAGES = ("messages", "Filter messages", "Search full commit messages (* wildcard)", "Filter commit messages", "No message matches")
+    FILES = ("files", "Filter files", "Search changed file names (* wildcard)", "Filter changed file names", "No changed file matches")
+
+    def __new__(cls, value: str, label: str, placeholder: str, field_name: str, no_match_text: str) -> Self:
+        """Keep the diagnostic word as the value and the texts the window shows for the mode beside it."""
+        member = object.__new__(cls)
+        member._value_ = value
+        member.label = label
+        member.placeholder = placeholder
+        member.field_name = field_name
+        member.no_match_text = no_match_text
+        return member
+
+
+# Every opening of a window, and every repository picked in its switch list, starts on this mode.
+HISTORY_FILTER_INITIAL_MODE = HistoryFilterMode.MESSAGES