accepted 0.2.0

A text editor to be ACCEPTED.
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

use syntect;
use syntect::easy::HighlightLines;
use syntect::highlighting::ThemeSet;
use syntect::parsing::SyntaxDefinition;
use syntect::parsing::SyntaxSet;

pub struct Syntax<'a> {
    pub syntax_set: &'a syntect::parsing::SyntaxSet,
    pub syntax: &'a syntect::parsing::SyntaxReference,
    pub theme: &'a syntect::highlighting::Theme,
}

pub struct SyntaxParent {
    pub syntax_set: SyntaxSet,
    pub theme_set: ThemeSet,
}

impl Default for SyntaxParent {
    fn default() -> Self {
        let syntax_set = SyntaxSet::load_defaults_nonewlines();
        let mut builder = syntax_set.into_builder();
        builder.add(
            SyntaxDefinition::load_from_str(
                include_str!("../assets/TOML.sublime-syntax"),
                false,
                None,
            )
            .unwrap(),
        );
        builder.add(
            SyntaxDefinition::load_from_str(
                include_str!("../assets/Git Commit.sublime-syntax"),
                false,
                None,
            )
            .unwrap(),
        );
        let syntax_set = builder.build();
        Self {
            syntax_set,
            theme_set: ThemeSet::load_defaults(),
        }
    }
}

impl SyntaxParent {
    pub fn load_syntax(&self, extension: &str) -> Option<Syntax> {
        let syntax = self.syntax_set.find_syntax_by_extension(extension)?;
        // let theme = ThemeSet::load_from_reader(&mut Cursor::new(theme::ONE_DARK.as_bytes())).unwrap();
        Some(Syntax {
            syntax_set: &self.syntax_set,
            syntax,
            theme: &self.theme_set.themes["Solarized (dark)"],
        })
    }

    pub fn load_syntax_or_txt(&self, extension: &str) -> Syntax {
        self.load_syntax(extension)
            .unwrap_or_else(|| self.load_syntax("txt").unwrap())
    }
}

impl<'a> Syntax<'a> {
    pub fn highlight_lines(&self) -> HighlightLines<'a> {
        HighlightLines::new(self.syntax, self.theme)
    }
}