feat: implement branch-fetch

Author: nik-rev

Cargo.toml

@@ -16,7 +16,6 @@ homepage = "https://github.com/nik-rev/patchy"
 pedantic = { priority = -1, level = "warn" }
 nursery = { priority = -1, level = "warn" }
 cargo = { priority = -1, level = "warn" }
-perf = { priority = -1, level = "deny" }
 
 # sometimes it can be more readable not to inline format!() args
 uninlined_format_args = "allow"
@@ -34,16 +33,10 @@ too_many_lines = "allow"
 maybe_infinite_iter = "allow"
 
 # === Restrictions ===
-
-absolute_paths = "warn"
-deref_by_slicing = "warn"
-wildcard_enum_match_arm = "warn"
-verbose_file_reads = "warn"
-
 # == safety ==
+
 # Each 'unsafe' block should always contain exactly 1 unsafe operation
 # with clear documentation why the invariants are upheld.
-
 undocumented_unsafe_blocks = "deny"
 unnecessary_safety_comment = "deny"
 unnecessary_safety_doc = "deny"
@@ -69,6 +62,7 @@ fn_to_numeric_cast_any = "deny"
 # integer division discards the remainder and is likely a mistake
 integer_division = "deny"
 lossy_float_literal = "deny"
+wildcard_enum_match_arm = "deny"
 
 # == performance ==
 
@@ -136,6 +130,9 @@ rest_pat_in_fully_bound_structs = "warn"
 same_name_method = "warn"
 # more explicit and avoids polluting the scope
 unused_trait_names = "warn"
+absolute_paths = "warn"
+deref_by_slicing = "warn"
+verbose_file_reads = "warn"
 
 # == enable these before pushing a new release ==
 # dbg_macro = "deny"

src/commands/branch_fetch.rs

@@ -1,10 +1,13 @@
 use std::process;
 
+use colored::Colorize as _;
+
 use crate::{
     commands::help,
     fail,
     flags::{is_valid_flag, Flag},
-    git_commands::is_valid_branch_name,
+    git_commands::{fetch_branch, is_valid_branch_name, GIT},
+    success,
     types::CommandArgs,
 };
 
@@ -29,23 +32,23 @@ pub struct Item {
     /// # Examples
     ///
     /// helix-editor/helix
-    repo: String,
+    pub repo: String,
     /// # Examples
     ///
     /// master
-    branch: String,
+    pub branch: String,
     /// If specified, use a custom branch name instead of a generated one
     ///
     /// # Examples
     ///
     /// my-custom-branch123
-    local_branch_name: Option<String>,
+    pub local_branch_name: Option<String>,
     /// If specified, do a **hard reset** to this commit when fetching the branch
     ///
     /// # Examples
     ///
     /// 6049f2035
-    commit_hash: Option<String>,
+    pub commit_hash: Option<String>,
 }
 
 impl Item {
@@ -76,14 +79,25 @@ Valid format is: username/repo/branch. Example: helix-editor/helix/master",
 
         Ok(Self::new(repo.to_owned(), branch.to_owned(), None, hash))
     }
+
+    #[must_use]
+    pub fn with_branch_name(mut self, branch_name: Option<String>) -> Self {
+        self.local_branch_name = branch_name;
+        self
+    }
 }
 
