git-ftp 2.0.0.dev0__py3-none-any.whl

gitftp/__main__.py

@@ -0,0 +1,7 @@
+"""Allow ``python -m gitftp``."""
+
+import sys
+
+from gitftp.cli import main
+
+sys.exit(main())

gitftp/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.0.0.dev0'
+__version_tuple__ = version_tuple = (2, 0, 0, 'dev0')
+
+__commit_id__ = commit_id = None

gitftp/auth.py

@@ -0,0 +1,209 @@
+"""Credential resolution.
+
+Precedence (first hit wins):
+
+user:     -u flag (bare -u => the local user) > URL userinfo > $GIT_FTP_USER > git-ftp.user
+password: -p > -P prompt > URL userinfo > password-command > keychain > $GIT_FTP_PASSWORD
+          > git-ftp.password (present-but-empty counts) > none
+netrc:    consulted only when no user and no password were found at all.
+"""
+
+from __future__ import annotations
+
+import getpass
+import netrc
+import os
+import re
+import subprocess
+import sys
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from gitftp.config import Config
+from gitftp.errors import MissingArgumentError
+from gitftp.output import Output
+from gitftp.url import RemoteURL
+
+
+@dataclass
+class AuthFlags:
+    user: str | None = None  # None = not given; "" = bare -u
+    password: str | None = None
+    ask_password: bool = False
+    password_command: str | None = None
+    keychain: str | None = None  # None = not given; "" = bare -k
+    key: str | None = None
+    pubkey: str | None = None
+    key_passphrase: str | None = None
+
+
+@dataclass
+class Credentials:
+    user: str = ""
+    password: str | None = None
+    key: str | None = None
+    pubkey: str | None = None
+    key_passphrase: str | None = None
+
+
+def local_user(env: Mapping[str, str]) -> str:
+    for var in ("USER", "USERNAME", "LOGNAME"):
+        if env.get(var):
+            return env[var]
+    try:
+        return getpass.getuser()
+    except Exception:
+        return ""
+
+
+def run_password_command(command: str, out: Output) -> str:
+    """Run ``command`` through the shell; the first line of stdout is the password."""
+    out.debug("Running password command.")
+    if sys.platform == "win32":
+        argv: list[str] = ["cmd.exe", "/c", command]
+    else:
+        argv = ["/bin/sh", "-c", command]
+    try:
+        proc = subprocess.run(argv, stdout=subprocess.PIPE, stdin=subprocess.DEVNULL, check=False)
+    except OSError as e:
+        raise MissingArgumentError(f"Password command failed: {e}") from e
+    if proc.returncode != 0:
+        raise MissingArgumentError(f"Password command failed with exit code {proc.returncode}.")
+    text = proc.stdout.decode("utf-8", "surrogateescape")
+    return text.split("\n", 1)[0].rstrip("\r")
+
+
+def keychain_lookup(account: str, host: str, out: Output) -> str | None:
+    """macOS ``security find-internet-password``; None when not found."""
+    argv = ["security", "find-internet-password", "-g", "-a", account]
+    if host:
+        argv += ["-s", host]
+    try:
+        proc = subprocess.run(argv, capture_output=True, check=False)
+    except OSError:
+        return None
+    err = proc.stderr.decode("utf-8", "replace")
+    if proc.returncode != 0 or "could not be found" in err:
+        return None
+    m = re.search(r'^password: (?:0x([0-9A-Fa-f]+)\s+)?"(.*)"$', err, re.MULTILINE)
+    if not m:
+        return None
+    if m.group(1):
+        return bytes.fromhex(m.group(1)).decode("utf-8", "replace")
+    return m.group(2)
+
+
+def netrc_lookup(hostname: str, env: Mapping[str, str]) -> tuple[str, str | None] | None:
+    if env.get("NETRC"):
+        candidates = [Path(env["NETRC"])]
+    else:
+        home = Path(env.get("HOME") or Path.home())
+        candidates = [home / ".netrc", home / "_netrc"]
+    for path in candidates:
+        if not path.is_file():
+            continue
+        try:
+            rc = netrc.netrc(str(path))
+        except (netrc.NetrcParseError, OSError):
+            continue
+        entry = rc.authenticators(hostname)
+        if entry is None:
+            for name, auth in rc.hosts.items():
+                if name.lower() == hostname.lower():
+                    entry = auth
+                    break
+        if entry is None and "default" in rc.hosts:
+            entry = rc.hosts["default"]
+        if entry is not None:
+            login, _account, password = entry
+            return login or "", password or None
+    return None
+
+
+def expand_path(p: str | None) -> str | None:
+    if not p:
+        return None
+    return os.path.expanduser(p)
+
+
+def resolve(
+    cfg: Config,
+    url: RemoteURL,
+    flags: AuthFlags,
+    out: Output,
+    *,
+    env: Mapping[str, str] | None = None,
+) -> Credentials:
+    env = os.environ if env is None else env
+
+    # -- user ----------------------------------------------------------------
+    if flags.user is not None:
+        user = flags.user or local_user(env)
+    elif url.user is not None:
+        user = url.user
+    elif env.get("GIT_FTP_USER"):
+        user = env["GIT_FTP_USER"]
+    else:
+        user = cfg.get("user", "")
+
+    # -- password ------------------------------------------------------------
+    password: str | None
+    if flags.password is not None:
+        password = flags.password
+    elif flags.ask_password:
+        password = out.prompt_secret("Password: ")
+    elif url.password is not None:
+        password = url.password
+    else:
+        password = None
+        command = flags.password_command or cfg.get("password-command")
+        keychain_spec = flags.keychain if flags.keychain is not None else cfg.lookup("keychain")
+        if command:
+            password = run_password_command(command, out)
+        elif keychain_spec is not None:
+            if sys.platform != "darwin":
+                out.debug("Ignoring -k on non-Darwin systems.")
+            else:
+                account, host = user, url.hostname
+                if "@" in keychain_spec:
+                    a, _, h = keychain_spec.partition("@")
+                    account = a or account
+                    host = h or host
+                elif keychain_spec:
+                    account = keychain_spec
+                if not account:
+                    raise MissingArgumentError("Missing keychain account.")
+                found = keychain_lookup(account, host, out)
+                if found is None:
+                    raise MissingArgumentError(
+                        f"Password not found in keychain for account '{account} @ {host}'."
+                    )
+                password = found
+        if password is None:
+            if env.get("GIT_FTP_PASSWORD"):
+                password = env["GIT_FTP_PASSWORD"]
+            else:
+                password = cfg.lookup("password")
+
+    # -- netrc ---------------------------------------------------------------
+    if user == "" and password is None:
+        entry = netrc_lookup(url.hostname, env)
+        if entry is not None:
+            out.debug("Using credentials from netrc.")
+            user, password = entry
+
+    # -- ssh keys ------------------------------------------------------------
+    key = expand_path(flags.key or cfg.get("key"))
+    pubkey = expand_path(flags.pubkey or cfg.get("pubkey"))
+    if key and not pubkey and os.access(f"{key}.pub", os.R_OK):
+        pubkey = f"{key}.pub"
+    passphrase = (
+        flags.key_passphrase if flags.key_passphrase is not None else cfg.lookup("key-passphrase")
+    )
+
+    out.add_secret(password)
+    out.add_secret(passphrase)
+    return Credentials(
+        user=user, password=password, key=key, pubkey=pubkey, key_passphrase=passphrase
+    )

