feat(sidebars): start supporting inline sidebars

Author: fiji-flo

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

@@ -16,7 +16,7 @@ use crate::resolve::url_to_path_buf;
 pub fn build_single_page(page: &Page) {
     let slug = &page.slug();
     let locale = page.locale();
-    let span = span!(Level::ERROR, "ctx", "{}:{}", locale, slug);
+    let span = span!(Level::ERROR, "page", "{}:{}", locale, slug);
     let _enter = span.enter();
     let built_page = match page {
         Page::Doc(doc) => build_doc(doc),

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

@@ -18,13 +18,13 @@ use super::json::{
 };
 use super::page::PageLike;
 use super::parents::parents;
-use super::sections::{split_sections, BuildSection, BuildSectionType};
 use super::title::{page_title, transform_title};
 use crate::baseline::get_baseline;
 use crate::error::DocError;
 use crate::html::modifier::add_missing_ids;
 use crate::html::rewriter::post_process_html;
-use crate::html::sidebar::render_sidebar;
+use crate::html::sections::{split_sections, BuildSection, BuildSectionType};
+use crate::html::sidebar::build_sidebars;
 use crate::specs::extract_specifications;
 use crate::templ::render::{decode_ref, render};
 
@@ -122,6 +122,7 @@ pub struct PageContent {
     body: Vec<Section>,
     toc: Vec<TocEntry>,
     summary: Option<String>,
+    sidebar: Option<String>,
 }
 
 pub fn make_toc(sections: &[BuildSection], with_h3: bool) -> Vec<TocEntry> {
@@ -143,15 +144,29 @@ pub fn build_content<T: PageLike>(doc: &T) -> Result<PageContent, DocError> {
     let post_processed_html = post_process_html(&html, doc, false)?;
     let mut fragment = Html::parse_fragment(&post_processed_html);
     add_missing_ids(&mut fragment)?;
-    let (sections, summary) = split_sections(&fragment).expect("DOOM");
+    let (sections, summary, sidebar) = split_sections(&fragment).expect("DOOM");
     let toc = make_toc(&sections, matches!(doc.page_type(), PageType::Curriculum));
     let body = sections.into_iter().map(Into::into).collect();
-    Ok(PageContent { body, toc, summary })
+    Ok(PageContent {
+        body,
+        toc,
+        summary,
+        sidebar,
+    })
 }
 
 pub fn build_doc(doc: &Doc) -> Result<BuiltDocy, DocError> {
-    let PageContent { body, toc, summary } = build_content(doc)?;
-    let sidebar_html = render_sidebar(doc)?;
+    let PageContent {
+        body,
+        toc,
+        summary,
+        sidebar,
+    } = build_content(doc)?;
+    let sidebar_html = if sidebar.is_some() {
+        sidebar
+    } else {
+        build_sidebars(doc)?
+    };
     let baseline = get_baseline(&doc.meta.browser_compat);
     let folder = doc
         .meta

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

@@ -6,6 +6,5 @@ pub mod dummy;
 pub mod json;
 pub mod page;
 pub mod parents;
-pub mod sections;
 pub mod title;
 pub mod types;

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

@@ -29,7 +29,7 @@ pub enum DocError {
     WalkError(#[from] ignore::Error),
     #[error(transparent)]
     JsonError(#[from] serde_json::Error),
-    #[error("File not found in static cache: {0}")]
+    #[error("Page not found (static cache): {0}")]
     NotFoundInStaticCache(PathBuf),
     #[error("File cache broken")]
     FileCacheBroken,

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

@@ -1 +1,2 @@
 pub mod css_info;
+pub mod subpages;

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

@@ -0,0 +1,233 @@
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+use std::fmt::Write;
+use std::path::PathBuf;
+
+use rari_types::fm_types::{FeatureStatus, PageType};
+use rari_types::globals::deny_warnings;
+use rari_types::locale::Locale;
+
+use crate::docs::page::{Page, PageLike, PageReader};
+use crate::error::DocError;
+use crate::redirects::resolve_redirect;
+use crate::templ::macros::badges::{write_deprecated, write_experimental, write_non_standard};
+use crate::utils::COLLATOR;
+use crate::walker::walk_builder;
+
+fn title_sorter(a: &Page, b: &Page) -> Ordering {
+    COLLATOR.with(|c| c.compare(a.title(), b.title()))
+}
+
+fn slug_sorter(a: &Page, b: &Page) -> Ordering {
+    COLLATOR.with(|c| c.compare(a.slug(), b.slug()))
+}
+
+fn title_natural_sorter(a: &Page, b: &Page) -> Ordering {
+    natural_compare_with_floats(a.title(), b.title())
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub enum SubPagesSorter {
+    #[default]
+    Title,
+    Slug,
+    TitleNatural,
+}
+
+impl SubPagesSorter {
+    pub fn sorter(&self) -> fn(a: &Page, b: &Page) -> Ordering {
+        match self {
+            SubPagesSorter::Title => title_sorter,
+            SubPagesSorter::Slug => slug_sorter,
+            SubPagesSorter::TitleNatural => title_natural_sorter,
+        }
+    }
+}
+
+pub fn write_li_with_badges(
+    out: &mut impl Write,
+    page: &impl PageLike,
+    locale: Locale,
+) -> Result<(), DocError> {
+    write!(
+        out,
+        "<li><a href=\"{}\">{}</a>",
+        page.url(),
+        html_escape::encode_safe(page.short_title().unwrap_or(page.title()))
+    )?;
+    if page.status().contains(&FeatureStatus::Experimental) {
+        write_experimental(out, locale)?;
+    }
+    if page.status().contains(&FeatureStatus::NonStandard) {
+        write_non_standard(out, locale)?;
+    }
+    if page.status().contains(&FeatureStatus::Deprecated) {
+        write_deprecated(out, locale)?;
+    }
+    Ok(write!(out, "</li>")?)
+}
+
+pub fn list_sub_pages_internal(
+    out: &mut impl Write,
+    url: &str,
+    locale: Locale,
+    depth: Option<usize>,
+    reverse: bool,
+    sorter: Option<SubPagesSorter>,
+    page_types: &[PageType],
+) -> Result<(), DocError> {
+    let sub_pages = get_sub_pages(url, depth, sorter.unwrap_or_default())?;
+
+    if reverse {
+        for sub_page in sub_pages.into_iter().rev() {
+            if !page_types.is_empty() && !page_types.contains(&sub_page.page_type()) {
+                continue;
+            }
+            write_li_with_badges(out, &sub_page, locale)?;
+        }
+    } else {
+        for sub_page in sub_pages {
+            if !page_types.is_empty() && !page_types.contains(&sub_page.page_type()) {
+                continue;
+            }
+            write_li_with_badges(out, &sub_page, locale)?;
+        }
+    }
+    Ok(())
+}
+
+pub fn list_sub_pages_grouped_internal(
+    out: &mut String,
+    url: &str,
+    locale: Locale,
+    sorter: Option<SubPagesSorter>,
+    page_types: &[PageType],
+) -> Result<(), DocError> {
+    let sub_pages = get_sub_pages(url, None, sorter.unwrap_or_default())?;
+
+    let mut grouped = BTreeMap::new();
+    for sub_page in sub_pages.iter() {
+        if !page_types.is_empty() && !page_types.contains(&sub_page.page_type()) {
+            continue;
+        }
+        let title = sub_page.title();
+        let prefix_index = if !title.is_empty() {
+            title[1..].find('-').map(|i| i + 1)
+        } else {
+            None
+        };
+        if let Some(prefix) = prefix_index.map(|i| &title[..i]) {
+            grouped
+                .entry(prefix)
+                .and_modify(|l: &mut Vec<_>| l.push(sub_page))
+                .or_insert(vec![sub_page]);
+        } else {
+            grouped.insert(sub_page.title(), vec![sub_page]);
+        }
+    }
+    for (prefix, group) in grouped {
+        let keep_group = group.len() > 2;
+        if keep_group {
+            out.push_str("<li class=\"toggle\"><details><summary>");
+            out.push_str(prefix);
+            out.push_str("-*</summary><ol>");
+        }
+        for sub_page in group {
+            write_li_with_badges(out, sub_page, locale)?;
+        }
+        if keep_group {
+            out.push_str("</ol></details></li>");
+        }
+    }
+    Ok(())
+}
+
+pub fn get_sub_pages(
+    url: &str,
+    depth: Option<usize>,
+    sorter: SubPagesSorter,
+) -> Result<Vec<Page>, DocError> {
+    let redirect = resolve_redirect(url);
+    let url = match redirect.as_ref() {
+        Some(redirect) if deny_warnings() => {
+            return Err(DocError::RedirectedLink {
+                from: url.to_string(),
+                to: redirect.to_string(),
+            })
+        }
+        Some(redirect) => redirect,
+        None => url,
+    };
+    let doc = Page::page_from_url_path(url)?;
+    let full_path = doc.full_path();
+    if let Some(folder) = full_path.parent() {
+        let sub_folders = walk_builder(&[folder], None)?
+            .max_depth(depth.map(|i| i + 1))
+            .build()
+            .filter_map(|f| f.ok())
+            .filter(|f| {
+                f.file_type().map(|ft| ft.is_file()).unwrap_or(false) && f.path() != full_path
+            })
+            .map(|f| f.into_path())
+            .collect::<Vec<PathBuf>>();
+
+        let mut sub_pages = sub_folders
+            .iter()
+            .map(Page::read)
+            .collect::<Result<Vec<_>, DocError>>()?;
+        sub_pages.sort_by(sorter.sorter());
+        return Ok(sub_pages);
+    }
+    Ok(vec![])
+}
+
+fn split_into_parts(s: &str) -> Vec<(bool, &str)> {
+    let mut parts = Vec::new();
+    let mut start = 0;
+    let mut end = 0;
+    let mut in_number = false;
+
+    for c in s.chars() {
+        if c.is_ascii_digit() || c == '.' {
+            if !in_number {
+                if start != end {
+                    parts.push((false, &s[start..end]));
+                    start = end
+                }
+                in_number = true;
+            }
+        } else if in_number {
+            if start != end {
+                parts.push((true, &s[start..end]));
+                start = end
+            }
+            in_number = false;
+        }
+        end += 1
+    }
+
+    if start != end {
+        parts.push((in_number, &s[start..end]));
+    }
+
+    parts
+}
+
+fn natural_compare_with_floats(a: &str, b: &str) -> Ordering {
+    let parts_a = split_into_parts(a);
+    let parts_b = split_into_parts(b);
+
+    for (part_a, part_b) in parts_a.iter().zip(parts_b.iter()) {
+        let order = if part_a.0 && part_b.0 {
+            let num_a: f64 = part_a.1.parse().unwrap_or(f64::NEG_INFINITY);
+            let num_b: f64 = part_b.1.parse().unwrap_or(f64::INFINITY);
+            num_a.partial_cmp(&num_b).unwrap()
+        } else {
+            part_a.1.cmp(part_b.1)
+        };
+        if order != Ordering::Equal {
+            return order;
+        }
+    }
+    parts_a.len().cmp(&parts_b.len())
+}

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

@@ -1,4 +1,5 @@
 pub mod links;
 pub mod modifier;
 pub mod rewriter;
+pub mod sections;
 pub mod sidebar;

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

@@ -243,14 +243,14 @@ pub fn post_process_html<T: PageLike>(
             el.after("</figure>", ContentType::Html);
             Ok(())
         }),
-    ];
-    if sidebar {
-        element_content_handlers.push(element!("*[data-rewriter=em]", |el| {
+        element!("*[data-rewriter=em]", |el| {
             el.prepend("<em>", ContentType::Html);
             el.append("</em>", ContentType::Html);
             el.remove_attribute("data-rewriter");
             Ok(())
-        }));
+        }),
+    ];
+    if sidebar {
         element_content_handlers.push(element!("html", |el| {
             el.remove_and_keep_content();
             Ok(())

Diff for: crates/rari-doc/src/docs/sections.rs renamed to crates/rari-doc/src/html/sections.rs

@@ -22,7 +22,9 @@ pub struct BuildSection<'a> {
     pub id: Option<String>,
 }
 
-pub fn split_sections(html: &Html) -> Result<(Vec<BuildSection<'_>>, Option<String>), DocError> {
+pub fn split_sections(
+    html: &Html,
+) -> Result<(Vec<BuildSection<'_>>, Option<String>, Option<String>), DocError> {
     let root_children = html.root_element().children();
     let raw_sections = root_children;
     let summary_selector = Selector::parse("p").unwrap();
@@ -34,6 +36,7 @@ pub fn split_sections(html: &Html) -> Result<(Vec<BuildSection<'_>>, Option<Stri
             None
         }
     });
+    let mut sidebar = None;
 
     let (mut sections, mut last) = raw_sections.fold(
         (Vec::new(), None::<BuildSection>),
@@ -100,6 +103,13 @@ pub fn split_sections(html: &Html) -> Result<(Vec<BuildSection<'_>>, Option<Stri
                             id,
                         });
                     }
+                    "section" if element.id() == Some("Quick_links") => {
+                        if let Some(section) = maybe_section.take() {
+                            sections.push(section);
+                        }
+                        let html = ElementRef::wrap(current).unwrap().html();
+                        sidebar = Some(html)
+                    }
                     _ => {
                         let (typ, query, urls) = if element.classes().any(|cls| cls == "bc-data") {
                             (BuildSectionType::Compat, element.attr("data-query"), None)
@@ -223,5 +233,5 @@ pub fn split_sections(html: &Html) -> Result<(Vec<BuildSection<'_>>, Option<Stri
     if let Some(section) = last.take() {
         sections.push(section);
     }
-    Ok((sections, summary))
+    Ok((sections, summary, sidebar))
 }