pub struct PyRegex {
engine: Engine,
closes: Vec<usize>,
}
enum Engine {
Fast(regex::Regex),
Fancy(fancy_regex::Regex),
}
pub type Spans = Vec<Option<(usize, usize)>>;
pub fn char_index_of(text: &str, byte: usize) -> usize {
match text.get(..byte) {
Some(prefix) => prefix.chars().count(),
None => text
.char_indices()
.take_while(|(i, _)| *i < byte)
.count()
.min(text.chars().count()),
}
}
pub fn byte_index_of(text: &str, ch: usize) -> usize {
text.char_indices()
.nth(ch)
.map(|(i, _)| i)
.unwrap_or(text.len())
}
impl PyRegex {
pub fn new(pattern: &str) -> Result<Self, String> {
let engine = match regex::Regex::new(pattern) {
Ok(re) => Engine::Fast(re),
Err(fast_err) => match fancy_regex::Regex::new(&fancy_spelling(pattern)) {
Ok(re) => Engine::Fancy(re),
Err(_) => return Err(last_line(&fast_err.to_string())),
},
};
Ok(PyRegex {
engine,
closes: group_closes(pattern),
})
}
pub fn captures_len(&self) -> usize {
match &self.engine {
Engine::Fast(re) => re.captures_len(),
Engine::Fancy(re) => re.captures_len(),
}
}
pub fn named_groups(&self) -> Vec<(String, usize)> {
match &self.engine {
Engine::Fast(re) => named_from(re.capture_names()),
Engine::Fancy(re) => named_from(re.capture_names()),
}
}
pub fn captures_at(&self, text: &str, start: usize) -> Option<Spans> {
let n = self.captures_len();
match &self.engine {
Engine::Fast(re) => re.captures_at(text, start).map(|c| collect_spans(&c, n)),
Engine::Fancy(re) => re
.captures_from_pos(text, start)
.ok()
.flatten()
.map(|c| collect_fancy_spans(&c, n)),
}
}
pub fn search_from(&self, text: &str, pos: usize, must_advance: bool) -> Option<Spans> {
let spans = self.captures_at(text, pos)?;
let (s, e) = spans.first().copied().flatten()?;
if !(must_advance && s == pos && e == pos) {
return Some(spans);
}
let next = pos + text[pos..].chars().next()?.len_utf8();
self.captures_at(text, next)
}
pub fn all_captures(&self, text: &str) -> Vec<Spans> {
let mut out = Vec::new();
let mut pos = 0usize;
let mut must_advance = false;
while pos <= text.len() {
let Some(spans) = self.search_from(text, pos, must_advance) else {
break;
};
let Some((s, e)) = spans.first().copied().flatten() else {
break;
};
must_advance = s == e;
pos = e;
out.push(spans);
}
out
}
pub fn last_closed_group(&self, spans: &Spans) -> Option<usize> {
spans
.iter()
.enumerate()
.skip(1)
.filter_map(|(g, span)| span.map(|(_, end)| (end, self.closes.get(g).copied(), g)))
.max()
.map(|(_, _, g)| g)
}
}
fn group_closes(pattern: &str) -> Vec<usize> {
let chars: Vec<char> = pattern.chars().collect();
let mut closes = vec![0];
let mut open: Vec<(Option<usize>, bool)> = Vec::new();
let mut verbose = false;
let mut class_depth = 0usize;
let mut i = 0;
while i < chars.len() {
let c = chars[i];
match c {
'\\' => i += 1,
'[' => {
class_depth += 1;
if chars.get(i + 1) == Some(&'^') {
i += 1;
}
if chars.get(i + 1) == Some(&']') {
i += 1;
}
}
']' if class_depth > 0 => class_depth -= 1,
_ if class_depth > 0 => {}
'#' if verbose => {
while i < chars.len() && chars[i] != '\n' {
i += 1;
}
}
'(' if chars.get(i + 1) == Some(&'?') => {
let rest: String = chars[i + 2..].iter().take(3).collect();
if rest.starts_with('#') {
while i < chars.len() && chars[i] != ')' {
i += 1;
}
} else if rest.starts_with("P<")
|| (rest.starts_with('<') && !rest[1..].starts_with(['=', '!']))
{
closes.push(0);
open.push((Some(closes.len() - 1), verbose));
} else {
let flags: String = chars[i + 2..]
.iter()
.take_while(|ch| ch.is_ascii_alphabetic() || **ch == '-')
.collect();
let after = chars.get(i + 2 + flags.chars().count());
let sets_x = flags.split('-').next().is_some_and(|on| on.contains('x'));
let clears_x = flags.split('-').nth(1).is_some_and(|off| off.contains('x'));
let flagged = (verbose || sets_x) && !clears_x;
if after == Some(&')') {
verbose = flagged;
i += 2 + flags.chars().count();
} else {
open.push((None, verbose));
if after == Some(&':') {
verbose = flagged;
}
}
}
}
'(' => {
closes.push(0);
open.push((Some(closes.len() - 1), verbose));
}
')' => {
if let Some((group, outer_verbose)) = open.pop() {
if let Some(g) = group {
closes[g] = i;
}
verbose = outer_verbose;
}
}
_ => {}
}
i += 1;
}
closes
}
fn fancy_spelling(pattern: &str) -> std::borrow::Cow<'_, str> {
if !pattern.contains("(?-u:") {
return std::borrow::Cow::Borrowed(pattern);
}
const W: &str = "[0-9A-Za-z_]";
let boundary = format!("(?:(?<={W})(?!{W})|(?<!{W})(?={W}))");
let not_boundary = format!("(?:(?<={W})(?={W})|(?<!{W})(?!{W}))");
let mut spelled = pattern
.replace("(?-u:\\b)", &boundary)
.replace("(?-u:\\B)", ¬_boundary);
for letter in ["k", "K", "s", "S"] {
spelled = spelled.replace(&format!("(?-u:{letter})"), letter);
}
std::borrow::Cow::Owned(spelled)
}
fn named_from<'a>(names: impl Iterator<Item = Option<&'a str>>) -> Vec<(String, usize)> {
names
.enumerate()
.filter_map(|(i, n)| n.map(|n| (n.to_string(), i)))
.collect()
}
fn collect_spans(caps: ®ex::Captures<'_>, n: usize) -> Spans {
(0..n)
.map(|i| caps.get(i).map(|m| (m.start(), m.end())))
.collect()
}
fn collect_fancy_spans(caps: &fancy_regex::Captures<'_>, n: usize) -> Spans {
(0..n)
.map(|i| caps.get(i).map(|m| (m.start(), m.end())))
.collect()
}
fn last_line(msg: &str) -> String {
msg.lines()
.last()
.unwrap_or("bad pattern")
.trim()
.to_string()
}