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

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

/// Rule MD048: Code fence style should be consistent
pub struct MD048CodeFenceStyle {
    style: CodeFenceStyle,
}

#[derive(Debug, Clone, PartialEq)]
pub enum CodeFenceStyle {
    Backtick,
    Tilde,
    Consistent,
}

impl MD048CodeFenceStyle {
    pub fn new(style: CodeFenceStyle) -> Self {
        Self { style }
    }

    fn detect_style(&self, content: &str) -> Option<CodeFenceStyle> {
        for line in content.lines() {
            let trimmed = line.trim_start();
            if trimmed.starts_with("```") {
                return Some(CodeFenceStyle::Backtick);
            } else if trimmed.starts_with("~~~") {
                return Some(CodeFenceStyle::Tilde);
            }
        }
        None
    }
}

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

    fn description(&self) -> &'static str {
        "Code fence style should be consistent"
    }

    fn check(&self, content: &str) -> LintResult {
        let mut warnings = Vec::new();
        let target_style = match self.style {
            CodeFenceStyle::Consistent => self.detect_style(content).unwrap_or(CodeFenceStyle::Backtick),
            _ => self.style.clone(),
        };

        for (line_num, line) in content.lines().enumerate() {
            let trimmed = line.trim_start();
            if trimmed.starts_with("```") && target_style == CodeFenceStyle::Tilde {
                warnings.push(LintWarning {
                    line: line_num + 1,
                    column: line.len() - trimmed.len() + 1,
                    message: "Code fence style should use tildes".to_string(),
                    fix: Some(Fix {
                        line: line_num + 1,
                        column: line.len() - trimmed.len() + 1,
                        replacement: line.replace("```", "~~~"),
                    }),
                });
            } else if trimmed.starts_with("~~~") && target_style == CodeFenceStyle::Backtick {
                warnings.push(LintWarning {
                    line: line_num + 1,
                    column: line.len() - trimmed.len() + 1,
                    message: "Code fence style should use backticks".to_string(),
                    fix: Some(Fix {
                        line: line_num + 1,
                        column: line.len() - trimmed.len() + 1,
                        replacement: line.replace("~~~", "```"),
                    }),
                });
            }
        }

        Ok(warnings)
    }

    fn fix(&self, content: &str) -> Result<String, LintError> {
        let target_style = match self.style {
            CodeFenceStyle::Consistent => self.detect_style(content).unwrap_or(CodeFenceStyle::Backtick),
            _ => self.style.clone(),
        };

        let mut result = String::new();
        for line in content.lines() {
            let trimmed = line.trim_start();
            if trimmed.starts_with("```") && target_style == CodeFenceStyle::Tilde {
                result.push_str(&line.replace("```", "~~~"));
            } else if trimmed.starts_with("~~~") && target_style == CodeFenceStyle::Backtick {
                result.push_str(&line.replace("~~~", "```"));
            } else {
                result.push_str(line);
            }
            result.push('\n');
        }

        Ok(result)
    }
}