mdx-gen 0.0.4

A robust Rust library for processing Markdown and converting it to HTML with support for custom blocks, enhanced table formatting, and flexible configuration options.
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

#[cfg(test)]
mod tests {
    use mdx_gen::MarkdownError;

    #[test]
    fn test_markdown_error_parse_error() {
        let error =
            MarkdownError::ParseError("Failed to parse".to_string());
        assert_eq!(
            format!("{error}"),
            "Failed to parse Markdown: Failed to parse"
        );
    }

    #[test]
    fn test_markdown_error_conversion_error() {
        let error = MarkdownError::ConversionError(
            "Conversion failed".to_string(),
        );
        assert_eq!(
            format!("{error}"),
            "Failed to convert Markdown to HTML: Conversion failed"
        );
    }

    #[test]
    fn test_markdown_error_custom_block_error() {
        let error = MarkdownError::CustomBlockError(
            "Custom block failed".to_string(),
        );
        assert_eq!(
            format!("{error}"),
            "Failed to process custom block: Custom block failed"
        );
    }

    #[test]
    fn test_markdown_error_syntax_highlight_error() {
        let error = MarkdownError::SyntaxHighlightError(
            "Highlighting failed".to_string(),
        );
        assert_eq!(
            format!("{error}"),
            "Syntax highlighting error: Highlighting failed"
        );
    }

    #[test]
    fn test_markdown_error_invalid_options_error() {
        let error = MarkdownError::InvalidOptionsError(
            "Invalid options".to_string(),
        );
        assert_eq!(
            format!("{error}"),
            "Invalid Markdown options: Invalid options"
        );
    }

    #[test]
    fn test_markdown_error_syntax_set_error() {
        let error = MarkdownError::SyntaxSetError(
            "Failed to load syntax set".to_string(),
        );
        assert_eq!(
            format!("{error}"),
            "Failed to load syntax set: Failed to load syntax set"
        );
    }

    #[test]
    fn test_markdown_error_input_too_large() {
        let error = MarkdownError::InputTooLarge {
            size: 2_000_000,
            limit: 1_000_000,
        };
        assert!(format!("{error}").contains("2000000"));
        assert!(format!("{error}").contains("1000000"));
    }

    #[test]
    fn test_markdown_error_render_error() {
        let error =
            MarkdownError::RenderError("fmt failed".to_string());
        assert_eq!(
            format!("{error}"),
            "HTML rendering error: fmt failed"
        );
    }
}