feat(templs): add js prop attr and svginfo

Author: fiji-flo

Diff for: Cargo.lock

@@ -10,3 +10,4 @@
 - [ ] unify link rendering
 - [ ] locale compare for sidebar?!
 - [ ] l10n for jsref
+- [ ] deal with summary() in templs

Diff for: TODO.md

@@ -0,0 +1,49 @@
+use rari_l10n::l10n_json_data;
+use rari_templ_func::rari_f;
+
+use crate::error::DocError;
+
+#[rari_f]
+pub fn js_property_attributes(
+    writable: i64,
+    enumerable: i64,
+    configurable: i64,
+) -> Result<String, DocError> {
+    let writable = writable != 0;
+    let enumerable = enumerable != 0;
+    let configurable = configurable != 0;
+    let yes = l10n_json_data("Template", "yes", env.locale)?;
+    let no = l10n_json_data("Template", "no", env.locale)?;
+
+    let mut out = String::new();
+    out.extend([
+        r#"<table class="standard-table"><thead><tr><th class="header" colspan="2">"#,
+        l10n_json_data(
+            "Template",
+            "js_property_attributes_header_prefix",
+            env.locale,
+        )?,
+        "<code>",
+        env.title,
+        "</code>",
+        l10n_json_data(
+            "Template",
+            "js_property_attributes_header_suffix",
+            env.locale,
+        )?,
+        r#"</th></tr></thead><tbody><tr><td>"#,
+        l10n_json_data("Template", "writable", env.locale)?,
+        r#"</td><td>"#,
+        if writable { yes } else { no },
+        r#"</td></tr><tr><td>"#,
+        l10n_json_data("Template", "enumerable", env.locale)?,
+        r#"</td><td>"#,
+        if enumerable { yes } else { no },
+        r#"</td></tr><tr><td>"#,
+        l10n_json_data("Template", "configurable", env.locale)?,
+        r#"</td><td>"#,
+        if configurable { yes } else { no },
+        r#"</td></tr></tbody></table>"#,
+    ]);
+    Ok(out)
+}

Diff for: crates/rari-doc/src/templ/templs/js_property_attributes.rs

