Checkout GitLab and GitHub PRs differently to improve upstream tracking.

Prior to this change, GitLab branches were not checked out in such a way
that git recorded an upstream ref to track. Since there was no tracking info,
`git pull` no longer worked.  This commit updates this so the remote
branch is first fetched, and then the local branch is explicitly checked
out as tracking the remote one.

    git fetch origin my-mr-branch
    git checkout -b my-mr-branch origin/my-mr-branch

For GitHub, the existing method has been preserved as the namespace refs
the service makes available are read-only.  Tracking isn't available
with this method.

   git fetch origin pull/1337/head:pr/1337
   git checkout pr/1337

I don't think GitHub makes that available (see:
https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/checking-out-pull-requests-locally)

Author: arusahni

src/git.rs

@@ -119,6 +119,7 @@ pub fn checkout_branch(
     remote_name: &str,
     remote_branch_name: &str,
     local_branch_name: &str,
+    is_virtual_remote_branch: bool,
 ) -> Result<bool, String> {
     let repo = Repository::open_from_env().expect("Couldn't find repository");
     let local_branch_name = match get_default_remote_name() {
@@ -140,32 +141,41 @@ pub fn checkout_branch(
         }
     };
 
-    // Fetch the remote branch if there's no local branch with the correct name
-    if repo.revparse_single(&local_branch_name).is_err() {
-        if cmd!(
-            "git",
-            "fetch",
-            remote_name,
-            &format!("{}:{}", remote_branch_name, local_branch_name)
-        )
-        .run()
-        .is_err()
-        {
-            return Err(format!(
-                "Could not fetch remote branch '{}' to local ref '{}'",
-                remote_branch_name, local_branch_name
-            ));
+    let local_branch_exists = repo.revparse_single(&local_branch_name);
+    match local_branch_exists {
+        Ok(_) => {
+            debug!("Checking out branch: {}", local_branch_name);
+            match cmd!("git", "checkout", &local_branch_name).run() {
+                Ok(_) => Ok(true),
+                Err(err) => Err(format!("Could not check out local branch: {}", err)),
+            }
         }
-        if repo.revparse_single(&local_branch_name).is_err() {
-            return Err(format!(
-                "Could not find remote branch: {}",
-                local_branch_name
-            ));
+        Err(_) => {
+            // Fetch the remote branch if there's no local branch with the correct name
+            let mut fetch_args = vec!["fetch", &remote_name];
+            let remote_to_local_binding = format!("{}:{}", remote_branch_name, local_branch_name);
+            fetch_args.push(if is_virtual_remote_branch {
+                &remote_to_local_binding
+            } else {
+                &remote_branch_name
+            });
+            if cmd("git", fetch_args).run().is_err() {
+                return Err(format!(
+                    "Could not fetch remote branch '{}'",
+                    remote_branch_name
+                ));
+            };
+            debug!("Checking out branch: {}", local_branch_name);
+            let origin_with_remote = format!("{}/{}", remote_name, remote_branch_name);
+            let remote_ref = if is_virtual_remote_branch {
+                &local_branch_name
+            } else {
+                &origin_with_remote
+            };
+            match cmd!("git", "checkout", "-b", &local_branch_name, &remote_ref).run() {
+                Ok(_) => Ok(true),
+                Err(err) => Err(format!("Could not check out local branch: {}", err)),
+            }
         }
     }
-    debug!("Checking out branch: {}", local_branch_name);
-    match cmd!("git", "checkout", local_branch_name).run() {
-        Ok(_) => Ok(true),
-        Err(err) => Err(format!("Could not check out local branch: {}", err)),
-    }
 }

src/main.rs

@@ -63,6 +63,7 @@ fn checkout_mr(remote_name: &str, mr_id: i64) {
         remote_name,
         &remote_branch_name,
         &remote.get_local_req_branch(mr_id).unwrap(),
+        remote.has_virtual_remote_branch_names(),
     ) {
         Ok(_) => {
             info!("Done!");

src/remotes/github.rs

@@ -47,6 +47,10 @@ impl Remote for GitHub {
     fn has_useful_branch_names(&mut self) -> bool {
         false
     }
+
+    fn has_virtual_remote_branch_names(&mut self) -> bool {
+        true
+    }
 }
 
 /// Convert a GitHub PR to a git-req MergeRequest

src/remotes/gitlab.rs

@@ -73,6 +73,10 @@ impl Remote for GitLab {
     fn has_useful_branch_names(&mut self) -> bool {
         true
     }
+
+    fn has_virtual_remote_branch_names(&mut self) -> bool {
+        false
+    }
 }
 
 /// Query the GitLab API

src/remotes/mod.rs

@@ -32,6 +32,11 @@ pub trait Remote {
     /// Determine if the branch names are useful to display
     fn has_useful_branch_names(&mut self) -> bool;
 
+    /// If the remote branch is a namespaced ref instead of an actual branch
+    // This is useful for GitHub's `pull/mr/head` refs, where they're read-only
+    fn has_virtual_remote_branch_names(&mut self) -> bool;
+
+    /// The domain that hosts the remote
     fn get_domain(&mut self) -> &str;
 }