mkdir2 0.1.7

A modern, cross-platform, production-ready replacement for mkdir: brace expansion, mixed `/`/`\` path separators, safe force-recreate, colored + emoji output, JSON reports, dry-run and more.
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
146

//! Colored, optionally emoji-decorated console output, with custom
//! hex (`#RRGGBB`) colors for each message category.

use colored::{Color, Colorize};
use is_terminal::IsTerminal;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ColorMode {
    Auto,
    Always,
    Never,
}

impl std::str::FromStr for ColorMode {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "auto" => Ok(ColorMode::Auto),
            "always" => Ok(ColorMode::Always),
            "never" => Ok(ColorMode::Never),
            other => Err(format!(
                "invalid value '{other}' for --color, expected auto|always|never"
            )),
        }
    }
}

/// Decide whether colored output should be used, honoring `NO_COLOR` and
/// whether stdout is an interactive terminal.
pub fn should_use_color(mode: ColorMode) -> bool {
    match mode {
        ColorMode::Always => true,
        ColorMode::Never => false,
        ColorMode::Auto => {
            std::env::var_os("NO_COLOR").is_none() && std::io::stdout().is_terminal()
        }
    }
}

/// Parse a `#RRGGBB` or `RRGGBB` hex string into an RGB triple.
pub fn parse_hex(s: &str) -> Result<(u8, u8, u8), String> {
    let trimmed = s.trim().trim_start_matches('#');
    if trimmed.len() != 6 || !trimmed.chars().all(|c| c.is_ascii_hexdigit()) {
        return Err(format!(
            "invalid hex color '{s}', expected a format like #00FFFF"
        ));
    }
    let r = u8::from_str_radix(&trimmed[0..2], 16).unwrap();
    let g = u8::from_str_radix(&trimmed[2..4], 16).unwrap();
    let b = u8::from_str_radix(&trimmed[4..6], 16).unwrap();
    Ok((r, g, b))
}

#[derive(Debug, Clone)]
pub struct Theme {
    pub success: (u8, u8, u8),
    pub error: (u8, u8, u8),
    pub warn: (u8, u8, u8),
    pub info: (u8, u8, u8),
    pub enabled: bool,
    pub emoji: bool,
}

impl Default for Theme {
    fn default() -> Self {
        Theme {
            success: (0x00, 0xC8, 0x53), // green
            error: (0xFF, 0x3B, 0x30),   // red
            warn: (0xFF, 0xA5, 0x00),    // amber
            info: (0x00, 0xAF, 0xFF),    // cyan-blue
            enabled: true,
            emoji: true,
        }
    }
}

impl Theme {
    fn paint(&self, text: &str, rgb: (u8, u8, u8)) -> String {
        if self.enabled {
            text.color(Color::TrueColor {
                r: rgb.0,
                g: rgb.1,
                b: rgb.2,
            })
            .to_string()
        } else {
            text.to_string()
        }
    }

    pub fn success(&self, text: &str) -> String {
        let icon = if self.emoji { "✅ " } else { "" };
        format!("{icon}{}", self.paint(text, self.success))
    }

    pub fn error(&self, text: &str) -> String {
        let icon = if self.emoji { "❌ " } else { "" };
        format!("{icon}{}", self.paint(text, self.error))
    }

    pub fn warn(&self, text: &str) -> String {
        let icon = if self.emoji { "⚠️  " } else { "" };
        format!("{icon}{}", self.paint(text, self.warn))
    }

    pub fn info(&self, text: &str) -> String {
        let icon = if self.emoji { "📁 " } else { "" };
        format!("{icon}{}", self.paint(text, self.info))
    }
}

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

    #[test]
    fn parses_hex_with_hash() {
        assert_eq!(parse_hex("#00FFFF").unwrap(), (0, 255, 255));
    }

    #[test]
    fn parses_hex_without_hash() {
        assert_eq!(parse_hex("00ffff").unwrap(), (0, 255, 255));
    }

    #[test]
    fn parses_mixed_case() {
        assert_eq!(parse_hex("#AaBbCc").unwrap(), (0xAA, 0xBB, 0xCC));
    }

    #[test]
    fn rejects_invalid_hex() {
        assert!(parse_hex("#ZZZZZZ").is_err());
        assert!(parse_hex("#FFF").is_err());
        assert!(parse_hex("not-a-color").is_err());
    }

    #[test]
    fn color_mode_parses_known_values() {
        use std::str::FromStr;
        assert_eq!(ColorMode::from_str("auto").unwrap(), ColorMode::Auto);
        assert_eq!(ColorMode::from_str("ALWAYS").unwrap(), ColorMode::Always);
        assert_eq!(ColorMode::from_str("never").unwrap(), ColorMode::Never);
        assert!(ColorMode::from_str("rainbow").is_err());
    }
}