Skip to content

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.rs
index 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.rs
index 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();