makepatch 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

makepatch/__init__.py

@@ -1 +1,3 @@
-from .hooks import PatcherBuildHook
+"""makepatch: git-based patching for Python packages."""
+
+__version__ = "0.1.0"

makepatch/__main__.py

@@ -0,0 +1,3 @@
+from makepatch.cli import main
+
+raise SystemExit(main())

makepatch/_startup.py

@@ -0,0 +1,90 @@
+"""Interpreter start-up check, imported from ``makepatch-startup.pth``.
+
+It only does work in an environment where ``makepatch pkg apply`` (or
+``pkg commit``) has run before, i.e. where ``<sys.prefix>/makepatch-state.json``
+exists. The fast path reads the patch files and the markers in the
+dist-info directories; only when they disagree (a package was reinstalled
+by uv/pip, or a patch was added, changed or removed) the patches are
+applied again, under the environment lock. Nothing is ever patched in
+memory: the result is the same as running ``makepatch pkg apply``.
+"""
+
+import hashlib
+import json
+import os
+import re
+import sys
+
+
+def _up_to_date(state):
+    applied = state.get("applied") or {}
+    patches_dir = state["patches_dir"]
+    try:
+        names = [n for n in os.listdir(patches_dir) if n.endswith(".patch")]
+    except FileNotFoundError:
+        names = []
+    if len(names) != len(applied):
+        return False
+    for name in names:
+        key = re.sub(r"[-_.]+", "-", name.partition("@")[0]).lower()
+        entry = applied.get(key)
+        if entry is None:
+            return False
+        with open(os.path.join(patches_dir, name), "rb") as fp:
+            sha = hashlib.sha256(fp.read()).hexdigest()
+        if entry.get("sha256") != sha:
+            return False
+        try:
+            with open(os.path.join(entry["dist_info"], "makepatch.json"), "rb") as fp:
+                marker = json.load(fp)
+        except (OSError, ValueError):
+            return False
+        if marker.get("sha256") != sha:
+            return False
+    return True
+
+
+def _repair(state):
+    from pathlib import Path
+
+    from makepatch.config import PackageConfig
+    from makepatch.package.apply import apply_all, locked
+    from makepatch.package.dist import Environment
+
+    env = Environment.current()
+    cfg = PackageConfig(root=Path(state["project"]), patches_dir=Path(state["patches_dir"]))
+    with locked(env):
+        # Another process may have repaired the environment meanwhile.
+        try:
+            with open(env.state_file, "rb") as fp:
+                if _up_to_date(json.load(fp)):
+                    return
+        except (OSError, ValueError, KeyError):
+            pass
+        results = apply_all(cfg, env)
+    for result in results:
+        if result.error:
+            sys.stderr.write(f"makepatch: warning: {result.error}\n")
+        elif result.action != "unchanged":
+            sys.stderr.write(f"makepatch: {result.key}: {result.action}\n")
+
+
+def _run():
+    if os.environ.get("MAKEPATCH_DISABLE_STARTUP") or sys.flags.isolated:
+        return
+    try:
+        with open(os.path.join(sys.prefix, "makepatch-state.json"), "rb") as fp:
+            state = json.load(fp)
+    except (OSError, ValueError):
+        return
+    if not os.path.isdir(state.get("project", "")):
+        return
+    if _up_to_date(state):
+        return
+    _repair(state)
+
+
+try:
+    _run()
+except Exception as exc:  # never break interpreter start-up
+    sys.stderr.write(f"makepatch: warning: start-up check failed: {exc}\n")

makepatch/cli.py

