Initial options impl

.vscode/settings.json

@@ -3,6 +3,7 @@
     "restructuredtext.confPath": "",
     "rust-analyzer.check.features": "all",
     "rust-analyzer.check.command": "clippy",
+    "rust-analyzer.cargo.features": "all",
     "[rust]": {
         "editor.defaultFormatter": "rust-lang.rust-analyzer",
         "editor.formatOnSave": true,

renderer/Cargo.toml

@@ -17,6 +17,7 @@ document_tree = { path = '../document_tree', version = "0.4.1" }
 anyhow = '1.0.86'
 serde_json = '1.0.44'
 serde-xml-rs = '0.5'
+derive_builder = '0.20.2'
 
 [dev-dependencies]
 rst_parser = { path = '../parser' }

renderer/src/html.rs

@@ -6,19 +6,25 @@ use std::io::Write;
 use anyhow::Error;
 
 // use crate::url::Url;
+use crate::opt::RenderOptions;
 use document_tree::{
     attribute_types as at, element_categories as c, elements as e, extra_attributes as a, Document,
     Element, ExtraAttributes, HasChildren,
 };
 
 // static FOOTNOTE_SYMBOLS: [char; 10] = ['*', '†', '‡', '§', '¶', '#', '♠', '♥', '♦', '♣'];
 
-pub fn render_html<W>(document: &Document, stream: W, standalone: bool) -> Result<(), Error>
+pub fn render_html<W, O>(document: &Document, stream: W, opts: O) -> Result<(), Error>
 where
     W: Write,
+    O: Into<RenderOptions>,
 {
-    let mut renderer = HTMLRenderer { stream, level: 0 };
-    if standalone {
+    let opts: RenderOptions = opts.into();
+    let mut renderer = HTMLRenderer {
+        stream,
+        level: opts.initial_header_level,
+    };
+    if opts.standalone {
         document.render_html(&mut renderer)
     } else {
         for c in document.children() {

renderer/src/lib.rs

@@ -1,26 +1,34 @@
 mod html;
+pub mod opt;
+#[cfg(test)]
+mod tests;
 
 use std::io::Write;
 
 use anyhow::{anyhow, Error};
 
 use document_tree::Document;
 
-pub fn render_json<W>(document: &Document, stream: W) -> Result<(), Error>
+pub use html::render_html;
+use opt::RenderOptions;
+
+pub fn render_json<W, O>(document: &Document, stream: W, opts: O) -> Result<(), Error>
 where
     W: Write,
+    O: Into<RenderOptions>,
 {
+    let _: RenderOptions = opts.into();
     serde_json::to_writer(stream, &document)?;
     Ok(())
 }
 
-pub fn render_xml<W>(document: &Document, stream: W) -> Result<(), Error>
+pub fn render_xml<W, O>(document: &Document, stream: W, opts: O) -> Result<(), Error>
 where
     W: Write,
+    O: Into<RenderOptions>,
 {
+    let _: RenderOptions = opts.into();
     serde_xml_rs::to_writer(stream, &document)
         .map_err(|e| anyhow!("Failed to serialize XML: {}", e))?;
     Ok(())
 }
-
-pub use html::render_html;

renderer/src/opt.rs

@@ -0,0 +1,38 @@
+use derive_builder::Builder;
+
+#[derive(Builder, Debug, Default, PartialEq, Eq, Hash, Clone)]
+#[builder(derive(Debug, PartialEq, Eq, Hash))]
+#[builder(build_fn(private, name = "fallible_build"))]
+pub struct RenderOptions {
+    // The initial header level
+    #[builder(default = 0)]
+    pub initial_header_level: u8,
+    /// Produce a standalone document
+    #[builder(default = true)]
+    pub standalone: bool,
+}
+
+impl RenderOptionsBuilder {
+    pub fn build(&mut self) -> RenderOptions {
+        self.fallible_build()
+            .expect("All required fields set at initialization")
+    }
+}
+
+impl From<bool> for RenderOptions {
+    fn from(standalone: bool) -> Self {
+        RenderOptionsBuilder::default()
+            .standalone(standalone)
+            .build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::RenderOptionsBuilder;
+
+    #[test]
+    fn no_required_fields_added_to_render_options() {
+        RenderOptionsBuilder::default().build();
+    }
+}

renderer/src/tests.rs

@@ -0,0 +1,18 @@
+use document_tree::Document;
+
+use crate::render_xml;
+
+const XML_DECL: &str = r#"<?xml version="1.0" encoding="UTF-8"?>"#;
+
+#[test]
+fn test_render_xml() {
+    let mut s = Vec::new();
+    // should probably be lowercase
+    let exp = "<Document />";
+
+    render_xml(&Document::default(), &mut s, true).unwrap();
+    assert_eq!(std::str::from_utf8(&s).unwrap(), format!("{XML_DECL}{exp}"));
+
+    render_xml(&Document::default(), &mut s, false).unwrap();
+    assert_eq!(std::str::from_utf8(&s).unwrap(), exp);
+}