gitpane 1.0.0__py3-none-any.whl

gitpane/account/account_choice.py

@@ -0,0 +1,297 @@
+"""Work out the account choice rows of Settings, one per service address.
+
+Nothing here draws a widget; the Settings page and the clone form only display these rows.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from gitpane.account.authentication import GENERIC_PROVIDER, check_repository_url, endpoint_origin, origin_address, provider_for_browser_origin
+from gitpane.transport.clone import FILE_URL_ENDPOINT_KIND, HTTPS_ENDPOINT_KIND, LOCAL_ENDPOINT_KIND, SSH_ENDPOINT_KIND, endpoint_kind
+
+if TYPE_CHECKING:
+    from gitpane.account.authentication import AccountCatalogue, AccountSelection
+    from gitpane.transport.remote_config import RemoteEntry
+
+CHOOSE_DEFAULT_TEXT = "Choose a default account"
+USE_GLOBAL_DEFAULT_TEXT = "Use global default — {label}"
+NONE_CHOSEN_LABEL = "none chosen yet"
+# First entry of a repository's account menu on the Accounts page when no account is connected for that address.
+NO_ACCOUNT_CHOICE_TEXT = "No connected account for {address} — use Add account… above"
+SSH_REMOTE_TEXT = "{remote} uses SSH — accounts do not apply"
+# Texts of the clone form's greyed Account row, which never hides so the form keeps its size. Add account… is on
+# the right of the menu there, so the address without an account is named without pointing above.
+ENTER_URL_FIRST_TEXT = "Enter a repository URL first"
+UNSUPPORTED_URL_TEXT = "Not an HTTPS, SSH or local repository address"
+SSH_URL_TEXT = "SSH URL — accounts do not apply"
+LOCAL_FOLDER_TEXT = "Local folder — accounts do not apply"
+CLONE_NO_ACCOUNT_TEXT = "No connected account for {address}"
+ACCOUNT_TEXT_SEPARATOR = " — "
+SERVICE_TITLE_SEPARATOR = " — "
+GENERIC_ACCOUNT_TEXT = "password or token"
+REMOTE_NAME_SEPARATOR = ", "
+
+
+@dataclass(frozen=True)
+class AccountChoice:
+    """One account offered in a menu: the store namespace saved when it is chosen, and the text shown for it."""
+
+    namespace: str
+    text: str
+
+
+@dataclass(frozen=True)
+class GlobalRow:
+    """One service address of the Global block, its accounts and its saved default when that default is still connected.
+
+    ``title`` is what the row is labelled with: the address, led by the service name the user gave it.
+    """
+
+    origin: str
+    address: str
+    title: str
+    choices: tuple[AccountChoice, ...]
+    default_namespace: str | None
+
+
+@dataclass(frozen=True)
+class RepositoryRow:
+    """One service address used by the repository's remotes, with its menu and the repository's own saved choice.
+
+    ``default_text`` is the first menu entry: the account the Global default gives, the fact that none is chosen yet, or,
+    for an address without any connected account, the only entry of a disabled menu. ``chosen_namespace`` is the
+    repository's explicit account, None when the row follows the default; ``missing_choice`` flags an explicit choice
+    whose account is no longer listed.
+    """
+
+    origin: str
+    address: str
+    title: str
+    choices: tuple[AccountChoice, ...]
+    default_text: str
+    chosen_namespace: str | None
+    missing_choice: bool
+
+
+@dataclass(frozen=True)
+class CloneAccountRow:
+    """What the clone form's Account row shows for the URL it will contact.
+
+    ``origin`` is the HTTPS service address, empty when no account applies (no URL yet, SSH, local folder). ``row`` is
+    the address's menu, None without an address. ``disabled_text`` is the only entry of a greyed menu, empty when the
+    menu offers accounts; ``add_account_enabled`` tells whether Add account… can add one for this address.
+    """
+
+    origin: str
+    row: RepositoryRow | None
+    disabled_text: str
+    add_account_enabled: bool
+
+
+@dataclass(frozen=True)
+class RepositoryAccountView:
+    """What This repository shows for one read of the remotes: the HTTPS address rows and one note per SSH remote."""
+
+    rows: tuple[RepositoryRow, ...]
+    ssh_notes: tuple[str, ...]
+
+
+def account_choices(catalogue: AccountCatalogue, origin: str) -> tuple[AccountChoice, ...]:
+    """List the connected accounts of exactly this service address, whatever their service, sorted by label then account.
+
+    A label shared by two accounts of the address gets the account name added, so the two menu entries stay distinct; a
+    username + password account gets its kind added instead, since its account name is that same username.
+    """
+    accounts = []
+    for selection in catalogue.accounts:
+        if selection.origin == origin:
+            accounts.append(selection)
+    accounts.sort(key=lambda selection: (selection.label.casefold(), selection.account, selection.provider))
+    label_count_by_label: dict[str, int] = {}
+    for selection in accounts:
+        label_count_by_label[selection.label] = label_count_by_label.get(selection.label, 0) + 1
+    choices = []
+    for selection in accounts:
+        text = selection.label
+        if label_count_by_label[selection.label] > 1:
+            text = selection.label + ACCOUNT_TEXT_SEPARATOR + (GENERIC_ACCOUNT_TEXT if selection.provider == GENERIC_PROVIDER else selection.account)
+        choices.append(AccountChoice(selection.namespace, text))
+    return tuple(choices)
+
+
+def service_text(catalogue: AccountCatalogue, selection: AccountSelection) -> str:
+    """Name the service of an account as the Service column shows it.
+
+    The name the user gave the address wins; otherwise a service account shows its provider, and a username + password
+    account shows the provider of a well-known address (github.com, gitlab.com, bitbucket.org) or else the address itself.
+    """
+    service_name = catalogue.service_name_by_origin.get(selection.origin)
+    if service_name:
+        return service_name
+    if selection.provider != GENERIC_PROVIDER:
+        return selection.provider
+    provider = provider_for_browser_origin(selection.origin)
+    if provider is not None:
+        return provider
+    return origin_address(selection.origin)
+
+
+def address_title(catalogue: AccountCatalogue, origin: str) -> str:
+    """Title a service address with the name the user gave it, so a self-hosted server is recognised by name; without one, the address alone."""
+    address = origin_address(origin)
+    service_name = catalogue.service_name_by_origin.get(origin)
+    if not service_name:
+        return address
+    return service_name + SERVICE_TITLE_SEPARATOR + address
+
+
+def address_sort_key(origin: str) -> tuple[str, str]:
+    """Order service addresses as the user reads them, ignoring case, with the exact origin to break ties."""
+    return origin_address(origin).casefold(), origin
+
+
+def global_rows(catalogue: AccountCatalogue) -> tuple[GlobalRow, ...]:
+    """Give one Global row per service address that has at least one connected account, in address order.
+
+    A saved default that names an account no longer listed is shown as no default at all: the row asks the user to
+    choose one instead of failing.
+    """
+    origin_set = set()
+    for selection in catalogue.accounts:
+        origin_set.add(selection.origin)
+    rows = []
+    for origin in sorted(origin_set, key=address_sort_key):
+        choices = account_choices(catalogue, origin)
+        default_namespace = catalogue.default_namespace_by_origin.get(origin)
+        if not offers_account(choices, default_namespace):
+            default_namespace = None
+        rows.append(GlobalRow(origin, origin_address(origin), address_title(catalogue, origin), choices, default_namespace))
+    return tuple(rows)
+
+
+def offers_account(choices: tuple[AccountChoice, ...], namespace: str | None) -> bool:
+    """Tell whether this namespace is one of the offered accounts, so a stale default or draft is never shown as chosen."""
+    for choice in choices:
+        if choice.namespace == namespace:
+            return True
+    return False
+
+
+def remote_sort_key(name: str) -> tuple[str, str]:
+    """Order remote names as the user reads them, ignoring case, with the exact name to break ties."""
+    return name.casefold(), name
+
+
+def repository_row(catalogue: AccountCatalogue, origin: str, remote_names: tuple[str, ...]) -> RepositoryRow:
+    """Describe one address of the repository: its title with the remotes using it, its menu and the repository's saved choice.
+
+    Nothing raises for an explicit choice or a default naming an account no longer listed: the row simply shows it.
+    """
+    address = origin_address(origin)
+    title = address_title(catalogue, origin)
+    if remote_names:
+        title += " (" + REMOTE_NAME_SEPARATOR.join(remote_names) + ")"
+    choices = account_choices(catalogue, origin)
+    default_namespace = catalogue.default_namespace_by_origin.get(origin)
+    default_label = NONE_CHOSEN_LABEL
+    for choice in choices:
+        if choice.namespace == default_namespace:
+            default_label = choice.text
+    default_text = USE_GLOBAL_DEFAULT_TEXT.format(label=default_label) if choices else NO_ACCOUNT_CHOICE_TEXT.format(address=address)
+    explicit_namespace = catalogue.repository_namespace_by_origin.get(origin)
+    missing_choice = explicit_namespace is not None and not offers_account(choices, explicit_namespace)
+    chosen_namespace = None if missing_choice else explicit_namespace
+    return RepositoryRow(origin, address, title, choices, default_text, chosen_namespace, missing_choice)
+
+
+def refused_url_account_row(endpoint: str) -> CloneAccountRow:
+    """Grey the clone form's Account row for a URL no clone accepts, telling an empty field apart from refused text."""
+    if not endpoint:
+        return CloneAccountRow("", None, ENTER_URL_FIRST_TEXT, False)
+    return CloneAccountRow("", None, UNSUPPORTED_URL_TEXT, False)
+
+
+def clone_account_row(catalogue: AccountCatalogue, url: str) -> CloneAccountRow:
+    """Describe the clone form's Account row for a typed URL, a local folder or nothing yet.
+
+    Only an HTTPS address has accounts; the new repository then starts from the address's global default, and the menu
+    is greyed with the address named when no account is connected for it. A file:// URL names a local repository just
+    like a folder path, so it says that accounts do not apply. An empty field asks for a URL, while typed text that no
+    clone accepts (plain HTTP, git://, a password or query in the URL) says so instead of asking for one again.
+    """
+    endpoint = url.strip()
+    try:
+        kind = endpoint_kind(endpoint, allow_local=True)
+    except ValueError:
+        return refused_url_account_row(endpoint)
+    if kind == SSH_ENDPOINT_KIND:
+        return CloneAccountRow("", None, SSH_URL_TEXT, False)
+    if kind in (LOCAL_ENDPOINT_KIND, FILE_URL_ENDPOINT_KIND):
+        return CloneAccountRow("", None, LOCAL_FOLDER_TEXT, False)
+    try:
+        origin = endpoint_origin(endpoint)
+    except ValueError:
+        return refused_url_account_row(endpoint)
+    row = repository_row(catalogue, origin, ())
+    if not row.choices:
+        return CloneAccountRow(origin, row, CLONE_NO_ACCOUNT_TEXT.format(address=row.address), True)
+    return CloneAccountRow(origin, row, "", True)
+
+
+def repository_account_view(catalogue: AccountCatalogue, remote_entries: tuple[RemoteEntry, ...]) -> RepositoryAccountView:
+    """Group the effective fetch and push URLs of the remotes by HTTPS service address and note every SSH remote.
+
+    A local path, a plain HTTP URL or anything Git transport would refuse gives no row: no account applies to it. Remotes
+    Git itself ignores are left out too, since they are never contacted.
+    """
+    remote_name_set_by_origin: dict[str, set[str]] = {}
+    ssh_notes = []
+    sorted_entries = sorted(remote_entries, key=lambda entry: remote_sort_key(entry.name))
+    for entry in sorted_entries:
+        if not entry.active:
+            continue
+        uses_ssh = False
+        for url in entry.fetch_urls + entry.push_urls:
+            try:
+                kind = endpoint_kind(url)
+                if kind == HTTPS_ENDPOINT_KIND:
+                    remote_name_set_by_origin.setdefault(endpoint_origin(url), set()).add(entry.name)
+            except ValueError:
+                continue
+            if kind == SSH_ENDPOINT_KIND:
+                uses_ssh = True
+        if uses_ssh:
+            ssh_notes.append(SSH_REMOTE_TEXT.format(remote=entry.name))
+    rows = []
+    for origin in sorted(remote_name_set_by_origin, key=address_sort_key):
+        remote_names = tuple(sorted(remote_name_set_by_origin[origin], key=remote_sort_key))
+        rows.append(repository_row(catalogue, origin, remote_names))
+    return RepositoryAccountView(tuple(rows), tuple(ssh_notes))
+
+
+def check_url_by_origin(remote_entries: tuple[RemoteEntry, ...]) -> dict[str, str]:
+    """Pick, for each HTTPS service address of the remotes, one repository URL on which a new account can be tested without asking for it.
+
+    The pick does not depend on the order Git lists the remotes in: remotes are taken by name, and within one remote
+    its fetch URLs come before its push URLs. The first usable URL of an address wins. Its credentials part is dropped,
+    so a username or token written in a remote URL is never shown or sent. Remotes Git ignores, SSH remotes and URLs
+    that could not be used for the test (no repository path, a password, a query) are skipped.
+    """
+    url_by_origin: dict[str, str] = {}
+    sorted_entries = sorted(remote_entries, key=lambda entry: remote_sort_key(entry.name))
+    for entry in sorted_entries:
+        if not entry.active:
+            continue
+        for url in entry.fetch_urls + entry.push_urls:
+            try:
+                if endpoint_kind(url) != HTTPS_ENDPOINT_KIND:
+                    continue
+                origin = endpoint_origin(url)
+                repository_url = check_repository_url(url, origin)
+            except ValueError:
+                continue
+            if origin not in url_by_origin:
+                url_by_origin[origin] = repository_url
+    return url_by_origin

