mbterm 0.1.4

ANSI terminal renderer for MBDown documents
Documentation
use unicode_width::UnicodeWidthStr;

use super::render;
use crate::{strip_terminal_sequences, table, Theme};

fn plain(input: &str) -> String {
    strip_terminal_sequences(input)
}

#[test]
fn wraps_plain_cjk_and_indents_each_paragraph_first_line() {
    assert_eq!(
        plain(&render("天地玄黄宇宙", 6, &Theme::new())),
        "天地玄\n黄宇宙"
    );
    let rendered = plain(&render(
        "[indent first=4]\n天地玄黄宇宙洪荒\n\n日月盈昃辰宿列张\n[/indent]",
        12,
        &Theme::new(),
    ));
    assert_eq!(rendered, "    天地玄黄\n宇宙洪荒\n\n    日月盈昃\n辰宿列张");
    assert!(
        rendered
            .lines()
            .all(|line| UnicodeWidthStr::width(line) <= 12),
        "{rendered:?}"
    );
}

#[test]
fn renders_exact_borderless_and_truecolor_boxes() {
    let bordered = render(
        "[box title=\"地图\" width=16 border-color=#12abef]\n天地玄黄宇宙\n[/box]",
        40,
        &Theme::new(),
    );
    assert!(bordered.contains("\x1b[38;2;18;171;239m┌─"), "{bordered:?}");
    let bordered_plain = plain(&bordered);
    assert!(
        bordered_plain
            .lines()
            .all(|line| UnicodeWidthStr::width(line) == 16),
        "{bordered_plain:?}"
    );

    let borderless = plain(&render(
        "[center][box width=8 border=none]\n天地玄黄宇宙\n[/box][/center]",
        20,
        &Theme::new(),
    ));
    assert_eq!(borderless, "      天地玄黄\n      宇宙");
    assert!(!borderless.contains(['┌', '│', '└']));
}

#[test]
fn applies_axis_padding_to_boxes_and_columns() {
    let boxed = plain(&render(
        "[box width=12 px=2 py=1]x[/box]",
        20,
        &Theme::new(),
    ));
    let box_lines = boxed.lines().collect::<Vec<_>>();
    assert_eq!(box_lines.len(), 5);
    assert_eq!(box_lines[1], "│          │");
    assert_eq!(box_lines[2], "│  x       │");
    assert_eq!(box_lines[3], "│          │");
    assert!(box_lines
        .iter()
        .all(|line| UnicodeWidthStr::width(*line) == 12));

    let columns = plain(&render(
        concat!(
            "[columns gap=1 px=1 py=1]",
            "[column width=8 p=1]A[/column]",
            "[column width=8 px=2 py=1]B[/column]",
            "[/columns]"
        ),
        24,
        &Theme::new(),
    ));
    let column_lines = columns.lines().collect::<Vec<_>>();
    assert_eq!(column_lines.len(), 5);
    assert!(column_lines[0].trim().is_empty());
    assert!(column_lines[2].contains('A'));
    assert!(column_lines[2].contains('B'));
    assert!(column_lines[4].trim().is_empty());
    assert!(column_lines
        .iter()
        .all(|line| UnicodeWidthStr::width(*line) == 19));
}

#[test]
fn fills_box_rectangles_with_concrete_and_semantic_backgrounds() {
    let mut theme = Theme::new();
    theme
        .insert(
            "panel",
            crate::TextStyle::new()
                .bold()
                .foreground(crate::Color::Basic(crate::BasicColor::Red))
                .background(crate::Color::Rgb(1, 2, 3)),
        )
        .unwrap();

    let bordered = render("[box width=8 bg=panel]x[/box]", 20, &theme);
    assert!(bordered.starts_with("\x1b[48;2;1;2;3m"), "{bordered:?}");
    assert!(!bordered.contains("\x1b[1;31m"), "{bordered:?}");
    assert!(plain(&bordered)
        .lines()
        .all(|line| UnicodeWidthStr::width(line) == 8));

    theme
        .insert(
            "markdown-box",
            crate::TextStyle::new()
                .foreground(crate::Color::Basic(crate::BasicColor::Green))
                .background(crate::Color::Basic(crate::BasicColor::Blue)),
        )
        .unwrap();
    let styled_border = render("[box width=8 bg=red]x[/box]", 20, &theme);
    assert!(
        styled_border.contains("\x1b[32;44m\x1b[41m┌"),
        "{styled_border:?}"
    );

    let borderless = render(
        "[box width=6 border=none bg=#102030]x[/box]after",
        20,
        &theme,
    );
    assert!(borderless.contains("\x1b[48;2;16;32;48mx     \x1b[0m"));
    assert_eq!(plain(&borderless), "x     \n\nafter");

    let cjk = render(
        "[box width=32 border=none bg=#30343b px=2 py=1]这是一个没有边框、只有背景色的 Box。[/box]",
        80,
        &theme,
    );
    assert!(
        cjk.lines().all(|line| table::visible_width(line) == 32),
        "{cjk:?}"
    );
}

