222 lines
8.8 KiB
Rust
222 lines
8.8 KiB
Rust
use nom::branch::alt;
|
|
use nom::bytes::complete::tag;
|
|
use nom::bytes::complete::tag_no_case;
|
|
use nom::character::complete::anychar;
|
|
use nom::character::complete::space0;
|
|
use nom::combinator::opt;
|
|
use nom::combinator::recognize;
|
|
use nom::combinator::verify;
|
|
use nom::multi::many1;
|
|
use nom::multi::many_till;
|
|
use nom::multi::separated_list1;
|
|
use nom::sequence::tuple;
|
|
|
|
use super::Context;
|
|
use crate::error::CustomError;
|
|
use crate::error::Res;
|
|
use crate::parser::citation_reference::citation_reference;
|
|
use crate::parser::citation_reference::citation_reference_key;
|
|
use crate::parser::citation_reference::get_bracket_depth;
|
|
use crate::parser::exiting::ExitClass;
|
|
use crate::parser::object::Citation;
|
|
use crate::parser::object_parser::standard_set_object;
|
|
use crate::parser::parser_context::CitationBracket;
|
|
use crate::parser::parser_context::ContextElement;
|
|
use crate::parser::parser_context::ExitMatcherNode;
|
|
use crate::parser::parser_with_context::parser_with_context;
|
|
use crate::parser::util::exit_matcher_parser;
|
|
use crate::parser::util::get_consumed;
|
|
use crate::parser::Object;
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
pub fn citation<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Citation<'s>> {
|
|
// TODO: Despite being a standard object, citations cannot exist inside the global prefix/suffix for other citations because citations must contain something that matches @key which is forbidden inside the global prefix/suffix. This TODO is to evaluate if its worth putting in an explicit check for this (which can be easily accomplished by checking the output of `get_bracket_depth()`). I suspect its not worth it because I expect, outside of intentionally crafted inputs, this parser will exit immediately inside a citation since it is unlikely to find the "[cite" substring inside a citation global prefix/suffix.
|
|
let (remaining, _) = tag_no_case("[cite")(input)?;
|
|
let (remaining, _) = opt(citestyle)(remaining)?;
|
|
let (remaining, _) = tag(":")(remaining)?;
|
|
let (remaining, _prefix) = opt(parser_with_context!(global_prefix)(context))(remaining)?;
|
|
let (remaining, _references) =
|
|
separated_list1(tag(";"), parser_with_context!(citation_reference)(context))(remaining)?;
|
|
let (remaining, _suffix) = opt(tuple((
|
|
tag(";"),
|
|
parser_with_context!(global_suffix)(context),
|
|
)))(remaining)?;
|
|
let (remaining, _) = tag("]")(remaining)?;
|
|
let (remaining, _) = space0(remaining)?;
|
|
let source = get_consumed(input, remaining);
|
|
Ok((remaining, Citation { source }))
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn citestyle<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
|
|
let (remaining, _) = tuple((tag("/"), style))(input)?;
|
|
let (remaining, _) = opt(tuple((tag("/"), variant)))(remaining)?;
|
|
let source = get_consumed(input, remaining);
|
|
Ok((remaining, source))
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn style<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
|
|
recognize(many1(verify(anychar, |c| {
|
|
c.is_alphanumeric() || "_-".contains(*c)
|
|
})))(input)
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn variant<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
|
|
recognize(many1(verify(anychar, |c| {
|
|
c.is_alphanumeric() || "_-/".contains(*c)
|
|
})))(input)
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn global_prefix<'r, 's>(
|
|
context: Context<'r, 's>,
|
|
input: &'s str,
|
|
) -> Res<&'s str, Vec<Object<'s>>> {
|
|
// TODO: I could insert CitationBracket entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
|
|
let parser_context = context
|
|
.with_additional_node(ContextElement::CitationBracket(CitationBracket {
|
|
position: input,
|
|
depth: 0,
|
|
}))
|
|
.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
|
|
class: ExitClass::Beta,
|
|
exit_matcher: &global_prefix_end,
|
|
}));
|
|
let (remaining, (children, _exit_contents)) = verify(
|
|
many_till(
|
|
parser_with_context!(standard_set_object)(&parser_context),
|
|
parser_with_context!(exit_matcher_parser)(&parser_context),
|
|
),
|
|
|(children, _exit_contents)| !children.is_empty(),
|
|
)(input)?;
|
|
let (remaining, _) = tag(";")(remaining)?;
|
|
Ok((remaining, children))
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn global_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
|
|
let context_depth = get_bracket_depth(context)
|
|
.expect("This function should only be called from inside a citation.");
|
|
let text_since_context_entry = get_consumed(context_depth.position, input);
|
|
let mut current_depth = context_depth.depth;
|
|
for c in text_since_context_entry.chars() {
|
|
match c {
|
|
'[' => {
|
|
current_depth += 1;
|
|
}
|
|
']' if current_depth == 0 => {
|
|
panic!("Exceeded citation global prefix bracket depth.")
|
|
}
|
|
']' if current_depth > 0 => {
|
|
current_depth -= 1;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
if current_depth == 0 {
|
|
let close_bracket = tag::<&str, &str, CustomError<&str>>("]")(input);
|
|
if close_bracket.is_ok() {
|
|
return close_bracket;
|
|
}
|
|
}
|
|
alt((
|
|
tag(";"),
|
|
recognize(parser_with_context!(citation_reference_key)(context)),
|
|
))(input)
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn global_suffix<'r, 's>(
|
|
context: Context<'r, 's>,
|
|
input: &'s str,
|
|
) -> Res<&'s str, Vec<Object<'s>>> {
|
|
// TODO: I could insert CitationBracket entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
|
|
let parser_context = context
|
|
.with_additional_node(ContextElement::CitationBracket(CitationBracket {
|
|
position: input,
|
|
depth: 0,
|
|
}))
|
|
.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
|
|
class: ExitClass::Beta,
|
|
exit_matcher: &global_suffix_end,
|
|
}));
|
|
let (remaining, (children, _exit_contents)) = verify(
|
|
many_till(
|
|
parser_with_context!(standard_set_object)(&parser_context),
|
|
parser_with_context!(exit_matcher_parser)(&parser_context),
|
|
),
|
|
|(children, _exit_contents)| !children.is_empty(),
|
|
)(input)?;
|
|
Ok((remaining, children))
|
|
}
|
|
|
|
#[tracing::instrument(ret, level = "debug")]
|
|
fn global_suffix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
|
|
let context_depth = get_bracket_depth(context)
|
|
.expect("This function should only be called from inside a citation.");
|
|
let text_since_context_entry = get_consumed(context_depth.position, input);
|
|
let mut current_depth = context_depth.depth;
|
|
for c in text_since_context_entry.chars() {
|
|
match c {
|
|
'[' => {
|
|
current_depth += 1;
|
|
}
|
|
']' if current_depth == 0 => {
|
|
panic!("Exceeded citation global suffix bracket depth.")
|
|
}
|
|
']' if current_depth > 0 => {
|
|
current_depth -= 1;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
if current_depth == 0 {
|
|
let close_bracket = tag::<&str, &str, CustomError<&str>>("]")(input);
|
|
if close_bracket.is_ok() {
|
|
return close_bracket;
|
|
}
|
|
}
|
|
alt((
|
|
tag(";"),
|
|
recognize(parser_with_context!(citation_reference_key)(context)),
|
|
))(input)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::parser::element_parser::element;
|
|
use crate::parser::parser_context::ContextElement;
|
|
use crate::parser::parser_context::ContextTree;
|
|
use crate::parser::parser_with_context::parser_with_context;
|
|
use crate::parser::source::Source;
|
|
|
|
#[test]
|
|
fn citation_simple() {
|
|
let input = "[cite:@foo]";
|
|
let initial_context: ContextTree<'_, '_> = ContextTree::new();
|
|
let document_context =
|
|
initial_context.with_additional_node(ContextElement::DocumentRoot(input));
|
|
let paragraph_matcher = parser_with_context!(element(true))(&document_context);
|
|
let (remaining, first_paragraph) = paragraph_matcher(input).expect("Parse first paragraph");
|
|
let first_paragraph = match first_paragraph {
|
|
crate::parser::Element::Paragraph(paragraph) => paragraph,
|
|
_ => panic!("Should be a paragraph!"),
|
|
};
|
|
assert_eq!(remaining, "");
|
|
assert_eq!(first_paragraph.get_source(), "[cite:@foo]");
|
|
assert_eq!(first_paragraph.children.len(), 1);
|
|
assert_eq!(
|
|
first_paragraph
|
|
.children
|
|
.get(0)
|
|
.expect("Len already asserted to be 1"),
|
|
&Object::Citation(Citation {
|
|
source: "[cite:@foo]"
|
|
})
|
|
);
|
|
}
|
|
}
|