fmtm 0.0.4

A diff-friendly Markdown formatter that breaks lines on sensible punctuations and words to fit a line width.
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

use std::iter::once;

use fmtt::{format, Hanging};

use super::*;

/// A [`ExternalFormatter`] that uses the FMTT to format Markdown paragraphs.
/// If the line width is not specified, do not format.
pub struct FmttParagraph {
    line_width: Option<usize>,
    buffer: String,
    hard_break_points: Vec<usize>,
}

impl Write for FmttParagraph {
    fn write_str(&mut self, s: &str) -> std::fmt::Result {
        trace!(s, "FmttParagraph::write_str");
        match s {
            r"\
" => {
                self.buffer.push_str(s);
                self.hard_break_points.push(self.buffer.len());
            }
            // NOTE: We use the null byte for a space character that
            // should not be used as a break point.
            "[ ] " => self.buffer.push_str("[ ]\0"),
            "[x] " => self.buffer.push_str("[x]\0"),
            _ => self.buffer.push_str(s),
        };
        Ok(())
    }
}

impl ExternalFormatter for FmttParagraph {
    fn new(_buffer_type: BufferType, max_width: Option<usize>, capacity: usize) -> Self {
        Self {
            line_width: max_width,
            buffer: String::with_capacity(capacity),
            hard_break_points: Vec::new(),
        }
    }

    fn is_empty(&self) -> bool {
        self.buffer.is_empty()
    }

    fn context(&self) -> FormattingContext {
        FormattingContext::Paragraph
    }

    fn into_buffer(self) -> String {
        let Self {
            line_width,
            buffer,
            hard_break_points,
        } = self;
        let chunk_border_indices = hard_break_points.iter().copied();
        match line_width {
            Some(line_width) => {
                let paragraph_starts = Default::default();
                once(0)
                    .chain(chunk_border_indices.clone())
                    .zip(chunk_border_indices.chain(once(buffer.len())))
                    .map(|(start, end)| {
                        format(
                            &buffer[start..end],
                            line_width,
                            Hanging::Hang,
                            &paragraph_starts,
                        )
                        .join("")
                    })
                    .collect::<String>()
                // format(&self.buffer, line_width, Hanging::Hang, &Default::default()).join("")
            }
            None => buffer,
        }
        .replace("\0", " ")
    }
}