gitpane 1.0.0__py3-none-any.whl

gitpane/ui/setting/credential_manager_dialog.py

@@ -0,0 +1,151 @@
+"""Tell the user which Git credential manager to install when an operation needs one, with its text to copy or its download page to open."""
+
+from __future__ import annotations
+
+import html
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QEvent, QSize, Qt, QUrl, Signal
+from PySide6.QtGui import QDesktopServices
+from PySide6.QtWidgets import QDialog, QHBoxLayout, QLabel, QPushButton, QStyle, QVBoxLayout
+
+from gitpane.config import GCM_RELEASES_URL, GIT_FOR_WINDOWS_DOWNLOAD_URL, HOMEBREW_INSTALL_URL
+from gitpane.ui.widget.content_growth import ContentGrowthMixin, OpeningFit
+from gitpane.ui.widget.content_measure import LayoutContentMeasure
+from gitpane.ui.widget.dialog_layout import MESSAGE_BOX_BODY_MARGINS, MESSAGE_BOX_BUTTON_BAND, MESSAGE_BOX_BUTTON_SIZE, MESSAGE_BOX_ICON_SIDE, MESSAGE_BOX_ICON_TO_TEXT_SPACE, BandButtonSizing, install_banded_layout
+from gitpane.ui.widget.result_label import ResultLabel
+from gitpane.ui.widget.standard_icon_label import StandardIconLabel
+from gitpane.ui.window_control.button_focus import set_button_enabled
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.account.credential_manager import CredentialManagerDetection
+
+CREDENTIAL_MANAGER_DIALOG_TITLE = "Git credential manager required"
+CREDENTIAL_MANAGER_CLOSE_LABEL = "Close"
+CREDENTIAL_MANAGER_CHECK_AGAIN_LABEL = "Check again"
+# Only these constant download or install addresses become links; a path read from the PATH never does, whatever it looks like.
+CREDENTIAL_MANAGER_LINK_URLS = (GCM_RELEASES_URL, GIT_FOR_WINDOWS_DOWNLOAD_URL, HOMEBREW_INSTALL_URL)
+# Rich text merges consecutive spaces and drops leading ones, which would lose the space in front of each bullet.
+INSTALL_TEXT_HTML_TEMPLATE = '<div style="white-space: pre-wrap;">{body}</div>'
+INSTALL_LINE_BREAK_HTML = "<br>"
+
+
+def install_text_html(lines: tuple[str, ...], link_urls: tuple[str, ...]) -> str:
+    """Turn the install lines into rich text that keeps their leading spaces and makes only the known download addresses clickable.
+
+    Every line is escaped first, so a placeholder such as <version> or a path read from the PATH stays literal text and
+    can never become markup or a link.
+    """
+    html_lines: list[str] = []
+    for line in lines:
+        escaped_line = html.escape(line)
+        for url in link_urls:
+            escaped_url = html.escape(url)
+            escaped_line = escaped_line.replace(escaped_url, '<a href="' + html.escape(url, quote=True) + '">' + escaped_url + "</a>")
+        html_lines.append(escaped_line)
+    return INSTALL_TEXT_HTML_TEMPLATE.format(body=INSTALL_LINE_BREAK_HTML.join(html_lines))
+
+
+class CredentialManagerDialog(ContentGrowthMixin, QDialog):
+    """Explain which credential manager to install, as a window modal for the whole application.
+
+    It is shown with show(): QDialog's open method would make it modal for its parent window only, and exec would run a
+    nested event loop. Its text can be selected and copied from the right-click menu; only the known download addresses
+    are clickable. Close, Escape and the title-bar close all close it.
+
+    Check again asks for a new search once the user has installed the credential manager; the window only reports what
+    that search found and never starts the refused operation again, the user does. Check again rewrites the text for the
+    refusal it finds. The window's height follows its answer both ways: a long answer grows it, and the next Check again,
+    which hides the answer, brings it back to the height it had before; a longer install line widens it. Its width only
+    grows: a later refusal whose install line is shorter leaves the window as wide as before, with room to the right of
+    the text.
+
+    ``blocked_by_modal`` is true while a modal window it does not belong to, opened after it, keeps it from taking any
+    click, as Qt reports it to the window.
+    """
+
+    check_again_requested = Signal()
+
+    def __init__(self, lines: tuple[str, ...], detection: CredentialManagerDetection, parent: QWidget | None = None, *,
+                 open_url: Callable[[QUrl], bool] = QDesktopServices.openUrl) -> None:
+        """Build the window for the install ``lines`` of one refusal; ``open_url`` opens a clicked download address."""
+        super().__init__(parent)
+        self.detection = detection
+        self.blocked_by_modal = False
+        self.setWindowTitle(CREDENTIAL_MANAGER_DIALOG_TITLE)
+        self.setWindowFlags(Qt.WindowType.Dialog | Qt.WindowType.CustomizeWindowHint | Qt.WindowType.WindowTitleHint | Qt.WindowType.WindowCloseButtonHint)
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        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)
+        # No word wrap and no fixed width: each install line stays on one line, so a copied command stays whole.
+        self.text_label = QLabel()
+        self.text_label.setTextFormat(Qt.TextFormat.RichText)
+        self.text_label.setText(install_text_html(lines, CREDENTIAL_MANAGER_LINK_URLS))
+        self.text_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.LinksAccessibleByMouse)
+        self.text_label.setOpenExternalLinks(False)
+        self.text_label.linkActivated.connect(lambda url: open_url(QUrl(url)))
+        text_column = QVBoxLayout()
+        text_column.addWidget(self.text_label)
+        # The answer of Check again, under the install text it refers to; hidden while there is none.
+        self.result_label = ResultLabel()
+        self.result_label.hide()
+        text_column.addWidget(self.result_label)
+        message_row.addLayout(text_column, 1)
+        layout.addLayout(message_row)
+        self.check_again_button = QPushButton(CREDENTIAL_MANAGER_CHECK_AGAIN_LABEL)
+        self.check_again_button.setMinimumSize(MESSAGE_BOX_BUTTON_SIZE)
+        self.check_again_button.setAutoDefault(False)
+        # Enter checks again, the natural next step once the user has installed the credential manager; Escape still closes.
+        self.check_again_button.setDefault(True)
+        self.close_button = QPushButton(CREDENTIAL_MANAGER_CLOSE_LABEL)
+        self.close_button.setMinimumSize(MESSAGE_BOX_BUTTON_SIZE)
+        self.close_button.setAutoDefault(False)
+        install_banded_layout(self, layout, [self.check_again_button, self.close_button], MESSAGE_BOX_BUTTON_BAND, MESSAGE_BOX_BODY_MARGINS, button_sizing=BandButtonSizing.WINDOW)
+        self.check_again_button.clicked.connect(self.check_again_requested.emit)
+        self.close_button.clicked.connect(self.reject)
+        # The window has no scroll area: its own layout tells the height its rows need. It opens at the height Qt gives
+        # it at its show, its layout's preferred height; Qt itself widens it to a longer install line, whose label
+        # never wraps, through the layout's minimum width.
+        self.install_content_growth(LayoutContentMeasure(self), OpeningFit.GROW_ONLY, self.sizeHint().height())
+
+    def event(self, event: QEvent) -> bool:
+        """Remember whether Qt currently blocks this window under another modal window, so a new refusal knows whether it can offer it again."""
+        if event.type() == QEvent.Type.WindowBlocked:
+            self.blocked_by_modal = True
+        elif event.type() == QEvent.Type.WindowUnblocked:
+            self.blocked_by_modal = False
+        return super().event(event)
+
+    def show_detection(self, lines: tuple[str, ...], detection: CredentialManagerDetection) -> None:
+        """Show the install text of the refusal a new search found, so the window, and a later short answer of Check again, always refer to the refusal shown.
+
+        A longer install line widens the window; a shorter one leaves its width as it was, since only its height follows
+        its content.
+        """
+        self.detection = detection
+        self.text_label.setText(install_text_html(lines, CREDENTIAL_MANAGER_LINK_URLS))
+
+    def set_checking(self, checking: bool) -> None:
+        """Disable Check again while a search runs, without moving the focus to another control, and clear the previous answer when one starts."""
+        set_button_enabled(self.check_again_button, not checking)
+        if checking:
+            self.result_label.clear()
+            self.result_label.hide()
+
+    def show_check_result(self, text: str) -> None:
+        """Show in red, under the install text, why the new search still found no usable credential manager.
+
+        The window follows the answer both ways through the common growth rule: it grows to show the answer whole, and
+        takes back its height when the next search hides it.
+        """
+        self.result_label.show_failure(text)
+        self.result_label.show()

