abacus 0.2.1

The mathemagical programming language
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

use colored::Color;

#[derive(Debug, Clone, Copy, Default)]
pub struct TextStyle {
    pub bold: bool,
    pub dim: bool,
}

#[must_use]
pub fn colorize(text: &str, color: Color, enabled: bool) -> String {
    paint(text, color, TextStyle::default(), enabled)
}

#[must_use]
pub fn colorize_bold(text: &str, color: Color, enabled: bool) -> String {
    paint(
        text,
        color,
        TextStyle {
            bold: true,
            dim: false,
        },
        enabled,
    )
}

#[must_use]
pub fn colorize_dim(text: &str, color: Color, enabled: bool) -> String {
    paint(
        text,
        color,
        TextStyle {
            bold: false,
            dim: true,
        },
        enabled,
    )
}

#[must_use]
pub fn paint(text: &str, color: Color, style: TextStyle, enabled: bool) -> String {
    if !enabled {
        return text.to_string();
    }

    let mut codes = String::new();
    if style.bold {
        codes.push_str("1;");
    }
    if style.dim {
        codes.push_str("2;");
    }
    codes.push_str(&foreground_code(color));

    format!("\x1b[{codes}m{text}\x1b[0m")
}

fn foreground_code(color: Color) -> String {
    color.to_fg_str().into_owned()
}

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

    struct EnvGuard {
        key: &'static str,
        original: Option<String>,
    }

    impl EnvGuard {
        fn set(key: &'static str, value: &str) -> Self {
            let original = env::var(key).ok();
            unsafe { env::set_var(key, value) };
            Self { key, original }
        }
    }

    impl Drop for EnvGuard {
        fn drop(&mut self) {
            match &self.original {
                Some(v) => unsafe { env::set_var(self.key, v) },
                None => unsafe { env::remove_var(self.key) },
            }
        }
    }

    #[test]
    fn colorize_bold_wraps_content() {
        let rendered = colorize_bold("hi", Color::Red, true);
        assert!(rendered.starts_with("\x1b[1;31m"));
        assert!(rendered.ends_with("\x1b[0m"));
    }

    #[test]
    fn colorize_honors_enabled_flag() {
        let rendered = colorize("hi", Color::Red, false);
        assert_eq!(rendered, "hi");
    }

    #[test]
    fn colorize_dim_applies_dim_code() {
        let rendered = colorize_dim("x", Color::Yellow, true);
        assert!(
            rendered.starts_with("\x1b[2;33m"),
            "dim yellow should use ESC[2;33m prefix, got {rendered:?}"
        );
    }

    #[test]
    fn paint_combines_bold_and_dim() {
        let rendered = paint(
            "mix",
            Color::BrightCyan,
            TextStyle {
                bold: true,
                dim: true,
            },
            true,
        );
        assert!(
            rendered.starts_with("\x1b[1;2;96m"),
            "expected bold+dim bright cyan prefix, got {rendered:?}"
        );
    }

    #[test]
    fn truecolor_renders_24bit_sequence_when_supported() {
        let _guard = EnvGuard::set("COLORTERM", "truecolor");
        let rendered = colorize("rgb", Color::TrueColor { r: 1, g: 2, b: 3 }, true);
        assert!(
            rendered.starts_with("\x1b[38;2;1;2;3m"),
            "truecolor should emit 38;2 sequence when supported, got {rendered:?}"
        );
    }
}