Partially switch to atomic multi-branch push

Pull Request: #29 (main)

Author: dimikot

git-grok

@@ -86,6 +86,15 @@ class Pr:
     labels: list[str]
 
 
+#
+# A pair of commit hash and branch name.
+#
+@dataclass
+class Branch:
+    hash: str
+    branch: str
+
+
 #
 # Some data passed from the main process to each individual child process call
 # within "git rebase -i", for each commit in the stack.
@@ -228,8 +237,8 @@ class Main:
                     commit_with_no_url = commit
                     break
                 else:
-                    # Push this branch and see whether GitHub says whether it
-                    # was up to date or not.
+                    # Push this branch and see whether GitHub says that it was
+                    # up to date or not.
                     commit_hashes_to_push_branch.append(commit.hash)
 
         # Some commits have no related PRs (no GitHub URLs in the message)?
@@ -261,6 +270,11 @@ class Main:
     # Runs the sync for only the top commit. This is an internal command which
     # is used during interactive rebase.
     #
+    # This workflow runs only when the tool finds a commit that has no PR URL in
+    # its description yet. If all commits have existing PR URLs (including the
+    # case when they were reordered), the interactive rebase workflow is not
+    # run; instead, the branches are just pushed, and the PRs are updated.
+    #
     def run_in_rebase_interactive(self, *, data: InRebaseInteractiveData):
         remote_commit = self.git_get_commits(
             latest_ref=f"remotes/{self.remote}/{self.remote_base_branch}",
@@ -273,23 +287,33 @@ class Main:
 
         self.print_header(f"Processing commit: {self.clean_title(commit.title)}")
 
+        to_push: list[Branch] = []
         if prev_commit.hash != remote_commit.hash:
-            prev_commit, result = self.process_commit_push_branch(commit=prev_commit)
+            prev_commit.branch = self.process_commit_infer_branch(commit=prev_commit)
+            to_push.append(Branch(hash=prev_commit.hash, branch=prev_commit.branch))
+        commit.branch = self.process_commit_infer_branch(commit=commit)
+        to_push.append(Branch(hash=commit.hash, branch=commit.branch))
+
+        push_results = self.git_push_branches(branches=to_push)
+
+        if prev_commit.branch in push_results:
             self.print_branch_result(
                 type="base",
-                branch=str(prev_commit.branch),
-                result=result,
+                branch=prev_commit.branch,
+                result=push_results[prev_commit.branch],
             )
         else:
             self.print_branch_result(
                 type="base",
                 branch=self.remote_base_branch,
                 result="up-to-date",
             )
-            prev_commit.branch = None
 
-        commit, result = self.process_commit_push_branch(commit=commit)
-        self.print_branch_result(type="head", branch=str(commit.branch), result=result)
+        self.print_branch_result(
+            type="head",
+            branch=commit.branch,
+            result=push_results[commit.branch],
+        )
 
         new_pr_title = commit.title
         new_pr_body = None
@@ -430,18 +454,38 @@ class Main:
         # We must iterate from the oldest commit to the newest one, because
         # previous commit PR's branch becomes the next commit PR's base branch.
         commits_old_to_new = list(reversed(commits))
+
+        # Collect commits/branches that need to be pushed.
+        to_push: dict[str, Branch] = {}
+        for commit in commits_old_to_new:
+            if (
+                self.debug_force_push_branches
+                or commit.hash in commit_hashes_to_push_branch
+            ):
+                commit.branch = self.process_commit_infer_branch(commit=commit)
+                to_push[commit.branch] = Branch(hash=commit.hash, branch=commit.branch)
+
+        push_results: dict[str, BranchPushResult] = {}
+
         for i, commit in enumerate(commits_old_to_new):
             self.print_header(f"Updating PR: {self.clean_title(commit.title)}")
 
-            if commit.hash in commit_hashes_to_push_branch:
-                commit, result = self.process_commit_push_branch(commit=commit)
-                if result == "pushed":
-                    self.print_branch_result(
-                        type="head",
-                        branch=str(commit.branch),
-                        result=result,
-                    )
-                commits_old_to_new[i] = commit
+            # Push branches sequentially, one by one, not in bulk. This is
+            # because when bulk-pushing after local commits reordering, GitHub
+            # may mark some PRs as merged and close them (this behavior is
+            # covered with a unit test).
+            if commit.branch in to_push:
+                push_results.update(
+                    self.git_push_branches(branches=[to_push[commit.branch]])
+                )
+
+            result = push_results.get(str(commit.branch), None)
+            if result == "pushed":
+                self.print_branch_result(
+                    type="head",
+                    branch=str(commit.branch),
+                    result=result,
+                )
 
             pr, result = self.process_update_pr(
                 prev_commit=commits_old_to_new[i - 1] if i > 0 else None,
@@ -456,24 +500,23 @@ class Main:
             commits_old_to_new[i].branch = pr.head_branch
 
     #
-    # Pushes an existing branch (it we know this commit's PR URL by querying
-    # GitHub), or creates a new branch based on commit title and pushes it.
+    # For a commit, infers its corresponding remote branch name by either
+    # querying it from the PR (when commit.url is set), or by building it from
+    # the commit title and hash.
     #
-    def process_commit_push_branch(
+    def process_commit_infer_branch(
         self,
         *,
         commit: Commit,
-    ) -> tuple[Commit, BranchPushResult]:
+    ) -> str:
         if commit.url:
-            pr = self.gh_get_pr(url=commit.url)
-            commit.branch = pr.head_branch
+            pr = self.gh_get_pr(url=commit.url)  # likely a cache hit
+            return pr.head_branch
         else:
-            commit.branch = self.build_branch_name(
+            return self.build_branch_name(
                 title=commit.title,
                 commit_hash=commit.hash,
             )
-        pushed = self.git_push_branch(branch=commit.branch, hash=commit.hash)
-        return commit, pushed
 
     #
     # Updates PR fields:
@@ -796,6 +839,8 @@ class Main:
     # Returns parsed commits between two refs in reverse-chronological order
     # (newest commits first, oldest last, as they're shown in "git log").
     #
+    # The returned commits will have branch = None, since it's unknown yet.
+    #
     def git_get_commits(
         self,
         *,
@@ -860,9 +905,16 @@ class Main:
         return commits
 
     #
-    # Pushes a branch to remote GitHub.
+    # Pushes multiple branches atomically to remote GitHub. Returns a dict
+    # mapping branch names to their push results.
     #
-    def git_push_branch(self, *, branch: str, hash: str) -> BranchPushResult:
+    def git_push_branches(
+        self,
+        *,
+        branches: list[Branch],
+    ) -> dict[str, BranchPushResult]:
+        if not branches:
+            return {}
         # Git push is a quick no-op on GitHub end if the branch isn't changed
         # (it prints "Everything up-to-date"), so we always push and then verify
         # the output for the status (instead of fetching from the remote and
@@ -873,15 +925,26 @@ class Main:
                 "push",
                 "-f",
                 self.remote,
-                f"{hash}:refs/heads/{branch}",
+                *[f"{branch.hash}:refs/heads/{branch.branch}" for branch in branches],
             ],
             stderr_to_stdout=True,
         )
-        return (
-            "up-to-date"
-            if re.match(r"^[^\n]+up-to-date", out, flags=re.S)
-            else "pushed"
-        )
+        # If the hash is NOT mentioned in the output, it's either a short
+        # "Everything up-to-date" message (which means that ALL branches are
+        # unchanged), or THIS particular branch is up-to-date. I.e. if a branch
+        # is changed, git always prints its hash in the output, on one of the
+        # following formats:
+        # 1. * [new branch] 10dc4f6 -> grok/...
+        # 2. + 10dc4f6...b28d03e 10dc4f6 -> grok/... (forced update)
+        results: dict[str, BranchPushResult] = {
+            branch.branch: "up-to-date" for branch in branches
+        }
+        for branch in branches:
+            for line in out.splitlines():
+                if branch.hash in line:
+                    results[branch.branch] = "pushed"
+                    break
+        return results
 
     #
     # Runs an interactive rebase with the provided shell command.