a3s-tui 0.1.0

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

use crate::element::{BoxElement, Element, FlexDirection, TextElement};
use crate::style::Color;

/// A breadcrumb navigation component.
///
/// Displays a path of items separated by a configurable separator,
/// with the last item highlighted as the current location.
pub struct Breadcrumb {
    items: Vec<String>,
    separator: String,
    active_color: Color,
    inactive_color: Color,
    separator_color: Color,
}

impl Breadcrumb {
    pub fn new(items: Vec<impl Into<String>>) -> Self {
        Self {
            items: items.into_iter().map(|i| i.into()).collect(),
            separator: " › ".to_string(),
            active_color: Color::White,
            inactive_color: Color::BrightBlack,
            separator_color: Color::BrightBlack,
        }
    }

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

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

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

    pub fn element<Msg>(&self) -> Element<Msg> {
        let mut children: Vec<Element<Msg>> = Vec::new();
        let last_idx = self.items.len().saturating_sub(1);

        for (i, item) in self.items.iter().enumerate() {
            let is_last = i == last_idx;

            if is_last {
                children.push(Element::Text(
                    TextElement::new(item.as_str()).bold().fg(self.active_color),
                ));
            } else {
                children.push(Element::Text(
                    TextElement::new(item.as_str()).fg(self.inactive_color),
                ));
                children.push(Element::Text(
                    TextElement::new(&self.separator).fg(self.separator_color),
                ));
            }
        }

        Element::Box(
            BoxElement::new()
                .direction(FlexDirection::Row)
                .children(children),
        )
    }
}

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

    #[test]
    fn single_item() {
        let bc = Breadcrumb::new(vec!["Home"]);
        let el: Element<()> = bc.element();
        match el {
            Element::Box(b) => assert_eq!(b.children.len(), 1),
            _ => panic!("expected Box"),
        }
    }

    #[test]
    fn multiple_items_have_separators() {
        let bc = Breadcrumb::new(vec!["Home", "Docs", "API"]);
        let el: Element<()> = bc.element();
        match el {
            Element::Box(b) => {
                // 3 items + 2 separators = 5 children
                assert_eq!(b.children.len(), 5);
            }
            _ => panic!("expected Box"),
        }
    }

    #[test]
    fn custom_separator() {
        let bc = Breadcrumb::new(vec!["a", "b"]).separator(" / ");
        let el: Element<()> = bc.element();
        match el {
            Element::Box(b) => {
                match &b.children[1] {
                    Element::Text(t) => assert_eq!(t.content, " / "),
                    _ => panic!("expected separator text"),
                }
            }
            _ => panic!("expected Box"),
        }
    }
}