Add rendering of the web into a directory

Author: Kobzol

Cargo.lock

@@ -5,7 +5,10 @@ authors = ["The Rust Project Developers"]
 edition = "2024"
 
 [dependencies]
-handlebars-fluent = "0.4.0"
+anyhow = "1"
+tokio = { version = "1", features = ["full"] }
+handlebars = { version = "6", features = ["dir_source"] }
+handlebars-fluent = "0.5"
 rocket = "0.5.1"
 rocket_dyn_templates = { version = "0.2.0", features = ["handlebars"] }
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -13,7 +13,7 @@ pub type Cache<T> = State<Arc<RwLock<T>>>;
 
 pub trait Cached: Send + Sync + Clone + 'static {
     fn get_timestamp(&self) -> Instant;
-    fn fetch() -> impl Future<Output = Result<Self, Box<dyn Error + Send + Sync>>> + Send;
+    fn fetch() -> impl Future<Output = anyhow::Result<Self>> + Send;
     async fn get(cache: &Cache<Self>) -> Self {
         let cached = cache.read().await.clone();
         let timestamp = cached.get_timestamp();

src/cache.rs

@@ -1,4 +1,4 @@
-use rocket_dyn_templates::handlebars::{
+use handlebars::{
     Context, Handlebars, Helper, HelperDef, HelperResult, Output, RenderContext, RenderErrorReason,
 };
 

src/i18n.rs

@@ -6,6 +6,7 @@ mod i18n;
 mod redirect;
 mod rust_version;
 mod teams;
+mod render;
 
 use cache::Cache;
 use cache::Cached;
@@ -20,11 +21,14 @@ use teams::encode_zulip_stream;
 use std::collections::hash_map::DefaultHasher;
 use std::env;
 use std::fs;
+use std::fs::File;
 use std::hash::Hasher;
+use std::io::BufWriter;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::sync::LazyLock;
-
+use anyhow::Context as _;
+use handlebars::{DirectorySourceOptions, Handlebars};
 use rocket::{
     fs::NamedFile,
     http::Status,
@@ -38,7 +42,7 @@ use sass_rs::{Options, compile_file};
 use category::Category;
 
 use caching::CachedNamedFile;
-use handlebars_fluent::{FluentHelper, loader::Loader};
+use handlebars_fluent::{FluentHelper, loader::Loader, simple_loader};
 use i18n::{EXPLICIT_LOCALE_INFO, LocaleInfo, SupportedLocale, TeamHelper, create_loader};
 
 const ZULIP_DOMAIN: &str = "https://rust-lang.zulipchat.com";
@@ -404,50 +408,59 @@ fn render_subject(category: Category, subject: &str, lang: String) -> Result<Tem
     Ok(Template::render(page, context))
 }
 
-#[rocket::launch]
-async fn rocket() -> _ {
-    let templating = Template::custom(|engine| {
-        engine
-            .handlebars
-            .register_helper("fluent", Box::new(FluentHelper::new(create_loader())));
-        engine
-            .handlebars
-            .register_helper("team-text", Box::new(TeamHelper::new()));
-        engine
-            .handlebars
-            .register_helper("encode-zulip-stream", Box::new(encode_zulip_stream));
-    });
-
-    let rust_version = RustVersion::fetch().await.unwrap_or_default();
-    let teams = RustTeams::fetch().await.unwrap_or_default();
-
-    rocket::build()
-        .attach(templating)
-        .attach(headers::InjectHeaders)
-        .manage(Arc::new(RwLock::new(rust_version)))
-        .manage(Arc::new(RwLock::new(teams)))
-        .mount(
-            "/",
-            rocket::routes![
-                index,
-                category_en,
-                governance,
-                team,
-                subject,
-                files,
-                robots_txt,
-                logos,
-                index_locale,
-                category_locale,
-                governance_locale,
-                team_locale,
-                subject_locale,
-                redirect_bare_en_us,
-                well_known_security,
-            ],
-        )
-        .register(
-            "/",
-            rocket::catchers![not_found, unprocessable_content, catch_error],
-        )
+// #[rocket::launch]
+// async fn rocket() -> _ {
+//     let templating = Template::custom(|engine| {
+//         engine
+//             .handlebars
+//             .register_helper("fluent", Box::new(FluentHelper::new(create_loader())));
+//         engine
+//             .handlebars
+//             .register_helper("team-text", Box::new(TeamHelper::new()));
+//         engine
+//             .handlebars
+//             .register_helper("encode-zulip-stream", Box::new(encode_zulip_stream));
+//     });
+//
+//     let rust_version = RustVersion::fetch().await.unwrap_or_default();
+//     let teams = RustTeams::fetch().await.unwrap_or_default();
+//
+//     rocket::build()
+//         .attach(templating)
+//         .attach(headers::InjectHeaders)
+//         .manage(Arc::new(RwLock::new(rust_version)))
+//         .manage(Arc::new(RwLock::new(teams)))
+//         .mount(
+//             "/",
+//             rocket::routes![
+//                 index,
+//                 category_en,
+//                 governance,
+//                 team,
+//                 subject,
+//                 files,
+//                 robots_txt,
+//                 logos,
+//                 index_locale,
+//                 category_locale,
+//                 governance_locale,
+//                 team_locale,
+//                 subject_locale,
+//                 redirect_bare_en_us,
+//                 well_known_security,
+//             ],
+//         )
+//         .register(
+//             "/",
+//             rocket::catchers![not_found, unprocessable_content, catch_error],
+//         )
+// }
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let rust_version = RustVersion::fetch().await?;
+    let teams = RustTeams::fetch().await?;
+    render::render(rust_version, teams)?;
+
+    Ok(())
 }

src/main.rs

@@ -0,0 +1,125 @@
+use crate::render::fs::ensure_directory;
+use anyhow::Context;
+use rocket::serde::Serialize;
+use sass_rs::{Options, compile_file};
+use std::fs;
+use std::hash::{DefaultHasher, Hasher};
+use std::path::Path;
+
+fn write_file(path: &Path, bytes: &[u8]) -> anyhow::Result<()> {
+    ensure_directory(path)?;
+    Ok(fs::write(path, bytes)?)
+}
+
+fn hash_string(content: &str) -> String {
+    let mut hasher = DefaultHasher::new();
+    hasher.write(content.as_bytes());
+    hasher.finish().to_string()
+}
+
+fn relative_url(path: &Path, out_dir: &Path) -> anyhow::Result<String> {
+    Ok(path.strip_prefix(out_dir)?.to_str().unwrap().to_string())
+}
+
+/// Compiles SASS file, stores it in `out_dir` and returns the relative URL to it.
+fn compile_sass(root_dir: &Path, out_dir: &Path, filename: &str) -> anyhow::Result<String> {
+    let scss_file = root_dir
+        .join("src")
+        .join("styles")
+        .join(format!("{filename}.scss"));
+
+    let css = compile_file(&scss_file, Options::default())
+        .map_err(|e| anyhow::anyhow!("{e}"))
+        .with_context(|| anyhow::anyhow!("couldn't compile sass: {}", scss_file.display()))?;
+
+    let css_sha = format!("{filename}_{}", hash_string(&css));
+    let out_css_path = out_dir
+        .join("static")
+        .join("styles")
+        .join(format!("{css_sha}.css"));
+
+    write_file(&out_css_path, &css.into_bytes())
+        .with_context(|| anyhow::anyhow!("couldn't write css file: {}", out_css_path.display()))?;
+
+    Ok(relative_url(&out_css_path, &out_dir)?)
+}
+
+fn concat_files(
+    root_dir: &Path,
+    out_dir: &Path,
+    files: &[&str],
+    directory: &str,
+    extension: &str,
+) -> anyhow::Result<String> {
+    let mut concatted = String::new();
+    for filestem in files {
+        let vendor_path = root_dir
+            .join("static")
+            .join(directory)
+            .join(format!("{filestem}.{extension}"));
+        let contents = fs::read_to_string(vendor_path)
+            .with_context(|| anyhow::anyhow!("couldn't read vendor {extension}"))?;
+        concatted.push_str(&contents);
+    }
+
+    let file_sha = format!("vendor_{}", hash_string(&concatted));
+    let out_file_path = out_dir
+        .join("static")
+        .join(directory)
+        .join(format!("{file_sha}.{extension}"));
+
+    write_file(Path::new(&out_file_path), concatted.as_bytes())
+        .with_context(|| anyhow::anyhow!("couldn't write vendor {extension}"))?;
+
+    Ok(relative_url(&out_file_path, &out_dir)?)
+}
+
+fn concat_vendor_css(root_dir: &Path, out_dir: &Path, files: Vec<&str>) -> anyhow::Result<String> {
+    concat_files(root_dir, out_dir, &files, "styles", "css")
+}
+
+fn concat_app_js(root_dir: &Path, out_dir: &Path, files: Vec<&str>) -> anyhow::Result<String> {
+    concat_files(root_dir, out_dir, &files, "scripts", "js")
+}
+
+#[derive(Serialize, Debug)]
+pub struct CSSFiles {
+    app: String,
+    fonts: String,
+    vendor: String,
+}
+
+#[derive(Serialize, Debug)]
+pub struct JSFiles {
+    app: String,
+}
+
+#[derive(Serialize, Debug)]
+pub struct AssetFiles {
+    css: CSSFiles,
+    js: JSFiles,
+}
+
+/// Compile all statics JS/CSS assets into the `out_dir` directory and return a structure
+/// that holds paths to them, based on the passed `baseurl`.
+pub fn compile_assets(
+    root_dir: &Path,
+    out_dir: &Path,
+    baseurl: &str,
+) -> anyhow::Result<AssetFiles> {
+    let app_css_file = compile_sass(root_dir, out_dir, "app")?;
+    let fonts_css_file = compile_sass(root_dir, out_dir, "fonts")?;
+    let vendor_css_file = concat_vendor_css(root_dir, out_dir, vec!["tachyons"])?;
+    let app_js_file = concat_app_js(root_dir, out_dir, vec!["tools-install"])?;
+
+    Ok(AssetFiles {
+        css: CSSFiles {
+            app: format!("{baseurl}{app_css_file}"),
+            fonts: format!("{baseurl}{fonts_css_file}"),
+            vendor: format!("{baseurl}{vendor_css_file}"),
+        },
+        js: JSFiles {
+            app: format!("{baseurl}{app_js_file}"),
+        },
+    })
+}

src/render/assets.rs

@@ -0,0 +1,11 @@
+use anyhow::Context;
+use std::path::Path;
+
+pub fn ensure_directory(path: &Path) -> anyhow::Result<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).with_context(|| {
+            anyhow::anyhow!("Could not create parent directory for {}", path.display())
+        })?;
+    }
+    Ok(())
+}