add utility for replacing strings within Inlines (#402)

yshavit · web-flow · commit 989c417ea47d · 2025-08-17T04:39:19.000-04:00
The core of this change is flat_inlines.rs, which lets you: 1. Translate a Vec<Inline> (which is a recursive data structure) into a flat representation. This representation is (a) a plain String, and (b) a series of formatting events, specified by offset and length. For example, "bold starting at char 5 for 10 chars". 2. Replace a slice of this flattened structure with another string. 3. Unflatten the structure back into Vec<Inline> This will be used in #376.
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,3 +30,6 @@ lazy_static = "1.4.0"
 indoc = "2"
 serde = { version = "1", features = ["derive"] }
 toml = "0.8"
+
+[lints.rust]
+dead_code = "allow" # TODO remove this; it's a temporary crutch for the phased commits of #376
diff --git a/src/md_elem/flat_inlines.rs b/src/md_elem/flat_inlines.rs
diff --git a/src/md_elem/inline_regex_replace.rs b/src/md_elem/inline_regex_replace.rs
@@ -0,0 +1,189 @@
+use crate::md_elem::flat_inlines::{FlattenedText, RangeReplacementError};
+use crate::md_elem::tree::elem::Inline;
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum RegexReplaceError {
+    InvalidRegex { pattern: String, error: String },
+    ReplacementError(RangeReplacementError),
+}
+
+impl Display for RegexReplaceError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RegexReplaceError::InvalidRegex { pattern, error } => write!(f, "invalid regex {pattern:?}: {error}"),
+            RegexReplaceError::ReplacementError(RangeReplacementError::InternalError(e)) => {
+                write!(f, "internal error: {e}")
+            }
+            RegexReplaceError::ReplacementError(RangeReplacementError::AtomicityViolation) => {
+                write!(f, "replacement crosses atomic boundary")
+            }
+        }
+    }
+}
+
+impl Error for RegexReplaceError {}
+
+#[derive(Debug)]
+pub(crate) struct Replaced<T> {
+    pub(crate) item: T,
+    pub(crate) matched_any: bool,
+}
+
+/// Applies regex search and replace to a vector of inline elements.
+///
+/// This flattens the inlines, applies the regex replacement, and reconstructs
+/// the tree structure. Returns an error if the regex would cross formatting
+/// boundaries that cannot be represented (like links or unsupported content).
+pub(crate) fn regex_replace_inlines(
+    inlines: impl IntoIterator<Item = Inline>,
+    pattern: &fancy_regex::Regex,
+    replacement: Option<&str>,
+) -> Result<Replaced<Vec<Inline>>, RegexReplaceError> {
+    // TODO should I have this take an owned Vec<Inline>? If I do, then if there are no matches I can just return the
+    //  original inlines, and thus save on the unflatten step.
+    let mut flattened = FlattenedText::from_inlines(inlines);
+
+    let mut replaced_string = String::new();
+    let flattened_text = flattened.text.to_string();
+    let matched_any = match replacement {
+        None => pattern
+            .is_match(&flattened_text)
+            .map_err(|e| map_re_error(e, pattern))?,
+        Some(replacement) => {
+            let mut matched_any = false;
+            for capture in pattern.captures_iter(&flattened_text) {
+                matched_any = true;
+                let capture = capture.map_err(|e| map_re_error(e, pattern))?;
+                let capture_match = capture.get(0).expect("unwrap of capture's 0-group");
+                replaced_string.clear();
+                capture.expand(replacement, &mut replaced_string);
+                let capture_range = capture_match.start()..capture_match.end();
+                flattened
+                    .replace_range(capture_range, &replaced_string)
+                    .map_err(RegexReplaceError::ReplacementError)?;
+            }
+            matched_any
+        }
+    };
+
+    let unflattened = flattened.unflatten().map_err(RegexReplaceError::ReplacementError)?;
+    Ok(Replaced {
+        matched_any,
+        item: unflattened,
+    })
+}
+
+fn map_re_error(e: fancy_regex::Error, pattern: &fancy_regex::Regex) -> RegexReplaceError {
+    RegexReplaceError::InvalidRegex {
+        pattern: pattern.as_str().to_string(),
+        error: format!("{e}"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::md_elem::tree_test_utils::inlines;
+
+    #[test]
+    fn simple_replacement() {
+        let inlines = inlines!["hello world"];
+        let pattern = fancy_regex::Regex::new(r"world").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("rust")).unwrap();
+
+        assert_eq!(result.item, inlines!["hello rust"]);
+        assert!(result.matched_any);
+    }
+
+    #[test]
+    fn simple_replacement_to_same() {
+        let inlines = inlines!["hello world"];
+        let pattern = fancy_regex::Regex::new(r"world").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("world")).unwrap();
+
+        assert_eq!(result.item, inlines!["hello world"]); // same as original
+        assert!(result.matched_any);
+    }
+
+    #[test]
+    fn no_match_returns_original() {
+        let inlines = inlines!["hello world"];
+        let pattern = fancy_regex::Regex::new(r"foo").unwrap();
+        let result = regex_replace_inlines(inlines.clone(), &pattern, Some("bar")).unwrap();
+
+        assert_eq!(result.item, inlines);
+        assert!(!result.matched_any);
+    }
+
+    #[test]
+    fn replacement_with_formatting() {
+        let inlines = inlines!["before ", em["emphasized"], " after"];
+        let pattern = fancy_regex::Regex::new(r"emphasized").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("replaced")).unwrap();
+
+        let expected = inlines!["before ", em["replaced"], " after"];
+        assert_eq!(result.item, expected);
+    }
+
+    #[test]
+    fn partial_replacement_with_formatting() {
+        let inlines = inlines!["before ", em["emphasized and"], " after"];
+        let pattern = fancy_regex::Regex::new(r"emphasized").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("replaced")).unwrap();
+
+        let expected = inlines!["before ", em["replaced and"], " after"];
+        assert_eq!(result.item, expected);
+    }
+
+    #[test]
+    fn replacement_across_formatting() {
+        let inlines = inlines!["before ", em["emphasized"], " after"];
+
+        let pattern = fancy_regex::Regex::new(r"ore emphasized af").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("oo")).unwrap();
+
+        // When replacement spans formatting boundaries, formatting should be removed
+        let expected = inlines!["befooter"];
+        assert_eq!(result.item, expected);
+    }
+
+    #[test]
+    fn capture_groups() {
+        let inlines = inlines!["hello world"];
+        let pattern = fancy_regex::Regex::new(r"(\w+) (\w+)").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("$2 $1")).unwrap();
+
+        assert_eq!(result.item, inlines!["world hello"]);
+    }
+
+    #[test]
+    fn multiple_matches() {
+        let inlines = inlines!["foo bar foo baz"];
+        let pattern = fancy_regex::Regex::new(r"foo").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("qux")).unwrap();
+
+        assert_eq!(result.item, inlines!["qux bar qux baz"]);
+        assert!(result.matched_any);
+    }
+
+    #[test]
+    fn unsupported_content_error() {
+        let inlines = inlines!["before ", link["link text"]("https://example.com"), " after"];
+
+        // This should succeed because the regex doesn't cross the link boundary
+        let pattern = fancy_regex::Regex::new(r"before").unwrap();
+        let result = regex_replace_inlines(inlines.clone(), &pattern, Some("pre")).unwrap();
+        assert_eq!(
+            result.item,
+            inlines!["pre ", link["link text"]("https://example.com"), " after",],
+        );
+
+        // This should fail because the regex crosses into the link
+        let pattern = fancy_regex::Regex::new(r"ore link").unwrap();
+        let result = regex_replace_inlines(inlines, &pattern, Some("replacement"));
+        assert!(result.is_err());
+    }
+}
diff --git a/src/md_elem/mod.rs b/src/md_elem/mod.rs
@@ -7,6 +7,8 @@ mod tree_ref;
 pub use tree::*;
 
 mod concatenate;
