cargo-x 0.3.7

A very simple third-party cargo subcommand to execute a custom command.
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
137
138
139
140
141
142
143
144
145

use anyhow::{bail, Context, Result};
use serde::Deserialize;
use std::collections::HashMap;
use std::fs;
use std::path::Path;

#[derive(Deserialize)]
struct Cargo {
    package: Option<Package>,
}

#[derive(Deserialize)]
struct Package {
    metadata: Option<Metadata>,
}

#[derive(Deserialize)]
struct Metadata {
    x: Option<Xconf>,
}

pub type Xconf = HashMap<String, String>;

fn read_file(path: &Path) -> Result<String> {
    fs::read_to_string(path)
        .with_context(|| format!("failed to read {}", path.display()))
}

fn parse_xconf(path: &Path) -> Result<Xconf> {
    if !path.exists() {
        return Ok(HashMap::new());
    }

    toml::from_str(&read_file(path)?)
        .with_context(|| format!("failed to parse {}", path.display()))
}

fn dotx(home_dir: Option<&Path>) -> Result<Xconf> {
    let Some(home_dir) = home_dir else {
        return Ok(HashMap::new());
    };

    parse_xconf(&home_dir.join(".x.toml"))
}

fn x(root: &Path) -> Result<Xconf> {
    parse_xconf(&root.join("x.toml"))
}

fn cargo(root: &Path) -> Result<Xconf> {
    let path = root.join("Cargo.toml");
    if !path.exists() {
        return Ok(HashMap::new());
    }

    let cargo_toml: Cargo = toml::from_str(&read_file(&path)?)
        .with_context(|| format!("failed to parse {}", path.display()))?;

    Ok(cargo_toml
        .package
        .and_then(|package| package.metadata)
        .and_then(|metadata| metadata.x)
        .unwrap_or_default())
}

fn get_from(home_dir: Option<&Path>, root: Option<&Path>) -> Result<Xconf> {
    let mut x_conf = dotx(home_dir)?;

    if let Some(root) = root {
        x_conf.extend(x(root)?);
        x_conf.extend(cargo(root)?);
    }

    if x_conf.contains_key("x") {
        // avoid problem caused by run `cargo-x x` directly
        bail!("command key `x` is reserved");
    }

    Ok(x_conf)
}

pub fn get() -> Result<Xconf> {
    let home_dir = dirs::home_dir();
    let root = super::meta::root()?;

    get_from(home_dir.as_deref(), root.as_deref())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::env;
    use std::time::{SystemTime, UNIX_EPOCH};

    fn temp_dir(label: &str) -> std::path::PathBuf {
        let nanos = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos();
        env::temp_dir().join(format!(
            "cargo-x-test-{}-{label}-{nanos}",
            std::process::id()
        ))
    }

    #[test]
    fn merges_configs_with_local_precedence() {
        let home = temp_dir("home");
        let root = temp_dir("root");
        fs::create_dir_all(&home).unwrap();
        fs::create_dir_all(&root).unwrap();
        fs::write(home.join(".x.toml"), "shared = \"home\"\nhome = \"yes\"\n")
            .unwrap();
        fs::write(root.join("x.toml"), "shared = \"local\"\nlocal = \"yes\"\n")
            .unwrap();
        fs::write(
            root.join("Cargo.toml"),
            "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n\n[package.metadata.x]\nshared = \"cargo\"\ncargo = \"yes\"\n",
        )
        .unwrap();

        let conf = get_from(Some(&home), Some(&root)).unwrap();

        assert_eq!(conf.get("shared").map(String::as_str), Some("cargo"));
        assert_eq!(conf.get("home").map(String::as_str), Some("yes"));
        assert_eq!(conf.get("local").map(String::as_str), Some("yes"));
        assert_eq!(conf.get("cargo").map(String::as_str), Some("yes"));

        fs::remove_dir_all(home).unwrap();
        fs::remove_dir_all(root).unwrap();
    }

    #[test]
    fn rejects_reserved_x_command() {
        let home = temp_dir("reserved");
        fs::create_dir_all(&home).unwrap();
        fs::write(home.join(".x.toml"), "x = \"cargo test\"\n").unwrap();

        let err = get_from(Some(&home), None).unwrap_err();

        assert!(err.to_string().contains("command key `x` is reserved"));

        fs::remove_dir_all(home).unwrap();
    }
}