rumdl 0.1.51

A fast Markdown linter written in Rust (Ru(st) MarkDown Linter)
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

use rumdl_lib::utils::{ElementQuality, ElementType, MarkdownElements};

#[test]
fn test_markdown_elements_detection() {
    let content = r#"---
title: Test Document
---

# Heading 1

This is a paragraph with `code span` and more text.

## Heading 2

- List item 1
- List item 2
* List item 3
+ List item 4

1. Ordered item 1
2. Ordered item 2

```rust
fn test() {
    println!("Hello, world!");
}
```

Setext heading
=============

Another paragraph
"#;

    // Test code block detection
    let code_blocks = MarkdownElements::detect_code_blocks(content);
    assert_eq!(code_blocks.len(), 1);
    assert_eq!(code_blocks[0].element_type, ElementType::CodeBlock);
    assert_eq!(code_blocks[0].metadata, Some("rust".to_string()));

    // Test heading detection
    let headings = MarkdownElements::detect_headings(content);

    // We have 3 headings: H1, H2, and the Setext heading (frontmatter is not treated as a heading)
    assert_eq!(headings.len(), 3);

    // Check each heading's level
    let levels: Vec<Option<u32>> = headings.iter().map(MarkdownElements::get_heading_level).collect();

    // Regular ATX headings
    assert_eq!(levels[0], Some(1)); // # Heading 1
    assert_eq!(levels[1], Some(2)); // ## Heading 2
    // Setext heading with = is level 1
    assert_eq!(levels[2], Some(1)); // Setext heading

    // Test list detection
    let lists = MarkdownElements::detect_lists(content);
    println!("Detected {} lists:", lists.len());
    for (i, list) in lists.iter().enumerate() {
        println!(
            "  {}. Line {}: '{}' (Marker: {:?}, Quality: {:?})",
            i + 1,
            list.start_line,
            list.text,
            list.metadata,
            list.quality
        );
    }
    assert_eq!(lists.len(), 6);

    // First list should be the first actual list in the document
    assert_eq!(lists[0].element_type, ElementType::List);
    assert_eq!(lists[0].metadata, Some("minus".to_string()));
    assert_eq!(lists[0].quality, ElementQuality::Valid);

    // Check all list marker types
    assert_eq!(lists[0].metadata, Some("minus".to_string()));
    assert_eq!(lists[1].metadata, Some("minus".to_string()));
    assert_eq!(lists[2].metadata, Some("asterisk".to_string()));
    assert_eq!(lists[3].metadata, Some("plus".to_string()));
    assert_eq!(lists[4].metadata, Some("ordered".to_string()));
    assert_eq!(lists[5].metadata, Some("ordered".to_string()));

    // Test front matter detection
    let front_matter = MarkdownElements::detect_front_matter(content);
    assert!(front_matter.is_some());
    assert_eq!(front_matter.unwrap().element_type, ElementType::FrontMatter);

    // Test code span detection
    let line = "This is a paragraph with `code span` and more text.";
    assert!(MarkdownElements::is_in_code_span(line, 25)); // Inside code span
    assert!(!MarkdownElements::is_in_code_span(line, 5)); // Outside code span

    // Test heading to fragment conversion
    assert_eq!(MarkdownElements::heading_to_fragment("Heading 1"), "heading-1");
}

#[test]
fn test_markdown_elements_with_edge_cases() {
    let content = r#"
Some text

```
Unclosed code block
"#;

    // Test unclosed code block
    let code_blocks = MarkdownElements::detect_code_blocks(content);
    assert_eq!(code_blocks.len(), 1);

    // Test empty content
    let empty_content = "";
    assert_eq!(MarkdownElements::detect_code_blocks(empty_content).len(), 0);
    assert_eq!(MarkdownElements::detect_headings(empty_content).len(), 0);
    assert_eq!(MarkdownElements::detect_lists(empty_content).len(), 0);
    assert!(MarkdownElements::detect_front_matter(empty_content).is_none());

    // Test content with only whitespace
    let whitespace_content = "   \n  \n";
    assert_eq!(MarkdownElements::detect_code_blocks(whitespace_content).len(), 0);
    assert_eq!(MarkdownElements::detect_headings(whitespace_content).len(), 0);
    assert_eq!(MarkdownElements::detect_lists(whitespace_content).len(), 0);
}