gitftp/changeset.py

@@ -0,0 +1,86 @@
+"""Compute what to upload and delete, in upstream's order.
+
+1. all tracked files (init, --all) or ``git diff`` against the deployed commit
+2. ``.git-ftp-include`` rules (may add uploads and deletes)
+3. ``.git-ftp-ignore`` patterns (remove from both lists)
+4. sort, deduplicate
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from gitftp import ignore as ignoremod
+from gitftp import include as includemod
+from gitftp.gitrepo import GitRepo, UnknownCommit
+from gitftp.output import Output
+
+__all__ = ["ChangeSet", "UnknownCommit", "build"]
+
+
+@dataclass
+class ChangeSet:
+    uploads: list[str] = field(default_factory=list)
+    deletes: list[str] = field(default_factory=list)
+    submodules: set[str] = field(default_factory=set)
+
+    def is_empty(self) -> bool:
+        return not self.uploads and not self.deletes
+
+    def total(self) -> int:
+        return len(self.uploads) + len(self.deletes)
+
+    def hook_status(self) -> bytes:
+        """NUL-separated ``A <path>`` / ``D <path>`` lines for the pre-push hook."""
+        parts = [f"A {p}".encode("utf-8", "surrogateescape") for p in self.uploads]
+        parts += [f"D {p}".encode("utf-8", "surrogateescape") for p in self.deletes]
+        return b"".join(p + b"\0" for p in parts)
+
+
+def remote_path(git_path: str, syncroot: str) -> str:
+    """Strip the syncroot prefix (a plain prefix, not a glob as upstream did)."""
+    if syncroot and git_path.startswith(syncroot):
+        return git_path[len(syncroot) :]
+    return git_path
+
+
+def _sorted_unique(items: list[str]) -> list[str]:
+    return sorted(set(items), key=lambda s: s.encode("utf-8", "surrogateescape"))
+
+
+def build(
+    repo: GitRepo,
+    syncroot: str,
+    deployed_sha: str | None,
+    take_all: bool,
+    out: Output,
+) -> ChangeSet:
+    """Raises :class:`UnknownCommit` when ``deployed_sha`` is unknown to git."""
+    if take_all or not deployed_sha:
+        uploads = repo.ls_files(syncroot)
+        deletes: list[str] = []
+        against = repo.empty_tree()
+    else:
+        uploads = repo.diff_names(deployed_sha, "AMT", syncroot)
+        deletes = repo.diff_names(deployed_sha, "D", syncroot)
+        against = deployed_sha
+
+    rules = includemod.load_rules(repo.root)
+    if rules:
+        inc_up, inc_del = includemod.expand(rules, repo, syncroot, against, out)
+        uploads += inc_up
+        deletes += inc_del
+
+    ignore = ignoremod.IgnoreRules.load(repo.root)
+    if len(ignore):
+        uploads = ignore.filter(uploads)
+        deletes = ignore.filter(deletes)
+
+    subs = repo.submodules(syncroot)
+    # Uninitialised submodules are gitlinks without a working tree: nothing to upload.
+    uninitialised = {p for p, ok in subs.items() if not ok}
+    uploads = [p for p in uploads if p not in uninitialised]
+    uploads = _sorted_unique(uploads)
+    deletes = _sorted_unique(deletes)
+    submodules = {p for p, ok in subs.items() if ok and p in set(uploads)}
+    return ChangeSet(uploads=uploads, deletes=deletes, submodules=submodules)

gitftp/cli/__init__.py

@@ -0,0 +1,111 @@
+"""Command-line entry point: argv normalisation and exit-code mapping."""
+
+from __future__ import annotations
+
+import sys
+import traceback
+
+import click
+
+from gitftp.cli.group import ACTIONS, build_group
+from gitftp.cli.options import OPTIONAL_VALUE_OPTIONS, VALUE_OPTIONS, long_name
+from gitftp.errors import Aborted, ExitCode, GitFtpError, MissingArgumentError
+from gitftp.output import Level, Output
+
+USAGE = "git-ftp <action> [<options>] [<url>]"
+_PASSTHROUGH = {"-h", "--help", "--version"}
+
+
+def level_from_argv(argv: list[str]) -> Level:
+    level = Level.NORMAL
+    for tok in argv:
+        if tok in ("-n", "--silent"):
+            return Level.SILENT
+        if tok == "--verbose" or (tok.startswith("-v") and set(tok[1:]) == {"v"}):
+            count = 1 if tok == "--verbose" else len(tok) - 1
+            level = Level.TRACE if count >= 2 or level == Level.VERBOSE else Level.VERBOSE
+    return level
+
+
+def normalize_argv(argv: list[str]) -> list[str] | None:
+    """Move the action to the front and make bare optional-value options explicit.
+
+    Returns ``None`` when there is nothing to run (bare ``git-ftp``).
+    """
+    action: str | None = None
+    rest: list[str] = []
+    i = 0
+    n = len(argv)
+    while i < n:
+        tok = argv[i]
+        if tok == "--":
+            rest.extend(argv[i:])
+            break
+        if action is None and tok in ACTIONS:
+            action = tok
+            i += 1
+            continue
+        if tok in OPTIONAL_VALUE_OPTIONS:
+            nxt = argv[i + 1] if i + 1 < n else None
+            if nxt is None or nxt.startswith("-") or (action is None and nxt in ACTIONS):
+                rest.append(f"{long_name(tok)}=")
+                i += 1
+                continue
+            rest.extend([tok, nxt])
+            i += 2
+            continue
+        if tok in VALUE_OPTIONS:
+            rest.extend(argv[i : i + 2])
+            i += 2
+            continue
+        rest.append(tok)
+        i += 1
+    if action is None:
+        if not argv:
+            return None
+        if any(tok in _PASSTHROUGH for tok in argv):
+            return rest
+        raise MissingArgumentError("Action unknown.")
+    return [action, *rest]
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    out = Output(level_from_argv(args))
+    try:
+        normalized = normalize_argv(args)
+        if normalized is None:
+            out.raw(USAGE)
+            return int(ExitCode.USAGE)
+        build_group().main(args=normalized, prog_name="git-ftp", standalone_mode=False, obj=out)
+    except click.exceptions.Exit as e:
+        return int(e.exit_code)
+    except (
+        click.NoSuchOption,
+        click.BadOptionUsage,
+        click.MissingParameter,
+        click.BadParameter,
+    ) as e:
+        out.fatal(e.format_message())
+        return int(ExitCode.MISSING_ARGUMENTS)
+    except click.UsageError as e:
+        out.fatal(e.format_message())
+        return int(ExitCode.USAGE)
+    except click.Abort:
+        out.fatal("Interrupted.")
+        return int(ExitCode.INTERRUPTED)
+    except Aborted:
+        return int(ExitCode.OK)
+    except GitFtpError as e:
+        if e.message:
+            out.fatal(e.message)
+        return int(e.code)
+    except KeyboardInterrupt:
+        out.fatal("Interrupted.")
+        return int(ExitCode.INTERRUPTED)
+    except Exception as e:
+        out.fatal(f"Unexpected error: {e}")
+        if out.tracing:
+            out.trace(traceback.format_exc())
+        return int(ExitCode.UNKNOWN)
+    return int(ExitCode.OK)

gitftp/cli/cmd_add_scope.py

@@ -0,0 +1,23 @@
+"""The ``add-scope`` action."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+
+from gitftp import config
+from gitftp.cli.options import common_options, prepare
+from gitftp.gitrepo import GitRepo
+
+
+@click.command("add-scope", short_help="Store a URL (with credentials) under a scope name.")
+@common_options
+@click.argument("scope_name", metavar="SCOPE")
+@click.argument("url", metavar="URL")
+@click.pass_context
+def command(ctx: click.Context, /, scope_name: str, url: str, **kw: Any) -> None:
+    _opts, _out = prepare(ctx, kw)
+    repo = GitRepo.discover(Path.cwd())
+    config.add_scope(repo, scope_name, url)

