talexander/natter
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Switch over to using the render context in render calls.

Browse Source
This commit is contained in:
Tom Alexander 2023-12-19 15:42:37 -05:00
parent cb3278aba5
commit add267d616
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
67 changed files with 699 additions and 1197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/command/build/render.rs
View File

@ -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,
&output_path,
blog_post,
blog_post_page,
self.output_directory.as_path(),
output_path.as_path(),
)?;
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)?;

4
src/context/angle_link.rs
View File

@ -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;

200
src/context/ast_node.rs
View File

@ -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,
output_directory: &Path,
output_file: &Path,
render_context: RenderContext<'_>,
) -> Result<RenderAstNode, CustomError>;
}
impl IntoRenderAstNode for IAstNode {
fn into_render_ast_node(
&self,
config: &Config,
output_directory: &Path,
output_file: &Path,
render_context: RenderContext<'_>,
) -> Result<RenderAstNode, CustomError> {
match self {
IAstNode::Heading(inner) => Ok(RenderAstNode::Heading(RenderHeading::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Section(inner) => Ok(RenderAstNode::Section(RenderSection::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Paragraph(inner) => Ok(RenderAstNode::Paragraph(RenderParagraph::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::PlainList(inner) => Ok(RenderAstNode::PlainList(RenderPlainList::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::CenterBlock(inner) => Ok(RenderAstNode::CenterBlock(RenderCenterBlock::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::QuoteBlock(inner) => Ok(RenderAstNode::QuoteBlock(RenderQuoteBlock::new(
config,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Drawer(inner) => Ok(RenderAstNode::Drawer(RenderDrawer::new(
config,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::VerseBlock(inner) => Ok(RenderAstNode::VerseBlock(RenderVerseBlock::new(
config,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::SrcBlock(inner) => Ok(RenderAstNode::SrcBlock(RenderSrcBlock::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Clock(inner) => Ok(RenderAstNode::Clock(RenderClock::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::DiarySexp(inner) => Ok(RenderAstNode::DiarySexp(RenderDiarySexp::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Planning(inner) => Ok(RenderAstNode::Planning(RenderPlanning::new(
config,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::BabelCall(inner) => Ok(RenderAstNode::BabelCall(RenderBabelCall::new(
config,
output_directory,
output_file,
render_context,
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(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Bold(inner) => {
Ok(RenderAstNode::Bold(RenderBold::new(render_context, inner)?))
}
IAstNode::Italic(inner) => Ok(RenderAstNode::Italic(RenderItalic::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Underline(inner) => Ok(RenderAstNode::Underline(RenderUnderline::new(
config,
output_directory,
output_file,
render_context,
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(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Code(inner) => {
Ok(RenderAstNode::Code(RenderCode::new(render_context, inner)?))
}
IAstNode::Verbatim(inner) => Ok(RenderAstNode::Verbatim(RenderVerbatim::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::PlainText(inner) => Ok(RenderAstNode::PlainText(RenderPlainText::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::RegularLink(inner) => Ok(RenderAstNode::RegularLink(RenderRegularLink::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::RadioLink(inner) => Ok(RenderAstNode::RadioLink(RenderRadioLink::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::RadioTarget(inner) => Ok(RenderAstNode::RadioTarget(RenderRadioTarget::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::PlainLink(inner) => Ok(RenderAstNode::PlainLink(RenderPlainLink::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::AngleLink(inner) => Ok(RenderAstNode::AngleLink(RenderAngleLink::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::OrgMacro(inner) => Ok(RenderAstNode::OrgMacro(RenderOrgMacro::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Entity(inner) => Ok(RenderAstNode::Entity(RenderEntity::new(
config,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Target(inner) => Ok(RenderAstNode::Target(RenderTarget::new(
config,
output_directory,
output_file,
render_context,
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,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Superscript(inner) => Ok(RenderAstNode::Superscript(RenderSuperscript::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
IAstNode::Timestamp(inner) => Ok(RenderAstNode::Timestamp(RenderTimestamp::new(
config,
output_directory,
output_file,
render_context,
inner,
)?)),
}

4
src/context/babel_call.rs
View File

@ -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;

110
src/context/blog_post_page.rs
View File

@ -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 {
// TODO: Maybe these settings should be moved into a common struct so this can have the same type signature as the others.
pub(crate) fn new(
global_settings: GlobalSettings,
page_header: Option<PageHeader>,
title: Option<String>,
self_link: Option<String>,
children: Vec<RenderDocumentElement>,
footnotes: Vec<RenderRealFootnoteDefinition>,
) -> RenderBlogPostPage {
RenderBlogPostPage {
render!(
RenderBlogPostPage,
RenderBlogPostPageInput,
original,
render_context,
{
let css_files = vec![
// get_web_path(
// config,
// output_directory,
// 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,
title,
self_link,
page_header: Some(page_header),
title: original.page.title.clone(),
self_link: Some(link_to_blog_post),
children,
footnotes,
}
};
Ok(ret)
}
}
);

140
src/context/blog_stream.rs
View File

@ -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 {
pub(crate) fn new(
config: &Config,
output_directory: &Path,
output_file: &Path,
original: &[&BlogPost],
older_link: Option<String>,
newer_link: Option<String>,
) -> Result<RenderBlogStream, CustomError> {
render!(
RenderBlogStream,
RenderBlogStreamInput,
original,
render_context,
{
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,
output_directory,
output_file,
render_context.config,
render_context.output_directory,
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),
Some(get_web_path(config, output_directory, output_file, "")?),
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 children = original
.original
.into_iter()
.map(|blog_post| {
RenderBlogStreamEntry::new(config, output_directory, output_file, blog_post)
})
.map(|blog_post| RenderBlogStreamEntry::new(render_context.clone(), blog_post))
.collect::<Result<Vec<_>, _>>()?;
let stream_pagination = if older_link.is_some() || newer_link.is_some() {
Some(RenderBlogStreamPagination::new(older_link, newer_link)?)
let stream_pagination = if original.older_link.is_some() || original.newer_link.is_some() {
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,43 +119,38 @@ pub(crate) struct RenderBlogStreamEntry {
footnotes: Vec<RenderRealFootnoteDefinition>,
}
impl RenderBlogStreamEntry {
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,
output_directory,
output_file,
output_file.strip_prefix(output_directory)?,
)?;
render!(RenderBlogStreamEntry, BlogPost, original, render_context, {
// TODO: This link is probably wrong.
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)?,
)?;
// TODO: Should I guess an index page instead of erroring out?
let index_page = original
.get_index_page()
.ok_or_else(|| format!("Blog post {} needs an index page.", original.id))?;
// TODO: Should I guess an index page instead of erroring out?
let index_page = original
.get_index_page()
.ok_or_else(|| format!("Blog post {} needs an index page.", original.id))?;
let title = index_page.title.clone();
let title = index_page.title.clone();
// TODO: Handle footnotes.
let children = index_page
.children
.iter()
.map(|child| RenderDocumentElement::new(config, output_directory, output_file, child))
.collect::<Result<Vec<_>, _>>()?;
// TODO: Handle footnotes.
let children = index_page
.children
.iter()
.map(|child| RenderDocumentElement::new(render_context.clone(), child))
.collect::<Result<Vec<_>, _>>()?;
Ok(RenderBlogStreamEntry {
title,
self_link: Some(link_to_blog_post),
children,
footnotes: Vec::new(),
})
}
}
Ok(RenderBlogStreamEntry {
title,
self_link: Some(link_to_blog_post),
children,
footnotes: Vec::new(),
})
});
#[derive(Debug, Serialize)]
pub(crate) struct RenderBlogStreamPagination {

37
src/context/bold.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderBold, IBold, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderBold { children })
}
);
Ok(RenderBold { children })
});

4
src/context/center_block.rs
View File

@ -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;

4
src/context/citation.rs
View File

@ -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;

4
src/context/citation_reference.rs
View File

@ -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;

4
src/context/clock.rs
View File

@ -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;

22
src/context/code.rs
View File

@ -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!(
RenderCode,
ICode,
original,
_config,
_output_directory,
_output_file,
{
Ok(RenderCode {
contents: original.contents.clone(),
})
}
);
render!(RenderCode, ICode, original, _render_context, {
Ok(RenderCode {
contents: original.contents.clone(),
})
});

4
src/context/comment.rs
View File

@ -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;

4
src/context/comment_block.rs
View File

@ -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;

4
src/context/diary_sexp.rs
View File

@ -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;

12
src/context/document_element.rs
View File

@ -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,
output_directory,
output_file,
render_context,
{
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)?,
)),
}
}

4
src/context/drawer.rs
View File

@ -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;

4
src/context/dynamic_block.rs
View File

@ -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;

226
src/context/element.rs
View File

@ -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!(
RenderElement,
IElement,
original,
config,
output_directory,
output_file,
{
match original {
IElement::Paragraph(inner) => Ok(RenderElement::Paragraph(RenderParagraph::new(
config,
output_directory,
output_file,
inner,
)?)),
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)?,
)),
}
render!(RenderElement, IElement, original, render_context, {
match original {
IElement::Paragraph(inner) => Ok(RenderElement::Paragraph(RenderParagraph::new(
render_context.clone(),
inner,
)?)),
IElement::PlainList(inner) => Ok(RenderElement::PlainList(RenderPlainList::new(
render_context.clone(),
inner,
)?)),
IElement::CenterBlock(inner) => Ok(RenderElement::CenterBlock(RenderCenterBlock::new(
render_context.clone(),
inner,
)?)),
IElement::QuoteBlock(inner) => Ok(RenderElement::QuoteBlock(RenderQuoteBlock::new(
render_context.clone(),
inner,
)?)),
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::FootnoteDefinition(inner) => Ok(RenderElement::FootnoteDefinition(
RenderFootnoteDefinition::new(render_context.clone(), inner)?,
)),
IElement::Comment(inner) => Ok(RenderElement::Comment(RenderComment::new(
render_context.clone(),
inner,
)?)),
IElement::Drawer(inner) => Ok(RenderElement::Drawer(RenderDrawer::new(
render_context.clone(),
inner,
)?)),
IElement::PropertyDrawer(inner) => Ok(RenderElement::PropertyDrawer(
RenderPropertyDrawer::new(render_context.clone(), inner)?,
)),
IElement::Table(inner) => Ok(RenderElement::Table(RenderTable::new(
render_context.clone(),
inner,
)?)),
IElement::VerseBlock(inner) => Ok(RenderElement::VerseBlock(RenderVerseBlock::new(
render_context.clone(),
inner,
)?)),
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::ExportBlock(inner) => Ok(RenderElement::ExportBlock(RenderExportBlock::new(
render_context.clone(),
inner,
)?)),
IElement::SrcBlock(inner) => Ok(RenderElement::SrcBlock(RenderSrcBlock::new(
render_context.clone(),
inner,
)?)),
IElement::Clock(inner) => Ok(RenderElement::Clock(RenderClock::new(
render_context.clone(),
inner,
)?)),
IElement::DiarySexp(inner) => Ok(RenderElement::DiarySexp(RenderDiarySexp::new(
render_context.clone(),
inner,
)?)),
IElement::Planning(inner) => Ok(RenderElement::Planning(RenderPlanning::new(
render_context.clone(),
inner,
)?)),
IElement::FixedWidthArea(inner) => Ok(RenderElement::FixedWidthArea(
RenderFixedWidthArea::new(render_context.clone(), inner)?,
)),
IElement::HorizontalRule(inner) => Ok(RenderElement::HorizontalRule(
RenderHorizontalRule::new(render_context.clone(), inner)?,
)),
IElement::Keyword(inner) => Ok(RenderElement::Keyword(RenderKeyword::new(
render_context.clone(),
inner,
)?)),
IElement::BabelCall(inner) => Ok(RenderElement::BabelCall(RenderBabelCall::new(
render_context.clone(),
inner,
)?)),
IElement::LatexEnvironment(inner) => Ok(RenderElement::LatexEnvironment(
RenderLatexEnvironment::new(render_context.clone(), inner)?,
)),
}
);
});

22
src/context/entity.rs
View File

@ -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!(
RenderEntity,
IEntity,
original,
_config,
_output_directory,
_output_file,
{
Ok(RenderEntity {
html: original.html.clone(),
})
}
);
render!(RenderEntity, IEntity, original, _render_context, {
Ok(RenderEntity {
html: original.html.clone(),
})
});

4
src/context/example_block.rs
View File

@ -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;

4
src/context/export_block.rs
View File

@ -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;

4
src/context/export_snippet.rs
View File

@ -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;

4
src/context/fixed_width_area.rs
View File

@ -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;

10
src/context/footnote_definition.rs
View File

@ -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,
output_directory,
output_file,
render_context,
{
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
};

8
src/context/footnote_reference.rs
View File

@ -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,
_output_directory,
_output_file,
_render_context,
{
Ok(RenderFootnoteReference {
reference_id: original.get_reference_id(),

64
src/context/heading.rs
View File

@ -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,44 +17,26 @@ pub(crate) struct RenderHeading {
children: Vec<RenderDocumentElement>,
}
render!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderHeading, IHeading, original, render_context, {
let title = {
let mut ret = Vec::new();
for obj in original.title.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderDocumentElement::new(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderDocumentElement::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderHeading {
level: original.level + 1, // Adding 1 because the page title is going to be h1.
title,
children,
})
}
);
Ok(RenderHeading {
level: original.level + 1, // Adding 1 because the page title is going to be h1.
title,
children,
})
});

4
src/context/horizontal_rule.rs
View File

@ -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;

4
src/context/inline_babel_call.rs
View File

@ -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;

8
src/context/inline_source_block.rs
View File

@ -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,
_output_directory,
_output_file,
_render_context,
{
Ok(RenderInlineSourceBlock {
value: original.value.clone(),

37
src/context/italic.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderItalic, IItalic, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderItalic { children })
}
);
Ok(RenderItalic { children })
});

4
src/context/keyword.rs
View File

@ -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;

4
src/context/latex_environment.rs
View File

@ -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;

8
src/context/latex_fragment.rs
View File

@ -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,
_output_directory,
_output_file,
_render_context,
{
Ok(RenderLatexFragment {
value: original.value.clone(),

4
src/context/line_break.rs
View File

@ -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;

14
src/context/macros.rs
View File

@ -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,
output_directory: &Path,
output_file: &Path,
render_context: RenderContext<'_>,
original: &$istruct,
) -> Result<$rstruct, CustomError> {
let $original = original;
let $config = config;
let $output_directory = output_directory;
let $output_file = output_file;
let $render_context = render_context;
$fnbody
}
}
@ -29,9 +25,7 @@ macro_rules! rnoop {
($rstruct:ident, $istruct:ident) => {
impl $rstruct {
pub(crate) fn new(
_config: &Config,
_output_directory: &Path,
_output_file: &Path,
_render_context: RenderContext<'_>,
_original: &$istruct,
) -> Result<$rstruct, CustomError> {
Ok($rstruct {})

3
src/context/mod.rs
View File

@ -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;

259
src/context/object.rs
View File

@ -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!(
RenderObject,
IObject,
original,
config,
output_directory,
output_file,
{
match original {
IObject::Bold(inner) => Ok(RenderObject::Bold(RenderBold::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Italic(inner) => Ok(RenderObject::Italic(RenderItalic::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Underline(inner) => Ok(RenderObject::Underline(RenderUnderline::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::StrikeThrough(inner) => Ok(RenderObject::StrikeThrough(
RenderStrikeThrough::new(config, output_directory, output_file, inner)?,
)),
IObject::Code(inner) => Ok(RenderObject::Code(RenderCode::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Verbatim(inner) => Ok(RenderObject::Verbatim(RenderVerbatim::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::PlainText(inner) => Ok(RenderObject::PlainText(RenderPlainText::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::RegularLink(inner) => Ok(RenderObject::RegularLink(RenderRegularLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::RadioLink(inner) => Ok(RenderObject::RadioLink(RenderRadioLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::RadioTarget(inner) => Ok(RenderObject::RadioTarget(RenderRadioTarget::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::PlainLink(inner) => Ok(RenderObject::PlainLink(RenderPlainLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::AngleLink(inner) => Ok(RenderObject::AngleLink(RenderAngleLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::OrgMacro(inner) => Ok(RenderObject::OrgMacro(RenderOrgMacro::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Entity(inner) => Ok(RenderObject::Entity(RenderEntity::new(
config,
output_directory,
output_file,
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)?,
)),
IObject::Citation(inner) => Ok(RenderObject::Citation(RenderCitation::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::CitationReference(inner) => Ok(RenderObject::CitationReference(
RenderCitationReference::new(config, output_directory, output_file, inner)?,
)),
IObject::InlineBabelCall(inner) => Ok(RenderObject::InlineBabelCall(
RenderInlineBabelCall::new(config, output_directory, output_file, inner)?,
)),
IObject::InlineSourceBlock(inner) => Ok(RenderObject::InlineSourceBlock(
RenderInlineSourceBlock::new(config, output_directory, output_file, inner)?,
)),
IObject::LineBreak(inner) => Ok(RenderObject::LineBreak(RenderLineBreak::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Target(inner) => Ok(RenderObject::Target(RenderTarget::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::StatisticsCookie(inner) => Ok(RenderObject::StatisticsCookie(
RenderStatisticsCookie::new(config, output_directory, output_file, inner)?,
)),
IObject::Subscript(inner) => Ok(RenderObject::Subscript(RenderSubscript::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Superscript(inner) => Ok(RenderObject::Superscript(RenderSuperscript::new(
config,
output_directory,
output_file,
inner,
)?)),
IObject::Timestamp(inner) => Ok(RenderObject::Timestamp(RenderTimestamp::new(
config,
output_directory,
output_file,
inner,
)?)),
}
render!(RenderObject, IObject, original, render_context, {
match original {
IObject::Bold(inner) => Ok(RenderObject::Bold(RenderBold::new(
render_context.clone(),
inner,
)?)),
IObject::Italic(inner) => Ok(RenderObject::Italic(RenderItalic::new(
render_context.clone(),
inner,
)?)),
IObject::Underline(inner) => Ok(RenderObject::Underline(RenderUnderline::new(
render_context.clone(),
inner,
)?)),
IObject::StrikeThrough(inner) => Ok(RenderObject::StrikeThrough(RenderStrikeThrough::new(
render_context.clone(),
inner,
)?)),
IObject::Code(inner) => Ok(RenderObject::Code(RenderCode::new(
render_context.clone(),
inner,
)?)),
IObject::Verbatim(inner) => Ok(RenderObject::Verbatim(RenderVerbatim::new(
render_context.clone(),
inner,
)?)),
IObject::PlainText(inner) => Ok(RenderObject::PlainText(RenderPlainText::new(
render_context.clone(),
inner,
)?)),
IObject::RegularLink(inner) => Ok(RenderObject::RegularLink(RenderRegularLink::new(
render_context.clone(),
inner,
)?)),
IObject::RadioLink(inner) => Ok(RenderObject::RadioLink(RenderRadioLink::new(
render_context.clone(),
inner,
)?)),
IObject::RadioTarget(inner) => Ok(RenderObject::RadioTarget(RenderRadioTarget::new(
render_context.clone(),
inner,
)?)),
IObject::PlainLink(inner) => Ok(RenderObject::PlainLink(RenderPlainLink::new(
render_context.clone(),
inner,
)?)),
IObject::AngleLink(inner) => Ok(RenderObject::AngleLink(RenderAngleLink::new(
render_context.clone(),
inner,
)?)),
IObject::OrgMacro(inner) => Ok(RenderObject::OrgMacro(RenderOrgMacro::new(
render_context.clone(),
inner,
)?)),
IObject::Entity(inner) => Ok(RenderObject::Entity(RenderEntity::new(
render_context.clone(),
inner,
)?)),
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::FootnoteReference(inner) => Ok(RenderObject::FootnoteReference(
RenderFootnoteReference::new(render_context.clone(), inner)?,
)),
IObject::Citation(inner) => Ok(RenderObject::Citation(RenderCitation::new(
render_context.clone(),
inner,
)?)),
IObject::CitationReference(inner) => Ok(RenderObject::CitationReference(
RenderCitationReference::new(render_context.clone(), inner)?,
)),
IObject::InlineBabelCall(inner) => Ok(RenderObject::InlineBabelCall(
RenderInlineBabelCall::new(render_context.clone(), inner)?,
)),
IObject::InlineSourceBlock(inner) => Ok(RenderObject::InlineSourceBlock(
RenderInlineSourceBlock::new(render_context.clone(), inner)?,
)),
IObject::LineBreak(inner) => Ok(RenderObject::LineBreak(RenderLineBreak::new(
render_context.clone(),
inner,
)?)),
IObject::Target(inner) => Ok(RenderObject::Target(RenderTarget::new(
render_context.clone(),
inner,
)?)),
IObject::StatisticsCookie(inner) => Ok(RenderObject::StatisticsCookie(
RenderStatisticsCookie::new(render_context.clone(), inner)?,
)),
IObject::Subscript(inner) => Ok(RenderObject::Subscript(RenderSubscript::new(
render_context.clone(),
inner,
)?)),
IObject::Superscript(inner) => Ok(RenderObject::Superscript(RenderSuperscript::new(
render_context.clone(),
inner,
)?)),
IObject::Timestamp(inner) => Ok(RenderObject::Timestamp(RenderTimestamp::new(
render_context.clone(),
inner,
)?)),
}
);
});

4
src/context/org_macro.rs
View File

@ -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;

37
src/context/paragraph.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderParagraph, IParagraph, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderParagraph { children })
}
);
Ok(RenderParagraph { children })
});

4
src/context/plain_link.rs
View File

@ -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;

53
src/context/plain_list.rs
View File

@ -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,35 +15,22 @@ pub(crate) struct RenderPlainList {
children: Vec<RenderPlainListItem>,
}
render!(
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(),
organic::types::PlainListType::Descriptive => "descriptive".to_owned(),
};
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderPlainListItem::new(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderPlainList, IPlainList, original, render_context, {
let list_type = match original.list_type {
organic::types::PlainListType::Unordered => "unordered".to_owned(),
organic::types::PlainListType::Ordered => "ordered".to_owned(),
organic::types::PlainListType::Descriptive => "descriptive".to_owned(),
};
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderPlainListItem::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderPlainList {
list_type,
children,
})
}
);
Ok(RenderPlainList {
list_type,
children,
})
});

22
src/context/plain_list_item.rs
View File

@ -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,
output_directory,
output_file,
render_context,
{
let tag = {
let mut ret = Vec::new();
for obj in original.tag.iter() {
ret.push(RenderObject::new(
config,
output_directory,
output_file,
obj,
)?);
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
@ -42,12 +33,7 @@ render!(
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderElement::new(
config,
output_directory,
output_file,
obj,
)?);
ret.push(RenderElement::new(render_context.clone(), obj)?);
}
ret
};

22
src/context/plain_text.rs
View File

@ -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!(
RenderPlainText,
IPlainText,
original,
_config,
_output_directory,
_output_file,
{
Ok(RenderPlainText {
source: original.source.clone(),
})
}
);
render!(RenderPlainText, IPlainText, original, _render_context, {
Ok(RenderPlainText {
source: original.source.clone(),
})
});

4
src/context/planning.rs
View File

@ -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;

4
src/context/property_drawer.rs
View File

@ -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;

37
src/context/quote_block.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderQuoteBlock, IQuoteBlock, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderElement::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderQuoteBlock { children })
}
);
Ok(RenderQuoteBlock { children })
});

4
src/context/radio_link.rs
View File

@ -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;

4
src/context/radio_target.rs
View File

@ -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;

43
src/context/regular_link.rs
View File

@ -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,30 +15,17 @@ pub(crate) struct RenderRegularLink {
children: Vec<RenderObject>,
}
render!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderRegularLink, IRegularLink, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderRegularLink {
raw_link: original.raw_link.clone(),
children,
})
}
);
Ok(RenderRegularLink {
raw_link: original.raw_link.clone(),
children,
})
});

37
src/context/section.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderSection, ISection, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderElement::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderSection { children })
}
);
Ok(RenderSection { children })
});

4
src/context/special_block.rs
View File

@ -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;

22
src/context/src_block.rs
View File

@ -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!(
RenderSrcBlock,
ISrcBlock,
original,
_config,
_output_directory,
_output_file,
{
Ok(RenderSrcBlock {
lines: original.lines.clone(),
})
}
);
render!(RenderSrcBlock, ISrcBlock, original, _render_context, {
Ok(RenderSrcBlock {
lines: original.lines.clone(),
})
});

4
src/context/statistics_cookie.rs
View File

@ -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;

15
src/context/strike_through.rs
View File

@ -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,
output_directory,
output_file,
render_context,
{
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(
config,
output_directory,
output_file,
obj,
)?);
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};

4
src/context/subscript.rs
View File

@ -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;

4
src/context/superscript.rs
View File

@ -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;

37
src/context/table.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderTable, ITable, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderTableRow::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderTable { children })
}
);
Ok(RenderTable { children })
});

37
src/context/table_cell.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderTableCell, ITableCell, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderTableCell { children })
}
);
Ok(RenderTableCell { children })
});

37
src/context/table_row.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderTableRow, ITableRow, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderTableCell::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderTableRow { children })
}
);
Ok(RenderTableRow { children })
});

22
src/context/target.rs
View File

@ -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!(
RenderTarget,
ITarget,
original,
_config,
_output_directory,
_output_file,
{
Ok(RenderTarget {
id: original.id.clone(),
})
}
);
render!(RenderTarget, ITarget, original, _render_context, {
Ok(RenderTarget {
id: original.id.clone(),
})
});

4
src/context/timestamp.rs
View File

@ -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;

37
src/context/underline.rs
View File

@ -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!(
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(
config,
output_directory,
output_file,
obj,
)?);
}
ret
};
render!(RenderUnderline, IUnderline, original, render_context, {
let children = {
let mut ret = Vec::new();
for obj in original.children.iter() {
ret.push(RenderObject::new(render_context.clone(), obj)?);
}
ret
};
Ok(RenderUnderline { children })
}
);
Ok(RenderUnderline { children })
});

22
src/context/verbatim.rs
View File

@ -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!(
RenderVerbatim,
IVerbatim,
original,
_config,
_output_directory,
_output_file,
{
Ok(RenderVerbatim {
contents: original.contents.clone(),
})
}
);
render!(RenderVerbatim, IVerbatim, original, _render_context, {
Ok(RenderVerbatim {
contents: original.contents.clone(),
})
});

4
src/context/verse_block.rs
View File

@ -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;

85
src/intermediate/convert.rs
View File

@ -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,

1
src/intermediate/mod.rs
View File

@ -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;