feat(sidebar): l10n support

also fixes baseline and id generation

Author: fiji-flo

Diff for: Cargo.lock

@@ -19,3 +19,4 @@ itertools = "0.13"
 similar = "2"
 regex = "1"
 once_cell = "1"
+htmldiff = "0.1"

Diff for: crates/diff-test/Cargo.toml

@@ -7,6 +7,7 @@ use std::path::Path;
 
 use anyhow::{anyhow, Error};
 use clap::{Args, Parser, Subcommand};
+use htmldiff::htmldiff;
 use ignore::types::TypesBuilder;
 use ignore::WalkBuilder;
 use itertools::Itertools;
@@ -157,7 +158,7 @@ fn make_key(path: &[PathIndex]) -> String {
 }
 
 fn is_html(s: &str) -> bool {
-    s.starts_with('<') && s.ends_with('>')
+    s.trim_start().starts_with('<') && s.trim_end().ends_with('>')
 }
 
 const IGNORE: &[&str] = &[
@@ -249,7 +250,7 @@ fn full_diff(lhs: &Value, rhs: &Value, path: &[PathIndex], diff: &mut BTreeMap<S
                             //    .to_string(),
                         );
                     } else {
-                        diff.insert(key, "differs".into());
+                        diff.insert(key, htmldiff(&lhs, &rhs));
                     }
                 }
             }

Diff for: crates/diff-test/src/main.rs

@@ -3,24 +3,22 @@ use std::fmt;
 use std::marker::PhantomData;
 use std::path::Path;
 
-use chrono::NaiveDate;
 use rari_utils::io::read_to_string;
 use serde::de::{self, value, SeqAccess, Visitor};
 use serde::{Deserialize, Deserializer, Serialize};
 use url::Url;
 
 use crate::error::Error;
 
+#[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct WebFeatures {
     pub features: BTreeMap<String, FeatureData>,
 }
 
 impl WebFeatures {
     pub fn from_file(path: &Path) -> Result<Self, Error> {
         let json_str = read_to_string(path)?;
-        Ok(Self {
-            features: serde_json::from_str(&json_str)?,
-        })
+        Ok(serde_json::from_str(&json_str)?)
     }
 
     pub fn feature_status(&self, features: &[&str]) -> Option<&SupportStatus> {
@@ -45,13 +43,6 @@ impl WebFeatures {
 
 #[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct FeatureData {
-    /** Alias identifier */
-    #[serde(
-        deserialize_with = "t_or_vec",
-        default,
-        skip_serializing_if = "Vec::is_empty"
-    )]
-    pub alias: Vec<String>,
     /** Specification */
     #[serde(
         deserialize_with = "t_or_vec",
@@ -76,9 +67,6 @@ pub struct FeatureData {
         skip_serializing_if = "Vec::is_empty"
     )]
     pub compat_features: Vec<String>,
-    /** Usage stats */
-    #[serde(deserialize_with = "t_or_vec", default)]
-    pub usage_stats: Vec<Url>,
 }
 
 #[derive(Deserialize, Serialize, Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
@@ -109,10 +97,10 @@ pub struct SupportStatus {
     pub baseline: Option<BaselineHighLow>,
     /// Date the feature achieved Baseline low status
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub baseline_low_date: Option<NaiveDate>,
+    pub baseline_low_date: Option<String>,
     /// Date the feature achieved Baseline high status
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub baseline_high_date: Option<NaiveDate>,
+    pub baseline_high_date: Option<String>,
     /// Browser versions that most-recently introduced the feature
     pub support: BTreeMap<BrowserIdentifier, String>,
 }

Diff for: crates/rari-data/src/baseline.rs

@@ -52,7 +52,7 @@ pub fn get_package(
             let current_version = package_json["version"]
                 .as_str()
                 .ok_or(DepsError::WebRefMissingVersionError)?;
-            current_version == latest_version
+            current_version != latest_version
         } else {
             true
         };

Diff for: crates/rari-deps/src/npm.rs

@@ -8,7 +8,7 @@ static WEB_FEATURES: Lazy<Option<WebFeatures>> = Lazy::new(|| {
         &data_dir()
             .join("web-features")
             .join("package")
-            .join("index.json"),
+            .join("data.json"),
     );
     match web_features {
         Ok(web_features) => Some(web_features),

Diff for: crates/rari-doc/src/baseline.rs

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock};
 
 use once_cell::sync::{Lazy, OnceCell};
-use rari_types::globals::{blog_root, cache_content, curriculum_root};
+use rari_types::globals::{blog_root, cache_content, content_root, curriculum_root};
 use rari_types::locale::Locale;
 use rari_utils::io::read_to_string;
 use tracing::error;
@@ -15,7 +15,7 @@ use crate::docs::page::{Page, PageLike};
 use crate::error::DocError;
 use crate::html::sidebar::{MetaSidebar, Sidebar};
 use crate::sidebars::jsref;
-use crate::utils::{root_for_locale, split_fm};
+use crate::utils::split_fm;
 use crate::walker::{read_docs_parallel, walk_builder};
 
 pub static STATIC_PAGE_FILES: OnceCell<HashMap<PathBuf, Page>> = OnceCell::new();
@@ -50,9 +50,8 @@ pub fn read_sidebar(name: &str, locale: Locale, slug: &str) -> Result<Arc<MetaSi
                     return Ok(sidebar.clone());
                 }
             }
