Refactor to support return Result by default everywhere

Add custom Error types and use them in Result types for error handling
by default. Approximately akin to the way pulldown-cmark handles errors

Author: tjk

lib/src/html/default.rs

@@ -48,9 +48,9 @@ mod tests {
         let config = HtmlConfig::default();
         let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), &config);
 
-        writer.write_str("<p>");
+        writer.write_str("<p>").unwrap();
         let _ = escape_html(&mut writer.get_writer(), "Hello & World");
-        writer.write_str("</p>");
+        writer.write_str("</p>").unwrap();
 
         assert_eq!(output, "<p>Hello &amp; World</p>");
     }
@@ -67,9 +67,9 @@ mod tests {
         );
 
         let mut writer = DefaultHtmlWriter::new(FmtWriter(&mut output), &config);
-        writer.start_paragraph();
-        writer.text("Test");
-        writer.end_paragraph();
+        writer.start_paragraph().unwrap();
+        writer.text("Test").unwrap();
+        writer.end_paragraph().unwrap();
 
         assert_eq!(output, r#"<p class="test">Test</p>"#);
     }
@@ -101,7 +101,7 @@ mod tests {
         let config = HtmlConfig::default();
         let mut writer = DefaultHtmlWriter::new(TestWriter(String::new()), &config);
 
-        writer.write_str("Test");
+        writer.write_str("Test").unwrap();
         assert_eq!(writer.get_writer().0, "Test");
     }
 
@@ -114,9 +114,11 @@ mod tests {
 
         assert!(!writer.get_state().currently_in_code_block);
         writer.get_state().currently_in_code_block = true;
-        writer.start_code_block(pulldown_cmark::CodeBlockKind::Fenced("rust".into()));
+        writer
+            .start_code_block(pulldown_cmark::CodeBlockKind::Fenced("rust".into()))
+            .unwrap();
         assert!(writer.get_state().currently_in_code_block);
-        writer.end_code_block();
+        writer.end_code_block().unwrap();
         writer.get_state().currently_in_code_block = false;
         assert!(!writer.get_state().currently_in_code_block);
     }

lib/src/html/error.rs

@@ -0,0 +1,52 @@
+use std::error::Error;
+use std::fmt;
+use std::io;
+
+/// Custom error type for HTML rendering operations
+#[derive(Debug)]
+pub enum HtmlError {
+    /// IO-related errors
+    Io(io::Error),
+    /// Writing-related errors
+    Write(fmt::Error),
+    /// Theme-related errors (for syntax highlighting)
+    Theme(String),
+    /// Configuration validation errors
+    Config(String),
+    /// General rendering errors
+    Render(String),
+}
+
+impl fmt::Display for HtmlError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            HtmlError::Io(err) => write!(f, "IO error: {}", err),
+            HtmlError::Write(err) => write!(f, "Write error: {}", err),
+            HtmlError::Theme(err) => write!(f, "Theme error: {}", err),
+            HtmlError::Config(err) => write!(f, "Configuration error: {}", err),
+            HtmlError::Render(err) => write!(f, "Rendering error: {}", err),
+        }
+    }
+}
+
+impl Error for HtmlError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            HtmlError::Io(err) => Some(err),
+            HtmlError::Write(err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl From<io::Error> for HtmlError {
+    fn from(err: io::Error) -> Self {
+        HtmlError::Io(err)
+    }
+}
+
+impl From<fmt::Error> for HtmlError {
+    fn from(err: fmt::Error) -> Self {
+        HtmlError::Write(err)
+    }
+}