gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reference/delete_local_branch_dialog.py

@@ -0,0 +1,323 @@
+"""Reproduce the Git Extensions "Delete branch" window: a list of local branches to type or pick, then one Delete button."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMargins, QSize, Qt, Signal
+from PySide6.QtWidgets import QComboBox, QHBoxLayout, QLabel, QMessageBox, QPushButton, QVBoxLayout, QWidget
+from shiboken6 import isValid
+
+from gitpane.config import DELETE_BRANCH_TITLE, DELETE_BUTTON_TEXT, ICON_SIDE, LOCAL_PREFIX
+from gitpane.operation.operation_status import OperationStatus
+from gitpane.reference.reference_snapshot import short_reference_name
+from gitpane.text.typed_text import typed_value
+from gitpane.ui.look.action_icon import action_icon
+from gitpane.ui.look.theme_look import follow_theme
+from gitpane.ui.look.windows_control_look import apply_windows_button_look, apply_windows_combo_look
+from gitpane.ui.reference.reference_form import ReferenceFormDialog
+from gitpane.ui.reference.select_branches_dialog import SELECT_BRANCHES_CAPTION, SelectBranchesDialog
+from gitpane.ui.widget.dialog_layout import BandButtonSizing, fit_caption_column, fit_capture_control, install_banded_layout
+from gitpane.ui.window_control.dialog_modality import open_window_modal, prepare_message_box
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from gitpane.operation.repository_operation import OperationOutcome
+    from gitpane.reference.reference_edit import BranchDeletionIntent
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+
+MULTIPLE_BRANCHES_NAME = "Select multiple branches"
+MULTIPLE_BRANCHES_HINT = "Type several branch names separated by spaces"
+UNMERGED_QUESTION_HEADING = "The following branches are not fully merged:"
+UNMERGED_QUESTION_ENDING = "Delete them anyway?"
+NO_BRANCH_CAUSE = "Select at least one branch to delete"
+CURRENT_BRANCH_CAUSE = "is the current branch"
+OCCUPIED_BRANCH_CAUSE = "is checked out in a worktree or held by a rebase or bisect"
+UNKNOWN_BRANCH_CAUSE = "is not a local branch"
+# Typed branch names are separated by ASCII whitespace only: Git refuses the ASCII space and every ASCII control
+# character in a branch name, but accepts other Unicode spaces such as the non-breaking space, which therefore
+# belong to the name and never separate two of them.
+BRANCH_NAME_SEPARATOR_PATTERN = re.compile(r"\s+", re.ASCII)
+# Client area of the Git Extensions capture (412 x 91 inside the window borders and title bar).
+DELETE_BRANCH_CLIENT_SIZE = QSize(412, 91)
+# Measured on the capture in client pixels at 100 %: white body y 0-49, band line y 50, band y 51-90; "Select branches"
+# ink from x 15; branch list (104, 12, 272, 23); multiple selection button (381, 11, 21, 23); Delete button
+# (325, 59, 73, 23) in the band. The body starts 1 px left of the caption ink and at the multiple button's top.
+DELETE_BRANCH_BODY_MARGINS = QMargins(14, 11, 10, 0)
+# Caption width from its left edge to the branch list (104 - 14); a wider caption text widens it.
+DELETE_BRANCH_CAPTION_WIDTH = 90
+# Qt's first anti-aliased ink pixel sits on the text origin, one pixel left of the capture's ink.
+DELETE_BRANCH_CAPTION_INDENT = 1
+BRANCH_LIST_TO_BUTTON_SPACE = 5
+MULTIPLE_BRANCHES_BUTTON_SIZE = QSize(21, 23)
+DELETE_BUTTON_SIZE = QSize(73, 23)
+# The list sits 1 px lower than the multiple selection button in the capture.
+BRANCH_LIST_DROP = 1
+
+
+class DeleteLocalBranchDialog(ReferenceFormDialog):
+    """Delete one or several local branches, like the Git Extensions Delete branch window.
+
+    The list takes branch names separated by spaces, as the Git Extensions list does; Git never allows an ASCII space
+    or control character in a branch name, and only those separate names, so the text reads back without ambiguity
+    even for a name holding another Unicode space. The window only checks the typed names against the
+    branches the reference form controller offered and hands their full names over; that controller decides which ones are merged,
+    asks about the others and runs Git.
+    """
+
+    delete_requested = Signal(object)
+
+    def __init__(self, session_id: str, parent: QWidget | None = None) -> None:
+        """Build the caption, the editable branch list, the multiple selection button and the button band of the capture."""
+        super().__init__(session_id, parent)
+        self.setWindowTitle(DELETE_BRANCH_TITLE)
+        # The request the reference form controller froze once every branch was classified and every question answered.
+        self.intent: BranchDeletionIntent | None = None
+        # The full names of the local branches this window may delete, as the reference form controller computed them at opening.
+        self.candidate_refs: tuple[str, ...] = ()
+        # The Select multiple branches window while it is open.
+        self.select_dialog: SelectBranchesDialog | None = None
+        self.unmerged_question: QMessageBox | None = None
+        # Raised for each request the reference form controller has to ask Git about, so a late answer for an older one is dropped.
+        self.classification_generation = 0
+        layout = QVBoxLayout()
+        layout.setSpacing(0)
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, 0, 0)
+        row.setSpacing(0)
+        self.caption_label = QLabel(SELECT_BRANCHES_CAPTION)
+        self.caption_label.setContentsMargins(DELETE_BRANCH_CAPTION_INDENT, 0, 0, 0)
+        self.branch_combo = QComboBox()
+        self.branch_combo.setEditable(True)
+        # Typed names stay in the text; the list itself only ever holds the offered branches.
+        self.branch_combo.setInsertPolicy(QComboBox.InsertPolicy.NoInsert)
+        self.branch_combo.setAccessibleName(SELECT_BRANCHES_CAPTION)
+        self.caption_label.setBuddy(self.branch_combo)
+        branch_column = QVBoxLayout()
+        branch_column.setContentsMargins(0, BRANCH_LIST_DROP, 0, 0)
+        branch_column.setSpacing(0)
+        branch_column.addWidget(self.branch_combo)
+        self.multiple_button = QPushButton()
+        self.multiple_button.setIcon(action_icon("choose_revision", self.devicePixelRatioF()))
+        self.multiple_button.setIconSize(QSize(ICON_SIDE, ICON_SIDE))
+        self.multiple_button.setFixedSize(MULTIPLE_BRANCHES_BUTTON_SIZE)
+        self.multiple_button.setAccessibleName(MULTIPLE_BRANCHES_NAME)
+        self.multiple_button.setToolTip(MULTIPLE_BRANCHES_HINT)
+        # Only the Delete button may be the default one; see the Enter handling of the reference forms.
+        self.multiple_button.setAutoDefault(False)
+        # Offered once the window knows its branches.
+        self.multiple_button.setEnabled(False)
+        row.addWidget(self.caption_label, 0, Qt.AlignmentFlag.AlignVCenter)
+        row.addLayout(branch_column, 1)
+        row.addSpacing(BRANCH_LIST_TO_BUTTON_SPACE)
+        row.addWidget(self.multiple_button, 0, Qt.AlignmentFlag.AlignTop)
+        layout.addLayout(row)
+        layout.addStretch(1)
+        self.submit_button.setText(DELETE_BUTTON_TEXT)
+        self.submit_button.setEnabled(False)
+        # Git Extensions shows this form as a white body over a grey band holding its single button; there is no
+        # Cancel button, Escape and the title bar close it.
+        self.apply_theme_look()
+        self.button_band = install_banded_layout(self, layout, [self.submit_button], body_margins=DELETE_BRANCH_BODY_MARGINS, button_sizing=BandButtonSizing.WINDOW)
+        follow_theme(self, self.apply_theme_look)
+        # Enter runs Delete from anywhere in the form. The role is set only now, once the button belongs to the dialog:
+        # Qt then records it as the dialog's main default and gives it back whenever the focus moves.
+        self.submit_button.setDefault(True)
+        self.submit_button.clicked.connect(self._submit)
+        self.multiple_button.clicked.connect(self._open_select_dialog)
+        self.branch_combo.editTextChanged.connect(self._text_changed)
+        self.resize(DELETE_BRANCH_CLIENT_SIZE)
+        # Git Extensions gives this window the same minimum and maximum height: it only grows in width.
+        self.single_row_height = DELETE_BRANCH_CLIENT_SIZE.height()
+        self.refresh_metrics()
+        self.branch_combo.setFocus()
+
+    def apply_theme_look(self) -> None:
+        """Lay the light or dark look of the branch list and the multiple selection button, decided on the application palette.
+
+        Called by the constructor and again at each switch; the body and the band follow the switch on their own. Only
+        style sheets and palettes change: the branches typed or picked stay as they are.
+        """
+        apply_windows_combo_look(self.branch_combo, editable=True)
+        apply_windows_button_look(self.multiple_button)
+
+    def fit_capture_controls(self) -> None:
+        """Give the caption and the Delete button the capture's sizes, or more when their text needs it; a wider caption moves the list right."""
+        fit_caption_column((self.caption_label,), DELETE_BRANCH_CAPTION_WIDTH)
+        fit_capture_control(self.submit_button, DELETE_BUTTON_SIZE)
+
+    def populate(self, snapshot: ReferenceSnapshot, candidate_refs: tuple[str, ...], initial_ref: str) -> None:
+        """Offer the deletable branches of the references the window was opened on, starting with the clicked branch.
+
+        The clicked branch is written in the list even when it cannot be deleted, so pressing Delete explains why.
+        """
+        if self.closed or self.busy or self.completed:
+            return
+        self.snapshot = snapshot
+        self.candidate_refs = candidate_refs
+        self.branch_combo.blockSignals(True)
+        self.branch_combo.clear()
+        for full_ref in candidate_refs:
+            self.branch_combo.addItem(short_reference_name(full_ref), full_ref)
+        initial_index = self.branch_combo.findData(initial_ref)
+        self.branch_combo.setCurrentIndex(initial_index)
+        if initial_index < 0:
+            self.branch_combo.setEditText(short_reference_name(initial_ref))
+        self.branch_combo.blockSignals(False)
+        self.branch_combo.lineEdit().selectAll()
+        self.branch_combo.setFocus()
+        self.multiple_button.setEnabled(True)
+        self._text_changed()
+
+    def selected_refs(self) -> tuple[str, ...]:
+        """Read the typed names as full local branch names, in the typed order and each only once."""
+        full_refs: list[str] = []
+        for name in BRANCH_NAME_SEPARATOR_PATTERN.split(self.branch_combo.currentText()):
+            if not name:
+                continue
+            full_ref = LOCAL_PREFIX + name
+            if full_ref not in full_refs:
+                full_refs.append(full_ref)
+        return tuple(full_refs)
+
+    def known_selected_refs(self) -> tuple[str, ...]:
+        """Read the typed names that are offered branches, silently leaving the others aside, to pre-check them in the list."""
+        full_refs: list[str] = []
+        for full_ref in self.selected_refs():
+            if full_ref in self.candidate_refs:
+                full_refs.append(full_ref)
+        return tuple(full_refs)
+
+    def _open_select_dialog(self) -> None:
+        """Open Select multiple branches on the offered branches, the typed ones checked, without starting Git."""
+        if self.closed or self.busy or self.completed or self.snapshot is None:
+            return
+        if self.select_dialog is not None and isValid(self.select_dialog) and self.select_dialog.isVisible():
+            self.select_dialog.raise_()
+            return
+        dialog = SelectBranchesDialog(self.candidate_refs, set(self.known_selected_refs()), self)
+        self.select_dialog = dialog
+        dialog.selection_applied.connect(self._apply_selection)
+        dialog.finished.connect(dialog.deleteLater)
+        open_window_modal(dialog)
+
+    def _apply_selection(self, full_refs: tuple[str, ...]) -> None:
+        """Write the branches checked in Select multiple branches as the list text, their names separated by spaces.
+
+        Git Extensions replaces the text with the checked branches however its window was closed, so an empty
+        selection empties the text.
+        """
+        self.select_dialog = None
+        if self.closed or self.busy or self.completed:
+            return
+        names: list[str] = []
+        for full_ref in full_refs:
+            names.append(short_reference_name(full_ref))
+        self.branch_combo.setEditText(" ".join(names))
+        self.branch_combo.setFocus()
+
+    def _refusal_cause(self, full_refs: tuple[str, ...]) -> str:
+        """Explain which typed names cannot be deleted and why, or answer an empty text when all of them can."""
+        if not full_refs:
+            return NO_BRANCH_CAUSE
+        causes: list[str] = []
+        for full_ref in full_refs:
+            if full_ref in self.candidate_refs:
+                continue
+            name = "'" + short_reference_name(full_ref) + "' "
+            if self.snapshot is not None and full_ref == self.snapshot.head_ref:
+                causes.append(name + CURRENT_BRANCH_CAUSE)
+            elif self.snapshot is not None and full_ref in self.snapshot.object_oid_by_name:
+                causes.append(name + OCCUPIED_BRANCH_CAUSE)
+            else:
+                causes.append(name + UNKNOWN_BRANCH_CAUSE)
+        if not causes:
+            return ""
+        return "Cannot delete: " + "; ".join(causes) + "."
+
+    def _text_changed(self) -> None:
+        """Offer Delete again once the typed names change, dropping the explanation of an earlier refusal."""
+        self.submit_button.setToolTip("")
+        self.submit_button.setEnabled(self.snapshot is not None and bool(typed_value(self.branch_combo.currentText())) and not self.busy
+                                      and not self.completed and not self.closed)
+
+    def _submit(self) -> None:
+        """Hand the typed branches to the reference form controller once, or explain before any process why some cannot be deleted."""
+        if self.closed or self.busy or self.completed or self.snapshot is None or not self.submit_button.isEnabled():
+            return
+        full_refs = self.selected_refs()
+        cause = self._refusal_cause(full_refs)
+        if cause:
+            self.show_error(cause)
+            return
+        self.busy = True
+        self._set_controls_enabled(False)
+        self.delete_requested.emit(full_refs)
+
+    def show_unmerged_question(self, unmerged_refs: tuple[str, ...], answer: Callable[[bool], None]) -> None:
+        """Ask once whether the listed branches may lose their commits, without blocking the application.
+
+        No is the default and the answer of Escape. An answer given after the window closed is dropped.
+        """
+        if self.closed:
+            return
+        lines = [UNMERGED_QUESTION_HEADING]
+        for full_ref in unmerged_refs:
+            lines.append(short_reference_name(full_ref))
+        lines.append(UNMERGED_QUESTION_ENDING)
+        question = QMessageBox(QMessageBox.Icon.Warning, DELETE_BRANCH_TITLE, "\n".join(lines),
+                               QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, self)
+        prepare_message_box(question, DELETE_BRANCH_TITLE)
+        question.setTextFormat(Qt.TextFormat.PlainText)
+        no_button = question.button(QMessageBox.StandardButton.No)
+        yes_button = question.button(QMessageBox.StandardButton.Yes)
+        question.setDefaultButton(no_button)
+        question.setEscapeButton(no_button)
+        self.unmerged_question = question
+
+        def finished() -> None:
+            """Pass the answer on once, and only while the window that asked is still open."""
+            self.unmerged_question = None
+            accepted = question.clickedButton() is yes_button
+            question.deleteLater()
+            if self.closed:
+                return
+            answer(accepted)
+
+        question.finished.connect(finished)
+        open_window_modal(question)
+
+    def release(self) -> None:
+        """Give the form back to the user after a request that wrote nothing, such as a No to the question."""
+        if self.closed:
+            return
+        self.busy = False
+        self.intent = None
+        self._set_controls_enabled(True)
+        self._text_changed()
+
+    def show_outcome(self, outcome: OperationOutcome) -> None:
+        """Close once every branch was deleted; otherwise keep the form, frozen, while the console explains each branch."""
+        self.busy = False
+        if outcome.status == OperationStatus.SUCCESS:
+            self.accept()
+            return
+        self.completed = True
+        self._set_controls_enabled(False)
+
+    def _set_controls_enabled(self, enabled: bool) -> None:
+        """Enable or disable the branch list, the multiple selection button and the Delete button together."""
+        self.branch_combo.setEnabled(enabled)
+        self.multiple_button.setEnabled(enabled)
+        self.submit_button.setEnabled(enabled)
+
+    def _closed(self) -> None:
+        """Close a pending question or branch selection with the window, so its late answer can never start a deletion."""
+        super()._closed()
+        self.classification_generation += 1
+        if self.unmerged_question is not None and isValid(self.unmerged_question):
+            self.unmerged_question.reject()
+        if self.select_dialog is not None and isValid(self.select_dialog):
+            self.select_dialog.reject()