## 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>
121 lines
3.5 KiB
Python
121 lines
3.5 KiB
Python
"""The commit-range linter over a real git repo, merge commits and exclusions included."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
from scripts import check_commit_messages
|
|
|
|
|
|
def _git(cwd: Path, *args: str) -> str:
|
|
env = {
|
|
"GIT_AUTHOR_NAME": "Test",
|
|
"GIT_AUTHOR_EMAIL": "test@example.com",
|
|
"GIT_COMMITTER_NAME": "Test",
|
|
"GIT_COMMITTER_EMAIL": "test@example.com",
|
|
"GIT_CONFIG_GLOBAL": "/dev/null",
|
|
"GIT_CONFIG_SYSTEM": "/dev/null",
|
|
"PATH": os.environ["PATH"],
|
|
}
|
|
return subprocess.check_output(["git", *args], cwd=cwd, text=True, env=env).strip()
|
|
|
|
|
|
def _init_repo(root: Path) -> None:
|
|
_git(root, "init", "-q", "-b", "main")
|
|
(root / "a.txt").write_text("a\n")
|
|
_git(root, "add", "a.txt")
|
|
_git(root, "commit", "-qm", "feat: seed initial file")
|
|
|
|
|
|
def test_range_with_merge_commit_passes(tmp_path: Path) -> None:
|
|
repo = tmp_path / "repo"
|
|
repo.mkdir()
|
|
_init_repo(repo)
|
|
base = _git(repo, "rev-parse", "HEAD")
|
|
|
|
_git(repo, "checkout", "-q", "-b", "feature")
|
|
(repo / "b.txt").write_text("b\n")
|
|
_git(repo, "add", "b.txt")
|
|
_git(repo, "commit", "-qm", "feat: add feature file")
|
|
|
|
_git(repo, "checkout", "-q", "main")
|
|
(repo / "c.txt").write_text("c\n")
|
|
_git(repo, "add", "c.txt")
|
|
_git(repo, "commit", "-qm", "feat: add main file")
|
|
|
|
_git(repo, "checkout", "-q", "feature")
|
|
_git(repo, "merge", "--no-ff", "-m", "Merge branch 'main' into feature", "main")
|
|
|
|
cwd = Path.cwd()
|
|
try:
|
|
os.chdir(repo)
|
|
exit_code = check_commit_messages.main([f"{base}..HEAD"])
|
|
finally:
|
|
os.chdir(cwd)
|
|
|
|
assert exit_code == 0
|
|
|
|
|
|
# Not a literal: this file is under the repo's English-source rule, and the case
|
|
# needs a message that breaks the ASCII rule at runtime.
|
|
_NON_ASCII = "feat: add a file named \u2014 the dash"
|
|
|
|
|
|
def _merge_history(repo: Path) -> str:
|
|
"""main gains one message that fails the gate; feature merges main in."""
|
|
_init_repo(repo)
|
|
base = _git(repo, "rev-parse", "HEAD")
|
|
|
|
_git(repo, "checkout", "-q", "-b", "feature")
|
|
(repo / "b.txt").write_text("b\n")
|
|
_git(repo, "add", "b.txt")
|
|
_git(repo, "commit", "-qm", "feat: add feature file")
|
|
|
|
_git(repo, "checkout", "-q", "main")
|
|
(repo / "c.txt").write_text("c\n")
|
|
_git(repo, "add", "c.txt")
|
|
_git(repo, "commit", "-qm", _NON_ASCII)
|
|
|
|
_git(repo, "checkout", "-q", "feature")
|
|
_git(repo, "merge", "--no-ff", "-m", "Merge branch 'main' into feature", "main")
|
|
return base
|
|
|
|
|
|
def _run(repo: Path, *revisions: str) -> int:
|
|
cwd = Path.cwd()
|
|
try:
|
|
os.chdir(repo)
|
|
return check_commit_messages.main(list(revisions))
|
|
finally:
|
|
os.chdir(cwd)
|
|
|
|
|
|
def test_the_default_branch_history_is_linted_without_an_exclusion(tmp_path: Path) -> None:
|
|
repo = tmp_path / "repo"
|
|
repo.mkdir()
|
|
base = _merge_history(repo)
|
|
|
|
assert _run(repo, f"{base}..HEAD") == 1
|
|
|
|
|
|
def test_excluding_the_default_branch_skips_the_history_it_carries(tmp_path: Path) -> None:
|
|
repo = tmp_path / "repo"
|
|
repo.mkdir()
|
|
base = _merge_history(repo)
|
|
|
|
assert _run(repo, f"{base}..HEAD", "^main") == 0
|
|
|
|
|
|
def test_the_exclusion_still_lints_the_branch_its_own_commits(tmp_path: Path) -> None:
|
|
repo = tmp_path / "repo"
|
|
repo.mkdir()
|
|
base = _merge_history(repo)
|
|
|
|
(repo / "d.txt").write_text("d\n")
|
|
_git(repo, "add", "d.txt")
|
|
_git(repo, "commit", "-qm", _NON_ASCII)
|
|
|
|
assert _run(repo, f"{base}..HEAD", "^main") == 1
|