organic/src/parser/element_parser.rs

use nom::branch::alt;
use nom::combinator::map;
use nom::combinator::opt;
use nom::multi::many0;
#[cfg(feature = "tracing")]
use tracing::span;

use super::babel_call::babel_call;
use super::clock::clock;
use super::comment::comment;
use super::comment::detect_comment;
use super::diary_sexp::detect_diary_sexp;
use super::diary_sexp::diary_sexp;
use super::drawer::drawer;
use super::dynamic_block::dynamic_block;
use super::fixed_width_area::detect_fixed_width_area;
use super::fixed_width_area::fixed_width_area;
use super::footnote_definition::detect_footnote_definition;
use super::footnote_definition::footnote_definition;
use super::greater_block::greater_block;
use super::horizontal_rule::horizontal_rule;
use super::keyword::affiliated_keyword;
use super::keyword::keyword;
use super::latex_environment::latex_environment;
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::org_source::OrgSource;
use super::paragraph::paragraph;
use super::plain_list::detect_plain_list;
use super::plain_list::plain_list;
use super::table::detect_table;
use crate::context::parser_with_context;
use crate::context::RefContext;
use crate::error::CustomError;
use crate::error::MyError;
use crate::error::Res;
use crate::parser::macros::ak_element;
use crate::parser::table::org_mode_table;
use crate::types::Element;

pub(crate) const fn element(
    can_be_paragraph: bool,
) -> impl for<'b, 'g, 'r, 's> Fn(
    RefContext<'b, 'g, 'r, 's>,
    OrgSource<'s>,
) -> Res<OrgSource<'s>, Element<'s>> {
    move |context, input: OrgSource<'_>| _element(context, input, can_be_paragraph)
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn _element<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
    can_be_paragraph: bool,
) -> Res<OrgSource<'s>, Element<'s>> {
    let (post_affiliated_keywords_input, affiliated_keywords) = many0(affiliated_keyword)(input)?;

    let mut affiliated_keywords = affiliated_keywords.into_iter();

    ak_element!(
        plain_list,
        &mut affiliated_keywords,
        post_affiliated_keywords_input,
        context,
        input,
        Element::PlainList
    );

    ak_element!(
        greater_block,
        &mut affiliated_keywords,
        post_affiliated_keywords_input,
        context,
        input
    );

    ak_element!(
        dynamic_block,
        &mut affiliated_keywords,
        post_affiliated_keywords_input,
        context,
        input,
        Element::DynamicBlock
    );

    ak_element!(
        footnote_definition,
        &mut affiliated_keywords,
        post_affiliated_keywords_input,
        context,
        input,
        Element::FootnoteDefinition
    );

    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 babel_keyword_matcher = parser_with_context!(babel_call)(context);
    let latex_environment_matcher = parser_with_context!(latex_environment)(context);

    let (remaining, maybe_element) = {
        #[cfg(feature = "tracing")]
        let span = span!(tracing::Level::DEBUG, "Main element block");
        #[cfg(feature = "tracing")]
        let _enter = span.enter();

        opt(alt((
            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(latex_environment_matcher, Element::LatexEnvironment),
            map(babel_keyword_matcher, Element::BabelCall),
            map(keyword_matcher, Element::Keyword),
        )))(input)?
    };

    if can_be_paragraph {
        // Paragraph with affiliated keyword
        ak_element!(
            paragraph,
            &mut affiliated_keywords,
            post_affiliated_keywords_input,
            context,
            input,
            Element::Paragraph
        );

        // Paragraph without affiliated keyword
        ak_element!(
            paragraph,
            std::iter::empty(),
            input,
            context,
            input,
            Element::Paragraph
        );
    }

    if maybe_element.is_none() {
        return Err(nom::Err::Error(CustomError::MyError(MyError(
            "No element.",
        ))));
    }
    let element = maybe_element.expect("The above if-statement ensures this is Some().");

    Ok((remaining, element))
}

pub(crate) const fn detect_element(
    can_be_paragraph: bool,
) -> impl for<'b, 'g, 'r, 's> Fn(RefContext<'b, 'g, 'r, 's>, OrgSource<'s>) -> Res<OrgSource<'s>, ()>
{
    move |context, input: OrgSource<'_>| _detect_element(context, input, can_be_paragraph)
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn _detect_element<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
    can_be_paragraph: bool,
) -> Res<OrgSource<'s>, ()> {
    if alt((
        parser_with_context!(detect_plain_list)(context),
        detect_footnote_definition,
        detect_diary_sexp,
        detect_comment,
        detect_fixed_width_area,
        detect_table,
    ))(input)
    .is_ok()
    {
        return Ok((input, ()));
    }
    if _element(context, input, can_be_paragraph).is_ok() {
        return Ok((input, ()));
    }
    return Err(nom::Err::Error(CustomError::MyError(MyError(
        "No element detected.".into(),
    ))));
}