@@ -0,0 +1,238 @@
+"""Command line interface: ``makepatch src ...`` and ``makepatch pkg ...``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from makepatch import __version__
+from makepatch.config import PackageConfig, SourceConfig, find_project_root
+from makepatch.errors import MakepatchError
+from makepatch.term import paint
+
+# Colors for the actions reported by ``pkg`` commands.
+ACTION_STYLES = {
+    "applied": ("green",),
+    "reapplied": ("green",),
+    "would apply": ("cyan",),
+    "unchanged": ("dim",),
+    "reverted": ("yellow",),
+    "would revert": ("yellow",),
+    "not patched": ("dim",),
+}
+
+
+def _root(args: argparse.Namespace) -> Path:
+    return find_project_root(Path(args.project) if args.project else None)
+
+
+def _action(action: str) -> str:
+    return paint(action, *ACTION_STYLES.get(action, ()))
+
+
+def _cmd(command: str) -> str:
+    return paint(f"`{command}`", "cyan")
+
+
+def _err(text: str, *styles: str) -> str:
+    return paint(text, *styles, stream=sys.stderr)
+
+
+def _note(message: str) -> None:
+    print(f"{_err('note:', 'yellow', 'bold')} {message}", file=sys.stderr)
+
+
+def _env(args: argparse.Namespace):
+    from makepatch.package.dist import Environment
+
+    return Environment.for_python(args.python) if args.python else Environment.current()
+
+
+# -- src -------------------------------------------------------------------------------
+
+
+def cmd_src_apply(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    work = workspace.setup(cfg, offline=args.offline, force=args.force)
+    print(f"{paint('work repository ready:', 'green')} {paint(str(work), 'bold')}")
+    return 0
+
+
+def cmd_src_rebuild(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    sources, features = workspace.rebuild(cfg)
+    counts = f"{paint(str(sources), 'bold')} source patch(es) and {paint(str(features), 'bold')} feature patch(es)"
+    print(f"{paint('wrote', 'green')} {counts}")
+    return 0
+
+
+def cmd_src_fixup(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    workspace.fixup(cfg)
+    print(f"{paint('folded changes into the source patch commit', 'green')}; run {_cmd('makepatch src rebuild')} to update patches")
+    return 0
+
+
+def cmd_src_status(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    st = workspace.status(cfg)
+    print(f"{paint('upstream:', 'bold')}        {cfg.upstream} @ {paint(cfg.ref, 'cyan')} {paint(f'({st.base[:12]})', 'dim')}")
+    print(f"{paint('source files:', 'bold')}    {st.source_files}")
+    print(f"{paint('feature commits:', 'bold')} {st.features}")
+    print(f"{paint('dirty:', 'bold')}           {paint('yes', 'yellow') if st.dirty else paint('no', 'green')}")
+    if st.in_progress:
+        print(f"{paint('in progress:', 'bold')}     {paint(st.in_progress, 'yellow', 'bold')}")
+    return 0
+
+
+# -- pkg -------------------------------------------------------------------------------
+
+
+def cmd_pkg_edit(args: argparse.Namespace) -> int:
+    from makepatch.package import edit
+
+    cfg = PackageConfig.load(_root(args))
+    path = edit.edit(cfg, _env(args), args.package, force=args.force)
+    print(f"edit the files in {paint(str(path), 'bold')}, then run {_cmd(f'makepatch pkg commit {args.package}')}")
+    return 0
+
+
+def cmd_pkg_commit(args: argparse.Namespace) -> int:
+    from makepatch.package import edit
+
+    cfg = PackageConfig.load(_root(args))
+    patch, action = edit.commit(cfg, _env(args), args.package, keep=args.keep)
+    if patch is None:
+        print(f"no changes; {paint(args.package, 'bold')}: {_action(action)}")
+    else:
+        wrote = paint(str(patch.relative_to(cfg.root)), "bold")
+        print(f"{paint('wrote', 'green')} {wrote}; {paint(args.package, 'bold')}: {_action(action)}")
+    return 0
+
+
+def _print_results(results) -> int:
+    failed = 0
+    for r in results:
+        if r.error:
+            failed += 1
+            print(f"{_err(r.key, 'bold')}: {_err('failed:', 'red', 'bold')} {r.error}", file=sys.stderr)
+        else:
+            print(f"{paint(r.key, 'bold')}: {_action(r.action)}")
+    return 1 if failed else 0
+
+
+def cmd_pkg_apply(args: argparse.Namespace) -> int:
+    from makepatch.package.apply import apply_all, locked
+
+    cfg = PackageConfig.load(_root(args))
+    env = _env(args)
+    with locked(env):
+        return _print_results(apply_all(cfg, env, dry_run=args.check))
+
+
+def cmd_pkg_revert(args: argparse.Namespace) -> int:
+    from makepatch.package.apply import locked, revert, write_state
+
+    cfg = PackageConfig.load(_root(args))
+    env = _env(args)
+    with locked(env):
+        dist = env.find(args.package)
+        done = revert(dist)
+        write_state(cfg, env)
+    print(f"{paint(dist.key, 'bold')}: {_action('reverted' if done else 'not patched')}")
+    if done:
+        _note("the start-up hook re-applies it unless the patch file is removed")
+    return 0
+
+
+def cmd_pkg_status(args: argparse.Namespace) -> int:
+    from makepatch.package.apply import discover
+
+    cfg = PackageConfig.load(_root(args))
+    env = _env(args)
+    patches = discover(cfg)
+    dists = {d.key: d for d in env.distributions()}
+    keys = sorted(set(patches) | {k for k, d in dists.items() if d.marker()})
+    if not keys:
+        print(paint("no package patches", "dim"))
+    for key in keys:
+        patch, dist = patches.get(key), dists.get(key)
+        if dist is None:
+            state = paint("not installed", "red")
+        elif patch is None:
+            state = paint("patched, but the patch file is gone", "red")
+        elif dist.version != patch.version:
+            state = paint(f"version mismatch (installed {dist.version})", "red")
+        else:
+            marker = dist.marker()
+            if marker is None:
+                state = paint("not applied", "yellow")
+            elif marker.get("sha256") != patch.sha256:
+                state = paint("outdated", "yellow")
+            else:
+                state = paint("applied", "green")
+        print(f"{paint(patch.path.name if patch else key, 'bold')}: {state}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="makepatch", description=__doc__)
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("-C", "--project", help="project directory (default: nearest pyproject.toml)")
+    modes = parser.add_subparsers(dest="mode", required=True)
+
+    src = modes.add_parser("src", help="source patch mode (fork an upstream git repository)")
+    src_cmds = src.add_subparsers(dest="command", required=True)
+    p = src_cmds.add_parser("apply", help="create the work repository and apply all patches")
+    p.add_argument("--offline", action="store_true", help="use the cached upstream only")
+    p.add_argument("--force", action="store_true", help="discard unsaved work in the work repository")
+    p.set_defaults(func=cmd_src_apply)
+    p = src_cmds.add_parser("rebuild", help="regenerate patches from the work repository")
+    p.set_defaults(func=cmd_src_rebuild)
+    p = src_cmds.add_parser("fixup", help="fold working tree changes into the source patches")
+    p.set_defaults(func=cmd_src_fixup)
+    p = src_cmds.add_parser("status", help="show the work repository state")
+    p.set_defaults(func=cmd_src_status)
+
+    pkg = modes.add_parser("pkg", help="package patch mode (patch installed distributions)")
+    pkg.add_argument("--python", help="interpreter of the target environment (default: the current one)")
+    pkg_cmds = pkg.add_subparsers(dest="command", required=True)
+    p = pkg_cmds.add_parser("edit", help="prepare an editable copy of an installed package")
+    p.add_argument("package")
+    p.add_argument("--force", action="store_true", help="discard an existing edit")
+    p.set_defaults(func=cmd_pkg_edit)
+    p = pkg_cmds.add_parser("commit", help="write the patch from an edit and apply it")
+    p.add_argument("package")
+    p.add_argument("--keep", action="store_true", help="keep the edit directory")
+    p.set_defaults(func=cmd_pkg_commit)
+    p = pkg_cmds.add_parser("apply", help="apply every package patch to the environment")
+    p.add_argument("--check", action="store_true", help="only check that the patches apply")
+    p.set_defaults(func=cmd_pkg_apply)
+    p = pkg_cmds.add_parser("revert", help="restore the original files of a package")
+    p.add_argument("package")
+    p.set_defaults(func=cmd_pkg_revert)
+    p = pkg_cmds.add_parser("status", help="show the state of every package patch")
+    p.set_defaults(func=cmd_pkg_status)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except MakepatchError as exc:
+        print(f"{_err('makepatch: error:', 'red', 'bold')} {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

makepatch/config.py

@@ -0,0 +1,130 @@
+"""Loading of ``[tool.makepatch]`` from ``pyproject.toml``."""
+
+from __future__ import annotations
+
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    import tomli as tomllib
+
+from makepatch.errors import MakepatchError
+
+STATE_DIR = ".makepatch"
+
+
+def find_project_root(start: Path | None = None) -> Path:
+    start = (start or Path.cwd()).resolve()
+    for directory in (start, *start.parents):
+        if (directory / "pyproject.toml").is_file():
+            return directory
+    raise MakepatchError(f"no pyproject.toml found in {start} or any parent directory")
+
+
+def load_tool_table(root: Path) -> dict[str, Any]:
+    path = root / "pyproject.toml"
+    try:
+        with path.open("rb") as fp:
+            data = tomllib.load(fp)
+    except FileNotFoundError:
+        raise MakepatchError(f"{path} does not exist") from None
+    except tomllib.TOMLDecodeError as exc:
+        raise MakepatchError(f"{path}: {exc}") from None
+    table = data.get("tool", {}).get("makepatch", {})
+    if not isinstance(table, dict):
+        raise MakepatchError("[tool.makepatch] must be a table")
+    return table
+
+
+def _safe_relpath(value: str, what: str) -> str:
+    path = PurePosixPath(value)
+    if not value or path.is_absolute() or ".." in path.parts:
+        raise MakepatchError(f"{what} must be a relative path without '..': {value!r}")
+    return path.as_posix().rstrip("/") if path.as_posix() != "." else "."
+
+
+def _patterns(table: dict[str, Any], key: str) -> list[str]:
+    value = table.get(key, [])
+    if not isinstance(value, list) or not all(isinstance(v, str) for v in value):
+        raise MakepatchError(f"[tool.makepatch.source] {key} must be a list of gitignore-style patterns")
+    return value
+
+
+@dataclass
+class SourceConfig:
+    root: Path
+    upstream: str
+    ref: str
+    include: dict[str, str] = field(default_factory=dict)
+    exclude: list[str] = field(default_factory=list)
+    work_exclude: list[str] = field(default_factory=list)
+    work_dir: Path = Path()
+    patches_dir: Path = Path()
+
+    @property
+    def state_dir(self) -> Path:
+        return self.root / STATE_DIR
+
+    @property
+    def source_patches(self) -> Path:
+        return self.patches_dir / "sources"
+
+    @property
+    def feature_patches(self) -> Path:
+        return self.patches_dir / "features"
+
+    @classmethod
+    def load(cls, root: Path, table: dict[str, Any] | None = None) -> "SourceConfig":
+        if table is None:
+            table = load_tool_table(root)
+        src = table.get("source")
+        if not isinstance(src, dict):
+            raise MakepatchError("missing [tool.makepatch.source] table in pyproject.toml")
+        upstream = src.get("upstream")
+        ref = src.get("ref")
+        if not isinstance(upstream, str) or not upstream:
+            raise MakepatchError("[tool.makepatch.source] upstream must be a git URL")
+        if not isinstance(ref, str) or not ref:
+            raise MakepatchError("[tool.makepatch.source] ref must be a commit, tag or branch")
+        include = src.get("include", {})
+        if not isinstance(include, dict) or not all(isinstance(v, str) for v in include.values()):
+            raise MakepatchError("[tool.makepatch.source] include must map upstream paths to wheel paths")
+        include = {_safe_relpath(k, "include key"): _safe_relpath(v, "include value") for k, v in include.items()}
+        exclude = _patterns(src, "exclude")
+        work_exclude = _patterns(src, "work-exclude")
+        # A local path upstream is resolved against the project root.
+        if not re.match(r"^[A-Za-z][A-Za-z0-9+.-]*://", upstream) and not re.match(r"^[^/]+@[^/]+:", upstream):
+            upstream = str((root / upstream).resolve())
+        return cls(
+            root=root,
+            upstream=upstream,
+            ref=ref,
+            include=include,
+            exclude=exclude,
+            work_exclude=work_exclude,
+            work_dir=root / _safe_relpath(src.get("work-dir", "work"), "work-dir"),
+            patches_dir=root / _safe_relpath(src.get("patches-dir", "patches"), "patches-dir"),
+        )
+
+
+@dataclass
+class PackageConfig:
+    root: Path
+    patches_dir: Path
+
+    @property
+    def edit_dir(self) -> Path:
+        return self.root / STATE_DIR / "edit"
+
+    @classmethod
+    def load(cls, root: Path) -> "PackageConfig":
+        table = load_tool_table(root).get("packages", {})
+        if not isinstance(table, dict):
+            raise MakepatchError("[tool.makepatch.packages] must be a table")
+        patches_dir = _safe_relpath(table.get("patches-dir", "patches/packages"), "patches-dir")
+        return cls(root=root, patches_dir=root / patches_dir)

makepatch/errors.py

@@ -0,0 +1,2 @@
+class MakepatchError(Exception):
+    """An expected failure, reported to the user without a traceback."""

makepatch/git.py

@@ -0,0 +1,133 @@
+"""Thin wrapper around the ``git`` executable.
+
+Every git invocation in makepatch goes through :func:`run` so that the
+environment is pinned: stable locale, fixed identity, no signing, no
+line-ending conversion and no discovery of an enclosing repository.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Sequence
+
+from makepatch.errors import MakepatchError
+
+IDENTITY_NAME = "makepatch"
+IDENTITY_EMAIL = "makepatch@localhost"
+# Fixed date for commits makepatch creates itself (base / source patches),
+# so that re-running setup yields identical commit ids.
+FIXED_DATE = "1970-01-01T00:00:00+0000"
+
+_CONFIG = (
+    "commit.gpgsign=false",
+    "tag.gpgsign=false",
+    "core.autocrlf=false",
+    "core.safecrlf=false",
+    "core.quotepath=false",
+    "advice.detachedHead=false",
+    "init.defaultBranch=main",
+)
+
+
+class GitError(MakepatchError):
+    def __init__(self, args: Sequence[str], returncode: int, stdout: str, stderr: str):
+        self.args_ = list(args)
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+        detail = (stderr or stdout).strip()
+        super().__init__(f"git {' '.join(args)} failed ({returncode})" + (f":\n{detail}" if detail else ""))
+
+
+def _env(cwd: Path, extra: dict[str, str] | None, fixed_date: bool, network: bool) -> dict[str, str]:
+    env = dict(os.environ)
+    for key in list(env):
+        # Never let an outer repository leak in (e.g. when run from a git hook).
+        if key.startswith("GIT_") and key not in ("GIT_SSH", "GIT_SSH_COMMAND", "GIT_ASKPASS", "GIT_TERMINAL_PROMPT"):
+            del env[key]
+    env["LC_ALL"] = "C"
+    env["LANG"] = "C"
+    if not network:
+        # Local operations (diff, format-patch, apply, am, commit, rebase) must
+        # not be influenced by user configuration such as diff.noprefix,
+        # format.* or core.hooksPath. Network operations keep it for
+        # proxies, credential helpers and url.*.insteadOf.
+        env["GIT_CONFIG_NOSYSTEM"] = "1"
+        env["GIT_CONFIG_GLOBAL"] = os.devnull
+    env["GIT_AUTHOR_NAME"] = env["GIT_COMMITTER_NAME"] = IDENTITY_NAME
+    env["GIT_AUTHOR_EMAIL"] = env["GIT_COMMITTER_EMAIL"] = IDENTITY_EMAIL
+    if fixed_date:
+        env["GIT_AUTHOR_DATE"] = env["GIT_COMMITTER_DATE"] = FIXED_DATE
+    # Stop repository discovery at the parent of cwd: ``cwd`` itself may be a
+    # repository, but nothing above it is ever used.
+    env["GIT_CEILING_DIRECTORIES"] = str(Path(cwd).resolve().parent)
+    if extra:
+        env.update(extra)
+    return env
+
+
+def run(
+    args: Sequence[str],
+    cwd: Path | str,
+    *,
+    check: bool = True,
+    input: bytes | str | None = None,
+    env: dict[str, str] | None = None,
+    fixed_date: bool = False,
+    binary: bool = False,
+    network: bool = False,
+) -> subprocess.CompletedProcess:
+    cwd = Path(cwd)
+    cmd = ["git"]
+    for item in _CONFIG:
+        cmd += ["-c", item]
+    cmd += list(args)
+    if isinstance(input, str):
+        input = input.encode()
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=cwd,
+            input=input,
+            capture_output=True,
+            env=_env(cwd, env, fixed_date, network),
+        )
+    except FileNotFoundError as exc:  # pragma: no cover - depends on system
+        raise MakepatchError("git executable not found in PATH") from exc
+    if not binary:
+        proc.stdout = proc.stdout.decode("utf-8", "surrogateescape")
+        proc.stderr = proc.stderr.decode("utf-8", "surrogateescape")
+    if check and proc.returncode != 0:
+        out = proc.stdout if isinstance(proc.stdout, str) else proc.stdout.decode("utf-8", "replace")
+        err = proc.stderr if isinstance(proc.stderr, str) else proc.stderr.decode("utf-8", "replace")
+        raise GitError(args, proc.returncode, out, err)
+    return proc
+
+
+def out(args: Sequence[str], cwd: Path | str, **kwargs) -> str:
+    return run(args, cwd, **kwargs).stdout.strip()
+
+
+def patch_paths(patch: Path, cwd: Path) -> list[str]:
+    """Return every path a patch touches (old and new names)."""
+    proc = run(["apply", "--numstat", "-z", str(patch)], cwd)
+    paths: list[str] = []
+    fields = proc.stdout.split("\0")
+    # ``--numstat -z`` emits "added\tdeleted\tpath\0", or for renames
+    # "added\tdeleted\t\0old\0new\0".
+    i = 0
+    while i < len(fields):
+        field = fields[i]
+        parts = field.split("\t")
+        if len(parts) == 3:
+            if parts[2]:
+                paths.append(parts[2])
+                i += 1
+            else:
+                paths += fields[i + 1 : i + 3]
+                i += 3
+        else:
+            i += 1
+    return list(dict.fromkeys(p for p in paths if p))

