gitpane 1.0.0__py3-none-any.whl

gitpane/controller/opening_controller.py

@@ -0,0 +1,375 @@
+"""Open a repository window once Git has read its repository."""
+
+from __future__ import annotations
+
+import os
+import threading
+from functools import partial
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Qt, Signal
+from shiboken6 import isValid
+
+from gitpane.controller.session_registry import RepositorySession
+from gitpane.controller.setting_controller import WaitingOpening
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.repository_value import RepositoryFailure, RequestIdentity
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.recent.recent_availability import folder_is_reachable
+from gitpane.system.path_identity import canonical_path
+from gitpane.thread.weak_signal import weak_signal_emitter
+from gitpane.ui.console.error_dialog import ErrorDialog
+from gitpane.ui.repository.repository_window import RepositoryWindow
+from gitpane.ui.window_control.dialog_modality import open_window_modal
+from gitpane.ui.window_control.window_placement import is_visible_window
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.account.authentication import AuthenticationService
+    from gitpane.controller.clone_controller import CloneController
+    from gitpane.controller.history_read_controller import HistoryReadController
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.refresh_controller import RefreshController
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.controller.setting_controller import SettingController
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.controller.window_activation import WindowActivationFilter
+    from gitpane.history.file_history import FileHistoryAnchor
+    from gitpane.history.repository import GitRepository
+    from gitpane.history.repository_value import Commit, RepositoryContext
+    from gitpane.operation.diagnostic import DiagnosticLog, PreparedDiagnostic
+    from gitpane.preference.preference_store import PreferenceStore
+    from gitpane.transport.clone import CloneService
+
+OPENING_FOLDER_THREAD_NAME = "gitpane-opening-folder-check"
+MISSING_FOLDER_LOG_TEXT = "Open repository: no folder exists at {path}; Git was not started."
+
+
+def answer_folder_question(is_folder_present: Callable[[str], bool], folder_dir: str, hand_over: Callable[[bool | None], None]) -> None:
+    """Ask on the worker thread whether the folder exists, and hand the answer over to the controller's thread.
+
+    The answer is None when the question gave no definite answer (a refused access, a disk not ready, a path the system
+    cannot read as written): the opening then goes on to Git as it would without the question.
+    """
+    try:
+        present: bool | None = is_folder_present(folder_dir)
+    except (OSError, ValueError):
+        present = None
+    # The controller may have been deleted while the question ran: the answer then has nobody left to take it.
+    try:
+        hand_over(present)
+    except RuntimeError:
+        pass
+
+
+class OpeningController(QObject):
+    """The openings asked from the welcome window, the clone form and the file histories: the checks before a window opens, then the actions that follow its wiring."""
+
+    # Session of a repository window just opened, whose worktree may be paused by a rebase started before it opened.
+    pause_observation_requested = Signal(str)
+    # Answer of the folder question of a welcome opening: its identity, the folder, and True, False or None when unknown.
+    folder_answered = Signal(object, str, object)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, window_activation_controller: WindowActivationFilter,
+                 reference_read_controller: ReferenceReadController, refresh_controller: RefreshController, history_read_controller: HistoryReadController, setting_controller: SettingController, clone_controller: CloneController,
+                 preference: PreferenceStore, repository: GitRepository, authentication: AuthenticationService, clone: CloneService, diagnostic_log: DiagnosticLog | None,
+                 wire_repository_window: Callable[[RequestIdentity, RepositorySession, RepositoryWindow, RepositoryContext, FileHistoryAnchor | None], None],
+                 is_folder_present: Callable[[str], bool] = folder_is_reachable, parent: QObject | None = None) -> None:
+        """Receive the services, the lower controllers and the wiring function a new repository window is connected with; the wiring builds it after the clone controller, and the rebase learns from its signal which opened window to observe.
+
+        ``is_folder_present`` tells whether the folder of a welcome opening exists, raising when it cannot tell. It may
+        block for long on a sleeping disk or a dead network share, so it is only ever asked on a thread of its own;
+        tests answer without a disk.
+        """
+        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.reference_read_controller = reference_read_controller
+        self.refresh_controller = refresh_controller
+        self.history_read_controller = history_read_controller
+        self.setting_controller = setting_controller
+        self.clone_controller = clone_controller
+        self.preference = preference
+        self.repository = repository
+        self.authentication = authentication
+        self.clone = clone
+        self.diagnostic_log = diagnostic_log
+        self.wire_repository_window = wire_repository_window
+        self.is_folder_present = is_folder_present
+        self.folder_answered.connect(self._folder_answered, Qt.ConnectionType.QueuedConnection)
+
+    def open(self, session_id: str, repository_dir: str) -> None:
+        """Assign a never-reused generation and reject repeated active opening intents."""
+        identity = self._begin_opening(session_id, repository_dir)
+        if identity is None:
+            return
+        if self._wait_for_startup_check(session_id, identity, repository_dir, checks_folder=False):
+            return
+        self.repository.open_repository(repository_dir, identity)
+
+    def open_from_welcome(self, session_id: str, repository_dir: str) -> None:
+        """Open the folder the welcome window asked for, once a question off the window's thread found that it exists.
+
+        A folder that does not exist is never handed to Git: the welcome window says "Invalid path" instead of Git's
+        failure to start in it. The question may block for long on a sleeping disk or a dead network share, so it is
+        never asked on the window's thread; meanwhile the window shows "Opening…" and Cancel reading, as during a read.
+        """
+        identity = self._begin_opening(session_id, repository_dir)
+        if identity is None:
+            return
+        if self._wait_for_startup_check(session_id, identity, repository_dir, checks_folder=True):
+            return
+        self._ask_folder(identity, repository_dir)
+
+    def resume_waiting_opening(self, waiting: WaitingOpening) -> None:
+        """Go on with an opening the startup check of Git released: ask about its folder first when it asks one, else read Git now.
+
+        The order stays the same whatever answers first: the startup check of Git, then the folder question, then Git.
+        """
+        if waiting.checks_folder:
+            self._ask_folder(waiting.identity, waiting.repository_dir)
+            return
+        self.repository.open_repository(waiting.repository_dir, waiting.identity)
+
+    def _begin_opening(self, session_id: str, repository_dir: str) -> RequestIdentity | None:
+        """Give an opening its never-reused identity and show the chooser busy, or return None for an opening refused here.
+
+        An opening is refused while another one of the session runs, once its chooser is gone, and during a clone for any
+        folder but the clone's destination.
+        """
+        if session_id in self.session_registry_controller.identity_by_session or session_id not in self.session_registry_controller.welcome_by_session:
+            return None
+        clone_dialog = self.session_registry_controller.clone_dialog_by_session.get(session_id)
+        if clone_dialog is not None and clone_dialog.operation_id is not None:
+            run = self.clone.run_by_id[clone_dialog.operation_id]
+            if run.open_status != "running" or run.destination is None or canonical_path(repository_dir) != canonical_path(run.destination.destination_dir):
+                return None
+        generation = self.session_registry_controller.generation_by_session.get(session_id, 0) + 1
+        self.session_registry_controller.generation_by_session[session_id] = generation
+        identity = RequestIdentity(session_id, generation)
+        self.session_registry_controller.identity_by_session[session_id] = identity
+        self.session_registry_controller.opening_dir_by_session[session_id] = repository_dir
+        self.session_registry_controller.welcome_by_session[session_id].set_loading(True)
+        return identity
+
+    def _wait_for_startup_check(self, session_id: str, identity: RequestIdentity, repository_dir: str, *, checks_folder: bool) -> bool:
+        """Leave the opening to the startup check of Git while that check runs, returning whether it now waits for it.
+
+        ``checks_folder`` makes the released opening ask about its folder before Git reads it.
+        """
+        if self.setting_controller.startup_identity is None:
+            return False
+        self.setting_controller.waiting_opening_by_session[session_id] = WaitingOpening(identity, repository_dir, self.repository.git_filename, checks_folder)
+        return True
+
+    def _ask_folder(self, identity: RequestIdentity, repository_dir: str) -> None:
+        """Ask on a thread of its own whether the opening's folder exists; the answer comes back through ``folder_answered``."""
+        # The thread holds the controller only weakly: a question blocked on a dead share keeps nothing alive.
+        hand_over = partial(weak_signal_emitter(self, lambda controller: controller.folder_answered), identity, repository_dir)
+        thread = threading.Thread(target=answer_folder_question, args=(self.is_folder_present, repository_dir, hand_over), name=OPENING_FOLDER_THREAD_NAME, daemon=True)
+        thread.start()
+
+    def _folder_answered(self, identity: RequestIdentity, repository_dir: str, present: bool | None) -> None:
+        """Go on with an opening whose folder question answered, unless Cancel reading, a closed chooser or a newer opening replaced it.
+
+        Only a definite "absent" refuses the folder; a question without a definite answer leaves the answer to Git.
+        """
+        if self.session_registry_controller.identity_by_session.get(identity.session_id) != identity:
+            return
+        if identity.session_id not in self.session_registry_controller.welcome_by_session:
+            return
+        if present is False:
+            self._refuse_missing_folder(identity, repository_dir)
+            return
+        # The folder question is already answered: an opening released later by a startup check reads Git at once.
+        if self._wait_for_startup_check(identity.session_id, identity, repository_dir, checks_folder=False):
+            return
+        self.repository.open_repository(repository_dir, identity)
+
+    def _refuse_missing_folder(self, identity: RequestIdentity, repository_dir: str) -> None:
+        """End an opening whose folder does not exist, give the chooser back to the user, and explain it in a message over it.
+
+        A recent of that folder is marked Unavailable, as after a failed opening.
+        """
+        self.session_registry_controller.identity_by_session.pop(identity.session_id, None)
+        welcome = self.session_registry_controller.welcome_by_session[identity.session_id]
+        welcome.set_loading(False)
+        welcome.mark_unavailable(repository_dir)
+        if self.diagnostic_log is not None:
+            self.diagnostic_log.write_line(MISSING_FOLDER_LOG_TEXT.format(path=repository_dir))
+        box = welcome.invalid_path_message(repository_dir)
+        self.session_registry_controller.dialogs.append(box)
+        box.finished.connect(lambda: self.session_registry_controller.dialogs.remove(box) if box in self.session_registry_controller.dialogs else None)
+        box.finished.connect(box.deleteLater)
+        open_window_modal(box)
+
+    def opened(self, identity: RequestIdentity, context: RepositoryContext, commit: Commit | None, file_history_anchor: FileHistoryAnchor | None = None,
+               requesting_window: QWidget | None = None) -> None:
+        """Publish a successful read only to its still-current requesting window.
+
+        ``requesting_window`` is the window a file history was asked from; a new window opens centred on it, or on the
+        Open or Clone repository window of its session. A read a navigation owns is left to the navigation's own slot,
+        connected before this one. A new window is connected to the controllers before anything selects, registers,
+        reads or shows it.
+        """
+        if identity.session_id in self.session_registry_controller.navigation_owner_by_id:
+            return
+        if self.session_registry_controller.identity_by_session.get(identity.session_id) != identity:
+            return
+        clone_dialog = self.session_registry_controller.clone_dialog_by_session.get(identity.session_id)
+        if clone_dialog is not None and clone_dialog.operation_id is not None:
+            run = self.clone.run_by_id[clone_dialog.operation_id]
+            try:
+                if run.cancelled or not self.operation_policy_controller.clone_is_current(run.intent):
+                    return
+                run.destination.verify()
+                if canonical_path(context.repository_dir) != canonical_path(run.destination.destination_dir):
+                    raise ValueError("The opened repository does not match the clone destination.")
+                if run.intent.selection is not None and not run.selection_saved:
+                    self.authentication.save_selection(run.intent.selection.origin, run.intent.selection, context)
+                    run.selection_saved = True
+            except (OSError, ValueError, TypeError) as error:
+                self.history_read_controller.failed(identity, RepositoryFailure("Open cloned repository", context.repository_dir, self.repository.git_filename, [], str(error)))
+                return
+        existing_window = self.session_registry_controller.window_by_session.get(identity.session_id)
+        if existing_window is not None:
+            existing_window.show_commit(commit)
+            self.refresh_controller.recovery_request_set.discard(identity)
+            return
+        if file_history_anchor is None:
+            showing_window = self.window_showing_folder(context.repository_dir, other_than=identity.session_id)
+            if showing_window is not None:
+                # Opening a folder already shown is still a successful opening: it goes first in the recent list.
+                preference_diagnostic = self.remember_repository(context.repository_dir)
+                self.bring_forward(showing_window)
+                welcome = self.session_registry_controller.welcome_by_session.get(identity.session_id)
+                if welcome is not None:
+                    # The chooser closes as after any opening; its close ends this unused opening.
+                    welcome.close()
+                if preference_diagnostic is not None:
+                    self.show_preference_failure(preference_diagnostic, showing_window)
+                return
+        preference_diagnostic = None
+        if file_history_anchor is None:
+            preference_diagnostic = self.remember_repository(context.repository_dir)
+        session = RepositorySession(identity.session_id, context, self.repository, file_history_anchor)
+        session.generation = identity.generation
+        self.session_registry_controller.session_by_id[identity.session_id] = session
+        window = RepositoryWindow(context, commit, mode=session.mode, placement_anchor=self._new_window_anchor(identity.session_id, requesting_window))
+        if file_history_anchor is not None:
+            _directory, _separator, basename = os.fsdecode(file_history_anchor.path).rpartition("/")
+            window.setWindowTitle(f"{basename} — File history — {context.repository_dir} — GitPane")
+        self.wire_repository_window(identity, session, window, context, file_history_anchor)
+        if commit is not None:
+            session.select_commit(commit.oid)
+        self.session_registry_controller.window_by_session[identity.session_id] = window
+        # Walking from a parent repository into a child inside an already active window delivers no activation event.
+        self.window_activation_controller.schedule_activation_update()
+        if WindowCapability.MANAGE in session.capabilities and not context.is_bare:
+            # The window starts with an unknown count, and this worktree may already have been read for another window.
+            self.staging_session_registry_controller.staging_session(context).refresh(announce=True)
+        window.show()
+        self.preference.refresh()
+        window.show_recent_repositories(self.preference.value_by_key["recent_dirs"])
+        window.apply_reading_preference(self.preference.value_by_key)
+        window.apply_fetch_preference(self.preference.value_by_key)
+        welcome = self.session_registry_controller.welcome_by_session.pop(identity.session_id, None)
+        clone_dialog = self.session_registry_controller.clone_dialog_by_session.pop(identity.session_id, None)
+        if clone_dialog is not None and clone_dialog.operation_id is not None:
+            self.clone_controller.keep_clone_console(clone_dialog.operation_id, window, show=False)
+            self.clone.open_result(clone_dialog.operation_id, True)
+            clone_dialog.accept()
+        # The replaced windows are handed to Qt for deletion while these local variables still hold them, so their end
+        # never depends on where their last Python reference goes away: destroyed at the wrong moment, in the middle of
+        # Qt switching the active window to the repository window, they made GitPane crash.
+        if clone_dialog is not None:
+            clone_dialog.deleteLater()
+        if welcome is not None:
+            welcome.close()
+            welcome.deleteLater()
+        window.begin_history()
+        self.reference_read_controller.read_history_with_references(identity.session_id, identity)
+        self.refresh_controller.read_submodules(identity.session_id)
+        self.pause_observation_requested.emit(identity.session_id)
+        if preference_diagnostic is not None:
+            self.show_preference_failure(preference_diagnostic, window)
+
+    def window_showing_folder(self, repository_dir: str, *, other_than: str) -> RepositoryWindow | None:
+        """Return the repository window, other than the ``other_than`` session's, that already shows this working folder.
+
+        GitPane keeps one window per working folder, so opening the folder again brings that window forward instead.
+        A file history window is not a repository window and is left out; another worktree of the same repository is
+        another folder, with its own window.
+        """
+        # Left as is on purpose: this check runs when an opening or a navigation is asked for, not again when it
+        # arrives. So two windows can still show one folder in a rare race: a second request for a folder while a first
+        # navigation to that same folder is still reading it, or a switch to a sub-folder of a repository, compared as
+        # given with the repository roots the windows show. Nothing is at risk then: every write reserves its
+        # repository first, so the two windows can never write to it at the same time.
+        target_dir = canonical_path(repository_dir)
+        for session_id, session in self.session_registry_controller.session_by_id.items():
+            if session_id == other_than or session.is_closed or session.file_history_anchor is not None:
+                continue
+            window = self.session_registry_controller.window_by_session.get(session_id)
+            if window is None or not isValid(window):
+                continue
+            if canonical_path(session.repository_context.repository_dir) == target_dir:
+                return window
+        return None
+
+    def bring_forward(self, window: QWidget) -> None:
+        """Show a window again in front of the others, restored if it was minimized."""
+        if window.isMinimized():
+            window.showNormal()
+        window.raise_()
+        window.activateWindow()
+
+    def _new_window_anchor(self, session_id: str, requesting_window: QWidget | None) -> QWidget | None:
+        """Return the window a new repository or file history window opens centred on.
+
+        The Clone repository window comes first while it is on screen, since the user is looking at it; then the Open
+        repository window of the session; a file history session has neither and uses the window that asked for it.
+        """
+        clone_dialog = self.session_registry_controller.clone_dialog_by_session.get(session_id)
+        if is_visible_window(clone_dialog):
+            return clone_dialog
+        welcome = self.session_registry_controller.welcome_by_session.get(session_id)
+        if is_visible_window(welcome):
+            return welcome
+        if is_visible_window(requesting_window):
+            return requesting_window
+        return None
+
+    def remember_repository(self, repository_dir: str) -> PreparedDiagnostic | None:
+        """Put a successfully opened repository first in the history, returning the diagnostic of a failed save.
+
+        A failed save never undoes the opening: the caller shows the diagnostic over the repository that is open.
+        """
+        try:
+            self.preference.remember(repository_dir)
+        except OSError as error:
+            return Diagnostic("Save preferences", repository_dir, self.repository.git_filename, [], str(error)).prepare()
+        return None
+
+    def show_preference_failure(self, diagnostic: PreparedDiagnostic, window: RepositoryWindow) -> None:
+        """Log a failed preference save and explain it in a dialog over the window that stays open."""
+        if self.diagnostic_log is not None:
+            self.diagnostic_log.write(diagnostic)
+        dialog = ErrorDialog(diagnostic, window, self.diagnostic_log.log_filename if self.diagnostic_log is not None else None)
+        self.session_registry_controller.dialogs.append(dialog)
+        dialog.finished.connect(lambda: self.session_registry_controller.dialogs.remove(dialog) if dialog in self.session_registry_controller.dialogs else None)
+        dialog.finished.connect(dialog.deleteLater)
+        open_window_modal(dialog)
+
+    def cancel_open(self, session_id: str) -> None:
+        """Abandon only the current chooser's read while keeping its form available."""
+        self.setting_controller.waiting_opening_by_session.pop(session_id, None)
+        self.session_registry_controller.identity_by_session.pop(session_id, None)
+        self.repository.cancel(session_id)
+        self.session_registry_controller.welcome_by_session[session_id].set_loading(False)

