ratatui-markdown 0.3.6

Markdown rendering, syntax highlighting, collapsible trees, and rich scroll widgets for ratatui
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::common::*;

static SIMPLE_TD: &str = "graph TD
    A[Start] --> B[End]";

static SIMPLE_TD_EXPECTED: &str = "
                                   ┌───────┐
                                   │ Start │
                                   └───────┘
                                       │
                                       │
                                       ▼
                                    ┌─────┐
                                    │ End │
                                    └─────┘";

static FORK_TD: &str = "graph TD
    A[Start] --> B[Left]
    A --> C[Right]";

static FORK_TD_EXPECTED: &str = "
                                   ┌───────┐
                                   │ Start │
                                   └───────┘
                                       │
                                 ┌─────┴─────┐
                                 ▼           ▼
                             ┌──────┐    ┌───────┐
                             │ Left │    │ Right │
                             └──────┘    └───────┘";

static LR: &str = "graph LR
    A --> B";

static LR_EXPECTED: &str = "
┌────┐    ┌────┐
│    │    │    │
│ A  │───►│ B  │
│    │    │    │
└────┘    └────┘";

static CHAIN: &str = "graph TD
    A --> B --> C";

static CHAIN_EXPECTED: &str = "
                                     ┌────┐
                                     │ A  │
                                     └────┘
                                        │
                                        │
                                        ▼
                                     ┌────┐
                                     │ B  │
                                     └────┘
                                        │
                                        │
                                        ▼
                                     ┌────┐
                                     │ C  │
                                     └────┘";

static DIAMOND: &str = "graph TD
    A{Start} -->|yes| B[Yes]
    A -->|no| C[No]";

static DIAMOND_EXPECTED: &str = "
                                   ╭───────╮
                                   │ Start │
                                   ╰───────╯
                                 yes   │    no
                                  ┌────┴─────┐
                                  ▼          ▼
                               ┌─────┐    ┌────┐
                               │ Yes │    │ No │
                               └─────┘    └────┘";

static LABELED_LR: &str = "graph LR
    A -->|hello| B -->|world| C";

static LABELED_LR_EXPECTED: &str = "
┌────┐    ┌────┐    ┌────┐
│    │ello│    │orld│    │
│ A  │───►│ B  │───►│ C  │
│    │    │    │    │    │
└────┘    └────┘    └────┘";

#[test]
fn simple_td() {
    let buf = render_to_buffer(SIMPLE_TD, 80, 10);
    assert_buffer_eq(&buf, SIMPLE_TD_EXPECTED);
}

#[test]
fn fork_td() {
    let buf = render_to_buffer(FORK_TD, 80, 10);
    assert_buffer_eq(&buf, FORK_TD_EXPECTED);
}

#[test]
fn lr() {
    let buf = render_to_buffer(LR, 20, 5);
    assert_buffer_eq(&buf, LR_EXPECTED);
}

#[test]
fn chain() {
    let buf = render_to_buffer(CHAIN, 80, 15);
    assert_buffer_eq(&buf, CHAIN_EXPECTED);
}

#[test]
fn diamond() {
    let buf = render_to_buffer(DIAMOND, 80, 12);
    assert_buffer_eq(&buf, DIAMOND_EXPECTED);
}

#[test]
fn labeled_lr() {
    let buf = render_to_buffer(LABELED_LR, 40, 5);
    assert_buffer_eq(&buf, LABELED_LR_EXPECTED);
}