#[test]
fn fills_wide_and_stacked_columns_with_background_precedence() {
    let source = concat!(
        "[columns gap=2 bg=#010203]",
        "[column width=4 bg=red]A[/column]",
        "[column width=4]B\n\nC[/column]",
        "[/columns]"
    );
    let wide = render(source, 10, &Theme::new());
    let wide_plain = plain(&wide);
    assert_eq!(wide_plain, "A     B   \n          \n      C   ");
    assert!(wide.contains("\x1b[41mA   \x1b[0m"), "{wide:?}");
    assert!(wide.contains("\x1b[48;2;1;2;3m  \x1b[0m"), "{wide:?}");
    assert!(wide.lines().all(|line| table::visible_width(line) == 10));

    let stacked = render(source, 8, &Theme::new());
    let stacked_plain = plain(&stacked);
    assert_eq!(
        stacked_plain,
        "A       \n        \nB       \n        \nC       "
    );
    assert!(
        stacked.contains("\n\x1b[48;2;1;2;3m        \x1b[0m\n"),
        "{stacked:?}"
    );
}

#[test]
fn renders_weighted_columns_and_stacks_on_narrow_terminals() {
    let source = concat!(
        "[columns gap=2]\n",
        "[column width=1fr]左栏[/column]\n",
        "[column width=10]右栏[/column]\n",
        "[/columns]"
    );
    let wide = plain(&render(source, 30, &Theme::new()));
    assert_eq!(wide, format!("左栏{}右栏", " ".repeat(16)));
    assert!(UnicodeWidthStr::width(wide.as_str()) <= 30);

    let narrow = plain(&render(source, 16, &Theme::new()));
    assert_eq!(narrow, "左栏\n\n右栏");
    assert!(narrow
        .lines()
        .all(|line| UnicodeWidthStr::width(line) <= 16));

    let minimum_overflow = concat!(
        "[columns gap=2]",
        "[column width=1]甲[/column]",
        "[column width=1]乙[/column]",
        "[/columns]"
    );
    assert_eq!(
        plain(&render(minimum_overflow, 4, &Theme::new())),
        "甲\n\n乙"
    );
}

#[test]
fn keeps_padded_cjk_flex_columns_side_by_side_when_they_fit() {
    let source = concat!(
        "[columns gap=2 p=1 py=0]",
        "[column width=1fr px=1 py=1]### 物品\n\n长剑[/column]",
        "[column width=1fr p=1]### 数量\n\n1[/column]",
        "[column width=1fr px=2 py=1]### 备注\n\n需要修理[/column]",
        "[/columns]"
    );
    let rendered = plain(&render(source, 112, &Theme::new()));
    let content_line = rendered
        .lines()
        .find(|line| line.contains("物品"))
        .expect("column heading row");
    assert!(content_line.contains("数量"), "{rendered:?}");
    assert!(content_line.contains("备注"), "{rendered:?}");
    assert!(rendered
        .lines()
        .all(|line| UnicodeWidthStr::width(line) <= 112));
}

#[test]
fn thematic_rules_fill_widths_larger_than_eighty_columns() {
    let rendered = plain(&render("---", 112, &Theme::new()));
    assert_eq!(UnicodeWidthStr::width(rendered.as_str()), 112);
    assert_eq!(rendered, "─".repeat(112));
}