coveralls 0.1.5

Send job to Coveralls (coveralls.io)
Documentation 
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

use super::LogValueKind;
use simple_error::SimpleError;
use std::{io::{Result, Error, ErrorKind}, process::Command, ffi::OsStr};

fn extract_remote(line: &str) -> Option<(String, String)> {
    if line.ends_with(" (fetch)") {
        let mut parts = line.split_whitespace().map(|s| s.trim());
        let name = parts.next().map(String::from);
        let url = parts.next().map(String::from);

        match (name, url) {
            (Some(name), Some(url)) => Some((name, url)),
            _ => None,
        }
    } else {
        None
    }
}

pub(in super::super) struct GitFetcher;

impl GitFetcher {
    pub(in super::super) fn new() -> Result<Self> {
        Ok(GitFetcher)
    }

    fn run_command(&self, args: Vec<&str>) -> Result<String> {
        let res = Command::new("git").args(args.into_iter().map( OsStr::new)).output()?;

        if res.status.success() {
            match String::from_utf8(res.stdout) {
                Ok(v) => Ok(v),
                Err(err) => Err(Error::new(ErrorKind::Other, err)),
            }
        } else {
            let out = String::from_utf8_lossy(res.stdout.as_slice());
            let err = String::from_utf8_lossy(res.stderr.as_slice());
            let msg = format!("GIT command return code {}\nSTDOUT: {:?}\nSTDERR: {:?}", res.status, out, err);

            Err(Error::new(ErrorKind::Other, SimpleError::new(msg)))
        }
    }

    pub(in super::super) fn get_branch(&self) -> Result<Option<String>> {
        let res = self.run_command(vec!["rev-parse", "--abbrev-ref", "HEAD"])?.trim().to_string();

        if res.is_empty() {
            Ok(None)
        } else {
            Ok(Some(res))
        }
    }

    pub(in super::super) fn get_log(&self, kind: LogValueKind) -> Result<Option<String>> {
        let pretty = format!("--pretty=format:%{}", kind.to_format_str());
        let res = self.run_command(vec!["--no-pager", "log", "-1", &pretty])?.trim().to_string();

        if res.is_empty() {
            Ok(None)
        } else {
            Ok(Some(res))
        }
    }

    pub(in super::super) fn get_remotes(&self) -> Result<Option<Vec<(String, String)>>> {
        let r = self.run_command(vec!["remote", "-v"])?.trim().lines().filter_map(extract_remote).collect::<Vec<_>>();

        if r.is_empty() {
            Ok(None)
        } else {
            Ok(Some(r))
        }
    }
}