DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
GREP styles: a scan and the pattern cache are bounded (#1598)
Hamzad5a6a7ddd52b
diff --git a/crates/compose/src/grep.rs b/crates/compose/src/grep.rsindex 1d7e0e6a9..09c6459e0 100644--- a/crates/compose/src/grep.rs+++ b/crates/compose/src/grep.rs@@ -23,6 +23,13 @@ use designcraft_doc::story;pub const MAX_PATTERN: usize = 4096;/// Backtracking steps one search may take before it gives up.pub const BACKTRACK_LIMIT: usize = 200_000;+/// Matches one GREP style may contribute to one paragraph.+///+/// [`BACKTRACK_LIMIT`] bounds a single search, not a scan: `find_all` pays it again for every+/// match, so a pattern tuned just under the limit cost `BACKTRACK_LIMIT × matches` per paragraph+/// on every relayout (#1598). A paragraph cannot usefully carry more styled runs than this, and+/// a scan that reaches it stops with what it has.+pub const MAX_MATCHES_PER_PARAGRAPH: usize = 4096;/// Compiled program size cap (bytes) for the underlying regex engine.const SIZE_LIMIT: usize = 4 << 20;diff --git a/crates/compose/src/overlay.rs b/crates/compose/src/overlay.rsindex d65460949..5c95b0ec8 100644--- a/crates/compose/src/overlay.rs+++ b/crates/compose/src/overlay.rs@@ -9,9 +9,42 @@ use designcraft_doc::{GrepStyle, NestedStyle, NestedUntil};use crate::grep::{Grep, GrepOptions};+/// Patterns kept compiled at once. A document's GREP styles are few; the cache grew without+/// bound across every pattern a session ever composed (#1598).+const MAX_CACHED_PATTERNS: usize = 64;+thread_local! {- /// Compiled GREP styles by pattern; None for one that doesn't compile or gave up on a search.- static PATTERNS: RefCell<HashMap<String, Option<Grep>>> = RefCell::new(HashMap::new());+ /// Compiled GREP styles by pattern, with the tick they were last used at; `None` for one that+ /// doesn't compile or gave up on a search. Bounded to [`MAX_CACHED_PATTERNS`], least recently+ /// used evicted first.+ static PATTERNS: RefCell<HashMap<String, (Option<Grep>, u64)>> = RefCell::new(HashMap::new());+ /// Counts cache uses, so the least recently used entry can be found.+ static TICK: RefCell<u64> = const { RefCell::new(0) };+}++/// The compiled pattern for `pattern`, compiling it on first use and evicting the least recently+/// used entry once the cache is full. `f` is given `None` when the pattern does not compile.+fn with_pattern<R>(pattern: &str, f: impl FnOnce(&mut Option<Grep>) -> R) -> R {+ let now = TICK.with(|t| {+ let mut t = t.borrow_mut();+ *t += 1;+ *t+ });+ PATTERNS.with(|p| {+ let mut p = p.borrow_mut();+ if !p.contains_key(pattern)+ && p.len() >= MAX_CACHED_PATTERNS+ && let Some(oldest) = p.iter().min_by_key(|(_, (_, used))| *used).map(|(k, _)| k.clone())+ {+ p.remove(&oldest);+ }+ let slot = p.entry(pattern.to_string()).or_insert_with(|| {+ let re = Grep::new(pattern, GrepOptions::default()).map_err(|e| log::warn!("GREP style {pattern:?} skipped: {e}")).ok();+ (re, now)+ });+ slot.1 = now;+ f(&mut slot.0)+ })}fn is_event(u: &NestedUntil, c: char, prev: Option<char>, next: Option<char>) -> bool {@@ -71,14 +104,15 @@ pub(crate) fn overlays(text: &str, range: Range<usize>, nested: &[NestedStyle],if g.style.is_empty() || g.pattern.is_empty() {continue;}- PATTERNS.with(|p| {- let mut p = p.borrow_mut();- let slot = p.entry(g.pattern.clone()).or_insert_with(|| {- Grep::new(&g.pattern, GrepOptions::default()).map_err(|e| log::warn!("GREP style {:?} skipped: {e}", g.pattern)).ok()- });+ with_pattern(&g.pattern, |slot| {let Some(re) = slot else { return };- match re.find_all(text.get(range.start..end).unwrap_or(""), usize::MAX) {- Ok(ms) => out.extend(ms.into_iter().filter(|m| !m.is_empty()).map(|m| (range.start + m.start..range.start + m.end, g.style.clone()))),+ match re.find_all(text.get(range.start..end).unwrap_or(""), crate::grep::MAX_MATCHES_PER_PARAGRAPH) {+ Ok(ms) => {+ if ms.len() == crate::grep::MAX_MATCHES_PER_PARAGRAPH {+ log::warn!("GREP style {:?} matched more than {} times in one paragraph; the rest are not styled", g.pattern, ms.len());+ }+ out.extend(ms.into_iter().filter(|m| !m.is_empty()).map(|m| (range.start + m.start..range.start + m.end, g.style.clone())));+ }Err(e) => {log::warn!("GREP style {:?} disabled: {e}", g.pattern);*slot = None;@@ -93,6 +127,31 @@ pub(crate) fn overlays(text: &str, range: Range<usize>, nested: &[NestedStyle],mod tests {use super::*;+ /// A GREP style's scan is bounded two ways (#1598): the matches one paragraph can take, and+ /// the patterns kept compiled at once.+ #[test]+ fn a_grep_scan_and_the_pattern_cache_are_bounded() {+ // More matches in one paragraph than the cap: the scan stops with what it has instead of+ // paying the backtrack limit again for each one.+ let text = "a ".repeat(crate::grep::MAX_MATCHES_PER_PARAGRAPH + 500);+ let o = overlays(&text, 0..text.len(), &[], &[GrepStyle { style: "A".into(), pattern: "a".into() }], 0);+ assert_eq!(o.len(), crate::grep::MAX_MATCHES_PER_PARAGRAPH, "the scan stops at the cap");++ // The cache holds at most MAX_CACHED_PATTERNS, and the one just used is not the one+ // dropped: a document's own styles stay compiled however many patterns a session saw.+ PATTERNS.with(|p| p.borrow_mut().clear());+ for i in 0..MAX_CACHED_PATTERNS + 20 {+ let pattern = format!("x{i}y");+ overlays("x1y", 0..3, &[], &[GrepStyle { style: "S".into(), pattern }], 0);+ }+ let (len, has_last) = PATTERNS.with(|p| {+ let p = p.borrow();+ (p.len(), p.contains_key(&format!("x{}y", MAX_CACHED_PATTERNS + 19)))+ });+ assert_eq!(len, MAX_CACHED_PATTERNS, "the cache is bounded");+ assert!(has_last, "the most recently used pattern is still cached");+ }+#[test]fn nested_and_grep_ranges() {let text = "Q: what is 42? A drop of 7 words.\n".to_string();