mdstitch 0.1.0

Streaming markdown preprocessor that closes unterminated syntax token-by-token.
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

use std::borrow::Cow;

use super::emphasis::find_trailing_strikethrough;
use super::ranges::CodeBlockRanges;
use super::utils::{cow_append, ends_with_odd_backslashes, is_empty_or_markers};

/// Counts `~~` pairs in the text.
fn count_double_tildes(text: &str) -> usize {
    let bytes = text.as_bytes();
    let mut count = 0;
    let mut i = 0;
    while i + 1 < bytes.len() {
        if bytes[i] == b'~' && bytes[i + 1] == b'~' {
            count += 1;
            i += 2;
        } else {
            i += 1;
        }
    }
    count
}

/// Finds `~~content~` half-complete pattern.
/// Returns the marker index of the opening `~~`.
fn find_half_complete_tilde(text: &str) -> Option<usize> {
    if !text.ends_with('~') || text.ends_with("~~") {
        return None;
    }
    let bytes = text.as_bytes();
    let content_end = bytes.len() - 1; // index of trailing `~`
    if content_end < 3 {
        return None;
    }
    let mut i = content_end - 1;
    while i >= 1 {
        if bytes[i] == b'~' && bytes[i - 1] == b'~' {
            let between = &text[i + 1..content_end];
            if !between.contains('~') {
                return Some(i - 1);
            }
        }
        i -= 1;
    }
    None
}

/// Test-only convenience wrapper that builds `CodeBlockRanges` on the fly.
#[cfg(test)]
fn handle(text: &str) -> Cow<'_, str> {
    handle_with_ranges(text, &CodeBlockRanges::new(text))
}

/// Completes incomplete strikethrough formatting, using pre-computed code block ranges.
pub(crate) fn handle_with_ranges<'a>(text: &'a str, ranges: &CodeBlockRanges) -> Cow<'a, str> {
    if let Some((marker_index, content)) = find_trailing_strikethrough(text) {
        if content.is_empty() || is_empty_or_markers(content) {
            return Cow::Borrowed(text);
        }
        if ranges.is_inside_code(marker_index)
            || ranges.is_within_complete_inline_code(marker_index)
            || ranges.is_within_complete_math(marker_index)
        {
            return Cow::Borrowed(text);
        }

        let pairs = count_double_tildes(text);
        if pairs % 2 == 1 {
            if ends_with_odd_backslashes(text) {
                return Cow::Borrowed(text);
            }
            return cow_append(text, "~~");
        }
    } else {
        // Check for half-complete: ~~content~ → ~~content~~.
        if let Some(marker_index) = find_half_complete_tilde(text)
            && !ranges.is_inside_code(marker_index)
            && !ranges.is_within_complete_inline_code(marker_index)
            && !ranges.is_within_complete_math(marker_index)
        {
            let pairs = count_double_tildes(text);
            if pairs % 2 == 1 {
                if ends_with_odd_backslashes(text) {
                    return Cow::Borrowed(text);
                }
                return cow_append(text, "~");
            }
        }
    }

    Cow::Borrowed(text)
}

#[cfg(test)]
mod tests {
    use super::handle;
    use std::borrow::Cow;

    #[test]
    fn completes_strikethrough() {
        assert_eq!(handle("~~strike text").as_ref(), "~~strike text~~");
    }

    #[test]
    fn half_complete() {
        assert_eq!(handle("~~strike~").as_ref(), "~~strike~~");
    }

    #[test]
    fn leaves_complete() {
        assert!(matches!(handle("~~strike~~"), Cow::Borrowed(_)));
    }

    #[test]
    fn empty_content() {
        assert!(matches!(handle("~~"), Cow::Borrowed(_)));
    }

    #[test]
    fn inside_code_block() {
        assert!(matches!(handle("```\n~~strike\n```"), Cow::Borrowed(_)));
    }

    #[test]
    fn leaves_trailing_backslash() {
        assert!(matches!(handle("~~\\"), Cow::Borrowed(_)));
    }

    #[test]
    fn idempotent_with_trailing_backslash() {
        let once = handle("~~\\").into_owned();
        let twice = handle(&once).into_owned();
        assert_eq!(twice, once);
    }
}