Merge branch 'src_block'

default_environment/templates/html/inline_source_block.dust

@@ -1 +1 @@
-!!!!!!!! inline_source_block
+<code>{.value}</code>

default_environment/templates/html/src_block.dust

@@ -1 +1,9 @@
-!!!!!!!! src_block
+<table>
+  <tbody>
+    {#.lines}
+      <tr>
+        <td><code>{.}</code></td>
+      </tr>
+    {/.lines}
+  </tbody>
+</table>

src/context/inline_source_block.rs

@@ -9,15 +9,19 @@ use crate::intermediate::IInlineSourceBlock;
 #[derive(Debug, Serialize)]
 #[serde(tag = "type")]
 #[serde(rename = "inline_source_block")]
-pub(crate) struct RenderInlineSourceBlock {}
+pub(crate) struct RenderInlineSourceBlock {
+    value: String,
+}
 
 impl RenderInlineSourceBlock {
     pub(crate) fn new(
         config: &Config,
         output_directory: &Path,
         output_file: &Path,
-        comment: &IInlineSourceBlock,
+        original: &IInlineSourceBlock,
     ) -> Result<RenderInlineSourceBlock, CustomError> {
-        Ok(RenderInlineSourceBlock {})
+        Ok(RenderInlineSourceBlock {
+            value: original.value.clone(),
+        })
     }
 }

src/context/src_block.rs

@@ -9,7 +9,9 @@ use crate::intermediate::ISrcBlock;
 #[derive(Debug, Serialize)]
 #[serde(tag = "type")]
 #[serde(rename = "src_block")]
-pub(crate) struct RenderSrcBlock {}
+pub(crate) struct RenderSrcBlock {
+    lines: Vec<String>,
+}
 
 impl RenderSrcBlock {
     pub(crate) fn new(
@@ -18,6 +20,8 @@ impl RenderSrcBlock {
         output_file: &Path,
         original: &ISrcBlock,
     ) -> Result<RenderSrcBlock, CustomError> {
-        Ok(RenderSrcBlock {})
+        Ok(RenderSrcBlock {
+            lines: original.lines.clone(),
+        })
     }
 }

src/intermediate/inline_source_block.rs

@@ -3,13 +3,17 @@ use crate::error::CustomError;
 use super::registry::Registry;
 
 #[derive(Debug)]
-pub(crate) struct IInlineSourceBlock {}
+pub(crate) struct IInlineSourceBlock {
+    pub(crate) value: String,
+}
 
 impl IInlineSourceBlock {
     pub(crate) async fn new<'parse>(
         registry: &mut Registry<'parse>,
         original: &organic::types::InlineSourceBlock<'parse>,
     ) -> Result<IInlineSourceBlock, CustomError> {
-        Ok(IInlineSourceBlock {})
+        Ok(IInlineSourceBlock {
+            value: original.value.to_owned(),
+        })
     }
 }

src/intermediate/src_block.rs

@@ -1,15 +1,23 @@
 use crate::error::CustomError;
 
 use super::registry::Registry;
+use super::util::GetFullLines;
 
 #[derive(Debug)]
-pub(crate) struct ISrcBlock {}
+pub(crate) struct ISrcBlock {
+    pub(crate) lines: Vec<String>,
+}
 
 impl ISrcBlock {
     pub(crate) async fn new<'parse>(
         registry: &mut Registry<'parse>,
         original: &organic::types::SrcBlock<'parse>,
     ) -> Result<ISrcBlock, CustomError> {
-        Ok(ISrcBlock {})
+        let lines = original
+            .contents
+            .full_lines()
+            .map(|s| s.to_owned())
+            .collect();
+        Ok(ISrcBlock { lines })
     }
 }

src/intermediate/util.rs

@@ -46,3 +46,129 @@ enum CoalesceWhitespace {
     Normal,
     HasWhitespace { in_whitespace: bool, ret: String },
 }
