implement regex replace for URLs

This PR adds search-and-replace functionality, allowing users to modify
link and image URLs using regex patterns. Users can now use
`!s/pattern/replacement/` syntax to find and replace URL content.

For now, only URLs support search-replace. General spans will come later
(see #376).

## High-level changes

- New `!s/pattern/replacement/` syntax for regex search-replace
  operations, extending the existing `/pattern/` regex syntax
- Replace `Matcher` with a new `MatchReplace` in the `Selector`
  variants' structs. This combines the original `Matcher` with an optional
  replacement string
- Implement URL replacement for links and images
- Refactor selector error handling to use proper `Result<Select,
  SelectError>` semantics instead of misusing `Err(MdElem)` for "no match"
  cases. The new `Select` enum is now how we represent "matched
  element(s), or the unmatched original"

## Breaking changes

- `MatchReplace` replaces `Matcher` in `Selector`s: All selector
  matchers now take `MatchReplace` instead of `Matcher`
- New `crate::run::Error::SelectionError` variant, with an accompanying
  struct
- `Table::retain_columns_by_header` and `Table::retain_rows` now require
  an additional error type parameter, representing a possible error coming
  from the passed-in function

## Review note

This PR is for a feature/integration branch. Please see the contributing
commits (each of which has its own PR) for the individual steps.

Resolves #277

Author: yshavit

.github/workflows/formatting.yml

@@ -3,7 +3,7 @@ on:
   push:
     branches: [ "main" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "feature/*" ]
 
 jobs:
   newlines:

.github/workflows/rust.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches: [ "main" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "feature/*" ]
 
 env:
   CARGO_TERM_COLOR: always
@@ -110,7 +110,7 @@ jobs:
         run: |
           if ! "$RUNNER_TEMP/cargo-semver-checks" semver-checks --baseline-rev "origin/$GITHUB_BASE_REF" ; then
             # There were breaking changes. Make sure we have the appropriate label!
-            breaking_change_label_count="$(gh pr view 364 --json labels | jq '.labels | select("breaking change") | length')"
+            breaking_change_label_count="$(gh pr view ${{ github.event.number }} --json labels | jq '.labels | map(select(.name == "breaking change")) | length')"
             if [[ "$breaking_change_label_count" != 1 ]]; then
               echo "::error title=semver-checks::semver-checks found breaking changes, but the 'breaking change' label isn't applied. Please add that label."
               exit 1

.github/workflows/system-test.yml

@@ -3,7 +3,7 @@ on:
   push:
     branches: [ "main" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "feature/*" ]
   workflow_dispatch: { }
 
 jobs:

src/lib.rs

@@ -50,7 +50,7 @@
 //! let selector: mdq::select::Selector = query_text.try_into()?;
 //!
 //! // Run the selector against the parsed Markdown
-//! let (found_nodes, found_nodes_ctx) = selector.find_nodes(parsed_md);
+//! let (found_nodes, found_nodes_ctx) = selector.find_nodes(parsed_md)?;
 //!
 //! // Output. Note our use of
 //! let mut output_string = String::new();

src/md_elem/tree_ref.rs

@@ -37,15 +37,15 @@ mod elem_ref {
             }
         }
 
-        pub fn retain_columns_by_header<F>(&mut self, mut f: F)
+        pub fn retain_columns_by_header<F, E>(&mut self, mut f: F) -> Result<(), E>
         where
-            F: FnMut(&TableCell) -> bool,
+            F: FnMut(&TableCell) -> Result<bool, E>,
         {
             let Some(first_row) = self.rows.first() else {
-                return;
+                return Ok(());
             };
             let mut keeper_indices = IndexKeeper::new();
-            keeper_indices.retain_when(first_row, |_, cell| f(cell));
+            keeper_indices.retain_when(first_row, |_, cell| f(cell))?;
 
             match keeper_indices.count_keeps() {
                 0 => {
@@ -58,24 +58,30 @@ mod elem_ref {
                 }
                 _ => {
                     // some columns match: retain those, and discard the rest
-                    self.alignments.retain_with_index(keeper_indices.retain_fn());
+                    self.alignments.retain_with_index(keeper_indices.retain_fn())?;
                     for row in self.rows.iter_mut() {
-                        row.retain_with_index(keeper_indices.retain_fn());
+                        row.retain_with_index(keeper_indices.retain_fn())?;
                     }
                 }
             }
+            Ok(())
         }
 
-        pub fn retain_rows<F>(&mut self, mut f: F)
+        pub fn retain_rows<F, E>(&mut self, mut f: F) -> Result<(), E>
         where
-            F: FnMut(&TableCell) -> bool,
+            F: FnMut(&TableCell) -> Result<bool, E>,
         {
             self.rows.retain_with_index(|idx, row| {
                 if idx == 0 {
-                    return true;
+                    return Ok(true);
                 }
-                row.iter().any(&mut f)
-            });
+                for cell in row {
+                    if f(cell)? {
+                        return Ok(true);
+                    }
+                }
+                Ok(false)
+            })
         }
 
         pub fn is_empty(&self) -> bool {
@@ -102,7 +108,7 @@ mod tests {
                 vec!["data 1 a", "data 1 b", "data 1 c"],
                 vec!["data 2 a", "data 2 b", "KEEPER c"],
             ]);
-            table.retain_columns_by_header(cell_matches("KEEPER"));
+            table.retain_columns_by_header(cell_matches("KEEPER")).unwrap();
 
             // note: "KEEPER" is in the last column, but not in the header; only the header gets
             // matched.
