markdown-ratatui 0.2.0

Backend-independent, width-aware Markdown widgets for ratatui
Documentation
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\né πŸ‘©β€πŸ’» πŸ‡―πŸ‡΅ πŸ™‚ ε…¨θ§’οΌ‘οΌ’οΌ£ [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 ["é", "πŸ‘©β€πŸ’»", "πŸ‡―πŸ‡΅", "ζ—₯本θͺž"] {
        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"));
}