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

Merge branch 'footnote'

This commit is contained in:
Tom Alexander 2023-10-29 22:29:38 -04:00
parent 06dcd22e69 0da37b25e3
commit ff57242434
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE
83 changed files with 1864 additions and 1006 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
default_environment/templates/html/ast_node.dust Normal file
View File

@ -0,0 +1,57 @@
{@select key=.type}
{@eq value="heading"}{>heading/}{/eq}
{@eq value="section"}{>section/}{/eq}
{@eq value="paragraph"}{>paragraph/}{/eq}
{@eq value="plain_list"}{>plain_list/}{/eq}
{@eq value="center_block"}{>center_block/}{/eq}
{@eq value="quote_block"}{>quote_block/}{/eq}
{@eq value="special_block"}{>special_block/}{/eq}
{@eq value="dynamic_block"}{>dynamic_block/}{/eq}
{@eq value="footnote_definition"}{>footnote_definition/}{/eq}
{@eq value="comment"}{>comment/}{/eq}
{@eq value="drawer"}{>drawer/}{/eq}
{@eq value="property_drawer"}{>property_drawer/}{/eq}
{@eq value="table"}{>table/}{/eq}
{@eq value="verse_block"}{>verse_block/}{/eq}
{@eq value="comment_block"}{>comment_block/}{/eq}
{@eq value="example_block"}{>example_block/}{/eq}
{@eq value="export_block"}{>export_block/}{/eq}
{@eq value="src_block"}{>src_block/}{/eq}
{@eq value="clock"}{>clock/}{/eq}
{@eq value="diary_sexp"}{>diary_sexp/}{/eq}
{@eq value="planning"}{>planning/}{/eq}
{@eq value="fixed_width_area"}{>fixed_width_area/}{/eq}
{@eq value="horizontal_rule"}{>horizontal_rule/}{/eq}
{@eq value="keyword"}{>keyword/}{/eq}
{@eq value="babel_call"}{>babel_call/}{/eq}
{@eq value="latex_environment"}{>latex_environment/}{/eq}
{@eq value="bold"}{>bold/}{/eq}
{@eq value="italic"}{>italic/}{/eq}
{@eq value="underline"}{>underline/}{/eq}
{@eq value="strike_through"}{>strike_through/}{/eq}
{@eq value="code"}{>code/}{/eq}
{@eq value="verbatim"}{>verbatim/}{/eq}
{@eq value="plain_text"}{>plain_text/}{/eq}
{@eq value="regular_link"}{>regular_link/}{/eq}
{@eq value="radio_link"}{>radio_link/}{/eq}
{@eq value="radio_target"}{>radio_target/}{/eq}
{@eq value="plain_link"}{>plain_link/}{/eq}
{@eq value="angle_link"}{>angle_link/}{/eq}
{@eq value="org_macro"}{>org_macro/}{/eq}
{@eq value="entity"}{>entity/}{/eq}
{@eq value="latex_fragment"}{>latex_fragment/}{/eq}
{@eq value="export_snippet"}{>export_snippet/}{/eq}
{@eq value="footnote_reference"}{>footnote_reference/}{/eq}
{@eq value="citation"}{>citation/}{/eq}
{@eq value="citation_reference"}{>citation_reference/}{/eq}
{@eq value="inline_babel_call"}{>inline_babel_call/}{/eq}
{@eq value="inline_source_block"}{>inline_source_block/}{/eq}
{@eq value="line_break"}{>line_break/}{/eq}
{@eq value="target"}{>target/}{/eq}
{@eq value="statistics_cookie"}{>statistics_cookie/}{/eq}
{@eq value="subscript"}{>subscript/}{/eq}
{@eq value="superscript"}{>superscript/}{/eq}
{@eq value="timestamp"}{>timestamp/}{/eq}
{@none}{!TODO: make this panic!}ERROR: Unrecognized type {.type}.{/none}
{/select}
{! TODO: Maybe the final space should be conditional on end blank in the org source !}

7
default_environment/templates/html/blog_post_page.dust
View File