-            let mut file = root_for_locale(locale)?.to_path_buf();
+            let mut file = content_root().to_path_buf();
             file.push("sidebars");
-            file.push(locale.as_folder_str());
             file.push(name);
             file.set_extension("yaml");
             let raw = read_to_string(&file)?;

Diff for: crates/rari-doc/src/cached_readers.rs

@@ -100,10 +100,18 @@ fn doc_from_path_and_locale(path: &Path, locale: Locale) -> Result<Page, DocErro
 }
 
 pub fn url_path_to_page(url_path: &str) -> Result<Page, DocError> {
+    url_path_to_page_with_other_locale_and_fallback(url_path, None)
+}
+
+pub fn url_path_to_page_with_other_locale_and_fallback(
+    url_path: &str,
+    locale: Option<Locale>,
+) -> Result<Page, DocError> {
     if let Some(dummy) = Dummy::from_url(url_path) {
         return Ok(dummy);
     }
-    let (path, locale, typ) = url_path_to_path_buf(url_path)?;
+    let (path, locale_from_url, typ) = url_path_to_path_buf(url_path)?;
+    let locale = locale.unwrap_or(locale_from_url);
     match typ {
         PageCategory::Doc => {
             let doc = doc_from_path_and_locale(&path, locale);

Diff for: crates/rari-doc/src/docs/page.rs

@@ -9,7 +9,9 @@ use rari_types::globals::deny_warnings;
 use rari_types::locale::Locale;
 
 use super::titles::api_page_title;
-use crate::docs::page::{Page, PageLike, PageReader};
+use crate::docs::page::{
+    url_path_to_page_with_other_locale_and_fallback, Page, PageLike, PageReader,
+};
 use crate::error::DocError;
 use crate::redirects::resolve_redirect;
 use crate::templ::templs::badges::{write_deprecated, write_experimental, write_non_standard};
@@ -60,14 +62,19 @@ impl SubPagesSorter {
 
 pub fn write_li_with_badges(
     out: &mut impl Write,
-    page: &impl PageLike,
+    page: &Page,
     locale: Locale,
 ) -> Result<(), DocError> {
+    let locale_page = if locale != Default::default() {
+        &url_path_to_page_with_other_locale_and_fallback(page.url(), Some(locale))?
+    } else {
+        page
+    };
     write!(
         out,
         "<li><a href=\"{}\">{}</a>",
-        page.url(),
-        html_escape::encode_safe(page.short_title().unwrap_or(page.title()))
+        locale_page.url(),
+        html_escape::encode_safe(locale_page.short_title().unwrap_or(locale_page.title()))
     )?;
     if page.status().contains(&FeatureStatus::Experimental) {
         write_experimental(out, locale)?;

Diff for: crates/rari-doc/src/helpers/subpages.rs

@@ -1,3 +1,6 @@
+use std::borrow::Cow;
+use std::collections::HashSet;
+
 use ego_tree::NodeId;
 use html5ever::{namespace_url, ns, QualName};
 use rari_md::anchor::anchorize;
@@ -33,6 +36,13 @@ pub fn remove_attribute(html: &mut Html, node_id: NodeId, key: &str) {
 }
 
 pub fn add_missing_ids(html: &mut Html) -> Result<(), DocError> {
+    let selector = Selector::parse("*[id]").unwrap();
+    let mut ids = html
+        .select(&selector)
+        .filter_map(|el| el.attr("id"))
+        .map(Cow::Borrowed)
+        .collect::<HashSet<_>>();
+
     let selector = Selector::parse("*[data-update-id], h2:not([id]), h3:not([id])").unwrap();
     let subs =
         html.select(&selector)
@@ -45,6 +55,25 @@ pub fn add_missing_ids(html: &mut Html) -> Result<(), DocError> {
                     el.text().collect::<String>()
                 };
                 let id = anchorize(&text);
+                if ids.contains(id.as_str()) {
+                    let (prefix, mut count) = if let Some((prefix, counter)) = id.rsplit_once('_') {
+                        if counter.chars().all(|c| c.is_ascii_digit()) {
+                            let count = counter.parse::<i64>().unwrap_or_default() + 1;
+                            (prefix, count)
+                        } else {
+                            (id.as_str(), 2)
+                        }
+                    } else {
+                        (id.as_str(), 2)
+                    };
+                    let mut id = format!("{prefix}_{count}");
+                    while ids.contains(id.as_str()) && count < 666 {
+                        count += 1;
+                        id = format!("{prefix}_{count}");
+                    }
+                }
+
+                ids.insert(Cow::Owned(id.clone()));
                 (el.id(), id)
             })
             .collect::<Vec<_>>();

Diff for: crates/rari-doc/src/html/modifier.rs

@@ -50,7 +50,7 @@ pub fn post_process_html<T: PageLike>(
     let mut element_content_handlers = vec![
         element!("*[id]", |el| {
             if let Some(id) = el.get_attribute("id") {
-                if !ids.contains(id.as_str()) {
+                if ids.contains(id.as_str()) {
                     let (prefix, mut count) = if let Some((prefix, counter)) = id.rsplit_once('_') {
                         if counter.chars().all(|c| c.is_ascii_digit()) {
                             let count = counter.parse::<i64>().unwrap_or_default() + 1;
@@ -62,10 +62,15 @@ pub fn post_process_html<T: PageLike>(
                         (id.as_str(), 2)
                     };
                     let mut id = format!("{prefix}_{count}");
-                    while !ids.insert(id) && count < 666 {
+                    while ids.contains(&id) && count < 666 {
                         count += 1;
                         id = format!("{prefix}_{count}");
                     }
+
+                    if !ids.contains(&id) && count < 666 {
+                        el.set_attribute("id", &id)?;
+                        ids.insert(id);
+                    }
                 } else {
                     ids.insert(id);
                 }

Diff for: crates/rari-doc/src/html/rewriter.rs

@@ -126,18 +126,41 @@ pub fn build_sidebars(doc: &Doc) -> Result<Option<String>, DocError> {
 
 #[derive(Serialize, Deserialize, Default, Debug)]
 #[serde(transparent)]
+pub struct SidebarL10n {
+    l10n: HashMap<Locale, HashMap<String, String>>,
+}
+
+impl SidebarL10n {
+    pub fn lookup<'a, 'b: 'a>(&'b self, key: &'a str, locale: Locale) -> &'a str {
+        let s = self.l10n.get(&locale).and_then(|l| l.get(key));
+        if locale == Default::default() || s.is_some() {
+            return s.map(|s| s.as_str()).unwrap_or(key);
+        }
+        self.l10n
+            .get(&Default::default())
+            .and_then(|l| l.get(key))
+            .map(|s| s.as_str())
+            .unwrap_or(key)
+    }
+}
+
+#[derive(Serialize, Deserialize, Default, Debug)]
 pub struct Sidebar {
-    pub entries: Vec<SidebarEntry>,
+    pub sidebar: Vec<SidebarEntry>,
+    #[serde(default)]
+    pub l10n: SidebarL10n,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct MetaSidebar {
     pub entries: Vec<SidebarMetaEntry>,
+    pub l10n: SidebarL10n,
 }
 impl From<Sidebar> for MetaSidebar {
     fn from(value: Sidebar) -> Self {
         MetaSidebar {
-            entries: value.entries.into_iter().map(Into::into).collect(),
+            entries: value.sidebar.into_iter().map(Into::into).collect(),
+            l10n: value.l10n,
         }
     }
 }
@@ -147,7 +170,7 @@ impl MetaSidebar {
         let mut out = String::new();
         out.push_str("<ol>");
         for entry in &self.entries {
-            entry.render(&mut out, locale)?;
+            entry.render(&mut out, locale, &self.l10n)?;
         }
         out.push_str("</ol>");
         Ok(out)
@@ -342,7 +365,12 @@ impl From<SidebarEntry> for SidebarMetaEntry {
 }
 
 impl SidebarMetaEntry {
-    pub fn render(&self, out: &mut String, locale: Locale) -> Result<(), DocError> {
+    pub fn render(
+        &self,
+        out: &mut String,
+        locale: Locale,
+        l10n: &SidebarL10n,
+    ) -> Result<(), DocError> {
         out.push_str("<li");
         if self.section {
             out.push_str(" class=\"section\"");
@@ -363,21 +391,15 @@ impl SidebarMetaEntry {
                 link: Some(link),
                 title,
             } => {
-                render_link_via_page(
-                    out,
-                    link,
-                    Some(locale),
-                    title.as_deref(),
-                    self.code,
-                    None,
-                    true,
-                )?;
+                let title = title.as_ref().map(|t| l10n.lookup(t.as_str(), locale));
+                render_link_via_page(out, link, Some(locale), title, self.code, None, true)?;
             }
             SidebarMetaEntryContent::Link { link: None, title } => {
+                let title = title.as_ref().map(|t| l10n.lookup(t.as_str(), locale));
                 if self.code {
                     out.push_str("<code>");
                 }
-                out.push_str(title.as_deref().unwrap_or_default());
+                out.push_str(title.unwrap_or_default());
                 if self.code {
                     out.push_str("</code>");
                 }
@@ -406,7 +428,7 @@ impl SidebarMetaEntry {
         match &self.children {
             MetaChildren::Children(children) => {
                 for child in children {
-                    child.render(out, locale)?;
+                    child.render(out, locale, l10n)?;
                 }
             }
             MetaChildren::ListSubPages(url, page_types) => {