gatekpr_patterns/

registry.rs

//! Pattern registry for managing compiled regex patterns
//!
//! Provides a centralized way to manage and match patterns across the codebase.

use regex::Regex;
use std::collections::HashMap;
use thiserror::Error;

/// Errors from pattern operations
#[derive(Error, Debug)]
pub enum PatternError {
    /// Invalid regex pattern
    #[error("Invalid regex pattern '{pattern}': {message}")]
    InvalidPattern { pattern: String, message: String },

    /// Pattern not found in registry
    #[error("Pattern not found: {0}")]
    NotFound(String),
}

/// Result type for pattern operations
pub type Result<T> = std::result::Result<T, PatternError>;

/// A match result from pattern matching
#[derive(Debug, Clone)]
pub struct PatternMatch {
    /// The pattern key that matched
    pub pattern_key: String,
    /// Start position of the match
    pub start: usize,
    /// End position of the match
    pub end: usize,
    /// The matched text
    pub text: String,
}

/// Registry for managing compiled regex patterns
///
/// Patterns are compiled once and stored for efficient repeated matching.
///
/// # Example
///
/// ```
/// use gatekpr_patterns::PatternRegistry;
///
/// let mut registry = PatternRegistry::new();
/// registry.register("email", r"[\w\.-]+@[\w\.-]+\.\w+").unwrap();
///
/// assert!(registry.is_match("email", "test@example.com"));
/// ```
#[derive(Default)]
pub struct PatternRegistry {
    patterns: HashMap<String, Regex>,
}

impl PatternRegistry {
    /// Create a new empty pattern registry
    pub fn new() -> Self {
        Self::default()
    }

    /// Register a new pattern
    ///
    /// Returns an error if the pattern is invalid regex.
    pub fn register(&mut self, key: &str, pattern: &str) -> Result<()> {
        let regex = Regex::new(pattern).map_err(|e| PatternError::InvalidPattern {
            pattern: pattern.to_string(),
            message: e.to_string(),
        })?;
        self.patterns.insert(key.to_string(), regex);
        Ok(())
    }

    /// Register multiple patterns at once
    pub fn register_many(&mut self, patterns: &[(&str, &str)]) -> Result<()> {
        for (key, pattern) in patterns {
            self.register(key, pattern)?;
        }
        Ok(())
    }

    /// Check if a pattern matches the given text
    pub fn is_match(&self, key: &str, text: &str) -> bool {
        self.patterns
            .get(key)
            .map(|regex| regex.is_match(text))
            .unwrap_or(false)
    }

    /// Check if any of the given patterns match
    pub fn any_match(&self, keys: &[&str], text: &str) -> bool {
        keys.iter().any(|key| self.is_match(key, text))
    }

    /// Check if all of the given patterns match
    pub fn all_match(&self, keys: &[&str], text: &str) -> bool {
        keys.iter().all(|key| self.is_match(key, text))
    }

    /// Find all matches for a pattern in text
    pub fn find_all(&self, key: &str, text: &str) -> Vec<PatternMatch> {
        self.patterns
            .get(key)
            .map(|regex| {
                regex
                    .find_iter(text)
                    .map(|m| PatternMatch {
                        pattern_key: key.to_string(),
                        start: m.start(),
                        end: m.end(),
                        text: m.as_str().to_string(),
                    })
                    .collect()
            })
            .unwrap_or_default()
    }

    /// Find matches from any of the given patterns
    pub fn find_any(&self, keys: &[&str], text: &str) -> Vec<PatternMatch> {
        keys.iter()
            .flat_map(|key| self.find_all(key, text))
            .collect()
    }

    /// Get the first match for a pattern
    pub fn find_first(&self, key: &str, text: &str) -> Option<PatternMatch> {
        self.patterns.get(key).and_then(|regex| {
            regex.find(text).map(|m| PatternMatch {
                pattern_key: key.to_string(),
                start: m.start(),
                end: m.end(),
                text: m.as_str().to_string(),
            })
        })
    }

    /// Get pattern by key
    pub fn get(&self, key: &str) -> Option<&Regex> {
        self.patterns.get(key)
    }

