organic/src/parser/object_parser.rs

use nom::branch::alt;
use nom::combinator::map;

use super::org_source::OrgSource;
use super::plain_text::plain_text;
use super::regular_link::regular_link;
use super::subscript_and_superscript::detect_subscript_or_superscript;
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::angle_link::angle_link;
use crate::parser::citation::citation;
use crate::parser::entity::entity;
use crate::parser::export_snippet::export_snippet;
use crate::parser::footnote_reference::footnote_reference;
use crate::parser::inline_babel_call::inline_babel_call;
use crate::parser::inline_source_block::inline_source_block;
use crate::parser::latex_fragment::latex_fragment;
use crate::parser::line_break::line_break;
use crate::parser::org_macro::org_macro;
use crate::parser::plain_link::plain_link;
use crate::parser::radio_link::radio_link;
use crate::parser::radio_link::radio_target;
use crate::parser::statistics_cookie::statistics_cookie;
use crate::parser::subscript_and_superscript::subscript;
use crate::parser::subscript_and_superscript::superscript;
use crate::parser::target::target;
use crate::parser::text_markup::text_markup;
use crate::parser::timestamp::timestamp;
use crate::types::Object;

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn standard_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    let (remaining, object) = alt((
        parser_with_context!(standard_set_object_sans_plain_text)(context),
        map(
            parser_with_context!(plain_text(detect_standard_set_object_sans_plain_text))(context),
            Object::PlainText,
        ),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn minimal_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    let (remaining, object) = alt((
        parser_with_context!(minimal_set_object_sans_plain_text)(context),
        map(
            parser_with_context!(plain_text(detect_minimal_set_object_sans_plain_text))(context),
            Object::PlainText,
        ),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    let (remaining, object) = alt((
        map(parser_with_context!(timestamp)(context), Object::Timestamp),
        map(parser_with_context!(subscript)(context), Object::Subscript),
        map(
            parser_with_context!(superscript)(context),
            Object::Superscript,
        ),
        map(
            parser_with_context!(statistics_cookie)(context),
            Object::StatisticsCookie,
        ),
        map(parser_with_context!(target)(context), Object::Target),
        map(parser_with_context!(line_break)(context), Object::LineBreak),
        map(
            parser_with_context!(inline_source_block)(context),
            Object::InlineSourceBlock,
        ),
        map(
            parser_with_context!(inline_babel_call)(context),
            Object::InlineBabelCall,
        ),
        map(parser_with_context!(citation)(context), Object::Citation),
        map(
            parser_with_context!(footnote_reference)(context),
            Object::FootnoteReference,
        ),
        map(
            parser_with_context!(export_snippet)(context),
            Object::ExportSnippet,
        ),
        map(parser_with_context!(entity)(context), Object::Entity),
        map(
            parser_with_context!(latex_fragment)(context),
            Object::LatexFragment,
        ),
        map(parser_with_context!(radio_link)(context), Object::RadioLink),
        map(
            parser_with_context!(radio_target)(context),
            Object::RadioTarget,
        ),
        parser_with_context!(text_markup)(context),
        map(
            parser_with_context!(regular_link)(context),
            Object::RegularLink,
        ),
        map(parser_with_context!(plain_link)(context), Object::PlainLink),
        map(parser_with_context!(angle_link)(context), Object::AngleLink),
        map(parser_with_context!(org_macro)(context), Object::OrgMacro),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    let (remaining, object) = alt((
        map(parser_with_context!(subscript)(context), Object::Subscript),
        map(
            parser_with_context!(superscript)(context),
            Object::Superscript,
        ),
        map(parser_with_context!(entity)(context), Object::Entity),
        map(
            parser_with_context!(latex_fragment)(context),
            Object::LatexFragment,
        ),
        parser_with_context!(text_markup)(context),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
    if detect_subscript_or_superscript(input).is_ok() {
        return Ok((input, ()));
    }
    if standard_set_object_sans_plain_text(context, input).is_ok() {
        return Ok((input, ()));
    }

    return Err(nom::Err::Error(CustomError::MyError(MyError(
        "No object detected.".into(),
    ))));
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
    if detect_subscript_or_superscript(input).is_ok() {
        return Ok((input, ()));
    }
    if minimal_set_object_sans_plain_text(context, input).is_ok() {
        return Ok((input, ()));
    }

    return Err(nom::Err::Error(CustomError::MyError(MyError(
        "No object detected.".into(),
    ))));
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn regular_link_description_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    // TODO: It can also contain another link, but only when it is a plain or angle link. It can contain square brackets, but not ]]
    let (remaining, object) = alt((
        parser_with_context!(regular_link_description_set_object_sans_plain_text)(context),
        map(
            parser_with_context!(plain_text(
                detect_regular_link_description_set_object_sans_plain_text
            ))(context),
            Object::PlainText,
        ),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    // TODO: It can also contain another link, but only when it is a plain or angle link. It can contain square brackets, but not ]]
    let (remaining, object) = alt((
        map(
            parser_with_context!(export_snippet)(context),
            Object::ExportSnippet,
        ),
        map(
            parser_with_context!(statistics_cookie)(context),
            Object::StatisticsCookie,
        ),
        map(
            parser_with_context!(inline_source_block)(context),
            Object::InlineSourceBlock,
        ),
        map(
            parser_with_context!(inline_babel_call)(context),
            Object::InlineBabelCall,
        ),
        map(parser_with_context!(org_macro)(context), Object::OrgMacro),
        parser_with_context!(minimal_set_object_sans_plain_text)(context),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
    if detect_subscript_or_superscript(input).is_ok() {
        return Ok((input, ()));
    }
    if regular_link_description_set_object_sans_plain_text(context, input).is_ok() {
        return Ok((input, ()));
    }

    return Err(nom::Err::Error(CustomError::MyError(MyError(
        "No object detected.".into(),
    ))));
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn table_cell_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    let (remaining, object) = alt((
        parser_with_context!(table_cell_set_object_sans_plain_text)(context),
        map(
            parser_with_context!(plain_text(detect_table_cell_set_object_sans_plain_text))(context),
            Object::PlainText,
        ),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Object<'s>> {
    let (remaining, object) = alt((
        map(parser_with_context!(citation)(context), Object::Citation),
        map(
            parser_with_context!(export_snippet)(context),
            Object::ExportSnippet,
        ),
        map(
            parser_with_context!(footnote_reference)(context),
            Object::FootnoteReference,
        ),
        map(parser_with_context!(radio_link)(context), Object::RadioLink),
        map(
            parser_with_context!(regular_link)(context),
            Object::RegularLink,
        ),
        map(parser_with_context!(plain_link)(context), Object::PlainLink),
        map(parser_with_context!(angle_link)(context), Object::AngleLink),
        map(parser_with_context!(org_macro)(context), Object::OrgMacro),
        map(
            parser_with_context!(radio_target)(context),
            Object::RadioTarget,
        ),
        map(parser_with_context!(target)(context), Object::Target),
        map(parser_with_context!(timestamp)(context), Object::Timestamp),
        parser_with_context!(minimal_set_object_sans_plain_text)(context),
    ))(input)?;
    Ok((remaining, object))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
    if detect_subscript_or_superscript(input).is_ok() {
        return Ok((input, ()));
    }
    if table_cell_set_object_sans_plain_text(context, input).is_ok() {
        return Ok((input, ()));
    }

    return Err(nom::Err::Error(CustomError::MyError(MyError(
        "No object detected.".into(),
    ))));
}