Allow users to define the default remote if one isn't discernable.

Author: arusahni

src/git.rs

@@ -1,9 +1,10 @@
+use std::collections::HashSet;
 use std::path::Path;
 use std::str;
 
 use duct::cmd;
 use git2::{Config, Error, Repository};
-use log::{debug, trace};
+use log::{debug, trace, warn};
 use shellexpand;
 
 /// Update old `req.key` config format to include remote name, i.e, `req.remote_name.key`
@@ -23,6 +24,15 @@ fn slugify_domain(domain: &str) -> String {
     str::replace(domain, ".", "|")
 }
 
+/// Get the remotes for the repository
+pub fn get_remotes() -> HashSet<String> {
+    let repo = Repository::open_from_env().expect("Couldn't find repository");
+    match repo.remotes() {
+        Ok(remotes) => remotes.into_iter().filter_map(|rem| rem).map(|rem| String::from(rem)).collect(),
+        Err(_) => HashSet::new()
+    }
+}
+
 /// Get the URL of the given remote
 pub fn get_remote_url(remote: &str) -> String {
     let repo = Repository::open_from_env().expect("Couldn't find repository");
@@ -47,7 +57,7 @@ pub fn get_config(field_name: &str, remote_name: &str) -> Option<String> {
     }
 }
 