gitftp/cli/cmd_catchup.py

@@ -0,0 +1,19 @@
+"""The catchup action."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp import deploy
+from gitftp.cli.options import common_options, session_for, url_argument
+
+
+@click.command("catchup", short_help="Record the current commit as deployed without uploading.")
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    opts, session = session_for(ctx, url, kw)
+    deploy.run(deploy.Action.CATCHUP, session, deploy.DeployOptions.from_cli(opts))

gitftp/cli/cmd_download.py

@@ -0,0 +1,19 @@
+"""The ``download`` action (native mirror, no lftp)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp import mirror
+from gitftp.cli.options import common_options, session_for, url_argument
+
+
+@click.command("download", short_help="Download the remote files into the working tree.")
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    opts, session = session_for(ctx, url, kw)
+    mirror.run_download(session, mirror.MirrorOptions.from_cli(opts))

gitftp/cli/cmd_help.py

@@ -0,0 +1,30 @@
+"""The ``help`` action."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp.cli.options import common_options
+
+
+@click.command("help", short_help="Show this help.")
+@common_options
+@click.pass_context
+def command(ctx: click.Context, /, **_kw: Any) -> None:
+    root = ctx.find_root()
+    click.echo(root.get_help())
+    click.echo()
+    for name in root.command.list_commands(root) if isinstance(root.command, click.Group) else []:
+        cmd = (
+            root.command.get_command(root, name) if isinstance(root.command, click.Group) else None
+        )
+        if cmd is not None and name not in ("help", "version"):
+            click.echo(f"  {name:14s} {cmd.get_short_help_str(limit=80)}")
+    click.echo()
+    click.echo("Options accepted by every action:")
+    with click.Context(ctx.command, info_name="<action>") as sub:
+        formatter = sub.make_formatter()
+        ctx.command.format_options(sub, formatter)
+        click.echo(formatter.getvalue().rstrip())

gitftp/cli/cmd_init.py

@@ -0,0 +1,19 @@
+"""The init action."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp import deploy
+from gitftp.cli.options import common_options, session_for, url_argument
+
+
+@click.command("init", short_help="Upload all files and record the commit (first deployment).")
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    opts, session = session_for(ctx, url, kw)
+    deploy.run(deploy.Action.INIT, session, deploy.DeployOptions.from_cli(opts))

