gitpane 1.0.0__py3-none-any.whl

gitpane/git_config/git_setting.py

@@ -0,0 +1,441 @@
+"""Give Settings targeted access to Git configuration values, without copying whole config files."""
+
+from __future__ import annotations
+
+import os
+import re
+import uuid
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Self
+
+from PySide6.QtCore import QObject, QTimer, Signal
+
+from gitpane.config import GIT_MUTATION_TIMEOUT_MS
+from gitpane.history.repository_value import RepositoryContext
+from gitpane.operation.repository_operation import OWNED_REPOSITORY_TEXT, OperationAction, OperationIntent, StaleCaptureError
+from gitpane.process.process_runner import LOCAL_WRITE_PROFILE, READ_PROFILE
+from gitpane.transport.remote_config import GitConfigScope, config_scope, parse_config
+from gitpane.worktree.command_sequence import GitCommand, GitCommandError, ReadBatch
+from gitpane.worktree.worktree_snapshot import fingerprint
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator
+
+    from gitpane.process.process_runner import ProcessRunner
+    from gitpane.transport.remote_config import RemoteValue
+    from gitpane.worktree.mutation import MutationService
+
+AUTOCRLF_KEY = "core.autocrlf"
+GIT_SETTING_KEYS = ("user.name", "user.email", AUTOCRLF_KEY)
+SETTING_LABEL_BY_KEY = {"user.name": "Name", "user.email": "Email", AUTOCRLF_KEY: "Line endings"}
+# The scopes Settings writes, in the order it shows them.
+SETTING_SCOPES = (GitConfigScope.GLOBAL, GitConfigScope.LOCAL)
+AUTOCRLF_DESCRIPTION_BY_VALUE = {
+    "true": "Check out Windows-style, commit Unix-style line endings",
+    "input": "Check out as-is, commit Unix-style line endings",
+    "false": "No line-ending conversion by core.autocrlf",
+}
+
+
+class SettingView(Enum):
+    """One reading of a setting that Settings keeps for each key, with the scope whose values it keeps.
+
+    The global and local views keep, from the effective listing, only the values Git attributes to their scope; the
+    direct view is the repository's own file without its includes, and the effective view is the value Git uses.
+    """
+
+    GLOBAL = ("global", GitConfigScope.GLOBAL)
+    LOCAL = ("local", GitConfigScope.LOCAL)
+    DIRECT = ("direct", None)
+    EFFECTIVE = ("effective", None)
+
+    def __new__(cls, value: str, scope: GitConfigScope | None) -> Self:
+        """Keep the view's name as the value and the scope it keeps beside it."""
+        member = object.__new__(cls)
+        member._value_ = value
+        member.scope = scope
+        return member
+
+    @classmethod
+    def for_scope(cls, scope: GitConfigScope) -> SettingView:
+        """Answer the view that shows the values of one scope Settings writes."""
+        for view in cls:
+            if view.scope == scope:
+                return view
+        raise ValueError("No Settings view keeps this Git configuration scope")
+
+
+class GitSettingOperation(Enum):
+    """What one Settings change does to a key: write the value, or remove every value of the key in its scope."""
+
+    SET = "set"
+    UNSET = "unset"
+
+
+REPOSITORY_SETTING_VIEWS = (SettingView.GLOBAL, SettingView.LOCAL, SettingView.DIRECT, SettingView.EFFECTIVE)
+GLOBAL_SETTING_VIEWS = (SettingView.GLOBAL, SettingView.EFFECTIVE)
+SETTING_READ_ACCEPTED_CODES = (0, 1)
+SETTING_FIELD_TERMINATOR = b"\0"
+SETTING_READ_OPTIONS = ("config", "--null", "--show-origin", "--show-scope")
+# The grouped reads search the supported keys only: no unrelated value, secrets included, is ever read, and a missing
+# global file answers "nothing found" instead of failing the way a listing of every global value does.
+SETTING_KEY_PATTERN = "^(" + "|".join(re.escape(key) for key in GIT_SETTING_KEYS) + ")$"
+AUTOCRLF_KEY_PATTERN = "^" + re.escape(AUTOCRLF_KEY) + "$"
+
+
+@dataclass(frozen=True)
+class GitSettingValue:
+    """Distinguish absence, explicit empty values and unreadable configuration."""
+
+    value: str | None = None
+    scope: GitConfigScope | None = None
+    origin: str = ""
+    state: str = "absent"
+    source_fingerprint: str = "absent"
+
+
+@dataclass(frozen=True)
+class GitSettingSnapshot:
+    """Capture direct and resolved values in the repository chosen when settings opened."""
+
+    context: RepositoryContext | None
+    git_filename: str
+    generation: int
+    value_by_target: dict[tuple[SettingView, str], GitSettingValue]
+
+
+@dataclass(frozen=True)
+class GitSettingChange:
+    """Carry one exact explicit edit independently of other save outcomes."""
+
+    key: str
+    scope: GitConfigScope
+    operation: GitSettingOperation
+    value: str = ""
+
+    def validate(self, context: RepositoryContext | None) -> None:
+        """Reject unsupported keys, scopes and operations before any process or write starts.
+
+        Only a member names an operation: the write treats anything that is not SET as a removal, so the text of an
+        operation, or any other value, would erase the user's setting instead of being refused.
+        """
+        if self.key not in GIT_SETTING_KEYS or self.scope not in SETTING_SCOPES or not isinstance(self.operation, GitSettingOperation):
+            raise ValueError("Unsupported Git setting change")
+        if self.scope == GitConfigScope.LOCAL and context is None:
+            raise ValueError("No repository was selected for these settings")
+        if "\0" in self.value:
+            raise ValueError("Git setting values cannot contain NUL characters")
+        if self.key == AUTOCRLF_KEY and self.operation == GitSettingOperation.SET and self.value not in AUTOCRLF_DESCRIPTION_BY_VALUE:
+            raise ValueError("Choose true, input or false for core.autocrlf")
+
+
+@dataclass(frozen=True)
+class GitSettingResult:
+    """Retain one write result even if another key could not be saved."""
+
+    change: GitSettingChange
+    saved: bool
+    cause: str = ""
+
+
+def parse_value(output: bytes) -> GitSettingValue:
+    """Decode Git's NUL scope/origin/value triples, retaining the last effective entry."""
+    if not output:
+        return GitSettingValue()
+    if not output.endswith(b"\0"):
+        raise ValueError("Incomplete Git setting output")
+    fields = iter(output.removesuffix(b"\0").split(b"\0"))
+    result = GitSettingValue()
+    try:
+        for scope in fields:
+            origin, value = next(fields), next(fields)
+            text = value.decode("utf-8", "replace")
+            result = GitSettingValue(text, config_scope(scope.decode("utf-8", "replace")), origin.decode("utf-8", "replace"), "empty" if not text else "present", fingerprint(output))
+    except StopIteration as error:
+        raise ValueError("Incomplete Git setting record") from error
+    return result
+
+
+def classified_setting_value(key: str, value: GitSettingValue) -> GitSettingValue:
+    """Mark a core.autocrlf value the form cannot offer as invalid, keeping what Git answered."""
+    if key == AUTOCRLF_KEY and value.value is not None and value.value not in AUTOCRLF_DESCRIPTION_BY_VALUE:
+        return GitSettingValue(value.value, value.scope, value.origin, "invalid", value.source_fingerprint)
+    return value
+
+
+def setting_value_from_records(values: tuple[RemoteValue, ...], key: str) -> GitSettingValue:
+    """Read one key from listed config records exactly as from Git's own answer for that key alone.
+
+    Only the key's occurrences are kept and written back in the scope, origin and value triples Git prints for that
+    key, so the final value, its origin, an absent or empty value and the fingerprint of the occurrences all come
+    from parse_value; other settings of the listing never enter the fingerprint.
+    """
+    records: list[bytes] = []
+    for value in values:
+        if value.key != key:
+            continue
+        for text in (value.scope.value, value.origin, value.value):
+            records.append(text.encode("utf-8", "surrogateescape") + SETTING_FIELD_TERMINATOR)
+    return classified_setting_value(key, parse_value(b"".join(records)))
+
+
+def count_by_source(values: tuple[RemoteValue, ...]) -> dict[tuple[GitConfigScope, str], int]:
+    """Count occurrences per scope and origin, the identity Git gives each configuration source."""
+    result: dict[tuple[GitConfigScope, str], int] = {}
+    for value in values:
+        source = (value.scope, value.origin)
+        result[source] = result.get(source, 0) + 1
+    return result
+
+
+def converted_occurrences(selected_values: tuple[RemoteValue, ...], raw_values: tuple[RemoteValue, ...],
+                          typed_values: tuple[RemoteValue, ...]) -> tuple[RemoteValue, ...] | None:
+    """Replace a view's raw occurrences of a key by the ones Git converted, matched by scope, origin and position.
+
+    ``raw_values`` and ``typed_values`` list the same effective occurrences from two reads; the selected occurrences
+    come from either the effective listing or the listing of the repository's own file, and always hold every
+    occurrence of their sources, so the k-th selected occurrence of a source is the k-th converted one of that source.
+    Answers None when the reads or the view do not pair one to one, so a converted value never lands on the wrong
+    occurrence.
+    """
+    typed_by_source: dict[tuple[GitConfigScope, str], list[RemoteValue]] = {}
+    for value in typed_values:
+        typed_by_source.setdefault((value.scope, value.origin), []).append(value)
+    typed_count_by_source: dict[tuple[GitConfigScope, str], int] = {}
+    for source, typed in typed_by_source.items():
+        typed_count_by_source[source] = len(typed)
+    if count_by_source(raw_values) != typed_count_by_source:
+        return None
+    for source, count in count_by_source(selected_values).items():
+        if typed_count_by_source.get(source, 0) != count:
+            return None
+    position_by_source: dict[tuple[GitConfigScope, str], int] = {}
+    converted: list[RemoteValue] = []
+    for value in selected_values:
+        source = (value.scope, value.origin)
+        position = position_by_source.get(source, 0)
+        converted.append(typed_by_source[source][position])
+        position_by_source[source] = position + 1
+    return tuple(converted)
+
+
+def key_values(values: tuple[RemoteValue, ...], key: str) -> tuple[RemoteValue, ...]:
+    """Keep the occurrences of one key, in their listed order."""
+    selected: list[RemoteValue] = []
+    for value in values:
+        if value.key == key:
+            selected.append(value)
+    return tuple(selected)
+
+
+class GitSettingService(QObject):
+    """Serialize application config writes while letting Git own its native file locks."""
+
+    changed = Signal(object)
+
+    def __init__(self, runner: ProcessRunner, mutation_service: MutationService, parent: QObject | None = None) -> None:
+        """Share bounded asynchronous command execution and mutation ownership."""
+        super().__init__(parent)
+        self.runner = runner
+        self.mutation_service = mutation_service
+        self.worktree_service = mutation_service.worktree_service
+        self.generation = 0
+
+    def read(self, context: RepositoryContext | None, git_filename: str, callback: Callable, is_current: Callable[[], bool] | None = None) -> Generator:
+        """Read only supported keys, never writing defaults or enabling worktree configuration."""
+        sequence = self.capture(context, git_filename, is_current)
+        self.worktree_service.run(self._command_context(context), git_filename, sequence, callback)
+        return sequence
+
+    def cancel_read(self, sequence: Generator) -> None:
+        """Cancel only this form's read, leaving shared worktree requests and saves alone."""
+        for request_id, continuation in tuple(self.worktree_service.continuation_by_id.items()):
+            current_sequence, *_rest = continuation
+            if current_sequence is sequence:
+                self.runner.cancel(request_id)
+
+    def _command_context(self, context: RepositoryContext | None) -> RepositoryContext:
+        """Use the user's home for global-only reads so a checkout cannot affect includes."""
+        home_dir = os.path.expanduser("~")
+        return context if context is not None else RepositoryContext(None, home_dir, home_dir, True)
+
+    def capture(self, context: RepositoryContext | None, git_filename: str, is_current: Callable[[], bool] | None = None) -> Generator:
+        """Read the global, local, direct and effective views of every supported key with three Git reads.
+
+        One effective search of the supported keys gives the global, local and effective views, one search of the
+        repository's own file gives the direct view, and Git itself converts core.autocrlf with bool-or-str; outside a
+        repository the two global reads suffice. Whatever these reads cannot prove complete, a failed or cut listing, or converted values
+        that cannot be paired with their occurrences, is read again one key and view at a time, so an error stays
+        attached to the value it concerns. Nothing read here is kept for another operation.
+        """
+        if is_current is not None and not is_current():
+            return None
+        in_repository = context is not None
+        # Outside a repository only the global files count, and the commands run from the home directory.
+        global_options = () if in_repository else ("--global",)
+        commands = [GitCommand([*SETTING_READ_OPTIONS, "--includes", *global_options, "--get-regexp", SETTING_KEY_PATTERN], accepted_codes=SETTING_READ_ACCEPTED_CODES, profile=READ_PROFILE),
+                    GitCommand([*SETTING_READ_OPTIONS, "--includes", *global_options, "--type=bool-or-str", "--get-regexp", AUTOCRLF_KEY_PATTERN],
+                               accepted_codes=SETTING_READ_ACCEPTED_CODES, profile=READ_PROFILE)]
+        if in_repository:
+            commands.append(GitCommand([*SETTING_READ_OPTIONS, "--local", "--no-includes", "--get-regexp", SETTING_KEY_PATTERN], accepted_codes=SETTING_READ_ACCEPTED_CODES, profile=READ_PROFILE))
+        try:
+            effective_output, typed_output, *direct_outputs = yield ReadBatch(tuple(commands))
+            effective_values = parse_config(effective_output)
+            typed_values = parse_config(typed_output)
+            direct_values: tuple[RemoteValue, ...] = ()
+            for direct_output in direct_outputs:
+                direct_values = parse_config(direct_output)
+        except (GitCommandError, ValueError):
+            return (yield from self._capture_separately(context, git_filename, is_current))
+        if is_current is not None and not is_current():
+            return None
+        value_by_view: dict[SettingView, tuple[RemoteValue, ...]] = {SettingView.EFFECTIVE: effective_values}
+        for view in SettingView:
+            if view.scope is None:
+                continue
+            scoped_values: list[RemoteValue] = []
+            for value in effective_values:
+                if value.scope == view.scope:
+                    scoped_values.append(value)
+            value_by_view[view] = tuple(scoped_values)
+        if in_repository:
+            value_by_view[SettingView.DIRECT] = direct_values
+        value_by_target: dict[tuple[SettingView, str], GitSettingValue] = {}
+        for key in GIT_SETTING_KEYS:
+            for view in REPOSITORY_SETTING_VIEWS if in_repository else GLOBAL_SETTING_VIEWS:
+                view_values = key_values(value_by_view[view], key)
+                if key == AUTOCRLF_KEY:
+                    converted = converted_occurrences(view_values, key_values(effective_values, key), key_values(typed_values, key))
+                    if converted is None:
+                        # Occurrences Git converted in another read cannot be paired: ask Git for this view alone.
+                        value_by_target[(view, key)] = yield from self._read_view(context, key, view)
+                        continue
+                    view_values = converted
+                value_by_target[(view, key)] = setting_value_from_records(view_values, key)
+        self.generation += 1
+        return GitSettingSnapshot(context, git_filename, self.generation, value_by_target)
+
+    def _capture_separately(self, context: RepositoryContext | None, git_filename: str, is_current: Callable[[], bool] | None = None) -> Generator:
+        """Read each key in each view with its own Git command, so one unreadable source fails only the values it affects."""
+        value_by_target: dict[tuple[SettingView, str], GitSettingValue] = {}
+        for key in GIT_SETTING_KEYS:
+            for view in REPOSITORY_SETTING_VIEWS if context is not None else GLOBAL_SETTING_VIEWS:
+                if is_current is not None and not is_current():
+                    return None
+                value_by_target[(view, key)] = yield from self._read_view(context, key, view)
+        self.generation += 1
+        return GitSettingSnapshot(context, git_filename, self.generation, value_by_target)
+
+    def _read_view(self, context: RepositoryContext | None, key: str, view: SettingView) -> Generator:
+        """Read one key in one view with one Git command, answering an error state rather than raising."""
+        arguments = [*SETTING_READ_OPTIONS, "--get-all"]
+        if view.scope is not None:
+            arguments.extend(["--" + view.scope.value, "--includes"])
+        elif view == SettingView.DIRECT:
+            arguments.extend(["--local", "--no-includes"])
+        else:
+            arguments.append("--includes")
+            if context is None:
+                arguments.append("--global")
+        arguments.append(key)
+        if key == AUTOCRLF_KEY:
+            arguments.insert(len(arguments) - 1, "--type=bool-or-str")
+        try:
+            output = yield GitCommand(arguments, accepted_codes=SETTING_READ_ACCEPTED_CODES, profile=READ_PROFILE)
+            return classified_setting_value(key, parse_value(output))
+        except (GitCommandError, ValueError):
+            # Git stderr may contain arbitrary included configuration; expose only the key's failure.
+            return GitSettingValue(state="error")
+
+    def save(self, snapshot: GitSettingSnapshot, changes: tuple[GitSettingChange, ...], callback: Callable) -> None:
+        """Reserve shared configuration and report successful writes without rolling them back.
+
+        When nothing in the availability checks explains a refusal, a write really holds the worktree or the global
+        configuration (another settings save, an index change), so the refusal names that running operation.
+        """
+        for change in changes:
+            change.validate(snapshot.context)
+        operation_id = uuid.uuid4().hex
+        global_configuration = any(change.scope == GitConfigScope.GLOBAL for change in changes)
+        context = self._command_context(snapshot.context)
+        intent = OperationIntent.capture(operation_id, context, snapshot.git_filename, generation=snapshot.generation,
+                                         global_configuration=global_configuration, action=OperationAction.CONFIG_WRITE)
+        mutation = self.mutation_service
+        legacy_busy = bool(mutation.active_key_set) if global_configuration else intent.key in mutation.active_key_set
+        reason = mutation.repository_operation.availability_diagnostic(intent)
+        if mutation.configuration_busy or legacy_busy or not mutation.repository_operation.reserve(intent):
+            results = tuple(GitSettingResult(change, False, reason or OWNED_REPOSITORY_TEXT) for change in changes)
+            QTimer.singleShot(0, lambda: callback((snapshot, results), None))
+            return
+        if global_configuration:
+            mutation.configuration_busy = True
+
+        def complete(result: object, error: Exception | None) -> None:
+            """Release ownership after all commands finish, including failed or closed views."""
+            if global_configuration:
+                mutation.configuration_busy = False
+            mutation.repository_operation.release(operation_id)
+            callback(result, error)
+
+        self.worktree_service.run(context, snapshot.git_filename, self._save(snapshot, changes, intent), complete, operation_id=operation_id)
+
+    def _save(self, snapshot: GitSettingSnapshot, changes: tuple[GitSettingChange, ...], intent: OperationIntent) -> Generator:
+        """Revalidate targeted values before each write; cross-process writes remain nontransactional.
+
+        Each change reads the configuration again just before its own write, and again after it to report the result.
+        The last of those reads is what the form shows: it is already fresh, so no further read follows it; a save
+        with no change still reads the configuration once. A write refused by the check just before Git starts, for
+        example because GitPane began closing between two changes, gives that check's reason rather than blaming file
+        permissions.
+        """
+        expected_by_target = dict(snapshot.value_by_target)
+        results: list[GitSettingResult] = []
+        latest = None
+        launch_refusal_causes: list[str] = []
+
+        def validate_before_write() -> None:
+            """Recheck the reservation just before Git starts, keeping the reason of a refusal so the result can give it."""
+            try:
+                self.mutation_service.repository_operation.validate(intent)
+            except StaleCaptureError as error:
+                launch_refusal_causes.append(str(error))
+                raise
+
+        for change in changes:
+            current = yield from self.capture(snapshot.context, snapshot.git_filename)
+            latest = current
+            changed = False
+            unreadable = False
+            for target, expected in expected_by_target.items():
+                _view, key = target
+                if key != change.key:
+                    continue
+                actual = current.value_by_target[target]
+                changed |= actual != expected
+                unreadable |= actual.state == "error" or expected.state == "error"
+            if changed or unreadable:
+                results.append(GitSettingResult(change, False, "Configuration changed or could not be read. Review the refreshed values and try Save again."))
+                continue
+            arguments = ["config", "--" + change.scope.value, "--replace-all" if change.operation == GitSettingOperation.SET else "--unset-all", change.key]
+            if change.operation == GitSettingOperation.SET:
+                arguments.append(change.value)
+            launch_refusal_causes.clear()
+            try:
+                yield GitCommand(arguments, accepted_codes=(0,) if change.operation == GitSettingOperation.SET else (0, 5), timeout_ms=GIT_MUTATION_TIMEOUT_MS,
+                                 before_start=validate_before_write, profile=LOCAL_WRITE_PROFILE)
+                results.append(GitSettingResult(change, True))
+            except (GitCommandError, ValueError):
+                cause = next(iter(launch_refusal_causes), "Git could not write this setting. Check file permissions or an existing config lock, then retry.")
+                results.append(GitSettingResult(change, False, cause))
+            refreshed = yield from self.capture(snapshot.context, snapshot.git_filename)
+            latest = refreshed
+            for target, value in refreshed.value_by_target.items():
+                _view, key = target
+                if key == change.key:
+                    expected_by_target[target] = value
+        if latest is None:
+            latest = yield from self.capture(snapshot.context, snapshot.git_filename)
+        if any(result.saved for result in results):
+            self.changed.emit((snapshot.context, tuple(results)))
+        return latest, tuple(results)