Switch over to using the render context in render calls.

src/command/build/render.rs

@@ -5,9 +5,12 @@ use include_dir::include_dir;
 use include_dir::Dir;
 
 use crate::config::Config;
+use crate::context::RenderBlogPostPage;
+use crate::context::RenderBlogPostPageInput;
 use crate::context::RenderBlogStream;
+use crate::context::RenderBlogStreamInput;
+use crate::context::RenderContext;
 use crate::error::CustomError;
-use crate::intermediate::convert_blog_post_page_to_render_context;
 use crate::intermediate::get_web_path;
 use crate::intermediate::BlogPost;
 use crate::render::DusterRenderer;
@@ -78,13 +81,13 @@ impl SiteRenderer {
                     .join(&blog_post.id)
                     .join(blog_post_page.get_output_path());
 
-                let render_context = convert_blog_post_page_to_render_context(
+                let convert_input = RenderBlogPostPageInput::new(blog_post, blog_post_page);
+                let render_context = RenderContext::new(
                     config,
-                    &self.output_directory,
+                    self.output_directory.as_path(),
-                    &output_path,
+                    output_path.as_path(),
-                    blog_post,
-                    blog_post_page,
                 )?;
+                let render_context = RenderBlogPostPage::new(render_context, &convert_input)?;
                 let rendered_output = renderer_integration.render(render_context)?;
                 let parent_directory = output_path
                     .parent()
@@ -158,14 +161,13 @@ impl SiteRenderer {
                 )?)
             };
 
