organic/src/parser/subscript_and_superscript.rs

use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::character::complete::anychar;
use nom::character::complete::one_of;
use nom::combinator::map;
use nom::combinator::not;
use nom::combinator::opt;
use nom::combinator::peek;
use nom::combinator::recognize;
use nom::combinator::verify;
use nom::multi::many_till;

use super::object_parser::standard_set_object;
use super::org_source::BracketDepth;
use super::org_source::OrgSource;
use super::util::exit_matcher_parser;
use super::util::maybe_consume_object_trailing_whitespace_if_not_exiting;
use super::util::preceded_by_whitespace;
use crate::context::parser_with_context;
use crate::context::ContextElement;
use crate::context::ContextMatcher;
use crate::context::ExitClass;
use crate::context::ExitMatcherNode;
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::Object;
use crate::types::Subscript;
use crate::types::Superscript;

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn subscript<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Subscript<'s>> {
    // We check for the underscore first before checking the pre-character as a minor optimization to avoid walking up the context tree to find the document root unnecessarily.
    let (remaining, _) = tag("_")(input)?;
    pre(input)?;
    let (remaining, _body) = script_body(context, remaining)?;
    let (remaining, _trailing_whitespace) =
        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        Subscript {
            source: source.into(),
        },
    ))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
pub fn superscript<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Superscript<'s>> {
    // We check for the circumflex first before checking the pre-character as a minor optimization to avoid walking up the context tree to find the document root unnecessarily.
    let (remaining, _) = tag("^")(input)?;
    pre(input)?;
    let (remaining, _body) = script_body(context, remaining)?;
    let (remaining, _trailing_whitespace) =
        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
    let source = get_consumed(input, remaining);
    Ok((
        remaining,
        Superscript {
            source: source.into(),
        },
    ))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn pre<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    not(preceded_by_whitespace(true))(input)?;
    Ok((input, ()))
}

#[derive(Debug)]
enum ScriptBody<'s> {
    Braceless(&'s str),
    WithBraces(Vec<Object<'s>>),
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn script_body<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ScriptBody<'s>> {
    alt((
        map(parser_with_context!(script_asterisk)(context), |body| {
            ScriptBody::Braceless(body.into())
        }),
        map(parser_with_context!(script_alphanum)(context), |body| {
            ScriptBody::Braceless(body.into())
        }),
        map(parser_with_context!(script_with_braces)(context), |body| {
            ScriptBody::WithBraces(body.into())
        }),
    ))(input)
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn script_asterisk<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
    tag("*")(input)
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn script_alphanum<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
    let (remaining, _sign) = opt(recognize(one_of("+-")))(input)?;
    let (remaining, _script) =
        many_till(script_alphanum_character, end_script_alphanum_character)(remaining)?;
    let source = get_consumed(input, remaining);
    Ok((remaining, source))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn script_alphanum_character<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    recognize(verify(anychar, |c| {
        c.is_alphanumeric() || r#",.\"#.contains(*c)
    }))(input)
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn end_script_alphanum_character<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    let (remaining, final_char) = recognize(verify(anychar, |c| c.is_alphanumeric()))(input)?;
    peek(not(script_alphanum_character))(remaining)?;
    Ok((remaining, final_char))
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn script_with_braces<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
    let (remaining, _) = tag("{")(input)?;
    let exit_with_depth = script_with_braces_end(remaining.get_brace_depth());
    let parser_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
        class: ExitClass::Gamma,
        exit_matcher: &exit_with_depth,
    });
    let parser_context = context.with_additional_node(&parser_context);

    let (remaining, (children, _exit_contents)) = many_till(
        parser_with_context!(standard_set_object)(&parser_context),
        parser_with_context!(exit_matcher_parser)(&parser_context),
    )(remaining)?;

    let (remaining, _) = tag("}")(remaining)?;
    Ok((remaining, children))
}

fn script_with_braces_end(starting_brace_depth: BracketDepth) -> impl ContextMatcher {
    move |context, input: OrgSource<'_>| {
        _script_with_braces_end(context, input, starting_brace_depth)
    }
}

#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
fn _script_with_braces_end<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
    starting_brace_depth: BracketDepth,
) -> Res<OrgSource<'s>, OrgSource<'s>> {
    let current_depth = input.get_brace_depth() - starting_brace_depth;
    if current_depth > 0 {
        // Its impossible for the next character to end the subscript or superscript if we're any amount of braces deep
        return Err(nom::Err::Error(CustomError::MyError(MyError(
            "Not a valid end for subscript or superscript.".into(),
        ))));
    }
    if current_depth < 0 {
        // This shouldn't be possible because if depth is 0 then a closing brace should end the subscript or superscript.
        unreachable!("Exceeded subscript or superscript brace depth.")
    }
    tag("}")(input)
}