taler-typescript-core

archive.py (5585B)

---

 #!/usr/bin/env python3
 
 # This file has been placed in the public domain.
 
 """Create a source archive containing this repository and its submodules."""
 
 from __future__ import annotations
 
 import argparse
 import io
 import json
 import os
 from pathlib import Path
 import subprocess
 import sys
 import tarfile
 
 
 def run_git(repo: Path, *args: str, input_data: bytes | None = None) -> bytes:
     try:
         return subprocess.run(
             ["git", *args],
             cwd=repo,
             input=input_data,
             check=True,
             stdout=subprocess.PIPE,
         ).stdout
     except subprocess.CalledProcessError as exc:
         command = " ".join(("git", *args))
         raise RuntimeError(f"'{command}' failed in {repo}") from exc
 
 
 def tracked_paths(repo: Path) -> list[Path]:
     output = run_git(repo, "ls-files", "-z", "--cached")
     return [
         Path(os.fsdecode(item)) for item in output.rstrip(b"\0").split(b"\0") if item
     ]
 
 
 def submodule_paths(repo: Path) -> set[Path]:
     gitmodules = repo / ".gitmodules"
     if not gitmodules.exists():
         return set()
     result = subprocess.run(
         [
             "git",
             "config",
             "-f",
             ".gitmodules",
             "--get-regexp",
             r"^submodule\..*\.path$",
         ],
         cwd=repo,
         check=False,
         stdout=subprocess.PIPE,
         text=True,
     )
     if result.returncode not in (0, 1):
         raise RuntimeError(f"could not read submodules from {gitmodules}")
     return {Path(line.split(maxsplit=1)[1]) for line in result.stdout.splitlines()}
 
 
 def export_ignored(repo: Path, paths: list[Path]) -> set[Path]:
     if not paths:
         return set()
     query = b"\0".join(os.fsencode(path) for path in paths) + b"\0"
     output = run_git(
         repo, "check-attr", "-z", "--stdin", "export-ignore", input_data=query
     )
     fields = output.rstrip(b"\0").split(b"\0")
     ignored: set[Path] = set()
     for index in range(0, len(fields), 3):
         if fields[index + 2] == b"set":
             ignored.add(Path(os.fsdecode(fields[index])))
     return ignored
 
 
 def repository_entries(repo: Path) -> list[tuple[Path, Path]]:
     """Return (filesystem path, archive-relative path) pairs for one repository."""
     submodules = submodule_paths(repo)
     candidates: list[tuple[Path, Path]] = []
 
     for relative in tracked_paths(repo):
         if relative not in submodules:
             candidates.append((repo / relative, relative))
 
     for submodule in sorted(submodules):
         submodule_dir = repo / submodule
         if not (submodule_dir / ".git").exists():
             raise RuntimeError(
                 f"submodule '{submodule}' is not initialized; run './bootstrap' first"
             )
         for source, relative in repository_entries(submodule_dir):
             candidates.append((source, submodule / relative))
 
     ignored = export_ignored(repo, [relative for _, relative in candidates])
     return [
         (source, relative) for source, relative in candidates if relative not in ignored
     ]
 
 
 def archive_prefix(output: Path) -> Path:
     name = output.name
     for suffix in (".tar.gz", ".tgz"):
         if name.endswith(suffix):
             prefix = name[: -len(suffix)]
             if prefix:
                 return Path(prefix)
             break
     raise ValueError("output file must end in .tar.gz or .tgz")
 
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
         "--include",
         action="append",
         default=[],
         metavar="FILE",
         help="include an untracked or export-ignored file (may be repeated)",
     )
     parser.add_argument("output", type=Path, help="output .tar.gz file")
     return parser.parse_args()
 
 
 def main() -> int:
     args = parse_args()
     root = Path(run_git(Path.cwd(), "rev-parse", "--show-toplevel").decode().strip())
     output = args.output.resolve()
     prefix = archive_prefix(output)
     entries = repository_entries(root)
     build_info = subprocess.run(
         ["node", str(root / "build-system/version-cli.mjs"), "--json", str(root)],
         check=True,
         stdout=subprocess.PIPE,
     ).stdout
     version_metadata = json.loads(build_info)
 
     included: list[tuple[Path, Path]] = []
     for name in args.include:
         relative = Path(name)
         if relative.is_absolute() or ".." in relative.parts:
             raise ValueError(
                 f"included path must be relative to the repository: {name}"
             )
         source = (root / relative).absolute()
         if not source.is_file():
             raise FileNotFoundError(f"included file does not exist: {name}")
         included.append((source, relative))
 
     with tarfile.open(output, "w:gz") as archive:
         for source, relative in [*included, *entries]:
             if relative == Path("build-info.json"):
                 continue
             archive.add(source, arcname=prefix / relative, recursive=False)
         metadata = tarfile.TarInfo(str(prefix / "build-info.json"))
         metadata.size = len(build_info)
         metadata.mode = 0o644
         metadata.mtime = int(
             run_git(root, "show", "-s", "--format=%ct", version_metadata["gitHash"])
         )
         archive.addfile(metadata, io.BytesIO(build_info))
 
     print(f"created {output}")
     return 0
 
 
 if __name__ == "__main__":
     try:
         sys.exit(main())
     except (OSError, RuntimeError, ValueError, subprocess.CalledProcessError) as exc:
         print(f"archive: {exc}", file=sys.stderr)
         sys.exit(1)