git-req 2.5.0

Check out merge requests from your GitLab/GitHub hosted repos with ease!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::git;
use anyhow::{anyhow, Result};
use log::{info, trace};
use logchop::*;
use regex::Regex;
use serde_derive::{Deserialize, Serialize};
use std::fmt;
use std::io::{stdin, stdout, Write};

pub mod github;
pub mod gitlab;

#[derive(Serialize, Deserialize, Debug)]
pub struct MergeRequest {
    pub id: i64,
    pub title: String,
    pub description: Option<String>,
    pub source_branch: String,
}

pub trait Remote {
    /// Get the ID of the project associated with the repository
    fn get_project_id(&mut self) -> Result<&str>;

    /// Get the local branch associated with the merge request having the given ID
    fn get_local_req_branch(&mut self, mr_id: i64) -> Result<String>;

    /// Get the remote branch associated with the merge request having the given ID
    fn get_remote_req_branch(&mut self, mr_id: i64) -> Result<String>;

    /// Get the names of the merge/pull requests opened against the remote
    fn get_req_names(&mut self) -> Result<Vec<MergeRequest>>;

    /// 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;
}

/// Print a pretty remote
impl fmt::Display for dyn Remote {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Remote")
    }
}

/// Get the domain from an origin URL
pub fn get_domain(origin: &str) -> Result<&str> {
    let domain_regex = Regex::new(r"((http[s]?|ssh)://)?(\S+@)?(?P<domain>([^:/])+)").unwrap();
    match domain_regex.captures(origin) {
        Some(captures) => Ok(captures.name("domain").map_or("", |x| x.as_str())),
        None => Err(anyhow!("invalid remote set")),
    }
}

/// Get the API key for the given domain. If absent, prompt.
fn get_api_key(domain: &str) -> String {
    git::get_req_config(domain, "apikey").unwrap_or_else(|| {
        let mut newkey = String::new();
        println!("No API token for {} found. See https://github.com/arusahni/git-req/wiki/API-Keys for instructions.", domain);
        print!("{} API token: ", domain);
        let _ = stdout().flush();
        stdin()
            .read_line(&mut newkey)
            .expect("Did not input a correct key");
        trace!("New Key: {}", &newkey);
        git::set_req_config(domain, "apikey", newkey.trim());
        newkey.trim().to_string()
    })
}

/// Get a remote struct from an origin URL
pub fn get_remote(remote_name: &str, origin: &str, skip_api_key: bool) -> Result<Box<dyn Remote>> {
    let domain = get_domain(origin)?;
    Ok(match domain {
        "github.com" => {
            let name = github::get_github_project_name(origin).ok_or_else(|| {
                anyhow!("Could not parse the GitHub project name from the origin.")
            })?;
            let mut remote = github::GitHub {
                id: String::from(&name),
                domain: String::from("github.com"),
                name,
                origin: String::from(origin),
                api_root: String::from("https://api.github.com/repos"),
                api_key: String::from(""),
            };
            if !skip_api_key {
                let apikey = get_api_key("github.com");
                info!("API Key: {}", &apikey);
                remote.api_key = apikey;
            }
            Box::new(remote)
        }
        // For now, if not GitHub, then GitLab
        gitlab_domain => {
            let namespace = gitlab::get_gitlab_project_namespace(origin).ok_or_else(|| {
                anyhow!("Could not parse the GitLab project namespace from the origin.")
            })?;
            let name = gitlab::get_gitlab_project_name(origin)
                .debug_some("Project name")
                .ok_or_else(|| {
                    anyhow!("Could not parse the GitLab project name from the origin.")
                })?;
            let full_path = gitlab::get_gitlab_project_full_path(origin)
                .ok_or_else(|| anyhow!("Could not parse the GitLab path from the origin."))?;
            let mut remote = gitlab::GitLab {
                id: String::from(""),
                domain: String::from(gitlab_domain),
                name,
                namespace,
                full_path,
                origin: String::from(origin),
                api_root: format!("https://{}/api/v4", gitlab_domain),
                api_key: String::from(""),
            };
            if !skip_api_key {
                let apikey = get_api_key(domain);
                info!("API Key: {}", &apikey);
                remote.api_key = apikey;
            }
            let project_id = match gitlab::load_project_id(remote_name) {
                Some(x) => x,
                None => {
                    if skip_api_key {
                        String::from("")
                    } else {
                        let project_id_str = remote
                            .get_project_id()
                            .info_err("Error getting project ID")?;
                        git::set_config("projectid", remote_name, project_id_str);
                        String::from(project_id_str)
                    }
                }
            };
            info!("Got project ID: {}", project_id);
            remote.id = project_id;
            Box::new(remote)
        }
    })
}