a3s-tui 0.1.4

TEA (The Elm Architecture) framework for terminal user interfaces
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

use crate::components::Sparkline;
use crate::style::{truncate_visible, visible_len, Color};

#[derive(Debug, Clone)]
pub struct MetricTrend {
    value: Option<f64>,
    history: Vec<f64>,
    width: usize,
    trend_width: usize,
    min: f64,
    max: f64,
    fg: Color,
    missing: String,
}

impl MetricTrend {
    pub fn new(value: Option<f64>, history: impl IntoIterator<Item = f64>) -> Self {
        Self {
            value: value.filter(|value| value.is_finite()),
            history: history
                .into_iter()
                .filter(|value| value.is_finite())
                .collect(),
            width: 15,
            trend_width: 8,
            min: 0.0,
            max: 100.0,
            fg: Color::Cyan,
            missing: "-".into(),
        }
    }

    pub fn width(mut self, width: usize) -> Self {
        self.width = width.max(1);
        self
    }

    pub fn trend_width(mut self, width: usize) -> Self {
        self.trend_width = width.max(1);
        self
    }

    pub fn range(mut self, min: f64, max: f64) -> Self {
        self.min = min;
        self.max = max.max(min);
        self
    }

    pub fn fg(mut self, color: Color) -> Self {
        self.fg = color;
        self
    }

    pub fn missing(mut self, missing: impl Into<String>) -> Self {
        self.missing = missing.into();
        self
    }

    pub fn view(&self) -> String {
        let label = self.value_label();
        if self.width <= visible_len(&label) {
            return truncate_visible(&label, self.width);
        }

        let available = self.width - visible_len(&label) - 1;
        if available == 0 {
            return truncate_visible(&label, self.width);
        }
        let trend_width = self.trend_width.min(available);
        let trend = Sparkline::new(self.history.iter().copied())
            .width(trend_width)
            .range(self.min, self.max)
            .fg(self.fg)
            .view();
        let cell = format!("{label} {trend}");

        if visible_len(&cell) < self.width {
            format!("{cell}{}", " ".repeat(self.width - visible_len(&cell)))
        } else {
            cell
        }
    }

    pub fn plain(&self) -> String {
        crate::style::strip_ansi(&self.view())
    }

    fn value_label(&self) -> String {
        self.value
            .map(|value| format!("{value:>5.1}%"))
            .unwrap_or_else(|| format!("{:>6}", self.missing))
    }
}

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

    #[test]
    fn renders_metric_and_trend_at_fixed_width() {
        let cell = MetricTrend::new(Some(12.5), [0.0, 10.0, 20.0])
            .width(15)
            .plain();

        assert_eq!(visible_len(&cell), 15);
        assert!(cell.starts_with(" 12.5% "));
    }

    #[test]
    fn renders_missing_metric_with_placeholder_trend() {
        let cell = MetricTrend::new(None, Vec::<f64>::new()).width(15).plain();

        assert_eq!(visible_len(&cell), 15);
        assert!(cell.starts_with("     - "));
        assert!(cell.contains("ยทยทยทยท"));
    }

    #[test]
    fn truncates_to_narrow_width() {
        let cell = MetricTrend::new(Some(123.4), [100.0]).width(5).plain();

        assert_eq!(visible_len(&cell), 5);
    }
}