glim-tui 0.2.1

A TUI for monitoring GitLab CI/CD pipelines and projects
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

use ratatui::{
    buffer::Buffer,
    layout::{Alignment, Offset, Rect},
    prelude::{Line, Modifier, Span, Style, Widget},
    widgets::Clear,
};

use crate::gruvbox::Gruvbox;

/// shortcuts widget
#[derive(Debug, Clone, Default)]
pub struct Shortcuts<'a> {
    values: Vec<(&'a str, &'a str)>,
    shortcut_label_style: Style,
    shortcut_key_style: Style,
    alignment: Alignment,
}

impl Shortcuts<'_> {
    pub fn from<'a>(values: Vec<(&'a str, &'a str)>) -> Shortcuts<'a> {
        Shortcuts {
            values,
            shortcut_label_style: Style::default()
                .fg(Gruvbox::OrangeDim.into())
                .add_modifier(Modifier::BOLD),
            shortcut_key_style: Style::default()
                .fg(Gruvbox::Orange.into())
                .add_modifier(Modifier::BOLD),
            alignment: Alignment::Right,
        }
    }

    pub fn as_line(&self) -> Line {
        let shortcuts = self
            .values
            .iter()
            .flat_map(|(key, label)| {
                if label.contains(key) {
                    self.spans_from_mnemonic(key, label)
                } else {
                    self.spans_from_shortcut(key, label)
                }
            })
            .collect::<Vec<Span>>();

        Line::from(shortcuts).alignment(self.alignment)
    }

    fn spans_from_shortcut<'a>(&self, key: &'a str, label: &'a str) -> Vec<Span<'a>> {
        vec![
            Span::from(" "),
            Span::from(key).style(self.shortcut_key_style),
            Span::from(" "),
            Span::from(label).style(self.shortcut_label_style),
            Span::from(" "),
        ]
    }

    fn spans_from_mnemonic<'a>(&'a self, key: &'a str, label: &'a str) -> Vec<Span<'a>> {
        let mnemonic = key.chars().next().unwrap();
        let mnemonic_idx = label.find(mnemonic).unwrap();

        let start = Span::from(&label[0..mnemonic_idx]).style(self.shortcut_label_style);
        let m = Span::from(&label[mnemonic_idx..mnemonic_idx + 1]).style(self.shortcut_key_style);
        let end =
            Span::from(&label[mnemonic_idx + 1..label.len()]).style(self.shortcut_label_style);

        vec![Span::from(" "), start, m, end, Span::from(" ")]
    }
}

impl Widget for Shortcuts<'_> {
    fn render(self, area: Rect, buf: &mut Buffer) {
        let line = self.as_line();

        // let len = shortcuts.iter().map(|s| s.content.chars().count()).sum::<usize>() as i32;
        let len = line.width() as i32;
        let delta = area.width as i32 - len;
        let area_to_clear = area.offset(Offset { x: delta, y: 0 }).clamp(area);

        Clear.render(area_to_clear, buf);
        line.render(area, buf);
    }
}