refactor: extract functions from git_high_level module

Author: nik-rev

src/commands/run.rs

@@ -1,6 +1,7 @@
 //! `run` subcommand
 
-use crate::config::{self, BranchName, Config, PullRequest};
+use crate::config::{self, BranchName, Config, PrNumber, PullRequest};
+use anyhow::Result;
 use std::ffi::OsString;
 use std::fs::{self, File};
 use std::io::Write as _;
@@ -9,7 +10,6 @@ use std::path::PathBuf;
 use anyhow::{anyhow, bail};
 use colored::Colorize as _;
 
-use crate::git_high_level;
 use crate::github::{self, Branch, Remote, RemoteBranch};
 use crate::utils::{format_pr, format_url, with_uuid};
 use crate::{commands, confirm_prompt, git};
@@ -23,7 +23,7 @@ struct FileBackup {
 }
 
 /// Run patchy, if `yes` then there will be no prompt
-pub async fn run(yes: bool, use_gh_cli: bool) -> anyhow::Result<()> {
+pub async fn run(yes: bool, use_gh_cli: bool) -> Result<()> {
     let root = config::ROOT.as_str();
 
     let Ok(config_string) = fs::read_to_string(&*config::FILE_PATH) else {
@@ -114,7 +114,7 @@ pub async fn run(yes: bool, use_gh_cli: bool) -> anyhow::Result<()> {
         },
     };
 
-    git_high_level::add_remote_branch(&info, commit.as_ref())?;
+    github::add_remote_branch(&info, commit.as_ref())?;
 
     // we want to checkout the `branch` of `remote`
     let branch = &info.branch.local_branch_name;
@@ -171,12 +171,9 @@ pub async fn run(yes: bool, use_gh_cli: bool) -> anyhow::Result<()> {
             continue;
         };
 
-        if let Err(err) = git_high_level::merge_pull_request(
-            &info,
-            *pull_request,
-            &response.title,
-            &response.html_url,
-        ) {
+        if let Err(err) =
+            merge_pull_request(&info, *pull_request, &response.title, &response.html_url)
+        {
             log::error!("failed to merge {pull_request}: {err}");
             continue;
         }
@@ -201,7 +198,7 @@ pub async fn run(yes: bool, use_gh_cli: bool) -> anyhow::Result<()> {
             continue;
         };
 
-        if let Err(err) = git_high_level::merge(
+        if let Err(err) = merge(
             &info.branch.local_branch_name,
             &info.branch.upstream_branch_name,
         ) {
@@ -327,3 +324,66 @@ pub async fn run(yes: bool, use_gh_cli: bool) -> anyhow::Result<()> {
 
     Ok(())
 }
+
+/// Create a merge commit that merges the `other_branch` into `current_branch`
+pub fn merge(
+    current_branch: &BranchName,
+    other_branch: &BranchName,
+) -> Result<String, anyhow::Error> {
+    log::trace!("Merging branch {current_branch}");
+
+    if let Err(err) = git::merge(current_branch.as_ref()) {
+        git::nuke_worktree()?;
+        bail!("failed to merge {other_branch}\n{err}");
+    }
+
+    // --squash will NOT commit anything. So we need to make the commit it manually
+    git::commit(&format!("Merge {current_branch}"))?;
+
+    Ok(format!("Merged {other_branch} successfully"))
+}
+
+/// Merge the `pull_request` into patchy's branch
+pub fn merge_pull_request(
+    info: &RemoteBranch,
+    pull_request: PrNumber,
+    pr_title: &str,
+    pr_url: &str,
+) -> Result<()> {
+    merge(
+        &info.branch.local_branch_name,
+        &info.branch.upstream_branch_name,
+    )
+    .map_err(|err| {
+        let pr = format_pr(pull_request, pr_title, pr_url);
+
+        let support_url = format_url(
+            "Merge conflicts (github)",
+            "https://github.com/nik-rev/patchy?tab=readme-ov-file#merge-conflicts",
+        )
+        .bright_blue();
+
+        anyhow!(
+            "Could not merge branch {} into the current branch for pull request {pr} since the \
+             merge is non-trivial.\nYou will need to merge it yourself:\n  {} {0}\nNote: To learn \
+             how to merge only once and re-use for subsequent invocations of patchy, see \
+             {support_url}\nSkipping this PR. Error message from git:\n{err}",
+            &info.branch.local_branch_name.as_ref().bright_cyan(),
+            "git merge --squash".bright_blue()
+        )
+    })?;
+
+    if git::is_worktree_dirty() {
+        git::commit(&format!(
+            "auto-merge pull request {}",
+            &pr_url.replace("github.com", "redirect.github.com")
+        ))?;
+    }
+
+    git::delete_remote_and_branch(
+        &info.remote.local_remote_alias,
+        &info.branch.local_branch_name,
+    )?;
+
+    Ok(())
+}

src/git_high_level.rs

@@ -7,10 +7,10 @@ use tap::Pipe as _;
 
 use crate::{
     config::{BranchName, CommitId, PrNumber, RepoName, RepoOwner},
-    git_high_level::{AvailableBranch, add_remote_branch, find_first_available_branch},
+    git,
     utils::{make_request, normalize_commit_msg, with_uuid},
 };
-use anyhow::{Result, anyhow};
+use anyhow::{Result, anyhow, bail};
 
 /// Data returned by GitHub's API for the pull request endpoint per repo
 #[derive(Serialize, Deserialize, Debug)]
@@ -190,3 +190,87 @@ pub async fn fetch_pull_request(
 
     Ok((response, remote_branch))
 }
+
+/// Available branch name to use
+pub enum AvailableBranch {
+    /// In this case, we can just use the original `branch` that we passed in
+    First,
+    /// The first branch was available, so we slapped on some arbitrary
+    /// identifier at the end Represents a branch like some-branch-2,
+    /// some-branch-3
+    Other(BranchName),
+}
+
+/// Given a branch, either return this branch or the first available branch with
+/// an identifier at the end (a `-#`) where `#` represents a number
+/// So we can keep on "trying" for a branch that isn't used. We might try
+/// `some-branch`, and if it already exists we will then try:
+///
+/// - some-branch-2
+/// - some-branch-3
+/// - some-branch-4
+/// - ...
+///
+/// Stopping when we find the first available
+///
+/// We do not want to return a branch if it already exists, since we don't want
+/// to overwrite any branch potentially losing the user their work
+///
+/// We also don't want to ask for a prompt for a custom name, as it would be
+/// pretty annoying to specify a name for each branch if you have like 30 pull
+/// requests you want to merge
+pub fn find_first_available_branch(branch: &str) -> AvailableBranch {
+    if git::does_object_exist(branch) {
+        return AvailableBranch::First;
+    }
+
+    // the first number for which the branch does not exist
+    #[expect(
+        clippy::maybe_infinite_iter,
+        reason = "there is definitely not an infinite number of branches"
+    )]
+    let number = (2..)
+        .find(|current| git::does_object_exist(&format!("{current}-{branch}")))
+        .expect("There will eventually be a #-branch which is available.");
+
+    let branch_name = BranchName::try_new(format!("{number}-{branch}"))
+        .expect("existing git branch is a valid branch name");
+
+    AvailableBranch::Other(branch_name)
+}
+
+/// Fetches a branch of a remote into local. Optionally accepts a commit hash
+/// for versioning.
+pub fn add_remote_branch(remote_branch: &RemoteBranch, commit: Option<&CommitId>) -> Result<()> {
+    git::add_remote(
+        &remote_branch.remote.local_remote_alias,
+        &remote_branch.remote.repository_url,
+    )
+    .map_err(|err| anyhow!("failed to fetch remote: {err}"))?;
+
+    if let Err(err) = git::fetch_remote_branch(
+        &remote_branch.branch.local_branch_name,
+        &remote_branch.branch.upstream_branch_name,
+        &remote_branch.remote.repository_url,
+    ) {
+        bail!(
+            "Failed to find branch {} of GitHub repository {}. Are you sure it exists?\n{err}",
+            remote_branch.branch.upstream_branch_name,
+            remote_branch.remote.repository_url
+        );
+    }
+
+    if let Some(commit) = commit {
+        git::reset_branch_to_commit(&remote_branch.branch.local_branch_name, commit).map_err(
+            |err| {
+                anyhow!(
+                    "Failed to find commit {} of branch {}. Are you sure the commit exists?\n{err}",
+                    commit.as_ref(),
+                    remote_branch.branch.local_branch_name
+                )
+            },
+        )?;
+    }
+
+    Ok(())
+}

src/github.rs

@@ -6,7 +6,6 @@ mod cli;
 mod commands;
 mod config;
 mod git;
-mod git_high_level;
 mod github;
 mod utils;