gitpane/controller/operation_policy.py

@@ -0,0 +1,76 @@
+"""Decide whether a window may still send a captured write to Git."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import TYPE_CHECKING
+
+from gitpane.history.file_history import WindowCapability
+from gitpane.operation.repository_operation import NO_LONGER_AUTHORIZED_TEXT, REPOSITORY_CHANGED_SINCE_OPENED_TEXT, REPOSITORY_CHANGED_WHILE_PREPARING_TEXT, rebase_action_diagnostic
+
+if TYPE_CHECKING:
+    from gitpane.controller.session_registry import SessionRegistry
+    from gitpane.history.repository import GitRepository
+    from gitpane.operation.repository_operation import OperationIntent, RepositoryOperationService
+    from gitpane.sequencer.rebase import RebaseService
+    from gitpane.transport.clone import CloneIntent
+
+
+class OperationPolicy:
+    """The authority a window keeps over the writes it captured."""
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, repository: GitRepository, repository_operation: RepositoryOperationService, rebase: RebaseService) -> None:
+        """Receive the sessions and the services the decision reads; the wiring builds it right after the rebase service, which it reads."""
+        self.session_registry_controller = session_registry_controller
+        self.repository = repository
+        self.repository_operation = repository_operation
+        self.rebase = rebase
+
+    def clone_is_current(self, intent: CloneIntent) -> bool:
+        """Prevent a closed or superseded welcome from publishing clone results."""
+        return (not self.session_registry_controller.shutdown_requested and intent.session_id in self.session_registry_controller.welcome_by_session and intent.session_id in self.session_registry_controller.clone_dialog_by_session
+                and self.session_registry_controller.clone_generation_by_session.get(intent.session_id) == intent.generation)
+
+    def allows(self, session_id: str, capability: WindowCapability) -> bool:
+        """Enforce the same action policy at service boundaries and widget entry points."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        return session is not None and not session.is_closed and capability in session.capabilities
+
+    def operation_allowed(self, intent: OperationIntent) -> bool:
+        """Validate captured window authority and repository identity at submission time."""
+        return not self.operation_refusal(intent)
+
+    def operation_refusal(self, intent: OperationIntent) -> str:
+        """Say why a captured write may no longer be sent, or "" when it may.
+
+        A window refreshed after its form was opened (an outside change the automatic refresh saw) has a newer
+        generation than the form's capture: the form cannot write any more and has to be reopened, which is what the
+        refusal says, rather than blaming another operation. A write captured at the click, with no form keeping it
+        (a stash, a rebase start, the push of a Commit & push), only has to be clicked again.
+        """
+        reason = self.repository_operation.policy_diagnostic(intent)
+        if reason:
+            return reason
+        state = self.rebase.state_by_key.get(intent.key)
+        if state is not None:
+            reason = rebase_action_diagnostic(intent.action, state)
+            if reason:
+                return reason
+        if intent.session_id is None:
+            return ""
+        if not self.allows(intent.session_id, intent.capability):
+            return NO_LONGER_AUTHORIZED_TEXT
+        session = self.session_registry_controller.session_by_id[intent.session_id]
+        if session.repository_context != intent.context or self.session_registry_controller.generation_by_session.get(intent.session_id) != intent.generation:
+            return REPOSITORY_CHANGED_SINCE_OPENED_TEXT if intent.from_form else REPOSITORY_CHANGED_WHILE_PREPARING_TEXT
+        return ""
+
+    def commit_push_operation(self, captured: OperationIntent) -> OperationIntent | None:
+        """Retain the original repository and permission through the normal history refresh."""
+        session_id = captured.session_id
+        if captured.capability != WindowCapability.MANAGE or not self.allows(session_id, WindowCapability.MANAGE):
+            return None
+        session = self.session_registry_controller.session_by_id[session_id]
+        if session.repository_context != captured.context or self.repository.git_filename != captured.git_filename:
+            return None
+        return replace(captured, generation=self.session_registry_controller.generation_by_session[session_id])