Simple block parser is back

src/blocks/simple.rs

@@ -1,21 +1,21 @@
 use nom::{multi::many1, IResult};
 
-use crate::primitives::non_empty_line;
+use crate::{input::Input, primitives::non_empty_line};
 
 /// A block that's treated as contiguous lines of paragraph text (and subject to
 /// normal substitutions) (e.g., a paragraph block).
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct SimpleBlock<'a> {
     /// Lines that were found.
-    pub inlines: Vec<&'a str>,
+    pub inlines: Vec<Input<'a>>,
 }
 
 impl<'a> SimpleBlock<'a> {
     /// Parse a byte-slice as a simple AsciiDoc block.
     ///
     /// Returns a tuple of the remaining input and the simple block.
     #[allow(dead_code)] // TEMPORARY
-    pub fn from_str(i: &'a str) -> IResult<&str, Self> {
+    pub(crate) fn parse(i: Input<'a>) -> IResult<Input, Self> {
         let (i, inlines) = many1(non_empty_line)(i)?;
 
         Ok((i, Self { inlines }))

src/lib.rs

@@ -5,7 +5,7 @@
 #![deny(warnings)]
 #![doc = include_str!("../README.md")]
 
-// pub mod blocks;
+pub mod blocks;
 
 mod error;
 pub use error::{Error, ParseResult};

src/tests/blocks/simple.rs

@@ -3,43 +3,56 @@ use nom::{
     Err,
 };
 
-use crate::blocks::simple::SimpleBlock;
+use crate::{blocks::simple::SimpleBlock, input::Input};
 
 #[test]
 fn empty_source() {
-    let expected_err: Err<Error<&str>> = Err::Error(Error::new("", ErrorKind::TakeTill1));
+    let expected_err = Err::Error(Error::new(Input::new("", true), ErrorKind::TakeTill1));
 
-    let actual_err = SimpleBlock::from_str("").unwrap_err();
+    let actual_err = SimpleBlock::parse(Input::new("", true)).unwrap_err();
 
     assert_eq!(expected_err, actual_err);
 }
 
 #[test]
 fn only_spaces() {
-    let expected_err: Err<Error<&str>> = Err::Error(Error::new("   ", ErrorKind::TakeTill1));
+    let expected_err = Err::Error(Error::new(Input::new("    ", true), ErrorKind::TakeTill1));
 
-    let actual_err = SimpleBlock::from_str("   ").unwrap_err();
+    let actual_err = SimpleBlock::parse(Input::new("    ", true)).unwrap_err();
 
     assert_eq!(expected_err, actual_err);
 }
 
 #[test]
 fn single_line() {
     let expected = SimpleBlock {
-        inlines: vec!["abc"],
+        inlines: vec![Input::new("abc", true)],
     };
 
-    assert_eq!(SimpleBlock::from_str("abc"), Ok(("", expected)));
+    let (rem, block) = SimpleBlock::parse(Input::new("abc", true)).unwrap();
+
+    assert_eq!(rem.line(), 1);
+    assert_eq!(rem.col(), 4);
+    assert_eq!(*rem.data(), "");
+
+    assert_eq!(block, expected);
 }
 
 #[test]
 fn multiple_lines() {
-    let expected = SimpleBlock {
-        inlines: vec!["abc", "def"],
-    };
+    let (rem, block) = SimpleBlock::parse(Input::new("abc\ndef", true)).unwrap();
+
+    assert_eq!(rem.line(), 2);
+    assert_eq!(rem.col(), 4);
+    assert_eq!(*rem.data(), "");
+
+    assert_eq!(block.inlines.len(), 2);
+
+    assert_eq!(block.inlines[0].line(), 1);
+    assert_eq!(block.inlines[0].col(), 1);
+    assert_eq!(*block.inlines[0].data(), "abc");
 
-    assert_eq!(
-        SimpleBlock::from_str("abc\ndef\n\nghi"),
-        Ok(("\nghi", expected))
-    );
+    assert_eq!(block.inlines[1].line(), 2);
+    assert_eq!(block.inlines[1].col(), 1);
+    assert_eq!(*block.inlines[1].data(), "def");
 }

src/tests/mod.rs

@@ -5,7 +5,7 @@
 #![allow(clippy::panic)]
 #![allow(clippy::unwrap_used)]
 
-// mod blocks;
+mod blocks;
 mod fixtures;
 mod input;
 mod primitives;