Add the skeletons for the elements.

src/context/babel_call.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IBabelCall;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "babel_call")]
+pub(crate) struct RenderBabelCall {}
+
+impl RenderBabelCall {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IBabelCall,
+    ) -> Result<RenderBabelCall, CustomError> {
+        Ok(RenderBabelCall {})
+    }
+}

src/context/center_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICenterBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "center_block")]
+pub(crate) struct RenderCenterBlock {}
+
+impl RenderCenterBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ICenterBlock,
+    ) -> Result<RenderCenterBlock, CustomError> {
+        Ok(RenderCenterBlock {})
+    }
+}

src/context/clock.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IClock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "clock")]
+pub(crate) struct RenderClock {}
+
+impl RenderClock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IClock,
+    ) -> Result<RenderClock, CustomError> {
+        Ok(RenderClock {})
+    }
+}

src/context/comment_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICommentBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "comment_block")]
+pub(crate) struct RenderCommentBlock {}
+
+impl RenderCommentBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ICommentBlock,
+    ) -> Result<RenderCommentBlock, CustomError> {
+        Ok(RenderCommentBlock {})
+    }
+}

src/context/diary_sexp.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDiarySexp;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "diary_sexp")]
+pub(crate) struct RenderDiarySexp {}
+
+impl RenderDiarySexp {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IDiarySexp,
+    ) -> Result<RenderDiarySexp, CustomError> {
+        Ok(RenderDiarySexp {})
+    }
+}

src/context/drawer.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDrawer;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "drawer")]
+pub(crate) struct RenderDrawer {}
+
+impl RenderDrawer {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IDrawer,
+    ) -> Result<RenderDrawer, CustomError> {
+        Ok(RenderDrawer {})
+    }
+}

src/context/dynamic_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDynamicBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "dynamic_block")]
+pub(crate) struct RenderDynamicBlock {}
+
+impl RenderDynamicBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IDynamicBlock,
+    ) -> Result<RenderDynamicBlock, CustomError> {
+        Ok(RenderDynamicBlock {})
+    }
+}

src/context/element.rs

@@ -6,16 +6,58 @@ use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IElement;
 
+use super::babel_call::RenderBabelCall;
+use super::center_block::RenderCenterBlock;
+use super::clock::RenderClock;
 use super::comment::RenderComment;
+use super::comment_block::RenderCommentBlock;
+use super::diary_sexp::RenderDiarySexp;
+use super::drawer::RenderDrawer;
+use super::dynamic_block::RenderDynamicBlock;
+use super::example_block::RenderExampleBlock;
+use super::export_block::RenderExportBlock;
+use super::fixed_width_area::RenderFixedWidthArea;
+use super::footnote_definition::RenderFootnoteDefinition;
+use super::horizontal_rule::RenderHorizontalRule;
 use super::keyword::RenderKeyword;
+use super::latex_environment::RenderLatexEnvironment;
 use super::paragraph::RenderParagraph;
+use super::plain_list::RenderPlainList;
+use super::planning::RenderPlanning;
+use super::property_drawer::RenderPropertyDrawer;
+use super::quote_block::RenderQuoteBlock;
+use super::special_block::RenderSpecialBlock;
+use super::src_block::RenderSrcBlock;
+use super::table::RenderTable;
+use super::verse_block::RenderVerseBlock;
 
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub(crate) enum RenderElement {
     Paragraph(RenderParagraph),
-    Keyword(RenderKeyword),
+    PlainList(RenderPlainList),
+    CenterBlock(RenderCenterBlock),
+    QuoteBlock(RenderQuoteBlock),
+    SpecialBlock(RenderSpecialBlock),
+    DynamicBlock(RenderDynamicBlock),
+    FootnoteDefinition(RenderFootnoteDefinition),
     Comment(RenderComment),
+    Drawer(RenderDrawer),
+    PropertyDrawer(RenderPropertyDrawer),
+    Table(RenderTable),
+    VerseBlock(RenderVerseBlock),
+    CommentBlock(RenderCommentBlock),
+    ExampleBlock(RenderExampleBlock),
+    ExportBlock(RenderExportBlock),
+    SrcBlock(RenderSrcBlock),
+    Clock(RenderClock),
+    DiarySexp(RenderDiarySexp),
+    Planning(RenderPlanning),
+    FixedWidthArea(RenderFixedWidthArea),
+    HorizontalRule(RenderHorizontalRule),
+    Keyword(RenderKeyword),
+    BabelCall(RenderBabelCall),
+    LatexEnvironment(RenderLatexEnvironment),
 }
 
 impl RenderElement {
@@ -32,18 +74,117 @@ impl RenderElement {
                 output_file,
                 inner,
             )?)),
