Struct ScanPattern 

pub struct ScanPattern {
    pub min_length: usize,
    /* private fields */
}

A pattern rule defining what to scan for and how to categorize matches.

Wraps a compiled regex::bytes::Regex with a Category for replacement lookups and a human-readable label for reporting.

Both regex and literal patterns are supported. Literal patterns keep their original text and are matched by the scanner’s Aho-Corasick automaton for fast multi-literal scanning.

Fields

min_length: usize

Minimum window size (bytes) required to produce a match. For literal patterns this equals the byte length of the literal itself. For regex patterns this is 0 (no guaranteed minimum). Used to skip captures_iter when the window is provably too short.

Implementations

impl ScanPattern

pub fn from_regex( pattern: &str, category: Category, label: impl Into<String>, ) -> Result<Self>

Create a pattern from a regex string.

Capture group 1 — partial replacement

If the regex contains a capture group 1 ((...)), only the bytes matched by that group are replaced; the bytes before and after it within the full match are emitted verbatim. This lets you write context-anchored patterns without redacting the prefix/suffix:

pattern: glpat-([A-Za-z0-9_-]{20})
          ^^^^^^ prefix preserved
                 ^^^^^^^^^^^^^^^^^^^^ group 1 → replaced

Patterns without a capture group replace the entire match.

Errors

Returns SanitizeError::PatternCompileError if the regex is invalid.

Examples

use sanitize_engine::scanner::ScanPattern;
use sanitize_engine::category::Category;

// No capture group — full match replaced:
let email = ScanPattern::from_regex(
    r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
    Category::Email,
    "email_address",
).unwrap();

// Capture group 1 — prefix preserved, only the token value replaced:
let token = ScanPattern::from_regex(
    r"glpat-([A-Za-z0-9_-]{20})",
    Category::AuthToken,
    "gitlab_pat",
).unwrap();

pub fn from_literal( literal: &str, category: Category, label: impl Into<String>, ) -> Result<Self>

Create a pattern from a literal string.

The literal is escaped so that regex metacharacters are matched verbatim.

Errors

Returns SanitizeError::PatternCompileError if regex compilation fails.

Examples

use sanitize_engine::scanner::ScanPattern;
use sanitize_engine::category::Category;

let pat = ScanPattern::from_literal(
    "sk-proj-abc123secret",
    Category::Custom("api_key".into()),
    "openai_key",
).unwrap();

pub fn category(&self) -> &Category

The category this pattern maps to.

pub fn label(&self) -> &str

The human-readable label.

pub fn regex_pattern(&self) -> &str

Return the raw regex pattern string for RegexSet construction.

Trait Implementations

impl Clone for ScanPattern

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScanPattern

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

Formats the value using the given formatter.