Standardize the construction of intermediate BlogPostPage.

src/intermediate/blog_post.rs

@@ -7,6 +7,7 @@ use tokio::task::JoinHandle;
 use walkdir::WalkDir;
 
 use crate::error::CustomError;
+use crate::intermediate::page::BlogPostPageInput;
 use crate::intermediate::registry::Registry;
 
 use super::BlogPostPage;
@@ -63,7 +64,10 @@ impl BlogPost {
                     let registry = Arc::new(Mutex::new(registry));
                     let relative_to_post_dir_path = real_path.strip_prefix(post_dir)?;
                     ret.push(
-                        BlogPostPage::new(relative_to_post_dir_path, registry, parsed_document)
+                        BlogPostPage::new(
+                            registry,
+                            BlogPostPageInput::new(relative_to_post_dir_path, parsed_document),
+                        )
                         .await?,
                     );
                 }

src/intermediate/bold.rs

@@ -8,7 +8,12 @@ pub(crate) struct IBold {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(IBold, Bold, original, registry, {
+intermediate!(
+    IBold,
+    &'orig organic::types::Bold<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(IBold, Bold, original, registry, {
         };
 
         Ok(IBold { children })
-});
+    }
+);

src/intermediate/code.rs

@@ -7,9 +7,15 @@ pub(crate) struct ICode {
     pub(crate) contents: String,
 }
 
-intermediate!(ICode, Code, original, _registry, {
+intermediate!(
+    ICode,
+    &'orig organic::types::Code<'parse>,
+    original,
+    _registry,
+    {
         Ok(ICode {
             // TODO: Should this coalesce whitespace like PlainText?
             contents: original.contents.to_owned(),
         })
-});
+    }
+);

src/intermediate/entity.rs

@@ -7,8 +7,14 @@ pub(crate) struct IEntity {
     pub(crate) html: String,
 }
 
-intermediate!(IEntity, Entity, original, _registry, {
+intermediate!(
+    IEntity,
+    &'orig organic::types::Entity<'parse>,
+    original,
+    _registry,
+    {
         Ok(IEntity {
             html: original.html.to_owned(),
         })
-});
+    }
+);

src/intermediate/footnote_definition.rs

