Files
luxe/scripts/fn-length-check.py
Evan Whittaker 09a7de2520 Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
2026-10-17 12:08:30 -05:00

153 lines
6.4 KiB
Python
Executable File

#!/usr/bin/env python3
"""Function-length ratchet: clippy's `too_many_lines` at the threshold in `clippy.toml` (80).
Runs clippy over the shipped code (`--lib --bins`, so tests and examples are out) with only that
lint on, in its own target directory so it never invalidates the gate's clippy cache. A function
over the threshold fails unless `scripts/fn-length-allowlist.txt` lists it, and then it may not grow
past the number recorded there. The list only shrinks: an entry whose function is back under the
threshold, or shorter than recorded, fails as stale until `--tighten` rewrites it.
`#[async_trait]` rewrites a method's body inside a macro expansion, and clippy does not lint what a
macro produced, so those methods (every `Tool::run`, among others) are measured here instead by
`rust_source`, with the same rule: non-blank, non-comment lines of the body.
Functions are keyed by file and name, since line numbers move. Same-named functions in one file
(two `deserialize` impls, say) share a key and are compared largest to largest.
scripts/fn-length-check.py check
scripts/fn-length-check.py --tighten lower recorded lengths to current, drop what is now short
scripts/fn-length-check.py --report every function over the threshold, longest first
"""
import json
import re
import subprocess
import sys
from collections import defaultdict
from pathlib import Path
import rust_source
ROOT = Path(__file__).resolve().parent.parent
ALLOWLIST = ROOT / "scripts" / "fn-length-allowlist.txt"
LENGTH = re.compile(r"too many lines \((\d+)/(\d+)\)")
NAME = re.compile(r"\bfn\s+(\w+)")
def measure() -> dict[tuple[str, str], list[int]]:
command = [
"cargo", "clippy", "--workspace", "--lib", "--bins", "--quiet",
"--message-format=json", "--target-dir", str(ROOT / "target" / "fn-length"),
"--", "-A", "clippy::all", "-W", "clippy::too_many_lines",
]
run = subprocess.run(command, cwd=ROOT, capture_output=True, text=True)
if run.returncode != 0:
sys.stderr.write(run.stderr)
sys.exit(f"clippy failed ({run.returncode})")
lengths = defaultdict(list)
seen = set()
for line in run.stdout.splitlines():
message = json.loads(line).get("message") if line.startswith("{") else None
if not message or (message.get("code") or {}).get("code") != "clippy::too_many_lines":
continue
span = message["spans"][0]
name = NAME.search(" ".join(text["text"] for text in span["text"]))
length = LENGTH.search(message["message"])
site = (span["file_name"], span["line_start"])
if not (name and length) or site in seen:
continue # a bin and a lib can both report the same function
seen.add(site)
lengths[(span["file_name"], name.group(1))].append(int(length.group(1)))
threshold = int(re.search(r"too-many-lines-threshold\s*=\s*(\d+)", (ROOT / "clippy.toml").read_text()).group(1))
for path in rust_source.rust_files():
if path in rust_source.test_files() or "/examples/" in path:
continue
for name, line, length in rust_source.async_trait_methods(path):
if length > threshold and (path, line) not in seen:
lengths[(path, name)].append(length)
return {key: sorted(values, reverse=True) for key, values in lengths.items()}
def load_allowlist() -> dict[tuple[str, str], tuple[list[int], str]]:
entries = {}
if not ALLOWLIST.exists():
return entries
for raw in ALLOWLIST.read_text().splitlines():
line = raw.strip()
if not line or line.startswith("#"):
continue
body, _, reason = line.partition("#")
sizes, path, name = body.split()
entries[(path, name)] = ([int(size) for size in sizes.split(",")], reason.strip())
return entries
def write_allowlist(entries: dict[tuple[str, str], tuple[list[int], str]]) -> None:
header = [
"# Functions allowed over clippy's too_many_lines threshold. See scripts/fn-length-check.py.",
"# <lines[,lines…]> <path> <fn> # reason",
]
rows = sorted(entries.items(), key=lambda item: (-item[1][0][0], item[0]))
body = [
f"{','.join(map(str, sizes)):>7} {path} {name} # {reason}"
for (path, name), (sizes, reason) in rows
]
ALLOWLIST.write_text("\n".join(header + body) + "\n")
def check() -> int:
measured, allowed = measure(), load_allowlist()
problems = []
for key, sizes in sorted(measured.items()):
where = f"{key[0]}: fn {key[1]}"
if key not in allowed:
problems.append(f"{where} is {sizes[0]} lines, over the threshold: split it")
continue
limit = allowed[key][0]
if len(sizes) > len(limit) or any(now > cap for now, cap in zip(sizes, limit)):
problems.append(f"{where} is {sizes} lines, grew past its allowance of {limit}")
for key, (sizes, _) in sorted(allowed.items()):
now = measured.get(key, [])
if len(now) < len(sizes) or any(n < s for n, s in zip(now, sizes)):
problems.append(f"{key[0]}: fn {key[1]} allowlisted at {sizes}, now {now}: run --tighten")
if problems:
print("function-length check failed:")
print("\n".join(f" {problem}" for problem in problems))
return 1
print(f"function-length check: {sum(map(len, measured.values()))} over the threshold, all allowlisted")
return 0
def tighten() -> int:
measured, allowed = measure(), load_allowlist()
kept = {}
for key, (sizes, reason) in allowed.items():
now = measured.get(key, [])
if now:
kept[key] = ([min(n, s) for n, s in zip(now, sizes)] + now[len(sizes):], reason)
write_allowlist(kept)
print(f"allowlist: {len(allowed)} -> {len(kept)} entries")
return 0
def report() -> int:
flat = [(size, path, name) for (path, name), sizes in measure().items() for size in sizes]
for size, path, name in sorted(flat, reverse=True):
print(f"{size:>5} {path} {name}")
return 0
def freeze() -> int:
"""Seed the allowlist with everything over the threshold today. Used once."""
write_allowlist({key: (sizes, "baseline") for key, sizes in measure().items()})
return 0
if __name__ == "__main__":
command = sys.argv[1] if len(sys.argv) > 1 else "--check"
actions = {"--check": check, "--tighten": tighten, "--report": report, "--freeze": freeze}
if command not in actions:
print(__doc__)
sys.exit(2)
sys.exit(actions[command]())