An implementation of a text joiner in a stream of events

text_joiner.rs

struct TextJoiner<'a, 'b> {
    source: &'a str,
    parser: Peekable<pulldown_cmark::OffsetIter<'a, 'b>>,
}

impl<'a, 'b> TextJoiner<'a, 'b> {
    fn new_ext(source: &'a str, options: Options) -> Self {
        Self {
            source,
            parser: pulldown_cmark::Parser::new_ext(source, options)
                .into_offset_iter()
                .peekable(),
        }
    }
}

impl<'a, 'b> Iterator for TextJoiner<'a, 'b> {
    type Item=(Event<'a>, Range<usize>);
    fn next(&mut self) -> Option<Self::Item> {
        let is_empty_text = |x| = match x {
            Event::Text(t) if t.is_empty() => true,
            _ => false
        };

        while is_empty_text(self.parser.peek()) {
            self.parser.next();
        };

        match self.parser.peek()? {
            (Event::Text(_), range) => {
                let start = range.start;
                let mut end = range.end;
                while let Some((Event::Text(_), _)) = self.parser.peek() {
                    end = self.parser.next().unwrap().1.end;
                }

                Some((Event::Text(self.source[start..end].into()), start..end))

            },
            _ => self.parser.next()
        }
    }
}