-pub fn branch_fetch(args: &CommandArgs) {
+pub async fn branch_fetch(args: &CommandArgs) -> anyhow::Result<()> {
+    if args.is_empty() {
+        let _ = help(Some("branch-fetch"));
+        process::exit(1);
+    }
+
     let has_checkout_flag = BRANCH_FETCH_CHECKOUT_FLAG.is_in(args);
 
     let mut args = args.iter().peekable();
 
-    let mut branches_with_maybe_custom_names = vec![];
+    let mut items = vec![];
 
     let mut no_more_flags = false;
 
@@ -105,11 +119,7 @@ pub fn branch_fetch(args: &CommandArgs) {
             continue;
         }
 
-        let (remote, hash) = parse_if_maybe_hash(arg, "@");
-
-        let Some((repo, branch)) = remote.rsplit_once('/') else {
-            fail!("Invalid format: {}, skipping. Valid format is: username/repo/branch. Example: helix-editor/helix/master", remote);
-
+        let Ok(item) = Item::create(arg).map_err(|err| fail!("{err}")) else {
             continue;
         };
 
@@ -124,13 +134,51 @@ pub fn branch_fetch(args: &CommandArgs) {
             args.next();
         };
 
-        branches_with_maybe_custom_names.push(Item::new(
-            repo.to_owned(),
-            branch.to_owned(),
-            maybe_custom_branch_name,
-            hash,
-        ));
+        let item = item.with_branch_name(maybe_custom_branch_name);
+
+        items.push(item);
     }
 
     let client = reqwest::Client::new();
+
+    for (i, item) in items.into_iter().enumerate() {
+        let hash = item.commit_hash.clone();
+        let repo = item.repo.clone();
+        match fetch_branch(item, &client).await {
+            Ok((_, info)) => {
+                success!(
+                    "Fetched branch {}/{} available at branch {}{}",
+                    repo,
+                    info.branch.upstream_branch_name,
+                    info.branch.local_branch_name.bright_cyan(),
+                    hash.map(|commit_hash| format!(", at commit {}", commit_hash.bright_yellow()))
+                        .unwrap_or_default()
+                );
+
+                // Attempt to cleanup after ourselves
+                let _ = GIT(&["remote", "remove", &info.remote.local_remote_alias]);
+
+                // If user uses --checkout flag, we're going to checkout the first fetched branch
+                if i == 0 && has_checkout_flag {
+                    if let Err(cant_checkout) = GIT(&["checkout", &info.branch.local_branch_name]) {
+                        fail!(
+                            "Could not check out branch {}:\n{cant_checkout}",
+                            info.branch.local_branch_name
+                        );
+                    } else {
+                        success!(
+                            "Automatically checked out the first branch: {}",
+                            info.branch.local_branch_name
+                        );
+                    }
+                }
+            }
+            Err(err) => {
+                fail!("{err}");
+                continue;
+            }
+        };
+    }
+
+    Ok(())
 }

src/commands/help.rs

@@ -52,6 +52,10 @@ pub fn help(command: Option<&str>) -> anyhow::Result<()> {
         "pr-fetch",
         "Fetch pull request for a GitHub repository as a local branch",
     );
+    let branch_fetch = format_subcommand(
+        "branch-fetch",
+        "Fetch branches for a GitHub repository as a local branch",
+    );
     let gen_patch = format_subcommand("gen-patch", "Generate a .patch file from commit hashes");
     let run = format_subcommand("run", &format!("Start {APP_NAME}"));
     let header = format!(
@@ -163,13 +167,13 @@ pub fn help(command: Option<&str>) -> anyhow::Result<()> {
 
             let example_1 = format!(
                 "{}
-            {}",
+    {}",
                 "helix-editor/helix/master".bright_green(),
                 format_description("Fetch a single branch")
             );
             let example_2 = format!(
                 "{}
-            {}",
+    {}",
                 "'helix-editor/helix/master@6049f20'".bright_green(),
                 format_description("Fetch a single branch at a certain commit")
             );
@@ -292,6 +296,8 @@ pub fn help(command: Option<&str>) -> anyhow::Result<()> {
 
     {pr_fetch} 
 
+    {branch_fetch} 
+
   Flags:
 
     {HELP_FLAG}

src/commands/pr_fetch.rs

@@ -54,6 +54,11 @@ pub static PR_FETCH_FLAGS: &[&Flag<'static>; 5] = &[
 ];
 
 pub async fn pr_fetch(args: &CommandArgs) -> anyhow::Result<()> {
+    if args.is_empty() {
+        let _ = help(Some("pr-fetch"));
+        process::exit(1);
+    }
+
     let has_checkout_flag = PR_FETCH_CHECKOUT_FLAG.is_in(args);
 
     let mut args = args.iter().peekable();

src/git_commands.rs

@@ -1,4 +1,4 @@
-use crate::{fail, types::Repo, utils::display_link};
+use crate::{commands::branch_fetch, fail, types::Repo, utils::display_link};
 use colored::Colorize as _;
 use std::{
     env, io,
@@ -289,28 +289,24 @@ fn first_available_branch(branch: &str) -> AvailableBranch {
 }
 
 pub async fn fetch_branch(
-    repo: &str,
+    item: branch_fetch::Item,
     client: &Client,
-    branch_name: &str,
-    custom_branch_name: Option<&str>,
-    commit_hash: Option<&str>,
 ) -> anyhow::Result<(Repo, BranchAndRemote)> {
-    let url = format!("https://api.github.com/repos/{repo}");
+    let url = format!("https://api.github.com/repos/{}", item.repo);
 
     let response = make_request(client, &url)
         .await
-        .map_err(|err| anyhow!("Could not fetch branch: {repo}\n{err}\n"))?;
+        .map_err(|err| anyhow!("Could not fetch branch: {}\n{err}\n", item.repo))?;
 
     let response: Repo = serde_json::from_str(&response).map_err(|err| {
         anyhow!("Could not parse response.\n{response}. Could not parse because: \n{err}")
     })?;
 
     let info = BranchAndRemote {
         branch: Branch {
-            upstream_branch_name: branch_name.to_owned(),
-            local_branch_name: custom_branch_name.map_or_else(
+            local_branch_name: item.local_branch_name.map_or_else(
                 || {
-                    let branch_name = &format!("{repo}/{branch_name}");
+                    let branch_name = &format!("{}/{}", item.repo, item.branch);
 
                     match first_available_branch(branch_name) {
                         AvailableBranch::First => branch_name.to_string(),
@@ -319,15 +315,20 @@ pub async fn fetch_branch(
                 },
                 Into::into,
             ),
+            upstream_branch_name: item.branch,
         },
         remote: Remote {
             repository_url: response.clone_url.clone(),
-            local_remote_alias: with_uuid(repo),
+            local_remote_alias: with_uuid(&item.repo),
         },
     };
 
-    add_remote_branch(&info, commit_hash)
-        .map_err(|err| anyhow!("Could not add remote branch {repo}, skipping.\n{err}"))?;
+    add_remote_branch(&info, item.commit_hash.as_deref()).map_err(|err| {
+        anyhow!(
+            "Could not add remote branch {}, skipping.\n{err}",
+            item.repo
+        )
+    })?;
 
     Ok((response, info))
 }

src/main.rs

@@ -1,4 +1,5 @@
-use colored::Colorize;
+use colored::Colorize as _;
+use patchy::commands::branch_fetch::branch_fetch;
 use patchy::commands::help::{HELP_FLAG, VERSION_FLAG};
 use patchy::commands::{gen_patch, help, init, pr_fetch, run};
 use patchy::fail;
@@ -16,6 +17,7 @@ async fn process_subcommand(subcommand: &str, args: CommandArgs) -> Result<()> {
         "gen-patch" => gen_patch(&args)?,
         // lower level commands
         "pr-fetch" => pr_fetch(&args).await?,
+        "branch-fetch" => branch_fetch(&args).await?,
         unrecognized => {
             if !unrecognized.is_empty() {
                 fail!(