@ -10,5 +10,12 @@
{#.children} {#.children}
{>document_element/} {>document_element/}
{/.children} {/.children}
{?.footnotes}
<h2>Footnotes:</h2>
{#.footnotes}
{>real_footnote_definition/}
{/.footnotes}
{/.footnotes}
</div> </div>
</div> </div>

2
default_environment/templates/html/footnote_definition.dust
View File

@ -1 +1 @@
!!!!!!!! footnote_definition {! noop !}

2
default_environment/templates/html/footnote_reference.dust
View File

@ -1 +1 @@
!!!!!!!! footnote_reference <sup><a id="{.reference_id}" href="{.definition_link}">{.label}</a></sup>

1
default_environment/templates/html/real_footnote_definition.dust Normal file
View File

@ -0,0 +1 @@
<div><sup><a id="{.definition_id}" href="{.reference_link}">{.label}</a></sup><div>{#.contents}{>ast_node/}{/.contents}</div></div>

21
org_test_documents/footnotes/reference_in_definition.org Normal file
View File

@ -0,0 +1,21 @@
# This test shows that footnote references only count if the definition containing them is rendered.
foo[fn:a:bar]
[fn:a] lorem
[fn:b] ipsum
[fn:d] fizz
[fn:c] dolar
yo[fn:b]
hello[fn:c]
[fn:e] buzz
sup[fn:d]

25
org_test_documents/footnotes/simple.org Normal file
View File

@ -0,0 +1,25 @@
# Test proves that:
#
# - Anonymous references with identical content get unique IDs.
# - Unreferenced footnote definitions are dropped.
# - Footnote definitions that come before their first reference are dropped.
foo[fn:2:something]
bar[fn::something]
baz[fn::something]
cat[fn::something]
dog[fn:3]
[fn:3] ipsum
[fn:4] lorem
[fn:3] dolar
[fn:5] not referenced
stuff[fn:4] and things

407
src/context/ast_node.rs Normal file
View File

@ -0,0 +1,407 @@
use std::path::Path;
use serde::Serialize;
use crate::config::Config;
use crate::error::CustomError;
use crate::intermediate::IAstNode;
use super::angle_link::RenderAngleLink;
use super::babel_call::RenderBabelCall;
use super::bold::RenderBold;
use super::center_block::RenderCenterBlock;
use super::citation::RenderCitation;
use super::citation_reference::RenderCitationReference;
use super::clock::RenderClock;
use super::code::RenderCode;
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::entity::RenderEntity;
use super::example_block::RenderExampleBlock;
use super::export_block::RenderExportBlock;
use super::export_snippet::RenderExportSnippet;
use super::fixed_width_area::RenderFixedWidthArea;
use super::footnote_definition::RenderFootnoteDefinition;
use super::footnote_reference::RenderFootnoteReference;
use super::horizontal_rule::RenderHorizontalRule;
use super::inline_babel_call::RenderInlineBabelCall;
use super::inline_source_block::RenderInlineSourceBlock;
use super::italic::RenderItalic;
use super::keyword::RenderKeyword;
use super::latex_environment::RenderLatexEnvironment;
use super::latex_fragment::RenderLatexFragment;
use super::line_break::RenderLineBreak;
use super::org_macro::RenderOrgMacro;
use super::paragraph::RenderParagraph;
use super::plain_link::RenderPlainLink;
use super::plain_list::RenderPlainList;
use super::plain_text::RenderPlainText;
use super::planning::RenderPlanning;
use super::property_drawer::RenderPropertyDrawer;
use super::quote_block::RenderQuoteBlock;
use super::radio_link::RenderRadioLink;
use super::radio_target::RenderRadioTarget;
use super::regular_link::RenderRegularLink;
use super::special_block::RenderSpecialBlock;
use super::src_block::RenderSrcBlock;
use super::statistics_cookie::RenderStatisticsCookie;
use super::strike_through::RenderStrikeThrough;
use super::subscript::RenderSubscript;
use super::superscript::RenderSuperscript;
use super::table::RenderTable;
use super::target::RenderTarget;
use super::timestamp::RenderTimestamp;
use super::underline::RenderUnderline;
use super::verbatim::RenderVerbatim;
use super::verse_block::RenderVerseBlock;
use super::RenderHeading;
use super::RenderSection;
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub(crate) enum RenderAstNode {
Heading(RenderHeading),
Section(RenderSection),
Paragraph(RenderParagraph),
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),
Bold(RenderBold),
Italic(RenderItalic),
Underline(RenderUnderline),
StrikeThrough(RenderStrikeThrough),
Code(RenderCode),
Verbatim(RenderVerbatim),
PlainText(RenderPlainText),
RegularLink(RenderRegularLink),
RadioLink(RenderRadioLink),
RadioTarget(RenderRadioTarget),
PlainLink(RenderPlainLink),
AngleLink(RenderAngleLink),
OrgMacro(RenderOrgMacro),
Entity(RenderEntity),
LatexFragment(RenderLatexFragment),
ExportSnippet(RenderExportSnippet),
FootnoteReference(RenderFootnoteReference),
Citation(RenderCitation),
CitationReference(RenderCitationReference),
InlineBabelCall(RenderInlineBabelCall),
InlineSourceBlock(RenderInlineSourceBlock),
LineBreak(RenderLineBreak),
Target(RenderTarget),
StatisticsCookie(RenderStatisticsCookie),
Subscript(RenderSubscript),
Superscript(RenderSuperscript),
Timestamp(RenderTimestamp),
}
pub(crate) trait IntoRenderAstNode {
fn into_render_ast_node(
&self,
config: &Config,
output_directory: &Path,
output_file: &Path,
) -> Result<RenderAstNode, CustomError>;
}
impl IntoRenderAstNode for IAstNode {
fn into_render_ast_node(
&self,
config: &Config,
output_directory: &Path,
output_file: &Path,
) -> Result<RenderAstNode, CustomError> {
match self {
IAstNode::Heading(inner) => Ok(RenderAstNode::Heading(RenderHeading::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Section(inner) => Ok(RenderAstNode::Section(RenderSection::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Paragraph(inner) => Ok(RenderAstNode::Paragraph(RenderParagraph::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::PlainList(inner) => Ok(RenderAstNode::PlainList(RenderPlainList::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::CenterBlock(inner) => Ok(RenderAstNode::CenterBlock(RenderCenterBlock::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::QuoteBlock(inner) => Ok(RenderAstNode::QuoteBlock(RenderQuoteBlock::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::SpecialBlock(inner) => Ok(RenderAstNode::SpecialBlock(
RenderSpecialBlock::new(config, output_directory, output_file, inner)?,
)),
IAstNode::DynamicBlock(inner) => Ok(RenderAstNode::DynamicBlock(
RenderDynamicBlock::new(config, output_directory, output_file, inner)?,
)),
IAstNode::FootnoteDefinition(inner) => Ok(RenderAstNode::FootnoteDefinition(
RenderFootnoteDefinition::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Comment(inner) => Ok(RenderAstNode::Comment(RenderComment::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Drawer(inner) => Ok(RenderAstNode::Drawer(RenderDrawer::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::PropertyDrawer(inner) => Ok(RenderAstNode::PropertyDrawer(
RenderPropertyDrawer::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Table(inner) => Ok(RenderAstNode::Table(RenderTable::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::VerseBlock(inner) => Ok(RenderAstNode::VerseBlock(RenderVerseBlock::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::CommentBlock(inner) => Ok(RenderAstNode::CommentBlock(
RenderCommentBlock::new(config, output_directory, output_file, inner)?,
)),
IAstNode::ExampleBlock(inner) => Ok(RenderAstNode::ExampleBlock(
RenderExampleBlock::new(config, output_directory, output_file, inner)?,
)),
IAstNode::ExportBlock(inner) => Ok(RenderAstNode::ExportBlock(RenderExportBlock::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::SrcBlock(inner) => Ok(RenderAstNode::SrcBlock(RenderSrcBlock::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Clock(inner) => Ok(RenderAstNode::Clock(RenderClock::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::DiarySexp(inner) => Ok(RenderAstNode::DiarySexp(RenderDiarySexp::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Planning(inner) => Ok(RenderAstNode::Planning(RenderPlanning::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::FixedWidthArea(inner) => Ok(RenderAstNode::FixedWidthArea(
RenderFixedWidthArea::new(config, output_directory, output_file, inner)?,
)),
IAstNode::HorizontalRule(inner) => Ok(RenderAstNode::HorizontalRule(
RenderHorizontalRule::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Keyword(inner) => Ok(RenderAstNode::Keyword(RenderKeyword::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::BabelCall(inner) => Ok(RenderAstNode::BabelCall(RenderBabelCall::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::LatexEnvironment(inner) => Ok(RenderAstNode::LatexEnvironment(
RenderLatexEnvironment::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Bold(inner) => Ok(RenderAstNode::Bold(RenderBold::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Italic(inner) => Ok(RenderAstNode::Italic(RenderItalic::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Underline(inner) => Ok(RenderAstNode::Underline(RenderUnderline::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::StrikeThrough(inner) => Ok(RenderAstNode::StrikeThrough(
RenderStrikeThrough::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Code(inner) => Ok(RenderAstNode::Code(RenderCode::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Verbatim(inner) => Ok(RenderAstNode::Verbatim(RenderVerbatim::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::PlainText(inner) => Ok(RenderAstNode::PlainText(RenderPlainText::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::RegularLink(inner) => Ok(RenderAstNode::RegularLink(RenderRegularLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::RadioLink(inner) => Ok(RenderAstNode::RadioLink(RenderRadioLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::RadioTarget(inner) => Ok(RenderAstNode::RadioTarget(RenderRadioTarget::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::PlainLink(inner) => Ok(RenderAstNode::PlainLink(RenderPlainLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::AngleLink(inner) => Ok(RenderAstNode::AngleLink(RenderAngleLink::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::OrgMacro(inner) => Ok(RenderAstNode::OrgMacro(RenderOrgMacro::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Entity(inner) => Ok(RenderAstNode::Entity(RenderEntity::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::LatexFragment(inner) => Ok(RenderAstNode::LatexFragment(
RenderLatexFragment::new(config, output_directory, output_file, inner)?,
)),
IAstNode::ExportSnippet(inner) => Ok(RenderAstNode::ExportSnippet(
RenderExportSnippet::new(config, output_directory, output_file, inner)?,
)),
IAstNode::FootnoteReference(inner) => Ok(RenderAstNode::FootnoteReference(
RenderFootnoteReference::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Citation(inner) => Ok(RenderAstNode::Citation(RenderCitation::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::CitationReference(inner) => Ok(RenderAstNode::CitationReference(
RenderCitationReference::new(config, output_directory, output_file, inner)?,
)),
IAstNode::InlineBabelCall(inner) => Ok(RenderAstNode::InlineBabelCall(
RenderInlineBabelCall::new(config, output_directory, output_file, inner)?,
)),
IAstNode::InlineSourceBlock(inner) => Ok(RenderAstNode::InlineSourceBlock(
RenderInlineSourceBlock::new(config, output_directory, output_file, inner)?,
)),
IAstNode::LineBreak(inner) => Ok(RenderAstNode::LineBreak(RenderLineBreak::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Target(inner) => Ok(RenderAstNode::Target(RenderTarget::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::StatisticsCookie(inner) => Ok(RenderAstNode::StatisticsCookie(
RenderStatisticsCookie::new(config, output_directory, output_file, inner)?,
)),
IAstNode::Subscript(inner) => Ok(RenderAstNode::Subscript(RenderSubscript::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Superscript(inner) => Ok(RenderAstNode::Superscript(RenderSuperscript::new(
config,
output_directory,
output_file,
inner,
)?)),
IAstNode::Timestamp(inner) => Ok(RenderAstNode::Timestamp(RenderTimestamp::new(
config,
output_directory,
output_file,
inner,
)?)),
}
}
}

5
src/context/blog_post_page.rs
View File

@ -1,5 +1,6 @@
use serde::Serialize; use serde::Serialize;
use super::footnote_definition::RenderRealFootnoteDefinition;
use super::GlobalSettings; use super::GlobalSettings;
use super::RenderDocumentElement; use super::RenderDocumentElement;
@ -15,6 +16,8 @@ pub(crate) struct RenderBlogPostPage {
self_link: Option<String>, self_link: Option<String>,
children: Vec<RenderDocumentElement>, children: Vec<RenderDocumentElement>,
footnotes: Vec<RenderRealFootnoteDefinition>,
} }
impl RenderBlogPostPage { impl RenderBlogPostPage {
@ -23,12 +26,14 @@ impl RenderBlogPostPage {
title: Option<String>, title: Option<String>,
self_link: Option<String>, self_link: Option<String>,
children: Vec<RenderDocumentElement>, children: Vec<RenderDocumentElement>,
footnotes: Vec<RenderRealFootnoteDefinition>,
) -> RenderBlogPostPage { ) -> RenderBlogPostPage {
RenderBlogPostPage { RenderBlogPostPage {
global_settings, global_settings,
title, title,
self_link, self_link,
children, children,
footnotes,
} }
} }
} }

38
src/context/footnote_definition.rs
View File

@ -5,6 +5,10 @@ use serde::Serialize;
use crate::config::Config; use crate::config::Config;
use crate::error::CustomError; use crate::error::CustomError;
use crate::intermediate::IFootnoteDefinition; use crate::intermediate::IFootnoteDefinition;
use crate::intermediate::IRealFootnoteDefinition;
use super::ast_node::IntoRenderAstNode;
use super::ast_node::RenderAstNode;
#[derive(Debug, Serialize)] #[derive(Debug, Serialize)]
#[serde(tag = "type")] #[serde(tag = "type")]
@ -21,3 +25,37 @@ impl RenderFootnoteDefinition {
Ok(RenderFootnoteDefinition {}) Ok(RenderFootnoteDefinition {})
} }
} }
#[derive(Debug, Serialize)]
#[serde(tag = "type")]
#[serde(rename = "footnote_reference")]
pub(crate) struct RenderRealFootnoteDefinition {
definition_id: String,
reference_link: String,
label: String,
contents: Vec<RenderAstNode>,
}
impl RenderRealFootnoteDefinition {
pub(crate) fn new(
config: &Config,
output_directory: &Path,
output_file: &Path,
original: &IRealFootnoteDefinition,
) -> Result<RenderRealFootnoteDefinition, CustomError> {
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
};
Ok(RenderRealFootnoteDefinition {
definition_id: original.get_definition_id(),
reference_link: format!("#{}", original.get_reference_id()),
label: original.get_display_label(),
contents,
})
}
}

14
src/context/footnote_reference.rs
View File

@ -9,15 +9,23 @@ use crate::intermediate::IFootnoteReference;
#[derive(Debug, Serialize)] #[derive(Debug, Serialize)]
#[serde(tag = "type")] #[serde(tag = "type")]
#[serde(rename = "footnote_reference")] #[serde(rename = "footnote_reference")]
pub(crate) struct RenderFootnoteReference {} pub(crate) struct RenderFootnoteReference {
reference_id: String,
definition_link: String,
label: String,
}
impl RenderFootnoteReference { impl RenderFootnoteReference {
pub(crate) fn new( pub(crate) fn new(
config: &Config, config: &Config,
output_directory: &Path, output_directory: &Path,
output_file: &Path, output_file: &Path,
comment: &IFootnoteReference, original: &IFootnoteReference,
) -> Result<RenderFootnoteReference, CustomError> { ) -> Result<RenderFootnoteReference, CustomError> {
Ok(RenderFootnoteReference {}) Ok(RenderFootnoteReference {
reference_id: original.get_reference_id(),
definition_link: format!("#{}", original.get_definition_id()),
label: original.get_display_label(),
})
} }
} }

8
src/context/heading.rs
View File

@ -30,8 +30,8 @@ impl RenderHeading {
for obj in heading.title.iter() { for obj in heading.title.iter() {
ret.push(RenderObject::new( ret.push(RenderObject::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }
@ -43,8 +43,8 @@ impl RenderHeading {
for obj in heading.children.iter() { for obj in heading.children.iter() {
ret.push(RenderDocumentElement::new( ret.push(RenderDocumentElement::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

2
src/context/mod.rs
View File

@ -1,4 +1,5 @@
mod angle_link; mod angle_link;
mod ast_node;
mod babel_call; mod babel_call;
mod blog_post_page; mod blog_post_page;
mod bold; mod bold;
@ -61,6 +62,7 @@ mod verse_block;
pub(crate) use blog_post_page::RenderBlogPostPage; pub(crate) use blog_post_page::RenderBlogPostPage;
pub(crate) use document_element::RenderDocumentElement; pub(crate) use document_element::RenderDocumentElement;
pub(crate) use element::RenderElement; pub(crate) use element::RenderElement;
pub(crate) use footnote_definition::RenderRealFootnoteDefinition;
pub(crate) use global_settings::GlobalSettings; pub(crate) use global_settings::GlobalSettings;
pub(crate) use heading::RenderHeading; pub(crate) use heading::RenderHeading;
pub(crate) use object::RenderObject; pub(crate) use object::RenderObject;

4
src/context/paragraph.rs
View File

@ -27,8 +27,8 @@ impl RenderParagraph {
for obj in paragraph.children.iter() { for obj in paragraph.children.iter() {
ret.push(RenderObject::new( ret.push(RenderObject::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

4
src/context/plain_list.rs
View File

@ -33,8 +33,8 @@ impl RenderPlainList {
for obj in original.children.iter() { for obj in original.children.iter() {
ret.push(RenderPlainListItem::new( ret.push(RenderPlainListItem::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

8
src/context/plain_list_item.rs
View File

@ -29,8 +29,8 @@ impl RenderPlainListItem {
for obj in original.tag.iter() { for obj in original.tag.iter() {
ret.push(RenderObject::new( ret.push(RenderObject::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }
@ -42,8 +42,8 @@ impl RenderPlainListItem {
for obj in original.children.iter() { for obj in original.children.iter() {
ret.push(RenderElement::new( ret.push(RenderElement::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

4
src/context/quote_block.rs
View File

@ -27,8 +27,8 @@ impl RenderQuoteBlock {
for obj in original.children.iter() { for obj in original.children.iter() {
ret.push(RenderElement::new( ret.push(RenderElement::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

4
src/context/regular_link.rs
View File

@ -28,8 +28,8 @@ impl RenderRegularLink {
for obj in regular_link.children.iter() { for obj in regular_link.children.iter() {
ret.push(RenderObject::new( ret.push(RenderObject::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

4
src/context/section.rs
View File

@ -27,8 +27,8 @@ impl RenderSection {
for obj in section.children.iter() { for obj in section.children.iter() {
ret.push(RenderElement::new( ret.push(RenderElement::new(
config, config,
&output_directory, output_directory,
&output_file, output_file,
obj, obj,
)?); )?);
} }

16
src/intermediate/angle_link.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IAngleLink, AngleLink);
#[derive(Debug)]
pub(crate) struct IAngleLink {}
impl IAngleLink {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::AngleLink<'parse>,
) -> Result<IAngleLink, CustomError> {
Ok(IAngleLink {})
}
}

319
src/intermediate/ast_node.rs Normal file
View File

@ -0,0 +1,319 @@
use super::angle_link::IAngleLink;
use super::bold::IBold;
use super::citation::ICitation;
use super::citation_reference::ICitationReference;
use super::code::ICode;
use super::comment::IComment;
use super::entity::IEntity;
use super::export_snippet::IExportSnippet;
use super::footnote_reference::IFootnoteReference;
use super::inline_babel_call::IInlineBabelCall;
use super::inline_source_block::IInlineSourceBlock;
use super::italic::IItalic;
use super::keyword::IKeyword;
use super::latex_fragment::ILatexFragment;
use super::line_break::ILineBreak;
use super::org_macro::IOrgMacro;
use super::plain_link::IPlainLink;
use super::plain_text::IPlainText;
use super::radio_link::IRadioLink;
use super::radio_target::IRadioTarget;
use super::registry::Registry;
use super::regular_link::IRegularLink;
use super::statistics_cookie::IStatisticsCookie;
use super::strike_through::IStrikeThrough;
use super::subscript::ISubscript;
use super::superscript::ISuperscript;
use super::IBabelCall;
use super::ICenterBlock;
use super::IClock;
use super::ICommentBlock;
use super::IDiarySexp;
use super::IDrawer;
use super::IDynamicBlock;
use super::IExampleBlock;
use super::IExportBlock;
use super::IFixedWidthArea;
use super::IFootnoteDefinition;
use super::IHeading;
use super::IHorizontalRule;
use super::ILatexEnvironment;
use super::IParagraph;
use super::IPlainList;
use super::IPlanning;
use super::IPropertyDrawer;
use super::IQuoteBlock;
use super::ISection;
use super::ISpecialBlock;
use super::ISrcBlock;
use super::ITable;
use super::ITarget;
use super::ITimestamp;
use super::IUnderline;
use super::IVerbatim;
use super::IVerseBlock;
use super::RefRegistry;
use crate::error::CustomError;
use futures::future::{BoxFuture, FutureExt};
#[derive(Debug, Clone)]
pub(crate) enum IAstNode {
Heading(IHeading),
Section(ISection),
Paragraph(IParagraph),
PlainList(IPlainList),
CenterBlock(ICenterBlock),
QuoteBlock(IQuoteBlock),
SpecialBlock(ISpecialBlock),
DynamicBlock(IDynamicBlock),
FootnoteDefinition(IFootnoteDefinition),
Comment(IComment),
Drawer(IDrawer),
PropertyDrawer(IPropertyDrawer),
Table(ITable),
VerseBlock(IVerseBlock),
CommentBlock(ICommentBlock),
ExampleBlock(IExampleBlock),
ExportBlock(IExportBlock),
SrcBlock(ISrcBlock),
Clock(IClock),
DiarySexp(IDiarySexp),
Planning(IPlanning),
FixedWidthArea(IFixedWidthArea),
HorizontalRule(IHorizontalRule),
Keyword(IKeyword),
BabelCall(IBabelCall),
LatexEnvironment(ILatexEnvironment),
Bold(IBold),
Italic(IItalic),
Underline(IUnderline),
StrikeThrough(IStrikeThrough),
Code(ICode),
Verbatim(IVerbatim),
PlainText(IPlainText),
RegularLink(IRegularLink),
RadioLink(IRadioLink),
RadioTarget(IRadioTarget),
PlainLink(IPlainLink),
AngleLink(IAngleLink),
OrgMacro(IOrgMacro),
Entity(IEntity),
LatexFragment(ILatexFragment),
ExportSnippet(IExportSnippet),
FootnoteReference(IFootnoteReference),
Citation(ICitation),
CitationReference(ICitationReference),
InlineBabelCall(IInlineBabelCall),
InlineSourceBlock(IInlineSourceBlock),
LineBreak(ILineBreak),
Target(ITarget),
StatisticsCookie(IStatisticsCookie),
Subscript(ISubscript),
Superscript(ISuperscript),
Timestamp(ITimestamp),
}
pub(crate) trait IntoIAstNode<'parse> {
fn into_ast_node<'orig>(
&'orig self,
registry: RefRegistry<'orig, 'parse>,
) -> BoxFuture<'orig, Result<IAstNode, CustomError>>;
}
impl<'parse> IntoIAstNode<'parse> for organic::types::DocumentElement<'parse> {
fn into_ast_node<'orig>(
&'orig self,
registry: RefRegistry<'orig, 'parse>,
) -> BoxFuture<'orig, Result<IAstNode, CustomError>> {
async move {
match self {
organic::types::DocumentElement::Heading(inner) => {
Ok(IAstNode::Heading(IHeading::new(registry, inner).await?))
}
organic::types::DocumentElement::Section(inner) => {
Ok(IAstNode::Section(ISection::new(registry, inner).await?))
}
}
}
.boxed()
}
}
impl<'parse> IntoIAstNode<'parse> for organic::types::Element<'parse> {
fn into_ast_node<'orig>(
&'orig self,
registry: RefRegistry<'orig, 'parse>,
) -> BoxFuture<'orig, Result<IAstNode, CustomError>> {
async move {
match self {
organic::types::Element::Paragraph(inner) => {
Ok(IAstNode::Paragraph(IParagraph::new(registry, inner).await?))
}
organic::types::Element::PlainList(inner) => {
Ok(IAstNode::PlainList(IPlainList::new(registry, inner).await?))
}
organic::types::Element::CenterBlock(inner) => Ok(IAstNode::CenterBlock(
ICenterBlock::new(registry, inner).await?,
)),
organic::types::Element::QuoteBlock(inner) => Ok(IAstNode::QuoteBlock(
IQuoteBlock::new(registry, inner).await?,
)),
organic::types::Element::SpecialBlock(inner) => Ok(IAstNode::SpecialBlock(
ISpecialBlock::new(registry, inner).await?,
)),
organic::types::Element::DynamicBlock(inner) => Ok(IAstNode::DynamicBlock(
IDynamicBlock::new(registry, inner).await?,
)),
organic::types::Element::FootnoteDefinition(inner) => Ok(
IAstNode::FootnoteDefinition(IFootnoteDefinition::new(registry, inner).await?),
),
organic::types::Element::Comment(inner) => {
Ok(IAstNode::Comment(IComment::new(registry, inner).await?))
}
organic::types::Element::Drawer(inner) => {
Ok(IAstNode::Drawer(IDrawer::new(registry, inner).await?))
}
organic::types::Element::PropertyDrawer(inner) => Ok(IAstNode::PropertyDrawer(
IPropertyDrawer::new(registry, inner).await?,
)),
organic::types::Element::Table(inner) => {
Ok(IAstNode::Table(ITable::new(registry, inner).await?))
}
organic::types::Element::VerseBlock(inner) => Ok(IAstNode::VerseBlock(
IVerseBlock::new(registry, inner).await?,
)),
organic::types::Element::CommentBlock(inner) => Ok(IAstNode::CommentBlock(
ICommentBlock::new(registry, inner).await?,
)),
organic::types::Element::ExampleBlock(inner) => Ok(IAstNode::ExampleBlock(
IExampleBlock::new(registry, inner).await?,
)),
organic::types::Element::ExportBlock(inner) => Ok(IAstNode::ExportBlock(
IExportBlock::new(registry, inner).await?,
)),
organic::types::Element::SrcBlock(inner) => {
Ok(IAstNode::SrcBlock(ISrcBlock::new(registry, inner).await?))
}
organic::types::Element::Clock(inner) => {
Ok(IAstNode::Clock(IClock::new(registry, inner).await?))
}
organic::types::Element::DiarySexp(inner) => {
Ok(IAstNode::DiarySexp(IDiarySexp::new(registry, inner).await?))
}
organic::types::Element::Planning(inner) => {
Ok(IAstNode::Planning(IPlanning::new(registry, inner).await?))
}
organic::types::Element::FixedWidthArea(inner) => Ok(IAstNode::FixedWidthArea(
IFixedWidthArea::new(registry, inner).await?,
)),
organic::types::Element::HorizontalRule(inner) => Ok(IAstNode::HorizontalRule(
IHorizontalRule::new(registry, inner).await?,
)),
organic::types::Element::Keyword(inner) => {
Ok(IAstNode::Keyword(IKeyword::new(registry, inner).await?))
}
organic::types::Element::BabelCall(inner) => {
Ok(IAstNode::BabelCall(IBabelCall::new(registry, inner).await?))
}
organic::types::Element::LatexEnvironment(inner) => Ok(IAstNode::LatexEnvironment(
ILatexEnvironment::new(registry, inner).await?,
)),
}
}
.boxed()
}
}
impl<'parse> IntoIAstNode<'parse> for organic::types::Object<'parse> {
fn into_ast_node<'orig>(
&'orig self,
registry: RefRegistry<'orig, 'parse>,
) -> BoxFuture<'orig, Result<IAstNode, CustomError>> {
async move {
match self {
organic::types::Object::Bold(inner) => {
Ok(IAstNode::Bold(IBold::new(registry, inner).await?))
}
organic::types::Object::Italic(inner) => {
Ok(IAstNode::Italic(IItalic::new(registry, inner).await?))
}
organic::types::Object::Underline(inner) => {
Ok(IAstNode::Underline(IUnderline::new(registry, inner).await?))
}
organic::types::Object::StrikeThrough(inner) => Ok(IAstNode::StrikeThrough(
IStrikeThrough::new(registry, inner).await?,
)),
organic::types::Object::Code(inner) => {
Ok(IAstNode::Code(ICode::new(registry, inner).await?))
}
organic::types::Object::Verbatim(inner) => {
Ok(IAstNode::Verbatim(IVerbatim::new(registry, inner).await?))
}
organic::types::Object::PlainText(inner) => {
Ok(IAstNode::PlainText(IPlainText::new(registry, inner).await?))
}
organic::types::Object::RegularLink(inner) => Ok(IAstNode::RegularLink(
IRegularLink::new(registry, inner).await?,
)),
organic::types::Object::RadioLink(inner) => {
Ok(IAstNode::RadioLink(IRadioLink::new(registry, inner).await?))
}
organic::types::Object::RadioTarget(inner) => Ok(IAstNode::RadioTarget(
IRadioTarget::new(registry, inner).await?,
)),
organic::types::Object::PlainLink(inner) => {
Ok(IAstNode::PlainLink(IPlainLink::new(registry, inner).await?))
}
organic::types::Object::AngleLink(inner) => {
Ok(IAstNode::AngleLink(IAngleLink::new(registry, inner).await?))
}
organic::types::Object::OrgMacro(inner) => {
Ok(IAstNode::OrgMacro(IOrgMacro::new(registry, inner).await?))
}
organic::types::Object::Entity(inner) => {
Ok(IAstNode::Entity(IEntity::new(registry, inner).await?))
}
organic::types::Object::LatexFragment(inner) => Ok(IAstNode::LatexFragment(
ILatexFragment::new(registry, inner).await?,
)),
organic::types::Object::ExportSnippet(inner) => Ok(IAstNode::ExportSnippet(
IExportSnippet::new(registry, inner).await?,
)),
organic::types::Object::FootnoteReference(inner) => Ok(
IAstNode::FootnoteReference(IFootnoteReference::new(registry, inner).await?),
),
organic::types::Object::Citation(inner) => {
Ok(IAstNode::Citation(ICitation::new(registry, inner).await?))
}
organic::types::Object::CitationReference(inner) => Ok(
IAstNode::CitationReference(ICitationReference::new(registry, inner).await?),
),
organic::types::Object::InlineBabelCall(inner) => Ok(IAstNode::InlineBabelCall(
IInlineBabelCall::new(registry, inner).await?,
)),
organic::types::Object::InlineSourceBlock(inner) => Ok(
IAstNode::InlineSourceBlock(IInlineSourceBlock::new(registry, inner).await?),
),
organic::types::Object::LineBreak(inner) => {
Ok(IAstNode::LineBreak(ILineBreak::new(registry, inner).await?))
}
organic::types::Object::Target(inner) => {
Ok(IAstNode::Target(ITarget::new(registry, inner).await?))
}
organic::types::Object::StatisticsCookie(inner) => Ok(IAstNode::StatisticsCookie(
IStatisticsCookie::new(registry, inner).await?,
)),
organic::types::Object::Subscript(inner) => {
Ok(IAstNode::Subscript(ISubscript::new(registry, inner).await?))
}
organic::types::Object::Superscript(inner) => Ok(IAstNode::Superscript(
ISuperscript::new(registry, inner).await?,
)),
organic::types::Object::Timestamp(inner) => {
Ok(IAstNode::Timestamp(ITimestamp::new(registry, inner).await?))
}
}
}
.boxed()
}
}

16
src/intermediate/babel_call.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IBabelCall, BabelCall);
#[derive(Debug)]
pub(crate) struct IBabelCall {}
impl IBabelCall {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::BabelCall<'parse>,
) -> Result<IBabelCall, CustomError> {
Ok(IBabelCall {})
}
}

16
src/intermediate/bold.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IBold, Bold);
#[derive(Debug)]
pub(crate) struct IBold {}
impl IBold {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Bold<'parse>,
) -> Result<IBold, CustomError> {
Ok(IBold {})
}
}

16
src/intermediate/center_block.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ICenterBlock, CenterBlock);
#[derive(Debug)]
pub(crate) struct ICenterBlock {}
impl ICenterBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::CenterBlock<'parse>,
) -> Result<ICenterBlock, CustomError> {
Ok(ICenterBlock {})
}
}

16
src/intermediate/citation.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ICitation, Citation);
#[derive(Debug)]
pub(crate) struct ICitation {}
impl ICitation {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Citation<'parse>,
) -> Result<ICitation, CustomError> {
Ok(ICitation {})
}
}

16
src/intermediate/citation_reference.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ICitationReference, CitationReference);
#[derive(Debug)]
pub(crate) struct ICitationReference {}
impl ICitationReference {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::CitationReference<'parse>,
) -> Result<ICitationReference, CustomError> {
Ok(ICitationReference {})
}
}

16
src/intermediate/clock.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IClock, Clock);
#[derive(Debug)]
pub(crate) struct IClock {}
impl IClock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Clock<'parse>,
) -> Result<IClock, CustomError> {
Ok(IClock {})
}
}

16
src/intermediate/code.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ICode, Code);
#[derive(Debug)]
pub(crate) struct ICode {}
impl ICode {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Code<'parse>,
) -> Result<ICode, CustomError> {
Ok(ICode {})
}
}

17
src/intermediate/comment.rs
View File

@ -1,16 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IComment, Comment);
/// Essentially a no-op since the comment is not rendered.
#[derive(Debug)]
pub(crate) struct IComment {}
impl IComment {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
comment: &organic::types::Comment<'parse>,
) -> Result<IComment, CustomError> {
Ok(IComment {})
}
}

16
src/intermediate/comment_block.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ICommentBlock, CommentBlock);
#[derive(Debug)]
pub(crate) struct ICommentBlock {}
impl ICommentBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::CommentBlock<'parse>,
) -> Result<ICommentBlock, CustomError> {
Ok(ICommentBlock {})
}
}

17
src/intermediate/convert.rs
View File

@ -6,6 +6,7 @@ use crate::config::Config;
use crate::context::GlobalSettings; use crate::context::GlobalSettings;
use crate::context::RenderBlogPostPage; use crate::context::RenderBlogPostPage;
use crate::context::RenderDocumentElement; use crate::context::RenderDocumentElement;
use crate::context::RenderRealFootnoteDefinition;
use crate::error::CustomError; use crate::error::CustomError;
use super::BlogPost; use super::BlogPost;
@ -55,11 +56,27 @@ pub(crate) fn convert_blog_post_page_to_render_context<D: AsRef<Path>, F: AsRef<
children 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( let ret = RenderBlogPostPage::new(
global_settings, global_settings,
page.title.clone(), page.title.clone(),
Some(link_to_blog_post), Some(link_to_blog_post),
children, children,
footnotes,
); );
Ok(ret) Ok(ret)
} }

37
src/intermediate/definition.rs
View File

@ -1,5 +1,7 @@
use std::path::Path; use std::path::Path;
use std::path::PathBuf; use std::path::PathBuf;
use std::sync::Arc;
use std::sync::Mutex;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
use walkdir::WalkDir; use walkdir::WalkDir;
@ -43,31 +45,26 @@ impl BlogPost {
ret ret
}; };
let mut registry = Registry::new();
// Assign IDs to the targets
for (_real_path, _contents, parsed_document) in parsed_org_files.iter() {
organic::types::AstNode::from(parsed_document)
.iter_all_ast_nodes()
.for_each(|node| match node {
organic::types::AstNode::Target(target) => {
registry.get_target(target.value);
}
_ => {}
});
}
let pages = { let pages = {
let mut ret = Vec::new(); let mut ret = Vec::new();
for (real_path, _contents, parsed_document) in parsed_org_files.iter() { for (real_path, _contents, parsed_document) in parsed_org_files.iter() {
let mut registry = Registry::new();
// Assign IDs to the targets
organic::types::AstNode::from(parsed_document)
.iter_all_ast_nodes()
.for_each(|node| match node {
organic::types::AstNode::Target(target) => {
registry.get_target(target.value);
}
_ => {}
});
let registry = Arc::new(Mutex::new(registry));
let relative_to_post_dir_path = real_path.strip_prefix(post_dir)?; let relative_to_post_dir_path = real_path.strip_prefix(post_dir)?;
ret.push( ret.push(
BlogPostPage::new( BlogPostPage::new(relative_to_post_dir_path, registry, parsed_document)
relative_to_post_dir_path, .await?,
&mut registry,
parsed_document,
)
.await?,
); );
} }
ret ret

16
src/intermediate/diary_sexp.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IDiarySexp, DiarySexp);
#[derive(Debug)]
pub(crate) struct IDiarySexp {}
impl IDiarySexp {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::DiarySexp<'parse>,
) -> Result<IDiarySexp, CustomError> {
Ok(IDiarySexp {})
}
}

41
src/intermediate/document_element.rs
View File

@ -1,31 +1,30 @@
use crate::error::CustomError; use super::macros::iitem;
use super::macros::iselector;
use super::registry::Registry; use super::registry::Registry;
use super::IHeading; use super::IHeading;
use super::ISection; use super::ISection;
use crate::error::CustomError;
use futures::future::{BoxFuture, FutureExt}; use futures::future::{BoxFuture, FutureExt};
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) enum IDocumentElement { pub(crate) enum IDocumentElement {
Heading(IHeading), Heading(IHeading),
Section(ISection), Section(ISection),
} }
impl IDocumentElement { iselector!(IDocumentElement, DocumentElement, original, registry, {
pub(crate) fn new<'parse, 'b>( iitem!(
registry: &'b mut Registry<'parse>, registry,
original: &'b organic::types::DocumentElement<'parse>, original,
) -> BoxFuture<'b, Result<IDocumentElement, CustomError>> { (
async move { organic::types::DocumentElement::Heading,
match original { IDocumentElement::Heading,
organic::types::DocumentElement::Heading(inner) => Ok(IDocumentElement::Heading( IHeading
IHeading::new(registry, inner).await?, ),
)), (
organic::types::DocumentElement::Section(inner) => Ok(IDocumentElement::Section( organic::types::DocumentElement::Section,
ISection::new(registry, inner).await?, IDocumentElement::Section,
)), ISection
} ),
} )
.boxed() });
}
}

16
src/intermediate/drawer.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IDrawer, Drawer);
#[derive(Debug)]
pub(crate) struct IDrawer {}
impl IDrawer {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Drawer<'parse>,
) -> Result<IDrawer, CustomError> {
Ok(IDrawer {})
}
}

16
src/intermediate/dynamic_block.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IDynamicBlock, DynamicBlock);
#[derive(Debug)]
pub(crate) struct IDynamicBlock {}
impl IDynamicBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::DynamicBlock<'parse>,
) -> Result<IDynamicBlock, CustomError> {
Ok(IDynamicBlock {})
}
}

205
src/intermediate/element.rs
View File

@ -1,7 +1,6 @@
use crate::error::CustomError;
use super::comment::IComment; use super::comment::IComment;
use super::keyword::IKeyword; use super::keyword::IKeyword;
use super::macros::iselector;
use super::registry::Registry; use super::registry::Registry;
use super::IBabelCall; use super::IBabelCall;
use super::ICenterBlock; use super::ICenterBlock;
@ -25,9 +24,11 @@ use super::ISpecialBlock;
use super::ISrcBlock; use super::ISrcBlock;
use super::ITable; use super::ITable;
use super::IVerseBlock; use super::IVerseBlock;
use crate::error::CustomError;
use crate::intermediate::macros::iitem;
use futures::future::{BoxFuture, FutureExt}; use futures::future::{BoxFuture, FutureExt};
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) enum IElement { pub(crate) enum IElement {
Paragraph(IParagraph), Paragraph(IParagraph),
PlainList(IPlainList), PlainList(IPlainList),
@ -55,87 +56,117 @@ pub(crate) enum IElement {
LatexEnvironment(ILatexEnvironment), LatexEnvironment(ILatexEnvironment),
} }
impl IElement { iselector!(IElement, Element, original, registry, {
pub(crate) fn new<'parse, 'b>( iitem!(
registry: &'b mut Registry<'parse>, registry,
elem: &'b organic::types::Element<'parse>, original,
) -> BoxFuture<'b, Result<IElement, CustomError>> { (
async move { organic::types::Element::Paragraph,
match elem { IElement::Paragraph,
organic::types::Element::Paragraph(inner) => { IParagraph
Ok(IElement::Paragraph(IParagraph::new(registry, inner).await?)) ),
} (
organic::types::Element::PlainList(inner) => { organic::types::Element::PlainList,
Ok(IElement::PlainList(IPlainList::new(registry, inner).await?)) IElement::PlainList,
} IPlainList
organic::types::Element::CenterBlock(inner) => Ok(IElement::CenterBlock( ),
ICenterBlock::new(registry, inner).await?, (
)), organic::types::Element::CenterBlock,
organic::types::Element::QuoteBlock(inner) => Ok(IElement::QuoteBlock( IElement::CenterBlock,
IQuoteBlock::new(registry, inner).await?, ICenterBlock
)), ),
organic::types::Element::SpecialBlock(inner) => Ok(IElement::SpecialBlock( (
ISpecialBlock::new(registry, inner).await?, organic::types::Element::QuoteBlock,
)), IElement::QuoteBlock,
organic::types::Element::DynamicBlock(inner) => Ok(IElement::DynamicBlock( IQuoteBlock
IDynamicBlock::new(registry, inner).await?, ),
)), (
organic::types::Element::FootnoteDefinition(inner) => Ok( organic::types::Element::SpecialBlock,
IElement::FootnoteDefinition(IFootnoteDefinition::new(registry, inner).await?), IElement::SpecialBlock,
), ISpecialBlock
organic::types::Element::Comment(inner) => { ),
Ok(IElement::Comment(IComment::new(registry, inner).await?)) (
} organic::types::Element::DynamicBlock,
organic::types::Element::Drawer(inner) => { IElement::DynamicBlock,
Ok(IElement::Drawer(IDrawer::new(registry, inner).await?)) IDynamicBlock
} ),
organic::types::Element::PropertyDrawer(inner) => Ok(IElement::PropertyDrawer( (
IPropertyDrawer::new(registry, inner).await?, organic::types::Element::FootnoteDefinition,
)), IElement::FootnoteDefinition,
organic::types::Element::Table(inner) => { IFootnoteDefinition
Ok(IElement::Table(ITable::new(registry, inner).await?)) ),
} (
organic::types::Element::VerseBlock(inner) => Ok(IElement::VerseBlock( organic::types::Element::Comment,
IVerseBlock::new(registry, inner).await?, IElement::Comment,
)), IComment
organic::types::Element::CommentBlock(inner) => Ok(IElement::CommentBlock( ),
ICommentBlock::new(registry, inner).await?, (organic::types::Element::Drawer, IElement::Drawer, IDrawer),
)), (
organic::types::Element::ExampleBlock(inner) => Ok(IElement::ExampleBlock( organic::types::Element::PropertyDrawer,
IExampleBlock::new(registry, inner).await?, IElement::PropertyDrawer,
)), IPropertyDrawer
organic::types::Element::ExportBlock(inner) => Ok(IElement::ExportBlock( ),
IExportBlock::new(registry, inner).await?, (organic::types::Element::Table, IElement::Table, ITable),
)), (
organic::types::Element::SrcBlock(inner) => { organic::types::Element::VerseBlock,
Ok(IElement::SrcBlock(ISrcBlock::new(registry, inner).await?)) IElement::VerseBlock,
} IVerseBlock
organic::types::Element::Clock(inner) => { ),
Ok(IElement::Clock(IClock::new(registry, inner).await?)) (
} organic::types::Element::CommentBlock,
organic::types::Element::DiarySexp(inner) => { IElement::CommentBlock,
Ok(IElement::DiarySexp(IDiarySexp::new(registry, inner).await?)) ICommentBlock
} ),
organic::types::Element::Planning(inner) => { (
Ok(IElement::Planning(IPlanning::new(registry, inner).await?)) organic::types::Element::ExampleBlock,
} IElement::ExampleBlock,
organic::types::Element::FixedWidthArea(inner) => Ok(IElement::FixedWidthArea( IExampleBlock
IFixedWidthArea::new(registry, inner).await?, ),
)), (
organic::types::Element::HorizontalRule(inner) => Ok(IElement::HorizontalRule( organic::types::Element::ExportBlock,
IHorizontalRule::new(registry, inner).await?, IElement::ExportBlock,
)), IExportBlock
organic::types::Element::Keyword(inner) => { ),
Ok(IElement::Keyword(IKeyword::new(registry, inner).await?)) (
} organic::types::Element::SrcBlock,
organic::types::Element::BabelCall(inner) => { IElement::SrcBlock,
Ok(IElement::BabelCall(IBabelCall::new(registry, inner).await?)) ISrcBlock
} ),
organic::types::Element::LatexEnvironment(inner) => Ok(IElement::LatexEnvironment( (organic::types::Element::Clock, IElement::Clock, IClock),
ILatexEnvironment::new(registry, inner).await?, (
)), organic::types::Element::DiarySexp,
} IElement::DiarySexp,
} IDiarySexp
.boxed() ),
} (
} organic::types::Element::Planning,
IElement::Planning,
IPlanning
),
(
organic::types::Element::FixedWidthArea,
IElement::FixedWidthArea,
IFixedWidthArea
),
(
organic::types::Element::HorizontalRule,
IElement::HorizontalRule,
IHorizontalRule
),
(
organic::types::Element::Keyword,
IElement::Keyword,
IKeyword
),
(
organic::types::Element::BabelCall,
IElement::BabelCall,
IBabelCall
),
(
organic::types::Element::LatexEnvironment,
IElement::LatexEnvironment,
ILatexEnvironment
),
)
});

21
src/intermediate/entity.rs
View File

@ -1,19 +1,14 @@
use super::macros::intermediate;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; #[derive(Debug, Clone)]
#[derive(Debug)]
pub(crate) struct IEntity { pub(crate) struct IEntity {
pub(crate) html: String, pub(crate) html: String,
} }
impl IEntity { intermediate!(IEntity, Entity, original, registry, {
pub(crate) async fn new<'parse>( Ok(IEntity {
registry: &mut Registry<'parse>, html: original.html.to_owned(),
original: &organic::types::Entity<'parse>, })
) -> Result<IEntity, CustomError> { });
Ok(IEntity {
html: original.html.to_owned(),
})
}
}

16
src/intermediate/example_block.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IExampleBlock, ExampleBlock);
#[derive(Debug)]
pub(crate) struct IExampleBlock {}
impl IExampleBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::ExampleBlock<'parse>,
) -> Result<IExampleBlock, CustomError> {
Ok(IExampleBlock {})
}
}

16
src/intermediate/export_block.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IExportBlock, ExportBlock);
#[derive(Debug)]
pub(crate) struct IExportBlock {}
impl IExportBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::ExportBlock<'parse>,
) -> Result<IExportBlock, CustomError> {
Ok(IExportBlock {})
}
}

16
src/intermediate/export_snippet.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IExportSnippet, ExportSnippet);
#[derive(Debug)]
pub(crate) struct IExportSnippet {}
impl IExportSnippet {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::ExportSnippet<'parse>,
) -> Result<IExportSnippet, CustomError> {
Ok(IExportSnippet {})
}
}

16
src/intermediate/fixed_width_area.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IFixedWidthArea, FixedWidthArea);
#[derive(Debug)]
pub(crate) struct IFixedWidthArea {}
impl IFixedWidthArea {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::FixedWidthArea<'parse>,
) -> Result<IFixedWidthArea, CustomError> {
Ok(IFixedWidthArea {})
}
}

58
src/intermediate/footnote_definition.rs
View File

@ -1,15 +1,57 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::register_footnote_definition;
use super::registry::Registry; use super::registry::Registry;
use super::IAstNode;
use crate::error::CustomError;
use crate::intermediate::RefRegistry;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IFootnoteDefinition {} pub(crate) struct IFootnoteDefinition {}
impl IFootnoteDefinition { intermediate!(
pub(crate) async fn new<'parse>( IFootnoteDefinition,
registry: &mut Registry<'parse>, FootnoteDefinition,
original: &organic::types::FootnoteDefinition<'parse>, original,
) -> Result<IFootnoteDefinition, CustomError> { registry,
{
register_footnote_definition(registry, original.label, &original.children).await?;
Ok(IFootnoteDefinition {}) Ok(IFootnoteDefinition {})
} }
);
#[derive(Debug)]
pub(crate) struct IRealFootnoteDefinition {
pub(crate) footnote_id: usize,
pub(crate) contents: Vec<IAstNode>,
}
impl IRealFootnoteDefinition {
pub(crate) async fn new<'orig, 'parse>(
registry: RefRegistry<'orig, 'parse>,
footnote_id: usize,
contents: Vec<IAstNode>,
) -> Result<IRealFootnoteDefinition, CustomError> {
Ok(IRealFootnoteDefinition {
footnote_id,
contents,
})
}
pub(crate) fn get_display_label(&self) -> String {
format!("{}", self.footnote_id + 1)
}
/// Get an ID to refer to the first reference to this footnote definition.
///
/// This ID could, for example, be used for the id attribute in HTML for the reference anchor tag.
pub(crate) fn get_reference_id(&self) -> String {
format!("fnr.{}", self.get_display_label())
}
/// Get an ID to refer to the footnote definition.
///
/// This ID could, for example, be used for the id attribute in HTML for the definition anchor tag.
pub(crate) fn get_definition_id(&self) -> String {
format!("fn.{}", self.get_display_label())
}
} }

46
src/intermediate/footnote_reference.rs
View File

@ -1,15 +1,45 @@
use super::macros::intermediate;
use super::registry::get_footnote_reference_id;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; #[derive(Debug, Clone)]
pub(crate) struct IFootnoteReference {
footnote_id: usize,
duplicate_offset: usize,
}
#[derive(Debug)] intermediate!(IFootnoteReference, FootnoteReference, original, registry, {
pub(crate) struct IFootnoteReference {} let (footnote_id, reference_count) =
get_footnote_reference_id(registry, original.label, &original.definition).await?;
Ok(IFootnoteReference {
footnote_id,
duplicate_offset: reference_count,
})
});
impl IFootnoteReference { impl IFootnoteReference {
pub(crate) async fn new<'parse>( pub(crate) fn get_display_label(&self) -> String {
registry: &mut Registry<'parse>, format!("{}", self.footnote_id + 1)
original: &organic::types::FootnoteReference<'parse>, }
) -> Result<IFootnoteReference, CustomError> {
Ok(IFootnoteReference {}) /// Get an ID to refer to this footnote reference.
///
/// This ID could, for example, be used for the id attribute in HTML for the reference anchor tag.
pub(crate) fn get_reference_id(&self) -> String {
if self.duplicate_offset == 0 {
format!("fnr.{}", self.get_display_label())
} else {
// Org-mode makes all duplicates use "100" but I figure there is no harm in giving each a unique ID.
let append = 100 + self.duplicate_offset - 1;
format!("fnr.{}.{}", self.get_display_label(), append)
}
}
/// Get an ID to refer to the footnote definition this footnote reference references.
///
/// This ID could, for example, be used for the id attribute in HTML for the definition anchor tag.
pub(crate) fn get_definition_id(&self) -> String {
format!("fn.{}", self.get_display_label())
} }
} }

53
src/intermediate/heading.rs
View File

@ -1,39 +1,34 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IDocumentElement; use super::IDocumentElement;
use super::IObject; use super::IObject;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IHeading { pub(crate) struct IHeading {
pub(crate) level: organic::types::HeadlineLevel, pub(crate) level: organic::types::HeadlineLevel,
pub(crate) title: Vec<IObject>, pub(crate) title: Vec<IObject>,
pub(crate) children: Vec<IDocumentElement>, pub(crate) children: Vec<IDocumentElement>,
} }
impl IHeading { intermediate!(IHeading, Heading, original, registry, {
pub(crate) async fn new<'parse>( let title = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
heading: &organic::types::Heading<'parse>, for obj in original.title.iter() {
) -> Result<IHeading, CustomError> { ret.push(IObject::new(registry.clone(), obj).await?);
let title = { }
let mut ret = Vec::new(); ret
for obj in heading.title.iter() { };
ret.push(IObject::new(registry, obj).await?); let children = {
} let mut ret = Vec::new();
ret for obj in original.children.iter() {
}; ret.push(IDocumentElement::new(registry.clone(), obj).await?);
let children = { }
let mut ret = Vec::new(); ret
for obj in heading.children.iter() { };
ret.push(IDocumentElement::new(registry, obj).await?); Ok(IHeading {
} title,
ret level: original.level,
}; children,
Ok(IHeading { })
title, });
level: heading.level,
children,
})
}
}

16
src/intermediate/horizontal_rule.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IHorizontalRule, HorizontalRule);
#[derive(Debug)]
pub(crate) struct IHorizontalRule {}
impl IHorizontalRule {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::HorizontalRule<'parse>,
) -> Result<IHorizontalRule, CustomError> {
Ok(IHorizontalRule {})
}
}

16
src/intermediate/inline_babel_call.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IInlineBabelCall, InlineBabelCall);
#[derive(Debug)]
pub(crate) struct IInlineBabelCall {}
impl IInlineBabelCall {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::InlineBabelCall<'parse>,
) -> Result<IInlineBabelCall, CustomError> {
Ok(IInlineBabelCall {})
}
}

21
src/intermediate/inline_source_block.rs
View File

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

16
src/intermediate/italic.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IItalic, Italic);
#[derive(Debug)]
pub(crate) struct IItalic {}
impl IItalic {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Italic<'parse>,
) -> Result<IItalic, CustomError> {
Ok(IItalic {})
}
}

17
src/intermediate/keyword.rs
View File

@ -1,16 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IKeyword, Keyword);
/// Essentially a no-op since the keyword is not rendered and any relevant impact on other elements is pulled from the parsed form of keyword.
#[derive(Debug)]
pub(crate) struct IKeyword {}
impl IKeyword {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
keyword: &organic::types::Keyword<'parse>,
) -> Result<IKeyword, CustomError> {
Ok(IKeyword {})
}
}

16
src/intermediate/latex_environment.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ILatexEnvironment, LatexEnvironment);
#[derive(Debug)]
pub(crate) struct ILatexEnvironment {}
impl ILatexEnvironment {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::LatexEnvironment<'parse>,
) -> Result<ILatexEnvironment, CustomError> {
Ok(ILatexEnvironment {})
}
}

16
src/intermediate/latex_fragment.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ILatexFragment, LatexFragment);
#[derive(Debug)]
pub(crate) struct ILatexFragment {}
impl ILatexFragment {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::LatexFragment<'parse>,
) -> Result<ILatexFragment, CustomError> {
Ok(ILatexFragment {})
}
}

16
src/intermediate/line_break.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ILineBreak, LineBreak);
#[derive(Debug)]
pub(crate) struct ILineBreak {}
impl ILineBreak {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::LineBreak<'parse>,
) -> Result<ILineBreak, CustomError> {
Ok(ILineBreak {})
}
}

74
src/intermediate/macros.rs Normal file
View File

@ -0,0 +1,74 @@
/// Write the implementation for the intermediate ast node for a type that is a noop or is not yet implemented.
///
/// This exists to make changing the type signature easier.
macro_rules! inoop {
($istruct:ident, $pstruct:ident) => {
#[derive(Debug, Clone)]
pub(crate) struct $istruct {}
impl $istruct {
pub(crate) async fn new<'reg, 'orig, 'parse>(
registry: crate::intermediate::RefRegistry<'orig, 'parse>,
original: &'orig organic::types::$pstruct<'parse>,
) -> Result<$istruct, CustomError> {
Ok($istruct {})
}
}
};
}
pub(crate) use inoop;
/// Write the implementation for the intermediate ast node.
///
/// This exists to make changing the type signature easier.
macro_rules! intermediate {
($istruct:ident, $pstruct:ident, $original:ident, $registry:ident, $fnbody:tt) => {
impl $istruct {
pub(crate) async fn new<'orig, 'parse>(
registry: crate::intermediate::RefRegistry<'orig, 'parse>,
original: &'orig organic::types::$pstruct<'parse>,
) -> Result<$istruct, CustomError> {
let $original = original;
let $registry = registry;
$fnbody
}
}
};
}
pub(crate) use intermediate;
/// Write the implementation for the intermediate ast node.
///
/// This exists to make changing the type signature easier.
macro_rules! iselector {
($istruct:ident, $pstruct:ident, $original:ident, $registry:ident, $fnbody:tt) => {
impl $istruct {
pub(crate) fn new<'orig, 'parse>(
registry: crate::intermediate::RefRegistry<'orig, 'parse>,
original: &'orig organic::types::$pstruct<'parse>,
) -> BoxFuture<'orig, Result<$istruct, CustomError>> {
let $registry = registry;
let $original = original;
async move { $fnbody }.boxed()
}
}
};
}
pub(crate) use iselector;
macro_rules! iitem {
($registry:expr, $original:expr, $(($penum:path, $ienum:path, $istruct:ident),)*) => {
match $original {
$(
$penum(inner) => Ok($ienum(
$istruct::new($registry.clone(), inner).await?,
)),
)*
}
};
}
pub(crate) use iitem;

7
src/intermediate/mod.rs
View File

@ -1,4 +1,5 @@
mod angle_link; mod angle_link;
mod ast_node;
mod babel_call; mod babel_call;
mod bold; mod bold;
mod center_block; mod center_block;
@ -31,6 +32,7 @@ mod keyword;
mod latex_environment; mod latex_environment;
mod latex_fragment; mod latex_fragment;
mod line_break; mod line_break;
mod macros;
mod object; mod object;
mod org_macro; mod org_macro;
mod page; mod page;
@ -61,6 +63,7 @@ mod util;
mod verbatim; mod verbatim;
mod verse_block; mod verse_block;
pub(crate) use angle_link::IAngleLink; pub(crate) use angle_link::IAngleLink;
pub(crate) use ast_node::IAstNode;
pub(crate) use babel_call::IBabelCall; pub(crate) use babel_call::IBabelCall;
pub(crate) use bold::IBold; pub(crate) use bold::IBold;
pub(crate) use center_block::ICenterBlock; pub(crate) use center_block::ICenterBlock;
@ -83,6 +86,7 @@ pub(crate) use export_block::IExportBlock;
pub(crate) use export_snippet::IExportSnippet; pub(crate) use export_snippet::IExportSnippet;
pub(crate) use fixed_width_area::IFixedWidthArea; pub(crate) use fixed_width_area::IFixedWidthArea;
pub(crate) use footnote_definition::IFootnoteDefinition; pub(crate) use footnote_definition::IFootnoteDefinition;
pub(crate) use footnote_definition::IRealFootnoteDefinition;
pub(crate) use footnote_reference::IFootnoteReference; pub(crate) use footnote_reference::IFootnoteReference;
pub(crate) use heading::IHeading; pub(crate) use heading::IHeading;
pub(crate) use horizontal_rule::IHorizontalRule; pub(crate) use horizontal_rule::IHorizontalRule;
@ -120,3 +124,6 @@ pub(crate) use timestamp::ITimestamp;
pub(crate) use underline::IUnderline; pub(crate) use underline::IUnderline;
pub(crate) use verbatim::IVerbatim; pub(crate) use verbatim::IVerbatim;
pub(crate) use verse_block::IVerseBlock; pub(crate) use verse_block::IVerseBlock;
pub(crate) type RefRegistry<'orig, 'parse> =
std::sync::Arc<std::sync::Mutex<registry::Registry<'orig, 'parse>>>;

218
src/intermediate/object.rs
View File

@ -1,4 +1,5 @@
use crate::error::CustomError; use crate::error::CustomError;
use crate::intermediate::macros::iitem;
use super::angle_link::IAngleLink; use super::angle_link::IAngleLink;
use super::bold::IBold; use super::bold::IBold;
@ -13,6 +14,7 @@ use super::inline_source_block::IInlineSourceBlock;
use super::italic::IItalic; use super::italic::IItalic;
use super::latex_fragment::ILatexFragment; use super::latex_fragment::ILatexFragment;
use super::line_break::ILineBreak; use super::line_break::ILineBreak;
use super::macros::iselector;
use super::org_macro::IOrgMacro; use super::org_macro::IOrgMacro;
use super::plain_link::IPlainLink; use super::plain_link::IPlainLink;
use super::plain_text::IPlainText; use super::plain_text::IPlainText;
@ -30,7 +32,7 @@ use super::verbatim::IVerbatim;
use super::ITarget; use super::ITarget;
use futures::future::{BoxFuture, FutureExt}; use futures::future::{BoxFuture, FutureExt};
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) enum IObject { pub(crate) enum IObject {
Bold(IBold), Bold(IBold),
Italic(IItalic), Italic(IItalic),
@ -61,96 +63,124 @@ pub(crate) enum IObject {
Timestamp(ITimestamp), Timestamp(ITimestamp),
} }
impl IObject { iselector!(IObject, Object, original, registry, {
pub(crate) fn new<'parse, 'b>( iitem!(
registry: &'b mut Registry<'parse>, registry,
obj: &'b organic::types::Object<'parse>, original,
) -> BoxFuture<'b, Result<IObject, CustomError>> { (organic::types::Object::Bold, IObject::Bold, IBold),
async move { (organic::types::Object::Italic, IObject::Italic, IItalic),
match obj { (
organic::types::Object::Bold(inner) => { organic::types::Object::Underline,
Ok(IObject::Bold(IBold::new(registry, inner).await?)) IObject::Underline,
} IUnderline
organic::types::Object::Italic(inner) => { ),
Ok(IObject::Italic(IItalic::new(registry, inner).await?)) (
} organic::types::Object::StrikeThrough,
organic::types::Object::Underline(inner) => { IObject::StrikeThrough,
Ok(IObject::Underline(IUnderline::new(registry, inner).await?)) IStrikeThrough
} ),
organic::types::Object::StrikeThrough(inner) => Ok(IObject::StrikeThrough( (organic::types::Object::Code, IObject::Code, ICode),
IStrikeThrough::new(registry, inner).await?, (
)), organic::types::Object::Verbatim,
organic::types::Object::Code(inner) => { IObject::Verbatim,
Ok(IObject::Code(ICode::new(registry, inner).await?)) IVerbatim
} ),
organic::types::Object::Verbatim(inner) => { (
Ok(IObject::Verbatim(IVerbatim::new(registry, inner).await?)) organic::types::Object::PlainText,
} IObject::PlainText,
organic::types::Object::PlainText(inner) => { IPlainText
Ok(IObject::PlainText(IPlainText::new(registry, inner).await?)) ),
} (
organic::types::Object::RegularLink(inner) => Ok(IObject::RegularLink( organic::types::Object::RegularLink,
IRegularLink::new(registry, inner).await?, IObject::RegularLink,
)), IRegularLink
organic::types::Object::RadioLink(inner) => { ),
Ok(IObject::RadioLink(IRadioLink::new(registry, inner).await?)) (
} organic::types::Object::RadioLink,
organic::types::Object::RadioTarget(inner) => Ok(IObject::RadioTarget( IObject::RadioLink,
IRadioTarget::new(registry, inner).await?, IRadioLink
)), ),
organic::types::Object::PlainLink(inner) => { (
Ok(IObject::PlainLink(IPlainLink::new(registry, inner).await?)) organic::types::Object::RadioTarget,
} IObject::RadioTarget,
organic::types::Object::AngleLink(inner) => { IRadioTarget
Ok(IObject::AngleLink(IAngleLink::new(registry, inner).await?)) ),
} (
organic::types::Object::OrgMacro(inner) => { organic::types::Object::PlainLink,
Ok(IObject::OrgMacro(IOrgMacro::new(registry, inner).await?)) IObject::PlainLink,
} IPlainLink
organic::types::Object::Entity(inner) => { ),
Ok(IObject::Entity(IEntity::new(registry, inner).await?)) (
} organic::types::Object::AngleLink,
organic::types::Object::LatexFragment(inner) => Ok(IObject::LatexFragment( IObject::AngleLink,
ILatexFragment::new(registry, inner).await?, IAngleLink
)), ),
organic::types::Object::ExportSnippet(inner) => Ok(IObject::ExportSnippet( (
IExportSnippet::new(registry, inner).await?, organic::types::Object::OrgMacro,
)), IObject::OrgMacro,
organic::types::Object::FootnoteReference(inner) => Ok(IObject::FootnoteReference( IOrgMacro
IFootnoteReference::new(registry, inner).await?, ),
)), (organic::types::Object::Entity, IObject::Entity, IEntity),
organic::types::Object::Citation(inner) => { (
Ok(IObject::Citation(ICitation::new(registry, inner).await?)) organic::types::Object::LatexFragment,
} IObject::LatexFragment,
organic::types::Object::CitationReference(inner) => Ok(IObject::CitationReference( ILatexFragment
ICitationReference::new(registry, inner).await?, ),
)), (
organic::types::Object::InlineBabelCall(inner) => Ok(IObject::InlineBabelCall( organic::types::Object::ExportSnippet,
IInlineBabelCall::new(registry, inner).await?, IObject::ExportSnippet,
)), IExportSnippet
organic::types::Object::InlineSourceBlock(inner) => Ok(IObject::InlineSourceBlock( ),
IInlineSourceBlock::new(registry, inner).await?, (
)), organic::types::Object::FootnoteReference,
organic::types::Object::LineBreak(inner) => { IObject::FootnoteReference,
Ok(IObject::LineBreak(ILineBreak::new(registry, inner).await?)) IFootnoteReference
} ),
organic::types::Object::Target(inner) => { (
Ok(IObject::Target(ITarget::new(registry, inner).await?)) organic::types::Object::Citation,
} IObject::Citation,
organic::types::Object::StatisticsCookie(inner) => Ok(IObject::StatisticsCookie( ICitation
IStatisticsCookie::new(registry, inner).await?, ),
)), (
organic::types::Object::Subscript(inner) => { organic::types::Object::CitationReference,
Ok(IObject::Subscript(ISubscript::new(registry, inner).await?)) IObject::CitationReference,
} ICitationReference
organic::types::Object::Superscript(inner) => Ok(IObject::Superscript( ),
ISuperscript::new(registry, inner).await?, (
)), organic::types::Object::InlineBabelCall,
organic::types::Object::Timestamp(inner) => { IObject::InlineBabelCall,
Ok(IObject::Timestamp(ITimestamp::new(registry, inner).await?)) IInlineBabelCall
} ),
} (
} organic::types::Object::InlineSourceBlock,
.boxed() IObject::InlineSourceBlock,
} IInlineSourceBlock
} ),
(
organic::types::Object::LineBreak,
IObject::LineBreak,
ILineBreak
),
(organic::types::Object::Target, IObject::Target, ITarget),
(
organic::types::Object::StatisticsCookie,
IObject::StatisticsCookie,
IStatisticsCookie
),
(
organic::types::Object::Subscript,
IObject::Subscript,
ISubscript
),
(
organic::types::Object::Superscript,
IObject::Superscript,
ISuperscript
),
(
organic::types::Object::Timestamp,
IObject::Timestamp,
ITimestamp
),
)
});

16
src/intermediate/org_macro.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IOrgMacro, OrgMacro);
#[derive(Debug)]
pub(crate) struct IOrgMacro {}
impl IOrgMacro {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::OrgMacro<'parse>,
) -> Result<IOrgMacro, CustomError> {
Ok(IOrgMacro {})
}
}

32
src/intermediate/page.rs
View File

@ -2,10 +2,12 @@ use std::path::PathBuf;
use crate::error::CustomError; use crate::error::CustomError;
use super::footnote_definition::IRealFootnoteDefinition;
use super::registry::Registry; use super::registry::Registry;
use super::IDocumentElement; use super::IDocumentElement;
use super::IHeading; use super::IHeading;
use super::ISection; use super::ISection;
use super::RefRegistry;
#[derive(Debug)] #[derive(Debug)]
pub(crate) struct BlogPostPage { pub(crate) struct BlogPostPage {
@ -15,31 +17,51 @@ pub(crate) struct BlogPostPage {
pub(crate) title: Option<String>, pub(crate) title: Option<String>,
pub(crate) children: Vec<IDocumentElement>, pub(crate) children: Vec<IDocumentElement>,
pub(crate) footnotes: Vec<IRealFootnoteDefinition>,
} }
impl BlogPostPage { impl BlogPostPage {
pub(crate) async fn new<'parse, P: Into<PathBuf>>( // TODO: Move path into the registry so I can give this a standard interface like the others.
pub(crate) async fn new<'a, 'b, 'parse, P: Into<PathBuf>>(
path: P, path: P,
registry: &mut Registry<'parse>, registry: RefRegistry<'b, 'parse>,
document: &organic::types::Document<'parse>, document: &'b organic::types::Document<'parse>,
) -> Result<BlogPostPage, CustomError> { ) -> Result<BlogPostPage, CustomError> {
let path = path.into(); let path = path.into();
let mut children = Vec::new(); let mut children = Vec::new();
if let Some(section) = document.zeroth_section.as_ref() { if let Some(section) = document.zeroth_section.as_ref() {
children.push(IDocumentElement::Section( children.push(IDocumentElement::Section(
ISection::new(registry, section).await?, ISection::new(registry.clone(), section).await?,
)); ));
} }
for heading in document.children.iter() { for heading in document.children.iter() {
children.push(IDocumentElement::Heading( children.push(IDocumentElement::Heading(
IHeading::new(registry, heading).await?, IHeading::new(registry.clone(), heading).await?,
)); ));
} }
let footnotes = {
let footnote_definitions: Vec<_> = {
let registry = registry.lock().unwrap();
let ret = registry
.get_footnote_ids()
.map(|(id, def)| (id, def.clone()))
.collect();
ret
};
let mut ret = Vec::new();
for (id, def) in footnote_definitions.into_iter() {
ret.push(IRealFootnoteDefinition::new(registry.clone(), id, def).await?);
}
ret
};
Ok(BlogPostPage { Ok(BlogPostPage {
path, path,
title: get_title(&document), title: get_title(&document),
children, children,
footnotes,
}) })
} }

31
src/intermediate/paragraph.rs
View File

@ -1,26 +1,21 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IObject; use super::IObject;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IParagraph { pub(crate) struct IParagraph {
pub(crate) children: Vec<IObject>, pub(crate) children: Vec<IObject>,
} }
impl IParagraph { intermediate!(IParagraph, Paragraph, original, registry, {
pub(crate) async fn new<'parse>( let children = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
paragraph: &organic::types::Paragraph<'parse>, for obj in original.children.iter() {
) -> Result<IParagraph, CustomError> { ret.push(IObject::new(registry.clone(), obj).await?);
let children = { }
let mut ret = Vec::new(); ret
for obj in paragraph.children.iter() { };
ret.push(IObject::new(registry, obj).await?);
}
ret
};
Ok(IParagraph { children }) Ok(IParagraph { children })
} });
}

16
src/intermediate/plain_link.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IPlainLink, PlainLink);
#[derive(Debug)]
pub(crate) struct IPlainLink {}
impl IPlainLink {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::PlainLink<'parse>,
) -> Result<IPlainLink, CustomError> {
Ok(IPlainLink {})
}
}

37
src/intermediate/plain_list.rs
View File

@ -1,30 +1,25 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IPlainListItem; use super::IPlainListItem;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IPlainList { pub(crate) struct IPlainList {
pub(crate) list_type: organic::types::PlainListType, pub(crate) list_type: organic::types::PlainListType,
pub(crate) children: Vec<IPlainListItem>, pub(crate) children: Vec<IPlainListItem>,
} }
impl IPlainList { intermediate!(IPlainList, PlainList, original, registry, {
pub(crate) async fn new<'parse>( let children = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
plain_list: &organic::types::PlainList<'parse>, for obj in original.children.iter() {
) -> Result<IPlainList, CustomError> { ret.push(IPlainListItem::new(registry.clone(), obj).await?);
let children = { }
let mut ret = Vec::new(); ret
for obj in plain_list.children.iter() { };
ret.push(IPlainListItem::new(registry, obj).await?);
}
ret
};
Ok(IPlainList { Ok(IPlainList {
list_type: plain_list.list_type, list_type: original.list_type,
children, children,
}) })
} });
}

45
src/intermediate/plain_list_item.rs
View File

@ -1,36 +1,31 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IElement; use super::IElement;
use super::IObject; use super::IObject;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IPlainListItem { pub(crate) struct IPlainListItem {
pub(crate) tag: Vec<IObject>, pub(crate) tag: Vec<IObject>,
pub(crate) children: Vec<IElement>, pub(crate) children: Vec<IElement>,
} }
impl IPlainListItem { intermediate!(IPlainListItem, PlainListItem, original, registry, {
pub(crate) async fn new<'parse>( let tag = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
plain_list_item: &organic::types::PlainListItem<'parse>, for obj in original.tag.iter() {
) -> Result<IPlainListItem, CustomError> { ret.push(IObject::new(registry.clone(), obj).await?);
let tag = { }
let mut ret = Vec::new(); ret
for obj in plain_list_item.tag.iter() { };
ret.push(IObject::new(registry, obj).await?);
}
ret
};
let children = { let children = {
let mut ret = Vec::new(); let mut ret = Vec::new();
for elem in plain_list_item.children.iter() { for elem in original.children.iter() {
ret.push(IElement::new(registry, elem).await?); ret.push(IElement::new(registry.clone(), elem).await?);
} }
ret ret
}; };
Ok(IPlainListItem { tag, children }) Ok(IPlainListItem { tag, children })
} });
}

23
src/intermediate/plain_text.rs
View File

@ -1,20 +1,15 @@
use crate::error::CustomError; use super::macros::intermediate;
use crate::intermediate::util::coalesce_whitespace;
use super::registry::Registry; use super::registry::Registry;
use super::util::coalesce_whitespace;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IPlainText { pub(crate) struct IPlainText {
pub(crate) source: String, pub(crate) source: String,
} }
impl IPlainText { intermediate!(IPlainText, PlainText, original, registry, {
pub(crate) async fn new<'parse>( Ok(IPlainText {
registry: &mut Registry<'parse>, source: coalesce_whitespace(original.source).into_owned(),
plain_text: &organic::types::PlainText<'parse>, })
) -> Result<IPlainText, CustomError> { });
Ok(IPlainText {
source: coalesce_whitespace(plain_text.source).into_owned(),
})
}
}

16
src/intermediate/planning.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IPlanning, Planning);
#[derive(Debug)]
pub(crate) struct IPlanning {}
impl IPlanning {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Planning<'parse>,
) -> Result<IPlanning, CustomError> {
Ok(IPlanning {})
}
}

16
src/intermediate/property_drawer.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IPropertyDrawer, PropertyDrawer);
#[derive(Debug)]
pub(crate) struct IPropertyDrawer {}
impl IPropertyDrawer {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::PropertyDrawer<'parse>,
) -> Result<IPropertyDrawer, CustomError> {
Ok(IPropertyDrawer {})
}
}

31
src/intermediate/quote_block.rs
View File

@ -1,26 +1,21 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IElement; use super::IElement;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IQuoteBlock { pub(crate) struct IQuoteBlock {
pub(crate) children: Vec<IElement>, pub(crate) children: Vec<IElement>,
} }
impl IQuoteBlock { intermediate!(IQuoteBlock, QuoteBlock, original, registry, {
pub(crate) async fn new<'parse>( let children = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
original: &organic::types::QuoteBlock<'parse>, for obj in original.children.iter() {
) -> Result<IQuoteBlock, CustomError> { ret.push(IElement::new(registry.clone(), obj).await?);
let children = { }
let mut ret = Vec::new(); ret
for obj in original.children.iter() { };
ret.push(IElement::new(registry, obj).await?);
}
ret
};
Ok(IQuoteBlock { children }) Ok(IQuoteBlock { children })
} });
}

16
src/intermediate/radio_link.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IRadioLink, RadioLink);
#[derive(Debug)]
pub(crate) struct IRadioLink {}
impl IRadioLink {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::RadioLink<'parse>,
) -> Result<IRadioLink, CustomError> {
Ok(IRadioLink {})
}
}

16
src/intermediate/radio_target.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IRadioTarget, RadioTarget);
#[derive(Debug)]
pub(crate) struct IRadioTarget {}
impl IRadioTarget {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::RadioTarget<'parse>,
) -> Result<IRadioTarget, CustomError> {
Ok(IRadioTarget {})
}
}

185
src/intermediate/registry.rs
View File

@ -1,24 +1,201 @@
use crate::error::CustomError;
use organic::types::Element;
use organic::types::Object;
use std::collections::HashMap; use std::collections::HashMap;
use super::ast_node::IAstNode;
use super::ast_node::IntoIAstNode;
use super::RefRegistry;
type IdCounter = u16; type IdCounter = u16;
pub(crate) struct Registry<'parse> { pub(crate) struct Registry<'orig, 'parse> {
id_counter: IdCounter, id_counter: IdCounter,
targets: HashMap<&'parse str, String>, targets: HashMap<&'parse str, String>,
footnote_ids: Vec<(Option<&'parse str>, Vec<IAstNode>)>,
footnote_reference_counts: HashMap<&'parse str, usize>,
on_deck_footnote_ids: HashMap<&'parse str, &'orig Vec<Element<'parse>>>,
} }
impl<'parse> Registry<'parse> { impl<'orig, 'parse> Registry<'orig, 'parse> {
pub(crate) fn new() -> Registry<'parse> { pub(crate) fn new() -> Registry<'orig, 'parse> {
Registry { Registry {
id_counter: 0, id_counter: 0,
targets: HashMap::new(), targets: HashMap::new(),
footnote_ids: Vec::new(),
footnote_reference_counts: HashMap::new(),
on_deck_footnote_ids: HashMap::new(),
} }
} }
pub(crate) fn get_target<'b>(&'b mut self, body: &'parse str) -> &'b String { pub(crate) fn get_target<'reg>(&'reg mut self, body: &'parse str) -> &'reg String {
self.targets.entry(body).or_insert_with(|| { self.targets.entry(body).or_insert_with(|| {
self.id_counter += 1; self.id_counter += 1;
format!("target_{}", self.id_counter) format!("target_{}", self.id_counter)
}) })
} }
pub(crate) fn get_footnote_ids(&self) -> impl Iterator<Item = (usize, &Vec<IAstNode>)> {
self.footnote_ids
.iter()
.map(|(_label, definition)| definition)
.enumerate()
}
}
/// Get a 0-indexed ID for a footnote.
///
/// This needs to be incremented to be 1-indexed for render.
pub(crate) async fn get_footnote_reference_id<'orig, 'parse>(
registry: RefRegistry<'orig, 'parse>,
label: Option<&'parse str>,
definition: &'orig Vec<Object<'parse>>,
) -> Result<(usize, usize), CustomError> {
if let None = label {
// If it has no label then it must always get a new ID.
let contents = convert_reference_contents(registry.clone(), definition).await?;
let pos = {
let mut registry = registry.lock().unwrap();
registry.footnote_ids.push((None, contents));
registry.footnote_ids.len() - 1
};
return Ok((pos, 0));
}
let reference_count = if let Some(label) = label {
promote_footnote_definition(registry.clone(), label).await?;
let mut registry = registry.lock().unwrap();
let reference_count = registry
.footnote_reference_counts
.entry(label)
.and_modify(|count| *count += 1)
.or_insert(0);
*reference_count
} else {
0
};
let existing_index = registry
.lock()
.unwrap()
.footnote_ids
.iter()
.position(|(id, _definition)| *id == label);
if let Some(existing_id) = existing_index {
if !definition.is_empty() {
let contents = convert_reference_contents(registry.clone(), definition).await?;
let mut registry = registry.lock().unwrap();
let entry = registry
.footnote_ids
.get_mut(existing_id)
.expect("If-statement proves this to be Some.");
entry.1 = contents;
}
Ok((existing_id, reference_count))
} else {
let existing_id = {
let mut registry = registry.lock().unwrap();
registry.footnote_ids.push((label, Vec::new()));
registry.footnote_ids.len() - 1
};
let contents = convert_reference_contents(registry.clone(), definition).await?;
{
let mut registry = registry.lock().unwrap();
let entry = registry
.footnote_ids
.get_mut(existing_id)
.expect("If-statement proves this to be Some.");
entry.1 = contents;
}
Ok((existing_id, reference_count))
}
}
/// Update the definition to a footnote but do not mark it as referenced.
pub(crate) async fn register_footnote_definition<'orig, 'parse>(
registry: RefRegistry<'orig, 'parse>,
label: &'parse str,
definition: &'orig Vec<Element<'parse>>,
) -> Result<(), CustomError> {
let has_existing: bool = {
let mut registry = registry.lock().unwrap();
registry
.footnote_ids
.iter_mut()
.any(|(id, _definition)| *id == Some(label))
};
if !has_existing {
let mut registry = registry.lock().unwrap();
registry.on_deck_footnote_ids.insert(label, definition);
return Ok(());
}
let contents = convert_definition_contents(registry.clone(), definition).await?;
let mut registry = registry.lock().unwrap();
if let Some((_existing_id, existing_definition)) = registry
.footnote_ids
.iter_mut()
.find(|(id, _definition)| *id == Some(label))
{
*existing_definition = contents;
}
Ok(())
}
async fn convert_reference_contents<'orig, 'parse>(
registry: RefRegistry<'orig, 'parse>,
contents: &'orig Vec<Object<'parse>>,
) -> Result<Vec<IAstNode>, CustomError> {
let contents = {
let mut ret = Vec::new();
for obj in contents.iter() {
ret.push(obj.into_ast_node(registry.clone()).await?);
}
ret
};
Ok(contents)
}
async fn convert_definition_contents<'orig, 'parse>(
registry: RefRegistry<'orig, 'parse>,
contents: &'orig Vec<Element<'parse>>,
) -> Result<Vec<IAstNode>, CustomError> {
let contents = {
let mut ret = Vec::new();
for obj in contents.iter() {
ret.push(obj.into_ast_node(registry.clone()).await?);
}
ret
};
Ok(contents)
}
/// Take a footnote definition that has not yet received a reference and move it into the active footnotes.
pub(crate) async fn promote_footnote_definition<'orig, 'parse>(
registry: RefRegistry<'orig, 'parse>,
label: &'parse str,
) -> Result<(), CustomError> {
let definition = {
let mut registry = registry.lock().unwrap();
let definition = registry.on_deck_footnote_ids.remove(label);
definition
};
if let Some(elements) = definition {
let existing_id = {
let mut registry = registry.lock().unwrap();
registry.footnote_ids.push((Some(label), Vec::new()));
registry.footnote_ids.len() - 1
};
let contents = convert_definition_contents(registry.clone(), elements).await?;
{
let mut registry = registry.lock().unwrap();
let entry = registry
.footnote_ids
.get_mut(existing_id)
.expect("If-statement proves this to be Some.");
entry.1 = contents;
}
}
Ok(())
} }

37
src/intermediate/regular_link.rs
View File

@ -1,29 +1,24 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IObject; use super::IObject;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct IRegularLink { pub(crate) struct IRegularLink {
pub(crate) raw_link: String, pub(crate) raw_link: String,
pub(crate) children: Vec<IObject>, pub(crate) children: Vec<IObject>,
} }
impl IRegularLink { intermediate!(IRegularLink, RegularLink, original, registry, {
pub(crate) async fn new<'parse>( let children = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
original: &organic::types::RegularLink<'parse>, for obj in original.children.iter() {
) -> Result<IRegularLink, CustomError> { ret.push(IObject::new(registry.clone(), obj).await?);
let children = { }
let mut ret = Vec::new(); ret
for obj in original.children.iter() { };
ret.push(IObject::new(registry, obj).await?); Ok(IRegularLink {
} raw_link: original.get_raw_link().into_owned(),
ret children,
}; })
Ok(IRegularLink { });
raw_link: original.get_raw_link().into_owned(),
children,
})
}
}

31
src/intermediate/section.rs
View File

@ -1,26 +1,21 @@
use crate::error::CustomError; use super::macros::intermediate;
use super::registry::Registry; use super::registry::Registry;
use super::IElement; use super::IElement;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct ISection { pub(crate) struct ISection {
pub(crate) children: Vec<IElement>, pub(crate) children: Vec<IElement>,
} }
impl ISection { intermediate!(ISection, Section, original, registry, {
pub(crate) async fn new<'parse>( let children = {
registry: &mut Registry<'parse>, let mut ret = Vec::new();
section: &organic::types::Section<'parse>, for elem in original.children.iter() {
) -> Result<ISection, CustomError> { ret.push(IElement::new(registry.clone(), elem).await?);
let children = { }
let mut ret = Vec::new(); ret
for elem in section.children.iter() { };
ret.push(IElement::new(registry, elem).await?);
}
ret
};
Ok(ISection { children }) Ok(ISection { children })
} });
}

16
src/intermediate/special_block.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ISpecialBlock, SpecialBlock);
#[derive(Debug)]
pub(crate) struct ISpecialBlock {}
impl ISpecialBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::SpecialBlock<'parse>,
) -> Result<ISpecialBlock, CustomError> {
Ok(ISpecialBlock {})
}
}

27
src/intermediate/src_block.rs
View File

@ -1,22 +1,17 @@
use super::macros::intermediate;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; #[derive(Debug, Clone)]
#[derive(Debug)]
pub(crate) struct ISrcBlock { pub(crate) struct ISrcBlock {
pub(crate) lines: Vec<String>, pub(crate) lines: Vec<String>,
} }
impl ISrcBlock { intermediate!(ISrcBlock, SrcBlock, original, registry, {
pub(crate) async fn new<'parse>( let lines = original
registry: &mut Registry<'parse>, .contents
original: &organic::types::SrcBlock<'parse>, .split_inclusive('\n')
) -> Result<ISrcBlock, CustomError> { .map(|s| s.to_owned())
let lines = original .collect();
.contents Ok(ISrcBlock { lines })
.split_inclusive('\n') });
.map(|s| s.to_owned())
.collect();
Ok(ISrcBlock { lines })
}
}

16
src/intermediate/statistics_cookie.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IStatisticsCookie, StatisticsCookie);
#[derive(Debug)]
pub(crate) struct IStatisticsCookie {}
impl IStatisticsCookie {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::StatisticsCookie<'parse>,
) -> Result<IStatisticsCookie, CustomError> {
Ok(IStatisticsCookie {})
}
}

16
src/intermediate/strike_through.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(IStrikeThrough, StrikeThrough);
#[derive(Debug)]
pub(crate) struct IStrikeThrough {}
impl IStrikeThrough {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::StrikeThrough<'parse>,
) -> Result<IStrikeThrough, CustomError> {
Ok(IStrikeThrough {})
}
}

16
src/intermediate/subscript.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ISubscript, Subscript);
#[derive(Debug)]
pub(crate) struct ISubscript {}
impl ISubscript {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Subscript<'parse>,
) -> Result<ISubscript, CustomError> {
Ok(ISubscript {})
}
}

