feat: add --use-gh-cli option

Author: nik-rev

src/cli.rs

@@ -88,10 +88,10 @@ pub enum Command {
 
 impl Command {
     /// Execute the command
-    pub async fn execute(self) -> anyhow::Result<()> {
+    pub async fn execute(self, use_gh_cli: bool) -> anyhow::Result<()> {
         match self {
             Self::Init => commands::init()?,
-            Self::Run { yes } => commands::run(yes).await?,
+            Self::Run { yes } => commands::run(yes, use_gh_cli).await?,
             Self::GenPatch { commit, filename } => {
                 commands::gen_patch(commit, filename)?;
             }
@@ -101,12 +101,12 @@ impl Command {
                 branch,
                 commit,
                 checkout,
-            } => commands::pr_fetch(pr, remote, branch, commit, checkout).await?,
+            } => commands::pr_fetch(pr, remote, branch, commit, checkout, use_gh_cli).await?,
             Self::BranchFetch {
                 remote,
                 commit,
                 checkout,
-            } => commands::branch_fetch(remote, commit, checkout).await?,
+            } => commands::branch_fetch(remote, commit, checkout, use_gh_cli).await?,
             Self::Completions { shell } => {
                 shell.generate(&mut Cli::command(), &mut std::io::stdout());
             }

src/commands/branch_fetch.rs

@@ -4,16 +4,17 @@ use colored::Colorize as _;
 
 use crate::config::{CommitId, Remote};
 use crate::git;
-use crate::github_api;
+use crate::github;
 use anyhow::anyhow;
 
 /// Fetch the given branch
 pub async fn branch_fetch(
     remote: Remote,
     commit: Option<CommitId>,
     checkout: bool,
+    use_gh_cli: bool,
 ) -> anyhow::Result<()> {
-    let (_, info) = github_api::fetch_branch(&remote).await?;
+    let (_, info) = github::fetch_branch(&remote, use_gh_cli).await?;
 
     log::info!(
         "Fetched branch {}/{}/{} available at branch {}{}",

src/commands/pr_fetch.rs

@@ -4,8 +4,7 @@ use anyhow::{Context as _, anyhow};
 use colored::Colorize as _;
 
 use crate::config::{BranchName, CommitId, PrNumber, Remote, RepoName, RepoOwner};
-use crate::git;
-use crate::github_api::fetch_pull_request;
+use crate::{git, github};
 
 /// Fetch the given `pr` of `remote` at `commit` and store it in local `branch`
 ///
@@ -16,6 +15,7 @@ pub async fn pr_fetch(
     branch: Option<BranchName>,
     commit: Option<CommitId>,
     checkout: bool,
+    use_gh_cli: bool,
 ) -> anyhow::Result<()> {
     pub const GITHUB_REMOTE_PREFIX: &str = "[email protected]:";
     pub const GITHUB_REMOTE_SUFFIX: &str = ".git";
@@ -46,11 +46,12 @@ pub async fn pr_fetch(
         Ok,
     )?;
 
-    let Ok((response, info)) = fetch_pull_request(
+    let Ok((response, info)) = github::fetch_pull_request(
         &format!("{}/{}", remote.owner, remote.repo),
         pr,
         branch,
         commit.as_ref(),
+        use_gh_cli,
     )
     .await
     .inspect_err(|err| {
@@ -61,16 +62,7 @@ pub async fn pr_fetch(
 
     log::info!(
         "Fetched pull request {} available at branch {}{}",
-        crate::utils::display_link(
-            &format!(
-                "{}{}{}{}",
-                "#".bright_blue(),
-                pr.to_string().bright_blue(),
-                " ".bright_blue(),
-                response.title.bright_blue().italic()
-            ),
-            &response.html_url
-        ),
+        crate::utils::format_pr(pr, &response.title, &response.html_url),
         info.branch.local_branch_name.as_ref().bright_cyan(),
         commit
             .clone()

src/commands/run.rs

@@ -10,8 +10,8 @@ use anyhow::{anyhow, bail};
 use colored::Colorize as _;
 
 use crate::git_high_level;
-use crate::github_api::{self, Branch, Remote, RemoteBranch};
-use crate::utils::{display_link, with_uuid};
+use crate::github::{self, Branch, Remote, RemoteBranch};
+use crate::utils::{format_pr, format_url, with_uuid};
 use crate::{commands, confirm_prompt, git};
 
 /// Backup for a file
@@ -23,7 +23,7 @@ struct FileBackup {
 }
 
 /// Run patchy, if `yes` then there will be no prompt
-pub async fn run(yes: bool) -> anyhow::Result<()> {
+pub async fn run(yes: bool, use_gh_cli: bool) -> anyhow::Result<()> {
     let root = config::ROOT.as_str();
 
     let Ok(config_string) = fs::read_to_string(&*config::FILE_PATH) else {
@@ -140,7 +140,7 @@ pub async fn run(yes: bool) -> anyhow::Result<()> {
     if config.pull_requests.is_empty() && config.branches.is_empty() {
         log::warn!(
             "You haven't specified any pull requests or branches to fetch in your config, {}",
-            display_link(
+            format_url(
                 "see the instructions on how to configure patchy.",
                 "https://github.com/nik-rev/patchy?tab=readme-ov-file#config"
             )
@@ -157,13 +157,17 @@ pub async fn run(yes: bool) -> anyhow::Result<()> {
     } in &config.pull_requests
     {
         // TODO: refactor this to not use such deep nesting
-        let Ok((response, info)) =
-            github_api::fetch_pull_request(&config.repo, *pull_request, None, commit.as_ref())
-                .await
-                .inspect_err(|err| {
-                    log::error!("failed to fetch branch from remote:\n{err}");
-                })
-        else {
+        let Ok((response, info)) = github::fetch_pull_request(
+            &config.repo,
+            *pull_request,
+            None,
+            commit.as_ref(),
+            use_gh_cli,
+        )
+        .await
+        .inspect_err(|err| {
+            log::error!("failed to fetch branch from remote:\n{err}");
+        }) else {
             continue;
         };
 
@@ -179,16 +183,7 @@ pub async fn run(yes: bool) -> anyhow::Result<()> {
 
         log::info!(
             "Merged pull request {}",
-            display_link(
-                &format!(
-                    "{}{}{}{}",
-                    "#".bright_blue(),
-                    pull_request.to_string().bright_blue(),
-                    " ".bright_blue(),
-                    &response.title.bright_blue().italic()
-                ),
-                &response.html_url
-            ),
+            format_pr(*pull_request, &response.title, &response.html_url),
         );
     }
 
@@ -197,9 +192,12 @@ pub async fn run(yes: bool) -> anyhow::Result<()> {
         let owner = &remote.owner;
         let repo = &remote.repo;
         let branch = &remote.branch;
-        let Ok((_, info)) = github_api::fetch_branch(remote).await.inspect_err(|err| {
-            log::error!("failed to fetch branch {owner}/{repo}/{branch}: {err}");
-        }) else {
+        let Ok((_, info)) = github::fetch_branch(remote, use_gh_cli)
+            .await
+            .inspect_err(|err| {
+                log::error!("failed to fetch branch {owner}/{repo}/{branch}: {err}");
+            })
+        else {
             continue;
         };
 

src/git_high_level.rs

@@ -10,8 +10,8 @@ use crate::git;
 use anyhow::{Result, anyhow, bail};
 use colored::Colorize as _;
 
-use crate::github_api::RemoteBranch;
-use crate::utils::display_link;
+use crate::github::RemoteBranch;
+use crate::utils::{format_pr, format_url};
 
 /// Fetches a branch of a remote into local. Optionally accepts a commit hash
 /// for versioning.
@@ -79,18 +79,9 @@ pub fn merge_pull_request(
         &info.branch.upstream_branch_name,
     )
     .map_err(|err| {
-        let pr = display_link(
-            &format!(
-                "{}{}{}{}",
-                "#".bright_blue(),
-                pull_request.to_string().bright_blue(),
-                " ".bright_blue(),
-                pr_title.bright_blue().italic()
-            ),
-            pr_url,
-        );
+        let pr = format_pr(pull_request, pr_title, pr_url);
 
-        let support_url = display_link(
+        let support_url = format_url(
             "Merge conflicts (github)",
             "https://github.com/nik-rev/patchy?tab=readme-ov-file#merge-conflicts",
         )

src/github_api.rs renamed to src/github.rs

@@ -4,7 +4,10 @@
     reason = "GitHub API is self-explanatory"
 )]
 
+use std::process;
+
 use serde::{Deserialize, Serialize};
+use tap::Pipe as _;
 
 use crate::{
     config::{BranchName, CommitId, PrNumber},
@@ -50,23 +53,38 @@ pub struct RemoteBranch {
     pub branch: Branch,
 }
 
-/// Fetch the branch of `remote` at the given `commit`
-pub async fn fetch_branch(remote: &crate::config::Remote) -> Result<(Repo, RemoteBranch)> {
-    let url = format!(
-        "https://api.github.com/repos/{}/{}",
-        remote.owner, remote.repo
-    );
+/// Make a request to GitHub's API.
+///
+/// Either manually fetch the URL or use `gh` CLI
+async fn gh_api(url: &str, use_gh_cli: bool) -> Result<String> {
+    if use_gh_cli {
+        process::Command::new("gh")
+            .arg("api")
+            .arg(url)
+            .output()?
+            .stdout
+            .pipe(String::from_utf8)?
+            .pipe(Ok)
+    } else {
+        make_request(url).await
+    }
+}
 
-    let response = make_request(&url).await.map_err(|err| {
-        anyhow!(
-            "Could not fetch branch: {}/{}\n{err}\n",
-            remote.owner,
-            remote.repo
-        )
-    })?;
+/// Fetch the branch of `remote` at the given `commit`
+pub async fn fetch_branch(
+    remote: &crate::config::Remote,
+    use_gh_cli: bool,
+) -> Result<(Repo, RemoteBranch)> {
+    let owner = &remote.owner;
+    let repo = &remote.repo;
+    let url = format!("https://api.github.com/repos/{owner}/{repo}",);
+
+    let response = gh_api(&url, use_gh_cli)
+        .await
+        .map_err(|err| anyhow!("failed to fetch branch `{owner}/{repo}`:\n{err}\n"))?;
 
     let response: Repo = serde_json::from_str(&response).map_err(|err| {
-        anyhow!("Could not parse response.\n{response}. Could not parse because: \n{err}")
+        anyhow!("failed to parse response.\n{response}. failed to parse because: \n{err}")
     })?;
 
     let info = RemoteBranch {
@@ -98,15 +116,25 @@ pub async fn fetch_pull_request(
     pull_request: PrNumber,
     custom_branch_name: Option<BranchName>,
     commit_hash: Option<&CommitId>,
+    use_gh_cli: bool,
 ) -> Result<(GitHubResponse, RemoteBranch)> {
     let url = format!("https://api.github.com/repos/{repo}/pulls/{pull_request}");
 
-    let response = make_request(&url)
-        .await
-        .map_err(|err| anyhow!("failed to fetch pull request #{pull_request}\n{err}\n"))?;
+    let gh_response = if use_gh_cli {
+        process::Command::new("gh")
+            .arg("api")
+            .arg(url)
+            .output()?
+            .stdout
+            .pipe(String::from_utf8)?
+    } else {
+        make_request(&url)
+            .await
+            .map_err(|err| anyhow!("failed to fetch pull request #{pull_request}\n{err}\n"))?
+    };
 
-    let response: GitHubResponse = serde_json::from_str(&response).map_err(|err| {
-        anyhow!("failed to parse GitHub response.\n{response}. Could not parse because: \n{err}")
+    let response: GitHubResponse = serde_json::from_str(&gh_response).map_err(|err| {
+        anyhow!("failed to parse GitHub response.\n{gh_response}. Could not parse because: \n{err}")
     })?;
 
     let remote_branch = RemoteBranch {

src/lib.rs

@@ -7,7 +7,7 @@ mod commands;
 mod config;
 mod git;
 mod git_high_level;
-mod github_api;
+mod github;
 mod utils;
 
 pub use cli::Cli;

src/main.rs

@@ -11,7 +11,7 @@ async fn main() -> ExitCode {
         .filter_level(args.verbosity.into())
         .init();
 
-    if let Err(err) = args.command.execute().await {
+    if let Err(err) = args.command.execute(args.use_gh_cli).await {
         log::error!("{err}");
         ExitCode::FAILURE
     } else {