implement regex-replace for all selectors

This uses the new flat_inlines (#402) to replace all of the
string-matching that the selectors had previous had, with a new
regex-replace functionality.

Resolves #376.

Author: yshavit

Cargo.toml

@@ -30,6 +30,3 @@ 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

src/md_elem/flat_inlines.rs

@@ -1,6 +1,7 @@
 use crate::md_elem::tree::elem::Span;
 use crate::md_elem::tree::elem::{Autolink, AutolinkStyle, Image, Link, StandardLink};
 use crate::md_elem::tree::elem::{FootnoteId, Inline, LinkDefinition, SpanVariant, Text, TextVariant};
+use crate::output::{inlines_to_plain_string, FootnoteToString, InlineToStringOpts};
 use std::cmp::Ordering;
 use std::iter::Peekable;
 use std::ops::Range;
@@ -482,7 +483,12 @@ fn flatten_inlines(inlines: impl IntoIterator<Item = Inline>, text: &mut String)
                 // range starts outside this inline). Rather than describing a complex situation to the user, we'll just
                 // prohibit them.
                 let start_pos = text.len();
-                let content = String::from("1"); // TODO
+                let content = inlines_to_plain_string(
+                    &[&other],
+                    InlineToStringOpts {
+                        footnotes: FootnoteToString::OnlyFootnoteId,
+                    },
+                );
                 text.push_str(&content);
                 let length = content.len();
 

src/md_elem/tree.rs

@@ -1442,7 +1442,7 @@ macro_rules! m_node {
 
     // Recursive case: A::B<tail> -> A::B(B<tail>)
     ($head:ident :: $next:ident $(:: $($tail:ident)::*)? $( $( <$last_variant:ident> )? { $($args:tt)* })? ) => {
-        $head::$next( m_node!($next $(:: $($tail)::*)? $( $( <$last_variant> )? { $($args)* })?) )
+        $head::$next( crate::md_elem::m_node!($next $(:: $($tail)::*)? $( $( <$last_variant> )? { $($args)* })?) )
     };
 }
 pub(crate) use m_node;

src/output/fmt_plain_str.rs

@@ -1,29 +1,48 @@
 use crate::md_elem::elem::*;
 use std::borrow::Borrow;
 
-pub(crate) fn inlines_to_plain_string<N: Borrow<Inline>>(inlines: &[N]) -> String {
+#[derive(Default, Copy, Clone)]
+pub(crate) struct InlineToStringOpts {
+    pub(crate) footnotes: FootnoteToString,
+}
+
+#[derive(Default, Copy, Clone)]
+pub(crate) enum FootnoteToString {
+    /// Includes all the surrounding Markdown. If the footnote id is `"1"`, this will render as `[^1]`.
+    #[default]
+    IncludeMarkdown,
+
+    /// Includes only the footnote id. If the footnote id is `"1"`, this will render as `1`.
+    OnlyFootnoteId,
+}
+
+pub(crate) fn inlines_to_plain_string<N: Borrow<Inline>>(inlines: &[N], opts: InlineToStringOpts) -> String {
     let mut result = String::with_capacity(inlines.len() * 5); // random guess
-    build_inlines(&mut result, inlines);
+    build_inlines(&mut result, inlines, opts);
     result
 }
 
-fn build_inlines<N: Borrow<Inline>>(out: &mut String, inlines: &[N]) {
+fn build_inlines<N: Borrow<Inline>>(out: &mut String, inlines: &[N], opts: InlineToStringOpts) {
     for inline in inlines {
-        build_inline(out, inline.borrow());
+        build_inline(out, inline.borrow(), opts);
     }
 }
 
-fn build_inline(out: &mut String, elem: &Inline) {
+fn build_inline(out: &mut String, elem: &Inline, opts: InlineToStringOpts) {
     match elem {
-        Inline::Span(Span { children, .. }) => build_inlines(out, children),
+        Inline::Span(Span { children, .. }) => build_inlines(out, children, opts),
         Inline::Text(Text { value, .. }) => out.push_str(value),
-        Inline::Link(Link::Standard(standard_link)) => build_inlines(out, &standard_link.display),
+        Inline::Link(Link::Standard(standard_link)) => build_inlines(out, &standard_link.display, opts),
         Inline::Link(Link::Autolink(autolink)) => out.push_str(&autolink.url),
         Inline::Image(Image { alt, .. }) => out.push_str(alt),
         Inline::Footnote(footnote) => {
-            out.push_str("[^");
+            if matches!(opts.footnotes, FootnoteToString::IncludeMarkdown) {
+                out.push_str("[^");
+            }
             out.push_str(footnote.as_str());
-            out.push(']');
+            if matches!(opts.footnotes, FootnoteToString::IncludeMarkdown) {
+                out.push(']');
+            }
         }
     }
 }
@@ -70,7 +89,7 @@ mod tests {
         unwrap!(&md_elems[0], MdElem::Paragraph(contents));
         unwrap!(&contents.body[1], inline @ Inline::Text(_));
         VARIANTS_CHECKER.see(inline);
-        let actual = inlines_to_plain_string(&contents.body);
+        let actual = inlines_to_plain_string(&contents.body, Default::default());
         assert_eq!(&actual, "Hello <foo> world");
     }
 
@@ -119,7 +138,7 @@ mod tests {
         let md_elems = MdDoc::parse(md, &options).unwrap().roots;
         unwrap!(&md_elems[0], MdElem::Paragraph(p));
         p.body.iter().for_each(|inline| VARIANTS_CHECKER.see(inline));
-        let actual = inlines_to_plain_string(&p.body);
+        let actual = inlines_to_plain_string(&p.body, Default::default());
         assert_eq!(&actual, expect);
     }
 }

src/select/match_replace.rs

@@ -5,3 +5,45 @@ pub struct MatchReplace {
     pub matcher: Matcher,
     pub replacement: Option<String>,
 }
+
+#[cfg(test)]
+mod test_utils {
+    use super::*;
+    use crate::select::{Matcher, Regex};
+
+    impl MatchReplace {
+        pub(crate) fn match_any() -> MatchReplace {
+            Self::build(|b| b)
+        }
+
+        pub(crate) fn build(f: impl FnOnce(&mut MatchReplaceBuilder) -> &mut MatchReplaceBuilder) -> MatchReplace {
+            let mut builder = MatchReplaceBuilder {
+                matcher: None,
+                replacement: None,
+            };
+            f(&mut builder);
+            MatchReplace {
+                matcher: builder.matcher.unwrap_or(Matcher::Any { explicit: false }),
+                replacement: builder.replacement,
+            }
+        }
+    }
+
+    pub(crate) struct MatchReplaceBuilder {
+        matcher: Option<Matcher>,
+        replacement: Option<String>,
+    }
+
+    impl MatchReplaceBuilder {
+        pub(crate) fn match_regex(&mut self, pattern: impl AsRef<str>) -> &mut Self {
+            let re = fancy_regex::Regex::new(pattern.as_ref()).expect("test error: bad regex");
+            self.matcher = Some(Matcher::Regex(Regex { re }));
+            self
+        }
+
+        pub(crate) fn replacement(&mut self, replacement: impl Into<String>) -> &mut Self {
+            self.replacement = Some(replacement.into());
+            self
+        }
+    }
+}

src/select/match_selector.rs

@@ -24,3 +24,11 @@ where
         }
     }
 }
+
+pub(crate) fn make_select_result<T: Into<MdElem>>(item: T, matched_any: bool) -> Select {
+    if matched_any {
+        Select::Hit(vec![item.into()])
+    } else {
+        Select::Miss(item.into())
+    }
+}