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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

#[cfg(test)]
mod tests {
    use comrak::Options;
    use mdx_gen::{process_markdown, MarkdownError, MarkdownOptions};

    #[test]
    fn test_markdown_error_access() {
        // Ensure that the MarkdownError enum is accessible and works
        let error =
            MarkdownError::ConversionError("Test error".to_string());
        assert_eq!(
            format!("{}", error),
            "Failed to convert Markdown to HTML: Test error"
        );
    }

    #[test]
    fn test_process_markdown_with_default_options() {
        let markdown = "# Heading\n\nThis is a **bold** text.";
        let options = MarkdownOptions::new().with_comrak_options({
            let mut opts = Options::default();
            opts.extension.table = true; // Ensure table extension is disabled for default test
            opts
        });
        let result = process_markdown(markdown, &options)
            .expect("Failed to process markdown");
        assert!(
            result.contains("<h1>Heading</h1>"),
            "Heading was not processed correctly"
        );
        assert!(
            result.contains("<strong>bold</strong>"),
            "Bold text was not processed correctly"
        );
    }

    #[test]
    fn test_process_markdown_with_custom_blocks() {
        let markdown = r#"<div class="note">This is a note.</div>"#;
        let options = MarkdownOptions::new()
            .with_custom_blocks(true)
            .with_comrak_options({
                let mut opts = Options::default();
                opts.extension.table = true;
                opts
            })
            .with_unsafe_html(true);
        let result = process_markdown(markdown, &options)
            .expect("Failed to process markdown with custom blocks");
        assert!(result.contains(r#"<div class="alert alert-info" role="alert"><strong>Note:</strong>"#), "Custom block was not processed correctly");
    }

    #[test]
    fn test_process_markdown_with_syntax_highlighting() {
        let markdown = "```rust\nfn main() {\n    println!(\"Hello, world!\");\n}\n```";
        let options = MarkdownOptions::new()
            .with_syntax_highlighting(true)
            .with_comrak_options({
                let mut opts = Options::default();
                opts.extension.table = true; // Ensure table extension is enabled to avoid conflicts
                opts
            });
        let result = process_markdown(markdown, &options).expect(
            "Failed to process markdown with syntax highlighting",
        );
        println!(
            "Processed Markdown (Syntax Highlighting):\n{}",
            result
        );

        // Check for syntax highlighting in the generated HTML
        assert!(result.contains("<code class=\"language-rust\">"), "Code block was not processed with the expected syntax highlighting class");

        // Check that the general structure of the code content is present (using Hello, world!)
        assert!(
            result.contains("Hello, world!"),
            "Code block content was not processed correctly"
        );

        // Highlighter now emits class-based spans (no inline styles).
        assert!(
            result.contains("<span class=\""),
            "Expected class-based syntax spans in: {result}"
        );
        assert!(
            !result.contains(" style=\""),
            "Inline style attributes should no longer appear: {result}"
        );
    }

    #[test]
    fn test_process_markdown_with_enhanced_tables() {
        let markdown = "| Header 1 | Header 2 |\n| --- | --- |\n| Cell 1 | Cell 2 |";
        let options = MarkdownOptions::new()
            .with_enhanced_tables(true)
            .with_comrak_options({
                let mut opts = Options::default();
                opts.extension.table = true; // Enable table extension
                opts
            });
        let result = process_markdown(markdown, &options)
            .expect("Failed to process markdown with enhanced tables");
        println!("Processed Markdown (Enhanced Tables):\n{}", result);

        // Check for table elements with enhanced formatting
        assert!(
            result.contains("<div class=\"table-responsive\">"),
            "Table wrapper was not processed correctly"
        );
        assert!(
            result.contains("<table class=\"table\">"),
            "Table class was not applied correctly"
        );
        assert!(
            result.contains("<td class=\"text-left\">Cell 1</td>"),
            "Cell 1 was not processed correctly"
        );
        assert!(
            result.contains("<td class=\"text-left\">Cell 2</td>"),
            "Cell 2 was not processed correctly"
        );
    }

    #[test]
    fn test_markdown_options_customization() {
        let options = MarkdownOptions::new()
            .with_custom_blocks(false)
            .with_syntax_highlighting(false)
            .with_enhanced_tables(false);
        assert!(
            !options.enable_custom_blocks,
            "Custom blocks should be disabled"
        );
        assert!(
            !options.enable_syntax_highlighting,
            "Syntax highlighting should be disabled"
        );
        assert!(
            !options.enable_enhanced_tables,
            "Enhanced tables should be disabled"
        );
    }
}