maudit 0.11.0

Library for generating static websites.
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

use core::panic;
use std::sync::OnceLock;
use syntect::{
    Error,
    easy::HighlightLines,
    highlighting::ThemeSet,
    html::{IncludeBackground, styled_line_to_highlighted_html},
    parsing::SyntaxSet,
    util::LinesWithEndings,
};

static SYNTAX_SET: OnceLock<SyntaxSet> = OnceLock::new();
static THEME_SET: OnceLock<ThemeSet> = OnceLock::new();

fn get_syntax_set() -> &'static SyntaxSet {
    SYNTAX_SET.get_or_init(SyntaxSet::load_defaults_newlines)
}

fn get_theme_set() -> &'static ThemeSet {
    THEME_SET.get_or_init(ThemeSet::load_defaults)
}

pub fn highlight_code(content: &str, options: &HighlightOptions) -> Result<String, Error> {
    let ss = get_syntax_set();
    let ts = get_theme_set();

    let syntax = ss
        .find_syntax_by_token(&options.language)
        // Maybe token is enough, looking around at other users of Syntect, it seems like they often just use by_token, not sure.
        .or_else(|| ss.find_syntax_by_name(&options.language))
        .or_else(|| ss.find_syntax_by_extension(&options.language))
        .or_else(|| ss.find_syntax_by_first_line(content))
        .unwrap_or_else(|| ss.find_syntax_plain_text());

    let theme = match ts.themes.get(&options.theme_path) {
        Some(theme) => theme,
        None => &match ThemeSet::get_theme(&options.theme_path) {
            Ok(theme) => theme,
            Err(_) => panic!(
                "Theme '{}' not found in default themes and could not be loaded from file.",
                options.theme_path
            ),
        },
    };

    let mut h = HighlightLines::new(syntax, theme);

    let mut highlighted = String::new();
    for line in LinesWithEndings::from(content) {
        let regions = h.highlight_line(line, ss)?;
        let html = styled_line_to_highlighted_html(&regions, IncludeBackground::No)?; // TODO: Handle the background coloring
        highlighted.push_str(&html);
    }

    Ok(highlighted)
}

fn opening_html(language: Option<&str>) -> String {
    let mut attrs = Vec::new();

    // Follow EC here on the attribute name, though EC only adds it to the pre tag. I figure there's no harm in adding it to the code tag too.
    if let Some(lang) = language {
        attrs.push((String::from("data-language"), format!("\"{lang}\"")));
    }

    let format_attrs = |attrs: &[(String, String)]| {
        if attrs.is_empty() {
            String::new()
        } else {
            let attrs_str = attrs
                .iter()
                .map(|(name, value)| format!("{}={}", name, value))
                .collect::<Vec<_>>()
                .join(" ");
            format!(" {}", attrs_str)
        }
    };

    let pre_attrs_str = format_attrs(&attrs);
    let code_attrs_str = format_attrs(&attrs);

    format!("<pre{pre_attrs_str}><code{code_attrs_str}>")
}

pub struct HighlightOptions {
    pub language: String,
    pub theme_path: String,
}

impl HighlightOptions {
    /// Parse the value after the opening of a fenced Markdown code block
    /// e.g. for ```rust ins=0, you'd get lang: "rs", ins: "0"
    pub fn new_from_fence(fence: &str, theme_path: impl Into<String>) -> Self {
        // TODO: Write the parser for this, lol
        let language = fence.to_string();
        Self {
            language,
            // TODO: We could somehow allow specifying the theme in the fence too, it'd be funny
            theme_path: theme_path.into(),
        }
    }

    #[allow(dead_code)]
    pub fn new(language: impl Into<String>, theme_path: impl Into<String>) -> Self {
        Self {
            language: language.into(),
            theme_path: theme_path.into(),
        }
    }
}

pub struct CodeBlock {
    pub highlight_options: HighlightOptions,
}

impl CodeBlock {
    pub fn new(fence: &str, theme_path: &str) -> (Self, String) {
        let highlight_options = HighlightOptions::new_from_fence(fence, theme_path);
        let opening_html = opening_html(Some(&highlight_options.language));

        (Self { highlight_options }, opening_html)
    }

    pub fn highlight(&self, content: &str) -> Result<String, Error> {
        highlight_code(content, &self.highlight_options)
    }
}