organic/src/parser/entity.rs

use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::character::complete::satisfy;
use nom::combinator::eof;
use nom::combinator::map;
use nom::combinator::peek;
use nom::combinator::recognize;
use nom::combinator::verify;
use nom::sequence::tuple;

use super::org_source::OrgSource;
use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
use crate::context::EntityDefinition;
use crate::context::RefContext;
use crate::error::CustomError;
use crate::error::MyError;
use crate::error::Res;
use crate::parser::util::get_consumed;
use crate::types::Entity;

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub(crate) fn entity<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Entity<'s>> {
    let (remaining, _) = tag("\\")(input)?;
    let (remaining, (entity_definition, entity_name, use_brackets)) = name(context, remaining)?;

    let (remaining, _trailing_whitespace) =
        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;

    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        Entity {
            source: source.into(),
            name: entity_name.into(),
            latex_math_mode: entity_definition.latex_math_mode,
            latex: entity_definition.latex,
            html: entity_definition.html,
            ascii: entity_definition.ascii,
            utf8: entity_definition.utf8,
            use_brackets,
        },
    ))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn name<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, (&'g EntityDefinition<'s>, OrgSource<'s>, bool)> {
    for entity in context.get_global_settings().entities {
        let result = tuple((
            tag::<_, _, CustomError<_>>(entity.name),
            alt((
                verify(map(tag("{}"), |_| true), |_| !entity.name.ends_with(" ")),
                map(peek(recognize(entity_end)), |_| false),
            )),
        ))(input);
        match result {
            Ok((remaining, (ent, use_brackets))) => {
                return Ok((remaining, (entity, ent, use_brackets)));
            }
            Err(_) => {}
        }
    }

    Err(nom::Err::Error(CustomError::MyError(MyError(
        "NoEntity".into(),
    ))))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn entity_end<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    let (remaining, _) = alt((eof, recognize(satisfy(|c| !c.is_alphabetic()))))(input)?;

    Ok((remaining, ()))
}