Composable MD parser example

composition.rs

struct MultilineDelimiterCtx {
    delimiter: &'static str,
    start: usize,
    closing_tag: TagEnd,
}

/// Markdown parser that extends `pulldown_cmark` one with tags/elements that
/// aren't part of CommonMark specification.
pub struct MarkdownParser<'input> {
    source: &'input str,
    inner: pulldown_cmark::Parser<'input, 'input>,
    remainder: VecDeque<Event<'input>>,
    multiline: Option<MultilineDelimiterCtx>,
}

impl<'input> Iterator for MarkdownParser<'input> {
    type Item = Event<'input>;

    fn next(&mut self) -> Option<Self::Item> {
        Some('result: loop {
            let current: Event<'input> = if !self.remainder.is_empty() {
                self.remainder.pop_front().unwrap()
            } else {
                Event::CommonMark(self.inner.next()?)
            };

            break match current {
                Event::CommonMark(cm) => match (&*cm, &mut self.multiline) {
                    (CMEventData::Text(text), None) => {
                        for t in Tag::ALL {
                            let delimiter = t.delimiter();
                            let len = delimiter.len();
                            if t.is_multiline() {
                                if let Some(start) = text.as_ref().find(delimiter) {
                                    self.multiline = Some(MultilineDelimiterCtx {
                                        delimiter,
                                        start: cm.span().start() + start + len,
                                        closing_tag: TagEnd::from(t),
                                    });
                                    self.remainder.push_back(Event::Start(t));
                                    break 'result Event::CommonMark(CMEvent::new(
                                        CMEventData::Text(text.slice(..start)),
                                        cm.span().cap_length(start),
                                    ));
                                } else {
                                    break 'result Event::CommonMark(cm);
                                }
                            } else if let Some((start, end)) =
                                find_wrapped(text.as_ref(), delimiter)
                            {
                                self.remainder.extend([
                                    Event::Start(t),
                                    Event::CommonMark(CMEvent::new(
                                        CMEventData::Text(text.slice((start + len)..(end - len))),
                                        cm.span()
                                            .offset_start((start + len) as isize)
                                            .cap_length(end - start - len * 2),
                                    )),
                                    Event::End(TagEnd::from(t)),
                                    Event::CommonMark(CMEvent::new(
                                        CMEventData::Text(text.slice(end..)),
                                        cm.span().offset_start(end as isize),
                                    )),
                                ]);
                                break 'result Event::CommonMark(CMEvent::new(
                                    CMEventData::Text(text.slice(..start)),
                                    cm.span().cap_length(start),
                                ));
                            }
                        }

                        Event::CommonMark(cm)
                    }
                    (_, multiline) => match multiline {
                        Some(multiline) => {
                            let text = &self.source[cm.span()];
                            if let Some(end) = text.find(multiline.delimiter) {
                                let len = multiline.delimiter.len();
                                self.remainder.extend([
                                    Event::End(multiline.closing_tag),
                                    Event::CommonMark(CMEvent::new(
                                        CMEventData::Text(CowStr::Borrowed(&text[(end + len)..])),
                                        cm.span().offset_start((end + len) as isize),
                                    )),
                                ]);
                                let span = Span::from(multiline.start..(cm.span().start() + end));
                                self.multiline = None;
                                Event::CommonMark(CMEvent::new(
                                    CMEventData::Text(CowStr::Borrowed(&self.source[span])),
                                    span,
                                ))
                            } else {
                                continue;
                            }
                        }
                        None => Event::CommonMark(cm),
                    },
                },
                other => other,
            };
        })
    }
}

pulldown_cmark types are re-exported with CM prefix and wrapped in local structs with the same name because I'm not very creative.