use std::cell::RefCell;
use rushdown::parser::{self, Parser, ParserExtension as _};
use rushdown::renderer::html::{self, RendererExtension as _};
use rushdown::text;
use rushdown_emoji::{
EmojiHtmlRendererOptions, EmojiParserOptions, emoji_html_renderer_extension,
emoji_parser_extension,
};
use rushdown_meta::{MetaParserOptions, meta_parser_extension};
use crate::ast::{self, AstNode, ParseResult};
use crate::error::OxydeError;
use crate::extensions::{
assign_heading_anchors, block_component_html_renderer_extension,
block_component_parser_extension, inline_component_html_renderer_extension,
inline_component_parser_extension, slot_html_renderer_extension, slot_parser_extension,
span_attribute_html_renderer_extension, span_attribute_parser_extension,
};
use crate::html_render::render_ast_to_html;
use crate::slug;
fn build_parser() -> Parser {
let parser_extensions = parser::gfm(parser::GfmOptions::default())
.and(meta_parser_extension(MetaParserOptions::default()))
.and(emoji_parser_extension(EmojiParserOptions::default()))
.and(block_component_parser_extension())
.and(slot_parser_extension())
.and(inline_component_parser_extension())
.and(span_attribute_parser_extension());
let options = parser::Options {
attributes: true,
..parser::Options::default()
};
Parser::with_extensions(options, parser_extensions)
}
fn build_renderer() -> html::Renderer<'static, String> {
html::Renderer::with_extensions(
html::Options::default(),
emoji_html_renderer_extension(EmojiHtmlRendererOptions::default())
.and(block_component_html_renderer_extension())
.and(slot_html_renderer_extension())
.and(inline_component_html_renderer_extension())
.and(span_attribute_html_renderer_extension()),
)
}
thread_local! {
static CACHED_PARSER: RefCell<Parser> = RefCell::new(build_parser());
static CACHED_RENDERER: RefCell<html::Renderer<'static, String>> =
RefCell::new(build_renderer());
}
fn with_parser<R>(f: impl FnOnce(&Parser) -> R) -> R {
CACHED_PARSER.with(|p| f(&p.borrow()))
}
fn with_renderer<R>(f: impl FnOnce(&html::Renderer<'static, String>) -> R) -> R {
CACHED_RENDERER.with(|r| f(&r.borrow()))
}
pub fn parse(markdown: &str) -> AstNode {
with_parser(|parser| {
let mut reader = text::BasicReader::new(markdown);
let (mut arena, document_ref) = parser.parse(&mut reader);
assign_heading_anchors(&mut arena, document_ref, markdown);
ast::arena_to_ast_node(&arena, document_ref, markdown)
})
}
pub fn parse_document(markdown: &str) -> ParseResult {
with_parser(|parser| {
let mut reader = text::BasicReader::new(markdown);
let (mut arena, document_ref) = parser.parse(&mut reader);
assign_heading_anchors(&mut arena, document_ref, markdown);
let frontmatter = ast::document_meta(&arena, document_ref);
let headings = ast::collect_headings(&arena, document_ref, markdown);
let toc = ast::build_toc(&headings);
let summary =
ast::extract_summary_blocks(&arena, document_ref, markdown).map(render_summary_blocks);
let root = ast::arena_to_ast_node(&arena, document_ref, markdown);
ParseResult {
root,
headings,
toc,
summary,
frontmatter,
}
})
}
fn render_summary_blocks(blocks: Vec<AstNode>) -> String {
let summary_doc = AstNode {
kind: "document".to_string(),
children: blocks,
text: None,
attributes: std::collections::HashMap::new(),
metadata: None,
props: None,
};
render_ast_to_html(&summary_doc)
}
pub fn render_ast(node: &AstNode) -> String {
render_ast_to_html(node)
}
pub fn markdown_to_html(markdown: &str) -> Result<String, OxydeError> {
with_parser(|parser| {
let mut reader = text::BasicReader::new(markdown);
let (mut arena, document_ref) = parser.parse(&mut reader);
assign_heading_anchors(&mut arena, document_ref, markdown);
with_renderer(|renderer| {
let mut output = String::new();
renderer
.render(&mut output, markdown, &arena, document_ref)
.map_err(|e| OxydeError::Render(format!("{e}")))?;
Ok(output)
})
})
}
pub fn slugify(text: &str, existing: Option<Vec<String>>) -> String {
match existing {
Some(items) => {
let mut set: std::collections::HashSet<String> = items.into_iter().collect();
slug::slugify_unique(text, &mut set)
}
None => slug::slugify_base(text),
}
}
pub fn extract_summary(markdown: &str) -> Option<String> {
with_parser(|parser| {
let mut reader = text::BasicReader::new(markdown);
let (mut arena, document_ref) = parser.parse(&mut reader);
assign_heading_anchors(&mut arena, document_ref, markdown);
let blocks = ast::extract_summary_blocks(&arena, document_ref, markdown)?;
Some(render_summary_blocks(blocks))
})
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use super::*;
use crate::ast::AstNode;
use crate::extensions;
use crate::html_render::{collect_text, html_escape};
#[test]
fn parse_simple_paragraph() {
let ast = parse("Hello");
assert_eq!(ast.kind, "document");
assert!(!ast.children.is_empty());
let para = &ast.children[0];
assert_eq!(para.kind, "paragraph");
let text_node = ¶.children[0];
assert_eq!(text_node.kind, "text");
assert_eq!(text_node.text.as_deref(), Some("Hello"));
}
#[test]
fn parse_heading() {
let ast = parse("# Title");
let heading = &ast.children[0];
assert_eq!(heading.kind, "heading");
assert_eq!(
heading.attributes.get("level").map(|v| v.as_str()),
Some("1")
);
}
#[test]
fn parse_emphasis_and_strong() {
let ast = parse("*em* **strong**");
let para = &ast.children[0];
assert!(para.children.iter().any(|c| c.kind == "emphasis"));
assert!(para.children.iter().any(|c| c.kind == "strong"));
}
#[test]
fn render_simple_paragraph() {
let html = markdown_to_html("Hello").unwrap();
assert!(html.contains("<p>"));
assert!(html.contains("Hello"));
}
#[test]
fn render_ast_round_trip() {
let ast = parse("Hello **world**");
let html = render_ast_to_html(&ast);
assert!(html.contains("<p>"));
assert!(html.contains("<strong>"));
assert!(html.contains("world"));
}
#[test]
fn render_heading_round_trip() {
let ast = parse("# Title");
let html = render_ast_to_html(&ast);
assert!(html.contains("<h1"));
assert!(html.contains("Title"));
}
#[test]
fn walk_returns_all_nodes() {
let ast = parse("Hello **world**");
let nodes = ast.walk();
let kinds: Vec<&str> = nodes.iter().map(|n| n.kind.as_str()).collect();
assert!(kinds.contains(&"document"));
assert!(kinds.contains(&"paragraph"));
assert!(kinds.contains(&"text"));
assert!(kinds.contains(&"strong"));
}
#[test]
fn parse_frontmatter() {
let input = "---\ntitle: Hello\n---\n\nContent";
let ast = parse(input);
assert_eq!(ast.kind, "document");
assert!(ast.metadata.is_some());
let meta = ast.metadata.as_ref().unwrap();
assert_eq!(meta.get("title").map(|v| v.as_str()), Some("Hello"));
}
#[test]
fn parse_link() {
let ast = parse("[click](https://example.com)");
let para = &ast.children[0];
let link = para.children.iter().find(|c| c.kind == "link").unwrap();
assert_eq!(
link.attributes.get("href").map(|v| v.as_str()),
Some("https://example.com")
);
let text_node = link.children.iter().find(|c| c.kind == "text").unwrap();
assert_eq!(text_node.text.as_deref(), Some("click"));
}
#[test]
fn parse_link_with_title() {
let ast = parse(r#"[click](https://example.com "a title")"#);
let para = &ast.children[0];
let link = para.children.iter().find(|c| c.kind == "link").unwrap();
assert_eq!(
link.attributes.get("href").map(|v| v.as_str()),
Some("https://example.com")
);
assert_eq!(
link.attributes.get("title").map(|v| v.as_str()),
Some("a title")
);
}
#[test]
fn parse_image() {
let ast = parse("");
let para = &ast.children[0];
let img = para.children.iter().find(|c| c.kind == "image").unwrap();
assert_eq!(
img.attributes.get("src").map(|v| v.as_str()),
Some("image.png")
);
}
#[test]
fn parse_code_span() {
let ast = parse("Use `code` here");
let para = &ast.children[0];
assert!(para.children.iter().any(|c| c.kind == "code_span"));
}
#[test]
fn parse_code_span_exposes_its_text() {
let ast = parse("Use `code` here");
let para = &ast.children[0];
let span = para
.children
.iter()
.find(|c| c.kind == "code_span")
.expect("code span");
assert_eq!(span.text.as_deref(), Some("code"));
assert!(render_ast(&ast).contains("<code>code</code>"));
}
#[test]
fn parse_strikethrough() {
let ast = parse("~~deleted~~");
let para = &ast.children[0];
assert!(para.children.iter().any(|c| c.kind == "strikethrough"));
}
#[test]
fn parse_heading_levels() {
for level in 1..=6 {
let input = format!("{} Heading {level}", "#".repeat(level));
let ast = parse(&input);
let heading = &ast.children[0];
assert_eq!(heading.kind, "heading");
assert_eq!(
heading
.attributes
.get("level")
.and_then(|v| v.parse::<usize>().ok()),
Some(level)
);
}
}
#[test]
fn parse_blockquote() {
let ast = parse("> quoted text");
let bq = &ast.children[0];
assert_eq!(bq.kind, "blockquote");
}
#[test]
fn parse_unordered_list() {
let ast = parse("- one\n- two\n- three");
let list = &ast.children[0];
assert_eq!(list.kind, "list");
assert_eq!(
list.children
.iter()
.filter(|c| c.kind == "list_item")
.count(),
3
);
}
#[test]
fn parse_code_block() {
let ast = parse("```\nfn main() {}\n```");
assert!(ast.children.iter().any(|c| c.kind == "code_block"));
}
#[test]
fn parse_thematic_break() {
let ast = parse("***");
assert!(ast.children.iter().any(|c| c.kind == "thematic_break"));
}
#[test]
fn parse_table() {
let input = "| A | B |\n|---|---|\n| 1 | 2 |";
let ast = parse(input);
assert!(ast.children.iter().any(|c| c.kind == "table"));
}
#[test]
fn parse_emoji_shortcode() {
let ast = parse("Hello :wave:");
let nodes = ast.walk();
let text_nodes: Vec<&AstNode> = nodes.iter().filter(|n| n.kind == "text").collect();
assert!(!text_nodes.is_empty());
}
#[test]
fn parse_frontmatter_multiple_keys() {
let input = "---\ntitle: Hello\nauthor: World\ntags: test\n---\n\nContent";
let ast = parse(input);
let meta = ast.metadata.as_ref().unwrap();
assert_eq!(meta.get("title").map(|v| v.as_str()), Some("Hello"));
assert_eq!(meta.get("author").map(|v| v.as_str()), Some("World"));
assert_eq!(meta.get("tags").map(|v| v.as_str()), Some("test"));
}
#[test]
fn parse_no_frontmatter() {
let ast = parse("Just text");
assert!(ast.metadata.is_none());
}
#[test]
fn render_heading_levels() {
for level in 1..=6 {
let input = format!("{} H{level}", "#".repeat(level));
let html = markdown_to_html(&input).unwrap();
assert!(
html.contains(&format!("<h{level}")),
"Expected <h{level}> in: {html}"
);
}
}
#[test]
fn render_link() {
let html = markdown_to_html("[text](https://example.com)").unwrap();
assert!(html.contains("<a"));
assert!(html.contains("href"));
assert!(html.contains("https://example.com"));
}
#[test]
fn render_image() {
assert_both_paths(
"",
"<p><img src=\"img.png\" alt=\"alt\"></p>\n",
);
}
#[test]
fn render_image_without_alt_text() {
assert_both_paths("", "<p><img src=\"img.png\" alt=\"\"></p>\n");
}
#[test]
fn render_image_with_title() {
assert_both_paths(
"",
"<p><img src=\"img.png\" alt=\"alt\" title=\"Title\"></p>\n",
);
}
#[test]
fn render_code_block() {
let html = markdown_to_html("```\ncode\n```").unwrap();
assert!(html.contains("<pre>") || html.contains("<code>"));
}
#[test]
fn render_blockquote() {
let html = markdown_to_html("> quote").unwrap();
assert!(html.contains("<blockquote>"));
}
#[test]
fn render_list() {
let html = markdown_to_html("- a\n- b").unwrap();
assert!(html.contains("<ul>") || html.contains("<li>"));
}
#[test]
fn render_thematic_break() {
assert_both_paths("***", "<hr>\n");
}
#[test]
fn render_thematic_break_after_content() {
assert_both_paths("a\n\n---\n\nb", "<p>a</p>\n<hr>\n<p>b</p>\n");
}
#[test]
fn render_hard_break() {
assert_both_paths("a \nb", "<p>a<br>\nb</p>\n");
}
#[test]
fn render_html_block_is_omitted() {
assert_both_paths("<div>x</div>", "<!-- raw HTML omitted -->\n");
}
#[test]
fn render_inline_raw_html_is_omitted() {
assert_both_paths(
"x <b>y</b> z",
"<p>x <!-- raw HTML omitted -->y<!-- raw HTML omitted --> z</p>\n",
);
}
#[test]
fn render_leading_dashes_are_frontmatter() {
assert_both_paths("---", "<!-- raw HTML omitted -->\n");
}
#[test]
fn render_strikethrough() {
let html = markdown_to_html("~~deleted~~").unwrap();
assert!(html.contains("<del>"));
assert!(html.contains("deleted"));
}
#[test]
fn render_table() {
let input = "| A | B |\n|---|---|\n| 1 | 2 |";
let html = markdown_to_html(input).unwrap();
assert!(html.contains("<table>"));
assert!(html.contains("<td>"));
}
#[test]
fn render_inline_code() {
let html = markdown_to_html("Use `code` here").unwrap();
assert!(html.contains("<code>"));
assert!(html.contains("code"));
}
#[test]
fn render_ast_link_round_trip() {
let ast = parse("[click](https://example.com)");
let html = render_ast_to_html(&ast);
assert!(html.contains("<a"));
assert!(html.contains("href=\"https://example.com\""));
assert!(html.contains("click"));
}
#[test]
fn render_ast_code_block_round_trip() {
let ast = parse("```\nfn main() {}\n```");
let html = render_ast_to_html(&ast);
assert!(html.contains("<pre><code>"));
}
#[test]
fn render_ast_blockquote_round_trip() {
let ast = parse("> quoted");
let html = render_ast_to_html(&ast);
assert!(html.contains("<blockquote>"));
}
#[test]
fn render_ast_list_round_trip() {
let ast = parse("- x\n- y");
let html = render_ast_to_html(&ast);
assert!(html.contains("<li>"));
}
#[test]
fn render_ast_strikethrough_round_trip() {
let ast = parse("~~gone~~");
let html = render_ast_to_html(&ast);
assert!(html.contains("<del>"));
assert!(html.contains("gone"));
}
#[test]
fn render_ast_table_round_trip() {
let input = "| A | B |\n|---|---|\n| 1 | 2 |";
let ast = parse(input);
let html = render_ast_to_html(&ast);
assert!(html.contains("<table>"));
assert!(html.contains("<td>"));
}
#[test]
fn render_ast_emphasis_round_trip() {
let ast = parse("*emphasis*");
let html = render_ast_to_html(&ast);
assert!(html.contains("<em>"));
assert!(html.contains("emphasis"));
}
#[test]
fn render_ast_inline_code_round_trip() {
let ast = parse("Use `code` here");
let html = render_ast_to_html(&ast);
assert!(html.contains("<code>"));
}
#[test]
fn ast_node_default_construction() {
let node = AstNode {
kind: "test".to_string(),
children: Vec::new(),
text: None,
attributes: HashMap::new(),
metadata: None,
props: None,
};
assert_eq!(node.kind, "test");
assert!(node.children.is_empty());
assert!(node.text.is_none());
assert!(node.attributes.is_empty());
assert!(node.metadata.is_none());
}
#[test]
fn walk_count_matches_tree() {
let ast = parse("# Hi\n\nParagraph with **bold** and *italic*.");
let nodes = ast.walk();
assert!(
nodes.len() >= 5,
"Expected at least 5 nodes, got {}",
nodes.len()
);
assert_eq!(nodes[0].kind, "document");
}
#[test]
fn walk_order_is_depth_first() {
let ast = parse("**bold**");
let nodes = ast.walk();
let kinds: Vec<&str> = nodes.iter().map(|n| n.kind.as_str()).collect();
assert_eq!(kinds[0], "document");
assert_eq!(kinds[1], "paragraph");
assert_eq!(kinds[2], "strong");
assert_eq!(kinds[3], "text");
}
#[test]
fn ast_node_repr() {
let node = AstNode {
kind: "text".to_string(),
children: Vec::new(),
text: Some("hello".to_string()),
attributes: HashMap::new(),
metadata: None,
props: None,
};
let repr = node.repr_string();
assert!(repr.contains("text"));
assert!(repr.contains("hello"));
}
#[test]
fn ast_node_repr_no_text() {
let node = AstNode {
kind: "document".to_string(),
children: vec![AstNode {
kind: "paragraph".to_string(),
children: Vec::new(),
text: None,
attributes: HashMap::new(),
metadata: None,
props: None,
}],
text: None,
attributes: HashMap::new(),
metadata: None,
props: None,
};
let repr = node.repr_string();
assert!(repr.contains("document"));
assert!(repr.contains("children=1"));
}
#[test]
fn parse_empty_input() {
let ast = parse("");
assert_eq!(ast.kind, "document");
}
#[test]
fn render_empty_input() {
let html = markdown_to_html("").unwrap();
assert!(html.is_empty() || html.trim().is_empty());
}
#[test]
fn parse_nested_emphasis() {
let ast = parse("***bold italic***");
let nodes = ast.walk();
let kinds: Vec<&str> = nodes.iter().map(|n| n.kind.as_str()).collect();
assert!(kinds.contains(&"emphasis") || kinds.contains(&"strong"));
}
#[test]
fn parse_multiline_paragraph() {
let ast = parse("line one\nline two");
let para = &ast.children[0];
assert_eq!(para.kind, "paragraph");
let all_text = collect_text(para);
assert!(all_text.contains("line one"));
assert!(all_text.contains("line two"));
}
#[test]
fn parse_multiple_paragraphs() {
let ast = parse("Para one\n\nPara two");
let paragraphs: Vec<&AstNode> = ast
.children
.iter()
.filter(|c| c.kind == "paragraph")
.collect();
assert_eq!(paragraphs.len(), 2);
}
#[test]
fn render_special_characters_escaped() {
let html = markdown_to_html("Use <script> & \"quotes\"").unwrap();
assert!(!html.is_empty());
}
#[test]
fn html_escape_correctness() {
assert_eq!(html_escape("<>&\""), "<>&"");
}
#[test]
fn parse_emoji_node_kind() {
let ast = parse("Hello :wave:");
let nodes = ast.walk();
let emoji_nodes: Vec<&AstNode> = nodes.iter().filter(|n| n.kind == "emoji").collect();
assert!(
!emoji_nodes.is_empty(),
"Expected at least one emoji node, got kinds: {:?}",
nodes.iter().map(|n| &n.kind).collect::<Vec<_>>()
);
}
#[test]
fn parse_emoji_has_shortcode_attribute() {
let ast = parse(":wave:");
let nodes = ast.walk();
let emoji = nodes.iter().find(|n| n.kind == "emoji").unwrap();
assert_eq!(
emoji.attributes.get("shortcode").map(|v| v.as_str()),
Some("wave")
);
}
#[test]
fn parse_emoji_has_text_content() {
let ast = parse(":wave:");
let nodes = ast.walk();
let emoji = nodes.iter().find(|n| n.kind == "emoji").unwrap();
assert!(
emoji.text.is_some(),
"Emoji node should have text (Unicode char)"
);
assert_eq!(emoji.text.as_deref(), Some("\u{1F44B}"));
}
#[test]
fn render_emoji_fast_path() {
let html = markdown_to_html(":wave:").unwrap();
assert!(
html.contains("\u{1F44B}"),
"Expected wave emoji in HTML, got: {html}"
);
}
#[test]
fn render_emoji_ast_round_trip() {
let ast = parse(":wave:");
let html = render_ast_to_html(&ast);
assert!(
html.contains("\u{1F44B}"),
"Expected wave emoji in round-trip HTML, got: {html}"
);
}
#[test]
fn parse_block_component() {
let input = "::note\nSome content\n::";
let ast = parse(input);
let nodes = ast.walk();
let bc = nodes
.iter()
.find(|n| n.kind == "block_component")
.expect("Expected a block_component node");
assert_eq!(bc.attributes.get("name").map(|v| v.as_str()), Some("note"));
}
#[test]
fn parse_block_component_with_attributes() {
let input = "::warning{.alert #important}\nBe careful\n::";
let ast = parse(input);
let nodes = ast.walk();
let bc = nodes
.iter()
.find(|n| n.kind == "block_component")
.expect("Expected a block_component node");
assert_eq!(
bc.attributes.get("name").map(|v| v.as_str()),
Some("warning")
);
assert_eq!(
bc.attributes.get("class").map(|v| v.as_str()),
Some("alert")
);
assert_eq!(
bc.attributes.get("id").map(|v| v.as_str()),
Some("important")
);
}
#[test]
fn parse_block_component_with_key_value() {
let input = "::note{type=\"info\"}\nContent\n::";
let ast = parse(input);
let nodes = ast.walk();
let bc = nodes
.iter()
.find(|n| n.kind == "block_component")
.expect("Expected a block_component node");
assert_eq!(bc.attributes.get("type").map(|v| v.as_str()), Some("info"));
}
#[test]
fn parse_block_component_has_children() {
let input = "::note\nHello world\n::";
let ast = parse(input);
let nodes = ast.walk();
let bc = nodes
.iter()
.find(|n| n.kind == "block_component")
.expect("Expected a block_component node");
assert!(
!bc.children.is_empty(),
"Block component should have children"
);
}
fn nested_components(node: &AstNode) -> Vec<&AstNode> {
node.children
.iter()
.filter(|n| n.kind == "block_component")
.collect()
}
fn component_name(node: &AstNode) -> &str {
node.attributes
.get("name")
.map(|v| v.as_str())
.expect("component should carry a name attribute")
}
fn assert_both_paths(input: &str, expected: &str) {
let fast = markdown_to_html(input).expect("fast path should render");
let round_trip = render_ast_to_html(&parse(input));
assert_eq!(fast, expected, "Fast path output mismatch");
assert_eq!(round_trip, expected, "AST round-trip output mismatch");
}
#[test]
fn triple_colon_opens_block_component() {
let input = ":::note\nContent\n:::";
let ast = parse(input);
let note = find_block_component(&ast);
assert_eq!(component_name(note), "note");
assert_eq!(
note.children.first().map(|c| c.kind.as_str()),
Some("paragraph")
);
}
#[test]
fn nested_block_components_two_levels() {
let input = ":::outer\n::inner\nx\n::\n:::";
let ast = parse(input);
let outer = find_block_component(&ast);
assert_eq!(component_name(outer), "outer");
let inner_components = nested_components(outer);
assert_eq!(inner_components.len(), 1, "Expected one nested component");
let inner = inner_components[0];
assert_eq!(component_name(inner), "inner");
assert_eq!(
inner.children.first().map(|c| c.kind.as_str()),
Some("paragraph")
);
}
#[test]
fn nested_block_components_three_levels() {
let input = "::level-1\n:::level-2\n::::level-3\nContent\n::::\n:::\n::";
let ast = parse(input);
let level1 = find_block_component(&ast);
assert_eq!(component_name(level1), "level-1");
let level2 = nested_components(level1);
assert_eq!(level2.len(), 1, "Expected level-2 nested in level-1");
assert_eq!(component_name(level2[0]), "level-2");
let level3 = nested_components(level2[0]);
assert_eq!(level3.len(), 1, "Expected level-3 nested in level-2");
assert_eq!(component_name(level3[0]), "level-3");
assert_eq!(
level3[0].children.first().map(|c| c.kind.as_str()),
Some("paragraph")
);
}
#[test]
fn equal_colon_nesting_is_resolved_innermost_first() {
let input = "::level-1\n::level-2\nContent\n::\n::\n\nAfter";
let ast = parse(input);
let level1 = find_block_component(&ast);
let level2 = nested_components(level1);
assert_eq!(level2.len(), 1, "Expected level-2 nested in level-1");
assert_eq!(component_name(level2[0]), "level-2");
assert!(
ast.walk()
.iter()
.all(|n| n.text.as_deref().is_none_or(|t| !t.contains("::"))),
"Closing fences should not leak into the document text"
);
}
#[test]
fn nested_component_inside_slot() {
let input = "::card\n#header\n:::badge\nNew\n:::\n::\n\nAfter";
let ast = parse(input);
let card = find_block_component(&ast);
let slots: Vec<&AstNode> = card.children.iter().filter(|n| n.kind == "slot").collect();
assert_eq!(slots.len(), 1, "Expected exactly one slot");
let badges = nested_components(slots[0]);
assert_eq!(badges.len(), 1, "Expected a component nested in the slot");
assert_eq!(component_name(badges[0]), "badge");
assert_eq!(
ast.children.last().map(|c| c.kind.as_str()),
Some("paragraph"),
"The component should close before the trailing paragraph"
);
}
#[test]
fn bare_colon_run_is_not_a_block_component() {
let input = "::::\n\nText";
let ast = parse(input);
assert!(
ast.walk().iter().all(|n| n.kind != "block_component"),
"A bare colon run should not open a component"
);
}
#[test]
fn content_after_closing_fence_is_a_sibling() {
let input = "::note\nHello\n::\nAfter";
let ast = parse(input);
let note = find_block_component(&ast);
assert_eq!(note.children.len(), 1, "Component holds only its own body");
assert_eq!(
ast.children.last().map(|c| c.kind.as_str()),
Some("paragraph"),
"Text after the closing fence is a sibling paragraph"
);
}
#[test]
fn render_nested_components_emit_nested_divs() {
assert_both_paths(
":::outer\n::inner\nx\n::\n:::",
"<div>\n<div>\n<p>x</p>\n</div>\n</div>\n",
);
}
use rushdown::ast::Meta;
fn component_props(input: &str) -> Option<rushdown::util::StringMap<Meta>> {
let ast = parse(input);
let bc = find_block_component(&ast);
match &bc.props {
Some(Meta::Mapping(map)) => Some(map.clone()),
None => None,
other => panic!("expected mapping props, got {other:?}"),
}
}
#[test]
fn parse_block_component_props_frontmatter_style() {
let input =
"::card\n---\nvariant: elevated\ncount: 42\nenabled: true\n---\nCard content\n::";
let props = component_props(input).expect("expected props");
assert_eq!(props.get("variant"), Some(&Meta::String("elevated".into())));
assert_eq!(props.get("count"), Some(&Meta::Int(42)));
assert_eq!(props.get("enabled"), Some(&Meta::Bool(true)));
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(
bc.children.iter().any(|c| c.kind == "paragraph"),
"expected body paragraph, got: {:?}",
bc.children.iter().map(|c| &c.kind).collect::<Vec<_>>()
);
}
#[test]
fn parse_block_component_props_codeblock_style() {
let input = "::card\n```yaml [props]\nvariant: elevated\ncount: 42\n```\nCard content\n::";
let props = component_props(input).expect("expected props");
assert_eq!(props.get("variant"), Some(&Meta::String("elevated".into())));
assert_eq!(props.get("count"), Some(&Meta::Int(42)));
}
#[test]
fn parse_block_component_props_none_when_inline_only() {
let input = "::note{.info}\nBody\n::";
assert!(component_props(input).is_none());
let ast = parse(input);
let bc = find_block_component(&ast);
assert_eq!(bc.attributes.get("class").map(|v| v.as_str()), Some("info"));
}
#[test]
fn parse_block_component_props_typed_values() {
let input = "::card\n---\ntags:\n - a\n - b\nobj:\n k: v\n---\n::";
let props = component_props(input).expect("expected props");
assert_eq!(
props.get("tags"),
Some(&Meta::Sequence(vec![
Meta::String("a".into()),
Meta::String("b".into()),
]))
);
match props.get("obj") {
Some(Meta::Mapping(inner)) => {
assert_eq!(inner.get("k"), Some(&Meta::String("v".into())));
}
other => panic!("expected nested mapping, got {other:?}"),
}
}
#[test]
fn parse_block_component_props_precedence_drops_colliding_key() {
let input = "::card{variant=\"inline\"}\n---\nvariant: yaml\ntitle: T\n---\n::";
let ast = parse(input);
let bc = find_block_component(&ast);
assert_eq!(
bc.attributes.get("variant").map(|v| v.as_str()),
Some("inline")
);
let props = component_props(input).expect("expected props");
assert!(props.get("variant").is_none());
assert_eq!(props.get("title"), Some(&Meta::String("T".into())));
}
#[test]
fn parse_block_component_props_all_collide_yields_none() {
let input = "::card{variant=\"inline\"}\n---\nvariant: yaml\n---\n::";
assert!(component_props(input).is_none());
}
#[test]
fn parse_block_component_no_props_unaffected() {
let input = "::note\nContent\n::";
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(bc.props.is_none());
assert!(!bc.children.is_empty());
}
#[test]
fn parse_block_component_props_malformed_yaml_graceful() {
let input = "::card\n---\n: : bad\n---\n::";
let _ = parse(input); assert!(component_props(input).is_none());
}
#[test]
fn parse_block_component_props_unterminated_falls_back() {
let input = "::card\n---\nvariant: x\n::";
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(bc.props.is_none());
assert!(
!bc.children.is_empty(),
"unterminated block should become content"
);
}
#[test]
fn parse_block_component_props_blank_line_not_props() {
let input = "::card\n\n---\nvariant: x\n---\n::";
assert!(component_props(input).is_none());
}
#[test]
fn parse_block_component_plain_yaml_fence_is_content() {
let input = "::card\n```yaml\nvariant: x\n```\n::";
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(bc.props.is_none());
assert!(
bc.children.iter().any(|c| c.kind == "code_block"),
"expected a code_block child, got: {:?}",
bc.children.iter().map(|c| &c.kind).collect::<Vec<_>>()
);
}
#[test]
fn parse_block_component_props_then_slots() {
let input = "::card\n---\nvariant: elevated\n---\n#header\n## Title\n::";
let props = component_props(input).expect("expected props");
assert_eq!(props.get("variant"), Some(&Meta::String("elevated".into())));
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(
bc.children.iter().any(|c| c.kind == "slot"),
"expected a slot child alongside props"
);
}
#[test]
fn render_block_component_props_omitted_from_html() {
let input = "::card{.featured}\n---\ntitle: Secret\n---\nBody\n::";
let html = markdown_to_html(input).unwrap();
assert!(html.contains("class=\"featured\""), "got: {html}");
assert!(
!html.contains("title"),
"typed props must not be emitted as HTML, got: {html}"
);
}
#[test]
fn render_block_component_props_only_body() {
let input = "::card\n---\nvariant: elevated\ncount: 42\n---\n::\n";
assert_eq!(markdown_to_html(input).unwrap(), "<div>\n</div>\n");
let props = component_props(input).expect("expected props");
assert_eq!(props.get("variant"), Some(&Meta::String("elevated".into())));
assert_eq!(props.get("count"), Some(&Meta::Int(42)));
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(
bc.children.is_empty(),
"a props-only body must not produce children, got: {:?}",
bc.children.iter().map(|c| &c.kind).collect::<Vec<_>>()
);
}
#[test]
fn render_block_component_fenced_props_only_body() {
let input = "::card\n```yaml [props]\nvariant: elevated\n```\n::\n";
assert_eq!(markdown_to_html(input).unwrap(), "<div>\n</div>\n");
let props = component_props(input).expect("expected props");
assert_eq!(props.get("variant"), Some(&Meta::String("elevated".into())));
let ast = parse(input);
let bc = find_block_component(&ast);
assert!(
bc.children.is_empty(),
"a props-only body must not produce children, got: {:?}",
bc.children.iter().map(|c| &c.kind).collect::<Vec<_>>()
);
}
#[test]
fn render_block_component_props_then_body() {
let input = "::card\n---\nx: 1\n---\nBody\n::\n";
assert_eq!(
markdown_to_html(input).unwrap(),
"<div>\n<p>Body</p>\n</div>\n"
);
}
#[test]
fn render_block_component_fast_path() {
let input = "::note\nContent\n::";
let html = markdown_to_html(input).unwrap();
assert!(
html.contains("<div"),
"Block component should render as <div>, got: {html}"
);
assert!(
html.contains("</div>"),
"Block component should have closing </div>, got: {html}"
);
}
#[test]
fn render_block_component_with_attrs_fast_path() {
let input = "::note{.info}\nContent\n::";
let html = markdown_to_html(input).unwrap();
assert!(
html.contains("class=\"info\""),
"Expected class attribute in HTML, got: {html}"
);
}
#[test]
fn render_block_component_ast_round_trip() {
let input = "::note\nContent\n::";
let ast = parse(input);
let html = render_ast_to_html(&ast);
assert!(
html.contains("<div"),
"Block component round-trip should produce <div>, got: {html}"
);
}
fn find_block_component(ast: &AstNode) -> &AstNode {
ast.children
.iter()
.find(|n| n.kind == "block_component")
.expect("Expected a block_component node")
}
#[test]
fn parse_single_named_slot() {
let input = "::card\n#header\n## Card Title\n::";
let ast = parse(input);
let card = find_block_component(&ast);
let slots: Vec<&AstNode> = card.children.iter().filter(|n| n.kind == "slot").collect();
assert_eq!(slots.len(), 1, "Expected exactly one slot");
let header = slots[0];
assert_eq!(
header.attributes.get("name").map(|v| v.as_str()),
Some("header")
);
assert_eq!(
header.children.first().map(|c| c.kind.as_str()),
Some("heading"),
"Slot should contain the heading content"
);
}
#[test]
fn parse_multiple_named_slots() {
let input = "::card\n#header\n## Card Title\n\n#content\nMain content here.\n::";
let ast = parse(input);
let card = find_block_component(&ast);
let slots: Vec<&AstNode> = card.children.iter().filter(|n| n.kind == "slot").collect();
assert_eq!(slots.len(), 2, "Expected header and content slots");
assert_eq!(
slots[0].attributes.get("name").map(|v| v.as_str()),
Some("header")
);
assert_eq!(
slots[0].children.first().map(|c| c.kind.as_str()),
Some("heading")
);
assert_eq!(
slots[1].attributes.get("name").map(|v| v.as_str()),
Some("content")
);
assert_eq!(
slots[1].children.first().map(|c| c.kind.as_str()),
Some("paragraph")
);
}
#[test]
fn parse_explicit_default_slot() {
let input = "::card\n#default\nDefault content.\n\n#footer\nFooter here.\n::";
let ast = parse(input);
let card = find_block_component(&ast);
let slots: Vec<&AstNode> = card.children.iter().filter(|n| n.kind == "slot").collect();
assert_eq!(slots.len(), 2, "Expected default and footer slots");
assert_eq!(
slots[0].attributes.get("name").map(|v| v.as_str()),
Some("default")
);
assert_eq!(
slots[1].attributes.get("name").map(|v| v.as_str()),
Some("footer")
);
}
#[test]
fn parse_implicit_default_slot_not_wrapped() {
let input = "::card\nBefore slot.\n\n#header\nHeader content.\n::";
let ast = parse(input);
let card = find_block_component(&ast);
assert_eq!(
card.children.first().map(|c| c.kind.as_str()),
Some("paragraph"),
"Implicit default content should be a direct paragraph child"
);
let slots: Vec<&AstNode> = card.children.iter().filter(|n| n.kind == "slot").collect();
assert_eq!(slots.len(), 1, "Only the explicit #header slot is wrapped");
assert_eq!(
slots[0].attributes.get("name").map(|v| v.as_str()),
Some("header")
);
}
#[test]
fn parse_component_without_slots_has_no_slot_nodes() {
let input = "::alert{type=\"info\"}\nJust content, no slots.\n::";
let ast = parse(input);
let alert = find_block_component(&ast);
assert!(
alert.children.iter().all(|n| n.kind != "slot"),
"Component without markers should not contain slot nodes"
);
assert_eq!(
alert.children.first().map(|c| c.kind.as_str()),
Some("paragraph")
);
}
#[test]
fn slot_marker_outside_component_is_not_a_slot() {
let input = "#header\n\n# Real Heading";
let ast = parse(input);
let nodes = ast.walk();
assert!(
nodes.iter().all(|n| n.kind != "slot"),
"No slot nodes should be produced outside a component"
);
assert!(
nodes.iter().any(|n| n.kind == "heading"),
"The `# Real Heading` line should still parse as a heading"
);
}
#[test]
fn render_named_slots_emit_data_slot_wrappers() {
assert_both_paths(
"::card\n#header\n## Card Title\n\n#content\nMain content here.\n::",
concat!(
"<div>\n",
"<div data-slot=\"header\">\n",
"<h2 id=\"card-title\">Card Title</h2>\n",
"</div>\n",
"<div data-slot=\"content\">\n",
"<p>Main content here.</p>\n",
"</div>\n",
"</div>\n",
),
);
}
#[test]
fn render_implicit_default_slot_is_not_wrapped() {
assert_both_paths(
"::card\nIntro\n\n#header\nH\n::",
concat!(
"<div>\n",
"<p>Intro</p>\n",
"<div data-slot=\"header\">\n",
"<p>H</p>\n",
"</div>\n",
"</div>\n",
),
);
}
#[test]
fn render_explicit_default_slot_is_wrapped() {
assert_both_paths(
"::card\n#default\nD\n::",
"<div>\n<div data-slot=\"default\">\n<p>D</p>\n</div>\n</div>\n",
);
}
#[test]
fn render_nested_component_inside_slot() {
assert_both_paths(
":::outer\n#a\n::inner\nx\n::\n:::",
concat!(
"<div>\n",
"<div data-slot=\"a\">\n",
"<div>\n",
"<p>x</p>\n",
"</div>\n",
"</div>\n",
"</div>\n",
),
);
}
#[test]
fn render_three_level_nesting() {
assert_both_paths(
"::level-1\n:::level-2\n::::level-3\nContent\n::::\n:::\n::",
"<div>\n<div>\n<div>\n<p>Content</p>\n</div>\n</div>\n</div>\n",
);
}
#[test]
fn render_component_attributes_are_filtered_and_sorted() {
assert_both_paths(
"::card{#c .a .b data-z=1}\ntext\n::",
"<div class=\"a b\" data-z=\"1\" id=\"c\">\n<p>text</p>\n</div>\n",
);
}
#[test]
fn render_component_attribute_values_are_escaped() {
assert_both_paths(
"::card{title=\"a & <b>\"}\ntext\n::",
"<div title=\"a & <b>\">\n<p>text</p>\n</div>\n",
);
}
#[test]
fn render_drops_non_html_component_attributes() {
let input = "::card{disabled foo=\"bar\"}\ntext\n::";
assert_both_paths(input, "<div>\n<p>text</p>\n</div>\n");
let ast = parse(input);
let card = find_block_component(&ast);
assert_eq!(
card.attributes.get(":disabled").map(|v| v.as_str()),
Some("true"),
"Boolean props are `:`-prefixed in the AST"
);
assert_eq!(
card.attributes.get("foo").map(|v| v.as_str()),
Some("bar"),
"Non-HTML attributes stay in the AST"
);
}
#[test]
fn render_inline_component_attributes_are_filtered() {
assert_both_paths(
"Some :icon[star]{.big disabled} here",
"<p>Some <span class=\"big\">star</span> here</p>\n",
);
}
#[test]
fn render_span_attributes_are_filtered() {
assert_both_paths(
"A [text]{.hl disabled} b",
"<p>A <span class=\"hl\">text</span> b</p>\n",
);
}
#[test]
fn parse_inline_component_with_content() {
let input = ":icon[star]";
let ast = parse(input);
let nodes = ast.walk();
let ic = nodes
.iter()
.find(|n| n.kind == "inline_component")
.expect("Expected an inline_component node");
assert_eq!(ic.attributes.get("name").map(|v| v.as_str()), Some("icon"));
}
#[test]
fn parse_inline_component_with_attrs() {
let input = ":badge[Pro]{.premium}";
let ast = parse(input);
let nodes = ast.walk();
let ic = nodes
.iter()
.find(|n| n.kind == "inline_component")
.expect("Expected an inline_component node");
assert_eq!(ic.attributes.get("name").map(|v| v.as_str()), Some("badge"));
assert_eq!(
ic.attributes.get("class").map(|v| v.as_str()),
Some("premium")
);
}
#[test]
fn parse_inline_component_attrs_only() {
let input = ":icon{type=\"star\"}";
let ast = parse(input);
let nodes = ast.walk();
let ic = nodes
.iter()
.find(|n| n.kind == "inline_component")
.expect("Expected an inline_component node");
assert_eq!(ic.attributes.get("name").map(|v| v.as_str()), Some("icon"));
assert_eq!(ic.attributes.get("type").map(|v| v.as_str()), Some("star"));
}
#[test]
fn render_inline_component_fast_path() {
let input = ":badge[Pro]{.premium}";
let html = markdown_to_html(input).unwrap();
assert!(
html.contains("<span"),
"Inline component should render as <span>, got: {html}"
);
}
#[test]
fn render_inline_component_ast_round_trip() {
let input = ":badge[Pro]";
let ast = parse(input);
let html = render_ast_to_html(&ast);
assert!(
html.contains("<span"),
"Inline component round-trip should produce <span>, got: {html}"
);
}
#[test]
fn parse_span_attributes() {
let input = "[important]{.highlight}";
let ast = parse(input);
let nodes = ast.walk();
let span = nodes
.iter()
.find(|n| n.kind == "span_attributes")
.expect("Expected a span node");
assert_eq!(
span.attributes.get("class").map(|v| v.as_str()),
Some("highlight")
);
}
#[test]
fn parse_span_with_id() {
let input = "[text]{#myid}";
let ast = parse(input);
let nodes = ast.walk();
let span = nodes
.iter()
.find(|n| n.kind == "span_attributes")
.expect("Expected a span node");
assert_eq!(span.attributes.get("id").map(|v| v.as_str()), Some("myid"));
}
#[test]
fn parse_span_with_multiple_classes() {
let input = "[text]{.a .b .c}";
let ast = parse(input);
let nodes = ast.walk();
let span = nodes
.iter()
.find(|n| n.kind == "span_attributes")
.expect("Expected a span node");
let class = span.attributes.get("class").map(|v| v.as_str()).unwrap();
assert!(class.contains("a"), "Expected class 'a' in: {class}");
assert!(class.contains("b"), "Expected class 'b' in: {class}");
assert!(class.contains("c"), "Expected class 'c' in: {class}");
}
#[test]
fn render_span_fast_path() {
let input = "[highlighted]{.mark}";
let html = markdown_to_html(input).unwrap();
assert!(
html.contains("<span"),
"Span should render as <span>, got: {html}"
);
assert!(
html.contains("class=\"mark\""),
"Span should have class attribute, got: {html}"
);
}
#[test]
fn render_span_ast_round_trip() {
let input = "[highlighted]{.mark}";
let ast = parse(input);
let html = render_ast_to_html(&ast);
assert!(
html.contains("<span"),
"Span round-trip should produce <span>, got: {html}"
);
}
#[test]
fn parse_component_attributes_class() {
with_parser(|parser| {
let mut reader = text::BasicReader::new("test");
let (mut arena, _) = parser.parse(&mut reader);
let node_ref = arena.new_node(extensions::SpanAttributes);
extensions::parse_component_attributes(".foo .bar", &mut arena[node_ref]);
let class_val = arena[node_ref]
.attributes()
.get("class")
.unwrap()
.str("test")
.to_string();
assert_eq!(class_val, "foo bar");
});
}
#[test]
fn parse_component_attributes_id() {
with_parser(|parser| {
let mut reader = text::BasicReader::new("test");
let (mut arena, _) = parser.parse(&mut reader);
let node_ref = arena.new_node(extensions::SpanAttributes);
extensions::parse_component_attributes("#myid", &mut arena[node_ref]);
let id_val = arena[node_ref]
.attributes()
.get("id")
.unwrap()
.str("test")
.to_string();
assert_eq!(id_val, "myid");
});
}
#[test]
fn parse_component_attributes_key_value() {
with_parser(|parser| {
let mut reader = text::BasicReader::new("test");
let (mut arena, _) = parser.parse(&mut reader);
let node_ref = arena.new_node(extensions::SpanAttributes);
extensions::parse_component_attributes("data-x=\"hello\"", &mut arena[node_ref]);
let val = arena[node_ref]
.attributes()
.get("data-x")
.unwrap()
.str("test")
.to_string();
assert_eq!(val, "hello");
});
}
#[test]
fn inline_component_not_double_colon() {
let input = "::notinline";
let ast = parse(input);
let nodes = ast.walk();
assert!(
nodes.iter().all(|n| n.kind != "inline_component"),
"Double colon should not create inline_component"
);
}
fn headings(ast: &AstNode) -> Vec<&AstNode> {
ast.children
.iter()
.filter(|c| c.kind == "heading")
.collect()
}
#[test]
fn heading_gets_slug_id() {
let ast = parse("# Overview");
let heading = &headings(&ast)[0];
assert_eq!(
heading.attributes.get("id").map(|v| v.as_str()),
Some("overview")
);
}
#[test]
fn duplicate_headings_get_suffixed_ids() {
let ast = parse("## Overview\n\n## Overview\n\n## Overview");
let hs = headings(&ast);
let ids: Vec<&str> = hs
.iter()
.map(|h| h.attributes.get("id").map(|v| v.as_str()).unwrap())
.collect();
assert_eq!(ids, vec!["overview", "overview-1", "overview-2"]);
}
#[test]
fn author_provided_id_wins_and_is_reserved() {
let ast = parse("## Title {#custom}\n\n## Custom");
let hs = headings(&ast);
assert_eq!(
hs[0].attributes.get("id").map(|v| v.as_str()),
Some("custom")
);
assert_eq!(
hs[1].attributes.get("id").map(|v| v.as_str()),
Some("custom-1")
);
}
#[test]
fn emoji_heading_uses_shortcode_in_slug() {
let ast = parse("# Hello :wave:");
let id = headings(&ast)[0]
.attributes
.get("id")
.map(|v| v.as_str())
.unwrap();
assert!(id.contains("wave"), "Expected shortcode in id, got: {id}");
assert!(
!id.contains('\u{1F44B}'),
"Slug should not contain the emoji char, got: {id}"
);
}
#[test]
fn unicode_heading_is_normalized() {
let ast = parse("# Café");
assert_eq!(
headings(&ast)[0].attributes.get("id").map(|v| v.as_str()),
Some("cafe")
);
}
#[test]
fn punctuation_only_heading_falls_back_to_section() {
let ast = parse("# ...");
assert_eq!(
headings(&ast)[0].attributes.get("id").map(|v| v.as_str()),
Some("section")
);
}
#[test]
fn fast_path_emits_heading_id() {
let html = markdown_to_html("# Overview").unwrap();
assert!(
html.contains("id=\"overview\""),
"Fast path should emit heading id, got: {html}"
);
}
#[test]
fn ast_round_trip_emits_heading_id() {
let ast = parse("# Overview");
let html = render_ast_to_html(&ast);
assert!(
html.contains("id=\"overview\""),
"AST round-trip should emit heading id, got: {html}"
);
}
#[test]
fn slugify_public_function() {
assert_eq!(slugify("Hello World", None), "hello-world");
assert_eq!(
slugify("Overview", Some(vec!["overview".to_string()])),
"overview-1"
);
}
#[test]
fn summary_splits_at_block_delimiter() {
let summary =
extract_summary("Intro paragraph shown in listings.\n\n<!-- more -->\n\nThe rest.")
.expect("delimiter present");
assert!(
summary.contains("<p>Intro paragraph shown in listings.</p>"),
"summary should contain the intro, got: {summary}"
);
assert!(
!summary.contains("The rest"),
"summary must not contain body content, got: {summary}"
);
}
#[test]
fn summary_absent_without_delimiter() {
assert!(extract_summary("Just a plain paragraph.").is_none());
}
#[test]
fn summary_delimiter_whitespace_and_case_tolerant() {
for delimiter in ["<!--more-->", "<!-- MORE -->", "<!-- More -->"] {
let src = format!("Intro.\n\n{delimiter}\n\nBody.");
let summary = extract_summary(&src)
.unwrap_or_else(|| panic!("delimiter {delimiter} should be detected"));
assert!(summary.contains("<p>Intro.</p>"), "got: {summary}");
assert!(!summary.contains("Body"), "got: {summary}");
}
}
#[test]
fn summary_ignores_nested_delimiter() {
assert!(extract_summary("> Intro.\n>\n> <!-- more -->\n\nBody.").is_none());
}
#[test]
fn summary_uses_first_top_level_delimiter() {
let summary =
extract_summary("First.\n\n<!-- more -->\n\nSecond.\n\n<!-- more -->\n\nThird.")
.expect("delimiter present");
assert!(summary.contains("<p>First.</p>"), "got: {summary}");
assert!(!summary.contains("Second"), "got: {summary}");
assert!(!summary.contains("Third"), "got: {summary}");
}
#[test]
fn summary_matches_render_ast_prefix() {
let src = "# Heading\n\nIntro.\n\n<!-- more -->\n\nBody.";
let summary = extract_summary(src).expect("delimiter present");
let prefix_ast = parse("# Heading\n\nIntro.");
let expected = render_ast_to_html(&prefix_ast);
assert_eq!(summary, expected);
}
#[test]
fn summary_empty_when_delimiter_is_first_block() {
let summary = extract_summary("<!-- more -->\n\nBody.").expect("delimiter present");
assert_eq!(summary, "");
}
#[test]
fn parse_document_headings_are_flat_and_ordered() {
let result = parse_document("# Title\n\n## Setup\n\n### CLI\n\n## FAQ");
let flat: Vec<(u8, &str, &str)> = result
.headings
.iter()
.map(|h| (h.level, h.id.as_str(), h.text.as_str()))
.collect();
assert_eq!(
flat,
[
(1, "title", "Title"),
(2, "setup", "Setup"),
(3, "cli", "CLI"),
(2, "faq", "FAQ"),
]
);
assert!(result.headings.iter().all(|h| h.children.is_empty()));
}
#[test]
fn parse_document_toc_nests_by_level() {
let result = parse_document("# Title\n\n## Setup\n\n### CLI\n\n## FAQ");
assert_eq!(result.toc.len(), 1);
let level_two: Vec<&str> = result.toc[0]
.children
.iter()
.map(|h| h.id.as_str())
.collect();
assert_eq!(level_two, ["setup", "faq"]);
assert_eq!(result.toc[0].children[0].children[0].id, "cli");
}
#[test]
fn parse_document_toc_tolerates_level_skips() {
let result = parse_document("# Title\n\n### Deep");
assert_eq!(result.toc.len(), 1);
assert_eq!(result.toc[0].children[0].id, "deep");
assert_eq!(result.toc[0].children[0].level, 3);
}
#[test]
fn parse_document_headings_include_block_components() {
let result = parse_document("# Title\n\n::note\n## Inside\n::\n\n## After");
let ids: Vec<&str> = result.headings.iter().map(|h| h.id.as_str()).collect();
assert_eq!(ids, ["title", "inside", "after"]);
}
#[test]
fn parse_document_heading_ids_are_deduplicated() {
let result = parse_document("# Overview\n\n## Overview");
let ids: Vec<&str> = result.headings.iter().map(|h| h.id.as_str()).collect();
assert_eq!(ids, ["overview", "overview-1"]);
}
#[test]
fn parse_document_heading_honours_author_provided_id() {
let result = parse_document("# Title {#custom}");
assert_eq!(result.headings[0].id, "custom");
}
#[test]
fn parse_document_without_headings_is_empty() {
let result = parse_document("Just a paragraph.");
assert!(result.headings.is_empty());
assert!(result.toc.is_empty());
}
#[test]
fn parse_document_ids_match_rendered_html() {
let markdown = "# Overview\n\n## Overview";
let result = parse_document(markdown);
let html = markdown_to_html(markdown).expect("renders");
for heading in &result.headings {
assert!(html.contains(&format!("id=\"{}\"", heading.id)));
}
}
#[test]
fn parse_document_summary_matches_extract_summary() {
let markdown = "Intro.\n\n<!-- more -->\n\nBody.";
assert_eq!(parse_document(markdown).summary, extract_summary(markdown));
assert!(
parse_document(markdown)
.summary
.expect("delimiter present")
.contains("<p>Intro.</p>")
);
}
#[test]
fn parse_document_summary_is_none_without_delimiter() {
assert!(parse_document("No delimiter.").summary.is_none());
}
#[test]
fn parse_document_root_still_contains_delimiter() {
let result = parse_document("Intro.\n\n<!-- more -->\n\nBody.");
let html = render_ast(&result.root);
assert!(html.contains("Intro."));
assert!(html.contains("Body."));
}
}