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
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

use super::fetcher::{GitFetcher, LogValueKind};
use crate::Config;
use serde::{Serialize, Deserialize};
use simple_error::SimpleError;
use const_format::concatcp;
use std::io::{Result, Error, ErrorKind};

const fn error_message() -> &'static str {
    const MSG: &str = "\
        Failed collecting git data. \
        Did you use command line arguments ? \
        Are you running coveralls inside a git repository ?\
    ";

    if cfg!(feature = "use-libgit") {
        MSG
    } else {
        concatcp!(MSG, " Is git installed ?")
    }
}

#[derive(Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
pub(crate) struct GitHead {
    #[serde(default)]
    pub(crate) id: String,

    #[serde(default)]
    pub(crate) author_name: String,

    #[serde(default)]
    pub(crate) author_email: String,

    #[serde(default)]
    pub(crate) committer_name: String,

    #[serde(default)]
    pub(crate) committer_email: String,

    #[serde(default)]
    pub(crate) message: String,
}

impl GitHead {
    pub(super) fn fetch_from_config(&mut self, config: &Config) {
        if let Some(v) = config.git_id.clone() {
            self.id = v;
        }

        if let Some(v) = config.git_author_name.clone() {
            self.author_name = v;
        }

        if let Some(v) = config.git_author_email.clone() {
            self.author_email = v;
        }

        if let Some(v) = config.git_committer_name.clone() {
            self.committer_name = v;
        }

        if let Some(v) = config.git_committer_email.clone() {
            self.committer_email = v;
        }

        if let Some(v) = config.git_message.clone() {
            self.message = v;
        }
    }

    pub(super) fn fetch_from_git(&mut self, git_fetcher: &GitFetcher) -> Result<()> {
        if let Some(v) = git_fetcher.get_log(LogValueKind::Id)? {
            self.id = v;
        }

        if let Some(v) = git_fetcher.get_log(LogValueKind::AuthorName)? {
            self.author_name = v;
        }

        if let Some(v) = git_fetcher.get_log(LogValueKind::AuthorEmail)? {
            self.author_email = v;
        }

        if let Some(v) = git_fetcher.get_log(LogValueKind::CommitterName)? {
            self.committer_name = v;
        }

        if let Some(v) = git_fetcher.get_log(LogValueKind::CommitterEmail)? {
            self.committer_email = v;
        }

        if let Some(v) = git_fetcher.get_log(LogValueKind::Message)? {
            self.message = v;
        }

        Ok(())
    }

    pub(super) fn check(&self) -> Result<()> {
        macro_rules! e {
            ($f:ident) => {self.$f.is_empty()};
        }

        if e!(id) || e!(author_name) || e!(author_email) || e!(committer_name) || e!(committer_email) || e!(message) {
            Err(Error::new(ErrorKind::Other, SimpleError::new(error_message())))
        } else {
            Ok(())
        }
    }
}