Create renderer

Author: sakex

Cargo.lock

@@ -11,13 +11,17 @@ description = "Plugins for a mdbook translation workflow based on Gettext."
 
 [dependencies]
 anyhow = "1.0.68"
+lol_html = "1.2.0"
 mdbook = { version = "0.4.25", default-features = false }
 polib = "0.2.0"
 pulldown-cmark = { version = "0.9.2", default-features = false }
 pulldown-cmark-to-cmark = "10.0.4"
 regex = "1.9.4"
 semver = "1.0.16"
+serde = "1.0.130"
 serde_json = "1.0.91"
+tera = "1.19.1"
+thiserror = "1.0.30"
 
 [dev-dependencies]
 pretty_assertions = "1.3.0"

Cargo.toml

@@ -0,0 +1,230 @@
+use super::error::RendererError;
+use super::CustomComponent;
+use crate::custom_component_renderer::error::Result;
+use lol_html::html_content::ContentType;
+use lol_html::{element, RewriteStrSettings};
+use mdbook::renderer::RenderContext;
+use serde_json::to_value;
+use std::collections::HashMap;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+pub struct RenderingContext<'a> {
+    pub path: PathBuf,
+    pub language: Option<String>,
+    pub serialized_ctx: &'a serde_json::Value,
+    pub ctx: &'a RenderContext,
+}
+
+impl<'a> RenderingContext<'a> {
+    fn new(
+        path: PathBuf,
+        language: Option<String>,
+        serialized_ctx: &'a serde_json::Value,
+        ctx: &'a RenderContext,
+    ) -> Result<Self> {
+        Ok(RenderingContext {
+            path,
+            language,
+            serialized_ctx,
+            ctx,
+        })
+    }
+}
+
+pub(crate) struct BookDirectoryRenderer {
+    ctx: Arc<RenderContext>,
+    serialized_ctx: serde_json::Value,
+    components: Vec<CustomComponent>,
+}
+
+impl BookDirectoryRenderer {
+    pub(crate) fn new(ctx: RenderContext) -> Result<BookDirectoryRenderer> {
+        Ok(BookDirectoryRenderer {
+            serialized_ctx: serde_json::to_value(&ctx)?,
+            ctx: Arc::new(ctx),
+            components: Vec::new(),
+        })
+    }
+
+    pub(crate) fn render_book(&mut self) -> Result<()> {
+        let dest_dir = &self
+            .ctx
+            .destination
+            .parent()
+            .ok_or_else(|| {
+                RendererError::InvalidPath(format!(
+                    "Destination directory {:?} has no parent",
+                    self.ctx.destination
+                ))
+            })?
+            .to_owned();
+        if !dest_dir.is_dir() {
+            return Err(RendererError::InvalidPath(format!(
+                "{:?} is not a directory",
+                dest_dir
+            )));
+        }
+        self.render_book_directory(&dest_dir)
+    }
+
+    fn create_get_context_function(&self) -> impl tera::Function {
+        let ctx_rx = Arc::clone(&self.ctx);
+        move |args: &HashMap<String, serde_json::value::Value>| -> tera::Result<tera::Value> {
+            let key = args
+                .get("key")
+                .ok_or_else(|| tera::Error::from(format!("No key argument provided")))?
+                .as_str()
+                .ok_or_else(|| {
+                    tera::Error::from(format!("Key has invalid type, expected string"))
+                })?;
+            let value = ctx_rx
+                .config
+                .get(key)
+                .ok_or_else(|| tera::Error::from(format!("Could not find key {key} in config")))?;
+            let value = to_value(value)?;
+            Ok(value)
+        }
+    }
+
+    pub(crate) fn add_component(&mut self, mut component: CustomComponent) {
+        component.register_function("get_context", self.create_get_context_function());
+        self.components.push(component);
+    }
+
+    fn render_components(&mut self, file_content: &str, path: &Path) -> Result<String> {
+        let rendering_context = RenderingContext::new(
+            path.to_owned(),
+            self.ctx.config.book.language.clone(),
+            &self.serialized_ctx,
+            &self.ctx,
+        )?;
+        let custom_components_handlers = self
+            .components
+            .iter()
+            .map(|component| {
+                element!(component.component_name(), |el| {
+                    let rendered = component.render(&rendering_context)?;
+                    el.replace(&rendered, ContentType::Html);
+                    Ok(())
+                })
+            })
+            .collect();
+        let output = lol_html::rewrite_str(
+            file_content,
+            RewriteStrSettings {
+                element_content_handlers: custom_components_handlers,
+                ..RewriteStrSettings::default()
+            },
+        )?;
+        Ok(output)
+    }
+
+    fn process_file(&mut self, path: &Path) -> Result<()> {
+        if path.extension().unwrap_or_default() != "html" {
+            return Ok(());
+        }
+        let mut file_content = String::new();
+        {
+            let mut file = fs::File::open(path)?;
+            file.read_to_string(&mut file_content)?;
+        }
+
+        let output = self.render_components(&file_content, path)?;
+        let mut output_file = fs::File::create(path)?;
+        output_file.write_all(output.as_bytes())?;
+        Ok(())
+    }
+
+    fn render_book_directory(&mut self, path: &Path) -> Result<()> {
+        for entry in path.read_dir()? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_dir() {
+                self.render_book_directory(&path)?;
+            } else {
+                self.process_file(&path)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::custom_component_renderer::standard_templates;
+
+    const FAKE_BOOK_TOML: &str = r#"
+    [book]
+    src = "src"
+
+    [rust]
+    edition = "2021"
+
+    [build]
+    extra-watch-dirs = ["po", "third_party"]
+
+    [preprocessor.gettext]
+    after = ["links"]
+
+    [preprocessor.svgbob]
+    renderers = ["html"]
+    after = ["gettext"]
+    class = "bob"
+
+    [output.html]
+    curly-quotes = true
+
+    [output.i18n]
+    default_language = "en"
+    translate_all_languages = false
+
+    [output.i18n.languages]
+    "en" = "English"
+    "es" = "Spanish (Español)"
+    "ko" = "Korean (한국어)"
+    "pt-BR" = "Brazilian Portuguese (Português do Brasil)"
+    "#;
+
+    #[test]
+    fn test_render_book() {
+        use super::*;
+        use std::fs::File;
+        use tempfile::tempdir;
+
+        const INITIAL_HTML: &[u8] = b"<html><body><LanguagePicker/></body></html>";
+
+        let dir = tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("html")).expect("Failed to create html directory");
+        std::fs::create_dir(dir.path().join("src")).expect("Failed to create src directory");
+
+        std::fs::write(dir.path().join("html/test.html"), INITIAL_HTML)
+            .expect("Failed to write initial html");
+        std::fs::write(dir.path().join("book.toml"), FAKE_BOOK_TOML)
+            .expect("Failed to write initial book.toml");
+        std::fs::write(dir.path().join("src/SUMMARY.md"), "")
+            .expect("Failed to write initial SUMMARY.md");
+
+        let mdbook = mdbook::MDBook::load(dir.path()).expect("Failed to load mdbook");
+        let ctx = RenderContext::new(
+            dir.path(),
+            mdbook.book,
+            mdbook.config,
+            dir.path().join("i18n-helpers"),
+        );
+
+        let mut renderer = BookDirectoryRenderer::new(ctx).expect("Failed to create renderer");
+        renderer.add_component(standard_templates::create_language_picker_component());
+        renderer.render_book().expect("Failed to render book");
+
+        let mut output = String::new();
+        let mut file = File::open(dir.path().join("html/test.html")).unwrap();
+        file.read_to_string(&mut output).unwrap();
+
+        const EXPECTED: &str = "<html><body><button id=\"language-toggle0\" class=\"icon-button\" type=\"button\"\n    title=\"Change language\" aria-label=\"Change language\"\n    aria-haspopup=\"true\" aria-expanded=\"false\"\n    aria-controls=\"language-list0\">\n    <i class=\"fa fa-globe\"></i>\n</button>\n<ul id=\"language-list0\" class=\"theme-popup\" aria-label=\"Languages\"\n    role=\"menu\" style=\"left: auto; right: 10px;\">\n    \n    <li role=\"none\">\n        <a id=\"en\"\n            href=\"/test.html\"\n            style=\"color: inherit;\">\n            <button role=\"menuitem\" class=\"theme  theme-selected \">\n                English\n            </button>\n        </a>\n    </li>\n    \n    <li role=\"none\">\n        <a id=\"es\"\n            href=\"/es/test.html\"\n            style=\"color: inherit;\">\n            <button role=\"menuitem\" class=\"theme \">\n                Spanish (Español)\n            </button>\n        </a>\n    </li>\n    \n    <li role=\"none\">\n        <a id=\"ko\"\n            href=\"/ko/test.html\"\n            style=\"color: inherit;\">\n            <button role=\"menuitem\" class=\"theme \">\n                Korean (한국어)\n            </button>\n        </a>\n    </li>\n    \n    <li role=\"none\">\n        <a id=\"pt-BR\"\n            href=\"/pt-BR/test.html\"\n            style=\"color: inherit;\">\n            <button role=\"menuitem\" class=\"theme \">\n                Brazilian Portuguese (Português do Brasil)\n            </button>\n        </a>\n    </li>\n    \n</ul>\n\n<script>\n    let langToggle = document.getElementById(\"language-toggle0\");\n    let langList = document.getElementById(\"language-list0\");\n    \n    langToggle.addEventListener(\"click\", (event) => {{\n        langList.style.display = langList.style.display == \"block\" ? \"none\" : \"block\";\n    }});\n    \n</script>\n\n<style>\n    [dir=rtl] #language-list0  {\n        left: 10px;\n        right: auto;\n    }\n    \n</style>\n</html>";
+
+        assert_eq!(output, EXPECTED);
+    }
+}

src/custom_component_renderer/book_directory_renderer.rs

@@ -0,0 +1,80 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+
+use tera::Tera;
+
+use crate::Result;
+
+use super::RenderingContext;
+
+const TEMPLATE_NAME: &str = "template";
+
+fn make_strip_prefix_function() -> impl tera::Function {
+    move |args: &HashMap<String, serde_json::value::Value>| -> tera::Result<tera::Value> {
+        let string = args
+            .get("s")
+            .ok_or_else(|| tera::Error::from(format!("No s argument provided")))?
+            .as_str()
+            .ok_or_else(|| tera::Error::from(format!("S has invalid type, expected string")))?;
+        let prefix = args
+            .get("prefix")
+            .ok_or_else(|| tera::Error::from(format!("No prefix argument provided")))?
+            .as_str()
+            .ok_or_else(|| {
+                tera::Error::from(format!("Prefix has invalid type, expected string"))
+            })?;
+        string
+            .strip_prefix(prefix)
+            .map(|s| tera::Value::String(s.to_owned()))
+            .ok_or_else(|| tera::Error::from(format!("Could not strip prefix")))
+    }
+}
+
+pub struct CustomComponent {
+    template: Tera,
+    name: String,
+    /// Used to generate unique ids for each component to prevent collisions in javascript with query selectors.
+    counter: RefCell<u32>,
+}
+
+impl CustomComponent {
+    pub fn new(name: &str, template_str: &str) -> Result<CustomComponent> {
+        let mut template = Tera::default();
+        template.add_raw_template(TEMPLATE_NAME, template_str)?;
+        template.register_function("strip_prefix", make_strip_prefix_function());
+        Ok(CustomComponent {
+            name: String::from(name),
+            counter: RefCell::new(0),
+            template,
+        })
+    }
+
+    pub fn register_function(&mut self, name: &str, function: impl tera::Function + 'static) {
+        self.template.register_function(name, function);
+    }
+
+    fn create_context(&self, rendering_context: &RenderingContext) -> tera::Context {
+        let counter = self.counter.replace_with(|&mut counter| counter + 1);
+        let mut context = tera::Context::new();
+        context.insert("counter", &counter);
+        context.insert("language", &rendering_context.language);
+        context.insert("path", &rendering_context.path);
+        context.insert("ctx", &rendering_context.serialized_ctx);
+        context.insert(
+            "book_dir",
+            &rendering_context.ctx.destination.parent().unwrap(),
+        );
+
+        context
+    }
+
+    pub fn render(&self, rendering_context: &RenderingContext) -> Result<String> {
+        let context = self.create_context(rendering_context);
+        let output = self.template.render(TEMPLATE_NAME, &context)?;
+        Ok(output)
+    }
+
+    pub fn component_name(&self) -> String {
+        self.name.clone()
+    }
+}

src/custom_component_renderer/custom_component.rs

@@ -0,0 +1,23 @@
+use std::path::StripPrefixError;
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum RendererError {
+    #[error("IO Error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Invalid path: {0}")]
+    InvalidPath(String),
+    #[error("Error rendering tera template: {0}")]
+    TeraError(#[from] tera::Error),
+    #[error("HTML Error: {0}")]
+    HtmlRewritingError(#[from] lol_html::errors::RewritingError),
+    #[error("Mdbook Error: {0}")]
+    Mdbook(#[from] mdbook::errors::Error),
+    #[error("Error in strip_prefix call: {0}")]
+    StripPrefixError(#[from] StripPrefixError),
+    #[error("Serde error: {0}")]
+    SerdeError(#[from] serde_json::Error),
+}
+
+pub type Result<T> = std::result::Result<T, RendererError>;

src/custom_component_renderer/error.rs

@@ -0,0 +1,8 @@
+mod book_directory_renderer;
+mod custom_component;
+mod error;
+pub(crate) mod standard_templates;
+
+pub(crate) use book_directory_renderer::*;
+pub(crate) use custom_component::*;
+pub(crate) use error::*;

src/custom_component_renderer/mod.rs

@@ -0,0 +1,10 @@
+use super::CustomComponent;
+
+mod templates {
+    pub const LANGUAGE_PICKER: &str = include_str!("standard_templates/language_picker.html");
+}
+
+pub fn create_language_picker_component() -> CustomComponent {
+    CustomComponent::new("LanguagePicker", templates::LANGUAGE_PICKER)
+        .expect("Failed to create language picker component")
+}