@@ -123,10 +129,12 @@ mod tests {
             table.normalize();
 
             let mut seen_lines = Vec::with_capacity(3);
-            table.retain_columns_by_header(|line| {
-                seen_lines.push(simple_to_string(line));
-                true
-            });
+            table
+                .retain_columns_by_header(|line| {
+                    seen_lines.push(simple_to_string(line));
+                    Ok::<_, ()>(true)
+                })
+                .unwrap();
 
             // normalization
             assert_eq!(
@@ -154,7 +162,7 @@ mod tests {
                 vec!["data 1 a", "data 1 b", "data 1 c"],
                 vec!["data 2 a", "KEEPER b", "data 2 c"],
             ]);
-            table.retain_rows(cell_matches("KEEPER"));
+            table.retain_rows(cell_matches("KEEPER")).unwrap();
 
             assert_eq!(
                 table.alignments,
@@ -187,10 +195,12 @@ mod tests {
             // retain only the rows with empty cells. This lets us get around the short-circuiting
             // of retain_rows (it short-circuits within each row as soon as it finds a matching
             // cell), to validate that the normalization works as expected.
-            table.retain_rows(|line| {
-                seen_lines.push(simple_to_string(line));
-                line.is_empty()
-            });
+            table
+                .retain_rows(|line| {
+                    seen_lines.push(simple_to_string(line));
+                    Ok::<_, ()>(line.is_empty())
+                })
+                .unwrap();
 
             // normalization
             assert_eq!(
@@ -219,10 +229,10 @@ mod tests {
             );
         }
 
-        fn cell_matches(substring: &str) -> impl Fn(&TableCell) -> bool + '_ {
+        fn cell_matches(substring: &str) -> impl Fn(&TableCell) -> Result<bool, ()> + '_ {
             move |line| {
                 let line_str = format!("{:?}", line);
-                line_str.contains(substring)
+                Ok(line_str.contains(substring))
             }
         }
 

src/query/grammar.pest

@@ -69,10 +69,15 @@ string = {
 asterisk = @{ "*" }
 unquoted_string = @{ LETTER ~ (!(PEEK | "$") ~ ANY)* }
 
-regex               = ${ "/" ~ regex_char* ~ "/" }
+regex               = ${
+  // Put these into a single rule, so that the error message just says "regex" for both the plain and replace variant.
+    ("/" ~ regex_char* ~ "/")
+  | ("!s/" ~ regex_char* ~ "/" ~ regex_replacement_segment? ~ "/")
+}
 regex_char          = ${
     (regex_escaped_slash | regex_normal_char)
 }
+regex_replacement_segment = ${ regex_char+ }
 regex_escaped_slash = @{ "\\/" }
 regex_normal_char   = @{ !("/") ~ ANY }
 

src/query/matcher_try_from.rs

@@ -1,28 +1,34 @@
 use crate::query::strings::{ParsedString, ParsedStringMode};
 use crate::query::{DetachedSpan, InnerParseError, Pair};
-use crate::select::{Matcher, Regex};
+use crate::select::{MatchReplace, Matcher, Regex};
 use fancy_regex::Error;
 
-impl Matcher {
+impl MatchReplace {
     pub(crate) fn try_from(pair: Option<Pair>) -> Result<Self, InnerParseError> {
         let Some(pair) = pair else {
-            return Ok(Self::Any { explicit: false });
+            return Ok(Self {
+                matcher: Matcher::Any { explicit: false },
+                replacement: None,
+            });
         };
         let span = DetachedSpan::from(&pair);
         let parsed_string = ParsedString::new_from_pairs(pair.into_inner())?;
         if parsed_string.is_equivalent_to_asterisk() {
-            return Ok(Self::Any {
-                explicit: parsed_string.explicit_wildcard,
+            return Ok(Self {
+                matcher: Matcher::Any {
+                    explicit: parsed_string.explicit_wildcard,
+                },
+                replacement: None,
             });
         }
         let matcher = match parsed_string.mode {
-            ParsedStringMode::CaseSensitive => Self::Text {
+            ParsedStringMode::CaseSensitive => Matcher::Text {
                 case_sensitive: true,
                 anchor_start: parsed_string.anchor_start,
                 text: parsed_string.text,
                 anchor_end: parsed_string.anchor_end,
             },
-            ParsedStringMode::CaseInsensitive => Self::Text {
+            ParsedStringMode::CaseInsensitive => Matcher::Text {
                 case_sensitive: false,
                 anchor_start: parsed_string.anchor_start,
                 text: parsed_string.text,
@@ -43,9 +49,12 @@ impl Matcher {
                         }
                     }
                 })?;
-                Self::Regex(Regex { re })
+                Matcher::Regex(Regex { re })
             }
         };
-        Ok(matcher)
+        Ok(Self {
+            matcher,
+            replacement: parsed_string.replace_string,
+        })
     }
 }

src/query/pest.rs

@@ -88,6 +88,7 @@ impl Query {
                 Rule::regex_char => "regex character",
                 Rule::regex_escaped_slash => "_/_",
                 Rule::regex_normal_char => "regex character",
+                Rule::regex_replacement_segment => "regex_replacement_segment",
                 Rule::quoted_string => "quoted string",
                 Rule::quoted_char => "character in quoted string",
                 Rule::asterisk => "_*_",