Add governance pages

Author: Kobzol

src/main.rs

@@ -1,19 +1,18 @@
 use crate::assets::{AssetFiles, compile_assets};
-use crate::category::Category;
 use crate::fs::ensure_directory;
 use crate::i18n::{EXPLICIT_LOCALE_INFO, LocaleInfo, SUPPORTED_LOCALES, TeamHelper, create_loader};
 use crate::rust_version::{RustVersion, fetch_rust_version};
-use crate::teams::{RustTeams, load_rust_teams};
+use crate::teams::{PageData, RustTeams, encode_zulip_stream, load_rust_teams};
 use anyhow::Context;
 use handlebars::{DirectorySourceOptions, Handlebars};
 use handlebars_fluent::{FluentHelper, Loader, SimpleLoader};
 use serde::Serialize;
+use std::ffi::OsStr;
 use std::fs::File;
 use std::io::BufWriter;
 use std::path::{Path, PathBuf};
 
 mod assets;
-mod category;
 mod fs;
 mod i18n;
 mod rust_version;
@@ -67,7 +66,10 @@ impl<'a, T: Serialize> PageCtx<'a, T> {
 
         let out_path = self.output_dir.join(path);
         ensure_directory(&out_path)?;
-        let mut output_file = BufWriter::new(File::create(&out_path)?);
+        let mut output_file = BufWriter::new(
+            File::create(&out_path)
+                .with_context(|| anyhow::anyhow!("Cannot create file at {}", path.display()))?,
+        );
         eprintln!("Rendering `{template}` into {}", out_path.display());
 
         self.handlebars
@@ -84,6 +86,7 @@ impl<'a, T: Serialize> PageCtx<'a, T> {
 
 struct RenderCtx<'a> {
     handlebars: Handlebars<'a>,
+    template_dir: PathBuf,
     fluent_loader: SimpleLoader,
     output_dir: PathBuf,
     rust_version: RustVersion,
@@ -124,16 +127,28 @@ impl<'a> RenderCtx<'a> {
         }
     }
 
-    fn copy_static_assets<P: AsRef<Path>>(&self, src_dir: P, dst_dir: P) -> anyhow::Result<()> {
+    fn copy_asset_dir<P: AsRef<Path>>(&self, src_dir: P, dst_dir: P) -> anyhow::Result<()> {
         let dst = self.output_dir.join(dst_dir.as_ref());
         println!(
-            "Copying static assets from {} to {}",
+            "Copying static asset directory from {} to {}",
             src_dir.as_ref().display(),
             dst.display()
         );
         copy_dir_all(src_dir.as_ref(), dst)?;
         Ok(())
     }
+
+    fn copy_asset_file<P: AsRef<Path>>(&self, src: P, dst: P) -> anyhow::Result<()> {
+        let dst = self.output_dir.join(dst.as_ref());
+        println!(
+            "Copying static asset file from {} to {}",
+            src.as_ref().display(),
+            dst.display()
+        );
+        ensure_directory(&dst)?;
+        std::fs::copy(src.as_ref(), dst)?;
+        Ok(())
+    }
 }
 
 /// Calls `func` for all supported languages.
@@ -181,6 +196,7 @@ fn setup_handlebars() -> anyhow::Result<Handlebars<'static>> {
     let helper = FluentHelper::new(loader);
     handlebars.register_helper("fluent", Box::new(helper));
     handlebars.register_helper("team-text", Box::new(TeamHelper::new()));
+    handlebars.register_helper("encode-zulip-stream", Box::new(encode_zulip_stream));
     Ok(handlebars)
 }
 
@@ -194,28 +210,35 @@ async fn main() -> anyhow::Result<()> {
     let _ = std::fs::remove_dir_all(&output_dir);
     std::fs::create_dir_all(&output_dir)?;
 
-    let assets = compile_assets(Path::new("."), &output_dir, "/")?;
+    let root_dir = Path::new(".");
+    let assets = compile_assets(root_dir, &output_dir, "/")?;
     let handlebars = setup_handlebars()?;
 
     let ctx = RenderCtx {
+        template_dir: root_dir.join("templates"),
         fluent_loader: create_loader(),
         assets,
         rust_version,
         teams,
         handlebars,
         output_dir,
     };
-    ctx.copy_static_assets("static", "static")?;
+    ctx.copy_asset_dir("static", "static")?;
+    ctx.copy_asset_file(
+        "static/text/well_known_security.txt",
+        ".well-known/security.txt",
+    )?;
 
     render_index(&ctx)?;
     render_governance(&ctx)?;
-    render_category(&ctx, "community")?;
-    render_category(&ctx, "learn")?;
-    render_category(&ctx, "policies")?;
-    render_category(&ctx, "tools")?;
-    render_category(&ctx, "what")?;
+    render_directory(&ctx, "community")?;
+    render_directory(&ctx, "learn")?;
+    render_directory(&ctx, "policies")?;
+    render_directory(&ctx, "tools")?;
+    render_directory(&ctx, "what")?;
+    ctx.page("404", "", &(), ENGLISH).render("404.html")?;
 
-    // TODO: 404, redirects
+    // TODO: redirects
 
     Ok(())
 }