    /// Check if a pattern key exists
    pub fn contains(&self, key: &str) -> bool {
        self.patterns.contains_key(key)
    }

    /// Get the number of registered patterns
    pub fn len(&self) -> usize {
        self.patterns.len()
    }

    /// Check if the registry is empty
    pub fn is_empty(&self) -> bool {
        self.patterns.is_empty()
    }

    /// Get all pattern keys
    pub fn keys(&self) -> impl Iterator<Item = &str> {
        self.patterns.keys().map(|s| s.as_str())
    }

    /// Merge another registry into this one
    pub fn merge(&mut self, other: PatternRegistry) {
        self.patterns.extend(other.patterns);
    }

    /// Create a new registry by merging multiple registries
    pub fn merged(registries: Vec<PatternRegistry>) -> Self {
        let mut result = Self::new();
        for registry in registries {
            result.merge(registry);
        }
        result
    }
}

/// A pattern set groups related patterns for a specific domain
///
/// # Example
///
/// ```
/// use gatekpr_patterns::PatternSet;
///
/// let set = PatternSet::new("webhooks")
///     .with_pattern("gdpr_data_request", r"customers[/_]data[/_]request")
///     .with_pattern("gdpr_redact", r"customers[/_]redact")
///     .build()
///     .unwrap();
///
/// assert!(set.is_match("gdpr_data_request", "customers/data_request"));
/// ```
pub struct PatternSet {
    name: String,
    patterns: Vec<(String, String)>,
}

impl PatternSet {
    /// Create a new pattern set builder
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            patterns: Vec::new(),
        }
    }

    /// Add a pattern to the set
    pub fn with_pattern(mut self, key: &str, pattern: &str) -> Self {
        self.patterns.push((key.to_string(), pattern.to_string()));
        self
    }

    /// Add multiple patterns at once
    pub fn with_patterns(mut self, patterns: &[(&str, &str)]) -> Self {
        for (key, pattern) in patterns {
            self.patterns.push((key.to_string(), pattern.to_string()));
        }
        self
    }

    /// Build the pattern set into a registry
    pub fn build(self) -> Result<PatternRegistry> {
        let mut registry = PatternRegistry::new();
        for (key, pattern) in self.patterns {
            registry.register(&key, &pattern)?;
        }
        Ok(registry)
    }

    /// Get the name of this pattern set
    pub fn name(&self) -> &str {
        &self.name
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_register_and_match() {
        let mut registry = PatternRegistry::new();
        registry.register("test", r"\d+").unwrap();

        assert!(registry.is_match("test", "abc123"));
        assert!(!registry.is_match("test", "abc"));
        assert!(!registry.is_match("nonexistent", "123"));
    }

    #[test]
    fn test_find_all() {
        let mut registry = PatternRegistry::new();
        registry.register("digits", r"\d+").unwrap();

        let matches = registry.find_all("digits", "a1b22c333");
        assert_eq!(matches.len(), 3);
        assert_eq!(matches[0].text, "1");
        assert_eq!(matches[1].text, "22");
        assert_eq!(matches[2].text, "333");
    }

    #[test]
    fn test_any_match() {
        let mut registry = PatternRegistry::new();
        registry.register("a", r"aaa").unwrap();
        registry.register("b", r"bbb").unwrap();
        registry.register("c", r"ccc").unwrap();

        assert!(registry.any_match(&["a", "b"], "xxxaaayyy"));
        assert!(!registry.any_match(&["a", "b"], "xxxcccyyy"));
    }

    #[test]
    fn test_pattern_set() {
        let registry = PatternSet::new("test")
            .with_pattern("email", r"[\w\.-]+@[\w\.-]+")
            .with_pattern("phone", r"\d{3}-\d{4}")
            .build()
            .unwrap();

        assert!(registry.is_match("email", "test@example.com"));
        assert!(registry.is_match("phone", "123-4567"));
    }

    #[test]
    fn test_invalid_pattern() {
        let mut registry = PatternRegistry::new();
        let result = registry.register("invalid", r"[invalid");
        assert!(result.is_err());
    }
}