@@ -6,7 +6,7 @@ use crate::templ::api::RariApi;
 #[rari_f]
 pub fn svgattr(name: String) -> Result<String, DocError> {
     let url = format!(
-        "/{}/docs/Web/SVG/Atrribute/{}",
+        "/{}/docs/Web/SVG/Attribute/{}",
         env.locale.as_url_str(),
         name,
     );

Diff for: crates/rari-doc/src/templ/templs/links/svgattr.rs

@@ -1,15 +1,20 @@
 use rari_templ_func::rari_f;
+use rari_types::locale::Locale;
 use rari_types::AnyArg;
 
 use crate::error::DocError;
 use crate::templ::api::RariApi;
 
 #[rari_f]
 pub fn svgxref(element_name: String, _: Option<AnyArg>) -> Result<String, DocError> {
+    svgxref_internal(&element_name, env.locale)
+}
+
+pub fn svgxref_internal(element_name: &str, locale: Locale) -> Result<String, DocError> {
     let display = format!("<{element_name}>");
     let url = format!(
         "/{}/docs/Web/SVG/Element/{}",
-        env.locale.as_url_str(),
+        locale.as_url_str(),
         element_name,
     );
 

Diff for: crates/rari-doc/src/templ/templs/links/svgxref.rs

@@ -8,12 +8,14 @@ pub mod firefox_for_developers;
 pub mod glossary;
 pub mod inheritance_diagram;
 pub mod inline_labels;
+pub mod js_property_attributes;
 pub mod links;
 pub mod listsubpages;
 pub mod previous_menu_next;
 pub mod quick_links_with_subpages;
 pub mod sidebars;
 pub mod specification;
+pub mod svginfo;
 pub mod web_ext_examples;
 
 use rari_types::globals::deny_warnings;
@@ -47,6 +49,8 @@ pub fn invoke(
         "inheritancediagram" => inheritance_diagram::inheritance_diagram_any,
         "webextexamples" => web_ext_examples::web_ext_examples_any,
         "firefox_for_developers" => firefox_for_developers::firefox_for_developers_any,
+        "js_property_attributes" => js_property_attributes::js_property_attributes_any,
+        "svginfo" => svginfo::svginfo_any,
 
         // prev menu next
         "previousmenunext" => previous_menu_next::previous_next_menu_any,

Diff for: crates/rari-doc/src/templ/templs/mod.rs

@@ -0,0 +1,111 @@
+use rari_l10n::l10n_json_data;
+use rari_templ_func::rari_f;
+use rari_types::globals::{json_svg_data_lookup, SVGDataDescription};
+
+use super::links::svgxref::svgxref_internal;
+use crate::error::DocError;
+use crate::templ::api::RariApi;
+
+#[rari_f]
+pub fn svginfo() -> Result<String, DocError> {
+    let name = env
+        .slug
+        .rsplit_once('/')
+        .map(|(_, name)| name)
+        .ok_or_else(|| DocError::InvalidSlugForX(env.slug.to_string()))?;
+    let info = json_svg_data_lookup().get(name);
+
+    let mut out = String::new();
+    if let Some(info) = info {
+        out.extend([
+            r#"<table class="properties"><tbody><tr><th scope="row">"#,
+            l10n_json_data("SVG", "categories", env.locale)?,
+            r#"</th><td>"#,
+        ]);
+        out.extend(itertools::intersperse(
+            info.categories.iter().map(|category| {
+                l10n_json_data("SVG", category, env.locale).unwrap_or(category.as_str())
+            }),
+            l10n_json_data("Common", "listSeparator", env.locale).unwrap_or(", "),
+        ));
+        out.push_str(r#"</td></tr>"#);
+
+        let (element_groups, elements): (Vec<String>, Vec<String>) =
+            info.content.elements.iter().try_fold(
+                (vec![], vec![]),
+                |(mut element_groups, mut elements), element| {
+                    if element.contains("&lt;") {
+                        let element_name = element.strip_prefix("&lt;").unwrap_or(element);
+                        let element_name =
+                            element_name.strip_suffix("&gt;").unwrap_or(element_name);
+                        elements.push(svgxref_internal(element_name, env.locale)?)
+                    } else {
+                        let anchor = to_snake_case(element);
+                        let url =
+                            format!("/{}/docs/Web/SVG/Element#{anchor}", env.locale.as_url_str());
+                        let display = l10n_json_data("SVG", element, env.locale).unwrap_or(element);
+                        let link = RariApi::link(&url, None, Some(display), false, None, false)?;
+                        element_groups.push(link);
+                    }
+                    Ok::<_, DocError>((element_groups, elements))
+                },
+            )?;
+
+        out.extend([
+            r#"<tr><th scope="row">"#,
+            l10n_json_data("SVG", "permittedContent", env.locale)?,
+            r#"</th><td>"#,
+            match info.content.description {
+                SVGDataDescription::Copy(ref s) => l10n_json_data("SVG", s, env.locale)?,
+                SVGDataDescription::L10n(ref map) => map
+                    .get(&env.locale)
+                    .or(map.get(&Default::default()))
+                    .map(|s| s.as_str())
+                    .unwrap_or_default(),
+            },
+        ]);
+
+        if !element_groups.is_empty() {
+            out.push_str("<br/>");
+            out.extend(itertools::intersperse(
+                element_groups.iter().map(|s| s.as_str()),
+                "<br/>",
+            ))
+        }
+        if !elements.is_empty() {
+            out.push_str("<br/>");
+            out.extend(itertools::intersperse(
+                elements.iter().map(|s| s.as_str()),
+                l10n_json_data("Common", "listSeparator", env.locale).unwrap_or(", "),
+            ))
+        }
+
+        out.push_str(r#"</td></tr></tbody></table>"#);
+    } else {
+        return Err(DocError::InvalidTempl(format!("No svginfor for {name}")));
+    }
+
+    Ok(out)
+}
+
+fn to_snake_case(s: &str) -> String {
+    let underscore_count = s
+        .chars()
+        .skip(1)
+        .filter(|&c| c.is_ascii_uppercase())
+        .count();
+    let mut result = String::with_capacity(s.len() + underscore_count);
+
+    for (i, c) in s.chars().enumerate() {
+        if c.is_ascii_uppercase() {
+            if i != 0 {
+                result.push('_');
+            }
+            result.push(c.to_ascii_lowercase());
+        } else {
+            result.push(c);
+        }
+    }
+
+    result
+}

Diff for: crates/rari-doc/src/templ/templs/svginfo.rs

@@ -8,3 +8,5 @@ license.workspace = true
 [dependencies]
 rari-types = { path = "../rari-types" }
 thiserror = "1"
+once_cell = "1"
+serde_json = { version = "1", features = ["preserve_order"] }

Diff for: crates/rari-l10n/Cargo.toml

@@ -1,6 +1,8 @@
 use std::collections::HashMap;
+use std::fs;
 
-use rari_types::globals::json_l10n_files;
+use once_cell::sync::OnceCell;
+use rari_types::globals::content_root;
 use rari_types::locale::Locale;
 use thiserror::Error;
 
@@ -31,3 +33,44 @@ pub fn get_for_locale<T>(locale: Locale, lookup: &HashMap<String, T>) -> Option<
         None
     }
 }
+pub type JsonL10nFile = HashMap<String, HashMap<String, String>>;
+
+pub static JSON_L10N_FILES: OnceCell<HashMap<String, JsonL10nFile>> = OnceCell::new();
+
+pub fn json_l10n_files() -> &'static HashMap<String, JsonL10nFile> {
+    JSON_L10N_FILES.get_or_init(|| {
+        content_root()
+            .join("jsondata")
+            .read_dir()
+            .expect("unable to read jsondata dir")
+            .filter_map(|f| {
+                if let Ok(f) = f {
+                    if f.path().is_file()
+                        && f.path()
+                            .extension()
+                            .map_or(false, |ext| ext.eq_ignore_ascii_case("json"))
+                        && f.path()
+                            .file_stem()
+                            .and_then(|s| s.to_str())
+                            .map_or(false, |s| s.starts_with("L10n-"))
+                    {
+                        return Some(f.path());
+                    }
+                }
+                None
+            })
+            .map(|f| {
+                let typ = f
+                    .file_stem()
+                    .and_then(|s| s.to_str())
+                    .unwrap_or_default()
+                    .strip_prefix("L10n-")
+                    .unwrap_or_default();
+                let json_str = fs::read_to_string(&f).expect("unable to read l10n json");
+                let l10n_json: JsonL10nFile =
+                    serde_json::from_str(&json_str).expect("unable to parse l10n json");
+                (typ.into(), l10n_json)
+            })
+            .collect()
+    })
+}

Diff for: crates/rari-l10n/src/lib.rs

@@ -6,6 +6,7 @@ use once_cell::sync::{Lazy, OnceCell};
 use serde::Deserialize;
 
 use crate::error::EnvError;
+use crate::locale::Locale;
 use crate::settings::Settings;
 use crate::{HistoryEntry, Popularities};
 
@@ -83,47 +84,47 @@ pub fn json_spec_data_lookup() -> &'static JsonSpecDataLookup {
     })
 }
 
