rumdl 0.0.12

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule};
use regex::Regex;
use lazy_static::lazy_static;

lazy_static! {
    static ref SINGLE_EMPHASIS_PATTERN: Regex = Regex::new(r"^\s*[*_]([^*_\n]+)[*_]\s*$").unwrap();
    static ref DOUBLE_EMPHASIS_PATTERN: Regex = Regex::new(r"^\s*(?:\*\*|__)([^*_\n]+)(?:\*\*|__)\s*$").unwrap();
    static ref CODE_BLOCK_PATTERN: Regex = Regex::new(r"^(\s*)```").unwrap();
}

#[derive(Debug)]
pub struct MD017NoEmphasisAsHeading {
    pub allow_emphasis_headings: bool,
}

impl Default for MD017NoEmphasisAsHeading {
    fn default() -> Self {
        Self { allow_emphasis_headings: false }
    }
}

impl MD017NoEmphasisAsHeading {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_allow_emphasis_headings(allow_emphasis_headings: bool) -> Self {
        Self { allow_emphasis_headings }
    }

    fn is_single_emphasis_heading(&self, line: &str) -> bool {
        SINGLE_EMPHASIS_PATTERN.is_match(line)
    }

    fn is_double_emphasis_heading(&self, line: &str) -> bool {
        DOUBLE_EMPHASIS_PATTERN.is_match(line)
    }

    fn fix_single_emphasis(&self, line: &str) -> String {
        let captures = SINGLE_EMPHASIS_PATTERN.captures(line).unwrap();
        let content = captures.get(1).unwrap().as_str();
        format!("# {}", content)
    }

    fn fix_double_emphasis(&self, line: &str) -> String {
        let captures = DOUBLE_EMPHASIS_PATTERN.captures(line).unwrap();
        let content = captures.get(1).unwrap().as_str();
        format!("## {}", content)
    }
}

impl Rule for MD017NoEmphasisAsHeading {
    fn name(&self) -> &'static str {
        "MD017"
    }

    fn description(&self) -> &'static str {
        "Emphasis should not be used as a heading"
    }

    fn check(&self, content: &str) -> LintResult {
        if self.allow_emphasis_headings {
            return Ok(Vec::new());
        }

        let mut warnings = Vec::new();
        let mut in_code_block = false;

        for (line_num, line) in content.lines().enumerate() {
            if CODE_BLOCK_PATTERN.is_match(line) {
                in_code_block = !in_code_block;
                continue;
            }

            if !in_code_block {
                if self.is_single_emphasis_heading(line) {
                    warnings.push(LintWarning {
                        line: line_num + 1,
                        column: 1,
                        message: "Single emphasis should not be used as a heading".to_string(),
                        fix: Some(Fix {
                            line: line_num + 1,
                            column: 1,
                            replacement: self.fix_single_emphasis(line),
                        }),
                    });
                } else if self.is_double_emphasis_heading(line) {
                    warnings.push(LintWarning {
                        line: line_num + 1,
                        column: 1,
                        message: "Double emphasis should not be used as a heading".to_string(),
                        fix: Some(Fix {
                            line: line_num + 1,
                            column: 1,
                            replacement: self.fix_double_emphasis(line),
                        }),
                    });
                }
            }
        }

        Ok(warnings)
    }

    fn fix(&self, content: &str) -> Result<String, LintError> {
        if self.allow_emphasis_headings {
            return Ok(content.to_string());
        }

        let mut result = String::new();
        let mut in_code_block = false;

        for line in content.lines() {
            if CODE_BLOCK_PATTERN.is_match(line) {
                in_code_block = !in_code_block;
                result.push_str(line);
            } else if !in_code_block {
                if self.is_single_emphasis_heading(line) {
                    result.push_str(&self.fix_single_emphasis(line));
                } else if self.is_double_emphasis_heading(line) {
                    result.push_str(&self.fix_double_emphasis(line));
                } else {
                    result.push_str(line);
                }
            } else {
                result.push_str(line);
            }
            result.push('\n');
        }

        // Remove trailing newline if the original content didn't have one
        if !content.ends_with('\n') {
            result.pop();
        }

        Ok(result)
    }
}