Restructure markdown highlighter

src/markdown/highlighter.rs

@@ -0,0 +1,268 @@
+use egui::text::{CCursorRange, LayoutJob};
+
+use crate::markdown::{
+    span::Span,
+    tokenizer::{Heading, Token, TokenKind, tokenize},
+};
+
+/// Highlight markdown, caching previous output to save CPU.
+#[derive(Default)]
+pub struct MemoizedHighlighter {
+    style: egui::Style,
+    code: String,
+    output: LayoutJob,
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+pub struct Style {
+    /// # heading (large text)
+    pub heading: Option<Heading>,
+
+    /// > quoted (slightly dimmer color or other font style)
+    pub quoted: bool,
+
+    /// `code` (monospace, some other color)
+    pub code: bool,
+
+    /// self.strong* (emphasized, e.g. bold)
+    pub strong: bool,
+
+    /// _underline_
+    pub underline: bool,
+
+    /// ~strikethrough~
+    pub strikethrough: bool,
+
+    /// /italics/
+    pub italics: bool,
+
+    /// $small$
+    pub small: bool,
+
+    /// ^raised^
+    pub raised: bool,
+}
+
+impl MemoizedHighlighter {
+    pub fn highlight(
+        &mut self,
+        egui_style: &egui::Style,
+        code: &str,
+        cursor: Option<CCursorRange>,
+    ) -> LayoutJob {
+        if (&self.style, self.code.as_str()) != (egui_style, code) {
+            self.style = egui_style.clone();
+            code.clone_into(&mut self.code);
+            self.output = highlight_markdown(egui_style, code, cursor);
+        }
+        self.output.clone()
+    }
+}
+
+pub fn highlight_markdown(
+    egui_style: &egui::Style,
+    text: &str,
+
+    // TODO: hide special characters where cursor isn't
+    _cursor: Option<CCursorRange>,
+) -> LayoutJob {
+    let mut job = LayoutJob::default();
+    let mut style = Style::default();
+
+    let mut prev = TokenKind::Newline;
+
+    let tokens: Vec<_> = tokenize(text).collect();
+    let mut tokens = &tokens[..];
+
+    const CODE_INDENT: f32 = 10.0;
+
+    while !tokens.is_empty() {
+        let token = tokens.first().unwrap();
+        tokens = &tokens[1..];
+
+        let start_of_line = prev == TokenKind::Newline;
+        prev = token.kind;
+
+        let mut basic_style: Option<fn(&mut Style) -> &mut bool> = None;
+
+        match token.kind {
+            TokenKind::CodeBlock if start_of_line => {
+                let span = collect_until(
+                    token,
+                    &mut tokens,
+                    series([TokenKind::Newline, TokenKind::CodeBlock]),
+                );
+
+                let code_style = format_from_style(
+                    egui_style,
+                    &Style {
+                        code: true,
+                        ..Default::default()
+                    },
+                );
+
+                job.append(&*span, CODE_INDENT, code_style.clone());
+                style = Default::default();
+                continue;
+            }
+
+            TokenKind::Newline => style = Style::default(),
+
+            TokenKind::Strong => basic_style = Some(|s| &mut s.strong),
+            TokenKind::Italic => basic_style = Some(|s| &mut s.italics),
+            TokenKind::Strikethrough => basic_style = Some(|s| &mut s.strikethrough),
+
+            TokenKind::CodeBlock | TokenKind::Mono => {
+                style.code = true;
+                let span = collect_until(
+                    token,
+                    &mut tokens,
+                    any_of([TokenKind::Mono, TokenKind::CodeBlock, TokenKind::Newline]),
+                );
+                job.append(&*span, 0.0, format_from_style(egui_style, &style));
+                style.code = false;
+                continue;
+            }
+
+            // TODO: different heading strengths
+            TokenKind::Heading(h) if start_of_line => style.heading = Some(h),
+            TokenKind::Quote if start_of_line => style.quoted = true,
+
+            // TODO: indented list entries
+            TokenKind::ListEntry if start_of_line => {
+                job.append("• ", 0.0, format_from_style(egui_style, &style));
+                continue;
+            }
+
+            TokenKind::Text
+            // the following tokens are only richly rendered if encountered e.g. at start_of_line.
+            | TokenKind::Indentation
+            | TokenKind::ListEntry
+            | TokenKind::Heading(..)
+            | TokenKind::Quote => {}
+        }
+
+        // if we encountered a marker for Bold, Italic, or Strikethrough, toggle that style and
+        // render the token with the style enabled.
+        if let Some(basic_style) = basic_style {
+            let mut tmp_style = style;
+            *basic_style(&mut tmp_style) = true;
+            *basic_style(&mut style) ^= true; // toggle
+            job.append(&token.span, 0.0, format_from_style(egui_style, &tmp_style));
+            continue;
+        }
+
+        job.append(&token.span, 0.0, format_from_style(egui_style, &style));
+    }
+
+    job
+}
+
+fn series<'a, const N: usize>(of: [TokenKind; N]) -> impl FnMut(&[Token<'a>; N]) -> bool {
+    move |token| {
+        of.iter()
+            .zip(token)
+            .all(|(kind, token)| kind == &token.kind)
+    }
+}
+
+fn any_of<'a, const N: usize>(these: [TokenKind; N]) -> impl FnMut(&[Token<'a>; 1]) -> bool {
+    move |[token]| these.contains(&token.kind)
+}
+
+/// Collect all tokens up to and including `pattern`, and merge them into a signle span.
+///
+/// `N` determines how many specific and consecutive tokens we are looking for.
+/// i.e. if we were looking for a [TokenKind::Newline] followed by a [TokenKind::Quote], `N`
+/// would equal `2`.
+///
+/// `pattern` is a function that accepts an array of `N` tokens and returns `true` if they match,
+/// i.e. if we should stop collecting. [any_of] and [series] can help to construct this function.
+///
+/// The collected tokens will be split off the head of the slice referred to by `tokens`.
+///
+/// # Panic
+/// Panics if `tokens` does not contain only consecutive adjacent spans.
+fn collect_until<'a, const N: usize>(
+    token: &Token<'a>,
+    tokens: &mut &[Token<'a>],
+    pattern: impl FnMut(&[Token<'a>; N]) -> bool,
+) -> Span<'a>
+where
+    for<'b> &'b [Token<'a>; N]: TryFrom<&'b [Token<'a>]>,
+{
+    let mut windows = tokens
+        .windows(N)
+        .map(|slice| <&[Token<'a>; N]>::try_from(slice).ok().unwrap());
+
+    let split_at = match windows.position(pattern) {
+        Some(i) => i + N,
+        None => tokens.len(), // consume everything
+    };
+
+    let (consume, keep) = tokens.split_at(split_at);
+    *tokens = keep;
+
+    consume
+        .iter()
+        .fold(token.span.clone(), |span: Span<'_>, token| {
+            span.try_merge(&token.span).unwrap()
+        })
+}
+
+fn format_from_style(egui_style: &egui::Style, emark_style: &Style) -> egui::text::TextFormat {
+    use egui::{Align, Color32, Stroke, TextStyle};
+
+    let color = if emark_style.strong || emark_style.heading.is_some() {
+        egui_style.visuals.strong_text_color()
+    } else if emark_style.quoted {
+        egui_style.visuals.weak_text_color()
+    } else {
+        egui_style.visuals.text_color()
+    };
+
+    let text_style = if emark_style.heading.is_some() {
+        TextStyle::Heading
+    } else if emark_style.code {
+        TextStyle::Monospace
+    } else if emark_style.small | emark_style.raised {
+        TextStyle::Small
+    } else {
+        TextStyle::Body
+    };
+
+    let background = if emark_style.code {
+        egui_style.visuals.code_bg_color
+    } else {
+        Color32::TRANSPARENT
+    };
+
+    let underline = if emark_style.underline {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let strikethrough = if emark_style.strikethrough {
+        Stroke::new(1.0, color)
+    } else {
+        Stroke::NONE
+    };
+
+    let valign = if emark_style.raised {
+        Align::TOP
+    } else {
+        Align::BOTTOM
+    };
+
+    egui::text::TextFormat {
+        font_id: text_style.resolve(egui_style),
+        color,
+        background,
+        italics: emark_style.italics,
+        underline,
+        strikethrough,
+        valign,
+        ..Default::default()
+    }
+}