Enum Matcher 

pub enum Matcher {
    Literal {
        pattern: String,
    },
    Regex {
        re: Regex,
        prescreen: Option<Regex>,
    },
}

Abstraction over literal and regex matching.

Variants

Literal

Fields

pattern: String

Regex

A regex matcher — used for both explicit --regex patterns and as the implementation backing case-insensitive literal matching (via regex::escape + (?i)), which avoids byte-offset mismatches from str::to_lowercase() on multi-byte Unicode characters.

Fields

re: Regex

prescreen: Option<Regex>

Whole-buffer fast-reject shadow: the same pattern compiled with (?m) so ^/$ keep their per-line meaning against a full buffer. None when no sound shadow exists (see [prescreen_shadow]) — then prescreening always says “maybe”.

Implementations

impl Matcher

pub fn new(op: &Op) -> Result<Self, RipsedError>

Create a new matcher from an operation.

pub fn prescreen(&self, text: &str) -> bool

Cheap whole-buffer check: false means no line of text can match this pattern, so per-line processing can be skipped entirely. true means “maybe” — false positives are fine, false negatives are a correctness bug (locked by a proptest).

pub fn is_match(&self, text: &str) -> bool

Check if the given text matches.

pub fn replace(&self, text: &str, replacement: &str) -> Option<String>

Replace all matches in the given text. Returns None if no matches.

pub fn replace_n( &self, text: &str, replacement: &str, limit: usize, ) -> Option<(String, usize)>

Replace up to limit matches (0 = unlimited), left to right.

Returns the new text and how many occurrences were replaced, or None if nothing matched. With limit == 0 this is exactly Matcher::replace plus the occurrence count.

pub fn find_replacements(&self, text: &str, replacement: &str) -> Vec<MatchSpan>

Find every non-overlapping match in text and compute its expanded replacement, left to right.

Spans are returned in ascending order and never overlap, with the same semantics as Matcher::replace (str::replace for literals, Regex::replace_all for regexes) — splicing each span’s replacement into the original text reproduces replace’s output exactly.

Trait Implementations

impl Debug for Matcher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.