gitftp/cli/cmd_log.py

@@ -0,0 +1,31 @@
+"""The log action."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp.cli.options import common_options, session_for, url_argument
+from gitftp.errors import DownloadError, GitError
+from gitftp.transport import registry
+from gitftp.transport.base import RemoteNotFound
+
+
+@click.command("log", short_help="Run 'git log' on the deployed commit.")
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    _opts, session = session_for(ctx, url, kw)
+    registry.check_available(session.url.scheme)
+    try:
+        data = session.primary.get(session.deployed_sha1_file)
+    except (RemoteNotFound, DownloadError) as e:
+        raise DownloadError(f"Could not get uploaded log file. {e}") from e
+    sha = data.decode("utf-8", "replace").strip()
+    if not sha:
+        raise DownloadError("Could not get uploaded log file. It is empty.")
+    session.close()
+    if session.require_repo().log(sha) != 0:
+        raise GitError(f"git log {sha} failed.")

gitftp/cli/cmd_pull.py

@@ -0,0 +1,19 @@
+"""The ``pull`` action (native mirror, no lftp)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp import mirror
+from gitftp.cli.options import common_options, session_for, url_argument
+
+
+@click.command("pull", short_help="Download remote changes into a commit and merge it.")
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    opts, session = session_for(ctx, url, kw)
+    mirror.run_pull(session, mirror.MirrorOptions.from_cli(opts))

