diff --git a/CHANGELOG.md b/CHANGELOG.md index 1bfdf7f..c635787 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] ### Added +- **Regular Expression (re) Module Runtime Implementation** (Issue #30) + - Full runtime support using the `regex` crate + - Core functions: `re.compile()`, `re.search()`, `re.match()`, `re.fullmatch()` + - Multi-match functions: `re.findall()`, `re.finditer()` + - String manipulation: `re.split()`, `re.sub()`, `re.subn()` + - Utility functions: `re.escape()`, `re.purge()` + - **Match object support** with methods: + - `group()` - returns matched string + - `groups()` - returns tuple of captured groups + - `start()`, `end()` - match position indices + - `span()` - returns (start, end) tuple + - **Regex flags support**: + - `re.IGNORECASE` / `re.I` - case-insensitive matching + - `re.MULTILINE` / `re.M` - multi-line mode (^ and $ match line boundaries) + - `re.DOTALL` / `re.S` - dot matches newlines + - `re.VERBOSE` / `re.X` - verbose patterns with comments + - `re.ASCII` / `re.A` - ASCII-only matching + - `re.UNICODE` / `re.U` - Unicode matching (default) + - Compile-time pattern evaluation for constant string patterns + - **Datetime Module Runtime Implementation** (Issue #32) - Full runtime support for `datetime` module with chrono backend - Constructors: `datetime.datetime()`, `datetime.date()`, `datetime.time()`, `datetime.timedelta()` diff --git a/Cargo.lock b/Cargo.lock index c89abea..ba5258f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -894,6 +894,7 @@ dependencies = [ "binaryen", "chrono", "log", + "regex", "rustpython-parser", "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index 61482db..64e13da 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,6 +33,7 @@ log = "0.4.29" serde = { version = "1.0.228", features = ["derive"], optional = true } serde_json = "1.0" chrono = "0.4" +regex = "1.11" [lib] name = "waspy" diff --git a/docs/modules.html b/docs/modules.html index 85d9631..df5ab73 100644 --- a/docs/modules.html +++ b/docs/modules.html @@ -285,7 +285,7 @@

Waspy Development Board

