nom 6.0.0-alpha2

/// `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) => ( {
      let r = $crate::lib::regex::Regex::new($re).unwrap();
      $crate::regexp::str::re_match(r)($i)
      } )
);

/// `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) => ( {
      let r = $crate::lib::regex::bytes::Regex::new($re).unwrap();
      $crate::regexp::bytes::re_match(r)($i)
      } )
);

/// `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) => ( {
      let r = $crate::lib::regex::Regex::new($re).unwrap();
      $crate::regexp::str::re_find(r)($i)
      } )
);

/// `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) => ( {
      let r = $crate::lib::regex::bytes::Regex::new($re).unwrap();
      $crate::regexp::bytes::re_find(r)($i)
      } )
);

/// `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) => ( {
      let r = $crate::lib::regex::Regex::new($re).unwrap();
      $crate::regexp::str::re_matches(r)($i)
      } )
);

/// `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) => ( {
      let r = $crate::lib::regex::bytes::Regex::new($re).unwrap();
      $crate::regexp::bytes::re_matches(r)($i)
      } )
);

/// `re_capture!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>`
/// Returns the capture groups of the first match.
///
/// Requires the `regexp` feature.
#[macro_export(local_inner_macros)]
macro_rules! re_capture (
  ($i:expr, $re:expr) => ( {
      let r = $crate::lib::regex::Regex::new($re).unwrap();
      $crate::regexp::str::re_capture(r)($i)
      } )
);

/// `re_bytes_capture!(regexp) => &[T] -> IResult<&[T], Vec<&[T]>>`
/// Returns the capture groups of the first match.
///
/// Requires the `regexp` feature.
#[macro_export(local_inner_macros)]
macro_rules! re_bytes_capture (
  ($i:expr, $re:expr) => ( {
      let r = $crate::lib::regex::bytes::Regex::new($re).unwrap();
      $crate::regexp::bytes::re_capture(r)($i)
      }
      )
);

/// `re_captures!(regexp) => &[T] -> IResult<&[T], Vec<Vec<&[T]>>>`
/// Returns the capture groups of all matches.
///
/// Requires the `regexp` feature.
#[macro_export(local_inner_macros)]
macro_rules! re_captures (
  ($i:expr, $re:expr) => ( {
      let r = $crate::lib::regex::Regex::new($re).unwrap();
      $crate::regexp::str::re_captures(r)($i)
      } )
);

/// `re_bytes_captures!(regexp) => &[T] -> IResult<&[T], Vec<Vec<&[T]>>>`
/// Returns the capture groups of all matches.
///
/// Requires the `regexp` feature.
#[macro_export(local_inner_macros)]
macro_rules! re_bytes_captures (
  ($i:expr, $re:expr) => ( {
      let r = $crate::lib::regex::bytes::Regex::new($re).unwrap();
      $crate::regexp::bytes::re_captures(r)($i)
      } )
);

#[cfg(test)]
mod tests {
  use crate::error::ErrorKind;
  use crate::internal::Err;
  #[cfg(feature = "alloc")]
  use crate::lib::std::vec::Vec;

  #[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")));
  }

  #[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 = "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 = "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")]
  #[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"],
        ]
      ))
    );
  }

  #[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"[..]))
    );
  }

  #[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 = "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")]
  #[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")]
  #[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"[..],
          ],
        ]
      ))
    );
  }
}