markupwright 0.1.3

Template-driven workspace documentation generator
Documentation
use std::collections::BTreeMap;

use pulldown_cmark::{Event, HeadingLevel, Parser, Tag, TagEnd};

use crate::markdown::{List, anchor_link};

const TOC_MARKER: &str = "<!-- block:toc -->";

#[must_use]
pub(crate) fn inject(output: &str) -> String {
    if !output.contains(TOC_MARKER) {
        return output.to_string();
    }

    let toc = build(output);

    output.replace(TOC_MARKER, &toc)
}

fn build(rendered: &str) -> String {
    let mut headings = Vec::new();
    let mut current = None;

    for event in Parser::new(rendered) {
        match event {
            Event::Start(Tag::Heading {
                level: HeadingLevel::H2,
                ..
            }) => current = Some(String::new()),

            Event::Text(text) | Event::Code(text) => {
                if let Some(heading) = &mut current {
                    heading.push_str(&text);
                }
            }

            Event::SoftBreak | Event::HardBreak => {
                if let Some(heading) = &mut current {
                    heading.push(' ');
                }
            }

            Event::End(TagEnd::Heading(HeadingLevel::H2)) => {
                if let Some(heading) = current.take().filter(|heading| !heading.is_empty()) {
                    headings.push(heading);
                }
            }

            _ => {}
        }
    }

    let mut anchors = BTreeMap::<String, usize>::new();
    let items = headings.into_iter().map(|heading| {
        let base = to_anchor(&heading);
        let count = anchors.entry(base.clone()).or_default();
        let anchor = if *count == 0 {
            base
        } else {
            format!("{base}-{count}")
        };

        *count += 1;

        anchor_link(heading, anchor)
    });

    List::new().items(items).build()
}

fn to_anchor(heading: &str) -> String {
    heading
        .to_lowercase()
        .chars()
        .filter_map(|c| match c {
            ' ' | '-' => Some('-'),
            ch if ch.is_alphanumeric() => Some(ch),
            _ => None,
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;

    #[gtest]
    fn anchor_lowercases_and_replaces_spaces() -> Result<()> {
        verify_eq!(to_anchor("HTTP API"), "http-api")?;
        verify_eq!(to_anchor("How scheduling works"), "how-scheduling-works")?;

        verify_eq!(to_anchor("Cargo features"), "cargo-features")
    }

    #[gtest]
    fn anchor_strips_punctuation() -> Result<()> {
        verify_eq!(to_anchor("What's new?"), "whats-new")?;

        verify_eq!(to_anchor("C/C++ support"), "cc-support")
    }

    #[gtest]
    fn build_extracts_h2_only() {
        let input = "# Title\n## Section A\n### Sub\n## Section B\n";
        let rendered = build(input);

        assert_eq!(
            rendered,
            "- [Section A](#section-a)\n- [Section B](#section-b)"
        );
    }

    #[gtest]
    fn inject_replaces_marker() {
        let input = "<!-- block:toc -->\n\n## Usage\n\n## Tests\n";
        let rendered = inject(input);

        assert_eq!(
            rendered,
            "- [Usage](#usage)\n- [Tests](#tests)\n\n## Usage\n\n## Tests\n"
        );
    }

    #[gtest]
    fn inject_noop_without_marker() -> Result<()> {
        let input = "## Usage\n## Tests\n";

        verify_eq!(inject(input), input)
    }

    #[gtest]
    fn build_empty_when_no_headings() -> Result<()> {
        verify_eq!(build("# Title\nSome text.\n"), "")
    }

    #[gtest]
    fn build_ignores_headings_inside_code_blocks() -> Result<()> {
        verify_eq!(
            build("## Real\n\n```markdown\n## Not a heading\n```\n"),
            "- [Real](#real)"
        )
    }

    #[gtest]
    fn build_numbers_duplicate_heading_anchors() -> Result<()> {
        verify_eq!(
            build("## Repeated\n\n## Repeated\n"),
            "- [Repeated](#repeated)\n- [Repeated](#repeated-1)"
        )
    }
}