ReXile 🦎

A blazing-fast regex engine with 94%+ feature compatibility and 10-100x faster compilation

ReXile is a production-ready regex engine that achieves exceptional compilation speed while maintaining competitive matching performance:

• ⚡ 10-100x faster compilation - Load patterns instantly
• 🎯 94%+ regex compatibility - Full feature support for rule engines
• 🚀 Competitive matching - 1.4-1.9x faster on simple patterns
• 🔍 Lookaround assertions - (?=...) and (?!...) support - NEW in v0.3.0
• 🎪 Word boundaries - Full \b and \B support - NEW in v0.3.0
• 📦 Only 2 dependencies - memchr and aho-corasick for SIMD primitives
• 🧠 Smart backtracking - Handles complex patterns with quantifiers
• 🔧 Perfect for parsers - Ideal for GRL, DSL, and rule engines

✨ What's New in v0.3.0

Major Feature Release:

• ✅ Lookaround assertions - Positive/negative lookahead (?=...), (?!...)
• ✅ Full word boundaries - \b and \B in all contexts including sequences
• ✅ Complete anchors - ^ and $ work correctly in all patterns
• ✅ Negated character classes - [^\s], [^a-z] fully functional
• ✅ Case-insensitive matching - (?i) flag support
• ✅ 94%+ compatibility - 129/129 library tests + 23/23 feature tests passing

Production Ready:

• 🎯 Perfect for rule engines - Tested and validated
• 📊 49/52 production patterns passing (94.2%)
• 🚀 Zero breaking changes - Drop-in replacement for v0.2.x
• 📖 Comprehensive documentation - See FEATURE_STATUS.md

🚀 Quick Start

use rexile::Pattern;

// Literal matching with SIMD acceleration
let pattern = Pattern::new("hello").unwrap();
assert!(pattern.is_match("hello world"));
assert_eq!(pattern.find("say hello"), Some((4, 9)));

// Word boundaries (NEW in v0.3.0)
let word = Pattern::new(r"\bhello\b").unwrap();
assert!(word.is_match("hello world"));
assert!(!word.is_match("hellothere"));

// Lookahead assertions (NEW in v0.3.0)
let lookahead = Pattern::new(r"password(?=.*\d)").unwrap();
assert!(lookahead.is_match("password123"));  // Contains digit
assert!(!lookahead.is_match("password"));    // No digit

// Negative lookahead (NEW in v0.3.0)
let negative = Pattern::new(r"username(?!admin)").unwrap();
assert!(negative.is_match("username123"));
assert!(!negative.is_match("usernameadmin"));

// Case insensitive (NEW in v0.3.0)
let case_insensitive = Pattern::new(r"(?i)hello").unwrap();
assert!(case_insensitive.is_match("HELLO"));
assert!(case_insensitive.is_match("HeLLo"));

// Negated character classes (IMPROVED in v0.3.0)
let not_whitespace = Pattern::new(r"[^\s]+").unwrap();
assert_eq!(not_whitespace.find("  hello"), Some((2, 7)));

// Multi-pattern matching (aho-corasick fast path)
let multi = Pattern::new("foo|bar|baz").unwrap();
assert!(multi.is_match("the bar is open"));

// Dot wildcard matching (with backtracking)
let dot = Pattern::new("a.c").unwrap();
assert!(dot.is_match("abc"));  // . matches 'b'

// Non-greedy quantifiers
let lazy = Pattern::new(r"start\{.*?\}").unwrap();
assert_eq!(lazy.find("start{abc}end{xyz}"), Some((0, 10)));

// Capturing groups
let caps_pattern = Pattern::new(r"(\w+)@(\w+)\.(\w+)").unwrap();
let caps = caps_pattern.captures("user@example.com").unwrap();
assert_eq!(caps.get(1), Some("user"));
assert_eq!(caps.get(2), Some("example"));
assert_eq!(caps.get(3), Some("com"));

✨ Supported Features

Complete Feature List (v0.3.0)

Production-Ready Patterns (94.2% passing)

// Email validation
let email = Pattern::new(r"\w+@\w+\.\w+").unwrap();
assert!(email.is_match("user@example.com"));

// IP address matching
let ip = Pattern::new(r"\d+\.\d+\.\d+\.\d+").unwrap();
assert!(ip.is_match("192.168.1.1"));

// Keyword extraction with boundaries
let keyword = Pattern::new(r"\bfunction\b").unwrap();
assert!(keyword.is_match("function test() {}"));
assert!(!keyword.is_match("functionality"));

// Log level matching (case insensitive)
let log_level = Pattern::new(r"(?i)(error|warning|info)").unwrap();
assert!(log_level.is_match("ERROR: something failed"));

// Password validation with lookahead
let has_digit = Pattern::new(r"\w+(?=.*\d)").unwrap();
assert!(has_digit.is_match("password123"));

// URL protocol detection
let protocol = Pattern::new(r"(http|https)://").unwrap();
assert!(protocol.is_match("https://example.com"));

📊 Performance Benchmarks

Compilation Speed (Primary Advantage)

Pattern Compilation Benchmark (vs regex crate):

Average: 10-100x faster compilation - Perfect for dynamic patterns!

Matching Speed

Simple Patterns (Fast paths):

• Pattern \d+ on "12345": 1.4-1.9x faster ✅
• Pattern \w+ on "variable": 1.4-1.9x faster ✅
• Pattern "[^"]+" on quoted strings: Competitive ✅

Complex Patterns (Backtracking):

• Pattern a.+c on "abc": 2-5x slower (acceptable)
• Pattern .*test.* on long strings: 2-10x slower (acceptable)
• Trade-off: 100x faster compilation vs slightly slower complex matching

