markdown2pdf 1.3.0

Create PDF with Markdown files (a md to pdf transpiler)
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

use markdown2pdf::markdown::*;

use super::common::parse;


#[test]
fn atx_without_space_is_text() {
    let tokens = parse("#hello");
    assert_eq!(tokens, vec![Token::Text("#hello".to_string())]);
}

#[test]
fn atx_with_space_is_heading() {
    let tokens = parse("# hello");
    assert!(matches!(tokens[0], Token::Heading(_, 1)));
}

#[test]
fn atx_with_tab_after_hash_is_heading() {
    let tokens = parse("#\thello");
    assert!(matches!(tokens[0], Token::Heading(_, 1)));
}

#[test]
fn atx_seven_hashes_falls_back_to_text() {
    let tokens = parse("####### too deep");
    assert!(!matches!(tokens[0], Token::Heading(_, _)));
    let text = Token::collect_all_text(&tokens);
    assert!(text.contains("####### too deep"), "got {:?}", text);
}

#[test]
fn atx_six_hashes_is_h6() {
    let tokens = parse("###### six");
    assert!(matches!(tokens[0], Token::Heading(_, 6)));
}

#[test]
fn atx_trailing_hashes_stripped() {
    let tokens = parse("## Title ##");
    if let Token::Heading(content, 2) = &tokens[0] {
        let text = Token::collect_all_text(content);
        assert_eq!(text, "Title");
    } else {
        panic!("expected H2, got {:?}", tokens);
    }
}

#[test]
fn atx_trailing_hashes_with_trailing_space_stripped() {
    let tokens = parse("## Title ## ");
    if let Token::Heading(content, 2) = &tokens[0] {
        let text = Token::collect_all_text(content);
        assert_eq!(text, "Title");
    } else {
        panic!("expected H2, got {:?}", tokens);
    }
}

#[test]
fn atx_trailing_hash_without_preceding_space_kept() {
    // Regression — `## C#` must keep the `#` as content (no preceding space).
    let tokens = parse("## C#");
    if let Token::Heading(content, 2) = &tokens[0] {
        let text = Token::collect_all_text(content);
        assert_eq!(text, "C#");
    } else {
        panic!("expected H2, got {:?}", tokens);
    }
}

#[test]
fn empty_atx_just_hashes() {
    let tokens = parse("##");
    assert!(matches!(tokens[0], Token::Heading(_, 2)));
    if let Token::Heading(content, _) = &tokens[0] {
        assert!(content.is_empty());
    }
}