gitpane 1.0.0__py3-none-any.whl

gitpane/controller/stash_controller.py

@@ -0,0 +1,367 @@
+"""Manage the stashes of a repository window."""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Qt, Signal
+from PySide6.QtWidgets import QMessageBox
+from shiboken6 import isValid
+
+from gitpane.config import ConsoleOperation
+from gitpane.controller.refresh_controller import RefreshScope
+from gitpane.history.file_history import WindowCapability
+from gitpane.operation.console_line import END_TEXT_TEMPLATE, REPOSITORY_HEADER_LABEL, STASH_POP_LABEL, ConsoleHeader, operation_end_text
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.operation.operation_trace import OperationTrace, publish_after_trace
+from gitpane.operation.repository_operation import OperationAction, OperationIntent
+from gitpane.reference.stash import DROP_OPERATION_LABEL, StashDropIntent, StashObservation, pop_stopped_on_conflict
+from gitpane.reference.stash_list import stash_selector
+from gitpane.sequencer.conflict import snapshot_has_conflicts
+from gitpane.system.path_identity import canonical_path
+from gitpane.ui.console.operation_dialog import OperationDialog
+from gitpane.ui.reference.stash_dialog import StashDialog
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+from gitpane.worktree.worktree_snapshot import WorktreeKey
+
+if TYPE_CHECKING:
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.refresh_controller import FullRefreshRead, RefreshController
+    from gitpane.controller.replay_controller import ReplayController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.window_activation import WindowActivationFilter
+    from gitpane.history.repository import GitRepository
+    from gitpane.operation.diagnostic import DiagnosticLog
+    from gitpane.operation.repository_operation import OperationOutcome
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.reference.stash import StashIntent, StashService
+    from gitpane.reference.stash_list import StashEntry
+    from gitpane.worktree.worktree_service import WorktreeService
+
+# The question Drop stash asks, filled with the stash selector and the message the left panel shows.
+STASH_DROP_QUESTION = "Drop {selector}: {message}?\n\nThe stash is deleted. Working files, the index and submodules are not changed."
+STASH_DROP_CANCEL_LABEL = "Cancel"
+STASH_DROPPED_STATUS = "Dropped {selector}."
+STASH_DROP_FAILED_PREFIX = "Drop stash refused: "
+STASH_DROP_VIEW_CHANGED_CAUSE = "The repository view changed; refresh it and try again"
+# Where a stash drop came from, as the --log journal names it.
+STASH_DROP_MANUAL_ORIGIN = "Drop stash from the left panel"
+STASH_DROP_AUTOMATIC_ORIGIN = "Stash kept by a Stash pop, dropped after its conflicts were resolved in GitPane"
+
+
+@dataclass(frozen=True)
+class StashDropAfterResolution:
+    """Remember that a conflict of a Stash pop was just resolved in GitPane, so the stash that pop kept may be dropped.
+
+    Git keeps a stash whose pop stopped on conflicts. Once the last of those conflicts is resolved in GitPane's conflict
+    list or merge tool, the stash is dropped with nothing shown, the way users expect a pop to end. ``known_generation``
+    is the worktree read generation when the resolution finished: only a later read shows its result, and that read
+    decides. A read still listing a conflict ends the request; the next resolution in GitPane asks again.
+    """
+
+    session_id: str
+    retained_oid: str
+    known_generation: int
+
+
+class StashController(QObject):
+    """The stashes of every repository window: the Stash form, Stash pop with its console, Drop stash with its question, and the drop of a stash a Stash pop kept, once GitPane resolved its conflicts."""
+
+    # A Stash pop that ended with its stash kept tells the conflict, which watches that stash while the pop's conflicts
+    # remain: the worktree key and the observation of the kept stash. Connected directly, so the watch starts before
+    # the rest of the pop's result is handled, as when the stash called the conflict itself.
+    conflict_retention_requested = Signal(object, object)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter,
+                 refresh_controller: RefreshController, replay_controller: ReplayController, preference: PreferenceStore, repository: GitRepository, worktree_service: WorktreeService,
+                 stash: StashService, diagnostic_log: DiagnosticLog | None, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers a stash works with; the wiring builds it after the rebase controller, and the conflict hears from it through a signal the wiring connects."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.window_activation_controller = window_activation_controller
+        self.refresh_controller = refresh_controller
+        self.preference = preference
+        self.repository = repository
+        self.worktree_service = worktree_service
+        self.stash = stash
+        self.diagnostic_log = diagnostic_log
+        self.replay_controller = replay_controller
+        self.stash_dialog_by_session: dict[str, StashDialog] = {}
+        self.stash_intent_by_id: dict[str, StashIntent] = {}
+        self.stash_pop_intent_by_id: dict[str, OperationIntent] = {}
+        self.stash_pop_dialog_by_id: dict[str, OperationDialog] = {}
+        self.stash_pop_trace_by_id: dict[str, OperationTrace] = {}
+        self.stash_drop_by_id: dict[str, StashDropIntent] = {}
+        # The drops GitPane makes on its own, after the conflicts of a Stash pop were resolved: they show nothing.
+        self.stash_drop_automatic_id_set: set[str] = set()
+        self.stash_drop_confirmation_by_session: dict[str, QMessageBox] = {}
+        self.stash_drop_after_resolution_by_key: dict[WorktreeKey, StashDropAfterResolution] = {}
+
+    def open_stash(self, session_id: str) -> StashDialog | None:
+        """Open or explicitly reload a retained stash draft under current management authority."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        window = self.session_registry_controller.window_by_session[session_id]
+        if window.context.is_bare:
+            return None
+        existing = self.stash_dialog_by_session.get(session_id)
+        if existing is not None and isValid(existing) and not existing.closed:
+            existing.raise_()
+            if existing.running or existing.capture_pending:
+                return existing
+            dialog = existing
+        else:
+            dialog = StashDialog(session_id, self.preference, window)
+            dialog.installEventFilter(self.window_activation_controller)
+            self.stash_dialog_by_session[session_id] = dialog
+            dialog.submit_requested.connect(lambda intent: self.submit_stash(session_id, intent))
+        session = self.session_registry_controller.session_by_id[session_id]
+        generation = session.generation
+        dialog.begin_capture()
+        dialog.show()
+
+        def complete(snapshot: object, error: Exception | None) -> None:
+            """Publish only to the still-authorized form that requested this read."""
+            if dialog.closed or not isValid(dialog):
+                return
+            if session.is_closed or session.generation != generation or not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+                dialog.show_error("The repository changed. Click Stash in the toolbar to reload this draft.")
+            elif error is not None:
+                dialog.show_error(str(error))
+            else:
+                dialog.populate(snapshot)
+
+        self.worktree_service.read(window.context, self.repository.git_filename, generation, complete)
+        return dialog
+
+    def submit_stash(self, session_id: str, intent: StashIntent) -> str | None:
+        """Submit only the original visible form's immutable intention."""
+        dialog = self.stash_dialog_by_session.get(session_id)
+        if (not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) or dialog is None or dialog.closed
+                or dialog.intent != intent or intent.operation.session_id != session_id):
+            return None
+
+        def is_current() -> bool:
+            """Recheck authority after asynchronous reads and any native queue wait."""
+            return (not dialog.closed and self.operation_policy_controller.operation_allowed(intent.operation)
+                    and self.repository.git_filename == intent.operation.git_filename)
+
+        self.stash_intent_by_id[intent.operation.operation_id] = intent
+        return self.stash.create(intent, is_current=is_current)
+
+    def stash_finished(self, outcome: OperationOutcome) -> None:
+        """Keep uncertain drafts while refreshing every view of the original worktree."""
+        intent = self.stash_intent_by_id.pop(outcome.operation_id, None)
+        if intent is None:
+            return
+        self.stash.outcome_by_id[outcome.operation_id] = outcome
+        dialog = self.stash_dialog_by_session.get(intent.operation.session_id)
+        if dialog is not None and isValid(dialog) and not dialog.closed and dialog.intent == intent:
+            dialog.show_result(outcome)
+        if outcome.diagnostic is not None and self.diagnostic_log is not None:
+            self.diagnostic_log.write(outcome.diagnostic)
+        shared_by_key: dict[WorktreeKey, FullRefreshRead] = {}
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if not session.is_closed and WorktreeKey.from_context(session.repository_context) == intent.operation.key:
+                self.refresh_controller.refresh(session_id, full_refresh_read=self.refresh_controller.full_refresh_read_for(session, shared_by_key))
+        refreshed_key_set = self.refresh_controller.observe_full_refresh_pauses(shared_by_key)
+        staging = self.staging_session_registry_controller.staging_by_key.get(intent.operation.key)
+        # A preparation session without any open repository window still shows the result.
+        if staging is not None and intent.operation.key not in refreshed_key_set:
+            staging.refresh()
+
+    def stash_pop(self, session_id: str) -> OperationDialog | None:
+        """Apply the latest stash directly with the shared output preference and write owner."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        session = self.session_registry_controller.session_by_id[session_id]
+        if session.repository_context.is_bare:
+            return None
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename,
+                                            session_id=session_id, generation=self.session_registry_controller.generation_by_session[session_id], operation=STASH_POP_LABEL, action=OperationAction.STASH)
+        trace = OperationTrace(operation.operation_id, self.repository.runner, self.diagnostic_log, header=ConsoleHeader(REPOSITORY_HEADER_LABEL, operation.context.repository_dir))
+        dialog = OperationDialog(trace, STASH_POP_LABEL, self.session_registry_controller.window_by_session[session_id], preference=self.preference, console_operation=ConsoleOperation.STASH_POP)
+        self.stash_pop_intent_by_id[operation.operation_id] = operation
+        self.stash_pop_trace_by_id[operation.operation_id] = trace
+        self.stash_pop_dialog_by_id[operation.operation_id] = dialog
+        dialog.finished.connect(trace.close)
+        dialog.set_running()
+        open_window_modal(dialog, keeps_window_buttons=True)
+        self.stash.pop(operation, is_current=lambda: self.operation_policy_controller.operation_allowed(operation) and self.repository.git_filename == operation.git_filename)
+        return dialog
+
+    def stash_pop_finished(self, outcome: OperationOutcome) -> None:
+        """Retain output independently and refresh only the original current repository session."""
+        operation = self.stash_pop_intent_by_id.pop(outcome.operation_id, None)
+        if operation is None:
+            return
+        self.stash.outcome_by_id[outcome.operation_id] = outcome
+        trace = self.stash_pop_trace_by_id[outcome.operation_id]
+        allowed = self.operation_policy_controller.operation_allowed(operation)
+
+        def publish_result() -> None:
+            """Write the result in the console once the trace has ended the last process with its own line."""
+            if outcome.diagnostic is not None:
+                # The log keeps the cause alone here, as it always did; the console shows the diagnostic's own short line.
+                trace.append_record(outcome.operation_id, "status", outcome.diagnostic.cause,
+                                    trace.diagnostic_console_line(outcome.diagnostic, outcome.status, paused=pop_stopped_on_conflict(outcome)))
+            trace.append_end_line(outcome.operation_id, "status", END_TEXT_TEMPLATE.format(label=STASH_POP_LABEL, word=outcome.status.value),
+                                  operation_end_text(STASH_POP_LABEL, outcome.status), outcome.status, expected_stop=pop_stopped_on_conflict(outcome))
+            dialog = self.stash_pop_dialog_by_id.get(outcome.operation_id)
+            if dialog is not None and isValid(dialog):
+                # Conflicts are a pause: the conflict question and the repository window wait for the user, not the console.
+                dialog.show_result(outcome.status, expected_stop=pop_stopped_on_conflict(outcome))
+            if not allowed:
+                trace.close()
+
+        publish_after_trace(publish_result, self)
+        if not allowed:
+            return
+        for step in outcome.steps:
+            if isinstance(step.after, StashObservation) and step.after.retained_oid is not None:
+                self.conflict_retention_requested.emit(operation.key, step.after)
+                if step.after.unmerged_paths:
+                    self.session_registry_controller.conflict_pending_session_set.add(operation.session_id)
+        shared_by_key: dict[WorktreeKey, FullRefreshRead] = {}
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if not session.is_closed and WorktreeKey.from_context(session.repository_context) == operation.key:
+                self.refresh_controller.checkout_refresh_session_set.add(session_id)
+                self.refresh_controller.refresh(session_id, full_refresh_read=self.refresh_controller.full_refresh_read_for(session, shared_by_key, explicit=True))
+        refreshed_key_set = self.refresh_controller.observe_full_refresh_pauses(shared_by_key)
+        staging = self.staging_session_registry_controller.staging_by_key.get(operation.key)
+        # A preparation session without any open repository window still shows the result.
+        if staging is not None and operation.key not in refreshed_key_set:
+            staging.refresh(explicit=True)
+
+    def drop_stash(self, session_id: str, entry: StashEntry) -> QMessageBox | None:
+        """Ask before dropping the stash chosen in the left panel, and drop exactly that stash once the user agrees.
+
+        The question names the stash by its selector and message, with Cancel as the default and Escape answer. The
+        stash is checked again by its commit just before Git drops it, so a list changed meanwhile drops nothing.
+        """
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return None
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        session = self.session_registry_controller.session_by_id[session_id]
+        if window is None or session.repository_context.is_bare:
+            return None
+        previous = self.stash_drop_confirmation_by_session.pop(session_id, None)
+        if previous is not None and isValid(previous):
+            previous.close()
+            previous.deleteLater()
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename, session_id=session_id,
+                                            generation=self.session_registry_controller.generation_by_session[session_id], operation=DROP_OPERATION_LABEL, action=OperationAction.STASH)
+        intent = StashDropIntent.of_entry(operation, entry)
+        text = STASH_DROP_QUESTION.format(selector=stash_selector(entry.index), message=entry.message)
+        confirmation = QMessageBox(QMessageBox.Icon.Question, DROP_OPERATION_LABEL, text, QMessageBox.StandardButton.NoButton, window)
+        prepare_message_box(confirmation, DROP_OPERATION_LABEL)
+        confirmation.setTextFormat(Qt.TextFormat.PlainText)
+        drop_button = confirmation.addButton(DROP_OPERATION_LABEL, QMessageBox.ButtonRole.DestructiveRole)
+        cancel_button = confirmation.addButton(STASH_DROP_CANCEL_LABEL, QMessageBox.ButtonRole.RejectRole)
+        confirmation.setDefaultButton(cancel_button)
+        confirmation.setEscapeButton(cancel_button)
+        self.stash_drop_confirmation_by_session[session_id] = confirmation
+
+        def answer() -> None:
+            """Drop only on an explicit Drop stash; any other ending leaves every stash in place."""
+            if self.stash_drop_confirmation_by_session.get(session_id) is confirmation:
+                del self.stash_drop_confirmation_by_session[session_id]
+            accepted = confirmation.clickedButton() is drop_button
+            confirmation.deleteLater()
+            if accepted:
+                self._submit_stash_drop(intent, automatic=False)
+
+        confirmation.finished.connect(answer)
+        open_window_modal(confirmation)
+        return confirmation
+
+    def _submit_stash_drop(self, intent: StashDropIntent, *, automatic: bool) -> None:
+        """Hand one drop to the stash service while its window may still write, under the Git it was asked with."""
+        operation = intent.operation
+        if not self.operation_policy_controller.operation_allowed(operation) or self.repository.git_filename != operation.git_filename:
+            self._report_stash_drop(intent, automatic, OperationStatus.REFUSED, STASH_DROP_VIEW_CHANGED_CAUSE)
+            return
+        self.stash_drop_by_id[operation.operation_id] = intent
+        if automatic:
+            self.stash_drop_automatic_id_set.add(operation.operation_id)
+        self.stash.drop(intent, is_current=lambda: self.operation_policy_controller.operation_allowed(operation) and self.repository.git_filename == operation.git_filename)
+
+    def stash_drop_finished(self, outcome: OperationOutcome) -> None:
+        """Report a finished drop and read the stash list again in every window of that repository, whatever the result."""
+        intent = self.stash_drop_by_id.pop(outcome.operation_id, None)
+        if intent is None:
+            return
+        automatic = outcome.operation_id in self.stash_drop_automatic_id_set
+        self.stash_drop_automatic_id_set.discard(outcome.operation_id)
+        cause = outcome.diagnostic.cause if outcome.diagnostic is not None else ""
+        self._report_stash_drop(intent, automatic, outcome.status, cause)
+        # The stash list lives in the shared Git directory: every window of the repository, linked worktrees included, shows it.
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if (not session.is_closed and WindowCapability.MANAGE in session.capabilities
+                    and canonical_path(session.repository_context.common_git_dir) == intent.operation.common_git_dir):
+                self.refresh_controller.refresh(session_id, scope=RefreshScope.REFERENCES)
+
+    def _report_stash_drop(self, intent: StashDropIntent, automatic: bool, status: OperationStatus, cause: str) -> None:
+        """Write every drop to the --log journal with the stash commit, and tell the user about the drops they asked for.
+
+        The dropped commit stays in the object database until Git prunes it, so with --log the journal line is what lets
+        it be recovered. A drop GitPane makes on its own after a Stash pop shows nothing at all, by design: without
+        --log no trace of that commit is kept, and only ``git fsck --unreachable`` finds it before the next prune. A
+        failed drop that carries no cause shows the word of its status instead.
+        """
+        operation = intent.operation
+        if self.diagnostic_log is not None:
+            origin = STASH_DROP_AUTOMATIC_ORIGIN if automatic else STASH_DROP_MANUAL_ORIGIN
+            message = f"{origin}: {status.value}. Stash commit: {intent.oid}." + (" " + cause if cause else "")
+            self.diagnostic_log.write(Diagnostic(DROP_OPERATION_LABEL, operation.context.repository_dir, operation.git_filename, [], message).prepare())
+        if automatic or operation.session_id is None:
+            return
+        window = self.session_registry_controller.window_by_session.get(operation.session_id)
+        if window is None or not isValid(window):
+            return
+        if status == OperationStatus.SUCCESS:
+            window.statusBar().showMessage(STASH_DROPPED_STATUS.format(selector=stash_selector(intent.index)))
+            return
+        window.statusBar().showMessage(STASH_DROP_FAILED_PREFIX + (cause or status.value))
+
+    def continue_stash_drops_after_resolution(self) -> None:
+        """Look again at every waiting drop, for instance once the merge tool or another write has released the repository."""
+        for key in tuple(self.stash_drop_after_resolution_by_key):
+            self.continue_stash_drop_after_resolution(key)
+
+    def continue_stash_drop_after_resolution(self, key: WorktreeKey) -> None:
+        """Drop the kept stash once a worktree read newer than the resolution shows no conflict and nothing holds the repository.
+
+        A read still listing a conflict ends the request without dropping anything. A closed or departed window ends it
+        too. The drop itself checks again, under the repository reservation, that no conflict remains and that the
+        stash commit is still in the list, and shows nothing to the user whatever happens; only the --log journal keeps
+        the dropped commit.
+        """
+        request = self.stash_drop_after_resolution_by_key.get(key)
+        if request is None:
+            return
+        session = self.session_registry_controller.session_by_id.get(request.session_id)
+        if (session is None or not self.operation_policy_controller.allows(request.session_id, WindowCapability.MANAGE) or WorktreeKey.from_context(session.repository_context) != key
+                or self.replay_controller.replay_session_leaving(request.session_id)):
+            del self.stash_drop_after_resolution_by_key[key]
+            return
+        staging = self.staging_session_registry_controller.staging_by_key.get(key)
+        snapshot = staging.snapshot if staging is not None else None
+        if (snapshot is None or not snapshot.fresh or staging.refresh_active or staging.refresh_queued or staging.explicit_refresh
+                or snapshot.generation <= request.known_generation):
+            return
+        if snapshot_has_conflicts(snapshot):
+            del self.stash_drop_after_resolution_by_key[key]
+            return
+        if self.replay_controller.replay_writer_busy(session.repository_context):
+            return
+        del self.stash_drop_after_resolution_by_key[key]
+        operation = OperationIntent.capture(uuid.uuid4().hex, session.repository_context, self.repository.git_filename, session_id=request.session_id,
+                                            generation=self.session_registry_controller.generation_by_session[request.session_id], operation=DROP_OPERATION_LABEL, action=OperationAction.STASH)
+        self._submit_stash_drop(StashDropIntent.of_retained(operation, request.retained_oid), automatic=True)