calcli 0.4.0

Fast terminal calculator (TUI) with history, variables and engineering helpers
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
138
139
140
141
142
143

//! Syntax-highlight styles and the caret colours the text editor paints with.
//!
//! Everything the shared palette already names (accent, selection, borders,
//! errors) is read from [`Palette`]. Only the per-token
//! expression colours live here, because no palette colour means "the colour of
//! a function name".

use ratada::style::{dim, fg, to_ratatui};
use ratatui::style::{Color, Modifier, Style};

use crate::config::HighlightColors;
use crate::domain::highlight::TokenKind;
use crate::theme::Palette;

/// The colours the block caret and the selection are painted with, resolved
/// once from the palette and handed to the text editor.
#[derive(Debug, Clone, Copy)]
pub struct CaretColors {
    /// Background of the cell the caret covers.
    pub cursor: Color,
    /// Background of the selected cells.
    pub selection: Color,
}

impl CaretColors {
    /// Reads the caret colours from the active palette.
    pub fn from_palette(palette: &Palette) -> Self {
        CaretColors {
            cursor: to_ratatui(palette.cursor),
            selection: to_ratatui(palette.selection),
        }
    }
}

/// The resolved per-category styles for syntax highlighting.
#[derive(Debug, Clone)]
pub struct Highlight {
    function: Style,
    constant: Style,
    operator: Style,
    number: Style,
    variable: Style,
    unit: Style,
    paren: Style,
    ans: Style,
    comment: Style,
    plain: Style,
}

impl Highlight {
    /// Builds the highlight styles from the configured token colours.
    ///
    /// Operators are rendered bold, parentheses dim, `ans` underlined and
    /// comments italic; the rest use their configured colour plainly.
    pub fn new(colors: &HighlightColors) -> Self {
        Highlight {
            function: fg(colors.function),
            constant: fg(colors.constant),
            operator: fg(colors.operator).add_modifier(Modifier::BOLD),
            number: fg(colors.number),
            variable: fg(colors.variable),
            unit: fg(colors.unit),
            paren: dim(),
            ans: fg(colors.ans).add_modifier(Modifier::UNDERLINED),
            comment: fg(colors.comment).add_modifier(Modifier::ITALIC),
            plain: Style::default(),
        }
    }

    /// The style for a token kind.
    pub fn style(&self, kind: TokenKind) -> Style {
        match kind {
            TokenKind::Function => self.function,
            TokenKind::Constant => self.constant,
            TokenKind::Operator => self.operator,
            TokenKind::Number => self.number,
            TokenKind::Variable => self.variable,
            TokenKind::Unit => self.unit,
            TokenKind::Paren => self.paren,
            TokenKind::Ans => self.ans,
            TokenKind::Comment => self.comment,
            TokenKind::Plain => self.plain,
        }
    }
}

/// Maps per-character token kinds to per-character styles.
pub fn styles_for(kinds: &[TokenKind], highlight: &Highlight) -> Vec<Style> {
    kinds.iter().map(|kind| highlight.style(*kind)).collect()
}

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

    #[test]
    fn highlight_maps_the_token_colours_and_adds_the_modifiers() {
        let colors = HighlightColors::default();
        let highlight = Highlight::new(&colors);

        assert_eq!(
            highlight.style(TokenKind::Function).fg,
            Some(to_ratatui(colors.function)),
        );

        let ans = highlight.style(TokenKind::Ans);
        assert_eq!(ans.fg, Some(to_ratatui(colors.ans)));
        assert!(ans.add_modifier.contains(Modifier::UNDERLINED));

        let operator = highlight.style(TokenKind::Operator);
        assert_eq!(operator.fg, Some(to_ratatui(colors.operator)));
        assert!(operator.add_modifier.contains(Modifier::BOLD));

        let comment = highlight.style(TokenKind::Comment);
        assert!(comment.add_modifier.contains(Modifier::ITALIC));

        assert!(
            highlight
                .style(TokenKind::Paren)
                .add_modifier
                .contains(Modifier::DIM)
        );
    }

    #[test]
    fn the_caret_reads_its_colours_from_the_palette() {
        let palette = Config::default().palette();
        let caret = CaretColors::from_palette(&palette);
        assert_eq!(caret.cursor, to_ratatui(palette.cursor));
        assert_eq!(caret.selection, to_ratatui(palette.selection));
        assert_ne!(caret.cursor, caret.selection);
    }

    #[test]
    fn styles_for_maps_one_style_per_character() {
        let highlight = Highlight::new(&HighlightColors::default());
        let kinds = [TokenKind::Number, TokenKind::Operator, TokenKind::Number];
        let styles = styles_for(&kinds, &highlight);
        assert_eq!(styles.len(), 3);
        assert!(styles[1].add_modifier.contains(Modifier::BOLD));
    }
}