Struct ScanPattern 

pub struct ScanPattern {
    pub min_length: usize,
    pub max_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 match length (bytes). Matches shorter than this are discarded. For literal patterns this defaults to the byte length of the literal itself; for regex patterns it defaults to 0 (no minimum). Set from a secrets entry’s min_length to suppress short false positives.

max_length: usize

Maximum match length (bytes). Matches longer than this are discarded. Defaults to usize::MAX (no maximum). Set from a secrets entry’s max_length to bound a greedy pattern — this also caps how far an unbounded pattern can run before the streaming scanner’s over-long redaction takes over.

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 rust_sanitize::scanner::ScanPattern;
use rust_sanitize::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 with_length_bounds(self, min: usize, max: usize) -> Self

Set the inclusive match-length bounds (bytes) for this pattern.

Matches shorter than min or longer than max are discarded during scanning. min == 0 and max == usize::MAX impose no bound. Used to plumb a secrets entry’s min_length / max_length onto a compiled pattern without changing the public constructor signatures.

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 rust_sanitize::scanner::ScanPattern;
use rust_sanitize::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.