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,280 @@
+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 std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+
+use std::collections::BTreeMap;
+
+use serde::Deserialize;
+
+/// Configuration specific to the i18n-helpers component.
+#[derive(Deserialize, Debug)]
+pub struct I18nConfiguration {
+    pub languages: BTreeMap<String, String>,
+    pub default_language: Option<String>,
+    #[serde(default)]
+    pub translate_all_languages: bool,
+}
+
+pub struct RenderingContext<'a> {
+    pub path: PathBuf,
+    pub language: String,
+    pub i18_config: &'a I18nConfiguration,
+    pub language_to_rendered_path: BTreeMap<String, PathBuf>,
+}
+
+impl<'a> RenderingContext<'a> {
+    fn new(
+        path: PathBuf,
+        book_dir: PathBuf,
+        language: String,
+        i18_config: &'a I18nConfiguration,
+    ) -> Result<Self> {
+        let html_dir = book_dir.join("html");
+        let mut language_to_rendered_path: BTreeMap<String, PathBuf> = BTreeMap::new();
+        for identifier in i18_config.languages.keys() {
+            let mut relative_path = path.strip_prefix(&html_dir)?.to_owned();
+            if let Ok(without_lang) = relative_path.strip_prefix(&language) {
+                relative_path = without_lang.to_owned();
+            }
+            if Some(identifier) != i18_config.default_language.as_ref() {
+                relative_path = Path::new(identifier).join(relative_path).to_owned();
+            }
+            language_to_rendered_path.insert(
+                identifier.clone(),
+                Path::new("/").join(relative_path).to_owned(),
+            );
+        }
+        Ok(RenderingContext {
+            path,
+            language,
+            i18_config,
+            language_to_rendered_path,
+        })
+    }
+}
+
+pub(crate) struct BookDirectoryRenderer {
+    config: I18nConfiguration,
+    book: mdbook::MDBook,
+    book_dir: PathBuf,
+    components: Vec<CustomComponent>,
+    languages_paths: BTreeMap<String, PathBuf>,
+}
+
+impl BookDirectoryRenderer {
+    pub(crate) fn new(
+        config: I18nConfiguration,
+        book: mdbook::MDBook,
+        book_dir: PathBuf,
+    ) -> BookDirectoryRenderer {
+        let default_language = config.default_language.clone();
+        let languages_paths = config
+            .languages
+            .keys()
+            .filter(|language| {
+                default_language.is_none() || *language != default_language.as_ref().unwrap()
+            })
+            .map(|language| (language.clone(), book_dir.join("html").join(language)))
+            .collect::<BTreeMap<String, PathBuf>>();
+        BookDirectoryRenderer {
+            config,
+            book,
+            languages_paths,
+            book_dir,
+            components: Vec::new(),
+        }
+    }
+
+    pub fn translate(&mut self) -> Result<()> {
+        let default_language = &self.config.default_language;
+        let original_language = self.book.config.book.language.clone();
+        let book_dir = self.book_dir.as_path();
+
+        for identifier in self.config.languages.keys() {
+            if let Some(default_language) = default_language {
+                if default_language == identifier {
+                    continue;
+                }
+            }
+
+            let translation_path = book_dir.join(identifier);
+
+            self.book.config.book.language = Some(identifier.clone());
+            self.book.config.book.multilingual = true;
+            self.book.config.build.build_dir = translation_path;
+            self.book.build()?;
+            std::fs::rename(
+                book_dir.join(identifier).join("html"),
+                book_dir.join("html").join(identifier),
+            )?;
+        }
+        self.book.config.book.language = original_language;
+        self.book.config.build.build_dir = book_dir.to_owned();
+        Ok(())
+    }
+
+    pub(crate) fn render_book(&mut self) -> Result<()> {
+        let html_dir = self.book_dir.join("html");
+        if !html_dir.is_dir() {
+            return Err(RendererError::InvalidPath(format!(
+                "{:?} is not a directory",
+                self.book_dir
+            )));
+        }
+        self.render_book_directory(&html_dir)
+    }
+
+    pub(crate) fn add_component(&mut self, component: CustomComponent) {
+        self.components.push(component);
+    }
+
+    fn extract_language_from_path(&self, path: &Path) -> String {
+        for (language, language_path) in &self.languages_paths {
+            if path.starts_with(language_path) {
+                return language.clone();
+            }
+        }
+        self.config.default_language.clone().unwrap_or_default()
+    }
+
+    fn render_components(&mut self, file_content: &str, path: &Path) -> Result<String> {
+        let rendering_context = RenderingContext::new(
+            path.to_owned(),
+            self.book_dir.clone(),
+            self.extract_language_from_path(path),
+            &self.config,
+        )?;
+        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-helpers]
+    default_language = "en"
+    translate_all_languages = false
+
+    [output.i18n-helpers.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 mut languages = BTreeMap::new();
+        languages.insert(String::from("en"), String::from("English"));
+        languages.insert(String::from("fr"), String::from("French"));
+        let mock_config = I18nConfiguration {
+            languages,
+            default_language: Some(String::from("en")),
+            translate_all_languages: true,
+        };
+        let mdbook = mdbook::MDBook::load(&dir.path()).expect("Failed to load book");
+
+        let mut renderer = BookDirectoryRenderer::new(mock_config, mdbook, dir.path().to_owned());
+        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=\"fr\"\n            href=\"/fr/test.html\"\n            style=\"color: inherit;\">\n            <button role=\"menuitem\" class=\"theme \">\n                French\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,92 @@
+use std::cell::RefCell;
+use std::collections::{BTreeMap, HashMap};
+use std::path::PathBuf;
+
+use serde_json::{from_value, to_value};
+use tera::Tera;
+
+use crate::Result;
+
+use super::RenderingContext;
+
+pub struct CustomComponent {
+    template: String,
+    name: String,
+    id: RefCell<u32>,
+}
+
+impl CustomComponent {
+    pub fn new(name: &str, template: &str) -> CustomComponent {
+        CustomComponent {
+            name: String::from(name),
+            template: String::from(template),
+            id: RefCell::new(0),
+        }
+    }
+
+    fn make_language_to_rendered_path_function(
+        language_to_rendered_path: BTreeMap<String, PathBuf>,
+    ) -> impl tera::Function {
+        Box::new(
+            move |args: &HashMap<String, tera::Value>| -> tera::Result<tera::Value> {
+                match args.get("identifier") {
+                    Some(val) => match from_value::<String>(val.clone()) {
+                        Ok(v) => Ok(to_value(language_to_rendered_path.get(&v).ok_or_else(
+                            || {
+                                tera::Error::from(
+                                    "No language with the provided indentifier was found",
+                                )
+                            },
+                        )?)?),
+                        Err(_) => Err("Failed to deserialize argument".into()),
+                    },
+                    None => Err("Identifier argument not provided".into()),
+                }
+            },
+        )
+    }
+
+    fn create_context(
+        &self,
+        tera_obj: &mut Tera,
+        rendering_context: &RenderingContext,
+    ) -> tera::Context {
+        let id = self.id.replace_with(|&mut id| id + 1);
+        let mut context = tera::Context::new();
+        context.insert("id", &id);
+        if rendering_context.language != "en" {
+            println!("LANGUAGE {}", rendering_context.language);
+        }
+
+        context.insert("language", &rendering_context.language);
+        context.insert(
+            "default_language",
+            &rendering_context.i18_config.default_language,
+        );
+        context.insert("languages", &rendering_context.i18_config.languages);
+        context.insert("path", &rendering_context.path);
+
+        let language_to_rendered_path = rendering_context.language_to_rendered_path.clone();
+        let language_to_rendered_path_function =
+            CustomComponent::make_language_to_rendered_path_function(language_to_rendered_path);
+        tera_obj.register_function(
+            "language_to_rendered_path",
+            language_to_rendered_path_function,
+        );
+
+        context
+    }
+
+    pub fn render(&self, rendering_context: &RenderingContext) -> Result<String> {
+        let mut tera = Tera::default();
+        tera.add_raw_template("template", &self.template)?;
+
+        let context = self.create_context(&mut tera, rendering_context);
+        let output = tera.render("template", &context)?;
+        Ok(output)
+    }
+
+    pub fn component_name(&self) -> String {
+        self.name.clone()
+    }
+}