@@ -243,18 +266,78 @@ fn render_governance(render_ctx: &RenderCtx) -> anyhow::Result<()> {
         render_ctx
             .page("governance/index", "governance-page-title", &data, lang)
             .render(dst_path)
-    })
+    })?;
+    for team in data.teams {
+        let data: PageData = render_ctx
+            .teams
+            .page_data(team.section, &team.page_name)
+            .unwrap_or_else(|error| panic!("Page data for team {team:?} not found: {error:?}"));
+
+        // We need to render into index.html to have an extensionless URL
+        all_langs(
+            &format!("governance/{}/index.html", team.url),
+            |dst_path, lang| {
+                render_ctx
+                    .page(
+                        "governance/group",
+                        &format!("governance-team-{}-title", team.team.name),
+                        &data,
+                        lang,
+                    )
+                    .render(dst_path)
+            },
+        )?;
+    }
+
+    Ok(())
 }
 
-fn render_category(render_ctx: &RenderCtx, category: &str) -> anyhow::Result<()> {
-    all_langs(&format!("{category}/index.html"), |dst_path, lang| {
-        render_ctx
-            .page(
-                &format!("{category}/index"),
-                &format!("{category}-page-title"),
-                &(),
-                lang,
-            )
-            .render(dst_path)
-    })
+/// Render all templates found in the given directory.
+fn render_directory(render_ctx: &RenderCtx, category: &str) -> anyhow::Result<()> {
+    for dir in std::fs::read_dir(render_ctx.template_dir.join(category))? {
+        let path = dir?.path();
+        if path.is_file() && path.extension() == Some(OsStr::new("hbs")) {
+            // foo.html.hbs => foo
+            let subject = path
+                .file_stem()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .split(".")
+                .next()
+                .unwrap();
+
+            // The "root" page of a category
+            if subject == "index" {
+                all_langs(&format!("{category}/index.html"), |dst_path, lang| {
+                    render_ctx
+                        .page(
+                            &format!("{category}/index"),
+                            &format!("{category}-page-title"),
+                            &(),
+                            lang,
+                        )
+                        .render(dst_path)
+                })?;
+            } else {
+                // A subpage (subject) of the category
+                // We need to render the page into a subdirectory, so that /foo/bar works without
+                // needing a HTML suffix.
+                all_langs(
+                    &format!("{category}/{subject}/index.html"),
+                    |dst_path, lang| {
+                        render_ctx
+                            .page(
+                                &format!("{category}/{subject}"),
+                                &format!("{category}-{subject}-page-title"),
+                                &(),
+                                lang,
+                            )
+                            .render(dst_path)
+                    },
+                )?;
+            }
+        }
+    }
+    Ok(())
 }

src/teams.rs

@@ -1,7 +1,7 @@
-use percent_encoding::{AsciiSet, NON_ALPHANUMERIC, utf8_percent_encode};
-use rocket_dyn_templates::handlebars::{
+use handlebars::{
     Context, Handlebars, Helper, HelperResult, Output, RenderContext, RenderErrorReason,
 };
+use percent_encoding::{AsciiSet, NON_ALPHANUMERIC, utf8_percent_encode};
 use rust_team_data::v1::{BASE_URL, Team, TeamKind, Teams};
 use serde::Serialize;
 use std::cmp::Reverse;
@@ -66,6 +66,8 @@ impl RustTeams {
             // teams.
             .filter(|team| team.kind == TeamKind::Team && team.subteam_of.is_none())
             .map(|team| IndexTeam {
+                section: kind_to_str(team.kind),
+                page_name: team.website_data.clone().unwrap().page,
                 url: format!(
                     "{}/{}",
                     kind_to_str(team.kind),
@@ -81,13 +83,15 @@ impl RustTeams {
         IndexData { teams }
     }
 
-    pub fn page_data(&self, section: &str, team_name: &str) -> anyhow::Result<PageData> {
+    pub fn page_data(&self, section: &str, team_page_name: &str) -> anyhow::Result<PageData> {
         let teams = self.0.clone();
 
         // Find the main team first
         let main_team = teams
             .iter()
-            .filter(|team| team.website_data.as_ref().map(|ws| ws.page.as_str()) == Some(team_name))
+            .filter(|team| {
+                team.website_data.as_ref().map(|ws| ws.page.as_str()) == Some(team_page_name)
+            })
             .find(|team| kind_to_str(team.kind) == section)
             .cloned()
             .ok_or(TeamNotFound)?;
@@ -187,19 +191,21 @@ impl RustTeams {
 
 #[derive(Serialize)]
 pub struct IndexData {
-    teams: Vec<IndexTeam>,
+    pub teams: Vec<IndexTeam>,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, Debug)]
 pub struct IndexTeam {
     #[serde(flatten)]
-    team: Team,
-    url: String,
+    pub team: Team,
+    pub url: String,
+    pub section: &'static str,
+    pub page_name: String,
 }
 
 #[derive(Serialize)]
 pub struct PageData {
-    pub team: Team,
+    team: Team,
     zulip_domain: &'static str,
     subteams: Vec<Team>,
     wgs: Vec<Team>,