gitpane 1.0.0__py3-none-any.whl

gitpane/controller/close_readiness.py

@@ -0,0 +1,212 @@
+"""Tell whether a repository window may close or change repository now."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, QTimer
+from shiboken6 import isValid
+
+from gitpane.config import REBASE_CLOSE_REREAD_ATTEMPTS, REBASE_REFRESH_INTERVAL_MS, SharedText
+from gitpane.sequencer.replay_state import replay_may_be_present
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from gitpane.controller.console_registry import ConsoleRegistry
+    from gitpane.controller.rebase_controller import RebaseController
+    from gitpane.controller.rebase_editor_controller import RebaseEditorController
+    from gitpane.controller.reference_form_controller import ReferenceFormController
+    from gitpane.controller.replay_controller import ReplayController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.operation.repository_operation import RepositoryOperationService
+    from gitpane.sequencer.mergetool import MergetoolService
+    from gitpane.sequencer.rebase import RebaseService
+    from gitpane.sequencer.replay import ReplayService
+    from gitpane.tool.editor import EditorService
+    from gitpane.worktree.mutation import MutationService
+
+
+class CloseReadiness(QObject):
+    """The wait of a repository window that closes or changes repository while Git still works in it: the decision, the explanation shown in its banner, the bounded rereads of the native state, the timer that tries again."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, console_registry_controller: ConsoleRegistry, reference_form_controller: ReferenceFormController, replay_controller: ReplayController, rebase_controller: RebaseController,
+                 rebase_editor_controller: RebaseEditorController, editor: EditorService, repository_operation: RepositoryOperationService, rebase: RebaseService, replay: ReplayService, mutation: MutationService, mergetool: MergetoolService,
+                 parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers the decision reads, then set the interval of the timer; the wiring builds it after the conflict controller and connects the timer to the resumption of the pending closes.
+
+        The rebase editor controller brings its windows forward when a close waits for an edit Git asked for.
+        """
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.console_registry_controller = console_registry_controller
+        self.reference_form_controller = reference_form_controller
+        self.replay_controller = replay_controller
+        self.rebase_controller = rebase_controller
+        self.rebase_editor_controller = rebase_editor_controller
+        self.editor = editor
+        self.repository_operation = repository_operation
+        self.rebase = rebase
+        self.replay = replay
+        self.mutation = mutation
+        self.mergetool = mergetool
+        self.close_timer = QTimer(self)
+        self.close_timer.setInterval(REBASE_REFRESH_INTERVAL_MS)
+
+    def _close_busy(self, session_id: str | None = None) -> bool:
+        """Retain authority until reference forms, output, editing and reconciliation finish."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session_id is not None and session is None:
+            return False
+        key = WorktreeKey.from_context(session.repository_context) if session is not None else None
+        if key is None:
+            return bool(self.editor.active_by_id or self.rebase_controller.rebase_intent_by_id or any(self._close_busy(identity) for identity in self.session_registry_controller.session_by_id))
+        for dialog_by_session in (self.replay_controller.replay_dialog_by_session, self.reference_form_controller.checkout_dialog_by_session,
+                                  self.reference_form_controller.checkout_revision_dialog_by_session, self.reference_form_controller.branch_dialog_by_session,
+                                  self.reference_form_controller.tag_dialog_by_session):
+            dialog = dialog_by_session.get(session_id)
+            if dialog is not None and isValid(dialog) and dialog.busy:
+                return True
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        for output in self.console_registry_controller.reference_output_by_id.values():
+            if isValid(output) and output.running and output.parent() is window:
+                return True
+        for intent in self.rebase_controller.rebase_intent_by_id.values():
+            if intent.operation.key == key:
+                return True
+        for context in self.editor.context_by_id.values():
+            if context.worktree_key == key and not context.closed:
+                return True
+        if any(intent.operation.key == key for intent in self.replay_controller.replay_intent_by_id.values()):
+            return True
+        if replay_may_be_present(self.replay.state_by_key.get(key)):
+            if any(operation.key == key for operation in self.repository_operation.active_by_id.values()):
+                return True
+            if self.mergetool.owns_repository(session.repository_context.common_git_dir):
+                return True
+        state = self.rebase.state_by_key.get(key)
+        if state is None or state.identity is None:
+            return False
+        for operation in self.repository_operation.active_by_id.values():
+            if operation.key == key:
+                return True
+        return self.mergetool.owns_repository(session.repository_context.common_git_dir)
+
+    def close_ready(self, session_id: str | None = None) -> bool:
+        """Require a fresh reread only after a command left its native result uncertain, and give up after a bounded number of failed rereads.
+
+        A state that stays unreadable (todo saved in another encoding, metadata removed externally) would otherwise keep the window,
+        Quit and navigation blocked forever while nothing runs any more; Git keeps its native files on disk, so closing cannot lose work.
+        """
+        if self._close_busy(session_id):
+            return False
+        ready = True
+        for identity, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if session_id is not None and identity != session_id:
+                continue
+            key = WorktreeKey.from_context(session.repository_context)
+            state = self.rebase.state_by_key.get(key)
+            attempts = self.session_registry_controller.close_reread_count_by_key.get(key)
+            if state is None or state.fresh or attempts is None:
+                self.session_registry_controller.close_reread_count_by_key.pop(key, None)
+                continue
+            if key in self.rebase.observers_by_key:
+                # A reread is still running; its published result decides whether another attempt is needed.
+                ready = False
+                continue
+            if attempts >= REBASE_CLOSE_REREAD_ATTEMPTS:
+                self.session_registry_controller.close_reread_count_by_key.pop(key, None)
+                continue
+            self.session_registry_controller.close_reread_count_by_key[key] = attempts + 1
+            self.rebase_controller.observe_rebase(identity)
+            ready = False
+        return ready
+
+    def navigation_ready(self, session_id: str) -> bool:
+        """Tell whether the window may leave its repository now.
+
+        Besides what closing the window waits for (the native repository state), a change of repository also waits for
+        any reserved operation holding the working tree, Fetch and Push included, and for any staging write in it:
+        leaving the repository would otherwise stop them halfway. The change waits for them to finish instead.
+        """
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None:
+            return False
+        if not self.close_ready(session_id):
+            return False
+        key = WorktreeKey.from_context(session.repository_context)
+        return not self.repository_operation.owns_worktree(key) and key not in self.mutation.active_key_set
+
+    def show_close_wait(self, session_id: str | None = None, *, navigation: bool = False) -> None:
+        """Keep a visible explanation while the original close request waits for native work.
+
+        While Git waits for an edit, the explanation sends the user to the GitPane editor window, which comes forward;
+        nothing answers Git in the user's place.
+        """
+        subject = "The repository will change" if navigation else "GitPane will close"
+        editor_waiting = bool(self.editor.active_by_id)
+        if editor_waiting:
+            message = f"{SharedText.REBASE_EDITOR_CLOSE_WAIT.value} {subject} after Git reaches a stable state."
+        else:
+            message = f"Waiting for Git and external tools to finish. {subject} after the repository state has been read."
+        editor_wait_started = False
+        for target_id, window in tuple(self.session_registry_controller.window_by_session.items()):
+            if session_id is not None and target_id != session_id:
+                continue
+            if not isValid(window) or window.is_closed:
+                continue
+            text = self._close_reread_message(target_id, message, subject)
+            if editor_waiting and window.rebase_label.text() != text:
+                editor_wait_started = True
+            window.rebase_label.setText(text)
+            window.rebase_banner.show()
+            window.show()
+        # The editor windows come forward when a banner starts asking for them, not at each retry of the close timer,
+        # so a long wait never keeps taking the keyboard from another window.
+        if editor_wait_started:
+            self.rebase_editor_controller.raise_windows()
+
+    def clear_navigation_wait(self, session_id: str) -> None:
+        """Put back the real rebase state in a window whose change of repository stopped without happening.
+
+        While a change of repository waits for Git, the rebase banner says the repository will change, with its Open
+        rebase button; only a published change hides it. A change that stops instead (folder gone, window opened
+        meanwhile, failed read) would otherwise keep announcing a change that will not come. A pending close keeps its
+        own message, and a running rebase command writes its progress there and publishes its state when it ends.
+        """
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if window is None or not isValid(window) or window.is_closed or session is None or session.is_closed:
+            return
+        if self.session_registry_controller.quit_pending or session_id in self.session_registry_controller.close_session_set:
+            return
+        key = WorktreeKey.from_context(session.repository_context)
+        for intent in self.rebase_controller.rebase_intent_by_id.values():
+            if intent.operation.key == key:
+                return
+        state = self.rebase.state_by_key.get(key)
+        if state is None:
+            window.rebase_banner.hide()
+            return
+        window.show_rebase_state(state)
+
+    def _close_reread_message(self, session_id: str, message: str, subject: str) -> str:
+        """Name the reread cause and attempt count instead of a generic wait once closing depends on rereading the native state."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or self.editor.active_by_id:
+            return message
+        key = WorktreeKey.from_context(session.repository_context)
+        attempts = self.session_registry_controller.close_reread_count_by_key.get(key, 0)
+        state = self.rebase.state_by_key.get(key)
+        if not attempts or state is None or state.fresh:
+            return message
+        return (f"Rereading the native rebase state, attempt {attempts} of {REBASE_CLOSE_REREAD_ATTEMPTS}. {subject} once it has been read, or after the last attempt."
+                + (" " + state.diagnostic if state.diagnostic else ""))
+
+    def defer_repository_close(self, session_id: str) -> bool:
+        """Record a close before any window or session callback can be invalidated."""
+        if self.close_ready(session_id):
+            return False
+        self.session_registry_controller.close_session_set.add(session_id)
+        self.show_close_wait(session_id)
+        self.close_timer.start()
+        return True