rough 0.2.0

A very simple and opinionated static site generator.
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

//! Defines a wrapper for `pulldown_cmark`'s parser (or any type implementing
//! the same iterator trait) which removes wrapped paragraph tags when they
//! only wrap a single image.
use pulldown_cmark::{Event, Tag};
use std::collections::VecDeque;

/// A wrapper for `pulldown_cmark`'s parser (or any type implementing the same
/// iterator trait) which removes wrapped paragraph tags when they only wrap a
/// single image.
pub struct InlineImages<'a, I: Iterator<Item = Event<'a>>> {
    /// The parser to get events from.
    parser: I,
    /// A buffer where events which have been requested from the underlying
    /// parser but not yet from whatever is consuming this wrapper are stored.
    buffer: VecDeque<Event<'a>>,
}

impl<'a, I: Iterator<Item = Event<'a>>> InlineImages<'a, I> {
    /// Wrap a parser in this converter. The wrapped parser can be used in the
    /// same way as the original one.
    pub fn new(parser: I) -> Self {
        InlineImages {
            parser,
            buffer: VecDeque::new(),
        }
    }

    /// Request events from the underlying parser until we reach an end image
    /// tag. The events will be stored in the buffer. Panics if we reach the
    /// end of the file without encountering an end image tag.
    fn buffer_until_image_end(&mut self) {
        loop {
            let event = self
                .parser
                .next()
                .expect("parser ended with unclosed image");
            if let Event::End(Tag::Image(..)) = event {
                self.buffer.push_back(event);
                break;
            }
            self.buffer.push_back(event);
        }
    }

    /// Handle the start of a paragraph, making the relevant transformations if
    /// the paragraph turns out to include only an image tag. Returns the next
    /// event to yield, but also always ends up with further events left in
    /// the buffer.
    fn on_paragraph_start(&mut self) -> Event<'a> {
        let event = self
            .parser
            .next()
            .expect("parser ended with unclosed paragraph");
        if let Event::Start(Tag::Image(..)) = event {
            self.buffer.push_back(event);
            self.buffer_until_image_end();
            let next = self
                .parser
                .next()
                .expect("parser ended with unclosed paragraph");
            if !matches!(next, Event::End(Tag::Paragraph)) {
                // The paragraph contains more than just the image, so re-insert
                // the paragraph start.
                self.buffer.push_front(Event::Start(Tag::Paragraph));
                self.buffer.push_back(next);
            }
            self.buffer.pop_front().expect("buffer not to be empty")
        } else {
            self.buffer.push_back(event);
            Event::Start(Tag::Paragraph)
        }
    }
}

impl<'a, I: Iterator<Item = Event<'a>>> Iterator for InlineImages<'a, I> {
    type Item = Event<'a>;

    /// Get the next event, with the transformation applied.
    fn next(&mut self) -> Option<Event<'a>> {
        self.buffer.pop_front().or_else(|| {
            let event = self.parser.next()?;
            if event == Event::Start(Tag::Paragraph) {
                Some(self.on_paragraph_start())
            } else {
                Some(event)
            }
        })
    }
}