zargo 0.1.1

The sysroot manager that lets you build and customize `std`
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
130
131
132
133
134
135
136

use std::{
    env,
    io::{self, Write},
    mem,
    path::{Display, Path, PathBuf},
    process::ExitStatus,
};

use rustc_version::VersionMeta;
use toml::Value;

use crate::{
    cargo,
    cargo::{Config, Root, Rustflags, Subcommand},
    cli::Args,
    errors::*,
    extensions::CommandExt,
    flock::{FileLock, Filesystem},
    util, CompilationMode,
};

pub fn run(
    args: &Args,
    cmode: &CompilationMode,
    rustflags: Rustflags,
    home: &Home,
    meta: &VersionMeta,
    config: Option<&Config>,
    verbose: bool,
) -> Result<ExitStatus> {
    let mut cmd = cargo::command();
    cmd.args(args.all());

    if args.subcommand() == Some(Subcommand::Doc) {
        cmd.env(
            "CARGO_ENCODED_RUSTDOCFLAGS",
            cargo::rustdocflags(config, cmode.triple())?.encode(home),
        );
    }

    if verbose {
        writeln!(io::stderr(), "+ RUSTFLAGS={}", rustflags).ok();
    }
    cmd.env("CARGO_ENCODED_RUSTFLAGS", rustflags.encode(home));

    let locks = (home.lock_ro(&meta.host), home.lock_ro(cmode.triple()));

    let status = cmd.run_and_get_status(verbose)?;

    mem::drop(locks);

    Ok(status)
}

pub struct Home {
    path: Filesystem,
}

impl Home {
    pub fn display(&self) -> Display<'_> {
        self.path.display()
    }

    fn path(&self, triple: &str) -> Filesystem {
        self.path.join("lib").join("rustlib").join(triple)
    }

    pub fn lock_ro(&self, triple: &str) -> Result<FileLock> {
        let fs = self.path(triple);

        fs.open_ro(".sentinel", &format!("{}'s sysroot", triple))
            .chain_err(|| format!("couldn't lock {}'s sysroot as read-only", triple))
    }

    pub fn lock_rw(&self, triple: &str) -> Result<FileLock> {
        let fs = self.path(triple);

        fs.open_rw(".sentinel", &format!("{}'s sysroot", triple))
            .chain_err(|| format!("couldn't lock {}'s sysroot as read-only", triple))
    }
}

pub fn home(cmode: &CompilationMode) -> Result<Home> {
    let mut p = if let Some(h) = env::var_os("ZARGO_HOME") {
        PathBuf::from(h)
    } else {
        dirs::home_dir()
            .ok_or("couldn't find your home directory. Is $HOME set?")?
            .join(".zargo")
    };

    if cmode.is_native() {
        p.push("HOST");
    }

    Ok(Home {
        path: Filesystem::new(p),
    })
}

pub struct Toml {
    table: Value,
}

impl Toml {
    /// Returns the `dependencies` part of `Zargo.toml`
    pub fn dependencies(&self) -> Option<&Value> {
        self.table.get("dependencies")
    }

    /// Returns the `target.{}.dependencies` part of `Zargo.toml`
    pub fn target_dependencies(&self, target: &str) -> Option<&Value> {
        self.table
            .get("target")
            .and_then(|t| t.get(target))
            .and_then(|t| t.get("dependencies"))
    }

    /// Returns the `patch` part of `Zargo.toml`
    pub fn patch(&self) -> Option<&Value> {
        self.table.get("patch")
    }
}

/// Returns the closest directory containing a 'Zargo.toml' and the parsed
/// content of this 'Zargo.toml'
pub fn toml(root: &Root) -> Result<(Option<&Path>, Option<Toml>)> {
    if let Some(p) = util::search(root.path(), "Zargo.toml") {
        Ok((
            Some(p),
            util::parse(&p.join("Zargo.toml")).map(|t| Some(Toml { table: t }))?,
        ))
    } else {
        Ok((None, None))
    }
}