rendering md with layouts

src/renderer.rs

@@ -0,0 +1,104 @@
+use std::{default, fs};
+use std::io::Error;
+use std::path::PathBuf;
+use eframe::egui::TextBuffer;
+use markdown::message::Message;
+use markdown::{CompileOptions, Constructs, ParseOptions};
+use markdown::mdast::Node;
+use serde::Deserialize;
+use thiserror::Error;
+
+pub struct RenderOutput {
+    pub filename: PathBuf,
+    pub contents: String
+}
+
+#[derive(Deserialize)]
+pub struct Frontmatter {
+    layout: Option<String>,
+    title: Option<String>
+}
+
+impl Frontmatter {
+    fn apply_layout(self, content: String, root: PathBuf) -> Result<String, RenderError> {
+        let title = self.title.unwrap_or(String::new());
+        if let Some(layout) = self.layout {
+            let absolute_layout = root.join(layout);
+            let layout = fs::read_to_string(absolute_layout.clone()).map_err(|e| RenderError::FileReadError(e, absolute_layout))?;
+            Ok(layout.replace("$title", title.as_str()).replace("$content", content.as_str()))
+        } else {
+            Ok(content)
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum RenderError {
+    #[error("Error reading {1}: {0}")]
+    FileReadError(Error, PathBuf),
+    #[error("Error parsing Markdown {1}: {0}")]
+    MarkdownParseError(Message, PathBuf),
+    #[error("Error parsing frontmatter in {1}: {0}")]
+    FrontmatterParseError(toml::de::Error, PathBuf)
+}
+
+pub fn render(source: PathBuf, root: PathBuf) -> Result<RenderOutput, RenderError> {
+    let contents = match source.extension().map(|o| o.to_str().unwrap()) {
+        Some("md") => render_as_markdown(source.clone(), root),
+        _ => todo!()
+    }?;
+    let filename = source.with_extension("html");
+    Ok(RenderOutput { filename, contents })
+}
+
+fn render_as_markdown(source: PathBuf, root: PathBuf) -> Result<String, RenderError> {
+    let absolute_source = root.join(source.clone());
+    let contents = fs::read_to_string(absolute_source.clone()).map_err(|e| RenderError::FileReadError(e, source.clone()))?;
+    let options = markdown::Options {
+        parse: ParseOptions {
+            constructs: Constructs {
+                frontmatter: true,
+                gfm_table: true,
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+    let html = markdown::to_html_with_options(contents.as_str(), &options).map_err(|e| RenderError::MarkdownParseError(e, source.clone()))?;
+    let ast = markdown::to_mdast(contents.as_str(), &options.parse).map_err(|e| RenderError::MarkdownParseError(e, source.clone()))?;
+
+    if let Some(frontmatter) = find_frontmatter(ast, source.clone())? {
+        frontmatter.apply_layout(html, root)
+    } else {
+        Ok(html)
+    }
+}
+
+fn find_frontmatter(node: Node, source: PathBuf) -> Result<Option<Frontmatter>, RenderError> {
+    if let Some(children) = node.children() {
+        for child in children.into_iter() {
+            if let Node::Toml(toml_str) = child {
+                let fmatter: Frontmatter = toml::from_str(toml_str.value.as_str()).map_err(|e| RenderError::FrontmatterParseError(e, source))?;
+                return Ok(Some(fmatter))
+            }
+        }
+        Ok(None)
+    } else { Ok(None) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rendering_markdown() {
+        match render("index.md".into(), "./testdata".into()) {
+            Err(e) => println!("{}", e),
+            Ok(ro) => {
+                println!("File: {}", ro.filename.to_str().unwrap());
+                println!("Contents:\n\n{}", ro.contents);
+            }
+        }
+    }
+}