harper 0.0.1

A library to implement SSGs.
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

use std::fmt::Write;

use pulldown_cmark::{Event, Tag, TagEnd};

use crate::error::Result;
use crate::markdown::Plugin;
use crate::value::Sink;

pub struct Snippet<O> {
    output: O,
    snippet: String,
    length: usize,
}

impl<O> Snippet<O> {
    pub fn new(output: O, length: usize) -> Self {
        Self { output, snippet: String::new(), length }
    }
}

struct SnippetIterator<'a, I: Iterator<Item = Event<'a>>> {
    snippet: &'a mut String,
    inner: I,
    capture: Vec<bool>,
    snip_text_len: usize,
    min_length: usize,
    done: bool,
}

macro_rules! open {
    ($it:expr) => ($it.capture.push(false));
    ($it:expr, $($fmt:tt)*) => ({
        let _ = write!($it.snippet, $($fmt)*);
        $it.capture.push(true);
    })
}

macro_rules! close {
    ($it:expr) => ({
        $it.capture.pop();
        if $it.capture.is_empty() && $it.snip_text_len >= $it.min_length {
            $it.done = true;
        }
    });
    ($it:expr, $($fmt:tt)*) => ({
        let _ = write!($it.snippet, $($fmt)*);
        close!($it);
    })
}

macro_rules! capture {
    ($it:expr, $str:expr) => (capture!($it, $str, $str));
    ($it:expr, $str:expr, $($fmt:tt)*) => ({
        if !$it.done && $it.capture.last().copied().unwrap_or_default() {
            let _ = write!($it.snippet, $($fmt)*);
            $it.snip_text_len += $str.len();
        }
    })
}

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

    fn next(&mut self) -> Option<Self::Item> {
        let event = self.inner.next()?;
        if self.done {
            return Some(event);
        }

        match &event {
            Event::Start(tag) => match tag {
                Tag::Paragraph => open!(self, "<p>"),
                Tag::Emphasis => open!(self, "<em>"),
                Tag::Strong => open!(self, "<strong>"),
                Tag::Strikethrough => open!(self, "<strike>"),
                Tag::BlockQuote => open!(self, "<blockquote>"),
                Tag::Link { dest_url, title, .. } => {
                    open!(self, r#"<a href="{dest_url}" title="{title}">"#)
                }
                _ => open!(self),
            },
            Event::End(tag) => match tag {
                TagEnd::Paragraph => close!(self, "</p>"),
                TagEnd::Emphasis => close!(self, "</em>"),
                TagEnd::Strong => close!(self, "</strong>"),
                TagEnd::Strikethrough => close!(self, "</strike>"),
                TagEnd::BlockQuote => close!(self, "</blockquote>"),
                TagEnd::Link => close!(self, "</a>"),
                _ => close!(self),
            },

            Event::SoftBreak => capture!(self, " "),
            Event::HardBreak => capture!(self, "", "<br>"),
            Event::Code(text) => capture!(self, text, "<code>{text}</code>"),
            Event::Text(text) => capture!(self, text, "{text}"),
            _ => { /* do nothing */ }
        }

        Some(event)
    }
}

// IDEA: What if we just take the first k character of the text and render that as markdown?

impl<O: Sink> Plugin for Snippet<O> {
    fn remap<'a, I>(&'a mut self, events: I) -> Box<dyn Iterator<Item = Event<'a>> + 'a>
        where I: Iterator<Item = Event<'a>> + 'a
    {
        Box::new(SnippetIterator {
            snippet: &mut self.snippet,
            snip_text_len: 0,
            inner: events,
            capture: vec![],
            min_length: self.length,
            done: self.length == 0,
        })
    }

    fn finalize(&mut self) -> Result<()> {
        let snippet = std::mem::replace(&mut self.snippet, String::new());
        self.output.write(snippet)
    }
}