accepted 0.3.2

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use std::io::BufReader;
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: 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(),
        );
        builder.add(
            SyntaxDefinition::load_from_str(
                include_str!("../assets/AWK.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, theme: Option<&str>) -> Option<Syntax> {
        let syntax = self.syntax_set.find_syntax_by_extension(extension)?;

        let theme = theme
            .and_then(|s| {
                self.theme_set.themes.get(s).cloned().or_else(|| {
                    shellexpand::full(s).ok().and_then(|s| {
                        let file = std::fs::File::open(s.as_ref()).ok()?;
                        ThemeSet::load_from_reader(&mut BufReader::new(file)).ok()
                    })
                })
            })
            .unwrap_or_else(|| self.theme_set.themes["Solarized (dark)"].clone());
        // let theme = ThemeSet::load_from_reader(&mut Cursor::new(theme::ONE_DARK.as_bytes())).unwrap();
        Some(Syntax {
            syntax_set: &self.syntax_set,
            syntax,
            theme,
        })
    }

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

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