makepatch/hatch/hook.py

@@ -0,0 +1,82 @@
+"""Hatchling build hook for source patch mode.
+
+``[tool.hatch.build.hooks.makepatch]`` enables it; the settings themselves
+live in ``[tool.makepatch.source]``.
+
+* sdist: the patched upstream tree is stored under ``_makepatch/tree`` so
+  that building a wheel from the sdist needs neither git history nor network.
+* wheel: the paths of ``include`` are mapped from the patched tree into the
+  wheel.
+
+Files matching ``exclude`` (gitignore syntax, relative to each ``include``
+path) are left out of both.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+from typing import Iterator
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+from makepatch.config import SourceConfig
+from makepatch.errors import MakepatchError
+from makepatch.source import workspace
+
+SDIST_TREE = "_makepatch/tree"
+
+
+class MakepatchBuildHook(BuildHookInterface):
+    PLUGIN_NAME = "makepatch"
+
+    def _tree(self, cfg: SourceConfig) -> Path:
+        root = Path(self.root)
+        prebuilt = root / SDIST_TREE
+        if (root / "PKG-INFO").is_file() and prebuilt.is_dir():
+            return prebuilt
+        offline = os.environ.get("MAKEPATCH_OFFLINE", "") not in ("", "0")
+        dest = cfg.state_dir / "build" / "tree"
+        self.app.display_info(f"makepatch: applying patches onto {cfg.upstream} @ {cfg.ref}")
+        return workspace.materialize(cfg, dest, offline=offline)
+
+    def initialize(self, version: str, build_data: dict) -> None:
+        cfg = SourceConfig.load(Path(self.root))
+        if not cfg.include:
+            raise MakepatchError("[tool.makepatch.source] include is empty: nothing would be built")
+        tree = self._tree(cfg)
+        force_include = build_data.setdefault("force_include", {})
+        for src, dst in cfg.include.items():
+            path = tree / src
+            if not path.exists():
+                raise MakepatchError(f"include path {src!r} does not exist in the patched upstream tree")
+            prefix = f"{SDIST_TREE}/{src}" if self.target_name == "sdist" else dst
+            for file, rel in _files(path, cfg.exclude):
+                force_include[str(file)] = f"{prefix}/{rel}" if rel else prefix
+
+    def clean(self, versions: list[str]) -> None:
+        build = Path(self.root) / ".makepatch" / "build"
+        if build.is_dir():
+            shutil.rmtree(build)
+
+
+def _files(path: Path, exclude: list[str]) -> Iterator[tuple[Path, str]]:
+    """Yield (file, path relative to ``path``) for files not excluded.
+
+    For a single-file include the relative path is empty and the file name
+    is matched against the patterns.
+    """
+    from pathspec import GitIgnoreSpec  # a dependency of hatchling
+
+    spec = GitIgnoreSpec.from_lines(exclude)
+    if path.is_file():
+        if not spec.match_file(path.name):
+            yield path, ""
+        return
+    for file in sorted(path.rglob("*")):
+        rel = file.relative_to(path).as_posix()
+        if ".git" in file.relative_to(path).parts or not file.is_file():
+            continue
+        if not spec.match_file(rel):
+            yield file, rel