From 8040b82ff15909aa2b6f169b9feb017e00105167 Mon Sep 17 00:00:00 2001 From: Joscha Date: Sun, 23 Feb 2025 20:22:04 +0100 Subject: [PATCH] Refactor euph message content highlighting --- cove/src/euph.rs | 2 + cove/src/euph/highlight.rs | 203 ++++++++++++++++++++++++++++++++ cove/src/euph/small_message.rs | 206 +-------------------------------- 3 files changed, 210 insertions(+), 201 deletions(-) create mode 100644 cove/src/euph/highlight.rs diff --git a/cove/src/euph.rs b/cove/src/euph.rs index d1fd872..77bf1db 100644 --- a/cove/src/euph.rs +++ b/cove/src/euph.rs @@ -1,7 +1,9 @@ +pub use highlight::*; pub use room::*; pub use small_message::*; pub use util::*; +mod highlight; mod room; mod small_message; mod util; diff --git a/cove/src/euph/highlight.rs b/cove/src/euph/highlight.rs new file mode 100644 index 0000000..e60a302 --- /dev/null +++ b/cove/src/euph/highlight.rs @@ -0,0 +1,203 @@ +use std::ops::Range; + +use crossterm::style::Stylize; +use toss::{Style, Styled}; + +use crate::euph::util; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SpanType { + Mention, + Room, + Emoji, +} + +fn nick_char(ch: char) -> bool { + // Closely following the heim mention regex: + // https://github.com/euphoria-io/heim/blob/978c921063e6b06012fc8d16d9fbf1b3a0be1191/client/lib/stores/chat.js#L14-L15 + // `>` has been experimentally confirmed to delimit mentions as well. + match ch { + ',' | '.' | '!' | '?' | ';' | '&' | '<' | '>' | '\'' | '"' => false, + _ => !ch.is_whitespace(), + } +} + +fn room_char(ch: char) -> bool { + // Basically just \w, see also + // https://github.com/euphoria-io/heim/blob/978c921063e6b06012fc8d16d9fbf1b3a0be1191/client/lib/ui/MessageText.js#L66 + ch.is_ascii_alphanumeric() || ch == '_' +} + +struct SpanFinder<'a> { + content: &'a str, + + span: Option<(SpanType, usize)>, + room_or_mention_possible: bool, + + result: Vec<(SpanType, Range)>, +} + +impl<'a> SpanFinder<'a> { + fn is_valid_span(&self, span: SpanType, range: Range) -> bool { + let text = &self.content[range.start..range.end]; + match span { + SpanType::Mention => range.len() > 1 && text.starts_with('@'), + SpanType::Room => range.len() > 1 && text.starts_with('&'), + SpanType::Emoji => { + if range.len() <= 2 { + return false; + } + + let Some(name) = Some(text) + .and_then(|it| it.strip_prefix(':')) + .and_then(|it| it.strip_suffix(':')) + else { + return false; + }; + + util::EMOJI.get(name).is_some() + } + } + } + + fn close_span(&mut self, end: usize) { + let Some((span, start)) = self.span else { + return; + }; + if self.is_valid_span(span, start..end) { + self.result.push((span, start..end)); + } + self.span = None; + } + + fn open_span(&mut self, span: SpanType, start: usize) { + self.close_span(start); + self.span = Some((span, start)) + } + + fn step(&mut self, idx: usize, char: char) { + match (char, self.span) { + ('@', _) if self.room_or_mention_possible => self.open_span(SpanType::Mention, idx), + ('&', _) if self.room_or_mention_possible => self.open_span(SpanType::Room, idx), + (':', None) => self.open_span(SpanType::Emoji, idx), + (':', Some((SpanType::Emoji, _))) => self.close_span(idx + 1), + (c, Some((SpanType::Mention, _))) if !nick_char(c) => self.close_span(idx), + (c, Some((SpanType::Room, _))) if !room_char(c) => self.close_span(idx), + _ => {} + } + + // More permissive than the heim web client + self.room_or_mention_possible = !char.is_alphanumeric(); + } + + fn find(content: &'a str) -> Vec<(SpanType, Range)> { + let mut this = Self { + content, + span: None, + room_or_mention_possible: true, + result: vec![], + }; + + for (idx, char) in content.char_indices() { + this.step(idx, char); + } + + this.close_span(content.len()); + + this.result + } +} + +pub fn find_spans(content: &str) -> Vec<(SpanType, Range)> { + SpanFinder::find(content) +} + +/// Highlight spans in a string. +/// +/// The list of spans must be non-overlapping and in ascending order. +/// +/// If `exact` is specified, colon-delimited emoji are not replaced with their +/// unicode counterparts. +pub fn apply_spans( + content: &str, + spans: &[(SpanType, Range)], + base: Style, + exact: bool, +) -> Styled { + let mut result = Styled::default(); + let mut i = 0; + + for (span, range) in spans { + assert!(i <= range.start); + assert!(range.end <= content.len()); + + if i < range.start { + result = result.then_plain(&content[i..range.start]); + } + + let text = &content[range.start..range.end]; + result = match span { + SpanType::Mention if exact => result.and_then(util::style_nick_exact(text, base)), + SpanType::Mention => result.and_then(util::style_nick(text, base)), + SpanType::Room => result.then(text, base.blue().bold()), + SpanType::Emoji if exact => result.then(text, base.magenta()), + SpanType::Emoji => { + let name = text.strip_prefix(':').unwrap_or(text); + let name = name.strip_suffix(':').unwrap_or(name); + if let Some(Some(replacement)) = util::EMOJI.get(name) { + result.then_plain(replacement) + } else { + result.then(name, base.magenta()) + } + } + }; + + i = range.end; + } + + if i < content.len() { + result = result.then_plain(&content[i..]); + } + + result +} + +/// Highlight an euphoria message's content. +/// +/// If `exact` is specified, colon-delimited emoji are not replaced with their +/// unicode counterparts. +pub fn highlight(content: &str, base: Style, exact: bool) -> Styled { + apply_spans(content, &find_spans(content), base, exact) +} + +#[cfg(test)] +mod tests { + + use crate::euph::SpanType; + + use super::find_spans; + + #[test] + fn mentions() { + assert_eq!(find_spans("@foo"), vec![(SpanType::Mention, 0..4)]); + assert_eq!(find_spans("a @foo b"), vec![(SpanType::Mention, 2..6)]); + assert_eq!(find_spans("@@foo@"), vec![(SpanType::Mention, 1..6)]); + assert_eq!(find_spans("a @b@c d"), vec![(SpanType::Mention, 2..6)]); + assert_eq!( + find_spans("a @b @c d"), + vec![(SpanType::Mention, 2..4), (SpanType::Mention, 5..7)] + ); + } + + #[test] + fn rooms() { + assert_eq!(find_spans("&foo"), vec![(SpanType::Room, 0..4)]); + assert_eq!(find_spans("a &foo b"), vec![(SpanType::Room, 2..6)]); + assert_eq!(find_spans("&&foo&"), vec![(SpanType::Room, 1..5)]); + assert_eq!(find_spans("a &b&c d"), vec![(SpanType::Room, 2..4)]); + assert_eq!( + find_spans("a &b &c d"), + vec![(SpanType::Room, 2..4), (SpanType::Room, 5..7)] + ); + } +} diff --git a/cove/src/euph/small_message.rs b/cove/src/euph/small_message.rs index 20596fa..003cd40 100644 --- a/cove/src/euph/small_message.rs +++ b/cove/src/euph/small_message.rs @@ -1,5 +1,3 @@ -use std::mem; - use crossterm::style::Stylize; use euphoxide::api::{MessageId, Snowflake, Time}; use jiff::Timestamp; @@ -7,200 +5,6 @@ use toss::{Style, Styled}; use crate::{store::Msg, ui::ChatMsg}; -use super::util; - -fn nick_char(ch: char) -> bool { - // Closely following the heim mention regex: - // https://github.com/euphoria-io/heim/blob/978c921063e6b06012fc8d16d9fbf1b3a0be1191/client/lib/stores/chat.js#L14-L15 - // `>` has been experimentally confirmed to delimit mentions as well. - match ch { - ',' | '.' | '!' | '?' | ';' | '&' | '<' | '>' | '\'' | '"' => false, - _ => !ch.is_whitespace(), - } -} - -fn room_char(ch: char) -> bool { - // Basically just \w, see also - // https://github.com/euphoria-io/heim/blob/978c921063e6b06012fc8d16d9fbf1b3a0be1191/client/lib/ui/MessageText.js#L66 - ch.is_ascii_alphanumeric() || ch == '_' -} - -enum Span { - Nothing, - Mention, - Room, - Emoji, -} - -struct Highlighter<'a> { - content: &'a str, - base_style: Style, - exact: bool, - - span: Span, - span_start: usize, - room_or_mention_possible: bool, - - result: Styled, -} - -impl<'a> Highlighter<'a> { - /// Does *not* guarantee `self.span_start == idx` after running! - fn close_mention(&mut self, idx: usize) { - let span_length = idx.saturating_sub(self.span_start); - if span_length <= 1 { - // We can repurpose the current span - self.span = Span::Nothing; - return; - } - - let text = &self.content[self.span_start..idx]; // Includes @ - self.result = mem::take(&mut self.result).and_then(if self.exact { - util::style_nick_exact(text, self.base_style) - } else { - util::style_nick(text, self.base_style) - }); - - self.span = Span::Nothing; - self.span_start = idx; - } - - /// Does *not* guarantee `self.span_start == idx` after running! - fn close_room(&mut self, idx: usize) { - let span_length = idx.saturating_sub(self.span_start); - if span_length <= 1 { - // We can repurpose the current span - self.span = Span::Nothing; - return; - } - - self.result = mem::take(&mut self.result).then( - &self.content[self.span_start..idx], - self.base_style.blue().bold(), - ); - - self.span = Span::Nothing; - self.span_start = idx; - } - - // Warning: `idx` is the index of the closing colon. - fn close_emoji(&mut self, idx: usize) { - let name = &self.content[self.span_start + 1..idx]; - if let Some(replace) = util::EMOJI.get(name) { - match replace { - Some(replace) if !self.exact => { - self.result = mem::take(&mut self.result).then(replace, self.base_style); - } - _ => { - let text = &self.content[self.span_start..=idx]; - let style = self.base_style.magenta(); - self.result = mem::take(&mut self.result).then(text, style); - } - } - - self.span = Span::Nothing; - self.span_start = idx + 1; - } else { - self.close_plain(idx); - self.span = Span::Emoji; - } - } - - /// Guarantees `self.span_start == idx` after running. - fn close_plain(&mut self, idx: usize) { - if self.span_start == idx { - // Span has length 0 - return; - } - - self.result = - mem::take(&mut self.result).then(&self.content[self.span_start..idx], self.base_style); - - self.span = Span::Nothing; - self.span_start = idx; - } - - fn close_span_before_current_char(&mut self, idx: usize, char: char) { - match self.span { - Span::Mention if !nick_char(char) => self.close_mention(idx), - Span::Room if !room_char(char) => self.close_room(idx), - Span::Emoji if char == '&' || char == '@' => { - self.span = Span::Nothing; - } - _ => {} - } - } - - fn update_span_with_current_char(&mut self, idx: usize, char: char) { - match self.span { - Span::Nothing if char == '@' && self.room_or_mention_possible => { - self.close_plain(idx); - self.span = Span::Mention; - } - Span::Nothing if char == '&' && self.room_or_mention_possible => { - self.close_plain(idx); - self.span = Span::Room; - } - Span::Nothing if char == ':' => { - self.close_plain(idx); - self.span = Span::Emoji; - } - Span::Emoji if char == ':' => self.close_emoji(idx), - _ => {} - } - } - - fn close_final_span(&mut self) { - let idx = self.content.len(); - if self.span_start >= idx { - return; // Span has no contents - } - - match self.span { - Span::Mention => self.close_mention(idx), - Span::Room => self.close_room(idx), - _ => {} - } - - self.close_plain(idx); - } - - fn step(&mut self, idx: usize, char: char) { - if self.span_start < idx { - self.close_span_before_current_char(idx, char); - } - - self.update_span_with_current_char(idx, char); - - // More permissive than the heim web client - self.room_or_mention_possible = !char.is_alphanumeric(); - } - - fn highlight(content: &'a str, base_style: Style, exact: bool) -> Styled { - let mut this = Self { - content: if exact { content } else { content.trim() }, - base_style, - exact, - span: Span::Nothing, - span_start: 0, - room_or_mention_possible: true, - result: Styled::default(), - }; - - for (idx, char) in (if exact { content } else { content.trim() }).char_indices() { - this.step(idx, char); - } - - this.close_final_span(); - - this.result - } -} - -fn highlight_content(content: &str, base_style: Style, exact: bool) -> Styled { - Highlighter::highlight(content, base_style, exact) -} - #[derive(Debug, Clone)] pub struct SmallMessage { pub id: MessageId, @@ -221,22 +25,22 @@ fn style_me() -> Style { fn styled_nick(nick: &str) -> Styled { Styled::new_plain("[") - .and_then(util::style_nick(nick, Style::new())) + .and_then(super::style_nick(nick, Style::new())) .then_plain("]") } fn styled_nick_me(nick: &str) -> Styled { let style = style_me(); - Styled::new("*", style).and_then(util::style_nick(nick, style)) + Styled::new("*", style).and_then(super::style_nick(nick, style)) } fn styled_content(content: &str) -> Styled { - highlight_content(content.trim(), Style::new(), false) + super::highlight(content.trim(), Style::new(), false) } fn styled_content_me(content: &str) -> Styled { let style = style_me(); - highlight_content(content.trim(), style, false).then("*", style) + super::highlight(content.trim(), style, false).then("*", style) } fn styled_editor_content(content: &str) -> Styled { @@ -245,7 +49,7 @@ fn styled_editor_content(content: &str) -> Styled { } else { Style::new() }; - highlight_content(content, style, true) + super::highlight(content, style, true) } impl Msg for SmallMessage {