317 lines
11 KiB
Rust
317 lines
11 KiB
Rust
use nom::branch::alt;
|
|
use nom::bytes::complete::is_a;
|
|
use nom::bytes::complete::tag;
|
|
use nom::character::complete::anychar;
|
|
use nom::character::complete::space0;
|
|
use nom::character::complete::space1;
|
|
use nom::combinator::consumed;
|
|
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::many0;
|
|
use nom::multi::many1;
|
|
use nom::multi::separated_list1;
|
|
use nom::sequence::tuple;
|
|
|
|
use super::org_source::OrgSource;
|
|
use super::section::section;
|
|
use super::util::get_consumed;
|
|
use super::util::org_line_ending;
|
|
use super::util::org_space;
|
|
use super::util::org_space_or_line_ending;
|
|
use super::util::start_of_line;
|
|
use crate::context::parser_with_context;
|
|
use crate::context::ContextElement;
|
|
use crate::context::ExitClass;
|
|
use crate::context::ExitMatcherNode;
|
|
use crate::context::RefContext;
|
|
use crate::error::CustomError;
|
|
use crate::error::Res;
|
|
use crate::parser::object_parser::standard_set_object;
|
|
use crate::parser::util::blank_line;
|
|
use crate::types::DocumentElement;
|
|
use crate::types::Element;
|
|
use crate::types::Heading;
|
|
use crate::types::HeadlineLevel;
|
|
use crate::types::Object;
|
|
use crate::types::PriorityCookie;
|
|
use crate::types::TodoKeywordType;
|
|
|
|
pub(crate) const fn heading(
|
|
parent_level: HeadlineLevel,
|
|
) -> impl for<'b, 'g, 'r, 's> Fn(
|
|
RefContext<'b, 'g, 'r, 's>,
|
|
OrgSource<'s>,
|
|
) -> Res<OrgSource<'s>, Heading<'s>> {
|
|
move |context, input: OrgSource<'_>| _heading(context, input, parent_level)
|
|
}
|
|
|
|
#[cfg_attr(
|
|
feature = "tracing",
|
|
tracing::instrument(ret, level = "debug", skip(context))
|
|
)]
|
|
fn _heading<'b, 'g, 'r, 's>(
|
|
context: RefContext<'b, 'g, 'r, 's>,
|
|
input: OrgSource<'s>,
|
|
parent_star_count: HeadlineLevel,
|
|
) -> Res<OrgSource<'s>, Heading<'s>> {
|
|
let mut scheduled = None;
|
|
let mut deadline = None;
|
|
let mut closed = None;
|
|
not(|i| context.check_exit_matcher(i))(input)?;
|
|
let (remaining, pre_headline) = headline(context, input, parent_star_count)?;
|
|
let section_matcher = parser_with_context!(section)(context);
|
|
let heading_matcher = parser_with_context!(heading(pre_headline.star_count))(context);
|
|
let (remaining, maybe_section) =
|
|
opt(map(section_matcher, DocumentElement::Section))(remaining)?;
|
|
let (remaining, _ws) = opt(tuple((start_of_line, many0(blank_line))))(remaining)?;
|
|
let (remaining, mut children) =
|
|
many0(map(heading_matcher, DocumentElement::Heading))(remaining)?;
|
|
if let Some(section) = maybe_section {
|
|
// If the section has a planning then the timestamp values are copied to the heading.
|
|
if let DocumentElement::Section(inner_section) = §ion {
|
|
if let Some(Element::Planning(planning)) = inner_section.children.first() {
|
|
scheduled = planning.scheduled.clone();
|
|
deadline = planning.deadline.clone();
|
|
closed = planning.closed.clone();
|
|
}
|
|
}
|
|
children.insert(0, section);
|
|
}
|
|
let remaining = if children.is_empty() {
|
|
// Support empty headings
|
|
let (remain, _ws) = many0(blank_line)(remaining)?;
|
|
remain
|
|
} else {
|
|
remaining
|
|
};
|
|
let is_archived = pre_headline.tags.contains(&"ARCHIVE");
|
|
|
|
let source = get_consumed(input, remaining);
|
|
Ok((
|
|
remaining,
|
|
Heading {
|
|
source: source.into(),
|
|
level: pre_headline.headline_level,
|
|
todo_keyword: pre_headline
|
|
.todo_keyword
|
|
.map(|(todo_keyword_type, todo_keyword)| {
|
|
(todo_keyword_type, Into::<&str>::into(todo_keyword))
|
|
}),
|
|
priority_cookie: pre_headline.priority_cookie.map(|(_, priority)| priority),
|
|
title: pre_headline.title,
|
|
tags: pre_headline.tags,
|
|
children,
|
|
is_comment: pre_headline.comment.is_some(),
|
|
is_archived,
|
|
is_footnote_section: pre_headline.is_footnote_section,
|
|
scheduled,
|
|
deadline,
|
|
closed,
|
|
},
|
|
))
|
|
}
|
|
|
|
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
|
|
pub(crate) fn detect_headline<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
|
|
tuple((start_of_line, many1(tag("*")), space1))(input)?;
|
|
Ok((input, ()))
|
|
}
|
|
|
|
/// Fields from a not-yet-fully-parsed Headline.
|
|
///
|
|
/// This struct exists to give names to the fields of a partially-parsed Headline to avoid returning a large tuple of nameless fields.
|
|
#[derive(Debug)]
|
|
struct PreHeadline<'s> {
|
|
headline_level: HeadlineLevel,
|
|
star_count: HeadlineLevel,
|
|
todo_keyword: Option<(TodoKeywordType, OrgSource<'s>)>,
|
|
priority_cookie: Option<(OrgSource<'s>, PriorityCookie)>,
|
|
comment: Option<OrgSource<'s>>,
|
|
title: Vec<Object<'s>>,
|
|
tags: Vec<&'s str>,
|
|
is_footnote_section: bool,
|
|
}
|
|
|
|
#[cfg_attr(
|
|
feature = "tracing",
|
|
tracing::instrument(ret, level = "debug", skip(context))
|
|
)]
|
|
fn headline<'b, 'g, 'r, 's>(
|
|
context: RefContext<'b, 'g, 'r, 's>,
|
|
input: OrgSource<'s>,
|
|
parent_star_count: HeadlineLevel,
|
|
) -> Res<OrgSource<'s>, PreHeadline<'s>> {
|
|
let parser_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
|
|
class: ExitClass::Document,
|
|
exit_matcher: &headline_title_end,
|
|
});
|
|
let parser_context = context.with_additional_node(&parser_context);
|
|
|
|
let (remaining, (_, (headline_level, star_count, _), _)) = tuple((
|
|
start_of_line,
|
|
verify(
|
|
parser_with_context!(headline_level)(&parser_context),
|
|
|(_, count, _)| *count > parent_star_count,
|
|
),
|
|
peek(org_space),
|
|
))(input)?;
|
|
|
|
let (remaining, maybe_todo_keyword) = opt(tuple((
|
|
space1,
|
|
parser_with_context!(heading_keyword)(&parser_context),
|
|
peek(org_space_or_line_ending),
|
|
)))(remaining)?;
|
|
|
|
let (remaining, maybe_priority) = opt(tuple((space1, priority_cookie)))(remaining)?;
|
|
|
|
let (remaining, maybe_comment) = opt(tuple((
|
|
space1,
|
|
tag("COMMENT"),
|
|
peek(org_space_or_line_ending),
|
|
)))(remaining)?;
|
|
|
|
let (remaining, maybe_title) = opt(tuple((
|
|
space1,
|
|
consumed(many1(parser_with_context!(standard_set_object)(
|
|
&parser_context,
|
|
))),
|
|
)))(remaining)?;
|
|
|
|
let (remaining, maybe_tags) = opt(tuple((space0, tags)))(remaining)?;
|
|
|
|
let (remaining, _) = tuple((space0, org_line_ending))(remaining)?;
|
|
|
|
let is_footnote_section = maybe_title
|
|
.as_ref()
|
|
.map(|(_, (raw_title, _))| raw_title)
|
|
.map(|raw_title| {
|
|
Into::<&str>::into(raw_title) == context.get_global_settings().footnote_section
|
|
})
|
|
.unwrap_or(false);
|
|
|
|
Ok((
|
|
remaining,
|
|
PreHeadline {
|
|
headline_level,
|
|
star_count,
|
|
todo_keyword: maybe_todo_keyword.map(|(_, todo, _)| todo),
|
|
priority_cookie: maybe_priority,
|
|
comment: maybe_comment.map(|(_, comment, _)| comment),
|
|
title: maybe_title
|
|
.map(|(_, (_, title))| title)
|
|
.unwrap_or(Vec::new()),
|
|
tags: maybe_tags
|
|
.map(|(_ws, tags)| tags.into_iter().map(Into::<&str>::into).collect())
|
|
.unwrap_or(Vec::new()),
|
|
is_footnote_section,
|
|
},
|
|
))
|
|
}
|
|
|
|
#[cfg_attr(
|
|
feature = "tracing",
|
|
tracing::instrument(ret, level = "debug", skip(_context))
|
|
)]
|
|
fn headline_title_end<'b, 'g, 'r, 's>(
|
|
_context: RefContext<'b, 'g, 'r, 's>,
|
|
input: OrgSource<'s>,
|
|
) -> Res<OrgSource<'s>, OrgSource<'s>> {
|
|
recognize(tuple((space0, opt(tuple((tags, space0))), org_line_ending)))(input)
|
|
}
|
|
|
|
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
|
|
fn tags<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Vec<OrgSource<'s>>> {
|
|
let (remaining, (_open, tags, _close)) =
|
|
tuple((tag(":"), separated_list1(tag(":"), single_tag), tag(":")))(input)?;
|
|
Ok((remaining, tags))
|
|
}
|
|
|
|
#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
|
|
fn single_tag<'r, 's>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
|
|
recognize(many1(verify(anychar, |c| {
|
|
c.is_alphanumeric() || "_@#%".contains(*c)
|
|
})))(input)
|
|
}
|
|
|
|
#[cfg_attr(
|
|
feature = "tracing",
|
|
tracing::instrument(ret, level = "debug", skip(context))
|
|
)]
|
|
fn heading_keyword<'b, 'g, 'r, 's>(
|
|
context: RefContext<'b, 'g, 'r, 's>,
|
|
input: OrgSource<'s>,
|
|
) -> Res<OrgSource<'s>, (TodoKeywordType, OrgSource<'s>)> {
|
|
let global_settings = context.get_global_settings();
|
|
if global_settings.in_progress_todo_keywords.is_empty()
|
|
&& global_settings.complete_todo_keywords.is_empty()
|
|
{
|
|
alt((
|
|
map(tag("TODO"), |capture| (TodoKeywordType::Todo, capture)),
|
|
map(tag("DONE"), |capture| (TodoKeywordType::Done, capture)),
|
|
))(input)
|
|
} else {
|
|
for todo_keyword in global_settings
|
|
.in_progress_todo_keywords
|
|
.iter()
|
|
.map(String::as_str)
|
|
{
|
|
let result = tag::<_, _, CustomError>(todo_keyword)(input);
|
|
if let Ok((remaining, ent)) = result {
|
|
return Ok((remaining, (TodoKeywordType::Todo, ent)));
|
|
}
|
|
}
|
|
for todo_keyword in global_settings
|
|
.complete_todo_keywords
|
|
.iter()
|
|
.map(String::as_str)
|
|
{
|
|
let result = tag::<_, _, CustomError>(todo_keyword)(input);
|
|
if let Ok((remaining, ent)) = result {
|
|
return Ok((remaining, (TodoKeywordType::Done, ent)));
|
|
}
|
|
}
|
|
Err(nom::Err::Error(CustomError::Static("NoTodoKeyword")))
|
|
}
|
|
}
|
|
|
|
fn priority_cookie(input: OrgSource<'_>) -> Res<OrgSource<'_>, PriorityCookie> {
|
|
let (remaining, (_, priority_character, _)) = tuple((
|
|
tag("[#"),
|
|
verify(anychar, |c| c.is_alphanumeric()),
|
|
tag("]"),
|
|
))(input)?;
|
|
let cookie = PriorityCookie::try_from(priority_character).map_err(|_| {
|
|
nom::Err::Error(CustomError::Static(
|
|
"Failed to cast priority cookie to number.",
|
|
))
|
|
})?;
|
|
Ok((remaining, cookie))
|
|
}
|
|
|
|
#[cfg_attr(
|
|
feature = "tracing",
|
|
tracing::instrument(ret, level = "debug", skip(context))
|
|
)]
|
|
fn headline_level<'b, 'g, 'r, 's>(
|
|
context: RefContext<'b, 'g, 'r, 's>,
|
|
input: OrgSource<'s>,
|
|
) -> Res<OrgSource<'s>, (HeadlineLevel, HeadlineLevel, OrgSource<'s>)> {
|
|
let (remaining, stars) = is_a("*")(input)?;
|
|
let count = stars.len().try_into().unwrap();
|
|
let level = match context.get_global_settings().odd_levels_only {
|
|
crate::context::HeadlineLevelFilter::Odd => {
|
|
if count % 2 == 0 {
|
|
(count + 2) / 2
|
|
} else {
|
|
(count + 1) / 2
|
|
}
|
|
}
|
|
crate::context::HeadlineLevelFilter::OddEven => count,
|
|
};
|
|
Ok((remaining, (level, count, stars)))
|
|
}
|