Raven-1/scripts/check_commit_messages.py
zhanghui b91abe5e09
ci(*): keep commit lint off the default branch's history (#531)
## Summary

A pull request whose base is not the default branch carries, in its
`BASE..HEAD` range, every commit the default branch has gained since the
two
diverged. Both commit linters read that range, so they re-read history
that
already passed this gate when it landed and that nobody can rewrite now.

#529 is the case that surfaced it: merging `main` into
`refactor/ui_web_architecture` puts 38 `main` commits in range, one of
which
(`b01534d0`, #471) carries a `Co-authored-by` trailer with a non-ASCII
name.
The gate reports that PR red for a message it did not write. The same
will
happen to every future catch-up merge.

`scripts/check_commit_messages.py` now takes several revision arguments
and
passes them to `git log`, so a caret exclusion works. Commitlint has no
equivalent flag, so the workflow iterates the same revision list and
lints one
message at a time. On a pull request the workflow excludes the
repository's
default branch; a push to the default branch is unchanged and still
lints what
it pushed.

This does not touch the offending commit on `main` and does not relax a
rule:
a commit that a PR actually introduces is linted exactly as before.

## Type

- [ ] Fix
- [ ] Feature
- [ ] Docs
- [x] CI / tooling
- [ ] Refactor
- [ ] Other

## Verification

`uv run pytest tests/test_check_commit_messages.py
tests/test_commit_lint.py -q`
-- 15 passed. Three of those cases are new and cover a repo where the
default
branch carries a rejected message and the feature branch merges it in:
the
range fails without an exclusion, passes with one, and still fails when
the
bad commit is the branch's own.

Mutation check on the new cases: replacing `_commit_messages(args)` with
`_commit_messages(args[:1])`, which is the behaviour before this change,
turns
`test_excluding_the_default_branch_skips_the_history_it_carries` red and
leaves
the other three green. The pin fails when the fix is removed.

Against the real history behind #529, with the checker run directly:

- `check_commit_messages.py "bc74bf73..a0666244c"` -- exit 1, naming
  `b01534d02` exactly as CI does.
- the same range plus `^github/main` -- exit 0.

The workflow's new loop was run as written against both ranges: 0
commits to
lint on the catch-up range, and a planted `Update stuff.` commit on a
feature
branch still sets the failure flag.

`make lint-python` -- clean. `scripts/check_source_language.py` over the
branch
-- exit 0; the test's non-ASCII message is built from an escape, so the
file
itself stays ASCII.

- [x] Relevant tests pass locally
- [x] Relevant lint / type checks pass locally
- [ ] User-facing docs or screenshots are updated when needed

## Risk

Commitlint now starts once per commit instead of once per range, so a PR
with
many commits spends a second or so more in this job. The exclusion only
ever
removes commits that are already on the default branch, so nothing a PR
introduces escapes either linter.

Rollback is reverting this PR; the previous behaviour is one range
argument and
one commitlint invocation.

- [x] Security impact considered
- [x] Backward compatibility considered
- [x] Rollback path is clear for risky changes

## Related Issues

N/A. Unblocks the `commit messages` check on #529.

---------

Co-authored-by: gloryfromca <23442919+gloryfromca@users.noreply.github.com>
Co-authored-by: Claude (claude-opus-5) <noreply@anthropic.com>
2026-09-20 15:21:54 +08:00

61 lines
1.7 KiB
Python

"""Lint every commit message a revision range names against the repo's message rules."""
from __future__ import annotations
import os
import subprocess
import sys
from scripts.commit_lint import check_commit_message
ZERO_SHA = "0" * 40
def main(argv: list[str] | None = None) -> int:
args = list(sys.argv[1:] if argv is None else argv)
if not args:
default = _default_range()
if not default:
print("No commit range detected; skipping commit message lint")
return 0
args = [default]
messages = _commit_messages(args)
failed = False
for sha, message in messages:
result = check_commit_message(message)
if result.ok:
continue
failed = True
header = message.strip().splitlines()[0] if message.strip() else "<empty>"
print(f"Invalid commit message {sha}: {header}", file=sys.stderr)
for error in result.errors:
print(f"- {error}", file=sys.stderr)
return 1 if failed else 0
def _default_range() -> str | None:
pr_base = os.environ.get("GITHUB_PR_BASE_SHA", "").strip()
if pr_base:
return f"{pr_base}..HEAD"
before = os.environ.get("GITHUB_EVENT_BEFORE", "").strip()
if before and before != ZERO_SHA:
return f"{before}..HEAD"
return os.environ.get("RANGE", "").strip() or None
def _commit_messages(revisions: list[str]) -> list[tuple[str, str]]:
output = subprocess.check_output(
["git", "log", "--no-merges", "--format=%H%x00%B%x00", *revisions],
text=True,
)
chunks = output.rstrip("\0").split("\0")
return list(zip(chunks[0::2], chunks[1::2]))
if __name__ == "__main__":
raise SystemExit(main())