16
src/intermediate/superscript.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ISuperscript, Superscript);
#[derive(Debug)]
pub(crate) struct ISuperscript {}
impl ISuperscript {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Superscript<'parse>,
) -> Result<ISuperscript, CustomError> {
Ok(ISuperscript {})
}
}

16
src/intermediate/table.rs
View File

@ -1,15 +1,5 @@
use super::macros::inoop;
use super::registry::Registry;
use crate::error::CustomError; use crate::error::CustomError;
use super::registry::Registry; inoop!(ITable, Table);
#[derive(Debug)]
pub(crate) struct ITable {}
impl ITable {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Table<'parse>,
) -> Result<ITable, CustomError> {
Ok(ITable {})
}
}

27
src/intermediate/target.rs
View File

@ -1,23 +1,18 @@
use crate::error::CustomError; use super::macros::intermediate;
use crate::intermediate::util::coalesce_whitespace;
use super::registry::Registry; use super::registry::Registry;
use crate::error::CustomError;
#[derive(Debug)] #[derive(Debug, Clone)]
pub(crate) struct ITarget { pub(crate) struct ITarget {
pub(crate) id: String, pub(crate) id: String,
value: String, value: String,
} }
impl ITarget { intermediate!(ITarget, Target, original, registry, {
pub(crate) async fn new<'parse>( let mut registry = registry.lock().unwrap();
registry: &mut Registry<'parse>, let id = registry.get_target(original.value);
target: &organic::types::Target<'parse>, Ok(ITarget {
) -> Result<ITarget, CustomError> { id: id.clone(),
let id = registry.get_target(target.value); value: original.value.to_owned(),
Ok(ITarget { })
id: id.clone(), });
value: target.value.to_owned(),
})
}
}