gitftp/cli/cmd_push.py

@@ -0,0 +1,21 @@
+"""The push action."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp import deploy
+from gitftp.cli.options import common_options, session_for, url_argument
+
+
+@click.command(
+    "push", short_help="Upload changed and delete removed files since the last deployment."
+)
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    opts, session = session_for(ctx, url, kw)
+    deploy.run(deploy.Action.PUSH, session, deploy.DeployOptions.from_cli(opts))

gitftp/cli/cmd_remove_scope.py

@@ -0,0 +1,23 @@
+"""The ``remove-scope`` action."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+
+from gitftp import config
+from gitftp.cli.options import common_options, prepare
+from gitftp.gitrepo import GitRepo
+
+
+@click.command("remove-scope", short_help="Delete a scope from the git config.")
+@common_options
+@click.argument("scope_name", metavar="SCOPE")
+@click.pass_context
+def command(ctx: click.Context, /, scope_name: str, **kw: Any) -> None:
+    _opts, out = prepare(ctx, kw)
+    repo = GitRepo.discover(Path.cwd())
+    config.remove_scope(repo, scope_name)
+    out.info(f"Successfully removed scope {scope_name}.")

gitftp/cli/cmd_show.py

@@ -0,0 +1,31 @@
+"""The show action."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from gitftp.cli.options import common_options, session_for, url_argument
+from gitftp.errors import DownloadError, GitError
+from gitftp.transport import registry
+from gitftp.transport.base import RemoteNotFound
+
+
+@click.command("show", short_help="Run 'git show' on the deployed commit.")
+@common_options
+@url_argument
+@click.pass_context
+def command(ctx: click.Context, /, url: str | None, **kw: Any) -> None:
+    _opts, session = session_for(ctx, url, kw)
+    registry.check_available(session.url.scheme)
+    try:
+        data = session.primary.get(session.deployed_sha1_file)
+    except (RemoteNotFound, DownloadError) as e:
+        raise DownloadError(f"Could not get uploaded log file. {e}") from e
+    sha = data.decode("utf-8", "replace").strip()
+    if not sha:
+        raise DownloadError("Could not get uploaded log file. It is empty.")
+    session.close()
+    if session.require_repo().show(sha) != 0:
+        raise GitError(f"git show {sha} failed.")