-/// Set a value for the project-local git-req configuration
+/// Set a value for the project remote-local git-req configuration
 pub fn set_config(field_name: &str, remote_name: &str, value: &str) {
     migrate_legacy(field_name, "origin");
     let repo = Repository::open_from_env().expect("Couldn't find repository");
@@ -65,6 +75,24 @@ pub fn delete_config(field_name: &str, remote_name: &str) {
         .unwrap();
 }
 
+/// Get a value for the given project-local git-req config
+pub fn get_project_config(field_name: &str) -> Option<String> {
+    let key = format!("req.{}", field_name);
+    match get_repo_info(&key) {
+        Ok(val) => Some(val),
+        Err(_) => None,
+    }
+}
+
+/// Set a value for the project-local git-req configuration. Consider using `set_config` unless
+/// absolutely necessary.
+pub fn set_project_config(field_name: &str, value: &str) {
+    let repo = Repository::open_from_env().expect("Couldn't find repository");
+    let mut cfg = repo.config().unwrap();
+    cfg.set_str(&format!("req.{}", field_name), value)
+        .unwrap();
+}
+
 /// Get a value for the given global git-req config
 pub fn get_req_config(domain: &str, field: &str) -> Option<String> {
     let slug = slugify_domain(domain);
@@ -99,9 +127,9 @@ pub fn delete_req_config(domain: &str, field: &str) -> Result<(), Error> {
     cfg.remove(&format!("req.{}.{}", slug, field))
 }
 
-/// Get the name of the default remote
+/// Guess the name of the default remote
 #[allow(clippy::match_wild_err_arm)]
-pub fn get_default_remote_name() -> Result<String, String> {
+pub fn guess_default_remote_name() -> Result<String, String> {
     let repo = Repository::open_from_env().expect("Couldn't find repository");
     let remotes = repo.remotes().expect("Couldn't fetch the list of remotes");
     match remotes.len() {
@@ -122,8 +150,8 @@ pub fn checkout_branch(
     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() {
-        Ok(default_remote_name) => {
+    let local_branch_name = match get_project_config("defaultremote") {
+        Some(default_remote_name) => {
             if remote_name != default_remote_name {
                 trace!("Non-default remote name requested: {}", remote_name);
                 format!("{}/{}", remote_name, local_branch_name)
@@ -132,9 +160,9 @@ pub fn checkout_branch(
                 String::from(local_branch_name)
             }
         }
-        Err(_) => {
-            trace!(
-                "Multiple remotes found, but none named origin: {}",
+        None => {
+            warn!(
+                "No default remote found. Using {}",
                 remote_name
             );
             format!("{}/{}", remote_name, local_branch_name)
@@ -172,6 +200,7 @@ pub fn checkout_branch(
             } else {
                 &origin_with_remote
             };
+            trace!("Checking '{}' as '{}'", remote_ref, local_branch_name);
             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)),

src/main.rs

@@ -2,11 +2,11 @@
 mod git;
 mod remotes;
 
-use clap::{crate_authors, crate_version, load_yaml, App, AppSettings};
+use clap::{crate_authors, crate_version, load_yaml, App, AppSettings, ArgMatches};
 use colored::*;
 use git2::ErrorCode;
 use log::{debug, error, info, trace};
-use std::io::{self, Cursor, Write};
+use std::io::{self, stdin, stdout, Cursor, Write};
 use std::{env, process};
 use tabwriter::TabWriter;
 
@@ -164,6 +164,36 @@ fn generate_completion(app: &mut App, shell_name: &str) {
     print!("{}", &output);
 }
 
+fn get_remote_name(matches: &ArgMatches) -> String {
+    let default_remote_name = match git::get_project_config("defaultremote") {
+        Some(remote_name) => remote_name,
+        None => {
+            let new_remote_name = match git::guess_default_remote_name() {
+                Ok(guessed) => guessed,
+                Err(_) => {
+                    let mut new_remote_name = String::new();
+                    println!("Multiple remotes detected. Enter the name of the default one.");
+                    for remote in git::get_remotes() {
+                        println!(" * {}", remote);
+                    }
+                    print!("Remote name: ");
+                    let _ = stdout().flush();
+                    stdin().read_line(&mut new_remote_name).expect("Did not input a name");
+                    trace!("New remote: {}", &new_remote_name);
+                    if !git::get_remotes().contains(new_remote_name.trim()) {
+                        panic!("Invalid remote name provided")
+                    }
+                    new_remote_name
+                }
+            };
+            git::set_project_config("defaultremote", &new_remote_name);
+            new_remote_name
+        }
+    };
+    // Not using Clap's default_value because of https://github.com/clap-rs/clap/issues/1140
+    String::from(matches.value_of("REMOTE_NAME").unwrap_or(&default_remote_name))
+}
+
 fn build_cli(cfg: &yaml_rust::Yaml) -> App {
     App::from_yaml(&cfg)
         .version(crate_version!())
@@ -183,25 +213,22 @@ fn main() {
     let app = build_cli(&cfg);
     let matches = app.get_matches();
 
-    // Not using Clap's default_value because of https://github.com/clap-rs/clap/issues/1140
-    let remote_name = matches.value_of("REMOTE_NAME").unwrap_or("origin");
-
     if let Some(project_id) = matches.value_of("NEW_PROJECT_ID") {
-        set_project_id(remote_name, project_id);
+        set_project_id(&get_remote_name(&matches), project_id);
     } else if matches.is_present("CLEAR_PROJECT_ID") {
-        clear_project_id(remote_name);
+        clear_project_id(&get_remote_name(&matches));
     } else if matches.is_present("LIST_MR") {
-        list_open_requests(remote_name);
+        list_open_requests(&get_remote_name(&matches));
     } else if matches.is_present("CLEAR_DOMAIN_KEY") {
-        clear_domain_key(remote_name);
+        clear_domain_key(&get_remote_name(&matches));
     } else if let Some(domain_key) = matches.value_of("NEW_DOMAIN_KEY") {
-        set_domain_key(remote_name, domain_key);
+        set_domain_key(&get_remote_name(&matches), domain_key);
     } else if let Some(shell_name) = matches.value_of("GENERATE_COMPLETIONS") {
         let mut app = build_cli(&cfg);
         generate_completion(&mut app, &shell_name);
     } else {
         checkout_mr(
-            remote_name,
+            &get_remote_name(&matches),
             matches.value_of("REQUEST_ID").unwrap().parse().unwrap(),
         );
     }