| use super::{Regex, Region, SearchOptions}; |
| use std::iter::FusedIterator; |
| |
| impl Regex { |
| /// Returns the capture groups corresponding to the leftmost-first match |
| /// in text. Capture group `0` always corresponds to the entire match. |
| /// If no match is found, then `None` is returned. |
| pub fn captures<'t>(&self, text: &'t str) -> Option<Captures<'t>> { |
| let mut region = Region::new(); |
| self.search_with_options( |
| text, |
| 0, |
| text.len(), |
| SearchOptions::SEARCH_OPTION_NONE, |
| Some(&mut region), |
| ) |
| .map(|pos| Captures { |
| text, |
| region, |
| offset: pos, |
| }) |
| } |
| |
| /// Returns an iterator for each successive non-overlapping match in `text`, |
| /// returning the start and end byte indices with respect to `text`. |
| /// |
| /// # Example |
| /// |
| /// Find the start and end location of every word with exactly 13 |
| /// characters: |
| /// |
| /// ```rust |
| /// # use onig::Regex; |
| /// # fn main() { |
| /// let text = "Retroactively relinquishing remunerations is reprehensible."; |
| /// for pos in Regex::new(r"\b\w{13}\b").unwrap().find_iter(text) { |
| /// println!("{:?}", pos); |
| /// } |
| /// // Output: |
| /// // (0, 13) |
| /// // (14, 27) |
| /// // (28, 41) |
| /// // (45, 58) |
| /// # } |
| /// ``` |
| pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> FindMatches<'r, 't> { |
| FindMatches { |
| regex: self, |
| region: Region::new(), |
| text, |
| last_end: 0, |
| last_match_end: None, |
| } |
| } |
| |
| /// Returns an iterator over all the non-overlapping capture groups matched |
| /// in `text`. This is operationally the same as `find_iter` (except it |
| /// yields information about submatches). |
| /// |
| /// # Example |
| /// |
| /// We can use this to find all movie titles and their release years in |
| /// some text, where the movie is formatted like "'Title' (xxxx)": |
| /// |
| /// ```rust |
| /// # use onig::Regex; |
| /// # fn main() { |
| /// let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)") |
| /// .unwrap(); |
| /// let text = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931)."; |
| /// for caps in re.captures_iter(text) { |
| /// println!("Movie: {:?}, Released: {:?}", caps.at(1), caps.at(2)); |
| /// } |
| /// // Output: |
| /// // Movie: Citizen Kane, Released: 1941 |
| /// // Movie: The Wizard of Oz, Released: 1939 |
| /// // Movie: M, Released: 1931 |
| /// # } |
| /// ``` |
| pub fn captures_iter<'r, 't>(&'r self, text: &'t str) -> FindCaptures<'r, 't> { |
| FindCaptures { |
| regex: self, |
| text, |
| last_end: 0, |
| last_match_end: None, |
| } |
| } |
| |
| /// Returns an iterator of substrings of `text` delimited by a match |
| /// of the regular expression. |
| /// Namely, each element of the iterator corresponds to text that *isn't* |
| /// matched by the regular expression. |
| /// |
| /// This method will *not* copy the text given. |
| /// |
| /// # Example |
| /// |
| /// To split a string delimited by arbitrary amounts of spaces or tabs: |
| /// |
| /// ```rust |
| /// # use onig::Regex; |
| /// # fn main() { |
| /// let re = Regex::new(r"[ \t]+").unwrap(); |
| /// let fields: Vec<&str> = re.split("a b \t c\td e").collect(); |
| /// assert_eq!(fields, vec!("a", "b", "c", "d", "e")); |
| /// # } |
| /// ``` |
| pub fn split<'r, 't>(&'r self, text: &'t str) -> RegexSplits<'r, 't> { |
| RegexSplits { |
| finder: self.find_iter(text), |
| last: 0, |
| } |
| } |
| |
| /// Returns an iterator of at most `limit` substrings of `text` delimited |
| /// by a match of the regular expression. (A `limit` of `0` will return no |
| /// substrings.) |
| /// Namely, each element of the iterator corresponds to text that *isn't* |
| /// matched by the regular expression. |
| /// The remainder of the string that is not split will be the last element |
| /// in the iterator. |
| /// |
| /// This method will *not* copy the text given. |
| /// |
| /// # Example |
| /// |
| /// Get the first two words in some text: |
| /// |
| /// ```rust |
| /// # use onig::Regex; |
| /// # fn main() { |
| /// let re = Regex::new(r"\W+").unwrap(); |
| /// let fields: Vec<&str> = re.splitn("Hey! How are you?", 3).collect(); |
| /// assert_eq!(fields, vec!("Hey", "How", "are you?")); |
| /// # } |
| /// ``` |
| pub fn splitn<'r, 't>(&'r self, text: &'t str, limit: usize) -> RegexSplitsN<'r, 't> { |
| RegexSplitsN { |
| splits: self.split(text), |
| n: limit, |
| } |
| } |
| |
| /// Scan the given slice, capturing into the given region and |
| /// executing a callback for each match. |
| pub fn scan_with_region<F>( |
| &self, |
| to_search: &str, |
| region: &mut Region, |
| options: SearchOptions, |
| mut callback: F, |
| ) -> i32 |
| where |
| F: Fn(i32, i32, &Region) -> bool, |
| { |
| use onig_sys::{onig_scan, OnigRegion}; |
| use std::os::raw::{c_int, c_void}; |
| |
| // Find the bounds of the string we're searching |
| let start = to_search.as_ptr(); |
| let end = to_search[to_search.len()..].as_ptr(); |
| |
| unsafe extern "C" fn scan_cb<F>( |
| i: c_int, |
| j: c_int, |
| r: *mut OnigRegion, |
| ud: *mut c_void, |
| ) -> c_int |
| where |
| F: Fn(i32, i32, &Region) -> bool, |
| { |
| let region = Region::clone_from_raw(r); |
| let callback = &*(ud as *mut F); |
| if callback(i, j, ®ion) { |
| 0 |
| } else { |
| -1 |
| } |
| } |
| |
| unsafe { |
| onig_scan( |
| self.raw, |
| start, |
| end, |
| (&mut region.raw) as *mut ::onig_sys::OnigRegion, |
| options.bits(), |
| Some(scan_cb::<F>), |
| &mut callback as *mut F as *mut c_void, |
| ) |
| } |
| } |
| |
| /// Scan a Pattern and Observe Captures |
| /// |
| /// The scan function takes a haystack `to_search` and invokes the |
| /// given `callback` for each capture of this expression. |
| pub fn scan<'t, CB>(&self, to_search: &'t str, callback: CB) |
| where |
| CB: Fn(i32, Captures<'t>) -> bool, |
| { |
| let mut region = Region::new(); |
| self.scan_with_region( |
| to_search, |
| &mut region, |
| SearchOptions::SEARCH_OPTION_NONE, |
| |n, s, region| { |
| let captures = Captures { |
| text: to_search, |
| region: region.clone(), |
| offset: s as usize, |
| }; |
| callback(n, captures) |
| }, |
| ); |
| } |
| } |
| |
| /// Captures represents a group of captured strings for a single match. |
| /// |
| /// The 0th capture always corresponds to the entire match. Each subsequent |
| /// index corresponds to the next capture group in the regex. Positions |
| /// returned from a capture group are always byte indices. |
| /// |
| /// `'t` is the lifetime of the matched text. |
| #[derive(Debug)] |
| pub struct Captures<'t> { |
| text: &'t str, |
| region: Region, |
| offset: usize, |
| } |
| |
| impl<'t> Captures<'t> { |
| /// Returns the start and end positions of the Nth capture group. Returns |
| /// `None` if i is not a valid capture group or if the capture group did |
| /// not match anything. The positions returned are always byte indices with |
| /// respect to the original string matched. |
| pub fn pos(&self, pos: usize) -> Option<(usize, usize)> { |
| self.region.pos(pos) |
| } |
| |
| /// Returns the matched string for the capture group `i`. If `i` isn't |
| /// a valid capture group or didn't match anything, then `None` is returned. |
| pub fn at(&self, pos: usize) -> Option<&'t str> { |
| self.pos(pos).map(|(beg, end)| &self.text[beg..end]) |
| } |
| |
| /// Returns the number of captured groups. |
| pub fn len(&self) -> usize { |
| self.region.len() |
| } |
| |
| /// Returns true if and only if there are no captured groups. |
| pub fn is_empty(&self) -> bool { |
| self.len() == 0 |
| } |
| |
| /// Creates an iterator of all the capture groups in order of appearance in |
| /// the regular expression. |
| pub fn iter(&'t self) -> SubCaptures<'t> { |
| SubCaptures { idx: 0, caps: self } |
| } |
| |
| /// Creates an iterator of all the capture group positions in order of |
| /// appearance in the regular expression. Positions are byte indices in |
| /// terms of the original string matched. |
| pub fn iter_pos(&'t self) -> SubCapturesPos<'t> { |
| SubCapturesPos { idx: 0, caps: self } |
| } |
| |
| /// Offset of the captures within the given string slice. |
| pub fn offset(&self) -> usize { |
| self.offset |
| } |
| } |
| |
| /// An iterator over capture groups for a particular match of a regular |
| /// expression. |
| /// |
| /// `'t` is the lifetime of the matched text. |
| pub struct SubCaptures<'t> { |
| idx: usize, |
| caps: &'t Captures<'t>, |
| } |
| |
| impl<'t> Iterator for SubCaptures<'t> { |
| type Item = Option<&'t str>; |
| |
| fn next(&mut self) -> Option<Option<&'t str>> { |
| if self.idx < self.caps.len() { |
| self.idx += 1; |
| Some(self.caps.at(self.idx - 1)) |
| } else { |
| None |
| } |
| } |
| |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| let size = self.caps.len(); |
| (size, Some(size)) |
| } |
| |
| fn count(self) -> usize { |
| self.caps.len() |
| } |
| } |
| |
| impl<'t> FusedIterator for SubCaptures<'t> {} |
| |
| impl<'t> ExactSizeIterator for SubCaptures<'t> {} |
| |
| /// An iterator over capture group positions for a particular match of |
| /// a regular expression. |
| /// |
| /// Positions are byte indices in terms of the original |
| /// string matched. `'t` is the lifetime of the matched text. |
| pub struct SubCapturesPos<'t> { |
| idx: usize, |
| caps: &'t Captures<'t>, |
| } |
| |
| impl<'t> Iterator for SubCapturesPos<'t> { |
| type Item = Option<(usize, usize)>; |
| |
| fn next(&mut self) -> Option<Option<(usize, usize)>> { |
| if self.idx < self.caps.len() { |
| self.idx += 1; |
| Some(self.caps.pos(self.idx - 1)) |
| } else { |
| None |
| } |
| } |
| |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| let size = self.caps.len(); |
| (size, Some(size)) |
| } |
| |
| fn count(self) -> usize { |
| self.caps.len() |
| } |
| } |
| |
| impl<'t> FusedIterator for SubCapturesPos<'t> {} |
| |
| impl<'t> ExactSizeIterator for SubCapturesPos<'t> {} |
| |
| /// An iterator over all non-overlapping matches for a particular string. |
| /// |
| /// The iterator yields a tuple of integers corresponding to the start and end |
| /// of the match. The indices are byte offsets. The iterator stops when no more |
| /// matches can be found. |
| /// |
| /// `'r` is the lifetime of the `Regex` struct and `'t` is the lifetime |
| /// of the matched string. |
| pub struct FindMatches<'r, 't> { |
| regex: &'r Regex, |
| region: Region, |
| text: &'t str, |
| last_end: usize, |
| last_match_end: Option<usize>, |
| } |
| |
| impl<'r, 't> Iterator for FindMatches<'r, 't> { |
| type Item = (usize, usize); |
| |
| fn next(&mut self) -> Option<(usize, usize)> { |
| if self.last_end > self.text.len() { |
| return None; |
| } |
| self.region.clear(); |
| self.regex.search_with_options( |
| self.text, |
| self.last_end, |
| self.text.len(), |
| SearchOptions::SEARCH_OPTION_NONE, |
| Some(&mut self.region), |
| )?; |
| let (s, e) = self.region.pos(0).unwrap(); |
| |
| // Don't accept empty matches immediately following the last match. |
| // i.e., no infinite loops please. |
| if e == s && self.last_match_end.map_or(false, |l| l == e) { |
| self.last_end += self.text[self.last_end..] |
| .chars() |
| .next() |
| .map(|c| c.len_utf8()) |
| .unwrap_or(1); |
| return self.next(); |
| } else { |
| self.last_end = e; |
| self.last_match_end = Some(e); |
| } |
| |
| Some((s, e)) |
| } |
| } |
| |
| impl<'r, 't> FusedIterator for FindMatches<'r, 't> {} |
| |
| /// An iterator that yields all non-overlapping capture groups matching a |
| /// particular regular expression. |
| /// |
| /// The iterator stops when no more matches can be found. |
| /// |
| /// `'r` is the lifetime of the `Regex` struct and `'t` is the lifetime |
| /// of the matched string. |
| pub struct FindCaptures<'r, 't> { |
| regex: &'r Regex, |
| text: &'t str, |
| last_end: usize, |
| last_match_end: Option<usize>, |
| } |
| |
| impl<'r, 't> Iterator for FindCaptures<'r, 't> { |
| type Item = Captures<'t>; |
| |
| fn next(&mut self) -> Option<Captures<'t>> { |
| if self.last_end > self.text.len() { |
| return None; |
| } |
| |
| let mut region = Region::new(); |
| let r = self.regex.search_with_options( |
| self.text, |
| self.last_end, |
| self.text.len(), |
| SearchOptions::SEARCH_OPTION_NONE, |
| Some(&mut region), |
| )?; |
| let (s, e) = region.pos(0).unwrap(); |
| |
| // Don't accept empty matches immediately following the last match. |
| // i.e., no infinite loops please. |
| if e == s && self.last_match_end.map_or(false, |l| l == e) { |
| self.last_end += self.text[self.last_end..] |
| .chars() |
| .next() |
| .map(|c| c.len_utf8()) |
| .unwrap_or(1); |
| return self.next(); |
| } else { |
| self.last_end = e; |
| self.last_match_end = Some(e); |
| } |
| Some(Captures { |
| text: self.text, |
| region, |
| offset: r, |
| }) |
| } |
| } |
| |
| impl<'r, 't> FusedIterator for FindCaptures<'r, 't> {} |
| |
| /// Yields all substrings delimited by a regular expression match. |
| /// |
| /// `'r` is the lifetime of the compiled expression and `'t` is the lifetime |
| /// of the string being split. |
| pub struct RegexSplits<'r, 't> { |
| finder: FindMatches<'r, 't>, |
| last: usize, |
| } |
| |
| impl<'r, 't> Iterator for RegexSplits<'r, 't> { |
| type Item = &'t str; |
| |
| fn next(&mut self) -> Option<&'t str> { |
| let text = self.finder.text; |
| match self.finder.next() { |
| None => { |
| if self.last >= text.len() { |
| None |
| } else { |
| let s = &text[self.last..]; |
| self.last = text.len(); |
| Some(s) |
| } |
| } |
| Some((s, e)) => { |
| let matched = &text[self.last..s]; |
| self.last = e; |
| Some(matched) |
| } |
| } |
| } |
| } |
| |
| impl<'r, 't> FusedIterator for RegexSplits<'r, 't> {} |
| |
| /// Yields at most `N` substrings delimited by a regular expression match. |
| /// |
| /// The last substring will be whatever remains after splitting. |
| /// |
| /// `'r` is the lifetime of the compiled expression and `'t` is the lifetime |
| /// of the string being split. |
| pub struct RegexSplitsN<'r, 't> { |
| splits: RegexSplits<'r, 't>, |
| n: usize, |
| } |
| |
| impl<'r, 't> Iterator for RegexSplitsN<'r, 't> { |
| type Item = &'t str; |
| |
| fn next(&mut self) -> Option<&'t str> { |
| if self.n == 0 { |
| return None; |
| } |
| self.n -= 1; |
| if self.n == 0 { |
| let text = self.splits.finder.text; |
| Some(&text[self.splits.last..]) |
| } else { |
| self.splits.next() |
| } |
| } |
| |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| (0, Some(self.n)) |
| } |
| } |
| |
| impl<'r, 't> FusedIterator for RegexSplitsN<'r, 't> {} |
| |
| #[cfg(test)] |
| mod tests { |
| use super::super::*; |
| |
| #[test] |
| fn test_regex_captures() { |
| let regex = Regex::new("e(l+)|(r+)").unwrap(); |
| let captures = regex.captures("hello").unwrap(); |
| assert_eq!(captures.len(), 3); |
| assert_eq!(captures.is_empty(), false); |
| let pos1 = captures.pos(0).unwrap(); |
| let pos2 = captures.pos(1).unwrap(); |
| let pos3 = captures.pos(2); |
| assert_eq!(pos1, (1, 4)); |
| assert_eq!(pos2, (2, 4)); |
| assert_eq!(pos3, None); |
| let str1 = captures.at(0).unwrap(); |
| let str2 = captures.at(1).unwrap(); |
| let str3 = captures.at(2); |
| assert_eq!(str1, "ell"); |
| assert_eq!(str2, "ll"); |
| assert_eq!(str3, None); |
| } |
| |
| #[test] |
| fn test_regex_subcaptures() { |
| let regex = Regex::new("e(l+)").unwrap(); |
| let captures = regex.captures("hello").unwrap(); |
| let caps = captures.iter().collect::<Vec<_>>(); |
| assert_eq!(caps[0], Some("ell")); |
| assert_eq!(caps[1], Some("ll")); |
| assert_eq!(caps.len(), 2); |
| } |
| |
| #[test] |
| fn test_regex_subcapturespos() { |
| let regex = Regex::new("e(l+)").unwrap(); |
| let captures = regex.captures("hello").unwrap(); |
| let caps = captures.iter_pos().collect::<Vec<_>>(); |
| assert_eq!(caps[0], Some((1, 4))); |
| assert_eq!(caps[1], Some((2, 4))); |
| assert_eq!(caps.len(), 2); |
| } |
| |
| #[test] |
| fn test_find_iter() { |
| let re = Regex::new(r"\d+").unwrap(); |
| let ms = re.find_iter("a12b2").collect::<Vec<_>>(); |
| assert_eq!(ms, vec![(1, 3), (4, 5)]); |
| } |
| |
| #[test] |
| fn test_find_iter_one_zero_length() { |
| let re = Regex::new(r"\d*").unwrap(); |
| let ms = re.find_iter("a1b2").collect::<Vec<_>>(); |
| assert_eq!(ms, vec![(0, 0), (1, 2), (3, 4)]); |
| } |
| |
| #[test] |
| fn test_find_iter_many_zero_length() { |
| let re = Regex::new(r"\d*").unwrap(); |
| let ms = re.find_iter("a1bbb2").collect::<Vec<_>>(); |
| assert_eq!(ms, vec![(0, 0), (1, 2), (3, 3), (4, 4), (5, 6)]); |
| } |
| |
| #[test] |
| fn test_find_iter_empty_after_match() { |
| let re = Regex::new(r"b|(?=,)").unwrap(); |
| let ms = re.find_iter("ba,").collect::<Vec<_>>(); |
| assert_eq!(ms, vec![(0, 1), (2, 2)]); |
| } |
| |
| #[test] |
| fn test_zero_length_matches_jumps_past_match_location() { |
| let re = Regex::new(r"\b").unwrap(); |
| let matches = re.find_iter("test string").collect::<Vec<_>>(); |
| assert_eq!(matches, [(0, 0), (4, 4), (5, 5), (11, 11)]); |
| } |
| |
| #[test] |
| fn test_captures_iter() { |
| let re = Regex::new(r"\d+").unwrap(); |
| let ms = re.captures_iter("a12b2").collect::<Vec<_>>(); |
| assert_eq!(ms[0].pos(0).unwrap(), (1, 3)); |
| assert_eq!(ms[1].pos(0).unwrap(), (4, 5)); |
| } |
| |
| #[test] |
| fn test_captures_stores_match_offset() { |
| let reg = Regex::new(r"\d+\.(\d+)").unwrap(); |
| let captures = reg.captures("100 - 3.1415 / 2.0").unwrap(); |
| assert_eq!(6, captures.offset()); |
| let all_caps = reg |
| .captures_iter("1 - 3234.3 * 123.2 - 100") |
| .map(|cap| cap.offset()) |
| .collect::<Vec<_>>(); |
| assert_eq!(vec![4, 13], all_caps); |
| } |
| } |