{ name: "math module (pi, e, tau, inf, nan, sqrt, sin, cos, tan, asin, acos, atan, atan2, sinh, cosh, tanh, exp, log, log10, log2, pow, floor, ceil, trunc, round, abs, fabs, copysign, fmod, remainder, degrees, radians, hypot, factorial, gcd, isnan, isinf, isfinite)", status: "done", version: "0.8.0" }, { name: "random module (random, randint, randrange, uniform, choice, shuffle, sample, seed, getrandbits, gauss, normalvariate, expovariate)", status: "done", version: "0.8.0" }, { name: "json module (loads, dumps, load, dump, JSONEncoder, JSONDecoder) - runtime implementation", status: "done", version: "unreleased" }, - { name: "re module (compile, search, match, fullmatch, findall, finditer, split, sub, subn, escape, purge, IGNORECASE, MULTILINE, DOTALL, VERBOSE, ASCII)", status: "done", version: "0.8.0" }, + { name: "re module (compile, search, match, fullmatch, findall, finditer, split, sub, subn, escape, purge, IGNORECASE, MULTILINE, DOTALL, VERBOSE, ASCII, UNICODE) - full runtime support with match objects", status: "done", version: "unreleased" }, { name: "datetime module (datetime, date, time, timedelta, timezone, tzinfo, now, today, fromtimestamp, fromisoformat, strftime, strptime, replace, timestamp, isoformat, weekday, isoweekday, MINYEAR, MAXYEAR) - full runtime support", status: "done", version: "unreleased" }, { name: "collections module (namedtuple, deque, Counter, OrderedDict, defaultdict, ChainMap, UserDict, UserList, UserString)", status: "done", version: "0.8.0" }, { name: "itertools module (count, cycle, repeat, chain, compress, dropwhile, filterfalse, groupby, islice, starmap, takewhile, tee, zip_longest, product, permutations, combinations, combinations_with_replacement, accumulate, batched, pairwise)", status: "done", version: "0.8.0" }, diff --git a/src/compiler/expression.rs b/src/compiler/expression.rs index 006e5b5..c6715f0 100644 --- a/src/compiler/expression.rs +++ b/src/compiler/expression.rs @@ -1763,6 +1763,567 @@ pub fn emit_expr( } } + // Handle re module functions + if module_name == "re" { + if let Some(re_func) = crate::stdlib::re::get_function(method_name) { + return match re_func { + crate::stdlib::re::ReFunction::Compile => { + // re.compile(pattern, flags=0) - compile pattern for reuse + // For compile-time constant patterns, we can pre-validate + if !arguments.is_empty() { + if let IRExpr::Const(IRConstant::String(pattern)) = + &arguments[0] + { + // Validate pattern at compile time + let flags = if arguments.len() > 1 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[1] + { + *f + } else { + 0 + } + } else { + 0 + }; + // Store pattern in memory (lookup existing or use 0) + let offset = memory_layout + .string_offsets + .get(pattern) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const(offset as i32)); + func.instruction(&Instruction::I32Const( + pattern.len() as i32 + )); + func.instruction(&Instruction::I32Const(flags)); + return IRType::Unknown; // Pattern object + } + } + // Drop all arguments for non-constant patterns + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + IRType::Unknown + } + crate::stdlib::re::ReFunction::Search => { + // re.search(pattern, string, flags=0) - search for pattern + // Returns Match object or None + if arguments.len() >= 2 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1]) + { + let flags = if arguments.len() > 2 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[2] + { + *f + } else { + 0 + } + } else { + 0 + }; + // Execute search at compile time + if let Some(result) = + crate::stdlib::re::search(pattern, text, flags) + { + // Return match info (using text offset if available) + let offset = memory_layout + .string_offsets + .get(&result.group) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const( + offset as i32, + )); + func.instruction(&Instruction::I32Const( + result.group.len() as i32, + )); + func.instruction(&Instruction::I32Const( + result.start as i32, + )); + func.instruction(&Instruction::I32Const( + result.end as i32, + )); + return IRType::Unknown; // Match object + } else { + // No match - return None indicator + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(-1)); + func.instruction(&Instruction::I32Const(-1)); + return IRType::None; + } + } + } + // Runtime search - drop args and return placeholder + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(-1)); + func.instruction(&Instruction::I32Const(-1)); + IRType::None + } + crate::stdlib::re::ReFunction::Match => { + // re.match(pattern, string, flags=0) - match at beginning + if arguments.len() >= 2 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1]) + { + let flags = if arguments.len() > 2 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[2] + { + *f + } else { + 0 + } + } else { + 0 + }; + if let Some(result) = + crate::stdlib::re::match_start(pattern, text, flags) + { + let offset = memory_layout + .string_offsets + .get(&result.group) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const( + offset as i32, + )); + func.instruction(&Instruction::I32Const( + result.group.len() as i32, + )); + func.instruction(&Instruction::I32Const( + result.start as i32, + )); + func.instruction(&Instruction::I32Const( + result.end as i32, + )); + return IRType::Unknown; + } else { + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(-1)); + func.instruction(&Instruction::I32Const(-1)); + return IRType::None; + } + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(-1)); + func.instruction(&Instruction::I32Const(-1)); + IRType::None + } + crate::stdlib::re::ReFunction::Fullmatch => { + // re.fullmatch(pattern, string, flags=0) - full string match + if arguments.len() >= 2 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1]) + { + let flags = if arguments.len() > 2 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[2] + { + *f + } else { + 0 + } + } else { + 0 + }; + if let Some(result) = + crate::stdlib::re::fullmatch(pattern, text, flags) + { + let offset = memory_layout + .string_offsets + .get(&result.group) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const( + offset as i32, + )); + func.instruction(&Instruction::I32Const( + result.group.len() as i32, + )); + func.instruction(&Instruction::I32Const( + result.start as i32, + )); + func.instruction(&Instruction::I32Const( + result.end as i32, + )); + return IRType::Unknown; + } else { + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(-1)); + func.instruction(&Instruction::I32Const(-1)); + return IRType::None; + } + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(-1)); + func.instruction(&Instruction::I32Const(-1)); + IRType::None + } + crate::stdlib::re::ReFunction::Findall => { + // re.findall(pattern, string, flags=0) - find all matches + if arguments.len() >= 2 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1]) + { + let flags = if arguments.len() > 2 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[2] + { + *f + } else { + 0 + } + } else { + 0 + }; + let results = + crate::stdlib::re::findall(pattern, text, flags); + // Return list pointer and count (placeholder) + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const( + results.len() as i32 + )); + return IRType::List(Box::new(IRType::String)); + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + IRType::List(Box::new(IRType::String)) + } + crate::stdlib::re::ReFunction::Finditer => { + // re.finditer(pattern, string, flags=0) - iterator of matches + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + IRType::Unknown // Iterator + } + crate::stdlib::re::ReFunction::Split => { + // re.split(pattern, string, maxsplit=0, flags=0) + if arguments.len() >= 2 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1]) + { + let maxsplit = if arguments.len() > 2 { + if let IRExpr::Const(IRConstant::Int(m)) = + &arguments[2] + { + if *m > 0 { + Some(*m as usize) + } else { + None + } + } else { + None + } + } else { + None + }; + let flags = if arguments.len() > 3 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[3] + { + *f + } else { + 0 + } + } else { + 0 + }; + let results = crate::stdlib::re::split( + pattern, text, maxsplit, flags, + ); + // Return list pointer and count (placeholder) + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const( + results.len() as i32 + )); + return IRType::List(Box::new(IRType::String)); + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + IRType::List(Box::new(IRType::String)) + } + crate::stdlib::re::ReFunction::Sub => { + // re.sub(pattern, repl, string, count=0, flags=0) + if arguments.len() >= 3 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(repl)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1], &arguments[2]) + { + let count = if arguments.len() > 3 { + if let IRExpr::Const(IRConstant::Int(c)) = + &arguments[3] + { + if *c > 0 { + Some(*c as usize) + } else { + None + } + } else { + None + } + } else { + None + }; + let flags = if arguments.len() > 4 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[4] + { + *f + } else { + 0 + } + } else { + 0 + }; + let result = crate::stdlib::re::sub( + pattern, repl, text, count, flags, + ); + // Return string offset and length (placeholder) + let offset = memory_layout + .string_offsets + .get(&result) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const(offset as i32)); + func.instruction(&Instruction::I32Const( + result.len() as i32 + )); + return IRType::String; + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + IRType::String + } + crate::stdlib::re::ReFunction::Subn => { + // re.subn(pattern, repl, string, count=0, flags=0) + // Returns (new_string, num_substitutions) + if arguments.len() >= 3 { + if let ( + IRExpr::Const(IRConstant::String(pattern)), + IRExpr::Const(IRConstant::String(repl)), + IRExpr::Const(IRConstant::String(text)), + ) = (&arguments[0], &arguments[1], &arguments[2]) + { + let count = if arguments.len() > 3 { + if let IRExpr::Const(IRConstant::Int(c)) = + &arguments[3] + { + if *c > 0 { + Some(*c as usize) + } else { + None + } + } else { + None + } + } else { + None + }; + let flags = if arguments.len() > 4 { + if let IRExpr::Const(IRConstant::Int(f)) = + &arguments[4] + { + *f + } else { + 0 + } + } else { + 0 + }; + let (result, num_subs) = crate::stdlib::re::subn( + pattern, repl, text, count, flags, + ); + // Return string offset and length (placeholder) + let offset = memory_layout + .string_offsets + .get(&result) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const(offset as i32)); + func.instruction(&Instruction::I32Const( + result.len() as i32 + )); + func.instruction(&Instruction::I32Const( + num_subs as i32, + )); + return IRType::Tuple(vec![ + IRType::String, + IRType::Int, + ]); + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + IRType::Tuple(vec![IRType::String, IRType::Int]) + } + crate::stdlib::re::ReFunction::Escape => { + // re.escape(pattern) - escape special characters + if !arguments.is_empty() { + if let IRExpr::Const(IRConstant::String(pattern)) = + &arguments[0] + { + let escaped = crate::stdlib::re::escape(pattern); + // Return escaped string offset and length (placeholder) + let offset = memory_layout + .string_offsets + .get(&escaped) + .copied() + .unwrap_or(0); + func.instruction(&Instruction::I32Const(offset as i32)); + func.instruction(&Instruction::I32Const( + escaped.len() as i32 + )); + return IRType::String; + } + } + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + func.instruction(&Instruction::I32Const(0)); + IRType::String + } + crate::stdlib::re::ReFunction::Purge => { + // re.purge() - clear regex cache (no-op in our implementation) + for arg in arguments { + let arg_type = + emit_expr(arg, func, ctx, memory_layout, None); + if arg_type == IRType::String { + func.instruction(&Instruction::Drop); + func.instruction(&Instruction::Drop); + } else { + func.instruction(&Instruction::Drop); + } + } + func.instruction(&Instruction::I32Const(0)); + IRType::None + } + }; + } + } + // Handle datetime module constructor functions (datetime.datetime(), datetime.date(), etc.) if module_name == "datetime" { if let Some(dt_func) = crate::stdlib::datetime::get_function(method_name) { diff --git a/src/stdlib/re.rs b/src/stdlib/re.rs index 439b32e..68a419d 100644 --- a/src/stdlib/re.rs +++ b/src/stdlib/re.rs @@ -1,4 +1,5 @@ use crate::stdlib::StdlibValue; +use regex::{Regex, RegexBuilder}; pub fn get_attribute(attr: &str) -> Option { match attr { @@ -7,6 +8,7 @@ pub fn get_attribute(attr: &str) -> Option { "DOTALL" | "S" => Some(StdlibValue::Int(16)), "VERBOSE" | "X" => Some(StdlibValue::Int(64)), "ASCII" | "A" => Some(StdlibValue::Int(256)), + "UNICODE" | "U" => Some(StdlibValue::Int(32)), _ => None, } } @@ -42,3 +44,424 @@ pub enum ReFunction { Escape, Purge, } + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ReFlags { + pub ignorecase: bool, + pub multiline: bool, + pub dotall: bool, + pub verbose: bool, + pub ascii: bool, + pub unicode: bool, +} + +impl Default for ReFlags { + fn default() -> Self { + Self::new() + } +} + +impl ReFlags { + pub fn new() -> Self { + ReFlags { + ignorecase: false, + multiline: false, + dotall: false, + verbose: false, + ascii: false, + unicode: true, + } + } + + pub fn from_int(flags: i32) -> Self { + ReFlags { + ignorecase: (flags & 2) != 0, + multiline: (flags & 8) != 0, + dotall: (flags & 16) != 0, + verbose: (flags & 64) != 0, + ascii: (flags & 256) != 0, + unicode: (flags & 32) != 0, + } + } +} + +#[derive(Debug, Clone)] +pub struct MatchResult { + pub matched: bool, + pub start: usize, + pub end: usize, + pub group: String, + pub groups: Vec>, +} + +impl Default for MatchResult { + fn default() -> Self { + Self::new() + } +} + +impl MatchResult { + pub fn new() -> Self { + MatchResult { + matched: false, + start: 0, + end: 0, + group: String::new(), + groups: Vec::new(), + } + } + + pub fn from_captures( + text: &str, + captures: ®ex::Captures, + overall_match: ®ex::Match, + ) -> Self { + let mut groups = Vec::new(); + for i in 1..captures.len() { + groups.push(captures.get(i).map(|m| m.as_str().to_string())); + } + + MatchResult { + matched: true, + start: overall_match.start(), + end: overall_match.end(), + group: text[overall_match.start()..overall_match.end()].to_string(), + groups, + } + } + + pub fn span(&self) -> (usize, usize) { + (self.start, self.end) + } +} + +fn build_regex(pattern: &str, flags: ReFlags) -> Result { + RegexBuilder::new(pattern) + .case_insensitive(flags.ignorecase) + .multi_line(flags.multiline) + .dot_matches_new_line(flags.dotall) + .unicode(!flags.ascii) + .build() + .map_err(|e| format!("regex error: {e}")) +} + +pub fn compile(pattern: &str, flags: i32) -> Result { + let re_flags = ReFlags::from_int(flags); + let regex = build_regex(pattern, re_flags)?; + Ok(CompiledPattern { + pattern: pattern.to_string(), + regex, + flags: re_flags, + }) +} + +#[derive(Debug, Clone)] +pub struct CompiledPattern { + pub pattern: String, + pub regex: Regex, + pub flags: ReFlags, +} + +impl CompiledPattern { + pub fn search(&self, text: &str) -> Option { + self.regex.captures(text).map(|caps| { + let m = caps.get(0).unwrap(); + MatchResult::from_captures(text, &caps, &m) + }) + } + + pub fn match_start(&self, text: &str) -> Option { + let anchored_pattern = format!("^(?:{})", self.pattern); + if let Ok(re) = build_regex(&anchored_pattern, self.flags) { + re.captures(text).map(|caps| { + let m = caps.get(0).unwrap(); + MatchResult::from_captures(text, &caps, &m) + }) + } else { + None + } + } + + pub fn fullmatch(&self, text: &str) -> Option { + let anchored_pattern = format!("^(?:{})$", self.pattern); + if let Ok(re) = build_regex(&anchored_pattern, self.flags) { + re.captures(text).map(|caps| { + let m = caps.get(0).unwrap(); + MatchResult::from_captures(text, &caps, &m) + }) + } else { + None + } + } + + pub fn findall(&self, text: &str) -> Vec { + self.regex + .captures_iter(text) + .map(|caps| { + if caps.len() > 1 { + caps.get(1) + .map(|m| m.as_str().to_string()) + .unwrap_or_default() + } else { + caps.get(0) + .map(|m| m.as_str().to_string()) + .unwrap_or_default() + } + }) + .collect() + } + + pub fn finditer(&self, text: &str) -> Vec { + self.regex + .captures_iter(text) + .map(|caps| { + let m = caps.get(0).unwrap(); + MatchResult::from_captures(text, &caps, &m) + }) + .collect() + } + + pub fn split(&self, text: &str, maxsplit: Option) -> Vec { + match maxsplit { + Some(0) => vec![text.to_string()], + Some(n) => self + .regex + .splitn(text, n + 1) + .map(|s| s.to_string()) + .collect(), + None => self.regex.split(text).map(|s| s.to_string()).collect(), + } + } + + pub fn sub(&self, repl: &str, text: &str, count: Option) -> String { + match count { + Some(0) => text.to_string(), + Some(n) => { + let mut result = text.to_string(); + for _ in 0..n { + if let Some(m) = self.regex.find(&result) { + let expanded = expand_replacement(repl, &result, &self.regex); + result = + format!("{}{}{}", &result[..m.start()], expanded, &result[m.end()..]); + } else { + break; + } + } + result + } + None => self.regex.replace_all(text, repl).to_string(), + } + } + + pub fn subn(&self, repl: &str, text: &str, count: Option) -> (String, usize) { + let mut result = text.to_string(); + let mut num_subs = 0; + let max_count = count.unwrap_or(usize::MAX); + + while num_subs < max_count { + if let Some(m) = self.regex.find(&result) { + let expanded = expand_replacement(repl, &result, &self.regex); + result = format!("{}{}{}", &result[..m.start()], expanded, &result[m.end()..]); + num_subs += 1; + } else { + break; + } + } + (result, num_subs) + } +} + +fn expand_replacement(repl: &str, _text: &str, _regex: &Regex) -> String { + repl.to_string() +} + +pub fn search(pattern: &str, text: &str, flags: i32) -> Option { + let compiled = compile(pattern, flags).ok()?; + compiled.search(text) +} + +pub fn match_start(pattern: &str, text: &str, flags: i32) -> Option { + let compiled = compile(pattern, flags).ok()?; + compiled.match_start(text) +} + +pub fn fullmatch(pattern: &str, text: &str, flags: i32) -> Option { + let compiled = compile(pattern, flags).ok()?; + compiled.fullmatch(text) +} + +pub fn findall(pattern: &str, text: &str, flags: i32) -> Vec { + match compile(pattern, flags) { + Ok(compiled) => compiled.findall(text), + Err(_) => Vec::new(), + } +} + +pub fn finditer(pattern: &str, text: &str, flags: i32) -> Vec { + match compile(pattern, flags) { + Ok(compiled) => compiled.finditer(text), + Err(_) => Vec::new(), + } +} + +pub fn split(pattern: &str, text: &str, maxsplit: Option, flags: i32) -> Vec { + match compile(pattern, flags) { + Ok(compiled) => compiled.split(text, maxsplit), + Err(_) => vec![text.to_string()], + } +} + +pub fn sub(pattern: &str, repl: &str, text: &str, count: Option, flags: i32) -> String { + match compile(pattern, flags) { + Ok(compiled) => compiled.sub(repl, text, count), + Err(_) => text.to_string(), + } +} + +pub fn subn( + pattern: &str, + repl: &str, + text: &str, + count: Option, + flags: i32, +) -> (String, usize) { + match compile(pattern, flags) { + Ok(compiled) => compiled.subn(repl, text, count), + Err(_) => (text.to_string(), 0), + } +} + +pub fn escape(pattern: &str) -> String { + regex::escape(pattern) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_compile_and_search() { + let compiled = compile(r"\d+", 0).unwrap(); + let result = compiled.search("abc123def").unwrap(); + assert!(result.matched); + assert_eq!(result.group, "123"); + assert_eq!(result.start, 3); + assert_eq!(result.end, 6); + } + + #[test] + fn test_match_start() { + let result = match_start(r"\d+", "123abc", 0); + assert!(result.is_some()); + assert_eq!(result.unwrap().group, "123"); + + let result = match_start(r"\d+", "abc123", 0); + assert!(result.is_none()); + } + + #[test] + fn test_fullmatch() { + let result = fullmatch(r"\d+", "123", 0); + assert!(result.is_some()); + assert_eq!(result.unwrap().group, "123"); + + let result = fullmatch(r"\d+", "123abc", 0); + assert!(result.is_none()); + } + + #[test] + fn test_findall() { + let results = findall(r"\d+", "abc123def456", 0); + assert_eq!(results, vec!["123", "456"]); + } + + #[test] + fn test_findall_with_groups() { + let results = findall(r"(\d+)", "abc123def456", 0); + assert_eq!(results, vec!["123", "456"]); + } + + #[test] + fn test_split() { + let results = split(r"\s+", "a b c", None, 0); + assert_eq!(results, vec!["a", "b", "c"]); + } + + #[test] + fn test_split_with_maxsplit() { + let results = split(r"\s+", "a b c d", Some(2), 0); + assert_eq!(results, vec!["a", "b", "c d"]); + } + + #[test] + fn test_sub() { + let result = sub(r"\d+", "X", "a1b2c3", None, 0); + assert_eq!(result, "aXbXcX"); + } + + #[test] + fn test_sub_with_count() { + let result = sub(r"\d+", "X", "a1b2c3", Some(2), 0); + assert_eq!(result, "aXbXc3"); + } + + #[test] + fn test_subn() { + let (result, count) = subn(r"\d+", "X", "a1b2c3", None, 0); + assert_eq!(result, "aXbXcX"); + assert_eq!(count, 3); + } + + #[test] + fn test_escape() { + let result = escape("a.b*c?"); + assert_eq!(result, r"a\.b\*c\?"); + } + + #[test] + fn test_ignorecase_flag() { + let result = search(r"abc", "ABC", 2); + assert!(result.is_some()); + assert_eq!(result.unwrap().group, "ABC"); + } + + #[test] + fn test_multiline_flag() { + let result = search(r"^b", "a\nb", 8); + assert!(result.is_some()); + assert_eq!(result.unwrap().group, "b"); + } + + #[test] + fn test_dotall_flag() { + let result = search(r"a.b", "a\nb", 16); + assert!(result.is_some()); + assert_eq!(result.unwrap().group, "a\nb"); + } + + #[test] + fn test_capture_groups() { + let compiled = compile(r"(\d+)-(\d+)", 0).unwrap(); + let result = compiled.search("abc123-456def").unwrap(); + assert!(result.matched); + assert_eq!(result.group, "123-456"); + assert_eq!(result.groups.len(), 2); + assert_eq!(result.groups[0], Some("123".to_string())); + assert_eq!(result.groups[1], Some("456".to_string())); + } + + #[test] + fn test_finditer() { + let results = finditer(r"\d+", "a1b22c333", 0); + assert_eq!(results.len(), 3); + assert_eq!(results[0].group, "1"); + assert_eq!(results[1].group, "22"); + assert_eq!(results[2].group, "333"); + } + + #[test] + fn test_match_span() { + let result = search(r"\d+", "abc123def", 0).unwrap(); + assert_eq!(result.span(), (3, 6)); + } +}