gitpane 1.0.0__py3-none-any.whl

gitpane/ui/transport/push_rejection_prompt.py

@@ -0,0 +1,100 @@
+"""Explain a Push the server refused because its branch holds commits the push would replace, with the next step to take."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QSize, Qt, Signal
+from PySide6.QtWidgets import QDialog, QHBoxLayout, QLabel, QPushButton, QStyle, QVBoxLayout
+
+from gitpane.config import LOCAL_PREFIX
+from gitpane.ui.widget.dialog_layout import (
+    MESSAGE_BOX_BODY_MARGINS,
+    MESSAGE_BOX_BUTTON_BAND,
+    MESSAGE_BOX_ICON_SIDE,
+    MESSAGE_BOX_ICON_TO_TEXT_SPACE,
+    install_banded_layout,
+)
+from gitpane.ui.widget.standard_icon_label import StandardIconLabel
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.transport.branch_exchange import PushRejection
+
+PUSH_REJECTION_TITLE = "Push rejected"
+FORCE_WITH_LEASE_LABEL = "Force push with lease"
+# The explanation wraps at a message-box width instead of stretching the prompt across the screen.
+PUSH_REJECTION_TEXT_WIDTH = 460
+UNSEEN_COMMITS_TEXT = ("The remote branch {branch} on {remote} has commits that you have not fetched: someone pushed to it after your last Fetch.\n\n"
+                       "Fetch to get their commits. Until then a force push with lease is refused, so their work is never replaced without you seeing it.")
+REWRITTEN_BRANCH_TEXT = ("The remote branch {branch} on {remote} is still at the commit you last fetched, but your branch no longer contains it "
+                         "(it was rewritten, for example by an amend or a rebase).\n\n"
+                         "Warning: Force push with lease means the remote branch will be replaced by yours.")
+NO_FETCHED_STATE_TEXT = ("The destination refused the push because its branch {branch} has commits that your branch does not contain.\n\n"
+                         "This destination is not a configured remote with a remote-tracking branch, so GitPane has no fetched state to compare with "
+                         "and cannot offer Fetch or a force push with lease. Push through a configured remote instead.")
+
+
+def push_rejection_text(rejection: PushRejection) -> str:
+    """Pick the explanation that matches what the user can do about this refusal."""
+    branch = rejection.destination_ref.removeprefix(LOCAL_PREFIX)
+    if not rejection.tracking_ref:
+        return NO_FETCHED_STATE_TEXT.format(branch=branch)
+    if rejection.unseen_commits:
+        return UNSEEN_COMMITS_TEXT.format(branch=branch, remote=rejection.remote_name)
+    return REWRITTEN_BRANCH_TEXT.format(branch=branch, remote=rejection.remote_name)
+
+
+class PushRejectionPrompt(QDialog):
+    """Offer Fetch when the remote holds commits the user has not fetched, or Force push with lease when only the local branch was rewritten.
+
+    Force is never offered while unseen commits exist: the lease would refuse it anyway, and the user asked to always be
+    told about new commits before anything replaces them. Cancel, Escape and the title-bar close do nothing else.
+    """
+
+    fetch_requested = Signal()
+    force_requested = Signal()
+
+    def __init__(self, rejection: PushRejection, parent: QWidget | None = None) -> None:
+        """Build the prompt with only the actions that apply to this refusal."""
+        super().__init__(parent)
+        self.rejection = rejection
+        self.answered = False
+        self.setWindowTitle(PUSH_REJECTION_TITLE)
+        self.setWindowFlags(Qt.WindowType.Dialog | Qt.WindowType.CustomizeWindowHint | Qt.WindowType.WindowTitleHint | Qt.WindowType.WindowCloseButtonHint)
+        layout = QVBoxLayout()
+        layout.setSpacing(0)
+        message_row = QHBoxLayout()
+        message_row.setSpacing(MESSAGE_BOX_ICON_TO_TEXT_SPACE)
+        icon_label = StandardIconLabel(QSize(MESSAGE_BOX_ICON_SIDE, MESSAGE_BOX_ICON_SIDE), QStyle.StandardPixmap.SP_MessageBoxWarning)
+        message_row.addWidget(icon_label, 0, Qt.AlignmentFlag.AlignTop)
+        self.text_label = QLabel(push_rejection_text(rejection))
+        self.text_label.setTextFormat(Qt.TextFormat.PlainText)
+        self.text_label.setWordWrap(True)
+        self.text_label.setFixedWidth(PUSH_REJECTION_TEXT_WIDTH)
+        self.text_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextSelectableByKeyboard)
+        message_row.addWidget(self.text_label, 1)
+        layout.addLayout(message_row)
+        self.force_button = QPushButton(FORCE_WITH_LEASE_LABEL)
+        self.fetch_button = QPushButton("Fetch")
+        self.cancel_button = QPushButton("Cancel")
+        for button in (self.force_button, self.fetch_button, self.cancel_button):
+            button.setAutoDefault(False)
+        install_banded_layout(self, layout, [self.force_button, self.fetch_button, self.cancel_button], MESSAGE_BOX_BUTTON_BAND, MESSAGE_BOX_BODY_MARGINS)
+        can_fetch = bool(rejection.remote_name and rejection.tracking_ref)
+        can_force = can_fetch and not rejection.unseen_commits
+        self.force_button.setVisible(can_force)
+        self.fetch_button.setVisible(can_fetch and not can_force)
+        # The safe answer is the default one: Fetch when it is offered, otherwise Cancel; forcing always takes a deliberate click.
+        (self.fetch_button if self.fetch_button.isVisibleTo(self) else self.cancel_button).setDefault(True)
+        self.force_button.clicked.connect(lambda: self._answer(self.force_requested))
+        self.fetch_button.clicked.connect(lambda: self._answer(self.fetch_requested))
+        self.cancel_button.clicked.connect(self.reject)
+
+    def _answer(self, signal: Signal) -> None:
+        """Emit the chosen action at most once, then close the prompt."""
+        if not self.answered:
+            self.answered = True
+            signal.emit()
+        self.accept()

gitpane/ui/transport/push_tracking_question.py

@@ -0,0 +1,88 @@
+"""Ask whether a branch pushed without upstream gets a tracking reference."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QCheckBox, QMessageBox
+
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+
+class PushTrackingText(Enum):
+    """The texts of the question a Push asks before sending a branch that follows no remote branch."""
+
+    TITLE = "Push"
+    QUESTION = "The branch {branch} does not have a tracking reference. Do you want to add a tracking reference to {destination}?"
+    YES = "Yes"
+    NO = "No"
+    CANCEL = "Cancel"
+    DONT_ASK_AGAIN = "Don't ask again"
+
+
+class PushTrackingAnswer(Enum):
+    """What the user answered: push and link, push without linking, or push nothing."""
+
+    YES = "yes"
+    NO = "no"
+    CANCEL = "cancel"
+
+
+def push_tracking_question_box(parent: QWidget, branch_name: str, destination_name: str) -> QMessageBox:
+    """Build the question for ``branch_name`` pushed to ``destination_name``, without connecting or opening it.
+
+    Yes is the default button, so Enter pushes and links like Git Extensions; Cancel is the escape button, so Escape and
+    the title-bar close push nothing. The window gallery builds the same question to show it without opening it.
+    """
+    title = PushTrackingText.TITLE.value
+    box = QMessageBox(QMessageBox.Icon.Question, title, PushTrackingText.QUESTION.value.format(branch=branch_name, destination=destination_name), QMessageBox.StandardButton.NoButton, parent)
+    prepare_message_box(box, title)
+    box.setTextFormat(Qt.TextFormat.PlainText)
+    yes_button = box.addButton(PushTrackingText.YES.value, QMessageBox.ButtonRole.YesRole)
+    box.addButton(PushTrackingText.NO.value, QMessageBox.ButtonRole.NoRole)
+    cancel_button = box.addButton(PushTrackingText.CANCEL.value, QMessageBox.ButtonRole.RejectRole)
+    box.setDefaultButton(yes_button)
+    box.setEscapeButton(cancel_button)
+    # Workaround: PySide does not hand the check box to the question in setCheckBox, so a check box without a parent
+    # is deleted with its Python wrapper and the question then reads a deleted widget. Its parent keeps it alive.
+    box.setCheckBox(QCheckBox(PushTrackingText.DONT_ASK_AGAIN.value, box))
+    return box
+
+
+def clicked_answer(box: QMessageBox) -> PushTrackingAnswer:
+    """Read the answer from the button that closed the question; no button at all, or any other one, is Cancel."""
+    clicked = box.clickedButton()
+    if clicked is None:
+        return PushTrackingAnswer.CANCEL
+    role = box.buttonRole(clicked)
+    if role == QMessageBox.ButtonRole.YesRole:
+        return PushTrackingAnswer.YES
+    if role == QMessageBox.ButtonRole.NoRole:
+        return PushTrackingAnswer.NO
+    return PushTrackingAnswer.CANCEL
+
+
+def ask_push_tracking(parent: QWidget, branch_name: str, destination_name: str, answered: Callable[[PushTrackingAnswer, bool], None]) -> QMessageBox:
+    """Open the question and hand ``answered`` the answer and whether Don't ask again was checked, once it closes.
+
+    A close that clicked no button, such as a rejection by the code, counts as Cancel, like Escape and the title-bar close.
+    """
+    box = push_tracking_question_box(parent, branch_name, destination_name)
+
+    def finish() -> None:
+        """Read the clicked button and the check box before the question goes away."""
+        answer = clicked_answer(box)
+        dont_ask_again = box.checkBox().isChecked()
+        box.deleteLater()
+        answered(answer, dont_ask_again)
+
+    box.finished.connect(finish)
+    open_window_modal(box)
+    return box