+mod flat_inlines;
+pub(crate) mod inline_regex_replace;
 #[cfg(test)]
 pub(crate) mod tree_test_utils;
 
diff --git a/src/md_elem/tree_test_utils.rs b/src/md_elem/tree_test_utils.rs
@@ -24,6 +24,7 @@ mod test_utils {
     pub(crate) use md_elems;
 
     macro_rules! mdq_inline {
+        // todo replace this with the `inlines!` macro below
         (span $which:ident [$($contents:expr),*$(,)?]) => {
             crate::md_elem::elem::Inline::Span(Span {
                 variant: crate::md_elem::elem::SpanVariant::$which,
@@ -40,6 +41,118 @@ mod test_utils {
     use crate::md_elem::elem::BlockHtml;
     pub(crate) use mdq_inline;
 
+    macro_rules! inlines {
+        // Empty case
+        [] => {
+            Vec::<crate::md_elem::elem::Inline>::new()
+        };
+
+        // String literal (optionally followed by more content)
+        [$text:literal $(, $($rest:tt)*)?] => {
+            crate::md_elem::inlines!(text[$text] $(, $($rest)*)?)
+        };
+
+        // Plain text (optionally followed by more content)
+        [text[$text:expr] $(, $($rest:tt)*)?] => {
+            {
+                #[allow(unused_mut)]
+                let mut result = vec![
+                    crate::md_elem::elem::Inline::Text(crate::md_elem::elem::Text {
+                        variant: crate::md_elem::elem::TextVariant::Plain,
+                        value: $text.to_string(),
+                    })
+                ];
+                $(result.extend(inlines![$($rest)*]);)?
+                result
+            }
+        };
+
+        // Emphasis (optionally followed by more content)
+        [em[$($content:tt)*] $(, $($rest:tt)*)?] => {
+            {
+                #[allow(unused_mut)]
+                let mut result = vec![
+                    crate::md_elem::elem::Inline::Span(crate::md_elem::elem::Span {
+                        variant: crate::md_elem::elem::SpanVariant::Emphasis,
+                        children: inlines![$($content)*],
+                    })
+                ];
+                $(result.extend(inlines![$($rest)*]);)?
+                result
+            }
+        };
+
+        // Strong (optionally followed by more content)
+        [strong[$($content:tt)*] $(, $($rest:tt)*)?] => {
+            {
+                #[allow(unused_mut)]
+                let mut result = vec![
+                    crate::md_elem::elem::Inline::Span(crate::md_elem::elem::Span {
+                        variant: crate::md_elem::elem::SpanVariant::Strong,
+                        children: inlines![$($content)*],
+                    })
+                ];
+                $(result.extend(inlines![$($rest)*]);)?
+                result
+            }
+        };
+
+        // Link (optionally followed by more content)
+        [link[$($display:tt)*] ($url:literal) $(, $($rest:tt)*)?] => {
+            {
+                #[allow(unused_mut)]
+                let mut result = vec![
+                    crate::md_elem::elem::Inline::Link(crate::md_elem::elem::Link::Standard(
+                        crate::md_elem::elem::StandardLink {
+                            display: inlines![$($display)*],
+                            link: crate::md_elem::elem::LinkDefinition {
+                                url: $url.to_string(),
+                                title: None,
+                                reference: crate::md_elem::elem::LinkReference::Inline,
+                            },
+                        }
+                    ))
+                ];
+                $(result.extend(inlines![$($rest)*]);)?
+                result
+            }
+        };
+
+        // image (optionally followed by more content)
+        [image[$alt:expr] ($url:expr) $(, $($rest:tt)*)?] => {
+            {
+                #[allow(unused_mut)]
+                let mut result = vec![
+                    crate::md_elem::elem::Inline::Image(crate::md_elem::elem::Image{
+                        alt: $alt.to_string(),
+                        link: crate::md_elem::elem::LinkDefinition {
+                            url: $url.to_string(),
+                            title: None,
+                            reference: crate::md_elem::elem::LinkReference::Inline,
+                        }
+                    })
+                ];
+                $(result.extend(inlines![$($rest)*]);)?
+                result
+            }
+        };
+
+        // Footnote, like `footnote["^1"]`
+        [footnote[$val:expr] $(, $($rest:tt)*)?] => {
+            {
+                #[allow(unused_mut)]
+                let mut result = vec![
+                    crate::md_elem::elem::Inline::Footnote(crate::md_elem::elem::FootnoteId{
+                        id: $val.to_string(),
+                    })
+                ];
+                $(result.extend(inlines![$($rest)*]);)?
+                result
+            }
+        };
+    }
+    pub(crate) use inlines;
+
     impl From<&str> for BlockHtml {
         fn from(value: &str) -> Self {
             Self {
diff --git a/src/query/pest.rs b/src/query/pest.rs
@@ -51,7 +51,7 @@ impl From<pest::error::Error<Rule>> for Error {
 }
 
 impl Query {
-    pub(crate) fn parse(query_text: &str) -> Result<Pairs, Error> {
+    pub(crate) fn parse(query_text: &str) -> Result<Pairs<'_>, Error> {
         QueryPairs::parse(Rule::top, query_text).map_err(Self::format_err)
     }
 
@@ -122,7 +122,7 @@ mod test_helpers {
     impl StringVariant {
         /// Tries to parse the given string. If it succeeds, returns the parsed Pairs and the remaining, unparsed query
         /// text.
-        pub(crate) fn parse(self, query_text: &str) -> Result<(Pairs, &str), Error> {
+        pub(crate) fn parse(self, query_text: &str) -> Result<(Pairs<'_>, &str), Error> {
             let parsed = QueryPairs::parse(self.as_rule(), query_text)?;
             let remaining = match parsed.peek() {
                 None => query_text,
diff --git a/src/select/string_matcher.rs b/src/select/string_matcher.rs
@@ -75,7 +75,7 @@ impl StringMatcher {
         self.replacement.is_some()
     }
 
-    pub(crate) fn match_replace(&self, haystack: String) -> Result<StringMatch, StringMatchError> {
+    pub(crate) fn match_replace(&self, haystack: String) -> Result<StringMatch<'_>, StringMatchError> {
         match self.re.is_match(&haystack) {
             Ok(is_match) => Ok(if is_match {
                 let replacement = self.replacement.as_ref().map(|r| (&self.re, r.as_str()));
diff --git a/src/util/output.rs b/src/util/output.rs
@@ -325,7 +325,7 @@ impl StaticIndentInfo {
         }
     }
 
-    fn build(self, blocks: &[Block]) -> IndentInfo {
+    fn build(self, blocks: &[Block]) -> IndentInfo<'_> {
         IndentInfo {
             blocks,
             static_info: self,
@@ -348,7 +348,7 @@ impl IndentHandler {
         }
     }
 
-    fn get_indentation_info(&mut self, ch: Option<char>, state: WritingState) -> IndentInfo {
+    fn get_indentation_info(&mut self, ch: Option<char>, state: WritingState) -> IndentInfo<'_> {
         // #199: I have a number of branches here. Can I nest some of them, so that in the happy path of a non-newline
         //       char, I just have a single check?
         let mut indent_builder = StaticIndentInfo::new(state);

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ impl StringMatcher {`
`75`	`75`	`self.replacement.is_some()`
`76`	`76`	`}`
`77`	`77`
`78`		`- pub(crate) fn match_replace(&self, haystack: String) -> Result<StringMatch, StringMatchError> {`
	`78`	`+ pub(crate) fn match_replace(&self, haystack: String) -> Result<StringMatch<'_>, StringMatchError> {`
`79`	`79`	`match self.re.is_match(&haystack) {`
`80`	`80`	`Ok(is_match) => Ok(if is_match {`
`81`	`81`	`let replacement = self.replacement.as_ref().map(\|r\| (&self.re, r.as_str()));`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ impl StaticIndentInfo {`
`325`	`325`	`}`
`326`	`326`	`}`
`327`	`327`
`328`		`- fn build(self, blocks: &[Block]) -> IndentInfo {`
	`328`	`+ fn build(self, blocks: &[Block]) -> IndentInfo<'_> {`
`329`	`329`	`IndentInfo {`
`330`	`330`	`blocks,`
`331`	`331`	`static_info: self,`
`@@ -348,7 +348,7 @@ impl IndentHandler {`
`348`	`348`	`}`
`349`	`349`	`}`
`350`	`350`
`351`		`- fn get_indentation_info(&mut self, ch: Option<char>, state: WritingState) -> IndentInfo {`
	`351`	`+ fn get_indentation_info(&mut self, ch: Option<char>, state: WritingState) -> IndentInfo<'_> {`
`352`	`352`	`// #199: I have a number of branches here. Can I nest some of them, so that in the happy path of a non-newline`
`353`	`353`	`// char, I just have a single check?`
`354`	`354`	`let mut indent_builder = StaticIndentInfo::new(state);`