Add initial support for html_writer macro and expose writer base class

Author: tjk

Cargo.lock

@@ -3,39 +3,58 @@ use pulldown_cmark_escape::StrWrite;
 use crate::html::config::HtmlConfig;
 use crate::html::state::HtmlState;
 use crate::html::writer::HtmlWriter;
+use crate::html_writer;
 
-/// Default HTML writer implementation that can work with any StrWrite-compatible writer
-pub struct DefaultHtmlWriter<'a, W: StrWrite> {
+/// Base type for HTML writers that handles common functionality
+pub struct HtmlWriterBase<W: StrWrite> {
     writer: W,
-    config: &'a HtmlConfig,
+    config: HtmlConfig,
     state: HtmlState,
 }
 
-impl<'a, W: StrWrite> DefaultHtmlWriter<'a, W> {
-    /// Create a new DefaultHtmlWriter with the given writer and configuration
-    pub fn new(writer: W, config: &'a HtmlConfig) -> Self {
+impl<W: StrWrite> HtmlWriterBase<W> {
+    /// Create a new HtmlWriterBase with the given writer and configuration
+    pub fn new(writer: W, config: HtmlConfig) -> Self {
         Self {
             writer,
             config,
             state: HtmlState::new(),
         }
     }
-}
 
-impl<'a, W: StrWrite> HtmlWriter<W> for DefaultHtmlWriter<'a, W> {
-    fn get_writer(&mut self) -> &mut W {
+    /// Get a mutable reference to the underlying writer
+    pub fn get_writer(&mut self) -> &mut W {
         &mut self.writer
     }
 
-    fn get_config(&self) -> &HtmlConfig {
-        self.config
+    /// Get a reference to the configuration
+    pub fn get_config(&self) -> &HtmlConfig {
+        &self.config
     }
 
-    fn get_state(&mut self) -> &mut HtmlState {
+    /// Get a mutable reference to the state
+    pub fn get_state(&mut self) -> &mut HtmlState {
         &mut self.state
     }
 }
 
+/// Default HTML writer implementation that can work with any StrWrite-compatible writer
+/// This should be the approximate amount of code any custom implementation needs to
+/// provide
+#[html_writer]
+pub struct DefaultHtmlWriter<W: StrWrite> {
+    base: HtmlWriterBase<W>,
+}
+
+impl<W: StrWrite> DefaultHtmlWriter<W> {
+    /// Create a new DefaultHtmlWriter with the given writer and configuration
+    pub fn new(writer: W, config: HtmlConfig) -> Self {
+        Self {
+            base: HtmlWriterBase::new(writer, config.clone()),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -46,7 +65,7 @@ mod tests {
     fn test_basic_writing() {
         let mut output = String::new();
         let config = HtmlConfig::default();
-        let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), &config);
+        let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), config);
 
         writer.write_str("<p>").unwrap();
         let _ = escape_html(&mut writer.get_writer(), "Hello & World");
@@ -66,7 +85,7 @@ mod tests {
                 .collect(),
         );
 
-        let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), &config);
+        let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), config);
         writer.start_paragraph().unwrap();
         writer.text("Test").unwrap();
         writer.end_paragraph().unwrap();
@@ -99,7 +118,7 @@ mod tests {
     #[test]
     fn test_custom_writer() {
         let config = HtmlConfig::default();
-        let mut writer = DefaultHtmlWriter::new(TestWriter(String::new()), &config);
+        let mut writer = DefaultHtmlWriter::new(TestWriter(String::new()), config);
 
         writer.write_str("Test").unwrap();
         assert_eq!(writer.get_writer().0, "Test");
@@ -110,7 +129,7 @@ mod tests {
         let mut output = String::new();
         let mut config = HtmlConfig::default();
         config.html.escape_html = true;
-        let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), &config);
+        let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), config);
 
         assert!(!writer.get_state().currently_in_code_block);
         writer.get_state().currently_in_code_block = true;

pulldown-html-ext/src/html/default.rs

@@ -203,7 +203,7 @@ where
     W: std::fmt::Write,
     I: Iterator<Item = Event<'a>>,
 {
-    let writer = DefaultHtmlWriter::new(FmtWriter(writer), config);
+    let writer = DefaultHtmlWriter::new(FmtWriter(writer), config.clone());
     let mut renderer = HtmlRenderer::new(writer);
     renderer.run(iter)
 }
@@ -220,7 +220,7 @@ where
     W: std::io::Write,
     I: Iterator<Item = Event<'a>>,
 {
-    let writer = DefaultHtmlWriter::new(IoWriter(writer), config);
+    let writer = DefaultHtmlWriter::new(IoWriter(writer), config.clone());
     let mut renderer = HtmlRenderer::new(writer);
     renderer.run(iter)
 }

pulldown-html-ext/src/html/mod.rs

@@ -92,7 +92,7 @@ impl HtmlConfig {
 
 /// Writer that adds syntax highlighting to code blocks
 pub struct SyntectWriter<'a, W: StrWrite> {
-    inner: DefaultHtmlWriter<'a, W>,
+    inner: DefaultHtmlWriter<W>,
     style: SyntectConfigStyle,
     syntax_set: Option<&'a SyntaxSet>,
     theme_set: Option<&'a ThemeSet>,
@@ -104,7 +104,7 @@ impl<'a, W: StrWrite> SyntectWriter<'a, W> {
         let style = config.syntect.clone().unwrap_or_default();
 
         Self {
-            inner: DefaultHtmlWriter::new(writer, config),
+            inner: DefaultHtmlWriter::new(writer, config.clone()),
             style,
             syntax_set: None,
             theme_set: None,
@@ -121,7 +121,7 @@ impl<'a, W: StrWrite> SyntectWriter<'a, W> {
         let style = config.syntect.clone().unwrap_or_default();
 
         Self {
-            inner: DefaultHtmlWriter::new(writer, config),
+            inner: DefaultHtmlWriter::new(writer, config.clone()),
             style,
             syntax_set,
             theme_set,

pulldown-html-ext/src/html/syntect.rs

@@ -530,6 +530,37 @@ pub trait HtmlWriter<W: StrWrite> {
     }
 }
 
+// Default bases to derive from, implements the default getter methods.
+pub struct HtmlWriterBase<W: StrWrite> {
+    writer: W,
+    config: HtmlConfig,
+    state: HtmlState,
+}
+
+impl<W: StrWrite> HtmlWriterBase<W> {
+    pub fn new(writer: W, config: HtmlConfig) -> Self {
+        Self {
+            writer,
+            config,
+            state: HtmlState::new(),
+        }
+    }
+}
+
+impl<W: StrWrite> HtmlWriter<W> for HtmlWriterBase<W> {
+    fn get_writer(&mut self) -> &mut W {
+        &mut self.writer
+    }
+
+    fn get_config(&self) -> &HtmlConfig {
+        &self.config
+    }
+
+    fn get_state(&mut self) -> &mut HtmlState {
+        &mut self.state
+    }
+}
+
 #[cfg(test)]
 mod tests {
 

pulldown-html-ext/src/html/writer.rs

@@ -74,13 +74,13 @@
 
 mod html;
 pub mod utils;
-
 pub use html::{
     create_html_renderer, push_html, push_html_with_highlighting, write_html_fmt, write_html_io,
     AttributeMappings, CodeBlockOptions, DefaultHtmlWriter, ElementOptions, HeadingOptions,
     HtmlConfig, HtmlError, HtmlOptions, HtmlRenderer, HtmlState, HtmlWriter, LinkOptions,
     SyntectConfig, SyntectConfigStyle, SyntectWriter,
 };
+pub use pulldown_html_ext_derive::html_writer;
 
 #[cfg(test)]
 mod tests_lib {

pulldown-html-ext/src/lib.rs

@@ -5,7 +5,7 @@ use std::collections::HashMap;
 
 fn render_with_config(input: &str, config: &HtmlConfig) -> String {
     let mut output = String::new();
-    let handler = DefaultHtmlWriter::new(&mut output, config);
+    let handler = DefaultHtmlWriter::new(&mut output, config.clone());
     let mut renderer = HtmlRenderer::new(handler);
     let _ = renderer.run(Parser::new(input));
     output