organic/src/parser/element_parser.rs

210 lines
6.7 KiB
Rust
Raw Normal View History

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;
2023-04-21 20:10:56 +00:00
use super::comment::comment;
use super::comment::detect_comment;
use super::diary_sexp::detect_diary_sexp;
2023-04-22 00:22:31 +00:00
use super::diary_sexp::diary_sexp;
2023-04-21 20:10:56 +00:00
use super::drawer::drawer;
use super::dynamic_block::dynamic_block;
use super::fixed_width_area::detect_fixed_width_area;
2023-04-22 02:04:22 +00:00
use super::fixed_width_area::fixed_width_area;
use super::footnote_definition::detect_footnote_definition;
2023-04-21 20:10:56 +00:00
use super::footnote_definition::footnote_definition;
use super::greater_block::greater_block;
2023-04-22 02:23:59 +00:00
use super::horizontal_rule::horizontal_rule;
use super::keyword::affiliated_keyword;
2023-04-22 02:33:10 +00:00
use super::keyword::keyword;
2023-04-22 20:56:36 +00:00
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;
2023-04-21 20:10:56 +00:00
use super::paragraph::paragraph;
use super::plain_list::detect_plain_list;
2023-04-21 20:10:56 +00:00
use super::plain_list::plain_list;
use super::table::detect_table;
2023-09-03 16:23:18 +00:00
use crate::context::parser_with_context;
use crate::context::RefContext;
use crate::error::CustomError;
use crate::error::MyError;
2023-04-21 22:36:01 +00:00
use crate::error::Res;
use crate::parser::macros::ak_element;
2023-10-12 20:52:49 +00:00
use crate::parser::macros::element;
2023-04-21 20:10:56 +00:00
use crate::parser::table::org_mode_table;
2023-09-03 16:23:18 +00:00
use crate::types::Element;
2023-04-21 20:10:56 +00:00
2023-09-11 17:13:28 +00:00
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>> {
2023-09-03 16:23:18 +00:00
move |context, input: OrgSource<'_>| _element(context, input, can_be_paragraph)
}
2023-10-09 23:52:32 +00:00
#[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!(
2023-10-12 20:09:35 +00:00
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
);
2023-10-12 20:46:15 +00:00
ak_element!(
dynamic_block,
&mut affiliated_keywords,
post_affiliated_keywords_input,
context,
input,
Element::DynamicBlock
);
2023-10-12 20:48:50 +00:00
ak_element!(
footnote_definition,
&mut affiliated_keywords,
post_affiliated_keywords_input,
context,
input,
Element::FootnoteDefinition
);
2023-10-12 20:52:49 +00:00
element!(comment, context, input, Element::Comment);
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);
2023-04-22 20:56:36 +00:00
2023-10-12 20:46:15 +00:00
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(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)?
};
2023-10-12 20:46:15 +00:00
if can_be_paragraph {
// Paragraph with affiliated keyword
ak_element!(
paragraph,
&mut affiliated_keywords,
post_affiliated_keywords_input,
context,
input,
Element::Paragraph
);
2023-10-12 20:46:15 +00:00
// 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))
2023-04-21 20:10:56 +00:00
}
2023-09-11 17:13:28 +00:00
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>, ()>
{
2023-09-03 16:23:18 +00:00
move |context, input: OrgSource<'_>| _detect_element(context, input, can_be_paragraph)
}
2023-10-09 23:52:32 +00:00
#[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(),
))));
}