gitpane/account/address_owner.py

@@ -0,0 +1,67 @@
+"""Find the one connected account whose name is the owner written in a repository address.
+
+Hosting services put the owner of a repository first in its path (``https://github.com/<owner>/<repository>.git``). When
+the branches of such an address cannot be read with the account in use, the account named like that owner is the one
+most likely to see them. Nothing here reads a store or draws a widget: the clone form hands the listed accounts and the
+typed address, and decides itself whether to switch.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from urllib.parse import unquote, urlsplit
+
+from gitpane.account.authentication import endpoint_origin
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from gitpane.account.authentication import AccountSelection
+
+# An address needs an owner segment and a repository segment after it; a single segment names no owner.
+OWNER_ADDRESS_MINIMUM_SEGMENT_COUNT = 2
+OWNER_SEGMENT_INDEX = 0
+PATH_SEPARATOR = "/"
+
+
+def address_owner(url: str) -> str:
+    """Return the owner written first in the path of an HTTPS repository address, decoded from its ``%xx`` escapes.
+
+    Only an address an account could be used for has an owner: an SSH address, a local folder, a ``file://`` URL or any
+    address the accounts refuse give an empty text, and so does an address with fewer than two path segments, since a
+    lone segment is the repository itself, not its owner.
+    """
+    try:
+        endpoint_origin(url)
+        path = urlsplit(url).path
+    except ValueError:
+        return ""
+    segments = []
+    for segment in path.split(PATH_SEPARATOR):
+        if segment:
+            segments.append(segment)
+    if len(segments) < OWNER_ADDRESS_MINIMUM_SEGMENT_COUNT:
+        return ""
+    return unquote(segments[OWNER_SEGMENT_INDEX])
+
+
+def owner_account_namespace(accounts: Sequence[AccountSelection], url: str) -> str | None:
+    """Return the namespace of the only listed account of this address's service whose name is the address's owner, else None.
+
+    The name compared is the one the account menu shows (``label``), without regard to case, since hosting services
+    compare their user names that way. Only accounts of the same service address (scheme, host and port) are
+    candidates, so a token is never offered to another server than its own. Two matching accounts leave no safe choice,
+    so None is returned then, as when none matches or the address names no owner.
+    """
+    owner = address_owner(url)
+    if not owner:
+        return None
+    origin = endpoint_origin(url)
+    folded_owner = owner.casefold()
+    matching_namespace_set = set()
+    for selection in accounts:
+        if selection.origin == origin and selection.label.casefold() == folded_owner:
+            matching_namespace_set.add(selection.namespace)
+    if len(matching_namespace_set) != 1:
+        return None
+    return next(iter(matching_namespace_set))