gitpane/ui/setting/git_setting_widget.py

@@ -0,0 +1,388 @@
+"""Edit scoped Git settings without losing a failed field or the captured repository."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QCheckBox, QComboBox, QGridLayout, QGroupBox, QLabel, QLineEdit, QVBoxLayout, QWidget
+from shiboken6 import isValid
+
+from gitpane.config import SPACING_MD, SPACING_SM, control_height
+from gitpane.git_config.git_setting import AUTOCRLF_DESCRIPTION_BY_VALUE, GIT_SETTING_KEYS, SETTING_LABEL_BY_KEY, GitSettingChange, GitSettingOperation, SettingView
+from gitpane.text.typed_text import typed_value
+from gitpane.transport.push_tracking import PushTrackingChoice
+from gitpane.transport.remote_config import GitConfigScope
+from gitpane.ui.setting.setting_block import GLOBAL_TITLE, REPOSITORY_TITLE, block_group
+from gitpane.ui.widget.result_label import ResultLabel
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from gitpane.git_config.git_setting import GitSettingService, GitSettingSnapshot, GitSettingValue
+    from gitpane.history.repository_value import RepositoryContext
+
+NO_REPOSITORY_GIT_SETTING_TEXT = "Open a repository to change its Git settings."
+# Separates the lines of a save result: the reason a tracking choice was not saved, and the result of each Git field saved with it.
+RESULT_LINE_SEPARATOR = "\n"
+
+
+class GitSettingText(Enum):
+    """Texts of the Git page, one member per text so a misspelt name is an error."""
+
+    PUSH_TRACKING = "Tracking reference on first push"
+    """The title of the list choosing whether a Push links a branch without upstream: ask, always or never."""
+    PUSH_TRACKING_NOTE = "GitPane keeps this choice for this repository; it is not written to the Git configuration."
+    """The sentence under that list, saying where the choice is kept."""
+    PUSH_TRACKING_NOT_SAVED = "The tracking reference choice could not be saved: {cause}"
+    """The status line when the preferences file refused the choice; the list keeps it as a draft."""
+
+
+class GitSettingWidget(QWidget):
+    """Keep one repository's draft separate from shared application preferences."""
+
+    draft_changed = Signal()
+    save_attention = Signal()
+
+    def __init__(self, service: GitSettingService, context: RepositoryContext | None, git_filename: str, parent: QWidget | None = None, *,
+                 push_tracking_choice: PushTrackingChoice = PushTrackingChoice.ASK, save_push_tracking: Callable[[PushTrackingChoice], None] | None = None) -> None:
+        """Build accessible global/local fields and begin a read without saving defaults.
+
+        With a repository and a ``save_push_tracking`` writer, This repository also offers the tracking choice of its
+        first Push, starting on ``push_tracking_choice``; Save hands a changed choice to that writer, which keeps it in the
+        preferences file and never in the Git configuration. Without a writer the list is not built.
+        """
+        super().__init__(parent)
+        self.service = service
+        self.context = context
+        self.git_filename = git_filename
+        self.snapshot: GitSettingSnapshot | None = None
+        self.closed = False
+        self.saving = False
+        self.rendering = False
+        self.read_generation = 0
+        self.editor_by_target: dict[tuple[SettingView, str], QLineEdit | QComboBox] = {}
+        self.override_by_key: dict[str, QCheckBox] = {}
+        self.group_by_view: dict[SettingView, QGroupBox] = {}
+        self.label_by_target: dict[tuple[SettingView, str], QLabel] = {}
+        self.dirty_target_set: set[tuple[SettingView, str]] = set()
+        self.save_push_tracking = save_push_tracking
+        self.push_tracking_combo: QComboBox | None = None
+        self.push_tracking_baseline = push_tracking_choice
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(SPACING_MD)
+        self.status_label = ResultLabel("Reading Git settings…")
+        layout.addWidget(self._label("Commit identity is separate from remote authentication."))
+        views = (SettingView.GLOBAL,) if context is None else (SettingView.GLOBAL, SettingView.LOCAL)
+        for view in views:
+            title = GLOBAL_TITLE if view == SettingView.GLOBAL else REPOSITORY_TITLE
+            group = QGroupBox(title)
+            self.group_by_view[view] = group
+            group_layout = QVBoxLayout(group)
+            group_layout.setContentsMargins(SPACING_MD, SPACING_MD, SPACING_MD, SPACING_MD)
+            group_layout.setSpacing(SPACING_SM)
+            if view == SettingView.LOCAL:
+                group_layout.addWidget(self._label(context.repository_dir))
+                identity_override = QCheckBox("Override with local value for this repo only")
+                identity_override.setAccessibleName("Override commit name and email with local values for this repository only")
+                identity_keys: list[str] = []
+                for key in GIT_SETTING_KEYS:
+                    if key.startswith("user."):
+                        identity_keys.append(key)
+                for key in identity_keys:
+                    self.override_by_key[key] = identity_override
+                identity_override.toggled.connect(lambda _checked, keys=tuple(identity_keys): self._override_changed(keys))
+                group_layout.addWidget(identity_override)
+            else:
+                group_layout.addWidget(self._label("Defaults for all repositories."))
+            field_layout = QGridLayout()
+            field_layout.setHorizontalSpacing(SPACING_MD)
+            field_layout.setVerticalSpacing(SPACING_SM)
+            label_column, editor_column = 0, 1
+            column_count = 2
+            field_layout.setColumnStretch(editor_column, 1)
+            group_layout.addLayout(field_layout)
+            for key in GIT_SETTING_KEYS:
+                target = (view, key)
+                if key == "core.autocrlf":
+                    if view == SettingView.LOCAL:
+                        line_ending_override = QCheckBox("Override line endings for this repo only")
+                        self.override_by_key[key] = line_ending_override
+                        line_ending_override.toggled.connect(lambda _checked, key=key: self._override_changed((key,)))
+                        field_layout.addWidget(line_ending_override, field_layout.rowCount(), label_column, 1, column_count)
+                    editor = QComboBox()
+                    editor.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
+                    editor.addItem("Not set / inherited", None)
+                    for value, description in AUTOCRLF_DESCRIPTION_BY_VALUE.items():
+                        editor.addItem(value + " — " + description, value)
+                    editor.currentIndexChanged.connect(lambda _index, target=target: self._edited(target))
+                else:
+                    editor = QLineEdit()
+                    editor.textChanged.connect(lambda _text, target=target: self._edited(target))
+                editor.setAccessibleName(title + " " + SETTING_LABEL_BY_KEY[key])
+                label = self._label(SETTING_LABEL_BY_KEY[key])
+                label.setBuddy(editor)
+                row = field_layout.rowCount()
+                field_layout.addWidget(label, row, label_column)
+                field_layout.addWidget(editor, row, editor_column)
+                self.editor_by_target[target] = editor
+                detail = self._label("")
+                self.label_by_target[target] = detail
+                field_layout.addWidget(detail, field_layout.rowCount(), editor_column)
+            if view == SettingView.LOCAL and save_push_tracking is not None:
+                self._add_push_tracking_row(field_layout, label_column, editor_column)
+            layout.addWidget(group)
+        if context is None:
+            layout.addWidget(self._no_repository_group())
+        layout.addWidget(self._label("Line endings: .gitattributes still applies. Saving this setting does not rewrite existing files or the index."))
+        layout.addWidget(self.status_label)
+        self.setEnabled(False)
+        self.reload()
+
+    def _add_push_tracking_row(self, field_layout: QGridLayout, label_column: int, editor_column: int) -> None:
+        """Offer Ask, Always add or Never add for this repository's first Push, below its Git fields, with where it is kept."""
+        combo = QComboBox()
+        combo.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
+        for choice in PushTrackingChoice:
+            combo.addItem(choice.label, choice)
+        combo.setCurrentIndex(combo.findData(self.push_tracking_baseline))
+        combo.setAccessibleName(REPOSITORY_TITLE + " " + GitSettingText.PUSH_TRACKING.value)
+        combo.currentIndexChanged.connect(lambda _index: self.draft_changed.emit())
+        label = self._label(GitSettingText.PUSH_TRACKING.value)
+        label.setBuddy(combo)
+        row = field_layout.rowCount()
+        field_layout.addWidget(label, row, label_column)
+        field_layout.addWidget(combo, row, editor_column)
+        field_layout.addWidget(self._label(GitSettingText.PUSH_TRACKING_NOTE.value), field_layout.rowCount(), editor_column)
+        self.push_tracking_combo = combo
+
+    def push_tracking_changed(self) -> bool:
+        """Tell whether the tracking choice shown differs from the one kept for this repository."""
+        return self.push_tracking_combo is not None and self.push_tracking_combo.currentData() != self.push_tracking_baseline
+
+    def _save_push_tracking(self) -> str:
+        """Hand a changed tracking choice to its writer and return why it was not saved, or "" when nothing failed.
+
+        A refused write keeps the choice in the list as a draft, so a second Save tries it again.
+        """
+        if not self.push_tracking_changed():
+            return ""
+        choice = self.push_tracking_combo.currentData()
+        try:
+            self.save_push_tracking(choice)
+        except (OSError, ValueError, TypeError) as error:
+            return GitSettingText.PUSH_TRACKING_NOT_SAVED.value.format(cause=error)
+        self.push_tracking_baseline = choice
+        return ""
+
+    def _show_save_failure(self, tracking_failure: str, text: str) -> None:
+        """Show a failed save on the status line, after the reason the tracking choice was not saved when there is one."""
+        lines = [tracking_failure] if tracking_failure else []
+        if text:
+            lines.append(text)
+        self.status_label.show_failure(RESULT_LINE_SEPARATOR.join(lines))
+        self.save_attention.emit()
+
+    def _no_repository_group(self) -> QGroupBox:
+        """Keep the This repository block in place, greyed and explained, when no repository is open.
+
+        It holds no field, so nothing local is ever read or written without a repository.
+        """
+        group, group_layout = block_group(REPOSITORY_TITLE)
+        self.group_by_view[SettingView.LOCAL] = group
+        group_layout.addWidget(self._label(NO_REPOSITORY_GIT_SETTING_TEXT))
+        group.setEnabled(False)
+        return group
+
+    def _label(self, text: str) -> QLabel:
+        """Keep untrusted origin paths plain and selectable without widening the whole form."""
+        label = QLabel(text)
+        label.setTextFormat(Qt.TextFormat.PlainText)
+        label.setWordWrap(True)
+        label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse | Qt.TextInteractionFlag.TextSelectableByKeyboard)
+        return label
+
+    def reload(self) -> None:
+        """Read asynchronously and ignore completion after the owning dialog closes."""
+        self.read_generation += 1
+        generation = self.read_generation
+        def complete(snapshot: GitSettingSnapshot | None, error: Exception | None) -> None:
+            """Publish only into a live form and retain any existing failed draft."""
+            if self.closed or not isValid(self) or generation != self.read_generation:
+                return
+            if error is not None:
+                self.status_label.show_failure("Git settings could not be read. Check the Git executable and configuration.")
+                return
+            self.snapshot = snapshot
+            self._render()
+            self.setEnabled(True)
+            self.status_label.setText("")
+        self.read_sequence = self.service.read(self.context, self.git_filename, complete, lambda: not self.closed and isValid(self) and generation == self.read_generation)
+
+    def stop_read(self) -> None:
+        """Abandon an opening read without interrupting an already requested save."""
+        self.closed = True
+        self.read_generation += 1
+        self.service.cancel_read(self.read_sequence)
+
+    def _render(self) -> None:
+        """Refresh actual values and origins without replacing unsaved fields."""
+        if self.snapshot is None:
+            return
+        self.rendering = True
+        for override in set(self.override_by_key.values()):
+            keys: list[str] = []
+            for key, control in self.override_by_key.items():
+                if control is override:
+                    keys.append(key)
+            if not any((SettingView.LOCAL, candidate) in self.dirty_target_set for candidate in keys):
+                override.setChecked(any(self.snapshot.value_by_target[(SettingView.DIRECT, candidate)].state != "absent" for candidate in keys))
+        for target, editor in self.editor_by_target.items():
+            view, key = target
+            value = self.snapshot.value_by_target[target]
+            effective = self.snapshot.value_by_target[(SettingView.EFFECTIVE, key)]
+            if target not in self.dirty_target_set:
+                shown = effective if view == SettingView.LOCAL and value.state == "absent" else value
+                if key == "core.autocrlf":
+                    index = editor.findData(shown.value)
+                    if index < 0:
+                        editor.addItem("Existing invalid value: " + shown.value, shown.value)
+                        index = editor.findData(shown.value)
+                    editor.setCurrentIndex(index)
+                else:
+                    editor.setText(shown.value or "")
+            editor.setEnabled(view != SettingView.LOCAL or self.override_by_key[key].isChecked())
+            label = self.label_by_target[target]
+            detail = f"Source: {value.origin or self._display(value)}\nEffective value: {self._display(effective)}"
+            if value.origin and value.state != "present":
+                detail = self._display(value) + "\n" + detail
+            if effective.origin and (effective.origin != value.origin or effective.scope != view.scope):
+                detail += "\nFrom " + effective.scope.value + ": " + effective.origin
+            label.setText(detail)
+            label.setAccessibleName(label.text())
+        self.rendering = False
+        self.refresh_metrics()
+
+    def _display(self, value: GitSettingValue) -> str:
+        """Keep empty, absent and failed reads visibly distinct."""
+        if value.state == "absent":
+            return "Not set"
+        if value.state == "empty":
+            return "Empty value"
+        if value.state == "error":
+            return "Could not read this setting"
+        if value.state == "invalid":
+            return "Invalid value: " + value.value
+        return value.value
+
+    def _edited(self, target: tuple[SettingView, str]) -> None:
+        """Track explicit intent without manufacturing edits during initial rendering."""
+        if self.rendering:
+            return
+        self.dirty_target_set.add(target)
+        view, key = target
+        if view == SettingView.LOCAL:
+            self.editor_by_target[target].setEnabled(self.override_by_key[key].isChecked())
+        self.draft_changed.emit()
+
+    def _override_changed(self, keys: tuple[str, ...]) -> None:
+        """Apply an explicit scope choice while keeping untouched mixed identities intact."""
+        if self.rendering:
+            return
+        for key in keys:
+            self._edited((SettingView.LOCAL, key))
+
+    def changes(self) -> tuple[GitSettingChange, ...]:
+        """Return only explicit edits that differ from the most recently read source.
+
+        A typed value loses the blanks around it first, so a name pasted with a space is written without it and a value
+        changed only by such blanks is no change at all.
+        """
+        changes: list[GitSettingChange] = []
+        if self.snapshot is None:
+            return ()
+        for target, editor in self.editor_by_target.items():
+            if target not in self.dirty_target_set:
+                continue
+            view, key = target
+            direct = self.snapshot.value_by_target[(SettingView.DIRECT, key)] if view == SettingView.LOCAL else self.snapshot.value_by_target[target]
+            if view == SettingView.LOCAL and not self.override_by_key[key].isChecked():
+                if direct.state != "absent":
+                    changes.append(GitSettingChange(key, view.scope, GitSettingOperation.UNSET))
+            else:
+                value = editor.currentData() if key == "core.autocrlf" else typed_value(editor.text())
+                if value is None:
+                    if direct.state != "absent":
+                        changes.append(GitSettingChange(key, view.scope, GitSettingOperation.UNSET))
+                elif value != direct.value:
+                    changes.append(GitSettingChange(key, view.scope, GitSettingOperation.SET, value))
+        return tuple(changes)
+
+    def save(self, callback: Callable[[bool], None]) -> None:
+        """Save fields independently and retain errors beside their actual reread values.
+
+        The tracking choice is written first, to the preferences file; its failure keeps it as a draft and is reported,
+        but the Git fields are still saved, and ``callback`` then receives False.
+        """
+        tracking_failure = self._save_push_tracking()
+        changes = self.changes()
+        if not changes:
+            if tracking_failure:
+                self._show_save_failure(tracking_failure, "")
+            callback(not tracking_failure)
+            return
+        self.saving = True
+        self.setEnabled(False)
+
+        def complete(result: object, error: Exception | None) -> None:
+            """Keep successful fields, preserve failed edits, and avoid touching a closed dialog."""
+            self.saving = False
+            if self.closed or not isValid(self):
+                return
+            self.setEnabled(True)
+            if error is not None:
+                self._show_save_failure(tracking_failure, "Git settings could not be saved. Your draft is retained.")
+                callback(False)
+                return
+            self.snapshot, results = result
+            messages: list[str] = []
+            complete_save = not tracking_failure
+            for outcome in results:
+                change = outcome.change
+                target = (SettingView.for_scope(change.scope), change.key)
+                if outcome.saved:
+                    self.dirty_target_set.discard(target)
+                    messages.append(change.scope.value.title() + " " + change.key + ": Saved")
+                    effective = self.snapshot.value_by_target[(SettingView.EFFECTIVE, change.key)]
+                    if effective.state == "error" or self.snapshot.value_by_target[target].state == "error":
+                        messages.append("Saved, but the effective value could not be reread. Review the configuration before continuing.")
+                        complete_save = False
+                    if ((change.scope == GitConfigScope.LOCAL and change.operation == GitSettingOperation.UNSET and effective.scope in (GitConfigScope.LOCAL, GitConfigScope.WORKTREE))
+                            or (change.operation == GitSettingOperation.SET and effective.value != change.value)):
+                        messages.append("Another origin still overrides this setting. Review the effective value below.")
+                        complete_save = False
+                else:
+                    messages.append(change.scope.value.title() + " " + change.key + ": " + outcome.cause)
+                    complete_save = False
+            self._render()
+            if complete_save:
+                self.status_label.show_success(RESULT_LINE_SEPARATOR.join(messages))
+            else:
+                self._show_save_failure(tracking_failure, RESULT_LINE_SEPARATOR.join(messages))
+            callback(complete_save)
+        try:
+            self.service.save(self.snapshot, changes, complete)
+        except ValueError as error:
+            self.saving = False
+            self.setEnabled(True)
+            self._show_save_failure(tracking_failure, str(error))
+            callback(False)
+
+    def refresh_metrics(self) -> None:
+        """Follow the system font without a separate scaling preference."""
+        for editor in self.editor_by_target.values():
+            editor.setMinimumHeight(control_height(editor.fontMetrics().height()))
+        if self.push_tracking_combo is not None:
+            self.push_tracking_combo.setMinimumHeight(control_height(self.push_tracking_combo.fontMetrics().height()))

gitpane/ui/setting/setting_block.py

@@ -0,0 +1,19 @@
+"""Frame the blocks every Settings page is built from."""
+
+from __future__ import annotations
+
+from PySide6.QtWidgets import QGroupBox, QVBoxLayout
+
+from gitpane.config import SPACING_MD, SPACING_SM
+
+GLOBAL_TITLE = "Global"
+REPOSITORY_TITLE = "This repository"
+
+
+def block_group(title: str) -> tuple[QGroupBox, QVBoxLayout]:
+    """Build one framed block with the spacing used by every Settings block."""
+    group = QGroupBox(title)
+    group_layout = QVBoxLayout(group)
+    group_layout.setContentsMargins(SPACING_MD, SPACING_MD, SPACING_MD, SPACING_MD)
+    group_layout.setSpacing(SPACING_SM)
+    return group, group_layout