use markdown_model::Document;
use markdown_ratatui::{
Layout, LayoutError, LayoutOptions, LineLimit, MarkdownView, TablePolicy, ViewState,
};
use ratatui_core::{buffer::Buffer, layout::Rect, widgets::StatefulWidget};
use std::sync::Arc;
use unicode_width::UnicodeWidthStr;
#[test]
fn unicode_long_lines_tables_and_zero_width_are_bounded() {
let doc = Document::parse(&format!("# ζ₯ζ¬θͺ\n\neΜ π©βπ» π―π΅ π ε
¨θ§οΌ‘οΌ’οΌ£ [long URL](https://example.com)\n\n{}\n\n```rust\n{}\n```\n\n| One | Two |\n| :- | -: |\n| ζ₯ζ¬θͺ | π©βπ» |", "https://example.com/".repeat(30), "ι·γγ³γΌγ".repeat(40))).unwrap();
for width in [0, 1, 2, 3, 8, 20, 80] {
let layout = Layout::new(&doc, width, &LayoutOptions::default()).unwrap();
for line in layout.plain_lines() {
assert!(
line.width() <= usize::from(width),
"width {width}: {line:?}"
);
}
let area = Rect::new(3, 2, width, 12);
let mut buf = Buffer::empty(Rect::new(0, 0, 90, 20));
layout
.widget()
.render(area, &mut buf, &mut ViewState::default());
assert_eq!(buf[(0, 0)].symbol(), " ");
if width == 0 {
assert_eq!(layout.line_count(), 0);
}
}
let layout = Layout::new(&doc, 80, &LayoutOptions::default()).unwrap();
let text = layout.plain_lines().join("\n");
for sample in ["eΜ", "π©βπ»", "π―π΅", "ζ₯ζ¬θͺ"] {
assert!(text.contains(sample));
}
}
#[test]
fn wrapped_link_cells_match_rendered_scrolled_buffer() {
let doc = Document::parse("# Heading\n\n[abcdefghijklmnop](next.md)\n\ntrailer\n\nmore\n\nend")
.unwrap();
let layout = Layout::new(&doc, 5, &LayoutOptions::default()).unwrap();
let link_id = doc.links()[0].id();
let positions: Vec<_> = layout
.links()
.iter()
.filter(|position| position.link_id() == link_id)
.collect();
assert!(positions.len() >= 4);
for p in positions {
let mut state = ViewState::default();
state.scroll_to(p.row());
state.select_link(Some(link_id));
let mut buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
layout.widget().render(buffer.area, &mut buffer, &mut state);
let line = &layout.plain_lines()[p.row().index()];
let rendered: String = (0..5).map(|x| buffer[(x, 0)].symbol()).collect();
assert_eq!(rendered.trim_end(), line.trim_end());
for x in p.columns().range() {
assert_eq!(
buffer[(x, 0)].bg,
LayoutOptions::default().theme.selected.bg.unwrap()
);
}
}
assert_eq!(layout.headings()[0].heading_id(), doc.headings()[0].id());
}
#[test]
fn cache_invalidates_only_for_document_width_or_options() {
let original = Arc::new(Document::parse("# old\n\n[hello](next.md)").unwrap());
let mut markdown = MarkdownView::from_document(original.clone());
let first_lines = markdown.prepare(10).unwrap().plain_lines();
let first_ptr = markdown.prepare(10).unwrap().links().as_ptr();
for scroll in 0..100 {
let layout = markdown.prepare(10).unwrap();
let mut buffer = Buffer::empty(Rect::new(0, 0, 10, 2));
let mut state = ViewState::default();
state.scroll_to(markdown_ratatui::DocumentRow::new(scroll));
layout.widget().render(buffer.area, &mut buffer, &mut state);
assert_eq!(layout.links().as_ptr(), first_ptr);
}
assert!(Arc::ptr_eq(markdown.shared_document(), &original));
assert_ne!(markdown.prepare(2).unwrap().plain_lines(), first_lines);
markdown.set_document(Arc::new(Document::parse("# new").unwrap()));
assert_eq!(
markdown.prepare(10).unwrap().headings()[0]
.heading_id()
.as_str(),
"new"
);
let options = LayoutOptions {
line_limit: LineLimit::new(0).unwrap(),
..LayoutOptions::default()
};
markdown.set_options(options.clone());
assert_eq!(markdown.options(), &options);
assert!(matches!(
markdown.prepare(10),
Err(LayoutError::TooManyLines { .. })
));
assert!(LineLimit::new(LineLimit::MAX + 1).is_err());
}
#[test]
fn table_alignment_and_narrow_fallback_keep_content() {
let doc = Document::parse("| L | R |\n| :- | -: |\n| xxxx | z |").unwrap();
let wide = Layout::new(&doc, 40, &LayoutOptions::default())
.unwrap()
.plain_lines()
.join("\n");
assert!(wide.contains("L β R"));
let stacked = Layout::new(
&doc,
40,
&LayoutOptions {
tables: TablePolicy::Stacked,
..LayoutOptions::default()
},
)
.unwrap()
.plain_lines()
.join("\n");
assert!(stacked.contains("L: xxxx"));
assert!(stacked.contains("R: z"));
}
#[test]
fn shrink_clamps_scroll_and_control_bytes_never_reach_buffer() {
let doc = Document::parse("# hi\n\n\x1b[2Jcontrol\u{009b}\x07").unwrap();
let layout = Layout::new(&doc, 30, &LayoutOptions::default()).unwrap();
let mut state = ViewState::default();
state.scroll_to_end();
let mut buffer = Buffer::empty(Rect::new(0, 0, 30, 20));
layout.widget().render(buffer.area, &mut buffer, &mut state);
assert_eq!(state.scroll().index(), 0);
for cell in buffer.content() {
assert!(!cell.symbol().chars().any(char::is_control));
}
}
#[test]
fn mermaid_fences_render_connected_ascii_boxes() {
let doc = Document::parse("```mermaid\nflowchart LR\n Markdown --> Mira\n```").unwrap();
let text = Layout::new(&doc, 40, &LayoutOptions::default())
.unwrap()
.plain_lines()
.join("\n");
assert!(text.contains("+----------+"));
assert!(text.contains("| Markdown | --> | Mira |"), "{text}");
assert!(!text.contains("flowchart LR"));
}
#[test]
fn mermaid_fallback_and_nested_layout_keep_source_and_limits() {
let mut view = MarkdownView::new("> ```mermaid\n> graph TD\n> A[ζ₯ζ¬θͺ] --> B[Done]\n> ```\n\n```mermaid\npie\n\"One\": 1\n```\n\n# After\n\n[next](next.md)").unwrap();
for width in [0, 1, 8, 20, 60] {
let layout = view.prepare(width).unwrap();
assert!(
layout
.plain_lines()
.iter()
.all(|line| line.width() <= usize::from(width))
);
}
let layout = view.prepare(60).unwrap();
let text = layout.plain_lines().join("\n");
assert!(text.contains("β | A: ζ₯ζ¬θͺ |"), "{text}");
assert!(text.contains("Mermaid source (unsupported diagram type)"));
assert!(text.contains("\"One\": 1"));
assert_eq!(layout.headings()[0].heading_id().as_str(), "after");
assert_eq!(layout.links().len(), 1);
view.set_options(LayoutOptions {
line_limit: LineLimit::new(3).unwrap(),
..LayoutOptions::default()
});
assert!(view.prepare(60).is_err());
}
#[test]
fn sequence_alternatives_render_in_buffers_with_a_separate_configurable_color() {
use markdown_ratatui::Theme;
use ratatui_core::style::{Color, Modifier, Style};
let source = format!(
"# Heading\n\n```text\nOrdinary code\n```\n\n```mermaid\n{}```\n\nAfter diagram",
include_str!("fixtures/tcp-forwarding.mmd")
);
let mut view = MarkdownView::new(&source).unwrap();
let defaults = Theme::default();
assert_eq!(defaults.diagram.fg, Some(Color::Magenta));
assert_ne!(defaults.diagram.fg, defaults.code.fg);
assert_ne!(defaults.diagram.fg, defaults.heading.fg);
assert_ne!(defaults.diagram.fg, defaults.link.fg);
for style in [
defaults.diagram,
Style::default()
.fg(Color::Green)
.add_modifier(Modifier::BOLD),
] {
view.set_options(LayoutOptions {
theme: Theme {
diagram: style,
..Theme::default()
},
..LayoutOptions::default()
});
for width in [40, 116, 180] {
let layout = view.prepare(width).unwrap();
let lines = layout.plain_lines();
let text = lines.join("\n");
assert!(!text.contains("Mermaid source"), "{text}");
let area = Rect::new(0, 0, width, layout.line_count() as u16);
let mut buffer = Buffer::empty(area);
layout
.widget()
.render(area, &mut buffer, &mut ViewState::default());
let code_row = lines
.iter()
.position(|line| line.contains("Ordinary code"))
.unwrap();
assert_eq!(buffer[(2, code_row as u16)].fg, Color::Yellow);
for marker in ["+-alt ", "+-else ", "+-end alt"] {
let row = lines
.iter()
.position(|line| line.starts_with(marker))
.unwrap();
assert_eq!(buffer[(0, row as u16)].fg, style.fg.unwrap());
assert_eq!(buffer[(2, row as u16)].fg, style.fg.unwrap());
assert_eq!(
buffer[(2, row as u16)].modifier.contains(Modifier::BOLD),
style.add_modifier.contains(Modifier::BOLD)
);
}
if width == 116 {
let row = lines
.iter()
.position(|line| line.contains("Established=false, Reset=false"))
.unwrap();
assert_eq!(buffer[(2, row as u16)].fg, style.fg.unwrap());
assert!(text.contains("SYN-ACK/RSTγη©ζ₯΅ηγ«θΏγγη ΄ζ£"));
}
}
}
}
#[test]
fn malformed_sequence_fragments_preserve_the_entire_source() {
let mut view = MarkdownView::new(
"```mermaid\nsequenceDiagram\nA->>B: before\nalt missing end\nA-->>B: after\n```\n",
)
.unwrap();
let text = view.prepare(100).unwrap().plain_lines().join("\n");
assert!(text.contains("unclosed sequence block (missing end)"));
assert!(text.contains("A->>B: before"));
assert!(text.contains("A-->>B: after"));
}