+
+pub(crate) struct FullLinesIterator<'i> {
+    inner: Option<&'i str>,
+}
+
+impl<'i> Iterator for FullLinesIterator<'i> {
+    type Item = &'i str;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(inner) = self.inner {
+            for (i, c) in inner.char_indices() {
+                if c == '\n' {
+                    let (current_line, remainder) = inner.split_at(i + 1);
+                    self.inner = Some(remainder);
+                    return Some(current_line);
+                }
+            }
+            if inner.is_empty() {
+                None
+            } else {
+                let final_unterminated_line = Some(inner);
+                self.inner = None;
+                final_unterminated_line
+            }
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if let Some(inner) = self.inner {
+            let line_count = {
+                inner.bytes().filter(|b| *b == b'\n').count()
+                    + (if inner.ends_with('\n') { 0 } else { 1 })
+            };
+            (line_count, Some(line_count))
+        } else {
+            (0, Some(0))
+        }
+    }
+}
+
+impl ExactSizeIterator for FullLinesIterator<'_> {}
+
+pub(crate) trait GetFullLines {
+    fn full_lines(&self) -> FullLinesIterator<'_>;
+}
+
+impl<'s, S: AsRef<str>> GetFullLines for S {
+    fn full_lines(&self) -> FullLinesIterator<'_> {
+        let inner = self.as_ref();
+        FullLinesIterator {
+            inner: if inner.is_empty() { None } else { Some(inner) },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_full_lines_iterator() {
+        {
+            let input = "foo\nbar\nbaz";
+            assert_eq!(input.lines().count(), input.full_lines().count());
+            assert_eq!(input.lines().count(), input.full_lines().len());
+            assert_eq!(input.lines().collect::<Vec<_>>(), vec!["foo", "bar", "baz"]);
+            assert_eq!(
+                input.full_lines().collect::<Vec<_>>(),
+                vec!["foo\n", "bar\n", "baz"]
+            );
+        }
+
+        {
+            // Trailing newline
+            let input = "foo\nbar\nbaz\n";
+            assert_eq!(input.lines().count(), input.full_lines().count());
+            assert_eq!(input.lines().count(), input.full_lines().len());
+            assert_eq!(input.lines().collect::<Vec<_>>(), vec!["foo", "bar", "baz"]);
+            assert_eq!(
+                input.full_lines().collect::<Vec<_>>(),
+                vec!["foo\n", "bar\n", "baz\n"]
+            );
+        }
+
+        {
+            // Leading newline
+            let input = "\nfoo\nbar\nbaz";
+            assert_eq!(input.lines().count(), input.full_lines().count());
+            assert_eq!(input.lines().count(), input.full_lines().len());
+            assert_eq!(
+                input.lines().collect::<Vec<_>>(),
+                vec!["", "foo", "bar", "baz"]
+            );
+            assert_eq!(
+                input.full_lines().collect::<Vec<_>>(),
+                vec!["\n", "foo\n", "bar\n", "baz"]
+            );
+        }
+
+        {
+            // Double newline
+            let input = "foo\nbar\n\nbaz";
+            assert_eq!(input.lines().count(), input.full_lines().count());
+            assert_eq!(input.lines().count(), input.full_lines().len());
+            assert_eq!(
+                input.lines().collect::<Vec<_>>(),
+                vec!["foo", "bar", "", "baz"]
+            );
+            assert_eq!(
+                input.full_lines().collect::<Vec<_>>(),
+                vec!["foo\n", "bar\n", "\n", "baz"]
+            );
+        }
+
+        {
+            // Empty
+            let input = "";
+            assert_eq!(input.lines().count(), input.full_lines().count());
+            assert_eq!(input.lines().count(), input.full_lines().len());
+            assert_eq!(input.lines().collect::<Vec<_>>(), Vec::<&str>::new());
+            assert_eq!(input.full_lines().collect::<Vec<_>>(), Vec::<&str>::new());
+        }
+    }
+}