Initial import

1 files changed, 225 insertions, 0 deletions

diff --git a/template/fresh/check.py b/template/fresh/check.py
new file mode 100644
index 0000000..424497e
--- /dev/null
+++ b/template/fresh/check.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from pathlib import PurePosixPath
+
+
+ROOT = Path(__file__).resolve().parent
+WORKSPACE_MANIFEST = ROOT / "Cargo.toml"
+DEFAULT_MAX_SOURCE_FILE_LINES = 2500
+DEFAULT_SOURCE_FILE_INCLUDE = ("*.rs", "**/*.rs")
+IGNORED_SOURCE_DIRS = frozenset(
+    {".direnv", ".git", ".hg", ".jj", ".svn", "__pycache__", "node_modules", "target", "vendor"}
+)
+Command = tuple[str, ...]
+CommandSequence = tuple[Command, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class SourceFilePolicy:
+    max_lines: int
+    include: tuple[str, ...]
+    exclude: tuple[str, ...]
+
+
+def load_workspace_metadata() -> dict[str, object]:
+    workspace = tomllib.loads(WORKSPACE_MANIFEST.read_text(encoding="utf-8"))
+    return workspace["workspace"]["metadata"]["rust-starter"]
+
+
+def load_command(value: object, *, key_path: str) -> Command:
+    if not isinstance(value, list) or not value or not all(isinstance(part, str) and part for part in value):
+        raise SystemExit(f"[check] invalid {key_path}: expected a non-empty string list")
+    return tuple(value)
+
+
+def load_command_sequence(value: object, *, key_path: str) -> CommandSequence:
+    if not isinstance(value, list) or not value:
+        raise SystemExit(f"[check] invalid {key_path}: expected a non-empty list of commands")
+
+    commands: list[Command] = []
+    for index, command in enumerate(value, start=1):
+        commands.append(load_command(command, key_path=f"{key_path}[{index}]"))
+    return tuple(commands)
+
+
+def load_commands(metadata: dict[str, object]) -> dict[str, Command | CommandSequence]:
+    commands: dict[str, Command | CommandSequence] = {
+        "format_command": load_command(
+            metadata.get("format_command"),
+            key_path="workspace.metadata.rust-starter.format_command",
+        ),
+        "clippy_command": load_command(
+            metadata.get("clippy_command"),
+            key_path="workspace.metadata.rust-starter.clippy_command",
+        ),
+        "test_command": load_command(
+            metadata.get("test_command"),
+            key_path="workspace.metadata.rust-starter.test_command",
+        ),
+        "canonicalize_commands": load_command_sequence(
+            metadata.get("canonicalize_commands"),
+            key_path="workspace.metadata.rust-starter.canonicalize_commands",
+        ),
+    }
+
+    raw_doc_command = metadata.get("doc_command")
+    if raw_doc_command is not None:
+        commands["doc_command"] = load_command(
+            raw_doc_command,
+            key_path="workspace.metadata.rust-starter.doc_command",
+        )
+    return commands
+
+
+def load_patterns(
+    value: object,
+    *,
+    default: tuple[str, ...],
+    key_path: str,
+    allow_empty: bool,
+) -> tuple[str, ...]:
+    if value is None:
+        return default
+    if not isinstance(value, list) or not all(isinstance(pattern, str) and pattern for pattern in value):
+        raise SystemExit(f"[check] invalid {key_path}: expected a string list")
+    if not allow_empty and not value:
+        raise SystemExit(f"[check] invalid {key_path}: expected at least one pattern")
+    return tuple(value)
+
+
+def load_source_file_policy(metadata: dict[str, object]) -> SourceFilePolicy:
+    raw_policy = metadata.get("source_files")
+    if raw_policy is None:
+        return SourceFilePolicy(DEFAULT_MAX_SOURCE_FILE_LINES, DEFAULT_SOURCE_FILE_INCLUDE, ())
+    if not isinstance(raw_policy, dict):
+        raise SystemExit("[check] invalid workspace.metadata.rust-starter.source_files: expected a table")
+
+    max_lines = raw_policy.get("max_lines", DEFAULT_MAX_SOURCE_FILE_LINES)
+    if not isinstance(max_lines, int) or max_lines <= 0:
+        raise SystemExit(
+            "[check] invalid workspace.metadata.rust-starter.source_files.max_lines: expected a positive integer"
+        )
+
+    include = load_patterns(
+        raw_policy.get("include"),
+        default=DEFAULT_SOURCE_FILE_INCLUDE,
+        key_path="workspace.metadata.rust-starter.source_files.include",
+        allow_empty=False,
+    )
+    exclude = load_patterns(
+        raw_policy.get("exclude"),
+        default=(),
+        key_path="workspace.metadata.rust-starter.source_files.exclude",
+        allow_empty=True,
+    )
+    return SourceFilePolicy(max_lines, include, exclude)
+
+
+def run(name: str, argv: Command) -> None:
+    print(f"[check] {name}: {' '.join(argv)}", flush=True)
+    proc = subprocess.run(argv, cwd=ROOT)
+    if proc.returncode != 0:
+        raise SystemExit(proc.returncode)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Thin Rust starter check runner")
+    parser.add_argument(
+        "mode",
+        nargs="?",
+        choices=("check", "verify", "deep", "fix", "canon"),
+        default="check",
+        help=(
+            "Run canonicalization plus the fast gate, run a non-mutating verification gate, "
+            "include docs for the deep gate, or run only canonicalization."
+        ),
+    )
+    return parser.parse_args()
+
+
+def run_command_sequence(name: str, commands: CommandSequence) -> None:
+    for index, command in enumerate(commands, start=1):
+        run(f"{name}.{index}", command)
+
+
+def matches_pattern(path: PurePosixPath, pattern: str) -> bool:
+    if path.match(pattern):
+        return True
+    prefix = "**/"
+    return pattern.startswith(prefix) and path.match(pattern.removeprefix(prefix))
+
+
+def iter_source_files(policy: SourceFilePolicy) -> list[Path]:
+    paths: list[Path] = []
+    for current_root, dirnames, filenames in os.walk(ROOT):
+        dirnames[:] = sorted(name for name in dirnames if name not in IGNORED_SOURCE_DIRS)
+        current = Path(current_root)
+        for filename in filenames:
+            path = current / filename
+            relative_path = PurePosixPath(path.relative_to(ROOT).as_posix())
+            if not any(matches_pattern(relative_path, pattern) for pattern in policy.include):
+                continue
+            if any(matches_pattern(relative_path, pattern) for pattern in policy.exclude):
+                continue
+            paths.append(path)
+    return sorted(paths)
+
+
+def line_count(path: Path) -> int:
+    return len(path.read_text(encoding="utf-8").splitlines())
+
+
+def enforce_source_file_policy(policy: SourceFilePolicy) -> None:
+    paths = iter_source_files(policy)
+    print(f"[check] source-files: max {policy.max_lines} lines", flush=True)
+    violations: list[tuple[str, int]] = []
+    for path in paths:
+        lines = line_count(path)
+        if lines > policy.max_lines:
+            violations.append((path.relative_to(ROOT).as_posix(), lines))
+    if not violations:
+        return
+
+    print(
+        f"[check] source-files: {len(violations)} file(s) exceed the configured limit",
+        flush=True,
+    )
+    for relative_path, lines in violations:
+        print(f"[check] source-files: {relative_path}: {lines} lines", flush=True)
+    raise SystemExit(1)
+
+
+def main() -> None:
+    metadata = load_workspace_metadata()
+    commands = load_commands(metadata)
+    source_file_policy = load_source_file_policy(metadata)
+    args = parse_args()
+
+    if args.mode in {"fix", "canon"}:
+        run_command_sequence("canonicalize", commands["canonicalize_commands"])
+        return
+
+    enforce_source_file_policy(source_file_policy)
+    if args.mode != "verify":
+        run_command_sequence("canonicalize", commands["canonicalize_commands"])
+
+    run("fmt", commands["format_command"])
+    run("clippy", commands["clippy_command"])
+    run("test", commands["test_command"])
+
+    if args.mode == "deep" and "doc_command" in commands:
+        run("doc", commands["doc_command"])
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        raise SystemExit(130)