gitpane 1.0.0__py3-none-any.whl

gitpane/controller/rebase_editor_controller.py

@@ -0,0 +1,309 @@
+"""Serve each rebase edit request from its window until Git gets its answer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Signal
+from shiboken6 import isValid
+
+from gitpane.config import LINE_SEPARATOR
+from gitpane.sequencer.commit_message_rule import message_is_empty, read_commit_message_rule
+from gitpane.sequencer.rebase_edit_file import read_edit_file, write_edit_file
+from gitpane.sequencer.rebase_state import read_message_context
+from gitpane.tool.editor import EditorAnswer, EditorRequestKind
+from gitpane.ui.sequencer.rebase_editor_window import EditorValidation, RebaseEditorText, RebaseEditorWindow
+from gitpane.worktree.command_sequence import FileTask
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.history.repository_value import RepositoryContext
+    from gitpane.sequencer.commit_message_rule import CommitMessageRule
+    from gitpane.sequencer.rebase_edit_file import EditFileContent
+    from gitpane.sequencer.rebase_state import RebaseMessageCommit
+    from gitpane.tool.editor import EditorRequest, EditorService, PendingEdit
+    from gitpane.worktree.worktree_service import WorktreeService
+
+@dataclass(frozen=True)
+class ExpectedEdit:
+    """What one rebase operation needs to show the edits Git asks for: its repository, its Git and how its windows validate."""
+
+    context: RepositoryContext
+    git_filename: str
+    validation: EditorValidation
+    parent_window: QWidget | None
+
+
+@dataclass(frozen=True)
+class EditRead:
+    """What the window of one edit needs: the file Git waits for and, for a commit message, the commits it is about and the repository's rule for an empty message."""
+
+    content: EditFileContent
+    commits: tuple[RebaseMessageCommit, ...] = ()
+    rule: CommitMessageRule | None = None
+
+
+# Between the short hash of a commit and its subject in the header of a message window.
+COMMIT_LINE_SEPARATOR = " "
+
+
+def message_context_lines(repository_dir: str, commits: tuple[RebaseMessageCommit, ...]) -> tuple[str, ...]:
+    """Answer the header of a message window: the repository folder, then the short hash and subject of each commit the message is about."""
+    lines = [repository_dir]
+    for commit in commits:
+        lines.append(commit.short_oid + COMMIT_LINE_SEPARATOR + commit.subject)
+    return tuple(lines)
+
+
+def edit_failure_reason(error: Exception) -> str:
+    """Name why a read or a write failed without quoting the file's content or its path.
+
+    The system's own reason is kept for a system error; the errors raised by the file module carry fixed texts.
+    """
+    if isinstance(error, OSError) and error.strerror:
+        return error.strerror
+    if isinstance(error, UnicodeError):
+        return RebaseEditorText.ENCODING_FAILED.value
+    return str(error)
+
+
+def save_failure_text(error: Exception | None) -> str:
+    """Answer the line a failed save shows: its fixed start, then why the file could not be written, never the text."""
+    cause = edit_failure_reason(error) if error is not None else RebaseEditorText.WRITE_GAVE_NO_RESULT.value
+    return RebaseEditorText.SAVE_FAILED.value.format(cause=cause)
+
+
+class RebaseEditorController(QObject):
+    """Turn the edits Git asks for during an expected rebase operation into windows, then their answers into the codes Git receives."""
+
+    # Tells that the window of an edit Git waits for is shown: the EditorRequest and its RebaseEditorWindow.
+    window_shown = Signal(object, object)
+
+    def __init__(self, *, editor: EditorService, worktree_service: WorktreeService, parent: QObject | None = None) -> None:
+        """Receive the editor service whose requests it serves and the scheduler that reads and writes Git's files off the Qt thread.
+
+        The rebase coordinator builds it and says which operations it serves; a test builds it on bare services.
+        """
+        super().__init__(parent)
+        self.editor = editor
+        self.worktree_service = worktree_service
+        self.expected_by_operation_id: dict[str, ExpectedEdit] = {}
+        self.window_by_operation_id: dict[str, RebaseEditorWindow] = {}
+        self.pending_by_operation_id: dict[str, PendingEdit] = {}
+        self.content_by_operation_id: dict[str, EditFileContent] = {}
+        # The repository's rule for an empty commit message, read when Git asked for the message the window shows.
+        self.rule_by_operation_id: dict[str, CommitMessageRule] = {}
+        # The problem a command was started to fix, shown once in the first window of that command.
+        self.error_text_by_operation_id: dict[str, str] = {}
+        # The error line a window opened with, such as Git's refusal of the instructions: a successful save shows it
+        # again instead of clearing the line.
+        self.opening_error_text_by_operation_id: dict[str, str] = {}
+        editor.edit_requested.connect(self._edit_requested)
+        editor.edit_cancelled.connect(self._edit_cancelled)
+
+    def expect_edits(self, operation_id: str, context: RepositoryContext, git_filename: str, validation: EditorValidation, parent_window: QWidget | None, error_text: str = "") -> None:
+        """Serve the edits Git asks for during this operation, each in a window parented to the given one.
+
+        An error text, such as the problem Git found in the instructions, is shown above the text of the first window.
+        """
+        self.expected_by_operation_id[operation_id] = ExpectedEdit(context, git_filename, validation, parent_window)
+        if error_text:
+            self.error_text_by_operation_id[operation_id] = error_text
+        else:
+            self.error_text_by_operation_id.pop(operation_id, None)
+
+    def raise_windows(self) -> None:
+        """Bring every editor window still waiting for its answer to the front, so a close that waits for Git sends the user to it."""
+        for window in tuple(self.window_by_operation_id.values()):
+            if not isValid(window) or window.answered:
+                continue
+            window.show()
+            window.raise_()
+            window.activateWindow()
+
+    def forget(self, operation_id: str) -> None:
+        """Stop serving this operation and close the window left from its last edit."""
+        self.expected_by_operation_id.pop(operation_id, None)
+        self.pending_by_operation_id.pop(operation_id, None)
+        self.content_by_operation_id.pop(operation_id, None)
+        self.rule_by_operation_id.pop(operation_id, None)
+        self.error_text_by_operation_id.pop(operation_id, None)
+        self.opening_error_text_by_operation_id.pop(operation_id, None)
+        window = self.window_by_operation_id.pop(operation_id, None)
+        if window is not None:
+            window.close_after_answer()
+            window.deleteLater()
+
+    def _edit_requested(self, pending: PendingEdit) -> None:
+        """Read the file of an edit this controller expects; an edit of another operation is left to its own owner."""
+        request = pending.request
+        expected = self.expected_by_operation_id.get(request.operation_id)
+        if expected is None:
+            return
+        self.pending_by_operation_id[request.operation_id] = pending
+        self.content_by_operation_id.pop(request.operation_id, None)
+        self.rule_by_operation_id.pop(request.operation_id, None)
+        self.worktree_service.run(expected.context, expected.git_filename, self._read(request, expected.context.git_dir),
+                                  lambda read, error: self._show(pending, expected, read, error))
+
+    def _edit_cancelled(self, request: EditorRequest) -> None:
+        """Close the window of a request whose bridge was lost; a click left on it no longer reaches Git."""
+        pending = self.pending_by_operation_id.get(request.operation_id)
+        if pending is None or pending.request is not request:
+            return
+        del self.pending_by_operation_id[request.operation_id]
+        window = self.window_by_operation_id.get(request.operation_id)
+        if window is not None:
+            window.close_after_answer()
+
+    def _read(self, request: EditorRequest, git_dir: str) -> Generator:
+        """Read the file Git waits for off the Qt thread; for a commit message, read first the repository's message settings, then the commits it is about.
+
+        One git config call gives the comment prefix and cleanup the empty-message rule follows, and the commit encoding
+        a message that is not UTF-8 is decoded and written back with.
+        """
+        if request.kind != EditorRequestKind.MESSAGE:
+            content = yield FileTask(lambda: read_edit_file(request.file_filename, request.file_identity))
+            return EditRead(content)
+        rule = yield from read_commit_message_rule()
+        content = yield FileTask(lambda: read_edit_file(request.file_filename, request.file_identity, fallback_codec=rule.commit_encoding))
+        commits = yield FileTask(lambda: read_message_context(git_dir))
+        return EditRead(content, commits, rule)
+
+    def _show(self, pending: PendingEdit, expected: ExpectedEdit, read: EditRead | None, error: Exception | None) -> None:
+        """Open the window of a read edit, read-only with its reason when the file cannot be written back exactly.
+
+        A message window names above its text the repository and the commits the message is about.
+        """
+        operation_id = pending.request.operation_id
+        content = read.content if read is not None else None
+        if pending.answered or self.pending_by_operation_id.get(operation_id) is not pending:
+            return
+        previous = self.window_by_operation_id.pop(operation_id, None)
+        if previous is not None:
+            previous.close_after_answer()
+            previous.deleteLater()
+        # A message always hands its text to Git: saving it while the rebase stays paused would mean nothing.
+        validation = EditorValidation.CONTINUE if pending.request.kind == EditorRequestKind.MESSAGE else expected.validation
+        window = RebaseEditorWindow(pending.request.kind, validation, content.text if content is not None else "", expected.context.repository_dir, expected.parent_window)
+        if pending.request.kind == EditorRequestKind.MESSAGE:
+            window.show_context(message_context_lines(expected.context.repository_dir, read.commits if read is not None else ()))
+        if error is not None:
+            window.set_read_only(RebaseEditorText.READ_FAILED.value.format(button=validation.label, cause=edit_failure_reason(error)))
+        elif content.read_only_cause is not None:
+            window.set_read_only(content.read_only_cause.label)
+        error_text = self.error_text_by_operation_id.pop(operation_id, "")
+        if error_text:
+            # The problem the command was started to fix comes first; a reason the text is read-only stays under it.
+            error_lines = [error_text]
+            if window.error_label.text():
+                error_lines.append(window.error_label.text())
+            window.show_error(LINE_SEPARATOR.join(error_lines))
+        self.opening_error_text_by_operation_id[operation_id] = window.error_label.text()
+        if content is not None:
+            self.content_by_operation_id[operation_id] = content
+        if read is not None and read.rule is not None:
+            self.rule_by_operation_id[operation_id] = read.rule
+        self.window_by_operation_id[operation_id] = window
+        window.validate_requested.connect(lambda: self._validate(operation_id, window))
+        window.save_requested.connect(lambda: self._save(operation_id, window))
+        window.abort_requested.connect(lambda: self._abort(operation_id, window))
+        window.present()
+        self.window_shown.emit(pending.request, window)
+
+    def _served(self, operation_id: str, window: RebaseEditorWindow) -> PendingEdit | None:
+        """Answer the request this window still serves, or nothing once it was answered, lost or replaced."""
+        pending = self.pending_by_operation_id.get(operation_id)
+        if pending is None or pending.answered or self.window_by_operation_id.get(operation_id) is not window:
+            return None
+        return pending
+
+    def _validate(self, operation_id: str, window: RebaseEditorWindow) -> None:
+        """Write the edited text, then hand it to Git; a file that cannot be written back goes to Git unchanged.
+
+        A commit message Git would find empty under the repository's settings is refused: the window stays open with
+        the reason and Git keeps waiting, since Git would abort the commit and pause the rebase.
+        """
+        pending = self._served(operation_id, window)
+        if pending is None:
+            return
+        content = self.content_by_operation_id.get(operation_id)
+        if content is None or content.read_only_cause is not None:
+            self._answer(operation_id, pending, window, EditorAnswer.CONTINUE)
+            return
+        expected = self.expected_by_operation_id.get(operation_id)
+        if expected is None:
+            return
+        text = window.edited_text()
+        rule = self.rule_by_operation_id.get(operation_id)
+        if rule is not None and message_is_empty(text, rule):
+            window.show_error(RebaseEditorText.EMPTY_MESSAGE.value)
+            return
+        window.set_busy(True)
+        self.worktree_service.run(expected.context, expected.git_filename, self._write(content, text),
+                                  lambda written, error: self._written(operation_id, pending, window, written, error))
+
+    def _write(self, content: EditFileContent, text: str) -> Generator:
+        """Write the edited text off the Qt thread."""
+        return (yield FileTask(lambda: write_edit_file(content, text)))
+
+    def _written(self, operation_id: str, pending: PendingEdit, window: RebaseEditorWindow, written: EditFileContent | None, error: Exception | None) -> None:
+        """Hand a saved text to Git, or keep the window open with the cause when saving failed: Git never receives an unsaved text."""
+        if pending.answered or self.pending_by_operation_id.get(operation_id) is not pending:
+            return
+        if error is not None or written is None:
+            window.show_error(save_failure_text(error))
+            window.set_busy(False)
+            return
+        self.content_by_operation_id[operation_id] = written
+        self._answer(operation_id, pending, window, EditorAnswer.CONTINUE)
+
+    def _save(self, operation_id: str, window: RebaseEditorWindow) -> None:
+        """Write the edited text without answering Git, as Ctrl+S asks: the window stays open and Git keeps waiting.
+
+        A file shown read-only, or one that could not be read, has nothing to save. The window stays busy during the
+        write, so neither a second Ctrl+S nor Continue starts another one.
+        """
+        pending = self._served(operation_id, window)
+        if pending is None:
+            return
+        content = self.content_by_operation_id.get(operation_id)
+        expected = self.expected_by_operation_id.get(operation_id)
+        if content is None or content.read_only_cause is not None or expected is None:
+            return
+        window.set_busy(True)
+        self.worktree_service.run(expected.context, expected.git_filename, self._write(content, window.edited_text()),
+                                  lambda written, error: self._saved(operation_id, pending, window, written, error))
+
+    def _saved(self, operation_id: str, pending: PendingEdit, window: RebaseEditorWindow, written: EditFileContent | None, error: Exception | None) -> None:
+        """Keep the saved text as the one Git's file now holds, or show why it could not be saved; Git receives no answer either way.
+
+        A successful save clears only what the window showed itself, a failed save or an empty message, and shows again
+        the error the window opened with: Git has not checked the saved text yet, so its refusal still says what to fix.
+        """
+        if pending.answered or self.pending_by_operation_id.get(operation_id) is not pending:
+            return
+        window.set_busy(False)
+        if error is not None or written is None:
+            window.show_error(save_failure_text(error))
+            return
+        # The saved text and its new file identity: Continue on the same text writes nothing more, and a later write checks this file.
+        self.content_by_operation_id[operation_id] = written
+        window.show_error(self.opening_error_text_by_operation_id.get(operation_id, ""))
+
+    def _abort(self, operation_id: str, window: RebaseEditorWindow) -> None:
+        """Answer Abort to Git for the request this window serves."""
+        pending = self._served(operation_id, window)
+        if pending is None:
+            return
+        self._answer(operation_id, pending, window, EditorAnswer.ABORT)
+
+    def _answer(self, operation_id: str, pending: PendingEdit, window: RebaseEditorWindow, answer: EditorAnswer) -> None:
+        """Give Git its one answer, then close the window; the window stays known until the next edit or the end of the operation."""
+        self.pending_by_operation_id.pop(operation_id, None)
+        pending.answer(answer)
+        window.close_after_answer()