13
src/intermediate/timestamp.rs
View File

@ -1,15 +1,6 @@
use crate::error::CustomError; use crate::error::CustomError;
use super::macros::inoop;
use super::registry::Registry; use super::registry::Registry;
#[derive(Debug)] inoop!(ITimestamp, Timestamp);
pub(crate) struct ITimestamp {}
impl ITimestamp {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Timestamp<'parse>,
) -> Result<ITimestamp, CustomError> {
Ok(ITimestamp {})
}
}

13
src/intermediate/underline.rs
View File

@ -1,15 +1,6 @@
use crate::error::CustomError; use crate::error::CustomError;
use super::macros::inoop;
use super::registry::Registry; use super::registry::Registry;
#[derive(Debug)] inoop!(IUnderline, Underline);
pub(crate) struct IUnderline {}
impl IUnderline {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Underline<'parse>,
) -> Result<IUnderline, CustomError> {
Ok(IUnderline {})
}
}

13
src/intermediate/verbatim.rs
View File

@ -1,15 +1,6 @@
use crate::error::CustomError; use crate::error::CustomError;
use super::macros::inoop;
use super::registry::Registry; use super::registry::Registry;
#[derive(Debug)] inoop!(IVerbatim, Verbatim);
pub(crate) struct IVerbatim {}
impl IVerbatim {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::Verbatim<'parse>,
) -> Result<IVerbatim, CustomError> {
Ok(IVerbatim {})
}
}

13
src/intermediate/verse_block.rs
View File

@ -1,15 +1,6 @@
use crate::error::CustomError; use crate::error::CustomError;
use super::macros::inoop;
use super::registry::Registry; use super::registry::Registry;
#[derive(Debug)] inoop!(IVerseBlock, VerseBlock);
pub(crate) struct IVerseBlock {}
impl IVerseBlock {
pub(crate) async fn new<'parse>(
registry: &mut Registry<'parse>,
original: &organic::types::VerseBlock<'parse>,
) -> Result<IVerseBlock, CustomError> {
Ok(IVerseBlock {})
}
}