envy-secrets 0.5.1

A secure, deterministic, and frictionless environment variable manager
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

use ratatui::style::Color;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Rgb(pub u8, pub u8, pub u8);

pub const STOPS: [Rgb; 5] = [
    Rgb(0x8A, 0x2B, 0xE2),
    Rgb(0x7B, 0x68, 0xEE),
    Rgb(0x93, 0x70, 0xDB),
    Rgb(0x1A, 0x09, 0x33),
    Rgb(0x0D, 0x02, 0x21),
];

pub fn lerp(a: Rgb, b: Rgb, amount: f32) -> Rgb {
    let amount = amount.clamp(0.0, 1.0);
    Rgb(
        (a.0 as f32 + (b.0 as f32 - a.0 as f32) * amount).round() as u8,
        (a.1 as f32 + (b.1 as f32 - a.1 as f32) * amount).round() as u8,
        (a.2 as f32 + (b.2 as f32 - a.2 as f32) * amount).round() as u8,
    )
}

pub fn gradient(count: usize) -> Vec<Rgb> {
    if count == 0 {
        return Vec::new();
    }
    (0..count)
        .map(|index| {
            let position = if count == 1 {
                0.0
            } else {
                index as f32 / (count - 1) as f32
            };
            let scaled = position * (STOPS.len() - 1) as f32;
            let segment = (scaled.floor() as usize).min(STOPS.len() - 2);
            lerp(STOPS[segment], STOPS[segment + 1], scaled - segment as f32)
        })
        .collect()
}

fn nearest_ansi256(rgb: Rgb) -> u8 {
    let levels = [0u8, 95, 135, 175, 215, 255];
    let level = |value: u8| {
        levels
            .iter()
            .enumerate()
            .min_by_key(|(_, candidate)| (**candidate as i16 - value as i16).abs())
            .map(|(index, _)| index as u8)
            .unwrap_or(0)
    };
    16 + 36 * level(rgb.0) + 6 * level(rgb.1) + level(rgb.2)
}

pub fn color(rgb: Rgb) -> Color {
    if std::env::var_os("NO_COLOR").is_some() {
        return Color::Reset;
    }
    let color_term = std::env::var("COLORTERM")
        .unwrap_or_default()
        .to_ascii_lowercase();
    let term = std::env::var("TERM")
        .unwrap_or_default()
        .to_ascii_lowercase();
    if color_term == "truecolor" || color_term == "24bit" {
        Color::Rgb(rgb.0, rgb.1, rgb.2)
    } else if term.contains("256color") {
        Color::Indexed(nearest_ansi256(rgb))
    } else if console::colors_enabled() {
        Color::Indexed(nearest_ansi256(rgb) % 16)
    } else {
        Color::Reset
    }
}

/// Color used to highlight error messages in the status bar.
pub fn alert() -> Color {
    if std::env::var_os("NO_COLOR").is_some() || !console::colors_enabled() {
        Color::Reset
    } else {
        Color::Red
    }
}

/// Color used to mark the focused panel title and borders (brand violet).
pub fn focus() -> Color {
    color(STOPS[1])
}

/// Color used for healthy/in-sync state.
pub fn ok() -> Color {
    if std::env::var_os("NO_COLOR").is_some() || !console::colors_enabled() {
        Color::Reset
    } else {
        Color::Green
    }
}

/// Color used for drift (needs sync) state.
pub fn drift() -> Color {
    if std::env::var_os("NO_COLOR").is_some() || !console::colors_enabled() {
        Color::Reset
    } else {
        Color::Yellow
    }
}

/// Color used for secondary metadata (labels, hints, legends).
pub fn dim() -> Color {
    if std::env::var_os("NO_COLOR").is_some() || !console::colors_enabled() {
        Color::Reset
    } else {
        Color::DarkGray
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn lerp_reaches_endpoints() {
        assert_eq!(lerp(Rgb(0, 0, 0), Rgb(10, 20, 30), 0.0), Rgb(0, 0, 0));
        assert_eq!(lerp(Rgb(0, 0, 0), Rgb(10, 20, 30), 1.0), Rgb(10, 20, 30));
    }
    #[test]
    fn gradient_is_ordered() {
        let values = gradient(5);
        assert_eq!(values.first(), Some(&STOPS[0]));
        assert_eq!(values.last(), Some(&STOPS[4]));
    }
}