| #[doc(hidden)] |
| #[macro_export] |
| macro_rules! regex ( |
| ($re: ident, $s:expr) => ( |
| lazy_static! { |
| static ref $re: $crate::lib::regex::Regex = $crate::lib::regex::Regex::new($s).unwrap(); |
| } |
| ); |
| ); |
| |
| #[doc(hidden)] |
| #[macro_export] |
| macro_rules! regex_bytes ( |
| ($re: ident, $s:expr) => ( |
| lazy_static! { |
| static ref $re: $crate::lib::regex::bytes::Regex = $crate::lib::regex::bytes::Regex::new($s).unwrap(); |
| } |
| ); |
| ); |
| |
| /// `re_match!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the whole input if a match is found |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_match ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::InputLength; |
| use $crate::Slice; |
| let re = $crate::lib::regex::Regex::new($re).unwrap(); |
| if re.is_match(&$i) { |
| Ok(($i.slice($i.input_len()..), $i)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatch))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_match_static!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the whole input if a match is found. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_match_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::InputLength; |
| use $crate::Slice; |
| regex!(RE, $re); |
| if RE.is_match(&$i) { |
| Ok(($i.slice($i.input_len()..), $i)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatch))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_bytes_match!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the whole input if a match is found |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_match ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::InputLength; |
| use $crate::Slice; |
| let re = $crate::lib::regex::bytes::Regex::new($re).unwrap(); |
| if re.is_match(&$i) { |
| Ok(($i.slice($i.input_len()..), $i)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatch))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_bytes_match_static!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the whole input if a match is found. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_match_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::InputLength; |
| use $crate::Slice; |
| regex_bytes!(RE, $re); |
| if RE.is_match(&$i) { |
| Ok(($i.slice($i.input_len()..), $i)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatch))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_find!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the first match |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_find ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::Regex::new($re).unwrap(); |
| if let Some(m) = re.find(&$i) { |
| Ok(($i.slice(m.end()..), $i.slice(m.start()..m.end()))) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpFind))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_find_static!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the first match. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_find_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex!(RE, $re); |
| if let Some(m) = RE.find(&$i) { |
| Ok(($i.slice(m.end()..), $i.slice(m.start()..m.end()))) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpFind))); |
| res |
| } |
| } |
| |
| ) |
| ); |
| |
| /// `re_bytes_find!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the first match |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_find ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::bytes::Regex::new($re).unwrap(); |
| if let Some(m) = re.find(&$i) { |
| Ok(($i.slice(m.end()..), $i.slice(m.start()..m.end()))) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpFind))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_bytes_find!(regexp) => &[T] -> IResult<&[T], &[T]>` |
| /// Returns the first match. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_find_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex_bytes!(RE, $re); |
| if let Some(m) = RE.find(&$i) { |
| Ok(($i.slice(m.end()..), $i.slice(m.start()..m.end()))) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpFind))); |
| res |
| } |
| } |
| |
| ) |
| ); |
| |
| /// `re_matches!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns all the matched parts |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_matches ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::Regex::new($re).unwrap(); |
| let v: Vec<_> = re.find_iter(&$i).map(|m| $i.slice(m.start()..m.end())).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatches))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_matches_static!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns all the matched parts. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_matches_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex!(RE, $re); |
| let v: Vec<_> = RE.find_iter(&$i).map(|m| $i.slice(m.start()..m.end())).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatches))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_bytes_matches!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns all the matched parts |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_matches ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::bytes::Regex::new($re).unwrap(); |
| let v: Vec<_> = re.find_iter(&$i).map(|m| $i.slice(m.start()..m.end())).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatches))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_bytes_matches_static!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns all the matched parts. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_matches_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex_bytes!(RE, $re); |
| let v: Vec<_> = RE.find_iter(&$i).map(|m| $i.slice(m.start()..m.end())).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpMatches))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_capture!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns the first capture group |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_capture ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::Regex::new($re).unwrap(); |
| if let Some(c) = re.captures(&$i) { |
| let v:Vec<_> = c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect(); |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_capture_static!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns the first capture group. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_capture_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex!(RE, $re); |
| if let Some(c) = RE.captures(&$i) { |
| let v:Vec<_> = c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect(); |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_bytes_capture!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns the first capture group |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_capture ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::bytes::Regex::new($re).unwrap(); |
| if let Some(c) = re.captures(&$i) { |
| let v:Vec<_> = c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect(); |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_bytes_capture_static!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>` |
| /// Returns the first capture group. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_capture_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex_bytes!(RE, $re); |
| if let Some(c) = RE.captures(&$i) { |
| let v:Vec<_> = c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect(); |
| let offset = { |
| let end = v.last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_captures!(regexp) => &[T] -> IResult<&[T], Vec<Vec<&[T]>>>` |
| /// Returns all the capture groups |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_captures ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::Regex::new($re).unwrap(); |
| let v:Vec<Vec<_>> = re.captures_iter(&$i) |
| .map(|c| c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()) |
| .map(|m| $i.slice(m.start()..m.end())).collect()).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap().last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_captures_static!(regexp) => &[T] -> IResult<&[T], Vec<Vec<&[T]>>>` |
| /// Returns all the capture groups. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_captures_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex!(RE, $re); |
| let v:Vec<Vec<_>> = RE.captures_iter(&$i) |
| .map(|c| c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect()).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap().last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| /// `re_bytes_captures!(regexp) => &[T] -> IResult<&[T], Vec<Vec<&[T]>>>` |
| /// Returns all the capture groups |
| /// |
| /// requires the `regexp` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_captures ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| let re = $crate::lib::regex::bytes::Regex::new($re).unwrap(); |
| let v:Vec<Vec<_>> = re.captures_iter(&$i) |
| .map(|c| c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect()).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap().last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| |
| #[cfg(feature = "regexp_macros")] |
| /// `re_bytes_captures_static!(regexp) => &[T] -> IResult<&[T], Vec<Vec<&[T]>>>` |
| /// Returns all the capture groups. Regular expression calculated at compile time |
| /// |
| /// requires the `regexp_macros` feature |
| #[macro_export(local_inner_macros)] |
| macro_rules! re_bytes_captures_static ( |
| ($i:expr, $re:expr) => ( |
| { |
| use $crate::lib::std::result::Result::*; |
| use $crate::{Err,error::ErrorKind,IResult}; |
| |
| use $crate::Slice; |
| regex_bytes!(RE, $re); |
| let v:Vec<Vec<_>> = RE.captures_iter(&$i) |
| .map(|c| c.iter().filter(|el| el.is_some()).map(|el| el.unwrap()).map(|m| $i.slice(m.start()..m.end())).collect()).collect(); |
| if v.len() != 0 { |
| let offset = { |
| let end = v.last().unwrap().last().unwrap(); |
| end.as_ptr() as usize + end.len() - $i.as_ptr() as usize |
| }; |
| Ok(($i.slice(offset..), v)) |
| } else { |
| let res: IResult<_,_> = Err(Err::Error(error_position!($i, ErrorKind::RegexpCapture))); |
| res |
| } |
| } |
| ) |
| ); |
| #[cfg(test)] |
| mod tests { |
| #[cfg(feature = "alloc")] |
| use crate::lib::std::vec::Vec; |
| use crate::error::ErrorKind; |
| use crate::internal::Err; |
| |
| #[test] |
| fn re_match() { |
| named!(rm<&str,&str>, re_match!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm("2015-09-07"), Ok(("", "2015-09-07"))); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpMatch |
| ),)) |
| ); |
| assert_eq!(rm("2015-09-07blah"), Ok(("", "2015-09-07blah"))); |
| } |
| |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_match_static() { |
| named!(rm<&str,&str>, re_match_static!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm("2015-09-07"), Ok(("", "2015-09-07"))); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpMatch |
| ),)) |
| ); |
| assert_eq!(rm("2015-09-07blah"), Ok(("", "2015-09-07blah"))); |
| } |
| |
| #[test] |
| fn re_find() { |
| named!(rm<&str,&str>, re_find!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm("2015-09-07"), Ok(("", "2015-09-07"))); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpFind |
| ),)) |
| ); |
| assert_eq!(rm("2015-09-07blah"), Ok(("blah", "2015-09-07"))); |
| } |
| |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_find_static() { |
| named!(rm<&str,&str>, re_find_static!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm("2015-09-07"), Ok(("", "2015-09-07"))); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpFind |
| ),)) |
| ); |
| assert_eq!(rm("2015-09-07blah"), Ok(("blah", "2015-09-07"))); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_matches() { |
| named!(rm< &str,Vec<&str> >, re_matches!(r"\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm("2015-09-07"), Ok(("", vec!["2015-09-07"]))); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpMatches |
| ))) |
| ); |
| assert_eq!( |
| rm("aaa2015-09-07blah2015-09-09pouet"), |
| Ok(("pouet", vec!["2015-09-07", "2015-09-09"])) |
| ); |
| } |
| |
| #[cfg(feature = "regexp_macros")] |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_matches_static() { |
| named!(rm< &str,Vec<&str> >, re_matches_static!(r"\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm("2015-09-07"), Ok(("", vec!["2015-09-07"]))); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpMatches |
| ))) |
| ); |
| assert_eq!( |
| rm("aaa2015-09-07blah2015-09-09pouet"), |
| Ok(("pouet", vec!["2015-09-07", "2015-09-09"])) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_capture() { |
| named!(rm< &str,Vec<&str> >, re_capture!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))")); |
| assert_eq!( |
| rm("blah nom 0.3.11pouet"), |
| Ok(("pouet", vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"])) |
| ); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm("hello nom 0.3.11 world regex 0.1.41"), |
| Ok(( |
| " world regex 0.1.41", |
| vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"] |
| )) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_capture_static() { |
| named!(rm< &str,Vec<&str> >, re_capture_static!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))")); |
| assert_eq!( |
| rm("blah nom 0.3.11pouet"), |
| Ok(("pouet", vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"])) |
| ); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm("hello nom 0.3.11 world regex 0.1.41"), |
| Ok(( |
| " world regex 0.1.41", |
| vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"] |
| )) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_captures() { |
| named!(rm< &str,Vec<Vec<&str>> >, re_captures!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))")); |
| assert_eq!( |
| rm("blah nom 0.3.11pouet"), |
| Ok(( |
| "pouet", |
| vec![vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"]] |
| )) |
| ); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm("hello nom 0.3.11 world regex 0.1.41 aaa"), |
| Ok(( |
| " aaa", |
| vec![ |
| vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"], |
| vec!["regex 0.1.41", "regex", "0.1.41", "0", "1", "41"], |
| ] |
| )) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_captures_static() { |
| named!(rm< &str,Vec<Vec<&str>> >, re_captures_static!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))")); |
| assert_eq!( |
| rm("blah nom 0.3.11pouet"), |
| Ok(( |
| "pouet", |
| vec![vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"]] |
| )) |
| ); |
| assert_eq!( |
| rm("blah"), |
| Err(Err::Error(error_position!( |
| &"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm("hello nom 0.3.11 world regex 0.1.41 aaa"), |
| Ok(( |
| " aaa", |
| vec![ |
| vec!["nom 0.3.11", "nom", "0.3.11", "0", "3", "11"], |
| vec!["regex 0.1.41", "regex", "0.1.41", "0", "1", "41"], |
| ] |
| )) |
| ); |
| } |
| |
| #[test] |
| fn re_bytes_match() { |
| named!(rm, re_bytes_match!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm(&b"2015-09-07"[..]), Ok((&b""[..], &b"2015-09-07"[..]))); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpMatch |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"2015-09-07blah"[..]), |
| Ok((&b""[..], &b"2015-09-07blah"[..])) |
| ); |
| } |
| |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_bytes_match_static() { |
| named!(rm, re_bytes_match_static!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm(&b"2015-09-07"[..]), Ok((&b""[..], &b"2015-09-07"[..]))); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpMatch |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"2015-09-07blah"[..]), |
| Ok((&b""[..], &b"2015-09-07blah"[..])) |
| ); |
| } |
| |
| #[test] |
| fn re_bytes_find() { |
| named!(rm, re_bytes_find!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm(&b"2015-09-07"[..]), Ok((&b""[..], &b"2015-09-07"[..]))); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpFind |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"2015-09-07blah"[..]), |
| Ok((&b"blah"[..], &b"2015-09-07"[..])) |
| ); |
| } |
| |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_bytes_find_static() { |
| named!(rm, re_bytes_find_static!(r"^\d{4}-\d{2}-\d{2}")); |
| assert_eq!(rm(&b"2015-09-07"[..]), Ok((&b""[..], &b"2015-09-07"[..]))); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpFind |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"2015-09-07blah"[..]), |
| Ok((&b"blah"[..], &b"2015-09-07"[..])) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_bytes_matches() { |
| named!(rm<Vec<&[u8]>>, re_bytes_matches!(r"\d{4}-\d{2}-\d{2}")); |
| assert_eq!( |
| rm(&b"2015-09-07"[..]), |
| Ok((&b""[..], vec![&b"2015-09-07"[..]])) |
| ); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpMatches |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"aaa2015-09-07blah2015-09-09pouet"[..]), |
| Ok((&b"pouet"[..], vec![&b"2015-09-07"[..], &b"2015-09-09"[..]])) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_bytes_matches_static() { |
| named!( |
| rm<Vec<&[u8]>>, |
| re_bytes_matches_static!(r"\d{4}-\d{2}-\d{2}") |
| ); |
| assert_eq!( |
| rm(&b"2015-09-07"[..]), |
| Ok((&b""[..], vec![&b"2015-09-07"[..]])) |
| ); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpMatches |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"aaa2015-09-07blah2015-09-09pouet"[..]), |
| Ok((&b"pouet"[..], vec![&b"2015-09-07"[..], &b"2015-09-09"[..]])) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_bytes_capture() { |
| named!( |
| rm<Vec<&[u8]>>, |
| re_bytes_capture!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))") |
| ); |
| assert_eq!( |
| rm(&b"blah nom 0.3.11pouet"[..]), |
| Ok(( |
| &b"pouet"[..], |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ] |
| )) |
| ); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"hello nom 0.3.11 world regex 0.1.41"[..]), |
| Ok(( |
| &b" world regex 0.1.41"[..], |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ] |
| )) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_bytes_capture_static() { |
| named!( |
| rm<Vec<&[u8]>>, |
| re_bytes_capture_static!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))") |
| ); |
| assert_eq!( |
| rm(&b"blah nom 0.3.11pouet"[..]), |
| Ok(( |
| &b"pouet"[..], |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ] |
| )) |
| ); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"hello nom 0.3.11 world regex 0.1.41"[..]), |
| Ok(( |
| &b" world regex 0.1.41"[..], |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ] |
| )) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[test] |
| fn re_bytes_captures() { |
| named!( |
| rm<Vec<Vec<&[u8]>>>, |
| re_bytes_captures!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))") |
| ); |
| assert_eq!( |
| rm(&b"blah nom 0.3.11pouet"[..]), |
| Ok(( |
| &b"pouet"[..], |
| vec![ |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ], |
| ] |
| )) |
| ); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"hello nom 0.3.11 world regex 0.1.41 aaa"[..]), |
| Ok(( |
| &b" aaa"[..], |
| vec![ |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ], |
| vec![ |
| &b"regex 0.1.41"[..], |
| &b"regex"[..], |
| &b"0.1.41"[..], |
| &b"0"[..], |
| &b"1"[..], |
| &b"41"[..], |
| ], |
| ] |
| )) |
| ); |
| } |
| |
| #[cfg(feature = "alloc")] |
| #[cfg(feature = "regexp_macros")] |
| #[test] |
| fn re_bytes_captures_static() { |
| named!( |
| rm<Vec<Vec<&[u8]>>>, |
| re_bytes_captures_static!(r"([[:alpha:]]+)\s+((\d+).(\d+).(\d+))") |
| ); |
| assert_eq!( |
| rm(&b"blah nom 0.3.11pouet"[..]), |
| Ok(( |
| &b"pouet"[..], |
| vec![ |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ], |
| ] |
| )) |
| ); |
| assert_eq!( |
| rm(&b"blah"[..]), |
| Err(Err::Error(error_position!( |
| &b"blah"[..], |
| ErrorKind::RegexpCapture |
| ))) |
| ); |
| assert_eq!( |
| rm(&b"hello nom 0.3.11 world regex 0.1.41 aaa"[..]), |
| Ok(( |
| &b" aaa"[..], |
| vec![ |
| vec![ |
| &b"nom 0.3.11"[..], |
| &b"nom"[..], |
| &b"0.3.11"[..], |
| &b"0"[..], |
| &b"3"[..], |
| &b"11"[..], |
| ], |
| vec![ |
| &b"regex 0.1.41"[..], |
| &b"regex"[..], |
| &b"0.1.41"[..], |
| &b"0"[..], |
| &b"1"[..], |
| &b"41"[..], |
| ], |
| ] |
| )) |
| ); |
| } |
| } |