git 0.1.9

The library provides basic operations with Git repositories.
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

#![feature(env, path, process)]

use std::{env, process};
use std::path::PathBuf;

macro_rules! cmd(
    ($name:expr) => (process::Command::new($name));
);

macro_rules! fmt(
    ($($arg:tt)*) => (&format!($($arg)*)[..]);
);

macro_rules! get(
    ($name:expr) => (env::var($name).unwrap());
);

macro_rules! run(
    ($command:expr) => (
        assert!($command.stdout(process::Stdio::inherit())
                        .stderr(process::Stdio::inherit())
                        .status().unwrap().success());
    );
);

macro_rules! link(
    ($name:expr) => (println!("cargo:rustc-flags=-l {}", $name));
);

macro_rules! look(
    ($path:expr) => (println!("cargo:rustc-flags=-L {}", $path));
);

fn main() {
    let ssh = require("libssh2", None);
    require("openssl", Some("-lssl -lcrypto"));
    require("zlib", Some("-lz"));

    if get!("TARGET").contains("apple") {
       link!("iconv");
    }

    let mut from = PathBuf::new(&get!("CARGO_MANIFEST_DIR"));
    from.push("build");
    from.push("libgit2");

    let mut cmake = PathBuf::new(&get!("CARGO_MANIFEST_DIR"));
    cmake.push("build");
    cmake.push("cmake");

    let into = PathBuf::new(&get!("OUT_DIR"));

    run!(cmd!("cmake").current_dir(&into)
                      .arg(&from)
                      .arg("-DBUILD_CLAR=OFF")
                      .arg("-DBUILD_EXAMPLES=OFF")
                      .arg("-DBUILD_SHARED_LIBS=OFF")
                      .arg("-DCMAKE_C_FLAGS=-fPIC")
                      .arg("-DTHREADSAFE=ON")
                      .arg(fmt!("-DCMAKE_MODULE_PATH={:?}", &cmake))
                      .arg(fmt!("-DUSE_SSH={}", if ssh { "ON" } else { "OFF" })));

    run!(cmd!("make").current_dir(&into).arg(fmt!("-j{}", get!("NUM_JOBS"))));

    look!(into.display());
    link!("git2:static");
}

fn require(name: &str, fallback: Option<&str>) -> bool {
    macro_rules! rescue(
        ($fallback:expr) => ({
            match $fallback {
                Some(output) => interpret(output),
                None => {},
            }
            return false;
        });
    );

    let result = match cmd!("pkg-config").arg("--libs").arg(name).output() {
        Ok(result) => result,
        Err(_) => rescue!(fallback),
    };

    if !result.status.success() {
        rescue!(fallback);
    }

    interpret(std::str::from_utf8(&result.stdout[..]).unwrap());

    true
}

fn interpret(output: &str) {
    for chunk in output.split(' ') {
        if chunk.starts_with("-l") {
            link!(chunk.slice_from(2));
        } else if chunk.starts_with("-L") {
            look!(chunk.slice_from(2));
        }
    }
}