katana-document-viewer 0.1.4

KatanA document viewer artifact, render evaluation, and export foundation.
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

use crate::export_surface_span::{SurfaceTextSpan, SurfaceTextStyle};
use image::Rgba;
use std::sync::LazyLock;
use syntect::easy::HighlightLines;
use syntect::highlighting::{Style, Theme, ThemeSet};
use syntect::parsing::{SyntaxReference, SyntaxSet};
use syntect::util::LinesWithEndings;

const SYNTAX_THEME: &str = "InspiredGitHub";

pub(crate) struct SurfaceCodeHighlighter;

impl SurfaceCodeHighlighter {
    pub(crate) fn highlight(language: Option<&str>, body: &str) -> Vec<Vec<SurfaceTextSpan>> {
        match language.filter(|value| !value.is_empty()) {
            Some(language) => Self::highlight_language(language, body),
            None => body.lines().map(Self::plain_line).collect(),
        }
    }

    fn highlight_language(language: &str, body: &str) -> Vec<Vec<SurfaceTextSpan>> {
        let syntax = syntax(language);
        let mut highlighter = HighlightLines::new(syntax, theme());
        LinesWithEndings::from(body)
            .map(|line| Self::highlight_line(&mut highlighter, line))
            .collect()
    }

    fn highlight_line(highlighter: &mut HighlightLines<'_>, line: &str) -> Vec<SurfaceTextSpan> {
        let line = line.trim_end_matches(['\r', '\n']);
        let fallback = vec![(Style::default(), line)];
        let ranges = highlighter
            .highlight_line(line, syntax_set())
            .unwrap_or(fallback);
        ranges
            .into_iter()
            .map(|(style, text)| SurfaceTextSpan::styled(text, span_style(style)))
            .collect()
    }

    fn plain_line(line: &str) -> Vec<SurfaceTextSpan> {
        let line = line.trim_end_matches(['\r', '\n']);
        vec![SurfaceTextSpan::styled(
            line,
            SurfaceTextStyle::default().monospace(),
        )]
    }
}

fn span_style(style: Style) -> SurfaceTextStyle {
    SurfaceTextStyle::default().monospace().with_color(Rgba([
        style.foreground.r,
        style.foreground.g,
        style.foreground.b,
        style.foreground.a,
    ]))
}

fn syntax(language: &str) -> &'static SyntaxReference {
    syntax_set()
        .find_syntax_by_token(language)
        .or_else(|| syntax_set().find_syntax_by_extension(language))
        .unwrap_or_else(|| syntax_set().find_syntax_plain_text())
}

fn syntax_set() -> &'static SyntaxSet {
    static SYNTAX_SET: LazyLock<SyntaxSet> = LazyLock::new(SyntaxSet::load_defaults_newlines);
    &SYNTAX_SET
}

fn theme_set() -> &'static ThemeSet {
    static THEME_SET: LazyLock<ThemeSet> = LazyLock::new(ThemeSet::load_defaults);
    &THEME_SET
}

fn theme() -> &'static Theme {
    &theme_set().themes[SYNTAX_THEME]
}

#[cfg(test)]
#[path = "export_surface_code_tests.rs"]
mod tests;