organic/src/parser/element_parser.rs

use super::clock::clock;
use super::comment::comment;
use super::diary_sexp::diary_sexp;
use super::drawer::drawer;
use super::dynamic_block::dynamic_block;
use super::element::Element;
use super::fixed_width_area::fixed_width_area;
use super::footnote_definition::footnote_definition;
use super::greater_block::greater_block;
use super::horizontal_rule::horizontal_rule;
use super::keyword::keyword;
use super::lesser_block::comment_block;
use super::lesser_block::example_block;
use super::lesser_block::export_block;
use super::lesser_block::src_block;
use super::lesser_block::verse_block;
use super::paragraph::paragraph;
use super::plain_list::plain_list;
use super::source::SetSource;
use super::util::get_consumed;
use super::util::maybe_consume_trailing_whitespace_if_not_exiting;

use super::Context;
use crate::error::Res;
use crate::parser::parser_with_context::parser_with_context;
use crate::parser::table::org_mode_table;
use nom::branch::alt;
use nom::combinator::map;
use nom::combinator::verify;
use nom::multi::many0;

pub fn element(
    can_be_paragraph: bool,
) -> impl for<'r, 's> Fn(Context<'r, 's>, &'s str) -> Res<&'s str, Element<'s>> {
    move |context: Context, input: &str| {
        let plain_list_matcher = parser_with_context!(plain_list)(context);
        let greater_block_matcher = parser_with_context!(greater_block)(context);
        let dynamic_block_matcher = parser_with_context!(dynamic_block)(context);
        let footnote_definition_matcher = parser_with_context!(footnote_definition)(context);
        let comment_matcher = parser_with_context!(comment)(context);
        let drawer_matcher = parser_with_context!(drawer)(context);
        let table_matcher = parser_with_context!(org_mode_table)(context);
        let verse_block_matcher = parser_with_context!(verse_block)(context);
        let comment_block_matcher = parser_with_context!(comment_block)(context);
        let example_block_matcher = parser_with_context!(example_block)(context);
        let export_block_matcher = parser_with_context!(export_block)(context);
        let src_block_matcher = parser_with_context!(src_block)(context);
        let clock_matcher = parser_with_context!(clock)(context);
        let diary_sexp_matcher = parser_with_context!(diary_sexp)(context);
        let fixed_width_area_matcher = parser_with_context!(fixed_width_area)(context);
        let horizontal_rule_matcher = parser_with_context!(horizontal_rule)(context);
        let keyword_matcher = parser_with_context!(keyword)(context);
        let paragraph_matcher = parser_with_context!(paragraph)(context);
        let (remaining, mut affiliated_keywords) = many0(keyword_matcher)(input)?;
        let (remaining, mut element) = match alt((
            map(plain_list_matcher, Element::PlainList),
            map(greater_block_matcher, Element::GreaterBlock),
            map(dynamic_block_matcher, Element::DynamicBlock),
            map(footnote_definition_matcher, Element::FootnoteDefinition),
            map(comment_matcher, Element::Comment),
            map(drawer_matcher, Element::Drawer),
            map(table_matcher, Element::Table),
            map(verse_block_matcher, Element::VerseBlock),
            map(comment_block_matcher, Element::CommentBlock),
            map(example_block_matcher, Element::ExampleBlock),
            map(export_block_matcher, Element::ExportBlock),
            map(src_block_matcher, Element::SrcBlock),
            map(clock_matcher, Element::Clock),
            map(diary_sexp_matcher, Element::DiarySexp),
            map(fixed_width_area_matcher, Element::FixedWidthArea),
            map(horizontal_rule_matcher, Element::HorizontalRule),
            map(
                verify(paragraph_matcher, |_p| can_be_paragraph),
                Element::Paragraph,
            ),
        ))(remaining)
        {
            the_ok @ Ok(_) => the_ok,
            Err(_) => {
                affiliated_keywords.clear();
                map(keyword_matcher, Element::Keyword)(input)
            }
        }?;

        let (remaining, _trailing_ws) =
            maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;

        let source = get_consumed(input, remaining);
        element.set_source(source);

        Ok((remaining, element))
    }
}