-            IElement::Keyword(inner) => Ok(RenderElement::Keyword(RenderKeyword::new(
+            IElement::PlainList(inner) => Ok(RenderElement::PlainList(RenderPlainList::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IElement::CenterBlock(inner) => Ok(RenderElement::CenterBlock(RenderCenterBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::QuoteBlock(inner) => Ok(RenderElement::QuoteBlock(RenderQuoteBlock::new(
+                config,
+                output_directory,
+                output_file,
+                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)?,
+            )),
             IElement::Comment(inner) => Ok(RenderElement::Comment(RenderComment::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IElement::Drawer(inner) => Ok(RenderElement::Drawer(RenderDrawer::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::PropertyDrawer(inner) => Ok(RenderElement::PropertyDrawer(
+                RenderPropertyDrawer::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::Table(inner) => Ok(RenderElement::Table(RenderTable::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::VerseBlock(inner) => Ok(RenderElement::VerseBlock(RenderVerseBlock::new(
+                config,
+                output_directory,
+                output_file,
+                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,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::SrcBlock(inner) => Ok(RenderElement::SrcBlock(RenderSrcBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::Clock(inner) => Ok(RenderElement::Clock(RenderClock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::DiarySexp(inner) => Ok(RenderElement::DiarySexp(RenderDiarySexp::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::Planning(inner) => Ok(RenderElement::Planning(RenderPlanning::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::FixedWidthArea(inner) => Ok(RenderElement::FixedWidthArea(
+                RenderFixedWidthArea::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::HorizontalRule(inner) => Ok(RenderElement::HorizontalRule(
+                RenderHorizontalRule::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::Keyword(inner) => Ok(RenderElement::Keyword(RenderKeyword::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::BabelCall(inner) => Ok(RenderElement::BabelCall(RenderBabelCall::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::LatexEnvironment(inner) => Ok(RenderElement::LatexEnvironment(
+                RenderLatexEnvironment::new(config, output_directory, output_file, inner)?,
+            )),
         }
     }
 }

src/context/example_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IExampleBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "example_block")]
+pub(crate) struct RenderExampleBlock {}
+
+impl RenderExampleBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IExampleBlock,
+    ) -> Result<RenderExampleBlock, CustomError> {
+        Ok(RenderExampleBlock {})
+    }
+}

src/context/export_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IExportBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "export_block")]
+pub(crate) struct RenderExportBlock {}
+
+impl RenderExportBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IExportBlock,
+    ) -> Result<RenderExportBlock, CustomError> {
+        Ok(RenderExportBlock {})
+    }
+}

src/context/fixed_width_area.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IFixedWidthArea;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "fixed_width_area")]
+pub(crate) struct RenderFixedWidthArea {}
+
+impl RenderFixedWidthArea {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IFixedWidthArea,
+    ) -> Result<RenderFixedWidthArea, CustomError> {
+        Ok(RenderFixedWidthArea {})
+    }
+}

src/context/footnote_definition.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IFootnoteDefinition;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "footnote_definition")]
+pub(crate) struct RenderFootnoteDefinition {}
+
+impl RenderFootnoteDefinition {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IFootnoteDefinition,
+    ) -> Result<RenderFootnoteDefinition, CustomError> {
+        Ok(RenderFootnoteDefinition {})
+    }
+}

src/context/horizontal_rule.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IHorizontalRule;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "horizontal_rule")]
+pub(crate) struct RenderHorizontalRule {}
+
+impl RenderHorizontalRule {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IHorizontalRule,
+    ) -> Result<RenderHorizontalRule, CustomError> {
+        Ok(RenderHorizontalRule {})
+    }
+}

src/context/latex_environment.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ILatexEnvironment;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "latex_environment")]
+pub(crate) struct RenderLatexEnvironment {}
+
+impl RenderLatexEnvironment {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ILatexEnvironment,
+    ) -> Result<RenderLatexEnvironment, CustomError> {
+        Ok(RenderLatexEnvironment {})
+    }
+}

src/context/mod.rs

@@ -1,15 +1,36 @@
+mod babel_call;
 mod blog_post_page;
+mod center_block;
+mod clock;
 mod comment;
+mod comment_block;
+mod diary_sexp;
 mod document_element;
+mod drawer;
+mod dynamic_block;
 mod element;
+mod example_block;
+mod export_block;
+mod fixed_width_area;
+mod footnote_definition;
 mod global_settings;
 mod heading;
+mod horizontal_rule;
 mod keyword;
+mod latex_environment;
 mod object;
 mod paragraph;
+mod plain_list;
 mod plain_text;
+mod planning;
+mod property_drawer;
+mod quote_block;
 mod section;
+mod special_block;
+mod src_block;
+mod table;
 mod target;
+mod verse_block;
 
 pub(crate) use blog_post_page::RenderBlogPostPage;
 pub(crate) use document_element::RenderDocumentElement;

src/context/plain_list.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPlainList;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "plain_list")]
+pub(crate) struct RenderPlainList {}
+
+impl RenderPlainList {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IPlainList,
+    ) -> Result<RenderPlainList, CustomError> {
+        Ok(RenderPlainList {})
+    }
+}

src/context/planning.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPlanning;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "planning")]
+pub(crate) struct RenderPlanning {}
+
+impl RenderPlanning {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IPlanning,
+    ) -> Result<RenderPlanning, CustomError> {
+        Ok(RenderPlanning {})
+    }
+}

src/context/property_drawer.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPropertyDrawer;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "property_drawer")]
+pub(crate) struct RenderPropertyDrawer {}
+
+impl RenderPropertyDrawer {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IPropertyDrawer,
+    ) -> Result<RenderPropertyDrawer, CustomError> {
+        Ok(RenderPropertyDrawer {})
+    }
+}

src/context/quote_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IQuoteBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "quote_block")]
+pub(crate) struct RenderQuoteBlock {}
+
+impl RenderQuoteBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IQuoteBlock,
+    ) -> Result<RenderQuoteBlock, CustomError> {
+        Ok(RenderQuoteBlock {})
+    }
+}

src/context/special_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISpecialBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "special_block")]
+pub(crate) struct RenderSpecialBlock {}
+
+impl RenderSpecialBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ISpecialBlock,
+    ) -> Result<RenderSpecialBlock, CustomError> {
+        Ok(RenderSpecialBlock {})
+    }
+}

src/context/src_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISrcBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "src_block")]
+pub(crate) struct RenderSrcBlock {}
+
+impl RenderSrcBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ISrcBlock,
+    ) -> Result<RenderSrcBlock, CustomError> {
+        Ok(RenderSrcBlock {})
+    }
+}

src/context/table.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ITable;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "table")]
+pub(crate) struct RenderTable {}
+
+impl RenderTable {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ITable,
+    ) -> Result<RenderTable, CustomError> {
+        Ok(RenderTable {})
+    }
+}

src/context/verse_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IVerseBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "verse_block")]
+pub(crate) struct RenderVerseBlock {}
+
+impl RenderVerseBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IVerseBlock,
+    ) -> Result<RenderVerseBlock, CustomError> {
+        Ok(RenderVerseBlock {})
+    }
+}