-            let blog_stream = RenderBlogStream::new(
+            let convert_input = RenderBlogStreamInput::new(chunk, older_link, newer_link);
+            let render_context = RenderContext::new(
                 config,
                 self.output_directory.as_path(),
                 output_file.as_path(),
-                chunk,
-                older_link,
-                newer_link,
             )?;
+            let blog_stream = RenderBlogStream::new(render_context, &convert_input)?;
 
             // Pass each RenderBlogStream to dust as the context to render index.html and any additional stream pages.
             let rendered_output = renderer_integration.render(blog_stream)?;

src/context/angle_link.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IAngleLink;
 

src/context/ast_node.rs

@@ -1,8 +1,5 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IAstNode;
 
@@ -45,6 +42,7 @@ use super::quote_block::RenderQuoteBlock;
 use super::radio_link::RenderRadioLink;
 use super::radio_target::RenderRadioTarget;
 use super::regular_link::RenderRegularLink;
+use super::render_context::RenderContext;
 use super::special_block::RenderSpecialBlock;
 use super::src_block::RenderSrcBlock;
 use super::statistics_cookie::RenderStatisticsCookie;
@@ -121,285 +119,207 @@ pub(crate) enum RenderAstNode {
 pub(crate) trait IntoRenderAstNode {
     fn into_render_ast_node(
         &self,
-        config: &Config,
+        render_context: RenderContext<'_>,
-        output_directory: &Path,
-        output_file: &Path,
     ) -> Result<RenderAstNode, CustomError>;
 }
 
 impl IntoRenderAstNode for IAstNode {
     fn into_render_ast_node(
         &self,
-        config: &Config,
+        render_context: RenderContext<'_>,
-        output_directory: &Path,
-        output_file: &Path,
     ) -> Result<RenderAstNode, CustomError> {
         match self {
             IAstNode::Heading(inner) => Ok(RenderAstNode::Heading(RenderHeading::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Section(inner) => Ok(RenderAstNode::Section(RenderSection::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Paragraph(inner) => Ok(RenderAstNode::Paragraph(RenderParagraph::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::PlainList(inner) => Ok(RenderAstNode::PlainList(RenderPlainList::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::CenterBlock(inner) => Ok(RenderAstNode::CenterBlock(RenderCenterBlock::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::QuoteBlock(inner) => Ok(RenderAstNode::QuoteBlock(RenderQuoteBlock::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::SpecialBlock(inner) => Ok(RenderAstNode::SpecialBlock(
-                RenderSpecialBlock::new(config, output_directory, output_file, inner)?,
+                RenderSpecialBlock::new(render_context, inner)?,
             )),
             IAstNode::DynamicBlock(inner) => Ok(RenderAstNode::DynamicBlock(
-                RenderDynamicBlock::new(config, output_directory, output_file, inner)?,
+                RenderDynamicBlock::new(render_context, inner)?,
             )),
             IAstNode::FootnoteDefinition(inner) => Ok(RenderAstNode::FootnoteDefinition(
-                RenderFootnoteDefinition::new(config, output_directory, output_file, inner)?,
+                RenderFootnoteDefinition::new(render_context, inner)?,
             )),
             IAstNode::Comment(inner) => Ok(RenderAstNode::Comment(RenderComment::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Drawer(inner) => Ok(RenderAstNode::Drawer(RenderDrawer::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::PropertyDrawer(inner) => Ok(RenderAstNode::PropertyDrawer(
-                RenderPropertyDrawer::new(config, output_directory, output_file, inner)?,
+                RenderPropertyDrawer::new(render_context, inner)?,
             )),
             IAstNode::Table(inner) => Ok(RenderAstNode::Table(RenderTable::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::VerseBlock(inner) => Ok(RenderAstNode::VerseBlock(RenderVerseBlock::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::CommentBlock(inner) => Ok(RenderAstNode::CommentBlock(
-                RenderCommentBlock::new(config, output_directory, output_file, inner)?,
+                RenderCommentBlock::new(render_context, inner)?,
             )),
             IAstNode::ExampleBlock(inner) => Ok(RenderAstNode::ExampleBlock(
-                RenderExampleBlock::new(config, output_directory, output_file, inner)?,
+                RenderExampleBlock::new(render_context, inner)?,
             )),
             IAstNode::ExportBlock(inner) => Ok(RenderAstNode::ExportBlock(RenderExportBlock::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::SrcBlock(inner) => Ok(RenderAstNode::SrcBlock(RenderSrcBlock::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Clock(inner) => Ok(RenderAstNode::Clock(RenderClock::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::DiarySexp(inner) => Ok(RenderAstNode::DiarySexp(RenderDiarySexp::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Planning(inner) => Ok(RenderAstNode::Planning(RenderPlanning::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::FixedWidthArea(inner) => Ok(RenderAstNode::FixedWidthArea(
-                RenderFixedWidthArea::new(config, output_directory, output_file, inner)?,
+                RenderFixedWidthArea::new(render_context, inner)?,
             )),
             IAstNode::HorizontalRule(inner) => Ok(RenderAstNode::HorizontalRule(
-                RenderHorizontalRule::new(config, output_directory, output_file, inner)?,
+                RenderHorizontalRule::new(render_context, inner)?,
             )),
             IAstNode::Keyword(inner) => Ok(RenderAstNode::Keyword(RenderKeyword::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::BabelCall(inner) => Ok(RenderAstNode::BabelCall(RenderBabelCall::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::LatexEnvironment(inner) => Ok(RenderAstNode::LatexEnvironment(
-                RenderLatexEnvironment::new(config, output_directory, output_file, inner)?,
+                RenderLatexEnvironment::new(render_context, inner)?,
             )),
-            IAstNode::Bold(inner) => Ok(RenderAstNode::Bold(RenderBold::new(
+            IAstNode::Bold(inner) => {
-                config,
+                Ok(RenderAstNode::Bold(RenderBold::new(render_context, inner)?))
-                output_directory,
+            }
-                output_file,
-                inner,
-            )?)),
             IAstNode::Italic(inner) => Ok(RenderAstNode::Italic(RenderItalic::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Underline(inner) => Ok(RenderAstNode::Underline(RenderUnderline::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::StrikeThrough(inner) => Ok(RenderAstNode::StrikeThrough(
-                RenderStrikeThrough::new(config, output_directory, output_file, inner)?,
+                RenderStrikeThrough::new(render_context, inner)?,
             )),
-            IAstNode::Code(inner) => Ok(RenderAstNode::Code(RenderCode::new(
+            IAstNode::Code(inner) => {
-                config,
+                Ok(RenderAstNode::Code(RenderCode::new(render_context, inner)?))
-                output_directory,
+            }
-                output_file,
-                inner,
-            )?)),
             IAstNode::Verbatim(inner) => Ok(RenderAstNode::Verbatim(RenderVerbatim::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::PlainText(inner) => Ok(RenderAstNode::PlainText(RenderPlainText::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::RegularLink(inner) => Ok(RenderAstNode::RegularLink(RenderRegularLink::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::RadioLink(inner) => Ok(RenderAstNode::RadioLink(RenderRadioLink::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::RadioTarget(inner) => Ok(RenderAstNode::RadioTarget(RenderRadioTarget::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::PlainLink(inner) => Ok(RenderAstNode::PlainLink(RenderPlainLink::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::AngleLink(inner) => Ok(RenderAstNode::AngleLink(RenderAngleLink::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::OrgMacro(inner) => Ok(RenderAstNode::OrgMacro(RenderOrgMacro::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Entity(inner) => Ok(RenderAstNode::Entity(RenderEntity::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::LatexFragment(inner) => Ok(RenderAstNode::LatexFragment(
-                RenderLatexFragment::new(config, output_directory, output_file, inner)?,
+                RenderLatexFragment::new(render_context, inner)?,
             )),
             IAstNode::ExportSnippet(inner) => Ok(RenderAstNode::ExportSnippet(
-                RenderExportSnippet::new(config, output_directory, output_file, inner)?,
+                RenderExportSnippet::new(render_context, inner)?,
             )),
             IAstNode::FootnoteReference(inner) => Ok(RenderAstNode::FootnoteReference(
-                RenderFootnoteReference::new(config, output_directory, output_file, inner)?,
+                RenderFootnoteReference::new(render_context, inner)?,
             )),
             IAstNode::Citation(inner) => Ok(RenderAstNode::Citation(RenderCitation::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::CitationReference(inner) => Ok(RenderAstNode::CitationReference(
-                RenderCitationReference::new(config, output_directory, output_file, inner)?,
+                RenderCitationReference::new(render_context, inner)?,
             )),
             IAstNode::InlineBabelCall(inner) => Ok(RenderAstNode::InlineBabelCall(
-                RenderInlineBabelCall::new(config, output_directory, output_file, inner)?,
+                RenderInlineBabelCall::new(render_context, inner)?,
             )),
             IAstNode::InlineSourceBlock(inner) => Ok(RenderAstNode::InlineSourceBlock(
-                RenderInlineSourceBlock::new(config, output_directory, output_file, inner)?,
+                RenderInlineSourceBlock::new(render_context, inner)?,
             )),
             IAstNode::LineBreak(inner) => Ok(RenderAstNode::LineBreak(RenderLineBreak::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Target(inner) => Ok(RenderAstNode::Target(RenderTarget::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::StatisticsCookie(inner) => Ok(RenderAstNode::StatisticsCookie(
-                RenderStatisticsCookie::new(config, output_directory, output_file, inner)?,
+                RenderStatisticsCookie::new(render_context, inner)?,
             )),
             IAstNode::Subscript(inner) => Ok(RenderAstNode::Subscript(RenderSubscript::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Superscript(inner) => Ok(RenderAstNode::Superscript(RenderSuperscript::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
             IAstNode::Timestamp(inner) => Ok(RenderAstNode::Timestamp(RenderTimestamp::new(
-                config,
+                render_context,
-                output_directory,
-                output_file,
                 inner,
             )?)),
         }

src/context/babel_call.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IBabelCall;
 

src/context/blog_post_page.rs

@@ -1,10 +1,29 @@
 use serde::Serialize;
 
+use super::render_context::RenderContext;
+use crate::error::CustomError;
+use crate::intermediate::get_web_path;
+use crate::intermediate::BlogPost;
+use crate::intermediate::BlogPostPage;
+
 use super::footnote_definition::RenderRealFootnoteDefinition;
+use super::macros::render;
 use super::GlobalSettings;
 use super::PageHeader;
 use super::RenderDocumentElement;
 
+#[derive(Debug)]
+pub(crate) struct RenderBlogPostPageInput<'a> {
+    post: &'a BlogPost,
+    page: &'a BlogPostPage,
+}
+
+impl<'a> RenderBlogPostPageInput<'a> {
+    pub(crate) fn new(post: &'a BlogPost, page: &'a BlogPostPage) -> RenderBlogPostPageInput<'a> {
+        RenderBlogPostPageInput { post, page }
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(tag = "type")]
 #[serde(rename = "blog_post_page")]
@@ -23,23 +42,82 @@ pub(crate) struct RenderBlogPostPage {
     footnotes: Vec<RenderRealFootnoteDefinition>,
 }
 
-impl RenderBlogPostPage {
+render!(
-    // TODO: Maybe these settings should be moved into a common struct so this can have the same type signature as the others.
+    RenderBlogPostPage,
-    pub(crate) fn new(
+    RenderBlogPostPageInput,
-        global_settings: GlobalSettings,
+    original,
-        page_header: Option<PageHeader>,
+    render_context,
-        title: Option<String>,
+    {
-        self_link: Option<String>,
+        let css_files = vec![
-        children: Vec<RenderDocumentElement>,
+            // get_web_path(
-        footnotes: Vec<RenderRealFootnoteDefinition>,
+            //     config,
-    ) -> RenderBlogPostPage {
+            //     output_directory,
-        RenderBlogPostPage {
+            //     output_file,
+            //     "stylesheet/reset.css",
+            // )?,
+            get_web_path(
+                render_context.config,
+                render_context.output_directory,
+                render_context.output_file,
+                "stylesheet/main.css",
+            )?,
+        ];
+        let js_files = vec![get_web_path(
+            render_context.config,
+            render_context.output_directory,
+            render_context.output_file,
+            "blog_post.js",
+        )?];
+        let global_settings = GlobalSettings::new(original.page.title.clone(), css_files, js_files);
+        let page_header = PageHeader::new(
+            render_context.config.get_site_title().map(str::to_string),
+            Some(get_web_path(
+                render_context.config,
+                render_context.output_directory,
+                render_context.output_file,
+                "",
+            )?),
+        );
+        let link_to_blog_post = get_web_path(
+            render_context.config,
+            render_context.output_directory,
+            render_context.output_file,
+            render_context
+                .output_file
+                .strip_prefix(render_context.output_directory)?,
+        )?;
+
+        let children = {
+            let mut children = Vec::new();
+
+            for child in original.page.children.iter() {
+                children.push(RenderDocumentElement::new(render_context.clone(), child)?);
+            }
+
+            children
+        };
+
+        let footnotes = {
+            let mut ret = Vec::new();
+
+            for footnote in original.page.footnotes.iter() {
+                ret.push(RenderRealFootnoteDefinition::new(
+                    render_context.clone(),
+                    footnote,
+                )?);
+            }
+
+            ret
+        };
+
+        let ret = RenderBlogPostPage {
             global_settings,
-            page_header,
+            page_header: Some(page_header),
-            title,
+            title: original.page.title.clone(),
-            self_link,
+            self_link: Some(link_to_blog_post),
             children,
             footnotes,
+        };
+        Ok(ret)
     }
-    }
+);
-}

src/context/blog_stream.rs

@@ -1,8 +1,7 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::macros::render;
+use super::render_context::RenderContext;
 use crate::context::RenderDocumentElement;
 use crate::context::RenderRealFootnoteDefinition;
 use crate::error::CustomError;
@@ -12,6 +11,27 @@ use crate::intermediate::BlogPost;
 use super::GlobalSettings;
 use super::PageHeader;
 
+#[derive(Debug)]
+pub(crate) struct RenderBlogStreamInput<'a, 'b> {
+    original: &'a [&'b BlogPost],
+    older_link: Option<String>,
+    newer_link: Option<String>,
+}
+
+impl<'a, 'b> RenderBlogStreamInput<'a, 'b> {
+    pub(crate) fn new(
+        original: &'a [&'b BlogPost],
+        older_link: Option<String>,
+        newer_link: Option<String>,
+    ) -> RenderBlogStreamInput<'a, 'b> {
+        RenderBlogStreamInput {
+            original,
+            older_link,
+            newer_link,
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(tag = "type")]
 #[serde(rename = "blog_stream")]
@@ -22,15 +42,12 @@ pub(crate) struct RenderBlogStream {
     stream_pagination: Option<RenderBlogStreamPagination>,
 }
 
-impl RenderBlogStream {
+render!(
-    pub(crate) fn new(
+    RenderBlogStream,
-        config: &Config,
+    RenderBlogStreamInput,
-        output_directory: &Path,
+    original,
-        output_file: &Path,
+    render_context,
-        original: &[&BlogPost],
+    {
-        older_link: Option<String>,
-        newer_link: Option<String>,
-    ) -> Result<RenderBlogStream, CustomError> {
         let css_files = vec![
             // get_web_path(
             //     config,
@@ -38,33 +55,45 @@ impl RenderBlogStream {
             //     output_file,
             //     "stylesheet/reset.css",
             // )?,
-            get_web_path(config, output_directory, output_file, "stylesheet/main.css")?,
+            get_web_path(
+                render_context.config,
+                render_context.output_directory,
+                render_context.output_file,
+                "stylesheet/main.css",
+            )?,
         ];
         let js_files = vec![get_web_path(
-            config,
+            render_context.config,
-            output_directory,
+            render_context.output_directory,
-            output_file,
+            render_context.output_file,
             "blog_post.js",
         )?];
         let global_settings = GlobalSettings::new(
-            config.get_site_title().map(str::to_string),
+            render_context.config.get_site_title().map(str::to_string),
             css_files,
             js_files,
         );
         let page_header = PageHeader::new(
-            config.get_site_title().map(str::to_string),
+            render_context.config.get_site_title().map(str::to_string),
-            Some(get_web_path(config, output_directory, output_file, "")?),
+            Some(get_web_path(
+                render_context.config,
+                render_context.output_directory,
+                render_context.output_file,
+                "",
+            )?),
         );
 
         let children = original
+            .original
             .into_iter()
-            .map(|blog_post| {
+            .map(|blog_post| RenderBlogStreamEntry::new(render_context.clone(), blog_post))
-                RenderBlogStreamEntry::new(config, output_directory, output_file, blog_post)
-            })
             .collect::<Result<Vec<_>, _>>()?;
 
-        let stream_pagination = if older_link.is_some() || newer_link.is_some() {
+        let stream_pagination = if original.older_link.is_some() || original.newer_link.is_some() {
-            Some(RenderBlogStreamPagination::new(older_link, newer_link)?)
+            Some(RenderBlogStreamPagination::new(
+                original.older_link.clone(),
+                original.newer_link.clone(),
+            )?)
         } else {
             None
         };
@@ -76,7 +105,7 @@ impl RenderBlogStream {
             stream_pagination,
         })
     }
-}
+);
 
 #[derive(Debug, Serialize)]
 pub(crate) struct RenderBlogStreamEntry {
@@ -90,19 +119,15 @@ pub(crate) struct RenderBlogStreamEntry {
     footnotes: Vec<RenderRealFootnoteDefinition>,
 }
 
-impl RenderBlogStreamEntry {
+render!(RenderBlogStreamEntry, BlogPost, original, render_context, {
-    fn new(
-        config: &Config,
-        output_directory: &Path,
-        output_file: &Path,
-        original: &BlogPost,
-    ) -> Result<RenderBlogStreamEntry, CustomError> {
     // TODO: This link is probably wrong.
     let link_to_blog_post = get_web_path(
-            config,
+        render_context.config,
-            output_directory,
+        render_context.output_directory,
-            output_file,
+        render_context.output_file,
-            output_file.strip_prefix(output_directory)?,
+        render_context
+            .output_file
+            .strip_prefix(render_context.output_directory)?,
     )?;
 
     // TODO: Should I guess an index page instead of erroring out?
@@ -116,7 +141,7 @@ impl RenderBlogStreamEntry {
     let children = index_page
         .children
         .iter()
-            .map(|child| RenderDocumentElement::new(config, output_directory, output_file, child))
+        .map(|child| RenderDocumentElement::new(render_context.clone(), child))
         .collect::<Result<Vec<_>, _>>()?;
 
     Ok(RenderBlogStreamEntry {
@@ -125,8 +150,7 @@ impl RenderBlogStreamEntry {
         children,
         footnotes: Vec::new(),
     })
-    }
+});
-}
 
 #[derive(Debug, Serialize)]
 pub(crate) struct RenderBlogStreamPagination {

src/context/bold.rs

@@ -1,12 +1,10 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IBold;
 
 use super::macros::render;
+use super::render_context::RenderContext;
 use super::RenderObject;
 
 #[derive(Debug, Serialize)]
@@ -16,27 +14,14 @@ pub(crate) struct RenderBold {
     children: Vec<RenderObject>,
 }
 
-render!(
+render!(RenderBold, IBold, original, render_context, {
-    RenderBold,
-    IBold,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderBold { children })
-    }
+});
-);

src/context/center_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ICenterBlock;
 

src/context/citation.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ICitation;
 

src/context/citation_reference.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ICitationReference;
 

src/context/clock.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IClock;
 

src/context/code.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ICode;
 
@@ -15,16 +13,8 @@ pub(crate) struct RenderCode {
     contents: String,
 }
 
-render!(
+render!(RenderCode, ICode, original, _render_context, {
-    RenderCode,
-    ICode,
-    original,
-    _config,
-    _output_directory,
-    _output_file,
-    {
     Ok(RenderCode {
         contents: original.contents.clone(),
     })
-    }
+});
-);

src/context/comment.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IComment;
 

src/context/comment_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ICommentBlock;
 

src/context/diary_sexp.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IDiarySexp;
 

src/context/document_element.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IDocumentElement;
 
@@ -21,16 +19,14 @@ render!(
     RenderDocumentElement,
     IDocumentElement,
     original,
-    config,
+    render_context,
-    output_directory,
-    output_file,
     {
         match original {
             IDocumentElement::Heading(inner) => Ok(RenderDocumentElement::Heading(
-                RenderHeading::new(config, output_directory, output_file, inner)?,
+                RenderHeading::new(render_context.clone(), inner)?,
             )),
             IDocumentElement::Section(inner) => Ok(RenderDocumentElement::Section(
-                RenderSection::new(config, output_directory, output_file, inner)?,
+                RenderSection::new(render_context.clone(), inner)?,
             )),
         }
     }

src/context/drawer.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IDrawer;
 

src/context/dynamic_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IDynamicBlock;
 

src/context/element.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IElement;
 
@@ -61,132 +59,98 @@ pub(crate) enum RenderElement {
     LatexEnvironment(RenderLatexEnvironment),
 }
 
-render!(
+render!(RenderElement, IElement, original, render_context, {
-    RenderElement,
-    IElement,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     match original {
         IElement::Paragraph(inner) => Ok(RenderElement::Paragraph(RenderParagraph::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::PlainList(inner) => Ok(RenderElement::PlainList(RenderPlainList::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::CenterBlock(inner) => Ok(RenderElement::CenterBlock(RenderCenterBlock::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::QuoteBlock(inner) => Ok(RenderElement::QuoteBlock(RenderQuoteBlock::new(
-                config,
+            render_context.clone(),
-                output_directory,
+            inner,
-                output_file,
+        )?)),
+        IElement::SpecialBlock(inner) => Ok(RenderElement::SpecialBlock(RenderSpecialBlock::new(
+            render_context.clone(),
+            inner,
+        )?)),
+        IElement::DynamicBlock(inner) => Ok(RenderElement::DynamicBlock(RenderDynamicBlock::new(
+            render_context.clone(),
             inner,
         )?)),
-            IElement::SpecialBlock(inner) => Ok(RenderElement::SpecialBlock(
-                RenderSpecialBlock::new(config, output_directory, output_file, inner)?,
-            )),
-            IElement::DynamicBlock(inner) => Ok(RenderElement::DynamicBlock(
-                RenderDynamicBlock::new(config, output_directory, output_file, inner)?,
-            )),
         IElement::FootnoteDefinition(inner) => Ok(RenderElement::FootnoteDefinition(
-                RenderFootnoteDefinition::new(config, output_directory, output_file, inner)?,
+            RenderFootnoteDefinition::new(render_context.clone(), inner)?,
         )),
         IElement::Comment(inner) => Ok(RenderElement::Comment(RenderComment::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::Drawer(inner) => Ok(RenderElement::Drawer(RenderDrawer::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::PropertyDrawer(inner) => Ok(RenderElement::PropertyDrawer(
-                RenderPropertyDrawer::new(config, output_directory, output_file, inner)?,
+            RenderPropertyDrawer::new(render_context.clone(), inner)?,
         )),
         IElement::Table(inner) => Ok(RenderElement::Table(RenderTable::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::VerseBlock(inner) => Ok(RenderElement::VerseBlock(RenderVerseBlock::new(
-                config,
+            render_context.clone(),
-                output_directory,
+            inner,
-                output_file,
+        )?)),
+        IElement::CommentBlock(inner) => Ok(RenderElement::CommentBlock(RenderCommentBlock::new(
+            render_context.clone(),
+            inner,
+        )?)),
+        IElement::ExampleBlock(inner) => Ok(RenderElement::ExampleBlock(RenderExampleBlock::new(
+            render_context.clone(),
             inner,
         )?)),
-            IElement::CommentBlock(inner) => Ok(RenderElement::CommentBlock(
-                RenderCommentBlock::new(config, output_directory, output_file, inner)?,
-            )),
-            IElement::ExampleBlock(inner) => Ok(RenderElement::ExampleBlock(
-                RenderExampleBlock::new(config, output_directory, output_file, inner)?,
-            )),
         IElement::ExportBlock(inner) => Ok(RenderElement::ExportBlock(RenderExportBlock::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::SrcBlock(inner) => Ok(RenderElement::SrcBlock(RenderSrcBlock::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::Clock(inner) => Ok(RenderElement::Clock(RenderClock::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::DiarySexp(inner) => Ok(RenderElement::DiarySexp(RenderDiarySexp::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::Planning(inner) => Ok(RenderElement::Planning(RenderPlanning::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::FixedWidthArea(inner) => Ok(RenderElement::FixedWidthArea(
-                RenderFixedWidthArea::new(config, output_directory, output_file, inner)?,
+            RenderFixedWidthArea::new(render_context.clone(), inner)?,
         )),
         IElement::HorizontalRule(inner) => Ok(RenderElement::HorizontalRule(
-                RenderHorizontalRule::new(config, output_directory, output_file, inner)?,
+            RenderHorizontalRule::new(render_context.clone(), inner)?,
         )),
         IElement::Keyword(inner) => Ok(RenderElement::Keyword(RenderKeyword::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::BabelCall(inner) => Ok(RenderElement::BabelCall(RenderBabelCall::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IElement::LatexEnvironment(inner) => Ok(RenderElement::LatexEnvironment(
-                RenderLatexEnvironment::new(config, output_directory, output_file, inner)?,
+            RenderLatexEnvironment::new(render_context.clone(), inner)?,
         )),
     }
-    }
+});
-);

src/context/entity.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IEntity;
 
@@ -15,16 +13,8 @@ pub(crate) struct RenderEntity {
     html: String,
 }
 
-render!(
+render!(RenderEntity, IEntity, original, _render_context, {
-    RenderEntity,
-    IEntity,
-    original,
-    _config,
-    _output_directory,
-    _output_file,
-    {
     Ok(RenderEntity {
         html: original.html.clone(),
     })
-    }
+});
-);

src/context/example_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IExampleBlock;
 

src/context/export_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IExportBlock;
 

src/context/export_snippet.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IExportSnippet;
 

src/context/fixed_width_area.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IFixedWidthArea;
 

src/context/footnote_definition.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IFootnoteDefinition;
 use crate::intermediate::IRealFootnoteDefinition;
@@ -33,14 +31,12 @@ render!(
     RenderRealFootnoteDefinition,
     IRealFootnoteDefinition,
     original,
-    config,
+    render_context,
-    output_directory,
-    output_file,
     {
         let contents = {
             let mut ret = Vec::new();
             for obj in original.contents.iter() {
-                ret.push(obj.into_render_ast_node(config, output_directory, output_file)?);
+                ret.push(obj.into_render_ast_node(render_context.clone())?);
             }
             ret
         };

src/context/footnote_reference.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IFootnoteReference;
 
@@ -21,9 +19,7 @@ render!(
     RenderFootnoteReference,
     IFootnoteReference,
     original,
-    _config,
+    _render_context,
-    _output_directory,
-    _output_file,
     {
         Ok(RenderFootnoteReference {
             reference_id: original.get_reference_id(),

src/context/heading.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IHeading;
 
@@ -19,23 +17,11 @@ pub(crate) struct RenderHeading {
     children: Vec<RenderDocumentElement>,
 }
 
-render!(
+render!(RenderHeading, IHeading, original, render_context, {
-    RenderHeading,
-    IHeading,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let title = {
         let mut ret = Vec::new();
         for obj in original.title.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
@@ -43,12 +29,7 @@ render!(
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderDocumentElement::new(
+            ret.push(RenderDocumentElement::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
@@ -58,5 +39,4 @@ render!(
         title,
         children,
     })
-    }
+});
-);

src/context/horizontal_rule.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IHorizontalRule;
 

src/context/inline_babel_call.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IInlineBabelCall;
 

src/context/inline_source_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IInlineSourceBlock;
 
@@ -19,9 +17,7 @@ render!(
     RenderInlineSourceBlock,
     IInlineSourceBlock,
     original,
-    _config,
+    _render_context,
-    _output_directory,
-    _output_file,
     {
         Ok(RenderInlineSourceBlock {
             value: original.value.clone(),

src/context/italic.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IItalic;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderItalic {
     children: Vec<RenderObject>,
 }
 
-render!(
+render!(RenderItalic, IItalic, original, render_context, {
-    RenderItalic,
-    IItalic,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderItalic { children })
-    }
+});
-);

src/context/keyword.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IKeyword;
 

src/context/latex_environment.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ILatexEnvironment;
 

src/context/latex_fragment.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ILatexFragment;
 
@@ -19,9 +17,7 @@ render!(
     RenderLatexFragment,
     ILatexFragment,
     original,
-    _config,
+    _render_context,
-    _output_directory,
-    _output_file,
     {
         Ok(RenderLatexFragment {
             value: original.value.clone(),

src/context/line_break.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ILineBreak;
 

src/context/macros.rs

@@ -2,18 +2,14 @@
 ///
 /// This exists to make changing the type signature easier.
 macro_rules! render {
-    ($rstruct:ident, $istruct:ident, $original:ident, $config:ident, $output_directory:ident, $output_file:ident, $fnbody:tt) => {
+    ($rstruct:ident, $istruct:ident, $original:ident, $render_context:ident, $fnbody:tt) => {
         impl $rstruct {
             pub(crate) fn new(
-                config: &Config,
+                render_context: RenderContext<'_>,
-                output_directory: &Path,
-                output_file: &Path,
                 original: &$istruct,
             ) -> Result<$rstruct, CustomError> {
                 let $original = original;
-                let $config = config;
+                let $render_context = render_context;
-                let $output_directory = output_directory;
-                let $output_file = output_file;
                 $fnbody
             }
         }
@@ -29,9 +25,7 @@ macro_rules! rnoop {
     ($rstruct:ident, $istruct:ident) => {
         impl $rstruct {
             pub(crate) fn new(
-                _config: &Config,
+                _render_context: RenderContext<'_>,
-                _output_directory: &Path,
-                _output_file: &Path,
                 _original: &$istruct,
             ) -> Result<$rstruct, CustomError> {
                 Ok($rstruct {})

src/context/mod.rs

@@ -66,7 +66,9 @@ mod verbatim;
 mod verse_block;
 
 pub(crate) use blog_post_page::RenderBlogPostPage;
+pub(crate) use blog_post_page::RenderBlogPostPageInput;
 pub(crate) use blog_stream::RenderBlogStream;
+pub(crate) use blog_stream::RenderBlogStreamInput;
 pub(crate) use document_element::RenderDocumentElement;
 pub(crate) use element::RenderElement;
 pub(crate) use footnote_definition::RenderRealFootnoteDefinition;
@@ -74,4 +76,5 @@ pub(crate) use global_settings::GlobalSettings;
 pub(crate) use heading::RenderHeading;
 pub(crate) use object::RenderObject;
 pub(crate) use page_header::PageHeader;
+pub(crate) use render_context::RenderContext;
 pub(crate) use section::RenderSection;

src/context/object.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IObject;
 
@@ -67,153 +65,110 @@ pub(crate) enum RenderObject {
     Timestamp(RenderTimestamp),
 }
 
-render!(
+render!(RenderObject, IObject, original, render_context, {
-    RenderObject,
-    IObject,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     match original {
         IObject::Bold(inner) => Ok(RenderObject::Bold(RenderBold::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Italic(inner) => Ok(RenderObject::Italic(RenderItalic::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Underline(inner) => Ok(RenderObject::Underline(RenderUnderline::new(
-                config,
+            render_context.clone(),
-                output_directory,
+            inner,
-                output_file,
+        )?)),
+        IObject::StrikeThrough(inner) => Ok(RenderObject::StrikeThrough(RenderStrikeThrough::new(
+            render_context.clone(),
             inner,
         )?)),
-            IObject::StrikeThrough(inner) => Ok(RenderObject::StrikeThrough(
-                RenderStrikeThrough::new(config, output_directory, output_file, inner)?,
-            )),
         IObject::Code(inner) => Ok(RenderObject::Code(RenderCode::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Verbatim(inner) => Ok(RenderObject::Verbatim(RenderVerbatim::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::PlainText(inner) => Ok(RenderObject::PlainText(RenderPlainText::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::RegularLink(inner) => Ok(RenderObject::RegularLink(RenderRegularLink::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::RadioLink(inner) => Ok(RenderObject::RadioLink(RenderRadioLink::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::RadioTarget(inner) => Ok(RenderObject::RadioTarget(RenderRadioTarget::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::PlainLink(inner) => Ok(RenderObject::PlainLink(RenderPlainLink::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::AngleLink(inner) => Ok(RenderObject::AngleLink(RenderAngleLink::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::OrgMacro(inner) => Ok(RenderObject::OrgMacro(RenderOrgMacro::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Entity(inner) => Ok(RenderObject::Entity(RenderEntity::new(
-                config,
+            render_context.clone(),
-                output_directory,
+            inner,
-                output_file,
+        )?)),
+        IObject::LatexFragment(inner) => Ok(RenderObject::LatexFragment(RenderLatexFragment::new(
+            render_context.clone(),
+            inner,
+        )?)),
+        IObject::ExportSnippet(inner) => Ok(RenderObject::ExportSnippet(RenderExportSnippet::new(
+            render_context.clone(),
             inner,
         )?)),
-            IObject::LatexFragment(inner) => Ok(RenderObject::LatexFragment(
-                RenderLatexFragment::new(config, output_directory, output_file, inner)?,
-            )),
-            IObject::ExportSnippet(inner) => Ok(RenderObject::ExportSnippet(
-                RenderExportSnippet::new(config, output_directory, output_file, inner)?,
-            )),
         IObject::FootnoteReference(inner) => Ok(RenderObject::FootnoteReference(
-                RenderFootnoteReference::new(config, output_directory, output_file, inner)?,
+            RenderFootnoteReference::new(render_context.clone(), inner)?,
         )),
         IObject::Citation(inner) => Ok(RenderObject::Citation(RenderCitation::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::CitationReference(inner) => Ok(RenderObject::CitationReference(
-                RenderCitationReference::new(config, output_directory, output_file, inner)?,
+            RenderCitationReference::new(render_context.clone(), inner)?,
         )),
         IObject::InlineBabelCall(inner) => Ok(RenderObject::InlineBabelCall(
-                RenderInlineBabelCall::new(config, output_directory, output_file, inner)?,
+            RenderInlineBabelCall::new(render_context.clone(), inner)?,
         )),
         IObject::InlineSourceBlock(inner) => Ok(RenderObject::InlineSourceBlock(
-                RenderInlineSourceBlock::new(config, output_directory, output_file, inner)?,
+            RenderInlineSourceBlock::new(render_context.clone(), inner)?,
         )),
         IObject::LineBreak(inner) => Ok(RenderObject::LineBreak(RenderLineBreak::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Target(inner) => Ok(RenderObject::Target(RenderTarget::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::StatisticsCookie(inner) => Ok(RenderObject::StatisticsCookie(
-                RenderStatisticsCookie::new(config, output_directory, output_file, inner)?,
+            RenderStatisticsCookie::new(render_context.clone(), inner)?,
         )),
         IObject::Subscript(inner) => Ok(RenderObject::Subscript(RenderSubscript::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Superscript(inner) => Ok(RenderObject::Superscript(RenderSuperscript::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
         IObject::Timestamp(inner) => Ok(RenderObject::Timestamp(RenderTimestamp::new(
-                config,
+            render_context.clone(),
-                output_directory,
-                output_file,
             inner,
         )?)),
     }
-    }
+});
-);

src/context/org_macro.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IOrgMacro;
 

src/context/paragraph.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IParagraph;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderParagraph {
     children: Vec<RenderObject>,
 }
 
-render!(
+render!(RenderParagraph, IParagraph, original, render_context, {
-    RenderParagraph,
-    IParagraph,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderParagraph { children })
-    }
+});
-);

src/context/plain_link.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IPlainLink;
 

src/context/plain_list.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IPlainList;
 
@@ -17,14 +15,7 @@ pub(crate) struct RenderPlainList {
     children: Vec<RenderPlainListItem>,
 }
 
-render!(
+render!(RenderPlainList, IPlainList, original, render_context, {
-    RenderPlainList,
-    IPlainList,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let list_type = match original.list_type {
         organic::types::PlainListType::Unordered => "unordered".to_owned(),
         organic::types::PlainListType::Ordered => "ordered".to_owned(),
@@ -33,12 +24,7 @@ render!(
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderPlainListItem::new(
+            ret.push(RenderPlainListItem::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
@@ -47,5 +33,4 @@ render!(
         list_type,
         children,
     })
-    }
+});
-);

src/context/plain_list_item.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IPlainListItem;
 
@@ -22,19 +20,12 @@ render!(
     RenderPlainListItem,
     IPlainListItem,
     original,
-    config,
+    render_context,
-    output_directory,
-    output_file,
     {
         let tag = {
             let mut ret = Vec::new();
             for obj in original.tag.iter() {
-                ret.push(RenderObject::new(
+                ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
             }
             ret
         };
@@ -42,12 +33,7 @@ render!(
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
-                ret.push(RenderElement::new(
+                ret.push(RenderElement::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
             }
             ret
         };

src/context/plain_text.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IPlainText;
 
@@ -15,16 +13,8 @@ pub(crate) struct RenderPlainText {
     source: String,
 }
 
-render!(
+render!(RenderPlainText, IPlainText, original, _render_context, {
-    RenderPlainText,
-    IPlainText,
-    original,
-    _config,
-    _output_directory,
-    _output_file,
-    {
     Ok(RenderPlainText {
         source: original.source.clone(),
     })
-    }
+});
-);

src/context/planning.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IPlanning;
 

src/context/property_drawer.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IPropertyDrawer;
 

src/context/quote_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IQuoteBlock;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderQuoteBlock {
     children: Vec<RenderElement>,
 }
 
-render!(
+render!(RenderQuoteBlock, IQuoteBlock, original, render_context, {
-    RenderQuoteBlock,
-    IQuoteBlock,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderElement::new(
+            ret.push(RenderElement::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderQuoteBlock { children })
-    }
+});
-);

src/context/radio_link.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IRadioLink;
 

src/context/radio_target.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IRadioTarget;
 

src/context/regular_link.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IRegularLink;
 
@@ -17,23 +15,11 @@ pub(crate) struct RenderRegularLink {
     children: Vec<RenderObject>,
 }
 
-render!(
+render!(RenderRegularLink, IRegularLink, original, render_context, {
-    RenderRegularLink,
-    IRegularLink,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
@@ -42,5 +28,4 @@ render!(
         raw_link: original.raw_link.clone(),
         children,
     })
-    }
+});
-);

src/context/section.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ISection;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderSection {
     children: Vec<RenderElement>,
 }
 
-render!(
+render!(RenderSection, ISection, original, render_context, {
-    RenderSection,
-    ISection,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderElement::new(
+            ret.push(RenderElement::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderSection { children })
-    }
+});
-);

src/context/special_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ISpecialBlock;
 

src/context/src_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ISrcBlock;
 
@@ -15,16 +13,8 @@ pub(crate) struct RenderSrcBlock {
     lines: Vec<String>,
 }
 
-render!(
+render!(RenderSrcBlock, ISrcBlock, original, _render_context, {
-    RenderSrcBlock,
-    ISrcBlock,
-    original,
-    _config,
-    _output_directory,
-    _output_file,
-    {
     Ok(RenderSrcBlock {
         lines: original.lines.clone(),
     })
-    }
+});
-);

src/context/statistics_cookie.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IStatisticsCookie;
 

src/context/strike_through.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IStrikeThrough;
 
@@ -20,19 +18,12 @@ render!(
     RenderStrikeThrough,
     IStrikeThrough,
     original,
-    config,
+    render_context,
-    output_directory,
-    output_file,
     {
         let children = {
             let mut ret = Vec::new();
             for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+                ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
             }
             ret
         };

src/context/subscript.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ISubscript;
 

src/context/superscript.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ISuperscript;
 

src/context/table.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ITable;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderTable {
     children: Vec<RenderTableRow>,
 }
 
-render!(
+render!(RenderTable, ITable, original, render_context, {
-    RenderTable,
-    ITable,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderTableRow::new(
+            ret.push(RenderTableRow::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderTable { children })
-    }
+});
-);

src/context/table_cell.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ITableCell;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderTableCell {
     children: Vec<RenderObject>,
 }
 
-render!(
+render!(RenderTableCell, ITableCell, original, render_context, {
-    RenderTableCell,
-    ITableCell,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderTableCell { children })
-    }
+});
-);

src/context/table_row.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ITableRow;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderTableRow {
     children: Vec<RenderTableCell>,
 }
 
-render!(
+render!(RenderTableRow, ITableRow, original, render_context, {
-    RenderTableRow,
-    ITableRow,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderTableCell::new(
+            ret.push(RenderTableCell::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderTableRow { children })
-    }
+});
-);

src/context/target.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ITarget;
 
@@ -15,16 +13,8 @@ pub(crate) struct RenderTarget {
     id: String,
 }
 
-render!(
+render!(RenderTarget, ITarget, original, _render_context, {
-    RenderTarget,
-    ITarget,
-    original,
-    _config,
-    _output_directory,
-    _output_file,
-    {
     Ok(RenderTarget {
         id: original.id.clone(),
     })
-    }
+});
-);

src/context/timestamp.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::ITimestamp;
 

src/context/underline.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IUnderline;
 
@@ -16,27 +14,14 @@ pub(crate) struct RenderUnderline {
     children: Vec<RenderObject>,
 }
 
-render!(
+render!(RenderUnderline, IUnderline, original, render_context, {
-    RenderUnderline,
-    IUnderline,
-    original,
-    config,
-    output_directory,
-    output_file,
-    {
     let children = {
         let mut ret = Vec::new();
         for obj in original.children.iter() {
-                ret.push(RenderObject::new(
+            ret.push(RenderObject::new(render_context.clone(), obj)?);
-                    config,
-                    output_directory,
-                    output_file,
-                    obj,
-                )?);
         }
         ret
     };
 
     Ok(RenderUnderline { children })
-    }
+});
-);

src/context/verbatim.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IVerbatim;
 
@@ -15,16 +13,8 @@ pub(crate) struct RenderVerbatim {
     contents: String,
 }
 
-render!(
+render!(RenderVerbatim, IVerbatim, original, _render_context, {
-    RenderVerbatim,
-    IVerbatim,
-    original,
-    _config,
-    _output_directory,
-    _output_file,
-    {
     Ok(RenderVerbatim {
         contents: original.contents.clone(),
     })
-    }
+});
-);

src/context/verse_block.rs

@@ -1,8 +1,6 @@
-use std::path::Path;
-
 use serde::Serialize;
 
-use crate::config::Config;
+use super::render_context::RenderContext;
 use crate::error::CustomError;
 use crate::intermediate::IVerseBlock;
 

src/intermediate/convert.rs

@@ -3,93 +3,8 @@ use std::path::Path;
 use std::path::PathBuf;
 
 use crate::config::Config;
-use crate::context::GlobalSettings;
-use crate::context::PageHeader;
-use crate::context::RenderBlogPostPage;
-use crate::context::RenderDocumentElement;
-use crate::context::RenderRealFootnoteDefinition;
 use crate::error::CustomError;
 
-use super::BlogPost;
-use super::BlogPostPage;
-
-pub(crate) fn convert_blog_post_page_to_render_context<D: AsRef<Path>, F: AsRef<Path>>(
-    config: &Config,
-    output_directory: D,
-    output_file: F,
-    _post: &BlogPost,
-    page: &BlogPostPage,
-) -> Result<RenderBlogPostPage, CustomError> {
-    let output_directory = output_directory.as_ref();
-    let output_file = output_file.as_ref();
-    let css_files = vec![
-        // get_web_path(
-        //     config,
-        //     output_directory,
-        //     output_file,
-        //     "stylesheet/reset.css",
-        // )?,
-        get_web_path(config, output_directory, output_file, "stylesheet/main.css")?,
-    ];
-    let js_files = vec![get_web_path(
-        config,
-        output_directory,
-        output_file,
-        "blog_post.js",
-    )?];
-    let global_settings = GlobalSettings::new(page.title.clone(), css_files, js_files);
-    let page_header = PageHeader::new(
-        config.get_site_title().map(str::to_string),
-        Some(get_web_path(config, output_directory, output_file, "")?),
-    );
-    let link_to_blog_post = get_web_path(
-        config,
-        output_directory,
-        output_file,
-        output_file.strip_prefix(output_directory)?,
-    )?;
-
-    let children = {
-        let mut children = Vec::new();
-
-        for child in page.children.iter() {
-            children.push(RenderDocumentElement::new(
-                config,
-                output_directory,
-                output_file,
-                child,
-            )?);
-        }
-
-        children
-    };
-
-    let footnotes = {
-        let mut ret = Vec::new();
-
-        for footnote in page.footnotes.iter() {
-            ret.push(RenderRealFootnoteDefinition::new(
-                config,
-                output_directory,
-                output_file,
-                footnote,
-            )?);
-        }
-
-        ret
-    };
-
-    let ret = RenderBlogPostPage::new(
-        global_settings,
-        Some(page_header),
-        page.title.clone(),
-        Some(link_to_blog_post),
-        children,
-        footnotes,
-    );
-    Ok(ret)
-}
-
 pub(crate) fn get_web_path<D: AsRef<Path>, F: AsRef<Path>, P: AsRef<Path>>(
     config: &Config,
     output_directory: D,

src/intermediate/mod.rs

@@ -76,7 +76,6 @@ pub(crate) use clock::IClock;
 pub(crate) use code::ICode;
 pub(crate) use comment::IComment;
 pub(crate) use comment_block::ICommentBlock;
-pub(crate) use convert::convert_blog_post_page_to_render_context;
 pub(crate) use convert::get_web_path;
 pub(crate) use diary_sexp::IDiarySexp;
 pub(crate) use document_element::IDocumentElement;