Use Case Performance

Loading 1000 GRL Rules:

• regex crate: ~2 seconds (2ms per pattern)
• rexile: ~0.02 seconds (20µs per pattern)
• Result: 100x faster startup! Perfect for parsers and rule engines.

Test Results

• Library tests: 129/129 passing (100%)
• Production features: 49/52 passing (94.2%)
• Full regex features: 23/23 passing (100%)
• Critical features: 7/7 passing (100%)

🔧 Use Cases

✅ Perfect For

• Rule engines - Fast pattern compilation for business rules
• Parsers and lexers - 100x faster pattern loading
• DSL compilers - GRL, configuration languages
• Log processing - Fast keyword and pattern extraction
• Dynamic patterns - Applications that compile patterns at runtime
• Validation - Email, phone, URL, format validation
• Text extraction - Structured data from logs and documents

🎯 Real-World Example: Rule Engine

use rexile::Pattern;

// Load 1000 rules instantly (vs 2 seconds with regex crate)
let rules = vec![
    r"when \w+ > \d+",
    r"if \w+ == '[^']+' then",
    r"rule \w+ \{.*?\}",
    // ... 997 more rules
];

for rule_pattern in rules {
    let pattern = Pattern::new(rule_pattern).unwrap();
    // Ready to match immediately - no JIT warmup needed
}

// Match with full regex features
let condition = Pattern::new(r"when (\w+) (>=|<=|==|!=|>|<) (.+)").unwrap();
let caps = condition.captures("when temperature > 100").unwrap();
assert_eq!(caps.get(1), Some("temperature"));
assert_eq!(caps.get(2), Some(">"));
assert_eq!(caps.get(3), Some("100"));

📋 Known Limitations

See FEATURE_STATUS.md for detailed compatibility information.

Minor limitations:

• Range quantifiers {n,m} have bugs (use {n,} instead)
• Standalone lookbehind patterns not supported (use combined patterns)
• Some complex alternations with (?i) flag may not work

Workarounds available for all limitations - See feature status document.

📦 Installation

Add to your Cargo.toml:

[dependencies]
rexile = "0.3"

🎓 Advanced Examples

Word Boundaries

// Match whole words only
let word = Pattern::new(r"\btest\b").unwrap();
assert!(word.is_match("this is a test"));
assert!(!word.is_match("testing"));  // No match - not whole word

// Boundaries in sequences
let pattern = Pattern::new(r"\bhello\b \bworld\b").unwrap();
assert!(pattern.is_match("hello world"));

Lookahead Assertions

// Password must contain a digit (lookahead)
let has_digit = Pattern::new(r"(?=.*\d)\w+").unwrap();
assert!(has_digit.is_match("password123"));
assert!(!has_digit.is_match("password"));

// Match word before colon
let before_colon = Pattern::new(r"\w+(?=:)").unwrap();
assert_eq!(before_colon.find("key:value"), Some((0, 3))); // Matches "key"

// Negative lookahead - no admin
let not_admin = Pattern::new(r"user(?!admin)").unwrap();
assert!(not_admin.is_match("user123"));
assert!(!not_admin.is_match("useradmin"));

Cached API (Best for Repeated Patterns)

// First call compiles and caches
rexile::is_match("keyword", "find keyword here").unwrap();

// Subsequent calls reuse cached pattern (zero compile cost)
rexile::is_match("keyword", "another keyword").unwrap();
rexile::is_match("keyword", "more keyword text").unwrap();

📚 More examples: See examples/ directory for:

• basic_usage.rs - Core API walkthrough
• production_ready_test.rs - Comprehensive feature test
• log_processing.rs - Log analysis patterns

Run examples with:

cargo run --example production_ready_test
cargo run --example basic_usage

🤝 Contributing

Contributions welcome! ReXile is actively maintained and evolving.

Recent milestones:

• ✅ v0.3.0: Lookaround, word boundaries, 94%+ compatibility
• ✅ v0.2.8: Case-insensitive matching
• ✅ v0.2.7: Full quantified groups support
• ✅ v0.2.3: Alternation with captures
• ✅ v0.2.1: Non-greedy quantifiers, DOTALL mode
• ✅ v0.2.0: Dot wildcard, capturing groups

Current focus:

• 🔄 Fix bounded quantifiers {n,m}
• 🔄 Full lookbehind support
• 🔄 Unicode properties support
• 🔄 Performance optimizations

How to contribute:

1. Check issues for open tasks
2. Run tests: cargo test
3. Run benchmarks: cargo run --release --example production_ready_test
4. Submit PR with tests

📜 License

Licensed under either of:

• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

at your option.

🙏 Credits

Built on top of:

• memchr by Andrew Gallant - SIMD-accelerated substring search
• aho-corasick by Andrew Gallant - Multi-pattern matching automaton

Developed for the rust-rule-engine project, providing fast pattern matching for GRL (Grule Rule Language) parsing and business rule evaluation.

Performance Philosophy: ReXile achieves competitive performance through intelligent specialization rather than complex JIT compilation:

• 10 hand-optimized fast paths for common patterns
• SIMD acceleration via memchr
• Pre-built automatons for alternations
• Zero-copy iterator design
• Minimal metadata overhead

Status: ✅ Production Ready (v0.3.0)

• ✅ Compilation Speed: 10-100x faster than regex crate
• ✅ Feature Coverage: 94%+ regex compatibility
• ✅ Lookaround: Positive/negative lookahead fully supported
• ✅ Word Boundaries: Full \b and \B support
• ✅ Testing: 129/129 library tests passing
• ✅ Real-world validated: Rule engines, parsers, DSL compilers
• ✅ Documentation: Comprehensive feature status and examples