Files
solidcraft/scripts/ci/affected.py
T
jyvikoandClaude Opus 5.5 948c208db9 CI: run only what a change needs, on pull requests and on main
- Pushes to main use the same code/no-code rule as pull requests (`touches_code` in Select
  checks): a push changing only documentation, packaging, other workflows or the bots' scripts
  runs the repository checks only. With the merge queue off, every push to main ran the full suite
  and the Windows jobs, docs-only ones included.
- affected.py: test data under tests/ selects the packages that read it (robustness, hole matrix,
  projection, taper: solidcraft-engine; oracle: the CLI, the kernel, xtask; action matrix: the
  CLI, the engine, xtask), and a vendored crate the packages that use it (truck: the kernel and up;
  egui-wgpu: the UI and the apps), instead of the whole workspace. tests/tools and unknown vendored
  crates still select everything.
- Docker (the web app image) skips pushes touching only docs, test data or bot scripts; Pages skips
  test data and bot scripts; Generated files runs only when the manifests, lockfile, command
  registry, CLI or xtask change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-19 16:42:11 -04:00

157 lines
6.2 KiB
Python

#!/usr/bin/env python3
"""Select the workspace packages a pull request affects.
Usage: affected.py --paths FILE [--metadata FILE] [--github-output FILE]
FILE holds the changed paths relative to the repository root, separated by NUL (git diff -z);
"-" reads standard input. --metadata is the output of `cargo metadata --no-deps
--format-version 1` (run on demand when omitted).
Prints and optionally appends to $GITHUB_OUTPUT:
full=true|false test the whole workspace
packages=a b c the affected packages (empty when full, or when nothing needs building)
A changed file maps to the package whose directory holds it. The packages that depend on those
(directly or not, dev-dependencies included) are added. Test data under tests/ maps to the
packages that read it, and a vendored crate (vendor/, a [patch] of a crates.io dependency) to the
packages that use it. Anything that can change every package, or that no package owns, selects
the full workspace. Only documentation and packaging files are ignored.
"""
import argparse
import json
import subprocess
import sys
# Changes here can affect every package.
FULL_PREFIXES = (".cargo/", ".config/", ".github/", "scripts/")
FULL_FILES = ("Cargo.toml", "Cargo.lock")
# Changes here affect no code: documentation and packaging.
IGNORED_PREFIXES = ("docs/", "packaging/")
# Root files that a crate embeds (include_str!), so they are not ignorable documentation.
EMBEDDED = {"ATTRIBUTION.md": "solidcraft-ui-egui"}
# Asset folders that only some packages read: the UI embeds the catalogs, xtask checks them.
EMBEDDED_PREFIXES = {"assets/locales/": ("solidcraft-ui-egui", "xtask")}
# Test data and the package directories whose tests (or xtask) read it. Any other folder under
# tests/ selects the full workspace.
TEST_DATA = {
"tests/robustness/": ("crates/engine/",),
"tests/hole_matrix/": ("crates/engine/",),
"tests/projection/": ("crates/engine/",),
"tests/taper/": ("crates/engine/",),
"tests/oracle/": ("apps/solidcraft-cli/", "crates/kernel/", "xtask/"),
"tests/action_matrix/": ("apps/solidcraft-cli/", "crates/engine/", "xtask/"),
}
# Vendored crates (vendor/<crate>/, a [patch] of a crates.io dependency) and the dependency names
# through which workspace packages reach them: the truck crates and their maths crate only through
# truck itself (crates/kernel), egui-wgpu directly or through eframe. Another vendored crate
# selects the full workspace.
TRUCK = lambda dep: dep.startswith("truck-") # noqa: E731
VENDOR_USES = {
"truck-geometry": TRUCK,
"truck-shapeops": TRUCK,
"truck-stepio": TRUCK,
"truck-meshalgo": TRUCK,
"matext4cgmath": TRUCK,
"egui-wgpu": lambda dep: dep in ("egui-wgpu", "eframe"),
}
def load_metadata(path):
if path:
with open(path, encoding="utf-8") as f:
return json.load(f)
out = subprocess.run(
["cargo", "metadata", "--no-deps", "--format-version", "1", "--locked"],
check=True, capture_output=True, text=True,
).stdout
return json.loads(out)
def read_paths(src):
data = sys.stdin.buffer.read() if src == "-" else open(src, "rb").read()
return [p.decode() for p in data.split(b"\0") if p]
def select(meta, paths):
"""Return (full, sorted package names)."""
root = meta["workspace_root"].rstrip("/") + "/"
pkgs = {}
for p in meta["packages"]:
manifest = p["manifest_path"]
assert manifest.startswith(root), manifest
pkgs[p["name"]] = manifest[len(root):].rsplit("/", 1)[0] + "/"
by_dir = {d: n for n, d in pkgs.items()}
# Reverse dependencies inside the workspace, matched by the dependency's path.
dependents = {n: set() for n in pkgs}
for p in meta["packages"]:
for d in p["dependencies"]:
path = d.get("path")
if not path:
continue
rel = path.rstrip("/") + "/"
target = by_dir.get(rel[len(root):]) if rel.startswith(root) else None
if target:
dependents[target].add(p["name"])
def users_of(vendored):
"""The workspace packages that depend on a vendored crate (by dependency name)."""
uses = VENDOR_USES.get(vendored)
if uses is None:
return set()
return {p["name"] for p in meta["packages"] if any(uses(d["name"]) for d in p["dependencies"])}
hit = set()
for path in paths:
if path in FULL_FILES or path.startswith(FULL_PREFIXES) or path.startswith("rust-toolchain"):
return True, []
owners = [d for d in by_dir if path.startswith(d)]
if path.startswith("vendor/"):
if path == "vendor/README.md":
continue
users = users_of(path.split("/")[1])
if not users:
return True, []
hit.update(users)
elif path.startswith("tests/"):
data = next((v for k, v in TEST_DATA.items() if path.startswith(k)), None)
readers = [by_dir[d] for d in data or () if d in by_dir]
if not readers:
return True, []
hit.update(readers)
elif owners:
hit.add(by_dir[max(owners, key=len)])
elif path in EMBEDDED:
hit.add(EMBEDDED[path])
elif any(path.startswith(p) for p in EMBEDDED_PREFIXES):
hit.update(next(v for p, v in EMBEDDED_PREFIXES.items() if path.startswith(p)))
elif path.startswith(IGNORED_PREFIXES) or ("/" not in path and path.endswith(".md")):
continue
else:
return True, [] # not owned by any package
todo, seen = list(hit), set(hit)
while todo:
for dep in dependents[todo.pop()]:
if dep not in seen:
seen.add(dep)
todo.append(dep)
return False, sorted(seen)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--paths", required=True)
ap.add_argument("--metadata")
ap.add_argument("--github-output")
a = ap.parse_args()
full, packages = select(load_metadata(a.metadata), read_paths(a.paths))
lines = [f"full={'true' if full else 'false'}", f"packages={' '.join(packages)}"]
print("\n".join(lines))
if a.github_output:
with open(a.github_output, "a", encoding="utf-8") as f:
f.write("\n".join(lines) + "\n")
if __name__ == "__main__":
main()