hulthe/inkr
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Restructure markdown highlighter

Browse Source
This commit is contained in:
hulthe committed 2025-07-07 11:40:15 +02:00
1 parent 83ad2068e0
commit 7f93084e64
15 files changed
+683 -600
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/easy_mark/easy_mark_highlighter.rs
-243
View File
@@ -1,243 +0,0 @@
use egui::text::{CCursorRange, LayoutJob};
use crate::easy_mark::easy_mark_parser;
/// Highlight easymark, memoizing previous output to save CPU.
///
/// In practice, the highlighter is fast enough not to need any caching.
#[derive(Default)]
pub struct MemoizedHighlighter {
style: egui::Style,
code: String,
output: LayoutJob,
}
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_easymark(egui_style, code, cursor);
}
self.output.clone()
}
}
pub fn highlight_easymark(
egui_style: &egui::Style,
mut text: &str,
// TODO: hide special characters where cursor isn't
_cursor: Option<CCursorRange>,
) -> LayoutJob {
let mut job = LayoutJob::default();
let mut style = easy_mark_parser::Style::default();
let mut start_of_line = true;
const CODE_INDENT: f32 = 10.0;
while !text.is_empty() {
if start_of_line && text.starts_with("```") {
let astyle = format_from_style(
egui_style,
&easy_mark_parser::Style {
code: true,
..Default::default()
},
);
// Render the initial backticks as spaces
text = &text[3..];
job.append(" ", CODE_INDENT, astyle.clone());
match text.find("\n```") {
Some(n) => {
for line in text[..n + 1].lines() {
job.append(line, CODE_INDENT, astyle.clone());
job.append("\n", 0.0, astyle.clone());
}
// Render the final backticks as spaces
job.append(" ", CODE_INDENT, astyle);
text = &text[n + 4..];
}
None => {
job.append(text, 0.0, astyle.clone());
text = "";
}
};
style = Default::default();
continue;
}
if text.starts_with('`') {
style.code = true;
let end = text[1..]
.find(&['`', '\n'][..])
.map_or_else(|| text.len(), |i| i + 2);
job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
text = &text[end..];
style.code = false;
continue;
}
let skip;
// zero-width space
let _zws = "\u{200b}";
let mut apply_basic_style =
|text: &mut &str,
style: &mut easy_mark_parser::Style,
access: fn(&mut easy_mark_parser::Style) -> &mut bool| {
let skip = if *access(style) {
// Include the character that is ending this style:
job.append(&text[..1], 0.0, format_from_style(egui_style, style));
*text = &text[1..];
0
} else {
1
};
*access(style) ^= true;
skip
};
if text.starts_with('*') {
skip = apply_basic_style(&mut text, &mut style, |style| &mut style.strong);
} else if text.starts_with('/') {
skip = apply_basic_style(&mut text, &mut style, |style| &mut style.italics);
} else if text.starts_with('_') {
skip = apply_basic_style(&mut text, &mut style, |style| &mut style.underline);
} else if text.starts_with('$') {
skip = apply_basic_style(&mut text, &mut style, |style| &mut style.small);
} else if text.starts_with('~') {
skip = apply_basic_style(&mut text, &mut style, |style| &mut style.strikethrough);
} else if text.starts_with('^') {
skip = apply_basic_style(&mut text, &mut style, |style| &mut style.raised);
} else if text.starts_with('\\') && text.len() >= 2 {
skip = 2;
} else if start_of_line && text.starts_with(' ') {
// we don't preview indentation, because it is confusing
skip = 1;
} else if start_of_line && text.starts_with("###### ") {
style.heading = true;
skip = 7;
} else if start_of_line && text.starts_with("##### ") {
style.heading = true;
skip = 6;
} else if start_of_line && text.starts_with("#### ") {
style.heading = true;
skip = 5;
} else if start_of_line && text.starts_with("### ") {
style.heading = true;
skip = 4;
} else if start_of_line && text.starts_with("## ") {
style.heading = true;
skip = 3;
} else if start_of_line && text.starts_with("# ") {
style.heading = true;
skip = 2;
} else if start_of_line && text.starts_with("> ") {
style.quoted = true;
skip = 2;
// we don't preview indentation, because it is confusing
} else if start_of_line && text.trim_start().starts_with("- ") {
job.append("• ", 0.0, format_from_style(egui_style, &style));
text = &text[2..];
skip = 0;
// we don't preview indentation, because it is confusing
} else {
skip = 0;
}
// Note: we don't preview underline, strikethrough and italics because it confuses things.
// Swallow everything up to the next special character:
let line_end = text[skip..]
.find('\n')
.map_or_else(|| text.len(), |i| (skip + i + 1));
let end = text[skip..]
.find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '['][..])
.map_or_else(|| text.len(), |i| (skip + i).max(1));
if line_end <= end {
job.append(
&text[..line_end],
0.0,
format_from_style(egui_style, &style),
);
text = &text[line_end..];
start_of_line = true;
style = Default::default();
} else {
job.append(&text[..end], 0.0, format_from_style(egui_style, &style));
text = &text[end..];
start_of_line = false;
}
}
job
}
fn format_from_style(
egui_style: &egui::Style,
emark_style: &easy_mark_parser::Style,
) -> egui::text::TextFormat {
use egui::{Align, Color32, Stroke, TextStyle};
let color = if emark_style.strong || emark_style.heading {
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 {
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()
}
}
src/easy_mark/easy_mark_parser.rs
-346
View File
@@ -1,346 +0,0 @@
//! A parser for `EasyMark`: a very simple markup language.
//!
//! WARNING: `EasyMark` is subject to change.
//
//! # `EasyMark` design goals:
//! 1. easy to parse
//! 2. easy to learn
//! 3. similar to markdown
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Item<'a> {
/// `\n`
// TODO(emilk): add Style here so empty heading still uses up the right amount of space.
Newline,
/// Text
Text(Style, &'a str),
/// title, url
Hyperlink(Style, &'a str, &'a str),
/// leading space before e.g. a [`Self::BulletPoint`].
Indentation(usize),
/// >
QuoteIndent,
/// - a point well made.
BulletPoint,
/// 1. numbered list. The string is the number(s).
NumberedPoint(&'a str),
/// ---
Separator,
/// language, code
CodeBlock(&'a str, &'a str),
}
#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
pub struct Style {
/// # heading (large text)
pub heading: bool,
/// > 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,
}
/// Parser for the `EasyMark` markup language.
pub struct Parser<'a> {
/// The remainder of the input text
s: &'a str,
/// Are we at the start of a line?
start_of_line: bool,
/// Current self.style. Reset after a newline.
style: Style,
}
impl<'a> Parser<'a> {
pub fn new(s: &'a str) -> Self {
Self {
s,
start_of_line: true,
style: Style::default(),
}
}
/// `1. `, `42. ` etc.
fn numbered_list(&mut self) -> Option<Item<'a>> {
let n_digits = self.s.chars().take_while(|c| c.is_ascii_digit()).count();
if n_digits > 0 && self.s.chars().skip(n_digits).take(2).eq(". ".chars()) {
let number = &self.s[..n_digits];
self.s = &self.s[(n_digits + 2)..];
self.start_of_line = false;
return Some(Item::NumberedPoint(number));
}
None
}
// ```{language}\n{code}```
fn code_block(&mut self) -> Option<Item<'a>> {
if let Some(language_start) = self.s.strip_prefix("```") {
if let Some(newline) = language_start.find('\n') {
let language = &language_start[..newline];
let code_start = &language_start[newline + 1..];
if let Some(end) = code_start.find("\n```") {
let code = &code_start[..end].trim();
self.s = &code_start[end + 4..];
self.start_of_line = false;
return Some(Item::CodeBlock(language, code));
} else {
self.s = "";
return Some(Item::CodeBlock(language, code_start));
}
}
}
None
}
// `code`
fn inline_code(&mut self) -> Option<Item<'a>> {
if let Some(rest) = self.s.strip_prefix('`') {
self.s = rest;
self.start_of_line = false;
self.style.code = true;
let rest_of_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
if let Some(end) = rest_of_line.find('`') {
let item = Item::Text(self.style, &self.s[..end]);
self.s = &self.s[end + 1..];
self.style.code = false;
return Some(item);
} else {
let end = rest_of_line.len();
let item = Item::Text(self.style, rest_of_line);
self.s = &self.s[end..];
self.style.code = false;
return Some(item);
}
}
None
}
/// `<url>` or `[link](url)`
fn url(&mut self) -> Option<Item<'a>> {
if self.s.starts_with('<') {
let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
if let Some(url_end) = this_line.find('>') {
let url = &self.s[1..url_end];
self.s = &self.s[url_end + 1..];
self.start_of_line = false;
return Some(Item::Hyperlink(self.style, url, url));
}
}
// [text](url)
if self.s.starts_with('[') {
let this_line = &self.s[..self.s.find('\n').unwrap_or(self.s.len())];
if let Some(bracket_end) = this_line.find(']') {
let text = &this_line[1..bracket_end];
if this_line[bracket_end + 1..].starts_with('(') {
if let Some(parens_end) = this_line[bracket_end + 2..].find(')') {
let parens_end = bracket_end + 2 + parens_end;
let url = &self.s[bracket_end + 2..parens_end];
self.s = &self.s[parens_end + 1..];
self.start_of_line = false;
return Some(Item::Hyperlink(self.style, text, url));
}
}
}
}
None
}
}
impl<'a> Iterator for Parser<'a> {
type Item = Item<'a>;
fn next(&mut self) -> Option<Self::Item> {
loop {
if self.s.is_empty() {
return None;
}
// \n
if self.s.starts_with('\n') {
self.s = &self.s[1..];
self.start_of_line = true;
self.style = Style::default();
return Some(Item::Newline);
}
// Ignore line break (continue on the same line)
if self.s.starts_with("\\\n") && self.s.len() >= 2 {
self.s = &self.s[2..];
self.start_of_line = false;
continue;
}
// \ escape (to show e.g. a backtick)
if self.s.starts_with('\\') && self.s.len() >= 2 {
let text = &self.s[1..2];
self.s = &self.s[2..];
self.start_of_line = false;
return Some(Item::Text(self.style, text));
}
if self.start_of_line {
// leading space (indentation)
if self.s.starts_with(' ') {
let length = self.s.find(|c| c != ' ').unwrap_or(self.s.len());
self.s = &self.s[length..];
self.start_of_line = true; // indentation doesn't count
return Some(Item::Indentation(length));
}
// # Heading
if let Some(after) = self.s.strip_prefix("# ") {
self.s = after;
self.start_of_line = false;
self.style.heading = true;
continue;
}
// > quote
if let Some(after) = self.s.strip_prefix("> ") {
self.s = after;
self.start_of_line = true; // quote indentation doesn't count
self.style.quoted = true;
return Some(Item::QuoteIndent);
}
// - bullet point
if self.s.starts_with("- ") {
self.s = &self.s[2..];
self.start_of_line = false;
return Some(Item::BulletPoint);
}
// `1. `, `42. ` etc.
if let Some(item) = self.numbered_list() {
return Some(item);
}
// --- separator
if let Some(after) = self.s.strip_prefix("---") {
self.s = after.trim_start_matches('-'); // remove extra dashes
self.s = self.s.strip_prefix('\n').unwrap_or(self.s); // remove trailing newline
self.start_of_line = false;
return Some(Item::Separator);
}
// ```{language}\n{code}```
if let Some(item) = self.code_block() {
return Some(item);
}
}
// `code`
if let Some(item) = self.inline_code() {
return Some(item);
}
if let Some(rest) = self.s.strip_prefix('*') {
self.s = rest;
self.start_of_line = false;
self.style.strong = !self.style.strong;
continue;
}
if let Some(rest) = self.s.strip_prefix('_') {
self.s = rest;
self.start_of_line = false;
self.style.underline = !self.style.underline;
continue;
}
if let Some(rest) = self.s.strip_prefix('~') {
self.s = rest;
self.start_of_line = false;
self.style.strikethrough = !self.style.strikethrough;
continue;
}
if let Some(rest) = self.s.strip_prefix('/') {
self.s = rest;
self.start_of_line = false;
self.style.italics = !self.style.italics;
continue;
}
if let Some(rest) = self.s.strip_prefix('$') {
self.s = rest;
self.start_of_line = false;
self.style.small = !self.style.small;
continue;
}
if let Some(rest) = self.s.strip_prefix('^') {
self.s = rest;
self.start_of_line = false;
self.style.raised = !self.style.raised;
continue;
}
// `<url>` or `[link](url)`
if let Some(item) = self.url() {
return Some(item);
}
// Swallow everything up to the next special character:
let end = self
.s
.find(&['*', '`', '~', '_', '/', '$', '^', '\\', '<', '[', '\n'][..])
.map_or_else(|| self.s.len(), |special| special.max(1));
let item = Item::Text(self.style, &self.s[..end]);
self.s = &self.s[end..];
self.start_of_line = false;
return Some(item);
}
}
}
#[test]
fn test_easy_mark_parser() {
let items: Vec<_> = Parser::new("~strikethrough `code`~").collect();
assert_eq!(
items,
vec![
Item::Text(
Style {
strikethrough: true,
..Default::default()
},
"strikethrough "
),
Item::Text(
Style {
code: true,
strikethrough: true,
..Default::default()
},
"code"
),
]
);
}
src/easy_mark/mod.rs
-7
View File
@@ -1,7 +0,0 @@
//! Experimental markup language
mod easy_mark_highlighter;
pub mod easy_mark_parser;
pub use easy_mark_highlighter::{MemoizedHighlighter, highlight_easymark};
pub use easy_mark_parser as parser;
src/handwriting/advanced-example.md
+3
View File
@@ -0,0 +1,3 @@
```handwriting
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 truncated
```
src/lib.rs
+1 -1
View File
@@ -3,8 +3,8 @@
pub mod app;
pub mod constants;
pub mod custom_code_block;
pub mod easy_mark;
pub mod file_editor;
pub mod markdown;
pub mod painting;
pub mod preferences;
pub mod rasterizer;
src/markdown/ast.rs
+54
View File
@@ -0,0 +1,54 @@
use super::span::Span;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Heading {
H1,
H2,
H3,
H4,
H5,
H6,
}
#[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,
}
pub enum MarkdownItem<'a> {
Text {
span: Span<'a>,
style: Style,
},
CodeBlock {
all: Span<'a>,
language: Span<'a>,
code: Span<'a>,
},
}
src/markdown/grammar.lalrpop
+10
View File
@@ -0,0 +1,10 @@
use std::str::FromStr;
grammar;
pub Term: i32 = {
<n:Num> => n,
"(" <t:Term> ")" => t,
};
Num: i32 = <s:r"[0-9]+"> => i32::from_str(s).unwrap();
src/markdown/highlighter.rs
+268
View File
@@ -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()
}
}
src/markdown/mod.rs
+7
View File
@@ -0,0 +1,7 @@
mod highlighter;
mod span;
mod tokenizer;
pub use highlighter::*;
pub use span::*;
pub use tokenizer::*;
src/markdown/snapshots/inkr__markdown__tokenizer__tests__tokenize.snap
+46
View File
@@ -0,0 +1,46 @@
---
source: src/markdown/tokenizer.rs
expression: examples
---
- string: "just some normal text :D"
tokens:
- "Token { span: Span(0..24, \"just some normal text :D\"), kind: Text }"
- string: normal *bold* normal
tokens:
- "Token { span: Span(0..7, \"normal \"), kind: Text }"
- "Token { span: Span(7..8, \"*\"), kind: Strong }"
- "Token { span: Span(8..12, \"bold\"), kind: Text }"
- "Token { span: Span(12..13, \"*\"), kind: Strong }"
- "Token { span: Span(13..20, \" normal\"), kind: Text }"
- string: normal * maybe bold? * normal
tokens:
- "Token { span: Span(0..7, \"normal \"), kind: Text }"
- "Token { span: Span(7..8, \"*\"), kind: Strong }"
- "Token { span: Span(8..21, \" maybe bold? \"), kind: Text }"
- "Token { span: Span(21..22, \"*\"), kind: Strong }"
- "Token { span: Span(22..29, \" normal\"), kind: Text }"
- string: "```lang\ncode code code\n```"
tokens:
- "Token { span: Span(0..3, \"```\"), kind: CodeBlock }"
- "Token { span: Span(3..7, \"lang\"), kind: Text }"
- "Token { span: Span(7..8, \"\\n\"), kind: Newline }"
- "Token { span: Span(8..22, \"code code code\"), kind: Text }"
- "Token { span: Span(22..23, \"\\n\"), kind: Newline }"
- "Token { span: Span(23..26, \"```\"), kind: CodeBlock }"
- string: "*/``/*"
tokens:
- "Token { span: Span(0..1, \"*\"), kind: Strong }"
- "Token { span: Span(1..2, \"/\"), kind: Italic }"
- "Token { span: Span(2..3, \"`\"), kind: Mono }"
- "Token { span: Span(3..4, \"`\"), kind: Mono }"
- "Token { span: Span(4..5, \"/\"), kind: Italic }"
- "Token { span: Span(5..6, \"*\"), kind: Strong }"
- string: "*/`*/*/"
tokens:
- "Token { span: Span(0..1, \"*\"), kind: Strong }"
- "Token { span: Span(1..2, \"/\"), kind: Italic }"
- "Token { span: Span(2..3, \"`\"), kind: Mono }"
- "Token { span: Span(3..4, \"*\"), kind: Strong }"
- "Token { span: Span(4..5, \"/\"), kind: Italic }"
- "Token { span: Span(5..6, \"*\"), kind: Strong }"
- "Token { span: Span(6..7, \"/\"), kind: Italic }"
src/markdown/span.rs
+83
View File
@@ -0,0 +1,83 @@
use std::{
fmt,
ops::{Deref, Range},
};
#[derive(Clone, Eq, PartialEq)]
pub struct Span<'a> {
complete_str: &'a str,
range: Range<usize>,
}
impl<'a> Span<'a> {
pub fn new(complete_str: &'a str) -> Self {
Self {
complete_str,
range: 0..complete_str.len(),
}
}
pub fn get(&self, slice: Range<usize>) -> Option<Self> {
let start = self.range.start.checked_add(slice.start)?;
let end = self.range.start.checked_add(slice.end)?;
if end > self.range.end || end < start {
return None;
}
Some(Self {
complete_str: self.complete_str,
range: Range { start, end },
})
}
pub fn complete_str(&self) -> Self {
Self::new(self.complete_str)
}
pub fn split_at(&self, i: usize) -> Option<(Self, Self)> {
let head = self.get(0..i)?;
let tail = self.get(i..self.range.len())?;
Some((head, tail))
}
/// Try to merge the spans.
///
/// This only works if spans are pointing into the same backing buffer, and are adjacent.
pub fn try_merge(&self, other: &Self) -> Option<Self> {
if self.complete_str.as_ptr() != other.complete_str.as_ptr() {
return None;
}
if self.range.end == other.range.start {
Some(Self {
range: self.range.start..other.range.end,
..*self
})
} else if self.range.start == other.range.end {
Some(Self {
range: other.range.start..self.range.end,
..*self
})
} else {
None
}
}
}
impl Deref for Span<'_> {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.complete_str[self.range.clone()]
}
}
impl<'a> fmt::Debug for Span<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Span")
.field(&self.range)
.field(&self.deref())
.finish()
}
}
src/markdown/tokenizer.rs
+156
View File
@@ -0,0 +1,156 @@
use std::iter;
use super::span::Span;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Heading {
H6,
H5,
H4,
H3,
H2,
H1,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TokenKind {
/// A newline that isn't a codeblock
Newline,
/// "#" to "######"
Heading(Heading),
/// A newline followed by three `
CodeBlock,
Mono,
Strong,
Italic,
Strikethrough,
/// ">"
Quote,
/// Two spaces
Indentation,
/// "- "
ListEntry,
/// Normal text
Text,
}
const TOKENS: &[(&'static str, TokenKind)] = &[
("\n", TokenKind::Newline),
("######", TokenKind::Heading(Heading::H6)),
("#####", TokenKind::Heading(Heading::H5)),
("####", TokenKind::Heading(Heading::H4)),
("###", TokenKind::Heading(Heading::H3)),
("##", TokenKind::Heading(Heading::H2)),
("#", TokenKind::Heading(Heading::H1)),
("```", TokenKind::CodeBlock),
("`", TokenKind::Mono),
("*", TokenKind::Strong),
("_", TokenKind::Italic),
("~", TokenKind::Strikethrough),
(">", TokenKind::Quote),
(" ", TokenKind::Indentation),
("- ", TokenKind::ListEntry),
];
#[derive(Debug)]
pub struct Token<'a> {
pub span: Span<'a>,
pub kind: TokenKind,
}
pub fn tokenize<'a>(s: &'a str) -> impl Iterator<Item = Token<'a>> {
let mut s = Span::new(s);
let mut yield_n: usize = 0;
iter::from_fn(move || {
loop {
if s.is_empty() {
return None;
}
if yield_n == s.len() {
let (token, rest) = s.split_at(s.len()).unwrap();
let token = Token {
span: token,
kind: TokenKind::Text,
};
s = rest;
return Some(token);
}
let token = TOKENS.iter().find_map(|(token_str, token_kind)| {
s[yield_n..]
.starts_with(token_str)
.then(|| (*token_kind, token_str.len()))
});
let Some((kind, len)) = token else {
yield_n += s[yield_n..].chars().next().unwrap_or('\0').len_utf8();
continue;
};
if yield_n > 0 {
let (token, rest) = s.split_at(yield_n).unwrap();
let token = Token {
span: token,
kind: TokenKind::Text,
};
s = rest;
yield_n = 0;
return Some(token);
}
let (token, rest) = s.split_at(len).unwrap();
let token = Token { span: token, kind };
s = rest;
return Some(token);
}
})
}
#[cfg(test)]
mod tests {
use serde::Serialize;
use super::tokenize;
#[test]
fn test_tokenize() {
let examples = [
"just some normal text :D",
"normal *bold* normal",
"normal * maybe bold? * normal",
"```lang\ncode code code\n```",
"*/``/*",
"*/`*/*/",
];
#[derive(Serialize)]
struct Result {
pub string: &'static str,
/// Debug-printed tokens
pub tokens: Vec<String>,
}
let examples = examples
.into_iter()
.map(|string| {
let tokens = tokenize(string)
.map(|tokens| format!("{tokens:?}"))
.collect::<Vec<_>>();
Result { string, tokens }
})
.collect::<Vec<_>>();
insta::assert_yaml_snapshot!(examples);
}
}
src/snapshots/inkr__custom_code_block__test__iter_markdown-2.snap.new
+44
View File
@@ -0,0 +1,44 @@
---
source: src/custom_code_block.rs
assertion_line: 133
expression: list
---
[
Line(
"\n",
),
Line(
"# Hello world\n",
),
Line(
"## Subheader\n",
),
Line(
"- 1\n",
),
CodeBlock {
key: "foo",
content: " whatever\n some code\n Hi mom!",
span: "```foo\n whatever\n some code\n Hi mom!\n```",
},
Line(
" \n",
),
Line(
"\n",
),
CodeBlock {
key: "` # wrong number of ticks, but that's ok",
content: " ``` # indented ticks",
span: "```` # wrong number of ticks, but that's ok\n ``` # indented ticks\n```\n",
},
Line(
"\n",
),
Line(
"``` # no closing ticks\n",
),
Line(
" ",
),
]
src/snapshots/inkr__painting__test__serialized handwriting.snap.new
+8
View File
@@ -0,0 +1,8 @@
---
source: src/painting.rs
assertion_line: 695
expression: serialized
---
```handwriting
BQAAvAA8AEIAPABCAEIAPgBAAAAAAAQAAEIAQgC8ADwAAAAAAEIAPA==
```
src/text_editor.rs
+3 -3
View File
@@ -8,7 +8,7 @@ use egui::{
Color32, InputState, Key, Modifiers, TextBuffer, TextEdit, Ui, Vec2, text::CCursorRange,
};
use crate::easy_mark::MemoizedHighlighter;
use crate::markdown::MemoizedHighlighter;
#[derive(Default, serde::Deserialize, serde::Serialize)]
pub struct MdTextEdit {
@@ -46,8 +46,8 @@ impl MdTextEdit {
let w = ui.available_width();
let mut layouter = |ui: &egui::Ui, easymark: &dyn TextBuffer, _wrap_width: f32| {
let mut layout_job = highlighter.highlight(ui.style(), easymark.as_str(), *cursor);
let mut layouter = |ui: &egui::Ui, markdown: &dyn TextBuffer, _wrap_width: f32| {
let mut layout_job = highlighter.highlight(ui.style(), markdown.as_str(), *cursor);
layout_job.wrap.max_width = w - 10.0;
ui.fonts(|f| f.layout_job(layout_job))
};