lambdust 0.1.1

//! Lightweight regular expression engine for Lambdust.
//!
//! This module provides a Thompson NFA-based regular expression implementation
//! designed to replace the heavyweight `regex` crate dependency. It focuses on
//! the subset of regex features actually used by Lambdust's SRFI-135 text
//! processing, achieving 90-95% binary size reduction.
//!
//! ## Features
//!
//! **Phase 1 (Basic 80% Coverage):**
//! - Basic metacharacters: `.` (any character), `^` (start), `$` (end)
//! - Character classes: `[abc]`, `[a-z]`, `[^abc]`, `\d`, `\w`, `\s`
//! - Quantifiers: `*` (0+), `+` (1+), `?` (0-1)
//! - Grouping: `(...)` basic grouping
//! - Escapes: `\t`, `\n`, `\\`, `\.`, etc.
//!
//! **Design Principles:**
//! 1. **Lightweight First**: Implement only used features
//! 2. **Performance Focus**: O(nm) time complexity via Thompson NFA
//! 3. **Memory Efficient**: Minimal memory footprint
//! 4. **API Compatibility**: Compatible with existing regex crate usage
//!
//! ## Algorithm: Thompson NFA
//!
//! Uses Thompson's construction algorithm to build Nondeterministic Finite
//! Automata from regular expressions, providing:
//! - Linear time construction: O(m) where m = pattern length
//! - Linear time matching: O(nm) where n = text length
//! - Predictable memory usage
//! - Simple implementation suitable for lightweight deployment

// Core engine modules
pub mod engine;
pub mod parser;
pub mod matcher;

// Compatibility layer with regex crate
pub mod compat;

// Re-export primary types for convenient usage
pub use engine::{Nfa, NfaEngine, EngineError};
pub use parser::{Pattern, PatternParser, PatternError};
pub use matcher::{Match, MatchResult, Matcher};
pub use compat::{LightRegex, RegexBuilder, Error as RegexError};

/// Result type for regex operations.
pub type Result<T> = std::result::Result<T, RegexError>;

/// Regular expression compilation and matching facade.
///
/// This is the primary interface, providing API compatibility with the
/// standard `regex` crate while using our lightweight Thompson NFA engine.
#[derive(Debug, Clone)]
pub struct Regex {
    engine: NfaEngine,
    pattern: String,
}

impl Regex {
    /// Compiles a regular expression pattern.
    ///
    /// # Examples
    /// ```
    /// use lambdust::regex::Regex;
    /// 
    /// let regex = Regex::new(r"\d+").unwrap();
    /// assert!(regex.is_match("123"));
    /// ```
    pub fn new(pattern: &str) -> Result<Self> {
        let parsed = PatternParser::new(pattern).parse()?;
        let engine = NfaEngine::from_pattern(&parsed)?;
        
        Ok(Self {
            engine,
            pattern: pattern.to_string(),
        })
    }
    
    /// Tests whether the pattern matches anywhere in the text.
    pub fn is_match(&self, text: &str) -> bool {
        let mut matcher = Matcher::new(&self.engine);
        matcher.find(text).is_some()
    }
    
    /// Finds the first match in the text.
    pub fn find(&self, text: &str) -> Option<Match> {
        let mut matcher = Matcher::new(&self.engine);
        matcher.find(text)
    }
    
    /// Finds all non-overlapping matches in the text.
    pub fn find_iter<'t>(&'t self, text: &'t str) -> impl Iterator<Item = Match> + 't {
        FindIter::new(&self.engine, text)
    }
    
    /// Returns the original pattern string.
    pub fn as_str(&self) -> &str {
        &self.pattern
    }
}

/// Iterator over all matches in a string.
struct FindIter<'t> {
    matcher: Matcher<'t>,
    text: &'t str,
    pos: usize,
}

impl<'t> FindIter<'t> {
    fn new(engine: &'t NfaEngine, text: &'t str) -> Self {
        Self {
            matcher: Matcher::new(engine),
            text,
            pos: 0,
        }
    }
}

impl<'t> Iterator for FindIter<'t> {
    type Item = Match;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.pos >= self.text.len() {
            return None;
        }
        
        let remaining = &self.text[self.pos..];
        if let Some(mut m) = self.matcher.find(remaining) {
            // Adjust match positions to be relative to original text
            m.start += self.pos;
            m.end += self.pos;
            
            // Advance position past this match
            self.pos = m.end.max(self.pos + 1); // Ensure progress
            Some(m)
        } else {
            None
        }
    }
}

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

    #[test]
    fn test_basic_matching() {
        let regex = Regex::new(r"hello").unwrap();
        assert!(regex.is_match("hello world"));
        assert!(!regex.is_match("goodbye world"));
    }
    
    #[test]
    fn test_pattern_storage() {
        let regex = Regex::new(r"\d+").unwrap();
        assert_eq!(regex.as_str(), r"\d+");
    }
    
    #[test]
    fn test_find_match() {
        let regex = Regex::new(r"\d+").unwrap();
        let m = regex.find("abc123def").unwrap();
        assert_eq!(m.start, 3);
        assert_eq!(m.end, 6);
        assert_eq!(m.as_str(), "123");
    }
    
    #[test]
    fn test_find_all() {
        let regex = Regex::new(r"\d+").unwrap();
        let matches: Vec<_> = regex.find_iter("a1b2c3").collect();
        assert_eq!(matches.len(), 3);
        assert_eq!(matches[0].as_str(), "1");
        assert_eq!(matches[1].as_str(), "2");
        assert_eq!(matches[2].as_str(), "3");
    }
}