rumdl 0.3.0

A fast Markdown linter and formatter written in Rust
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

//! Source-backed lexical emphasis shared by the spacing and style rules.
//!
//! Pairing and block eligibility remain rule-specific. Delimiters and the rare
//! masked text live in document-level arenas rather than one allocation per line.

use std::borrow::Cow;
use std::ops::Range;

use super::LintContext;
use crate::filtered_lines::FilteredLinesExt;
use crate::utils::emphasis_utils::{EmphasisMarker, find_emphasis_markers_into, replace_inline_code_cow};

struct LineRecord {
    line_num: usize,
    source: Range<usize>,
    mdx_masked: Option<Range<usize>>,
    code_masked: Option<Range<usize>>,
    markers: Range<usize>,
}

#[derive(Default)]
pub(super) struct LexicalEmphasis {
    lines: Vec<LineRecord>,
    markers: Vec<EmphasisMarker>,
    masked: String,
}

#[derive(Clone, Copy)]
pub(crate) struct EmphasisLine<'a> {
    pub(crate) line_num: usize,
    source: &'a str,
    without_code: &'a str,
    pub(crate) markers: &'a [EmphasisMarker],
}

impl<'a> EmphasisLine<'a> {
    pub(crate) fn source(self) -> &'a str {
        self.source
    }
    pub(crate) fn without_code(self) -> &'a str {
        self.without_code
    }
}

impl LexicalEmphasis {
    pub(super) fn lines<'a>(&'a self, content: &'a str) -> impl Iterator<Item = EmphasisLine<'a>> {
        self.lines.iter().map(|line| {
            let source = line
                .mdx_masked
                .as_ref()
                .map_or_else(|| &content[line.source.clone()], |range| &self.masked[range.clone()]);
            EmphasisLine {
                line_num: line.line_num,
                source,
                without_code: line
                    .code_masked
                    .as_ref()
                    .map_or(source, |range| &self.masked[range.clone()]),
                markers: &self.markers[line.markers.clone()],
            }
        })
    }

    fn store_mask(&mut self, text: Cow<'_, str>) -> Option<Range<usize>> {
        match text {
            Cow::Borrowed(_) => None,
            Cow::Owned(text) => {
                let start = self.masked.len();
                self.masked.push_str(&text);
                Some(start..self.masked.len())
            }
        }
    }
}

pub(super) fn collect(ctx: &LintContext<'_>) -> LexicalEmphasis {
    let mut result = LexicalEmphasis::default();
    for line in ctx
        .filtered_lines()
        .skip_front_matter()
        .skip_code_blocks()
        .skip_math_blocks()
        .skip_html_blocks()
        .skip_esm_blocks()
        .skip_obsidian_comments()
        .skip_mkdocstrings()
        .candidates(super::LineCandidateKind::Emphasis)
        .filter(|line| !line.line_info.is_myst_comment)
    {
        let info = line.line_info;
        let source_range = info.byte_offset..info.byte_offset + info.byte_len;
        let source =
            crate::utils::skip_context::mask_mdx_inline_code(ctx, &ctx.content[source_range.clone()], info.byte_offset);
        let code = replace_inline_code_cow(&source);
        let markers_start = result.markers.len();
        find_emphasis_markers_into(&code, &mut result.markers);
        let code_masked = result.store_mask(code);
        let mdx_masked = result.store_mask(source);
        result.lines.push(LineRecord {
            line_num: line.line_num,
            source: source_range,
            mdx_masked,
            code_masked,
            markers: markers_start..result.markers.len(),
        });
    }
    result
}