refactor: make a generic get_gh_api function

Author: nik-rev

src/github.rs

@@ -6,11 +6,11 @@
 
 use std::process;
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use tap::Pipe as _;
 
 use crate::{
-    config::{BranchName, CommitId, PrNumber},
+    config::{BranchName, CommitId, PrNumber, RepoName, RepoOwner},
     git_high_level::{AvailableBranch, add_remote_branch, find_first_available_branch},
     utils::{make_request, normalize_commit_msg, with_uuid},
 };
@@ -30,11 +30,27 @@ pub struct Head {
     pub r#ref: BranchName,
 }
 
+impl GitHubResponse {
+    /// The endpoint which returns the structure [`GitHubResponse`]
+    fn endpoint(repo: &str, pull_request: PrNumber) -> String {
+        format!("https://api.github.com/repos/{repo}/pulls/{pull_request}")
+    }
+}
+
+/// Data returned by endpoint
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Repo {
+    /// e.g. `https://github.com/helix-editor/helix.git`
     pub clone_url: String,
 }
 
+impl Repo {
+    /// the endpoint that returns the structure [`Repo`]
+    pub fn endpoint(owner: &RepoOwner, repo: &RepoName) -> String {
+        format!("https://api.github.com/repos/{owner}/{repo}",)
+    }
+}
+
 #[derive(Debug)]
 pub struct Branch {
     pub upstream_branch_name: BranchName,
@@ -53,10 +69,16 @@ pub struct RemoteBranch {
     pub branch: Branch,
 }
 
+/////////////////////////////////////////////////////////
+
 /// 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> {
+///
+/// - Outer `Result`: Failed to fetch the URL
+/// - Inner `Result`: Failed to deserialize text received by the URL
+async fn get_gh_api<T: DeserializeOwned>(url: &str, use_gh_cli: bool) -> Result<Result<T>> {
+    log::trace!("making a request to {url}");
     if use_gh_cli {
         process::Command::new("gh")
             .arg("api")
@@ -68,6 +90,11 @@ async fn gh_api(url: &str, use_gh_cli: bool) -> Result<String> {
     } else {
         make_request(url).await
     }
+    .map(|response| {
+        serde_json::from_str::<T>(&response).map_err(|err| {
+            anyhow!("failed to parse response.\n{response}. failed to parse because: \n{err}")
+        })
+    })
 }
 
 /// Fetch the branch of `remote` at the given `commit`
@@ -77,20 +104,16 @@ pub async fn fetch_branch(
 ) -> Result<(Repo, RemoteBranch)> {
     let owner = &remote.owner;
     let repo = &remote.repo;
-    let url = format!("https://api.github.com/repos/{owner}/{repo}",);
+    let url = Repo::endpoint(owner, repo);
 
-    let response = gh_api(&url, use_gh_cli)
+    let response = get_gh_api::<Repo>(&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!("failed to parse response.\n{response}. failed to parse because: \n{err}")
-    })?;
+        .map_err(|err| anyhow!("failed to fetch branch `{owner}/{repo}`:\n{err}\n"))??;
 
     let info = RemoteBranch {
         remote: Remote {
             repository_url: response.clone_url.clone(),
-            local_remote_alias: with_uuid(&format!("{}/{}", &remote.owner, remote.repo)),
+            local_remote_alias: with_uuid(&format!("{}/{}", &owner, repo)),
         },
         branch: Branch {
             local_branch_name: remote.branch.clone(),
@@ -101,8 +124,8 @@ pub async fn fetch_branch(
     add_remote_branch(&info, remote.commit.as_ref()).map_err(|err| {
         anyhow!(
             "Could not add remote branch {}/{}, skipping.\n{err}",
-            remote.owner,
-            remote.repo
+            owner,
+            repo
         )
     })?;
 
@@ -118,24 +141,11 @@ pub async fn fetch_pull_request(
     commit_hash: Option<&CommitId>,
     use_gh_cli: bool,
 ) -> Result<(GitHubResponse, RemoteBranch)> {
-    let url = format!("https://api.github.com/repos/{repo}/pulls/{pull_request}");
+    let url = GitHubResponse::endpoint(repo, pull_request);
 
-    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(&gh_response).map_err(|err| {
-        anyhow!("failed to parse GitHub response.\n{gh_response}. Could not parse because: \n{err}")
-    })?;
+    let response = get_gh_api::<GitHubResponse>(&url, use_gh_cli)
+        .await
+        .map_err(|err| anyhow!("failed to fetch pull request #{pull_request}\n{err}\n"))??;
 
     let remote_branch = RemoteBranch {
         remote: Remote {