@@ -10,7 +10,7 @@ pub(crate) struct IFootnoteDefinition {}
 
 intermediate!(
     IFootnoteDefinition,
-    FootnoteDefinition,
+    &'orig organic::types::FootnoteDefinition<'parse>,
     original,
     registry,
     {

src/intermediate/footnote_reference.rs

@@ -9,14 +9,20 @@ pub(crate) struct IFootnoteReference {
     duplicate_offset: usize,
 }
 
-intermediate!(IFootnoteReference, FootnoteReference, original, registry, {
+intermediate!(
+    IFootnoteReference,
+    &'orig organic::types::FootnoteReference<'parse>,
+    original,
+    registry,
+    {
         let (footnote_id, reference_count) =
             get_footnote_reference_id(registry, original.label, &original.definition).await?;
         Ok(IFootnoteReference {
             footnote_id,
             duplicate_offset: reference_count,
         })
-});
+    }
+);
 
 impl IFootnoteReference {
     pub(crate) fn get_display_label(&self) -> String {

src/intermediate/heading.rs

@@ -11,7 +11,12 @@ pub(crate) struct IHeading {
     pub(crate) children: Vec<IDocumentElement>,
 }
 
-intermediate!(IHeading, Heading, original, registry, {
+intermediate!(
+    IHeading,
+    &'orig organic::types::Heading<'parse>,
+    original,
+    registry,
+    {
         let title = {
             let mut ret = Vec::new();
             for obj in original.title.iter() {
@@ -31,4 +36,5 @@ intermediate!(IHeading, Heading, original, registry, {
             level: original.level,
             children,
         })
-});
+    }
+);

src/intermediate/inline_source_block.rs

@@ -7,8 +7,14 @@ pub(crate) struct IInlineSourceBlock {
     pub(crate) value: String,
 }
 
-intermediate!(IInlineSourceBlock, InlineSourceBlock, original, _registry, {
+intermediate!(
+    IInlineSourceBlock,
+    &'orig organic::types::InlineSourceBlock<'parse>,
+    original,
+    _registry,
+    {
         Ok(IInlineSourceBlock {
             value: original.value.to_owned(),
         })
-});
+    }
+);

src/intermediate/italic.rs

@@ -8,7 +8,12 @@ pub(crate) struct IItalic {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(IItalic, Italic, original, registry, {
+intermediate!(
+    IItalic,
+    &'orig organic::types::Italic<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(IItalic, Italic, original, registry, {
         };
 
         Ok(IItalic { children })
-});
+    }
+);

src/intermediate/latex_fragment.rs

@@ -7,7 +7,12 @@ pub(crate) struct ILatexFragment {
     pub(crate) value: String,
 }
 
-intermediate!(ILatexFragment, LatexFragment, original, _registry, {
+intermediate!(
+    ILatexFragment,
+    &'orig organic::types::LatexFragment<'parse>,
+    original,
+    _registry,
+    {
         let value: String = if original.value.starts_with("$$") && original.value.ends_with("$$") {
             format!("\\[{}\\]", &original.value[2..(original.value.len() - 2)])
         } else if original.value.starts_with("$") && original.value.ends_with("$") {
@@ -16,4 +21,5 @@ intermediate!(ILatexFragment, LatexFragment, original, _registry, {
             original.value.to_owned()
         };
         Ok(ILatexFragment { value })
-});
+    }
+);

src/intermediate/macros.rs

@@ -23,14 +23,12 @@ pub(crate) use inoop;
 ///
 /// This exists to make changing the type signature easier.
 macro_rules! intermediate {
-    ($istruct:ident, $pstruct:ident, $original:ident, $registry:ident, $fnbody:tt) => {
+    ($istruct:ident, $pstruct:ty, $original:ident, $registry:ident, $fnbody:tt) => {
         impl $istruct {
             pub(crate) async fn new<'orig, 'parse>(
-                registry: crate::intermediate::RefRegistry<'orig, 'parse>,
+                $registry: crate::intermediate::RefRegistry<'orig, 'parse>,
-                original: &'orig organic::types::$pstruct<'parse>,
+                $original: $pstruct,
             ) -> Result<$istruct, CustomError> {
-                let $original = original;
-                let $registry = registry;
                 $fnbody
             }
         }

src/intermediate/page.rs

@@ -4,10 +4,28 @@ use crate::error::CustomError;
 
 use super::footnote_definition::IRealFootnoteDefinition;
 
+use super::macros::intermediate;
 use super::IDocumentElement;
 use super::IHeading;
 use super::ISection;
-use super::RefRegistry;
+
+#[derive(Debug)]
+pub(crate) struct BlogPostPageInput<'b, 'parse> {
+    path: PathBuf,
+    document: &'b organic::types::Document<'parse>,
+}
+
+impl<'b, 'parse> BlogPostPageInput<'b, 'parse> {
+    pub(crate) fn new<P: Into<PathBuf>>(
+        path: P,
+        document: &'b organic::types::Document<'parse>,
+    ) -> BlogPostPageInput<'b, 'parse> {
+        BlogPostPageInput {
+            path: path.into(),
+            document,
+        }
+    }
+}
 
 #[derive(Debug)]
 pub(crate) struct BlogPostPage {
@@ -23,21 +41,19 @@ pub(crate) struct BlogPostPage {
     pub(crate) footnotes: Vec<IRealFootnoteDefinition>,
 }
 
-impl BlogPostPage {
+intermediate!(
-    // TODO: Move path into the registry so I can give this a standard interface like the others.
+    BlogPostPage,
-    pub(crate) async fn new<'a, 'b, 'parse, P: Into<PathBuf>>(
+    BlogPostPageInput<'orig, 'parse>,
-        path: P,
+    original,
-        registry: RefRegistry<'b, 'parse>,
+    registry,
-        document: &'b organic::types::Document<'parse>,
+    {
-    ) -> Result<BlogPostPage, CustomError> {
-        let path = path.into();
         let mut children = Vec::new();
-        if let Some(section) = document.zeroth_section.as_ref() {
+        if let Some(section) = original.document.zeroth_section.as_ref() {
             children.push(IDocumentElement::Section(
                 ISection::new(registry.clone(), section).await?,
             ));
         }
-        for heading in document.children.iter() {
+        for heading in original.document.children.iter() {
             children.push(IDocumentElement::Heading(
                 IHeading::new(registry.clone(), heading).await?,
             ));
@@ -60,14 +76,16 @@ impl BlogPostPage {
         };
 
         Ok(BlogPostPage {
-            path,
+            path: original.path,
-            title: get_title(&document),
+            title: get_title(original.document),
-            date: get_date(&document),
+            date: get_date(original.document),
             children,
             footnotes,
         })
     }
+);
 
+impl BlogPostPage {
     /// Get the output path relative to the post directory.
     pub(crate) fn get_output_path(&self) -> PathBuf {
         let mut ret = self.path.clone();

src/intermediate/paragraph.rs

@@ -8,7 +8,12 @@ pub(crate) struct IParagraph {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(IParagraph, Paragraph, original, registry, {
+intermediate!(
+    IParagraph,
+    &'orig organic::types::Paragraph<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(IParagraph, Paragraph, original, registry, {
         };
 
         Ok(IParagraph { children })
-});
+    }
+);

src/intermediate/plain_list.rs

@@ -9,7 +9,12 @@ pub(crate) struct IPlainList {
     pub(crate) children: Vec<IPlainListItem>,
 }
 
-intermediate!(IPlainList, PlainList, original, registry, {
+intermediate!(
+    IPlainList,
+    &'orig organic::types::PlainList<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -22,4 +27,5 @@ intermediate!(IPlainList, PlainList, original, registry, {
             list_type: original.list_type,
             children,
         })
-});
+    }
+);

src/intermediate/plain_list_item.rs

@@ -10,7 +10,12 @@ pub(crate) struct IPlainListItem {
     pub(crate) children: Vec<IElement>,
 }
 
-intermediate!(IPlainListItem, PlainListItem, original, registry, {
+intermediate!(
+    IPlainListItem,
+    &'orig organic::types::PlainListItem<'parse>,
+    original,
+    registry,
+    {
         let tag = {
             let mut ret = Vec::new();
             for obj in original.tag.iter() {
@@ -28,4 +33,5 @@ intermediate!(IPlainListItem, PlainListItem, original, registry, {
         };
 
         Ok(IPlainListItem { tag, children })
-});
+    }
+);

src/intermediate/plain_text.rs

@@ -8,8 +8,14 @@ pub(crate) struct IPlainText {
     pub(crate) source: String,
 }
 
-intermediate!(IPlainText, PlainText, original, _registry, {
+intermediate!(
+    IPlainText,
+    &'orig organic::types::PlainText<'parse>,
+    original,
+    _registry,
+    {
         Ok(IPlainText {
             source: coalesce_whitespace(original.source).into_owned(),
         })
-});
+    }
+);

src/intermediate/quote_block.rs

@@ -8,7 +8,12 @@ pub(crate) struct IQuoteBlock {
     pub(crate) children: Vec<IElement>,
 }
 
-intermediate!(IQuoteBlock, QuoteBlock, original, registry, {
+intermediate!(
+    IQuoteBlock,
+    &'orig organic::types::QuoteBlock<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(IQuoteBlock, QuoteBlock, original, registry, {
         };
 
         Ok(IQuoteBlock { children })
-});
+    }
+);

src/intermediate/regular_link.rs

@@ -9,7 +9,12 @@ pub(crate) struct IRegularLink {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(IRegularLink, RegularLink, original, registry, {
+intermediate!(
+    IRegularLink,
+    &'orig organic::types::RegularLink<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -21,4 +26,5 @@ intermediate!(IRegularLink, RegularLink, original, registry, {
             raw_link: original.get_raw_link().into_owned(),
             children,
         })
-});
+    }
+);

src/intermediate/section.rs

@@ -8,7 +8,12 @@ pub(crate) struct ISection {
     pub(crate) children: Vec<IElement>,
 }
 
-intermediate!(ISection, Section, original, registry, {
+intermediate!(
+    ISection,
+    &'orig organic::types::Section<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for elem in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(ISection, Section, original, registry, {
         };
 
         Ok(ISection { children })
-});
+    }
+);

src/intermediate/src_block.rs

@@ -7,11 +7,17 @@ pub(crate) struct ISrcBlock {
     pub(crate) lines: Vec<String>,
 }
 
-intermediate!(ISrcBlock, SrcBlock, original, _registry, {
+intermediate!(
+    ISrcBlock,
+    &'orig organic::types::SrcBlock<'parse>,
+    original,
+    _registry,
+    {
         let lines = original
             .get_value()
             .split_inclusive('\n')
             .map(|s| s.to_owned())
             .collect();
         Ok(ISrcBlock { lines })
-});
+    }
+);

src/intermediate/strike_through.rs

@@ -8,7 +8,12 @@ pub(crate) struct IStrikeThrough {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(IStrikeThrough, StrikeThrough, original, registry, {
+intermediate!(
+    IStrikeThrough,
+    &'orig organic::types::StrikeThrough<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(IStrikeThrough, StrikeThrough, original, registry, {
         };
 
         Ok(IStrikeThrough { children })
-});
+    }
+);

src/intermediate/table.rs

@@ -8,7 +8,12 @@ pub(crate) struct ITable {
     pub(crate) children: Vec<ITableRow>,
 }
 
-intermediate!(ITable, Table, original, registry, {
+intermediate!(
+    ITable,
+    &'orig organic::types::Table<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(ITable, Table, original, registry, {
         };
 
         Ok(ITable { children })
-});
+    }
+);

src/intermediate/table_cell.rs

@@ -8,7 +8,12 @@ pub(crate) struct ITableCell {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(ITableCell, TableCell, original, registry, {
+intermediate!(
+    ITableCell,
+    &'orig organic::types::TableCell<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(ITableCell, TableCell, original, registry, {
         };
 
         Ok(ITableCell { children })
-});
+    }
+);

src/intermediate/table_row.rs

@@ -1,5 +1,4 @@
 use super::macros::intermediate;
-
 use super::table_cell::ITableCell;
 use crate::error::CustomError;
 
@@ -8,7 +7,12 @@ pub(crate) struct ITableRow {
     pub(crate) children: Vec<ITableCell>,
 }
 
-intermediate!(ITableRow, TableRow, original, registry, {
+intermediate!(
+    ITableRow,
+    &'orig organic::types::TableRow<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +22,5 @@ intermediate!(ITableRow, TableRow, original, registry, {
         };
 
         Ok(ITableRow { children })
-});
+    }
+);

src/intermediate/target.rs

@@ -8,11 +8,17 @@ pub(crate) struct ITarget {
     value: String,
 }
 
-intermediate!(ITarget, Target, original, registry, {
+intermediate!(
+    ITarget,
+    &'orig organic::types::Target<'parse>,
+    original,
+    registry,
+    {
         let mut registry = registry.lock().unwrap();
         let id = registry.get_target(original.value);
         Ok(ITarget {
             id: id.clone(),
             value: original.value.to_owned(),
         })
-});
+    }
+);

src/intermediate/underline.rs

@@ -8,7 +8,12 @@ pub(crate) struct IUnderline {
     pub(crate) children: Vec<IObject>,
 }
 
-intermediate!(IUnderline, Underline, original, registry, {
+intermediate!(
+    IUnderline,
+    &'orig organic::types::Underline<'parse>,
+    original,
+    registry,
+    {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
@@ -18,4 +23,5 @@ intermediate!(IUnderline, Underline, original, registry, {
         };
 
         Ok(IUnderline { children })
-});
+    }
+);

src/intermediate/verbatim.rs

@@ -7,9 +7,15 @@ pub(crate) struct IVerbatim {
     pub(crate) contents: String,
 }
 
-intermediate!(IVerbatim, Verbatim, original, _registry, {
+intermediate!(
+    IVerbatim,
+    &'orig organic::types::Verbatim<'parse>,
+    original,
+    _registry,
+    {
         Ok(IVerbatim {
             // TODO: Should this coalesce whitespace like PlainText?
             contents: original.contents.to_owned(),
         })
-});
+    }
+);