organic/src/parser/bullshitium.rs

use nom::bytes::complete::tag_no_case;
use nom::character::complete::space0;
use nom::sequence::tuple;

use super::paragraph::paragraph;
use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
use super::util::org_line_ending;
use super::util::start_of_line;
use super::OrgSource;
use crate::context::RefContext;
use crate::error::Res;
use crate::types::AffiliatedKeywords;
use crate::types::Object;
use crate::types::Paragraph;
use crate::types::PlainText;

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn bullshitium<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Paragraph<'s>> {
    broken_end(context, input)
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn detect_bullshitium<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, ()> {
    bullshitium(context, input)?;
    Ok((input, ()))
}

#[cfg_attr(
    feature = "tracing",
    tracing::instrument(ret, level = "debug", skip(context))
)]
pub(crate) fn broken_end<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
) -> Res<OrgSource<'s>, Paragraph<'s>> {
    start_of_line(input)?;
    let (remaining, _) = space0(input)?;
    let (remaining, _) = tag_no_case(":end:")(remaining)?;
    let (lead_in_remaining, _) = tuple((space0, org_line_ending))(remaining)?;
    if let Ok((remaining, mut paragraph)) =
        paragraph(std::iter::empty(), lead_in_remaining, context, input)
    {
        match paragraph.children.first_mut() {
            Some(Object::PlainText(plain_text)) => {
                plain_text.source = input.get_until_end_of_str(plain_text.source).into();
            }
            Some(obj) => {
                panic!("Unhandled first object type inside bullshitium {:?}", obj);
            }
            None => {
                unreachable!("Paragraph must have children.");
            }
        };
        Ok((remaining, paragraph))
    } else {
        let (remaining, _trailing_ws) =
            maybe_consume_trailing_whitespace_if_not_exiting(context, lead_in_remaining)?;

        Ok((
            remaining,
            Paragraph {
                source: input.get_until(remaining).into(),
                affiliated_keywords: AffiliatedKeywords::default(),
                children: vec![Object::PlainText(PlainText {
                    source: input.get_until(lead_in_remaining).into(),
                })],
            },
        ))
    }
}