Answer product-owner round 1: 1 🔴, 2 🟡 (0 misread); count a pull request the forge reports merged by any method, check the worktree and main checkout before acting, remove todo items before the merge
This commit is contained in:
+1
-1
@@ -2,7 +2,7 @@
|
||||
|
||||
## Unreleased
|
||||
|
||||
- `chunk-pr clean` removes a merged chunk's worktree and branch and fast-forwards the main checkout, which it leaves as it was, saying why, while that is dirty or on another branch.
|
||||
- `chunk-pr clean` removes a merged chunk's worktree and local branch and fast-forwards the main checkout. It leaves a main checkout with uncommitted files, another branch or commits of its own as it was, and says why.
|
||||
- `review-replay` now replays each round at the commit with the newest author time at or before the round's time, and takes the clone's base the same way by the time the chunk began. It took the first such commit in log order, so a commit authored early but merged late, such as a dependency bump, could win over the commits the round reviewed.
|
||||
- The shared goal every project pursues, code health, now asks that code stay easy to read, change safely and debug, tomorrow and after seven years of development.
|
||||
- `rank_todo.py` now lets an item that adds a test, a gate leg or a probe name the maintain goal it guards, by how much more confident the project becomes that the goal holds, 1 to 10. Each point is worth 0.5.
|
||||
|
||||
+113
-53
@@ -1,4 +1,4 @@
|
||||
"""Open the chunk's pull request as a draft, mark it ready, or merge it, with gh where origin is on GitHub and tea elsewhere; then clean up after it.
|
||||
"""Open the chunk's pull request as a draft, mark it ready, or merge it, with gh where origin is on GitHub and tea elsewhere; once it has merged, remove the chunk's worktree and branch.
|
||||
|
||||
usage: chunk-pr open <title> [<body>]
|
||||
chunk-pr ready
|
||||
@@ -19,22 +19,26 @@ merge merges the pull request, and only while its head is still the commit ch
|
||||
a merge commit, fast-forward only, a rebase followed by a merge commit, a rebase, a squash.
|
||||
GitHub offers only the merge commit, the rebase and the squash. --gate-passed says the
|
||||
merge gate passed on that commit; without it, chunk-pr refuses.
|
||||
clean fetches origin and, once origin's default branch holds the commit checked out, removes
|
||||
the chunk's worktree and its branch, then fast-forwards the main checkout to origin's
|
||||
default branch. It leaves the main checkout as it was where that has uncommitted or
|
||||
untracked files or another branch checked out, and fails saying so: a dirty checkout is
|
||||
for its owner to look at. A worktree with uncommitted changes git keeps, branch and all.
|
||||
clean acts once the forge reports the branch's pull request merged at the commit checked out,
|
||||
by any merge method. It fetches origin, fast-forwards the main checkout to origin's
|
||||
default branch, removes the chunk's worktree, then deletes the local branch; origin's
|
||||
branch stays. Where the worktree has uncommitted or untracked files, it refuses and
|
||||
touches nothing. Where the main checkout has uncommitted or untracked files, another
|
||||
branch checked out, or commits origin's default branch lacks, it leaves that as it was,
|
||||
still removes the worktree and the branch, and fails saying why.
|
||||
|
||||
It prints what it did, exit 0, or why it failed, exit 1.
|
||||
"""
|
||||
import dataclasses
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import typing
|
||||
|
||||
from failure import Failure
|
||||
from chunk_preflight.gathered import Forge
|
||||
from chunk_preflight.choices import forge_of
|
||||
from deploy_release.forge import gitea, open_pull, Run, runner
|
||||
from deploy_release.forge import gitea, merged_pull, open_pull, Run, runner
|
||||
|
||||
USAGE = "usage: chunk-pr open <title> [<body>] | chunk-pr ready | chunk-pr merge --gate-passed | chunk-pr clean"
|
||||
|
||||
@@ -75,16 +79,30 @@ def step(argv: list[str], run: Run) -> str | Failure:
|
||||
return Failure(USAGE)
|
||||
|
||||
|
||||
def answers(run: Run, *commands: list[str]) -> list[str] | Failure:
|
||||
"""What each git command printed, stripped, or the first Failure."""
|
||||
answered = [run(["git", *args]) for args in commands]
|
||||
failed = next((answer for answer in answered if isinstance(answer, Failure)), None)
|
||||
return failed if failed is not None else [str(answer).strip() for answer in answered]
|
||||
|
||||
|
||||
def checkout(run: Run) -> tuple[Forge, str, str] | Failure:
|
||||
"""The forge, the branch checked out and its head commit."""
|
||||
answers = [run(["git", *args]) for args in (["remote", "get-url", "origin"], ["symbolic-ref", "--short", "HEAD"], ["rev-parse", "HEAD"])]
|
||||
failed = next((answer for answer in answers if isinstance(answer, Failure)), None)
|
||||
if failed is not None:
|
||||
return failed
|
||||
origin, branch, head = (str(answer).strip() for answer in answers)
|
||||
found = answers(run, ["remote", "get-url", "origin"], ["symbolic-ref", "--short", "HEAD"], ["rev-parse", "HEAD"])
|
||||
if isinstance(found, Failure):
|
||||
return found
|
||||
origin, branch, head = found
|
||||
return forge_of(origin), branch, head
|
||||
|
||||
|
||||
def default_branch(run: Run) -> str | Failure:
|
||||
"""origin's default branch, such as main."""
|
||||
default = run(["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"])
|
||||
if isinstance(default, Failure):
|
||||
return Failure(f"origin records no default branch; set it with `git remote set-head origin --auto`: {default.reason}")
|
||||
return default.strip().removeprefix("origin/")
|
||||
|
||||
|
||||
def pull(run: Run) -> tuple[Forge, str, str] | Failure:
|
||||
"""The forge, the number of the branch's open pull request at its head, and that head."""
|
||||
found = checkout(run)
|
||||
@@ -102,10 +120,9 @@ def opened(title: str, body: str, run: Run) -> str | Failure:
|
||||
if isinstance(found, Failure):
|
||||
return found
|
||||
forge, branch, head = found
|
||||
default = run(["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"])
|
||||
if isinstance(default, Failure):
|
||||
return Failure(f"origin records no default branch; set it with `git remote set-head origin --auto`: {default.reason}")
|
||||
base = default.strip().removeprefix("origin/")
|
||||
base = default_branch(run)
|
||||
if isinstance(base, Failure):
|
||||
return base
|
||||
if branch == base:
|
||||
return Failure(f"{branch} is origin's default branch; open the pull request from the chunk's branch")
|
||||
pushed = run(["git", "push", "--quiet", "--set-upstream", "origin", branch])
|
||||
@@ -166,50 +183,93 @@ def merge_method(forge: Forge, run: Run) -> str | Failure:
|
||||
return allowed if allowed is not None else Failure(f"the repository allows none of the merge methods chunk-pr knows: {', '.join(method for _, method in METHODS[forge])}")
|
||||
|
||||
|
||||
def cleaned(run: Run) -> str | Failure:
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class Chunk:
|
||||
"""A merged chunk's worktree and branch, the main checkout of their repository, and origin's default branch."""
|
||||
worktree: str
|
||||
branch: str
|
||||
main: str
|
||||
default: str
|
||||
|
||||
|
||||
def cleaned(run: Run, at: typing.Callable[[str], Run] = runner) -> str | Failure:
|
||||
"""Remove the worktree and branch of the merged chunk run is in, and fast-forward the main checkout; at(folder) runs commands in folder, here the main checkout."""
|
||||
chunk = merged_chunk(run)
|
||||
if isinstance(chunk, Failure):
|
||||
return chunk
|
||||
at_main = at(chunk.main)
|
||||
left = kept_as_it_was(at_main, chunk.default)
|
||||
files = unsaved(run)
|
||||
if isinstance(files, Failure):
|
||||
return files
|
||||
if files:
|
||||
also = f"\nIt would also have left {chunk.main} as it was: {left}" if left else ""
|
||||
return Failure(f"left everything as it was: {chunk.worktree} has uncommitted or untracked files:\n{files}{also}")
|
||||
return removed(chunk, at_main, left)
|
||||
|
||||
|
||||
def merged_chunk(run: Run) -> Chunk | Failure:
|
||||
"""The chunk run is in, once the forge reports its pull request merged at its head. It fetches origin, so the main checkout can fast-forward to the merge."""
|
||||
found = checkout(run)
|
||||
if isinstance(found, Failure):
|
||||
return found
|
||||
_, branch, head = found
|
||||
answers = [run(["git", *args]) for args in (["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], ["worktree", "list", "--porcelain"], ["rev-parse", "--show-toplevel"])]
|
||||
failed = next((answer for answer in answers if isinstance(answer, Failure)), None)
|
||||
if failed is not None:
|
||||
return failed
|
||||
base, listed, worktree = (str(answer).strip() for answer in answers)
|
||||
forge, branch, head = found
|
||||
default = default_branch(run)
|
||||
if isinstance(default, Failure):
|
||||
return default
|
||||
folders = worktree_and_main(run)
|
||||
if isinstance(folders, Failure):
|
||||
return folders
|
||||
number = merged_pull(forge, branch, head, run)
|
||||
if number is None:
|
||||
return Failure(f"no merged pull request from {branch} at {head[:12]}, so its worktree and branch stay")
|
||||
fetched = number if isinstance(number, Failure) else run(["git", "fetch", "--quiet", "origin"])
|
||||
return fetched if isinstance(fetched, Failure) else Chunk(folders[0], branch, folders[1], default)
|
||||
|
||||
|
||||
def worktree_and_main(run: Run) -> tuple[str, str] | Failure:
|
||||
"""The worktree run is in, and the main checkout of its repository. Run in the main checkout itself, it fails."""
|
||||
folders = answers(run, ["rev-parse", "--show-toplevel"], ["worktree", "list", "--porcelain"])
|
||||
if isinstance(folders, Failure):
|
||||
return folders
|
||||
# git lists the main checkout first.
|
||||
main = listed.splitlines()[0].removeprefix("worktree ")
|
||||
if worktree == main:
|
||||
return Failure(f"{main} is the main checkout; run clean in the chunk's worktree")
|
||||
fetched = run(["git", "fetch", "--quiet", "origin"])
|
||||
if isinstance(fetched, Failure):
|
||||
return fetched
|
||||
if isinstance(run(["git", "merge-base", "--is-ancestor", head, base]), Failure):
|
||||
return Failure(f"{base} doesn't hold {head[:12]}: {branch} is not merged, so its worktree and branch stay")
|
||||
at_main = runner(main)
|
||||
left = kept_as_it_was(at_main, base.removeprefix("origin/"))
|
||||
if left is None:
|
||||
forwarded = at_main(["git", "merge", "--quiet", "--ff-only", base])
|
||||
if isinstance(forwarded, Failure):
|
||||
return forwarded
|
||||
removed = at_main(["git", "worktree", "remove", worktree])
|
||||
if isinstance(removed, Failure):
|
||||
return removed
|
||||
# Not -d: the check above already found the branch merged, and -d would compare it with the main checkout's HEAD or a stale upstream instead.
|
||||
deleted = at_main(["git", "branch", "--quiet", "-D", branch])
|
||||
if isinstance(deleted, Failure):
|
||||
return deleted
|
||||
done = f"Removed worktree {worktree} and branch {branch}"
|
||||
if left is not None:
|
||||
return Failure(f"{done}, but left {main} as it was: {left}")
|
||||
return f"{done}, and fast-forwarded {main} to {base}."
|
||||
worktree, main = folders[0], folders[1].splitlines()[0].removeprefix("worktree ")
|
||||
return Failure(f"{main} is the main checkout; run clean in the chunk's worktree") if worktree == main else (worktree, main)
|
||||
|
||||
|
||||
def unsaved(run: Run) -> str | Failure:
|
||||
"""The uncommitted and untracked files of the checkout run is in, as git status lists them; empty where there are none."""
|
||||
status = run(["git", "status", "--porcelain"])
|
||||
return status if isinstance(status, Failure) else status.rstrip()
|
||||
|
||||
|
||||
def kept_as_it_was(at_main: Run, default: str) -> str | None:
|
||||
"""Why the main checkout must not move, or None where it may fast-forward."""
|
||||
"""Why the main checkout must not move, or None where it may fast-forward to origin's default."""
|
||||
branch = at_main(["git", "symbolic-ref", "--quiet", "--short", "HEAD"])
|
||||
if isinstance(branch, Failure) or branch.strip() != default:
|
||||
return f"it has {'no branch' if isinstance(branch, Failure) else branch.strip()} checked out, not {default}"
|
||||
status = at_main(["git", "status", "--porcelain"])
|
||||
if isinstance(status, Failure):
|
||||
return status.reason
|
||||
return f"it has uncommitted or untracked files:\n{status.rstrip()}" if status.strip() else None
|
||||
files = unsaved(at_main)
|
||||
if isinstance(files, Failure):
|
||||
return files.reason
|
||||
if files:
|
||||
return f"it has uncommitted or untracked files:\n{files}"
|
||||
if isinstance(at_main(["git", "merge-base", "--is-ancestor", "HEAD", f"origin/{default}"]), Failure):
|
||||
return f"it holds commits origin/{default} lacks"
|
||||
return None
|
||||
|
||||
|
||||
def removed(chunk: Chunk, at_main: Run, left: str | None) -> str | Failure:
|
||||
"""Fast-forward the main checkout unless left says why not, then remove the chunk's worktree and branch. Every command runs in the main checkout, since the worktree is gone after the removal."""
|
||||
if left is None:
|
||||
forwarded = at_main(["git", "merge", "--quiet", "--ff-only", f"origin/{chunk.default}"])
|
||||
if isinstance(forwarded, Failure):
|
||||
return forwarded
|
||||
removal = at_main(["git", "worktree", "remove", chunk.worktree])
|
||||
# Not -d: merged_chunk found the forge's pull request merged at the branch's head. -d would compare the branch with the main checkout's HEAD or its upstream instead, and after a rebase or squash merge neither need hold its commits.
|
||||
deleted = removal if isinstance(removal, Failure) else at_main(["git", "branch", "--quiet", "-D", chunk.branch])
|
||||
if isinstance(deleted, Failure):
|
||||
return deleted
|
||||
done = f"Removed worktree {chunk.worktree} and branch {chunk.branch}"
|
||||
if left is not None:
|
||||
return Failure(f"{done}, but left {chunk.main} as it was: {left}")
|
||||
return f"{done}, and fast-forwarded {chunk.main} to origin/{chunk.default}."
|
||||
|
||||
+129
-51
@@ -7,9 +7,10 @@ import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from chunk_pr.main import cleaned, step
|
||||
from failure import Failure
|
||||
from test_env import isolated_env
|
||||
from chunk_pr.main import step
|
||||
from deploy_release.forge import Run
|
||||
|
||||
TOOL = pathlib.Path(__file__).resolve().parents[1] / "chunk-pr"
|
||||
GITHUB = "git@github.com:me/project.git"
|
||||
@@ -174,21 +175,31 @@ class Merge(unittest.TestCase):
|
||||
|
||||
|
||||
class Clean(unittest.TestCase):
|
||||
"""A real origin whose default branch is main, its clone project, and the worktree project-item-7 on item-7, one commit ahead and pushed."""
|
||||
"""A real bare repository origin whose default branch is main; the clone project of it; and the worktree project-item-7 on branch item-7, one commit ahead of main and pushed.
|
||||
|
||||
cleaned runs git for real, but the forge is faked: origin's URL reads as GitHub's, or Gitea's where self.url says so, and pull request #12 from item-7 is merged at self.merged_at where that is set."""
|
||||
|
||||
def setUp(self):
|
||||
folder = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(folder.cleanup)
|
||||
root = pathlib.Path(folder.name)
|
||||
self.origin, self.project, self.worktree = root / "origin.git", root / "project", root / "project-item-7"
|
||||
self.origin, self.project, self.worktree, self.forge_clone = root / "origin.git", root / "project", root / "project-item-7", root / "forge"
|
||||
self.git(root, "init", "--quiet", "--bare", "--initial-branch=main", str(self.origin))
|
||||
self.git(root, "clone", "--quiet", str(self.origin), str(self.project))
|
||||
self.commit(self.project, "first")
|
||||
self.git(self.project, "push", "--quiet", "origin", "main")
|
||||
self.git(self.project, "remote", "set-head", "origin", "--auto")
|
||||
self.git(self.project, "worktree", "add", "--quiet", "-b", "item-7", str(self.worktree), "origin/main")
|
||||
(self.worktree / "chunk.txt").write_text("the chunk\n")
|
||||
self.git(self.worktree, "add", "chunk.txt")
|
||||
self.commit(self.worktree, "the chunk")
|
||||
self.git(self.worktree, "push", "--quiet", "--set-upstream", "origin", "item-7")
|
||||
self.head = self.git(self.worktree, "rev-parse", "HEAD")
|
||||
self.before = self.git(self.project, "rev-parse", "HEAD")
|
||||
self.url = GITHUB
|
||||
self.merged_at: str | None = None
|
||||
# The forge merges in a clone of its own, so the project's origin/main stays stale until clean fetches.
|
||||
self.git(root, "clone", "--quiet", str(self.origin), str(self.forge_clone))
|
||||
|
||||
def git(self, folder: pathlib.Path, *args: str) -> str:
|
||||
return subprocess.run(["git", "-c", "user.name=Test", "-c", "user.email=test@example.org", *args], cwd=folder, check=True, capture_output=True, encoding="utf-8", env=isolated_env()).stdout.strip()
|
||||
@@ -196,68 +207,127 @@ class Clean(unittest.TestCase):
|
||||
def commit(self, folder: pathlib.Path, message: str):
|
||||
self.git(folder, "commit", "--quiet", "--allow-empty", "-m", message)
|
||||
|
||||
def merge_on_origin(self):
|
||||
self.git(self.worktree, "push", "--quiet", "origin", "item-7:main")
|
||||
def merge_commit_on_origin(self) -> str:
|
||||
self.git(self.forge_clone, "fetch", "--quiet", "origin", "item-7")
|
||||
self.git(self.forge_clone, "merge", "--quiet", "--no-ff", "-m", "Merge item-7", "FETCH_HEAD")
|
||||
return self.publish()
|
||||
|
||||
def clean(self) -> subprocess.CompletedProcess:
|
||||
return subprocess.run([str(TOOL), "clean"], cwd=self.worktree, capture_output=True, encoding="utf-8", env=isolated_env())
|
||||
def rebase_on_origin(self) -> str:
|
||||
"""Put the chunk's change on origin's main as another commit, as a rebase or a squash merge does."""
|
||||
(self.forge_clone / "chunk.txt").write_text("the chunk\n")
|
||||
self.git(self.forge_clone, "add", "chunk.txt")
|
||||
self.commit(self.forge_clone, "the chunk, rebased")
|
||||
return self.publish()
|
||||
|
||||
def publish(self) -> str:
|
||||
self.git(self.forge_clone, "push", "--quiet", "origin", "main")
|
||||
self.merged_at = self.head
|
||||
return self.git(self.forge_clone, "rev-parse", "HEAD")
|
||||
|
||||
def at(self, folder: str) -> Run:
|
||||
def run(command: list[str]) -> str | Failure:
|
||||
if command == ["git", "remote", "get-url", "origin"]:
|
||||
return f"{self.url}\n"
|
||||
if command == ["gh", "pr", "list", "--head", "item-7", "--state", "merged", *GH_LIST[5:]] and self.url == GITHUB:
|
||||
return f"12\t{self.merged_at}\tfalse\n" if self.merged_at else ""
|
||||
if command == ["tea", "api", "repos/{owner}/{repo}/pulls?state=closed&limit=50"] and self.url == GITEA:
|
||||
return json.dumps([{"number": 12, "merged": self.merged_at is not None, "head": {"ref": "item-7", "sha": self.merged_at or self.head, "repo": {"full_name": "me/project"}}, "base": {"repo": {"full_name": "me/project"}}}])
|
||||
if command[0] != "git":
|
||||
return Failure(f"the fake forge doesn't answer {command}")
|
||||
done = subprocess.run(command, cwd=folder, capture_output=True, encoding="utf-8", env=isolated_env())
|
||||
return Failure(f"{' '.join(command[:3])}: {done.stderr.strip()}") if done.returncode else done.stdout
|
||||
return run
|
||||
|
||||
def clean(self, folder: pathlib.Path | None = None) -> str | Failure:
|
||||
return cleaned(self.at(str(folder or self.worktree)), self.at)
|
||||
|
||||
def branches(self) -> list[str]:
|
||||
return self.git(self.project, "branch", "--format=%(refname:short)").splitlines()
|
||||
return sorted(self.git(self.project, "branch", "--format=%(refname:short)").splitlines())
|
||||
|
||||
def test_a_merged_chunk_loses_its_worktree_and_branch_and_the_checkout_fast_forwards(self):
|
||||
self.merge_on_origin()
|
||||
merged = self.git(self.worktree, "rev-parse", "HEAD")
|
||||
done = self.clean()
|
||||
self.assertEqual(done.returncode, 0, done.stderr)
|
||||
self.assertFalse(self.worktree.exists())
|
||||
def assert_kept(self):
|
||||
"""Worktree, branch and main checkout are as setUp left them."""
|
||||
self.assertTrue(self.worktree.exists())
|
||||
self.assertEqual(self.branches(), ["item-7", "main"])
|
||||
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), self.before)
|
||||
|
||||
def test_a_chunk_merged_with_a_merge_commit_loses_its_worktree_and_branch_and_the_checkout_fast_forwards(self):
|
||||
for url in (GITHUB, GITEA):
|
||||
with self.subTest(url):
|
||||
if url == GITEA:
|
||||
self.setUp()
|
||||
self.url = url
|
||||
merged = self.merge_commit_on_origin()
|
||||
self.assertEqual(self.clean(), f"Removed worktree {self.worktree} and branch item-7, and fast-forwarded {self.project} to origin/main.")
|
||||
self.assertFalse(self.worktree.exists())
|
||||
self.assertEqual(self.branches(), ["main"])
|
||||
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), merged)
|
||||
|
||||
def test_a_rebased_chunk_is_cleaned_though_main_lacks_its_commit(self):
|
||||
# Without an upstream, git branch -d would compare item-7 with the main checkout's HEAD, which lacks its commit.
|
||||
self.git(self.project, "branch", "--unset-upstream", "item-7")
|
||||
merged = self.rebase_on_origin()
|
||||
self.assertEqual(self.clean(), f"Removed worktree {self.worktree} and branch item-7, and fast-forwarded {self.project} to origin/main.")
|
||||
self.assertEqual(self.branches(), ["main"])
|
||||
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), merged)
|
||||
self.assertIn("item-7", done.stdout)
|
||||
|
||||
def test_an_unmerged_chunk_keeps_everything(self):
|
||||
done = self.clean()
|
||||
self.assertEqual(done.returncode, 1)
|
||||
self.assertIn("not merged", done.stderr)
|
||||
self.assertTrue(self.worktree.exists())
|
||||
self.assertEqual(sorted(self.branches()), ["item-7", "main"])
|
||||
for url in (GITHUB, GITEA):
|
||||
with self.subTest(url):
|
||||
self.url = url
|
||||
self.assertEqual(self.clean(), Failure(f"no merged pull request from item-7 at {self.head[:12]}, so its worktree and branch stay"))
|
||||
self.assert_kept()
|
||||
|
||||
def test_a_dirty_checkout_is_left_as_it_was_and_reported(self):
|
||||
self.merge_on_origin()
|
||||
before = self.git(self.project, "rev-parse", "HEAD")
|
||||
(self.project / "notes.txt").write_text("mine\n")
|
||||
done = self.clean()
|
||||
self.assertEqual(done.returncode, 1)
|
||||
self.assertIn("uncommitted", done.stderr)
|
||||
self.assertIn(str(self.project), done.stderr)
|
||||
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), before)
|
||||
self.assertEqual((self.project / "notes.txt").read_text(), "mine\n")
|
||||
self.assertFalse(self.worktree.exists())
|
||||
self.assertEqual(self.branches(), ["main"])
|
||||
def test_a_pull_request_merged_at_another_head_keeps_everything(self):
|
||||
self.merge_commit_on_origin()
|
||||
self.merged_at = "0" * 40
|
||||
self.assertIsInstance(self.clean(), Failure)
|
||||
self.assert_kept()
|
||||
|
||||
def test_a_checkout_on_another_branch_is_left_as_it_was_and_reported(self):
|
||||
self.merge_on_origin()
|
||||
self.git(self.project, "switch", "--quiet", "-c", "elsewhere")
|
||||
before = self.git(self.project, "rev-parse", "HEAD")
|
||||
done = self.clean()
|
||||
self.assertEqual(done.returncode, 1)
|
||||
self.assertIn("elsewhere", done.stderr)
|
||||
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), before)
|
||||
self.assertFalse(self.worktree.exists())
|
||||
def test_a_main_checkout_that_cannot_fast_forward_is_left_as_it_was_and_named(self):
|
||||
cases = {
|
||||
"dirty": ("it has uncommitted or untracked files:\n?? notes.txt", lambda: (self.project / "notes.txt").write_text("mine\n")),
|
||||
"on another branch": ("it has elsewhere checked out, not main", lambda: self.git(self.project, "switch", "--quiet", "-c", "elsewhere")),
|
||||
"ahead of origin": ("it holds commits origin/main lacks", lambda: self.commit(self.project, "mine")),
|
||||
}
|
||||
for case, (why, spoil) in cases.items():
|
||||
with self.subTest(case):
|
||||
self.setUp()
|
||||
self.git(self.project, "branch", "--unset-upstream", "item-7")
|
||||
self.merge_commit_on_origin()
|
||||
spoil()
|
||||
before = self.git(self.project, "rev-parse", "HEAD")
|
||||
self.assertEqual(self.clean(), Failure(f"Removed worktree {self.worktree} and branch item-7, but left {self.project} as it was: {why}"))
|
||||
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), before)
|
||||
self.assertFalse(self.worktree.exists())
|
||||
self.assertEqual(self.branches(), ["elsewhere", "main"] if case == "on another branch" else ["main"])
|
||||
|
||||
def test_a_worktree_with_uncommitted_changes_is_kept(self):
|
||||
self.merge_on_origin()
|
||||
def test_a_worktree_with_uncommitted_or_untracked_files_keeps_everything(self):
|
||||
self.merge_commit_on_origin()
|
||||
(self.worktree / "chunk.txt").write_text("changed\n")
|
||||
(self.worktree / "draft.txt").write_text("unsaved\n")
|
||||
done = self.clean()
|
||||
self.assertEqual(done.returncode, 1)
|
||||
self.assertTrue((self.worktree / "draft.txt").exists())
|
||||
self.assertIn("item-7", self.branches())
|
||||
self.assertEqual(self.clean(), Failure(f"left everything as it was: {self.worktree} has uncommitted or untracked files:\n M chunk.txt\n?? draft.txt"))
|
||||
self.assert_kept()
|
||||
self.assertEqual((self.worktree / "draft.txt").read_text(), "unsaved\n")
|
||||
|
||||
def test_a_dirty_worktree_also_reports_a_main_checkout_it_would_have_left(self):
|
||||
self.merge_commit_on_origin()
|
||||
(self.worktree / "draft.txt").write_text("unsaved\n")
|
||||
(self.project / "notes.txt").write_text("mine\n")
|
||||
self.assertEqual(self.clean(), Failure(f"left everything as it was: {self.worktree} has uncommitted or untracked files:\n?? draft.txt\nIt would also have left {self.project} as it was: it has uncommitted or untracked files:\n?? notes.txt"))
|
||||
self.assert_kept()
|
||||
|
||||
def test_the_main_checkout_itself_is_refused(self):
|
||||
done = subprocess.run([str(TOOL), "clean"], cwd=self.project, capture_output=True, encoding="utf-8", env=isolated_env())
|
||||
self.assertEqual(done.returncode, 1)
|
||||
self.assertIn("worktree", done.stderr)
|
||||
self.assertTrue(self.worktree.exists())
|
||||
self.merge_commit_on_origin()
|
||||
self.assertEqual(self.clean(self.project), Failure(f"{self.project} is the main checkout; run clean in the chunk's worktree"))
|
||||
self.assert_kept()
|
||||
|
||||
def test_without_a_default_branch_on_record_it_says_how_to_set_one(self):
|
||||
self.merge_commit_on_origin()
|
||||
self.git(self.project, "remote", "set-head", "origin", "--delete")
|
||||
cleaned_up = self.clean()
|
||||
self.assertIsInstance(cleaned_up, Failure)
|
||||
self.assertTrue(cleaned_up.reason.startswith("origin records no default branch; set it with `git remote set-head origin --auto`: "), cleaned_up)
|
||||
self.assert_kept()
|
||||
|
||||
|
||||
class Launcher(unittest.TestCase):
|
||||
@@ -267,6 +337,14 @@ class Launcher(unittest.TestCase):
|
||||
self.assertEqual((wrong.returncode, wrong.stdout), (1, ""))
|
||||
self.assertIn("usage", wrong.stderr)
|
||||
|
||||
def test_clean_runs_in_the_folder_it_is_started_in(self):
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
for args in (["init", "--quiet"], ["remote", "add", "origin", GITHUB], ["-c", "user.name=Test", "-c", "user.email=test@example.org", "commit", "--quiet", "--allow-empty", "-m", "first"]):
|
||||
subprocess.run(["git", *args], cwd=folder, check=True, env=isolated_env())
|
||||
done = subprocess.run([str(TOOL), "clean"], cwd=folder, capture_output=True, encoding="utf-8", env=isolated_env())
|
||||
self.assertEqual((done.returncode, done.stdout), (1, ""))
|
||||
self.assertTrue(done.stderr.startswith("chunk-pr: origin records no default branch"), done.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -48,18 +48,28 @@ def gitea(run: Run, endpoint: str, *fields: str) -> typing.Any | Failure:
|
||||
|
||||
def open_pull(forge: Forge, branch: str, head: str, run: Run) -> str | None | Failure:
|
||||
"""The number of the open pull request from origin's own branch whose head is head; None where there is none."""
|
||||
return pull_at(forge, branch, head, "open", run)
|
||||
|
||||
|
||||
def merged_pull(forge: Forge, branch: str, head: str, run: Run) -> str | None | Failure:
|
||||
"""The number of the merged pull request from origin's own branch whose head was head; None where there is none. A rebase or a squash merge counts: the pull request keeps the head it had."""
|
||||
return pull_at(forge, branch, head, "merged", run)
|
||||
|
||||
|
||||
def pull_at(forge: Forge, branch: str, head: str, state: typing.Literal["open", "merged"], run: Run) -> str | None | Failure:
|
||||
if forge == "gh":
|
||||
listed = run(["gh", "pr", "list", "--head", branch, "--json", "number,headRefOid,isCrossRepository", "--template", "{{range .}}{{.number}}\t{{.headRefOid}}\t{{.isCrossRepository}}\n{{end}}"])
|
||||
# gh lists the open pull requests unless told another state.
|
||||
listed = run(["gh", "pr", "list", "--head", branch, *(["--state", "merged"] if state == "merged" else []), "--json", "number,headRefOid,isCrossRepository", "--template", "{{range .}}{{.number}}\t{{.headRefOid}}\t{{.isCrossRepository}}\n{{end}}"])
|
||||
if isinstance(listed, Failure):
|
||||
return listed
|
||||
rows = [line.split("\t") for line in listed.splitlines()]
|
||||
return next((row[0] for row in rows if row[1:] == [head, "false"]), None)
|
||||
# Gitea lists at most 50 a page; the pull request sought is among the newest.
|
||||
pulls = gitea(run, "repos/{owner}/{repo}/pulls?state=open&limit=50")
|
||||
# Gitea lists at most 50 a page; the pull request sought is among the newest. Gitea has no merged state: a merged pull request is a closed one marked merged.
|
||||
pulls = gitea(run, f"repos/{{owner}}/{{repo}}/pulls?state={'open' if state == 'open' else 'closed'}&limit=50")
|
||||
if isinstance(pulls, Failure):
|
||||
return pulls
|
||||
try:
|
||||
return next((str(pull["number"]) for pull in pulls if pull["head"]["ref"] == branch and pull["head"]["sha"] == head and pull["head"]["repo"]["full_name"] == pull["base"]["repo"]["full_name"]), None)
|
||||
return next((str(pull["number"]) for pull in pulls if pull["head"]["ref"] == branch and pull["head"]["sha"] == head and pull["head"]["repo"]["full_name"] == pull["base"]["repo"]["full_name"] and (state == "open" or pull["merged"] is True)), None)
|
||||
except (KeyError, TypeError):
|
||||
return Failure(f"tea api listed pull requests in a shape that can't be read: {str(pulls)[:200]}")
|
||||
|
||||
|
||||
@@ -193,9 +193,9 @@ Launch prose-reviewer with what the diff touched and every section this review c
|
||||
|
||||
1. Read the finished PR against the README goals and code health, unless the README voids it: does anything in it work against one? It breaks a maintain goal → do not merge; redesign the change or drop its item. It works against an achieve goal → do not merge; ask the human, stating the conflict.
|
||||
2. Run the comprehension check (§3) where it runs; it runs once. When `origin/<default branch>` moves after that, return to §4, and keep the ruling and scoring run already recorded.
|
||||
3. Aligned, every pass done and everything green → **merge** with `~/.claude/bin/chunk-pr merge --gate-passed`, which takes the first merge method the repository allows on its forge. A repo whose `AGENTS.md` names another method merges that way with the forge's CLI instead. A repo withholds this in its `AGENTS.md` → leave the PR ready and unmerged, and say which line withheld it.
|
||||
4. Merged → remove the chunk's items from `todo.md` per `~/.claude/CLAUDE.md` → "Working loop".
|
||||
5. Run `~/.claude/bin/chunk-pr clean` in the chunk's worktree. It removes the worktree and the branch and fast-forwards the main checkout; a failure it prints, such as a dirty main checkout, goes in the summary.
|
||||
3. Remove the chunk's items from `todo.md` per `~/.claude/CLAUDE.md` → "Working loop" in the branch, commit and push that, and wait for the forge's checks (§4 step 4); the commit re-enters no pass.
|
||||
4. Aligned, every pass done and everything green → **merge** with `~/.claude/bin/chunk-pr merge --gate-passed`, which takes the first merge method the repository allows on its forge. A repo whose `AGENTS.md` names another method merges that way with the forge's CLI instead. A repo withholds this in its `AGENTS.md` → leave the PR ready and unmerged, and say which line withheld it.
|
||||
5. Merged → run `~/.claude/bin/chunk-pr clean` in the chunk's worktree, and put a failure it prints in the summary.
|
||||
6. Stop. The next chunk gets a fresh session.
|
||||
|
||||
## 6. Wrap up
|
||||
|
||||
Reference in New Issue
Block a user