Add children to heading.

main
Tom Alexander 6 months ago
parent bd982fb62d
commit c279bad13a
Signed by: talexander
GPG Key ID: D3A179C9A53C0EDE

111
Cargo.lock generated

@ -71,6 +71,12 @@ version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
[[package]]
name = "backtrace"
version = "0.3.69"
@ -192,6 +198,95 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7"
[[package]]
name = "futures"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da0290714b38af9b4a7b094b8a37086d1b4e61f2df9122c3cad2577669145335"
dependencies = [
"futures-channel",
"futures-core",
"futures-executor",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-channel"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff4dd66668b557604244583e3e1e1eada8c5c2e96a6d0d6653ede395b78bbacb"
dependencies = [
"futures-core",
"futures-sink",
]
[[package]]
name = "futures-core"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eb1d22c66e66d9d72e1758f0bd7d4fd0bee04cad842ee34587d68c07e45d088c"
[[package]]
name = "futures-executor"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f4fb8693db0cf099eadcca0efe2a5a22e4550f98ed16aba6c48700da29597bc"
dependencies = [
"futures-core",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-io"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8bf34a163b5c4c52d0478a4d757da8fb65cabef42ba90515efee0f6f9fa45aaa"
[[package]]
name = "futures-macro"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53b153fd91e4b0147f4aced87be237c98248656bb01050b96bf3ee89220a8ddb"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "futures-sink"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e36d3378ee38c2a36ad710c5d30c2911d752cb941c00c72dbabfb786a7970817"
[[package]]
name = "futures-task"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "efd193069b0ddadc69c46389b740bbccdd97203899b48d09c5f7969591d6bae2"
[[package]]
name = "futures-util"
version = "0.3.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a19526d624e703a3179b3d322efec918b6246ea0fa51d41124525f00f1cc8104"
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-macro",
"futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
"pin-utils",
"slab",
]
[[package]]
name = "gimli"
version = "0.28.0"
@ -347,6 +442,12 @@ version = "0.2.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "proc-macro2"
version = "1.0.69"
@ -432,6 +533,15 @@ dependencies = [
"serde",
]
[[package]]
name = "slab"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
dependencies = [
"autocfg",
]
[[package]]
name = "static_assertions"
version = "1.1.0"
@ -641,6 +751,7 @@ version = "0.0.1"
dependencies = [
"clap",
"duster",
"futures",
"include_dir",
"organic",
"serde",

@ -8,6 +8,7 @@ edition = "2021"
[dependencies]
clap = { version = "4.4.6", default-features = false, features = ["std", "color", "help", "derive"] }
duster = { git = "https://code.fizz.buzz/talexander/duster.git", branch = "master" }
futures = "0.3.29"
include_dir = "0.7.3"
# TODO: This is temporary to work on the latest organic code. Eventually switch back to using the published crate.
organic = { path = "../organic" }

@ -1 +1,11 @@
heading
{@lte key=.level value=4}
<h{.level}>{#.title}{>object/}{/.title}</h{.level}>
{:else}
<ol>
<li>{#.title}{>object/}{/.title}</li>
</ol>
{/lte}
{#.children}
{>document_element/}
{/.children}

@ -12,10 +12,10 @@ use crate::intermediate::IAngleLink;
pub(crate) struct RenderAngleLink {}
impl RenderAngleLink {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IAngleLink,
) -> Result<RenderAngleLink, CustomError> {
Ok(RenderAngleLink {})

@ -12,10 +12,10 @@ use crate::intermediate::IBabelCall;
pub(crate) struct RenderBabelCall {}
impl RenderBabelCall {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IBabelCall,
) -> Result<RenderBabelCall, CustomError> {
Ok(RenderBabelCall {})

@ -12,10 +12,10 @@ use crate::intermediate::IBold;
pub(crate) struct RenderBold {}
impl RenderBold {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IBold,
) -> Result<RenderBold, CustomError> {
Ok(RenderBold {})

@ -12,10 +12,10 @@ use crate::intermediate::ICenterBlock;
pub(crate) struct RenderCenterBlock {}
impl RenderCenterBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &ICenterBlock,
) -> Result<RenderCenterBlock, CustomError> {
Ok(RenderCenterBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::ICitation;
pub(crate) struct RenderCitation {}
impl RenderCitation {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ICitation,
) -> Result<RenderCitation, CustomError> {
Ok(RenderCitation {})

@ -12,10 +12,10 @@ use crate::intermediate::ICitationReference;
pub(crate) struct RenderCitationReference {}
impl RenderCitationReference {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ICitationReference,
) -> Result<RenderCitationReference, CustomError> {
Ok(RenderCitationReference {})

@ -12,10 +12,10 @@ use crate::intermediate::IClock;
pub(crate) struct RenderClock {}
impl RenderClock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IClock,
) -> Result<RenderClock, CustomError> {
Ok(RenderClock {})

@ -12,10 +12,10 @@ use crate::intermediate::ICode;
pub(crate) struct RenderCode {}
impl RenderCode {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ICode,
) -> Result<RenderCode, CustomError> {
Ok(RenderCode {})

@ -12,10 +12,10 @@ use crate::intermediate::IComment;
pub(crate) struct RenderComment {}
impl RenderComment {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IComment,
) -> Result<RenderComment, CustomError> {
Ok(RenderComment {})

@ -12,10 +12,10 @@ use crate::intermediate::ICommentBlock;
pub(crate) struct RenderCommentBlock {}
impl RenderCommentBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &ICommentBlock,
) -> Result<RenderCommentBlock, CustomError> {
Ok(RenderCommentBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::IDiarySexp;
pub(crate) struct RenderDiarySexp {}
impl RenderDiarySexp {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IDiarySexp,
) -> Result<RenderDiarySexp, CustomError> {
Ok(RenderDiarySexp {})

@ -1,5 +1,11 @@
use std::path::Path;
use serde::Serialize;
use crate::config::Config;
use crate::error::CustomError;
use crate::intermediate::IDocumentElement;
use super::RenderHeading;
use super::RenderSection;
@ -9,3 +15,21 @@ pub(crate) enum RenderDocumentElement {
Heading(RenderHeading),
Section(RenderSection),
}
impl RenderDocumentElement {
pub(crate) fn new(
config: &Config,
output_directory: &Path,
output_file: &Path,
original: &IDocumentElement,
) -> Result<RenderDocumentElement, CustomError> {
match original {
IDocumentElement::Heading(inner) => Ok(RenderDocumentElement::Heading(
RenderHeading::new(config, output_directory, output_file, inner)?,
)),
IDocumentElement::Section(inner) => Ok(RenderDocumentElement::Section(
RenderSection::new(config, output_directory, output_file, inner)?,
)),
}
}
}

@ -12,10 +12,10 @@ use crate::intermediate::IDrawer;
pub(crate) struct RenderDrawer {}
impl RenderDrawer {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IDrawer,
) -> Result<RenderDrawer, CustomError> {
Ok(RenderDrawer {})

@ -12,10 +12,10 @@ use crate::intermediate::IDynamicBlock;
pub(crate) struct RenderDynamicBlock {}
impl RenderDynamicBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IDynamicBlock,
) -> Result<RenderDynamicBlock, CustomError> {
Ok(RenderDynamicBlock {})

@ -61,10 +61,10 @@ pub(crate) enum RenderElement {
}
impl RenderElement {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
element: &IElement,
) -> Result<RenderElement, CustomError> {
match element {

@ -12,10 +12,10 @@ use crate::intermediate::IEntity;
pub(crate) struct RenderEntity {}
impl RenderEntity {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IEntity,
) -> Result<RenderEntity, CustomError> {
Ok(RenderEntity {})

@ -12,10 +12,10 @@ use crate::intermediate::IExampleBlock;
pub(crate) struct RenderExampleBlock {}
impl RenderExampleBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IExampleBlock,
) -> Result<RenderExampleBlock, CustomError> {
Ok(RenderExampleBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::IExportBlock;
pub(crate) struct RenderExportBlock {}
impl RenderExportBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IExportBlock,
) -> Result<RenderExportBlock, CustomError> {
Ok(RenderExportBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::IExportSnippet;
pub(crate) struct RenderExportSnippet {}
impl RenderExportSnippet {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IExportSnippet,
) -> Result<RenderExportSnippet, CustomError> {
Ok(RenderExportSnippet {})

@ -12,10 +12,10 @@ use crate::intermediate::IFixedWidthArea;
pub(crate) struct RenderFixedWidthArea {}
impl RenderFixedWidthArea {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IFixedWidthArea,
) -> Result<RenderFixedWidthArea, CustomError> {
Ok(RenderFixedWidthArea {})

@ -12,10 +12,10 @@ use crate::intermediate::IFootnoteDefinition;
pub(crate) struct RenderFootnoteDefinition {}
impl RenderFootnoteDefinition {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IFootnoteDefinition,
) -> Result<RenderFootnoteDefinition, CustomError> {
Ok(RenderFootnoteDefinition {})

@ -12,10 +12,10 @@ use crate::intermediate::IFootnoteReference;
pub(crate) struct RenderFootnoteReference {}
impl RenderFootnoteReference {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IFootnoteReference,
) -> Result<RenderFootnoteReference, CustomError> {
Ok(RenderFootnoteReference {})

@ -6,6 +6,7 @@ use crate::config::Config;
use crate::error::CustomError;
use crate::intermediate::IHeading;
use super::RenderDocumentElement;
use super::RenderObject;
#[derive(Debug, Serialize)]
@ -14,23 +15,46 @@ use super::RenderObject;
pub(crate) struct RenderHeading {
level: organic::types::HeadlineLevel,
title: Vec<RenderObject>,
children: Vec<RenderDocumentElement>,
}
impl RenderHeading {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
heading: &IHeading,
) -> Result<RenderHeading, CustomError> {
let title = heading
.title
.iter()
.map(|obj| RenderObject::new(config, &output_directory, &output_file, obj))
.collect::<Result<Vec<_>, _>>()?;
let title = {
let mut ret = Vec::new();
for obj in heading.title.iter() {
ret.push(RenderObject::new(
config,
&output_directory,
&output_file,
obj,
)?);
}
ret
};
let children = {
let mut ret = Vec::new();
for obj in heading.children.iter() {
ret.push(RenderDocumentElement::new(
config,
&output_directory,
&output_file,
obj,
)?);
}
ret
};
Ok(RenderHeading {
level: heading.level,
level: heading.level + 1, // Adding 1 because the page title is going to be h1.
title,
children,
})
}
}

@ -12,10 +12,10 @@ use crate::intermediate::IHorizontalRule;
pub(crate) struct RenderHorizontalRule {}
impl RenderHorizontalRule {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IHorizontalRule,
) -> Result<RenderHorizontalRule, CustomError> {
Ok(RenderHorizontalRule {})

@ -12,10 +12,10 @@ use crate::intermediate::IInlineBabelCall;
pub(crate) struct RenderInlineBabelCall {}
impl RenderInlineBabelCall {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IInlineBabelCall,
) -> Result<RenderInlineBabelCall, CustomError> {
Ok(RenderInlineBabelCall {})

@ -12,10 +12,10 @@ use crate::intermediate::IInlineSourceBlock;
pub(crate) struct RenderInlineSourceBlock {}
impl RenderInlineSourceBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IInlineSourceBlock,
) -> Result<RenderInlineSourceBlock, CustomError> {
Ok(RenderInlineSourceBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::IItalic;
pub(crate) struct RenderItalic {}
impl RenderItalic {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IItalic,
) -> Result<RenderItalic, CustomError> {
Ok(RenderItalic {})

@ -12,10 +12,10 @@ use crate::intermediate::IKeyword;
pub(crate) struct RenderKeyword {}
impl RenderKeyword {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
keyword: &IKeyword,
) -> Result<RenderKeyword, CustomError> {
Ok(RenderKeyword {})

@ -12,10 +12,10 @@ use crate::intermediate::ILatexEnvironment;
pub(crate) struct RenderLatexEnvironment {}
impl RenderLatexEnvironment {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &ILatexEnvironment,
) -> Result<RenderLatexEnvironment, CustomError> {
Ok(RenderLatexEnvironment {})

@ -12,10 +12,10 @@ use crate::intermediate::ILatexFragment;
pub(crate) struct RenderLatexFragment {}
impl RenderLatexFragment {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ILatexFragment,
) -> Result<RenderLatexFragment, CustomError> {
Ok(RenderLatexFragment {})

@ -12,10 +12,10 @@ use crate::intermediate::ILineBreak;
pub(crate) struct RenderLineBreak {}
impl RenderLineBreak {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ILineBreak,
) -> Result<RenderLineBreak, CustomError> {
Ok(RenderLineBreak {})

@ -67,10 +67,10 @@ pub(crate) enum RenderObject {
}
impl RenderObject {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
object: &IObject,
) -> Result<RenderObject, CustomError> {
match object {

@ -12,10 +12,10 @@ use crate::intermediate::IOrgMacro;
pub(crate) struct RenderOrgMacro {}
impl RenderOrgMacro {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IOrgMacro,
) -> Result<RenderOrgMacro, CustomError> {
Ok(RenderOrgMacro {})

@ -16,17 +16,25 @@ pub(crate) struct RenderParagraph {
}
impl RenderParagraph {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
paragraph: &IParagraph,
) -> Result<RenderParagraph, CustomError> {
let children = paragraph
.children
.iter()
.map(|obj| RenderObject::new(config, &output_directory, &output_file, obj))
.collect::<Result<Vec<_>, _>>()?;
let children = {
let mut ret = Vec::new();
for obj in paragraph.children.iter() {
ret.push(RenderObject::new(
config,
&output_directory,
&output_file,
obj,
)?);
}
ret
};
Ok(RenderParagraph { children })
}
}

@ -12,10 +12,10 @@ use crate::intermediate::IPlainLink;
pub(crate) struct RenderPlainLink {}
impl RenderPlainLink {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IPlainLink,
) -> Result<RenderPlainLink, CustomError> {
Ok(RenderPlainLink {})

@ -12,10 +12,10 @@ use crate::intermediate::IPlainList;
pub(crate) struct RenderPlainList {}
impl RenderPlainList {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IPlainList,
) -> Result<RenderPlainList, CustomError> {
Ok(RenderPlainList {})

@ -12,10 +12,10 @@ use crate::intermediate::IPlainText;
pub(crate) struct RenderPlainText {}
impl RenderPlainText {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
heading: &IPlainText,
) -> Result<RenderPlainText, CustomError> {
Ok(RenderPlainText {})

@ -12,10 +12,10 @@ use crate::intermediate::IPlanning;
pub(crate) struct RenderPlanning {}
impl RenderPlanning {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IPlanning,
) -> Result<RenderPlanning, CustomError> {
Ok(RenderPlanning {})

@ -12,10 +12,10 @@ use crate::intermediate::IPropertyDrawer;
pub(crate) struct RenderPropertyDrawer {}
impl RenderPropertyDrawer {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IPropertyDrawer,
) -> Result<RenderPropertyDrawer, CustomError> {
Ok(RenderPropertyDrawer {})

@ -12,10 +12,10 @@ use crate::intermediate::IQuoteBlock;
pub(crate) struct RenderQuoteBlock {}
impl RenderQuoteBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IQuoteBlock,
) -> Result<RenderQuoteBlock, CustomError> {
Ok(RenderQuoteBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::IRadioLink;
pub(crate) struct RenderRadioLink {}
impl RenderRadioLink {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IRadioLink,
) -> Result<RenderRadioLink, CustomError> {
Ok(RenderRadioLink {})

@ -12,10 +12,10 @@ use crate::intermediate::IRadioTarget;
pub(crate) struct RenderRadioTarget {}
impl RenderRadioTarget {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IRadioTarget,
) -> Result<RenderRadioTarget, CustomError> {
Ok(RenderRadioTarget {})

@ -12,10 +12,10 @@ use crate::intermediate::IRegularLink;
pub(crate) struct RenderRegularLink {}
impl RenderRegularLink {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IRegularLink,
) -> Result<RenderRegularLink, CustomError> {
Ok(RenderRegularLink {})

@ -16,17 +16,24 @@ pub(crate) struct RenderSection {
}
impl RenderSection {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
section: &ISection,
) -> Result<RenderSection, CustomError> {
let children = section
.children
.iter()
.map(|obj| RenderElement::new(config, &output_directory, &output_file, obj))
.collect::<Result<Vec<_>, _>>()?;
let children = {
let mut ret = Vec::new();
for obj in section.children.iter() {
ret.push(RenderElement::new(
config,
&output_directory,
&output_file,
obj,
)?);
}
ret
};
Ok(RenderSection { children })
}

@ -12,10 +12,10 @@ use crate::intermediate::ISpecialBlock;
pub(crate) struct RenderSpecialBlock {}
impl RenderSpecialBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &ISpecialBlock,
) -> Result<RenderSpecialBlock, CustomError> {
Ok(RenderSpecialBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::ISrcBlock;
pub(crate) struct RenderSrcBlock {}
impl RenderSrcBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &ISrcBlock,
) -> Result<RenderSrcBlock, CustomError> {
Ok(RenderSrcBlock {})

@ -12,10 +12,10 @@ use crate::intermediate::IStatisticsCookie;
pub(crate) struct RenderStatisticsCookie {}
impl RenderStatisticsCookie {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IStatisticsCookie,
) -> Result<RenderStatisticsCookie, CustomError> {
Ok(RenderStatisticsCookie {})

@ -12,10 +12,10 @@ use crate::intermediate::IStrikeThrough;
pub(crate) struct RenderStrikeThrough {}
impl RenderStrikeThrough {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IStrikeThrough,
) -> Result<RenderStrikeThrough, CustomError> {
Ok(RenderStrikeThrough {})

@ -12,10 +12,10 @@ use crate::intermediate::ISubscript;
pub(crate) struct RenderSubscript {}
impl RenderSubscript {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ISubscript,
) -> Result<RenderSubscript, CustomError> {
Ok(RenderSubscript {})

@ -12,10 +12,10 @@ use crate::intermediate::ISuperscript;
pub(crate) struct RenderSuperscript {}
impl RenderSuperscript {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ISuperscript,
) -> Result<RenderSuperscript, CustomError> {
Ok(RenderSuperscript {})

@ -12,10 +12,10 @@ use crate::intermediate::ITable;
pub(crate) struct RenderTable {}
impl RenderTable {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &ITable,
) -> Result<RenderTable, CustomError> {
Ok(RenderTable {})

@ -14,10 +14,10 @@ pub(crate) struct RenderTarget {
}
impl RenderTarget {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
target: &ITarget,
) -> Result<RenderTarget, CustomError> {
Ok(RenderTarget {

@ -12,10 +12,10 @@ use crate::intermediate::ITimestamp;
pub(crate) struct RenderTimestamp {}
impl RenderTimestamp {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &ITimestamp,
) -> Result<RenderTimestamp, CustomError> {
Ok(RenderTimestamp {})

@ -12,10 +12,10 @@ use crate::intermediate::IUnderline;
pub(crate) struct RenderUnderline {}
impl RenderUnderline {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IUnderline,
) -> Result<RenderUnderline, CustomError> {
Ok(RenderUnderline {})

@ -12,10 +12,10 @@ use crate::intermediate::IVerbatim;
pub(crate) struct RenderVerbatim {}
impl RenderVerbatim {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
comment: &IVerbatim,
) -> Result<RenderVerbatim, CustomError> {
Ok(RenderVerbatim {})

@ -12,10 +12,10 @@ use crate::intermediate::IVerseBlock;
pub(crate) struct RenderVerseBlock {}
impl RenderVerseBlock {
pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
pub(crate) fn new(
config: &Config,
output_directory: D,
output_file: F,
output_directory: &Path,
output_file: &Path,
original: &IVerseBlock,
) -> Result<RenderVerseBlock, CustomError> {
Ok(RenderVerseBlock {})