mdq 0.10.0

Select and render specific elements in a Markdown document
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

use crate::util::output::{Output, SimpleWrite};
use std::collections::HashMap;

pub(crate) struct FootnoteTransformer<'md> {
    mappings: Option<HashMap<&'md str, usize>>,
}

pub(crate) struct FootnoteTransformerToString<'a, 'md> {
    transformer: &'a mut FootnoteTransformer<'md>,
    scratch: Output<String>,
}

impl<'md> FootnoteTransformer<'md> {
    pub(crate) fn new(active: bool) -> Self {
        Self {
            mappings: if active { Some(HashMap::default()) } else { None },
        }
    }

    pub(crate) fn write<W>(&mut self, out: &mut Output<W>, label: &'md str)
    where
        W: SimpleWrite,
    {
        match &mut self.mappings {
            None => out.write_str(label),
            Some(mapping) => {
                let current_mapping_len = mapping.len();
                let num = mapping.entry(label).or_insert(current_mapping_len + 1);
                out.write_str(&num.to_string());
            }
        }
    }

    pub(crate) fn new_to_stringer<'a>(&'a mut self) -> FootnoteTransformerToString<'a, 'md> {
        FootnoteTransformerToString::new(self)
    }
}

impl<'a, 'md> FootnoteTransformerToString<'a, 'md> {
    pub(crate) fn transform(&mut self, label: &'md str) -> String {
        let len = self.transformed_label_len(label);
        _ = self.scratch.replace_underlying(String::with_capacity(len)).unwrap();
        self.transformer.write(&mut self.scratch, label);
        self.scratch.take_underlying().unwrap()
    }

    fn new(transformer: &'a mut FootnoteTransformer<'md>) -> Self {
        Self {
            transformer,
            scratch: Output::without_text_wrapping(String::new()),
        }
    }

    fn transformed_label_len(&mut self, label: &str) -> usize {
        match &mut self.transformer.mappings {
            None => label.len(),
            Some(mapping) => {
                let renumbered_to = mapping.get(label).copied().unwrap_or(mapping.len() + 1);
                let renumbered_log10 = renumbered_to.checked_ilog10().unwrap_or(0);
                // Try to convert the u32 to usize; if we can't, just guess a length of 3.
                // That should be plenty!
                usize::try_from(renumbered_log10 + 1).unwrap_or(3)
            }
        }
    }
}

#[cfg(test)]
mod test {
    use crate::output::footnote_transform::FootnoteTransformer;
    use crate::util::output::Output;

    #[test]
    fn inactive() {
        let mut transformer = FootnoteTransformer::new(false);
        check("abc", &mut transformer, "abc", 3);
        check("1", &mut transformer, "1", 1);
        check("3", &mut transformer, "3", 1);

        // remember the old value
        check("1", &mut transformer, "1", 1);
    }

    #[test]
    fn active() {
        let mut transformer = FootnoteTransformer::new(true);
        check("abc", &mut transformer, "1", 1);
        check("1", &mut transformer, "2", 1);
        check("3", &mut transformer, "3", 1);

        // remember the old value
        check("1", &mut transformer, "2", 1);
    }

    #[test]
    fn active_with_ten_footnotes() {
        let mut transformer = FootnoteTransformer::new(true);

        // write nine labels; we don't care about the results
        let nine_labels: Vec<_> = (1..10).map(|i| format!("footnote-{i}")).collect();
        for label in &nine_labels {
            transformer.write(&mut Output::without_text_wrapping(String::new()), label);
        }

        // the tenth label should remap to "10" with an expected len of 2
        check("z", &mut transformer, "10", 2);
    }

    fn check<'a>(
        input: &'a str,
        transformer: &mut FootnoteTransformer<'a>,
        expect: &str,
        expect_transformed_len: usize,
    ) {
        // len-calculation should work before and after we first officially see the label. So, try
        // this once before transformer.write, and then later we'll try it again.
        assert_eq!(
            transformer.new_to_stringer().transformed_label_len(input),
            expect_transformed_len
        );

        let mut output = Output::without_text_wrapping(String::with_capacity(expect.len()));
        transformer.write(&mut output, input);
        let actual = output.take_underlying().unwrap();
        assert_eq!(&actual, expect);

        assert_eq!(
            transformer.new_to_stringer().transformed_label_len(input),
            expect_transformed_len
        );
    }
}