gitverse 0.0.2

Rustic implementation of GitVerse
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

use std::collections::HashMap;
use std::env;

use log::{debug, error, warn};
use reqwest;
use serde::Deserialize;

use git;

#[derive(Deserialize)]
struct JSONObject {
    name: String,
    body: String,
}

fn build_hashmap(parsed: Vec<JSONObject>) -> HashMap<String, Vec<String>> {
    let mut hashmap = HashMap::new();
    for iter in parsed {
        let mut body = Vec::new();
        for line in iter.body.split('\n') {
            body.push(line.trim().to_string());
        }
        hashmap.insert(iter.name, body);
    }
    hashmap
}

fn parse_response(result: reqwest::blocking::Response) -> Option<HashMap<String, Vec<String>>> {
    match result.text() {
        Ok(resp) => {
            match serde_json::from_str(&resp) {
                Ok(parsed) => {
                    return Some(build_hashmap(parsed));
                }
                Err(error_) => {
                    error!("{}", error_);
                }
            }
        }
        Err(error_msg) => {
            error!("{}", error_msg);
        }
    }
    None
}

pub fn get() -> Option<HashMap<String, Vec<String>>> {
    let origin = git::run(
        r"git config --get remote.origin.url | sed 's/.*\/\([^ ]*\/[^.]*\).*/\1/'"
    );
    origin.as_ref()?;
    let bind_origin = origin.unwrap();
    if bind_origin.is_empty() {
        warn!("Unable to get origin for current repository");
        return None;
    }
    let origin_info: Vec<&str> = bind_origin.trim().split('/').collect();
    if origin_info.len() != 2 {
        return None;
    }
    let owner = origin_info[0];
    let repo = origin_info[1];
    let mut client = reqwest::blocking::ClientBuilder::new().user_agent("rustc");
    let gh_token = env::var("GIT_TOKEN")
        .unwrap_or(env::var("git_token")
            .unwrap_or("".to_string()));
    if !gh_token.is_empty() {
        debug!("Loading bearer auth with git token");
        let mut headers = reqwest::header::HeaderMap::new();
        headers.insert(reqwest::header::AUTHORIZATION,
                       reqwest::header::HeaderValue::from_str(&format!("Bearer {}", gh_token)).unwrap());
        client = client.default_headers(headers)
    } else {
        warn!("Trying to collect release notes without github token");
    }
    let url = format!("https://api.github.com/repos/{}/{}/releases", owner, repo);
    match client.build().unwrap().get(url).send() {
        Ok(result) => {
            if result.status().is_success() {
                return parse_response(result);
            } else {
                warn!("Failed to get releases. {}", result.status())
            }
        }
        Err(error) => {
            error!("{}", error);
        }
    }
    None
}