detect_git_service 1.0.0

Detect Git hosting service from file path
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::error::{Error, Result};
use std::ffi::OsStr;
use std::fmt::Debug;
use std::path::Path;
use std::process::Command;
use std::str;

pub struct Git<'a> {
    command: &'a str,
    path: &'a Path,
}

impl<'a> Git<'a> {
    fn dir(&self) -> &Path {
        if self.path.is_file() {
            self.path.parent().unwrap()
        } else {
            self.path
        }
    }

    pub fn command<S: AsRef<OsStr> + Debug>(&self, args: &[S]) -> Result<String> {
        let out = Command::new(&self.command)
            .current_dir(self.dir())
            .arg("-C")
            .arg(self.dir())
            .args(args)
            .output()
            .map_err(Error::CommandCannotRun)?;

        if out.status.success() {
            let s = str::from_utf8(&out.stdout)
                .expect("Failed to convert git command stdout from UTF8");
            Ok(s.trim().to_string())
        } else {
            let stderr = str::from_utf8(&out.stderr)
                .expect("Failed to convert git command stderr from UTF8")
                .trim()
                .to_string();
            Err(Error::GitCommandFailed {
                stderr,
                args: args
                    .iter()
                    .map(|a| a.as_ref().to_string_lossy().to_string())
                    .collect(),
            })
        }
    }

    pub fn remote_url<S: AsRef<str>>(&self, name: S) -> Result<String> {
        // XXX:
        // `git remote get-url {name}` is not available because it's added recently (at 2.6.1).
        // Note that git installed in Ubuntu 14.04 is 1.9.1.
        let mut url =
            self.command(&["config", "--get", &format!("remote.{}.url", name.as_ref())])?;

        if url.starts_with("git@") {
            // Note: Convert SSH protocol URL
            //  git@service.com:user/repo.git -> ssh://git@service.com:22/user/repo.git
            if let Some(i) = url.find(':') {
                url.insert_str(i + 1, "22/");
            }
            url.insert_str(0, "ssh://");
        }

        Ok(url)
    }

    pub fn tracking_remote(&self) -> Result<(String, Option<String>)> {
        let output = self.command(&["rev-parse", "--abbrev-ref", "--symbolic", "@{u}"]);
        let (url, branch) = if let Ok(stdout) = output {
            // stdout is formatted as '{remote-name}/{branch-name}'
            let mut entries = stdout.splitn(2, '/');
            if let (Some(ref name), branch) = (entries.next(), entries.next()) {
                (self.remote_url(name), branch.map(str::to_string))
            } else {
                (self.remote_url("origin"), None)
            }
        } else {
            (self.remote_url("origin"), None)
        };
        url.map(|u| (u, branch.or_else(|| self.current_branch().ok())))
    }

    pub fn current_branch(&self) -> Result<String> {
        self.command(&["rev-parse", "--abbrev-ref", "--symbolic", "HEAD"])
    }
}

impl<'a> Git<'a> {
    pub fn new<P: AsRef<Path>>(path: &'a P, git_cmd: Option<&'a str>) -> Git<'a> {
        Git {
            command: git_cmd.unwrap_or("git"),
            path: path.as_ref(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn tracking_remote() {
        let p = Path::new(".");
        let git = Git::new(&p, None);
        let (url, branch) = git.tracking_remote().unwrap();
        assert!(
            url.starts_with("https://") || url.starts_with("ssh://"),
            "{}",
            url
        );
        assert!(url.contains("detect_git_service"), "{}", url);
        assert!(branch.is_some(), "{:?}", branch);
    }

    #[test]
    fn remote_url() {
        let p = Path::new(".");
        let git = Git::new(&p, None);
        let url = git.remote_url("origin").unwrap();
        assert!(
            url.starts_with("https://") || url.starts_with("ssh://"),
            "{}",
            url
        );
        assert!(url.contains("detect_git_service"), "{}", url);
    }
} // mod tests