gitpane 1.0.0__py3-none-any.whl

gitpane/ui/staging/staging_action.py

@@ -0,0 +1,356 @@
+"""Translate native text selection into captured byte-line intentions."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QObject, Qt, Signal
+from PySide6.QtWidgets import QMenu, QMessageBox
+
+from gitpane.config import ERROR_WIDTH, SPACING_MD, STAGE_SHORTCUT
+from gitpane.history.repository_value import BlobContentKind
+from gitpane.history.revision_file import DiffLineKind, decode_blob_display
+from gitpane.ui.emoji.file_action_icon import file_action_icon
+from gitpane.ui.widget.shortcut_text import with_shortcut
+from gitpane.ui.widget.system_shortcut import trash_key_pressed
+from gitpane.ui.window_control.dialog_modality import prepare_message_box
+from gitpane.worktree.file_menu_action import READ_ONLY_FILE_ACTION_SET, FileAction
+from gitpane.worktree.ignore_rule import IgnoreDestination
+from gitpane.worktree.partial_patch import RawLineSelection
+from gitpane.worktree.worktree_snapshot import StagingSide, local_history_path
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtCore import QPoint
+    from PySide6.QtWidgets import QListWidget
+
+    from gitpane.ui.reader.diff_panel import DiffView
+    from gitpane.ui.staging.staging_window import StagingWindow
+    from gitpane.worktree.partial_patch import RawPatch
+    from gitpane.worktree.staged_reset import ResetCandidate
+    from gitpane.worktree.trash import TrashRequest
+    from gitpane.worktree.worktree_snapshot import LocalEntry, WorktreeSnapshot
+
+
+SELECT_ONE_FILE_REASON = "Select one file"
+MOVE_TO_TRASH_TITLE = "Move selected file(s) to Trash"
+
+
+def configure_confirmation(dialog: QMessageBox, action_label: str, cancel_label: str) -> None:
+    """Name the exact effect and make both default activation and Escape cancel safely."""
+    dialog.setTextFormat(Qt.TextFormat.PlainText)
+    dialog.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextSelectableByKeyboard)
+    dialog.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel)
+    dialog.button(QMessageBox.StandardButton.Yes).setText(action_label)
+    dialog.button(QMessageBox.StandardButton.Cancel).setText(cancel_label)
+    dialog.setDefaultButton(QMessageBox.StandardButton.Cancel)
+    dialog.setEscapeButton(QMessageBox.StandardButton.Cancel)
+
+
+def show_confirmation_targets(dialog: QMessageBox, summary: str, labels: list[str]) -> None:
+    """Keep a short native summary above scrollable, complete target names and calculated details."""
+    preview = next(iter(labels)) if len(labels) == 1 else f"{len(labels)} selected files"
+    available_width = min(ERROR_WIDTH, dialog.screen().availableGeometry().width()) - SPACING_MD * 2
+    preview = dialog.fontMetrics().elidedText(preview.replace("\r", "\\r").replace("\n", "\\n"), Qt.TextElideMode.ElideMiddle, available_width)
+    dialog.setText(summary + "\n" + preview)
+    details = dialog.detailedText()
+    dialog.setDetailedText("\n".join(labels) + ("\n\n" + details if details else ""))
+
+
+class FileResetMenu(QObject):
+    """Capture exact list selections for a direct side-specific Reset action."""
+
+    requested = Signal(object)
+    delete_requested = Signal(object, object)
+    ignore_requested = Signal(object, object, object)
+    action_requested = Signal(object, object, object)
+
+    def __init__(self, window: StagingWindow) -> None:
+        """Attach menus to both lists while keeping the source side with each entry."""
+        super().__init__(window)
+        self.window = window
+        # The system whose trash keys the file lists follow; a test sets another one to check that system's keys.
+        self.platform = sys.platform
+        for file_list in (window.unstaged_list, window.staged_list):
+            file_list.installEventFilter(self)
+            file_list.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+            file_list.customContextMenuRequested.connect(lambda position, file_list=file_list: self._open(file_list, position))
+
+    def create_menu(self, file_list: QListWidget) -> QMenu:
+        """Recheck availability and retain the captured selection for delayed activation."""
+        menu = QMenu(self.window)
+        entries = self.window.selected_entries(file_list)
+        snapshot = self.window.snapshot
+        unstaged = file_list is self.window.unstaged_list
+        enabled = bool(entries) and snapshot is not None and snapshot.fresh and not self.window.busy
+        readable = enabled
+        file_entries = tuple(entry for entry in entries if not entry.is_gitlink)
+        if unstaged:
+            stage_action = menu.addAction(file_action_icon(FileAction.STAGE, menu), FileAction.STAGE.label)
+            stage_action.setEnabled(enabled and self.window.stage_button.isEnabled())
+            stage_action.setToolTip(with_shortcut(FileAction.STAGE.label, STAGE_SHORTCUT))
+            stage_action.triggered.connect(lambda: self._request(FileAction.STAGE, entries, snapshot, file_list))
+        action = menu.addAction(file_action_icon(FileAction.RESET, menu), FileAction.RESET.label)
+        enabled = enabled and not any(entry.conflict_stages for entry in snapshot.entries) and not any(entry.skip_worktree for entry in entries)
+        new_file = snapshot is not None and snapshot.requires_file_confirmation(tuple(entry.path for entry in file_entries))
+        action.setEnabled(enabled and bool(file_entries) and not new_file)
+        action.setToolTip("New files cannot be reset. Use Unstage or Delete file." if new_file else "Reset changes on the selected side")
+        action.triggered.connect(lambda checked=False: self._request(FileAction.RESET, entries, snapshot, file_list))
+        delete_action = menu.addAction(file_action_icon(FileAction.DELETE, menu), FileAction.DELETE.label)
+        delete_action.setEnabled(bool(file_entries) and snapshot is not None and snapshot.fresh and not self.window.busy)
+        delete_action.triggered.connect(lambda checked=False: self._request(FileAction.DELETE, entries, snapshot, file_list))
+        menu.setToolTipsVisible(True)
+        if unstaged:
+            copy_menu = menu.addMenu(FileAction.COPY_PATHS.label)
+            copy_menu.menuAction().setIcon(file_action_icon(FileAction.COPY_PATHS, menu))
+            copy_menu.setEnabled(readable)
+            for copy_file_action in (FileAction.COPY_BASENAME, FileAction.COPY_ABSOLUTE):
+                copy_action = copy_menu.addAction(file_action_icon(copy_file_action, copy_menu), copy_file_action.label)
+                copy_action.setIconVisibleInMenu(True)
+                copy_action.triggered.connect(lambda checked=False, copy_file_action=copy_file_action: self._request(copy_file_action, entries, snapshot, file_list))
+        single_file_reason = SELECT_ONE_FILE_REASON if len(entries) != 1 else ""
+        self._add_consultation(menu, FileAction.FOLDER, single_file_reason, "Open the existing file's folder", readable, entries, snapshot, file_list)
+        text_editor_reason = single_file_reason
+        if not text_editor_reason and self.window.text_editor_reason is not None:
+            text_editor_reason = self.window.text_editor_reason(next(iter(entries)))
+        self._add_consultation(menu, FileAction.TEXT_EDITOR, text_editor_reason, "Open the working copy file in the text editor", readable, entries, snapshot, file_list)
+        history_reason = single_file_reason
+        if not history_reason and (snapshot is None or next(iter(entries)).is_gitlink or local_history_path(snapshot, next(iter(entries))) is None):
+            history_reason = "No file history exists at HEAD for this file"
+        self._add_consultation(menu, FileAction.HISTORY, history_reason, "File history (H)", readable, entries, snapshot, file_list)
+        if unstaged:
+            for destination in IgnoreDestination:
+                ignore_action = menu.addAction(file_action_icon(destination, menu), destination.label)
+                ignore_action.setEnabled(enabled and bool(file_entries))
+                ignore_action.triggered.connect(lambda checked=False, destination=destination: self._request_ignore(destination, entries, snapshot, file_list))
+            stop_action = menu.addAction(file_action_icon(FileAction.STOP_TRACKING, menu), FileAction.STOP_TRACKING.label)
+            tracked = bool(entries) and all(entry.old_mode in ("100644", "100755", "120000") for entry in entries)
+            stop_action.setEnabled(enabled and tracked)
+            stop_action.setToolTip("Keep files on disk and stage removal of their tracking" if tracked else "Select tracked files")
+            stop_action.triggered.connect(lambda: self._request(FileAction.STOP_TRACKING, entries, snapshot, file_list))
+        for action in menu.actions():
+            action.setIconVisibleInMenu(True)
+        return menu
+
+    def _add_consultation(self, menu: QMenu, file_action: FileAction, reason: str, tooltip: str, readable: bool, entries: tuple[LocalEntry, ...],
+                          snapshot: WorktreeSnapshot | None, file_list: QListWidget) -> None:
+        """Add a consultation of the selected file, greyed with its reason when it cannot apply to the selection.
+
+        The Staged list only gets the actions of the read-only set, which never change the index: the session accepts
+        exactly those from it, so the menu never offers one the session would refuse.
+        """
+        if file_list is not self.window.unstaged_list and file_action not in READ_ONLY_FILE_ACTION_SET:
+            return
+        action = menu.addAction(file_action_icon(file_action, menu), file_action.label)
+        action.setEnabled(readable and not reason)
+        action.setToolTip(reason or tooltip)
+        action.triggered.connect(lambda checked=False: self._request(file_action, entries, snapshot, file_list))
+
+    def _fresh_current_read(self, snapshot: WorktreeSnapshot | None) -> WorktreeSnapshot | None:
+        """Answer the window's current read while the window can act and both the menu's read and the current one are fresh, else None.
+
+        Every menu action checks this first, so a busy or closing window, or a read that went stale, never starts one.
+        """
+        current = self.window.snapshot
+        if self.window.busy or self.window.close_requested or snapshot is None or not snapshot.fresh or current is None or not current.fresh:
+            return None
+        return current
+
+    def _selection_is_current(self, entries: tuple[LocalEntry, ...], snapshot: WorktreeSnapshot | None, file_list: QListWidget) -> bool:
+        """Tell whether the menu's read is still the window's fresh current read and the list still selects the same entries.
+
+        Every action that works on the selection as it is now, rather than on captured content, requires both.
+        """
+        current = self._fresh_current_read(snapshot)
+        return not (current is None or current is not snapshot or entries != self.window.selected_entries(file_list))
+
+    def _request(self, file_action: FileAction, entries: tuple[LocalEntry, ...], snapshot: WorktreeSnapshot | None, file_list: QListWidget) -> None:
+        """Keep captured Delete content for service validation and require current selections for other actions."""
+        if file_action == FileAction.DELETE:
+            current = self._fresh_current_read(snapshot)
+            if current is None or current.key != snapshot.key or current.git_filename != snapshot.git_filename:
+                return
+            # Trash validates the original bytes so a refresh cannot replace the user's captured intention.
+            entries = tuple(entry for entry in entries if not entry.is_gitlink)
+            if entries:
+                self.delete_requested.emit(entries, snapshot)
+            return
+        if not self._selection_is_current(entries, snapshot, file_list):
+            return
+        if file_action in (FileAction.RESET, FileAction.HISTORY, FileAction.STOP_TRACKING):
+            entries = tuple(entry for entry in entries if not entry.is_gitlink)
+            if not entries:
+                return
+        if file_action == FileAction.RESET:
+            if snapshot.requires_file_confirmation(tuple(entry.path for entry in entries)):
+                return
+            self.requested.emit(entries)
+        else:
+            self.action_requested.emit(file_action, entries, snapshot)
+
+    def _request_ignore(self, destination: IgnoreDestination, entries: tuple[LocalEntry, ...], snapshot: WorktreeSnapshot | None, file_list: QListWidget) -> None:
+        """Send a rule for the captured selection to its destination, only while the window, the read and the selection are still current.
+
+        Submodules are left out, since an ignore rule cannot apply to them; nothing is sent when no file remains.
+        """
+        if not self._selection_is_current(entries, snapshot, file_list):
+            return
+        entries = tuple(entry for entry in entries if not entry.is_gitlink)
+        if not entries:
+            return
+        self.ignore_requested.emit(entries, snapshot, destination)
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        """Restrict file shortcuts to their source list and suppress keyboard auto-repeat.
+
+        The filter watches only the two file lists, so the trash keys of the system (Delete, plus Backspace and
+        Cmd+Backspace on macOS) never act from a text field, where Backspace erases a character.
+        """
+        if event.type() == QEvent.Type.KeyPress and event.key() == Qt.Key.Key_H and not event.modifiers() and watched is self.window.unstaged_list:
+            if not event.isAutoRepeat():
+                self._request(FileAction.HISTORY, self.window.selected_entries(watched), self.window.snapshot, watched)
+            return True
+        if event.type() == QEvent.Type.KeyPress and trash_key_pressed(event.key(), event.modifiers(), self.platform):
+            snapshot = self.window.snapshot
+            if not event.isAutoRepeat() and not self.window.busy and snapshot is not None and snapshot.fresh:
+                entries = self.window.selected_entries(watched)
+                if entries:
+                    self._request(FileAction.DELETE, entries, snapshot, watched)
+            return True
+        return super().eventFilter(watched, event)
+
+    def confirm_stop_tracking(self, entries: tuple[LocalEntry, ...]) -> bool:
+        """Explain cached removal and preservation of local content before modifying the index."""
+        labels: list[str] = []
+        for entry in entries:
+            labels.append(entry.label)
+        dialog = QMessageBox(QMessageBox.Icon.Warning, FileAction.STOP_TRACKING.label, "Stop tracking:\n" + "\n".join(labels), parent=self.window)
+        prepare_message_box(dialog, FileAction.STOP_TRACKING.label)
+        dialog.setTextFormat(Qt.TextFormat.PlainText)
+        dialog.setInformativeText("Removal from tracking will be staged. All file content stays on disk. No ignore rule is added. Git will refuse if the index contains a unique version; review staged changes before retrying.")
+        show_confirmation_targets(dialog, "Stop tracking:", labels)
+        configure_confirmation(dialog, "Stop tracking selected files", "Cancel tracking change")
+        accepted = dialog.exec() == QMessageBox.StandardButton.Yes
+        dialog.deleteLater()
+        return accepted
+
+    def confirm_trash(self, request: TrashRequest) -> bool:
+        """Name every captured target and explain the difference between Trash and Reset."""
+        labels: list[str] = []
+        for target in request.targets:
+            labels.append(target.path.decode("utf-8", "replace") + (" (tracked)" if target.tracked else " (untracked)"))
+        dialog = QMessageBox(QMessageBox.Icon.Warning, MOVE_TO_TRASH_TITLE, MOVE_TO_TRASH_TITLE + ":\n" + "\n".join(labels), parent=self.window)
+        prepare_message_box(dialog, MOVE_TO_TRASH_TITLE)
+        dialog.setTextFormat(Qt.TextFormat.PlainText)
+        dialog.setInformativeText("Tracked deletions remain Unstaged. Reset restores the index version, not the deleted local edits. The OS Trash owns moved files; a batch cannot be rolled back automatically.")
+        show_confirmation_targets(dialog, MOVE_TO_TRASH_TITLE + ":", labels)
+        configure_confirmation(dialog, "Move files to Trash", "Cancel deletion")
+        accepted = dialog.exec() == QMessageBox.StandardButton.Yes
+        dialog.deleteLater()
+        return accepted
+
+    def _open(self, file_list: QListWidget, position: QPoint) -> None:
+        """Open the captured menu without retargeting another list."""
+        menu = self.create_menu(file_list)
+        menu.exec(file_list.mapToGlobal(position))
+        menu.deleteLater()
+
+    def confirm(self, prepared: ResetCandidate) -> bool:
+        """Explain the chosen side and show the calculated result before publication."""
+        from difflib import unified_diff
+
+        from gitpane.history.revision_file import decode_blob_display
+
+        labels: list[str] = []
+        details: list[str] = []
+        for change in prepared.changes:
+            label = change.path.decode("utf-8", "replace")
+            labels.append(label)
+            before = decode_blob_display("", change.before.read()).display_text
+            after = decode_blob_display("", change.after.read()).display_text
+            result = "File removed" if not change.after.exists else f"Result: {len(change.after.read())} bytes"
+            details.append(label + "\n" + result + "\n" + "".join(unified_diff(before.splitlines(keepends=True), after.splitlines(keepends=True), fromfile="Current", tofile="After Reset")))
+        title = "Reset " + prepared.side.title
+        dialog = QMessageBox(QMessageBox.Icon.Warning, title, "Reset " + prepared.side.label + " changes in:\n" + "\n".join(labels), parent=self.window)
+        prepare_message_box(dialog, title)
+        dialog.setTextFormat(Qt.TextFormat.PlainText)
+        dialog.setInformativeText(prepared.explanation + " Files are replaced before the index; an interrupted operation may require recovery.")
+        dialog.setDetailedText("\n\n".join(details))
+        show_confirmation_targets(dialog, "Reset " + prepared.side.label + " changes in:", labels)
+        configure_confirmation(dialog, "Reset " + prepared.side.label + " changes", "Cancel reset")
+        accepted = dialog.exec() == QMessageBox.StandardButton.Yes
+        dialog.deleteLater()
+        return accepted
+
+
+class StagingActionMenu(QObject):
+    """Offer exactly the two Unstaged actions without changing native text selection."""
+
+    stage_requested = Signal(object)
+    reset_requested = Signal(object)
+
+    def __init__(self, view: DiffView, available: Callable[[], bool]) -> None:
+        """Bind line identity to the displayed patch and ask the controller about freshness."""
+        super().__init__(view)
+        self.view = view
+        self.available = available
+        self.model: RawPatch | None = None
+        self.patch_index_by_line_index: dict[int, int] = {}
+        view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        view.customContextMenuRequested.connect(self._open)
+
+    def bind(self, model: RawPatch | None) -> None:
+        """Associate logical display lines explicitly, refusing incomplete previews."""
+        self.model = None
+        self.patch_index_by_line_index.clear()
+        if model is None:
+            return
+        content = decode_blob_display("", model.patch)
+        if not content.complete or content.content_kind == BlobContentKind.BINARY:
+            return
+        offset = 1 if content.diagnostic else 0
+        for change in model.changes:
+            if change.patch_index is not None and change.kind in (DiffLineKind.ADDED, DiffLineKind.REMOVED):
+                self.patch_index_by_line_index[change.patch_index + offset] = change.patch_index
+        self.model = model
+
+    def selection(self) -> RawLineSelection | None:
+        """Include intersected logical lines, excluding a following line at its start boundary."""
+        cursor = self.view.textCursor()
+        if self.model is None or not self.available() or not cursor.hasSelection():
+            return None
+        start = self.view.source_position(cursor.selectionStart())
+        end = self.view.source_position(cursor.selectionEnd())
+        first_index = self.view.logical_line_index(cursor.selectionStart())
+        last_index = self.view.logical_line_index(cursor.selectionEnd())
+        line_ids: list[int] = []
+        for line_index in range(first_index, last_index + 1):
+            line_start = self.view.source_position(self.view.line_positions[line_index])
+            if line_start >= end:
+                break
+            patch_index = self.patch_index_by_line_index.get(line_index)
+            if patch_index is not None and end > start:
+                line_ids.append(patch_index)
+        if not line_ids:
+            return None
+        return RawLineSelection(self.model.snapshot.key, self.model.snapshot.generation, StagingSide.UNSTAGED, self.model.entry.path, tuple(line_ids))
+
+    def create_menu(self) -> QMenu:
+        """Capture an intention at menu opening so delayed actions cannot retarget a new diff."""
+        if self.model is None:
+            return self.view.createStandardContextMenu()
+        menu = QMenu(self.view)
+        selection = self.selection()
+        for label, signal in (("Stage selected lines", self.stage_requested), ("Reset selected lines", self.reset_requested)):
+            action = menu.addAction(label)
+            action.setEnabled(selection is not None)
+            action.triggered.connect(lambda checked=False, signal=signal, selection=selection: signal.emit(selection))
+        return menu
+
+    def _open(self, position: QPoint) -> None:
+        """Open at the requested position without moving the original text cursor."""
+        menu = self.create_menu()
+        menu.exec(self.view.mapToGlobal(position))
+        menu.deleteLater()