runcc 2.0.3

run commands concurrently with rust and cargo
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

use serde::{Deserialize, Serialize};
use std::{convert::TryFrom, fmt::Display};

pub struct InvalidEnvName(String);

impl Display for InvalidEnvName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Invalid env name {}", self.0)
    }
}

#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(try_from = "String")]
#[serde(into = "String")]
pub struct EnvName(String);

impl TryFrom<String> for EnvName {
    type Error = InvalidEnvName;

    fn try_from(value: String) -> Result<Self, Self::Error> {
        if EnvName::check_str(&value) {
            Ok(Self(value))
        } else {
            Err(InvalidEnvName(value))
        }
    }
}

impl Into<String> for EnvName {
    fn into(self) -> String {
        self.0
    }
}

impl EnvName {
    pub fn to_string(self) -> String {
        self.0
    }

    pub fn check_str(s: &str) -> bool {
        s.len() > 0
            && s.chars().enumerate().all(|(i, c)| match c {
                'a'..='z' | 'A'..='Z' => true,
                '0'..='9' | '_' => i > 0,
                _ => false,
            })
    }
}

#[non_exhaustive]
#[derive(Deserialize, Serialize, Debug, Clone)]
pub enum WindowsCallCmdWithEnv {
    Random,
    EnvName(EnvName),
    Disable,
}

#[cfg(windows)]
fn get_random_env_name() -> String {
    use rand::{thread_rng, Rng};

    let mut rng = thread_rng();

    (0..8).map(|_| rng.gen_range('A'..='Z')).collect()
}

#[cfg(not(windows))]
fn get_random_env_name() -> String {
    "RANDNAME".to_string()
}

impl WindowsCallCmdWithEnv {
    pub fn try_into_env_name(self) -> Option<String> {
        match self {
            Self::Random => Some(format!("RUNCC_WIN_CMD__{}", get_random_env_name())),
            Self::EnvName(env_name) => Some(env_name.to_string()),
            Self::Disable => None,
        }
    }
}

impl Default for WindowsCallCmdWithEnv {
    fn default() -> Self {
        Self::Random
    }
}

/// strictly validate env name [a-zA-Z][a-zA-Z0-9_]*
#[cfg(test)]
mod tests {
    use super::EnvName;

    #[test]
    fn test_is_valid_env_name() {
        assert!(EnvName::check_str("MY_ENV_0123_"));

        assert!(!EnvName::check_str(""));
        assert!(!EnvName::check_str(" "));
        assert!(!EnvName::check_str("123abc"));
        assert!(!EnvName::check_str("_MY_ENV"));
    }
}