mini_markdown 0.3.5

Small markdown renderer
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
122
123
124
125
126

use mini_markdown::iter::MiniIter;

#[test]
fn peek_does_not_advance(){
    let some_text = "this is some plaintext";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("t"), some_text_iter.peek());
    assert_eq!(Some("t"), some_text_iter.peek());
    assert_eq!(Some("t"), some_text_iter.next());   
}

#[test]
fn peek_does_not_advance_utf(){
    let some_text = "الْأَ";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("ا"), some_text_iter.peek());
    assert_eq!(Some("ا"), some_text_iter.peek());
    assert_eq!(Some("ا"), some_text_iter.next());   
}

#[test]
fn modern_standard_arabic_test(){
    let some_text = "الْﺦﷺأَ"; // لْ is a weird character. 2 bytes are valid for the base and two more add the little circle on top.
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("الْﺦﷺأَ"), some_text_iter.consume_line_ahead());
    assert_eq!(None, some_text_iter.next());
}

#[test]
fn consume_until_end_consumes_full_string() {
    let some_text = "this is some plaintext";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("this is some plaintext"), some_text_iter.consume_until_end());
    assert_eq!(None, some_text_iter.next());
}

#[test]
fn next_advances_utf_correctly() {
    let some_text = "اa木b겅c€d𐍈e";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("ا"), some_text_iter.next());
    assert_eq!(Some("a"), some_text_iter.peek());
    assert_eq!(Some("a"), some_text_iter.next());
    assert_eq!(Some("木"), some_text_iter.peek());
    assert_eq!(Some("木"), some_text_iter.next());
    assert_eq!(Some("b"), some_text_iter.next());
    assert_eq!(Some("겅"), some_text_iter.peek());
    assert_eq!(Some("겅"), some_text_iter.next());
    assert_eq!(Some("c"), some_text_iter.next());
    assert_eq!(Some("€"), some_text_iter.next());
    assert_eq!(Some("d"), some_text_iter.peek());
    assert_eq!(Some("d"), some_text_iter.next());
    assert_eq!(Some("𐍈"), some_text_iter.next());
    assert_eq!(Some("e"), some_text_iter.next());
}

#[test]
fn test_slashes() {
    let slashes = "¯\\\\\\\\\\¯";
    let mut slash_iter = MiniIter::new(&slashes);
    assert_eq!(Some("¯"), slash_iter.peek());
    assert_eq!(Some("¯"), slash_iter.next());
    assert_eq!(Some("\\"), slash_iter.peek());
    assert_eq!(Some("\\\\\\\\\\"), slash_iter.consume_while_case_holds(&|c| c == "\\"));
    assert_eq!(Some("¯"), slash_iter.peek());
    assert_eq!(Some("¯"), slash_iter.next());
    assert_eq!(None, slash_iter.next());
}

#[test]
fn general_iter_test(){
    let some_text = "this is some plaintext";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("t"), some_text_iter.peek());
    assert_eq!(Some("t"), some_text_iter.peek());
    assert_eq!(Some("t"), some_text_iter.next());
    assert_eq!(Some("his"), some_text_iter.consume_while_case_holds(&|c| c != " "));
    assert_eq!(Some(" is some plain"), some_text_iter.consume_until_tail_is("plain"));
    assert_eq!(Some("text"), some_text_iter.consume_until_end());
    assert_eq!(None, some_text_iter.next());

    let other_text = "jkfsgbkfgbdklfdsbh gkhsdfbg <details> and more chars";
    let mut other_text_iter = MiniIter::new(&other_text);
    assert_eq!(Some("jkfsgbkfgbdklfdsbh gkhsdfbg <details>"), other_text_iter.consume_until_tail_is("<details>"));
    assert_eq!(Some(" and more chars") ,other_text_iter.consume_until_end());
    assert_eq!(None, other_text_iter.peek());
}

#[test]
fn consume_peek_line_test(){
    let some_text = "this is some plaintext in a line\nAnd a new line with more content";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("this is some plaintext in a line\n"), some_text_iter.peek_line_ahead());
    assert_eq!(Some("this is some plaintext in a line\n"), some_text_iter.consume_line_ahead());
    assert_ne!(Some("this is some plaintext in a line\n"), some_text_iter.peek_line_ahead());
    assert_eq!(Some("And a new line with more content"), some_text_iter.peek_line_ahead());
    assert_eq!(Some("And a new line with more content"), some_text_iter.consume_line_ahead());
    assert_eq!(None, some_text_iter.peek_line_ahead());
}

#[test]
fn test_degenerate_newlines() {
    let some_text = "\n\n\n\n\nfoo\n";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("\n"), some_text_iter.peek_line_ahead());
    assert_eq!(Some("\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("foo\n"), some_text_iter.consume_line_ahead());
    assert_eq!(None, some_text_iter.consume_line_ahead());
}

#[test]
fn test_mixed_chars() {
    let some_text = "  - foo\n\n\tbar\n";
    let mut some_text_iter = MiniIter::new(&some_text);
    assert_eq!(Some("  - foo\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("\n"), some_text_iter.consume_line_ahead());
    assert_eq!(Some("\tbar\n"), some_text_iter.consume_line_ahead());
}