gitpane 1.0.0__py3-none-any.whl

gitpane/controller/session_registry.py

@@ -0,0 +1,337 @@
+"""Hold the open repository sessions of GitPane with what every controller reads about them."""
+
+from __future__ import annotations
+
+import weakref
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Self
+
+from PySide6.QtCore import QEvent, QObject, QTimer, Signal
+from shiboken6 import isValid
+
+from gitpane.history.file_history import WINDOW_CAPABILITY_BY_MODE
+from gitpane.history.repository_value import FilePanel, validate_oid
+
+if TYPE_CHECKING:
+    from PySide6.QtCore import QMetaObject
+    from PySide6.QtGui import QScreen
+    from PySide6.QtWidgets import QApplication, QMessageBox
+
+    from gitpane.controller.refresh_controller import RefreshRequest
+    from gitpane.history.file_history import FileHistoryAnchor, FileHistoryEngine, FileHistoryResult
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import Commit, ComparisonGroup, FileReadIdentity, HistorySnapshot, RepositoryContext, RequestIdentity, RevisionEntry, TreeEntry
+    from gitpane.ui.console.error_dialog import ErrorDialog
+    from gitpane.ui.repository.repository_window import RepositoryWindow, ViewAnchor
+    from gitpane.ui.setting.setting_dialog import SettingDialog
+    from gitpane.ui.staging.staging_window import StagingWindow
+    from gitpane.ui.transport.clone_dialog import CloneDialog
+    from gitpane.ui.welcome.welcome_window import WelcomeWindow
+    from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+
+class WindowDisplayBinding(QObject):
+    """Follow one window's screen and system appearance without altering its session.
+
+    The binding never keeps a QScreen object. PySide has a single Python object per screen and makes it a child of the
+    last widget or native window whose screen() returned it; once that window is destroyed, PySide marks the object
+    deleted for everyone who holds it, although the screen is still there. GitPane centres each repository window on the
+    Open repository window, reading that window's screen, then deletes the Open window: a kept object was dead from the
+    start and the repository window stopped following font, density and usable-area changes. Any other window that read
+    the screen last and is then closed does the same. The screen is therefore asked from the window at each refresh, and
+    the screen's notifications are held as connections, which can be cut without that object.
+    """
+
+    def __init__(self, window: WelcomeWindow | RepositoryWindow | StagingWindow | SettingDialog | ErrorDialog, application: QApplication) -> None:
+        """Connect once per native window and coalesce appearance events into one update."""
+        super().__init__(window)
+        self.window_ref = weakref.ref(window)
+        self.application = application
+        self.screen_connections: list[QMetaObject.Connection] = []
+        self.handle = None
+        self.ratio: float | None = None
+        self.refreshing = False
+        self.timer = QTimer(self)
+        self.timer.setSingleShot(True)
+        self.timer.timeout.connect(self.refresh)
+        window.installEventFilter(self)
+        application.screenRemoved.connect(self.screen_removed)
+        self.attach_handle()
+
+    def attach_handle(self) -> None:
+        """Attach to a newly created native handle without duplicating its screen callback."""
+        window = self.window_ref()
+        if window is None or not isValid(window):
+            return
+        handle = window.windowHandle()
+        if handle is None or handle is self.handle:
+            return
+        if self.handle is not None and isValid(self.handle):
+            self.handle.screenChanged.disconnect(self.set_screen)
+        self.handle = handle
+        handle.screenChanged.connect(self.set_screen)
+        self.set_screen(handle.screen())
+
+    def set_screen(self, screen: QScreen | None) -> None:
+        """Listen to the usable-area and density changes of the window's new screen only, then refresh."""
+        screen = screen if screen is not None else self.application.primaryScreen()
+        for connection in self.screen_connections:
+            QObject.disconnect(connection)
+        self.screen_connections = []
+        if screen is not None:
+            self.screen_connections = [screen.availableGeometryChanged.connect(self.schedule_refresh),
+                                       screen.logicalDotsPerInchChanged.connect(self.schedule_refresh)]
+        self.schedule_refresh()
+
+    def screen_removed(self, screen: QScreen) -> None:
+        """Follow the primary screen when the window's screen is unplugged, until Qt moves the window to a remaining one."""
+        if self.handle is not None and isValid(self.handle) and self.handle.screen() is screen:
+            self.set_screen(self.application.primaryScreen())
+
+    def schedule_refresh(self, *arguments: object) -> None:
+        """Collapse bursts of native events while ignoring our own layout changes."""
+        if not self.refreshing and not self.timer.isActive():
+            self.timer.start(0)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """React to window appearance changes while preserving the native event behavior."""
+        if event.type() in (QEvent.Type.Show, QEvent.Type.WinIdChange):
+            self.attach_handle()
+        if event.type() in (QEvent.Type.Show, QEvent.Type.ApplicationFontChange, QEvent.Type.FontChange, QEvent.Type.ApplicationPaletteChange,
+                            QEvent.Type.PaletteChange, QEvent.Type.DevicePixelRatioChange, QEvent.Type.ScreenChangeInternal):
+            self.schedule_refresh()
+        return super().eventFilter(watched, event)
+
+    def refresh(self) -> None:
+        """Rebuild logical metrics and density-specific photos without resetting data or focus, for the screen the window is on now."""
+        window = self.window_ref()
+        if window is None or not isValid(window) or self.refreshing or not window.isVisible():
+            return
+        screen = window.screen()
+        if screen is None:
+            return
+        self.refreshing = True
+        try:
+            window.refresh_metrics(screen.availableGeometry())
+            ratio = window.devicePixelRatioF()
+            panel = getattr(window, "commit_panel", None)
+            if panel is not None and ratio != self.ratio:
+                panel.refresh_avatar(ratio)
+            self.ratio = ratio
+            window.update()
+        finally:
+            self.refreshing = False
+
+
+class NavigationKind(Enum):
+    """The kind of one change of repository inside the same window.
+
+    It decides what the window carries over: a walk into a submodule or back to its parent keeps the family, the
+    position and the filter of the repository it returns to; a repository chosen in the switch menu keeps nothing.
+    Each kind carries its own texts: the operation named in a failure's details, the status line of a failure, and the
+    cause given when the target turns out to be another repository.
+    """
+
+    SUBMODULE = ("submodule", "Open submodule",
+                 "Could not open submodule '{directory}'. The current repository is still open. Review the details, fix the reported problem, then open the submodule again.",
+                 "The target does not resolve to its declared repository.")
+    SWITCH = ("switch", "Open repository",
+              "Could not open repository '{directory}'. The current repository is still open. Review the details, fix the reported problem, then choose it again.",
+              "The folder is no longer the top folder of a Git repository: Git opens another repository from it.")
+
+    def __new__(cls, value: str, operation_label: str, failure_status: str, target_mismatch_text: str) -> Self:
+        """Keep the kind's name as its value, and its three texts beside it."""
+        member = object.__new__(cls)
+        member._value_ = value
+        member.operation_label = operation_label
+        member.failure_status = failure_status
+        member.target_mismatch_text = target_mismatch_text
+        return member
+
+
+@dataclass
+class StreamedHistory:
+    """The rows the history read delivered for one history, in the order they came.
+
+    They are kept so that a search with an empty query, which shows every commit, can publish them again without
+    reading Git: a refresh, a walk into another repository, a file history without a filter, or a cleared filter.
+    """
+
+    snapshot: HistorySnapshot
+    commits: list[Commit] = field(default_factory=list)
+
+    def complete_commits(self, snapshot: HistorySnapshot) -> list[Commit] | None:
+        """Answer the kept rows only when they are exactly every commit of this complete history, in its order."""
+        if self.snapshot is not snapshot or not snapshot.complete or len(self.commits) != len(snapshot.ordered_oids):
+            return None
+        for commit, oid in zip(self.commits, snapshot.ordered_oids, strict=True):
+            if commit.oid != oid:
+                return None
+        return self.commits
+
+
+def keep_streamed_commits(streamed_history: StreamedHistory | None, snapshot: HistorySnapshot, commits: list[Commit]) -> StreamedHistory:
+    """Add delivered rows to the kept rows of their history, starting over when they belong to a new history."""
+    if streamed_history is None or streamed_history.snapshot is not snapshot:
+        streamed_history = StreamedHistory(snapshot)
+    streamed_history.commits.extend(commits)
+    return streamed_history
+
+
+class RepositorySession(QObject):
+    """Own navigation and request generations for one repository window."""
+
+    selection_changed = Signal(object)
+    navigation_requested = Signal(str)
+    closed = Signal()
+
+    def __init__(self, session_id: str, repository_context: RepositoryContext, repository: GitRepository, file_history_anchor: FileHistoryAnchor | None = None) -> None:
+        """Associate independent navigation state with an injected Git service."""
+        super().__init__()
+        self.session_id = session_id
+        self.repository_context = repository_context
+        self.repository = repository
+        self.file_history_anchor = file_history_anchor
+        self.file_history_generation = 0
+        self.file_history_result: FileHistoryResult | None = None
+        self.file_history_engine: FileHistoryEngine | None = None
+        self.mode = "file_history" if file_history_anchor is not None else "repository"
+        self.capabilities = WINDOW_CAPABILITY_BY_MODE[self.mode]
+        self.visible_oid_set: set[str] = set()
+        self.generation = 0
+        self.selection_generation = 0
+        self.selected_oid: str | None = None
+        self.filter_text = ""
+        self.anchor_oid: str | None = None
+        self.task_id_set: set[str] = set()
+        self.is_closed = False
+        self.snapshot: HistorySnapshot | None = None
+        self.search_generation = 0
+        self.search_identity: RequestIdentity | None = None
+        self.search_pending = False
+        self.matching_commits: list[Commit] = []
+        self.streamed_history: StreamedHistory | None = None
+        self.refresh_active = False
+        # The refresh asked while another one runs; it keeps its scope, its capture and its generation until it starts.
+        self.refresh_queued: RefreshRequest | None = None
+        self.view_anchor: ViewAnchor | None = None
+        self.relation_generation = 0
+        self.relation_identity: RequestIdentity | None = None
+        self.navigation_oid: str | None = None
+        self.navigation_commit: Commit | None = None
+        self.navigation_filter_cleared = False
+        self.panel_generation = 0
+        self.file_identity_by_kind: dict[FilePanel, FileReadIdentity] = {}
+        self.diff_groups: list[ComparisonGroup] = []
+        self.selected_entry: RevisionEntry | None = None
+        self.tree_entries: list[TreeEntry] = []
+        # The tree read that answered while its tab was hidden; its entries are built when the File tree tab comes back.
+        self.pending_tree_identity: FileReadIdentity | None = None
+        self.selected_tree_entry: TreeEntry | None = None
+        # The request whose commit details are on screen; the file panels read for that very request.
+        self.commit_identity: RequestIdentity | None = None
+
+    def search(self, text: str) -> None:
+        """Keep the exact query and invalidate every older message scan immediately."""
+        if self.is_closed:
+            return
+        self.filter_text = text
+        self.search_generation += 1
+        self.search_identity = None
+        self.search_pending = True
+        self.matching_commits.clear()
+        self.repository.cancel_search(self.session_id)
+
+    def select_commit(self, oid: str) -> None:
+        """Change this window's selection without affecting another open repository."""
+        if self.is_closed or self.selected_oid == oid:
+            return
+        if self.mode == "file_history" and (self.search_pending or oid not in self.visible_oid_set):
+            return
+        self.selected_oid = oid
+        self.navigation_oid = None
+        self.navigation_commit = None
+        self.navigation_filter_cleared = False
+        self.selection_generation += 1
+        self.invalidate_file_selection()
+        self.selection_changed.emit(oid)
+
+    def invalidate_file_selection(self) -> None:
+        """Forget every old file comparison before a new commit can be displayed."""
+        self.panel_generation += 1
+        self.file_identity_by_kind.clear()
+        self.diff_groups.clear()
+        self.selected_entry = None
+        self.tree_entries.clear()
+        self.pending_tree_identity = None
+        self.selected_tree_entry = None
+        for panel_kind in (FilePanel.DIFF, FilePanel.TREE, FilePanel.BLOB):
+            self.repository.cancel_file(self.session_id, panel_kind)
+
+    def close(self) -> None:
+        """Invalidate outstanding work once and release this session's navigation."""
+        if self.is_closed:
+            return
+        self.is_closed = True
+        if self.file_history_engine is not None:
+            self.file_history_engine.finished.disconnect()
+            self.file_history_engine.progressed.disconnect()
+            self.file_history_engine.close()
+        self.generation += 1
+        self.selection_generation += 1
+        self.search_generation += 1
+        self.file_history_generation += 1
+        self.relation_generation += 1
+        self.search_identity = None
+        self.relation_identity = None
+        self.search_pending = False
+        self.matching_commits.clear()
+        self.streamed_history = None
+        self.navigation_oid = None
+        self.navigation_commit = None
+        self.invalidate_file_selection()
+        self.task_id_set.clear()
+        self.repository.cancel(self.session_id)
+        self.repository.context_by_session.pop(self.session_id, None)
+        self.closed.emit()
+
+    def navigate_to_commit(self, oid: str) -> None:
+        """Validate an explicit target and invalidate any older navigation before reading it."""
+        if self.is_closed or (self.mode == "file_history" and self.search_pending):
+            return
+        validate_oid(oid)
+        if self.mode == "file_history" and oid not in self.visible_oid_set:
+            return
+        self.select_commit(oid)
+        self.selection_generation += 1
+        self.navigation_oid = oid
+        self.navigation_requested.emit(oid)
+
+
+class SessionRegistry:
+    """The sessions, windows, dialogs and flags that the controllers of GitPane share."""
+
+    def __init__(self) -> None:
+        """Start with no session open; the wiring builds the registry before any service, so every controller can receive it."""
+        self.dialogs: list[ErrorDialog | QMessageBox] = []
+        self.clone_dialog_by_session: dict[str, CloneDialog] = {}
+        self.clone_generation_by_session: dict[str, int] = {}
+        self.export_owner_by_identity: dict[FileReadIdentity, str] = {}
+        self.setting_dialog: SettingDialog | None = None
+        self.welcome_by_session: dict[str, WelcomeWindow] = {}
+        self.window_by_session: dict[str, RepositoryWindow] = {}
+        self.session_by_id: dict[str, RepositorySession] = {}
+        self.generation_by_session: dict[str, int] = {}
+        self.opening_dir_by_session: dict[str, str] = {}
+        self.identity_by_session: dict[str, RequestIdentity] = {}
+        self.navigation_owner_by_id: dict[str, str] = {}
+        self.shutdown_requested = False
+        self.quit_pending = False
+        self.close_session_set: set[str] = set()
+        self.close_reread_count_by_key: dict[WorktreeKey, int] = {}
+        self.navigation_request_by_session: dict[str, tuple[RepositorySession, str, NavigationKind]] = {}
+        # Sessions whose conflict list opens, for a paused replay, or whose conflict resolution is offered, after a Stash
+        # pop left conflicts, once the next fresh read of their worktree arrives.
+        self.replay_pending_resolve_set: set[str] = set()
+        self.conflict_pending_session_set: set[str] = set()