shelly-shell 0.5.2

A Rust based Unix style shell with a typed and structured language syntax.
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


use std::sync::{ Arc, Mutex };

use reedline::{ Highlighter, StyledText };

use crate::{ language::analysis::{ analyze_semantics, SymbolSnapshot,
                                  highlight::{ highlight_spans, HighlightSpan } },
             runtime::color::TtyColorMode };

mod palette;
pub use crate::runtime::highlighting::palette::{ SyntaxSettings, SYNTAX_COLORS };


#[derive(Default)]
struct HighlightCache
{
    source: String,
    spans: Vec<HighlightSpan>,
}


pub struct ShellyHighlighter
{
    snapshot: Arc<SymbolSnapshot>,
    settings: SyntaxSettings,
    cache: Mutex<HighlightCache>,
}


impl ShellyHighlighter
{
    pub fn new(snapshot: Arc<SymbolSnapshot>, settings: SyntaxSettings) -> Self
    {
        Self
            {
                snapshot, settings, cache: Mutex::new(HighlightCache::default()),
            }
    }

    fn styled(&self, source: &str, spans: &[HighlightSpan]) -> StyledText
    {
        let mut styled = StyledText::new();
        for span in spans
        {
            let color = self.settings.colors[span.kind as usize];
            let style = color.map_or_else(Default::default, |color| color.normal());
            if let Some(text) = span.span.slice(source) { styled.push((style, text.to_string())); }
        }
        styled
    }
}


impl Highlighter for ShellyHighlighter
{
    fn highlight(&self, line: &str, _cursor: usize) -> StyledText
    {
        if !self.settings.enabled || self.settings.mode == TtyColorMode::TtyMonochrome
        {
            let mut plain = StyledText::new();
            plain.push((Default::default(), line.to_string()));
            return plain;
        }
        let mut cache = self.cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
        if cache.source != line
        {
            let analysis = analyze_semantics(line, &self.snapshot);
            cache.spans = highlight_spans(line, &analysis);
            cache.source = line.to_string();
        }
        // Cursor movement and completion redraws reuse the same classifications.
        self.styled(line, &cache.spans)
    }
}