-pub type JsonL10nFile = HashMap<String, HashMap<String, String>>;
-
-pub static JSON_L10N_FILES: OnceCell<HashMap<String, JsonL10nFile>> = OnceCell::new();
-
-pub fn json_l10n_files() -> &'static HashMap<String, JsonL10nFile> {
-    JSON_L10N_FILES.get_or_init(|| {
-        content_root()
-            .join("jsondata")
-            .read_dir()
-            .expect("unable to read jsondata dir")
-            .filter_map(|f| {
-                if let Ok(f) = f {
-                    if f.path().is_file()
-                        && f.path()
-                            .extension()
-                            .map_or(false, |ext| ext.eq_ignore_ascii_case("json"))
-                        && f.path()
-                            .file_stem()
-                            .and_then(|s| s.to_str())
-                            .map_or(false, |s| s.starts_with("L10n-"))
-                    {
-                        return Some(f.path());
-                    }
-                }
-                None
-            })
-            .map(|f| {
-                let typ = f
-                    .file_stem()
-                    .and_then(|s| s.to_str())
-                    .unwrap_or_default()
-                    .strip_prefix("L10n-")
-                    .unwrap_or_default();
-                let json_str = fs::read_to_string(&f).expect("unable to read l10n json");
-                let l10n_json: JsonL10nFile =
-                    serde_json::from_str(&json_str).expect("unable to parse l10n json");
-                (typ.into(), l10n_json)
-            })
-            .collect()
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+pub enum SVGDataDescription {
+    Copy(String),
+    L10n(HashMap<Locale, String>),
+}
+
+#[derive(Debug, Deserialize)]
+pub struct SVGDataContent {
+    pub description: SVGDataDescription,
+    #[serde(default)]
+    pub elements: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct SVGData {
+    pub categories: Vec<String>,
+    pub content: SVGDataContent,
+    pub attributes: Vec<String>,
+    pub interfaces: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct SVGDataContainer {
+    elements: HashMap<String, SVGData>,
+}
+
+pub type JsonSVGDataLookup = HashMap<String, SVGData>;
+
+pub static JSON_SVG_DATA_FILE: OnceCell<JsonSVGDataLookup> = OnceCell::new();
+
+pub fn json_svg_data_lookup() -> &'static JsonSVGDataLookup {
+    JSON_SVG_DATA_FILE.get_or_init(|| {
+        let json_str = fs::read_to_string(content_root().join("jsondata/SVGData.json"))
+            .expect("unable to read SVGData.json");
+        let data: SVGDataContainer =
+            serde_json::from_str(&json_str).expect("unabeld to parse SVGData.json");
+        data.elements
     })
 }
+
 pub static GIT_HISTORY: Lazy<HashMap<PathBuf, HistoryEntry>> = Lazy::new(|| {
     let f = content_root().join("en-US").join("_history.json");
     if let Ok(json_str) = fs::read_to_string(f) {