Initial implementation for citations.

This implementation definitely has bugs and is completely untested at this point. I'm just committing the initial "assume everything works" version before I did into debugging and fixing.

src/parser/citation.rs

@@ -1,10 +1,178 @@
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::bytes::complete::tag_no_case;
+use nom::character::complete::anychar;
+use nom::combinator::opt;
+use nom::combinator::recognize;
+use nom::combinator::verify;
+use nom::multi::many0;
+use nom::multi::many1;
+use nom::multi::many_till;
+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::util::not_yet_implemented;
+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>> {
-    not_yet_implemented()?;
-    todo!()
+    let (remaining, _) = tag_no_case("[cite")(input)?;
+    let (remaining, _) = opt(citestyle)(remaining)?;
+    let (remaining, _) = tag(":")(remaining)?;
+    let (remaining, _prefix) = parser_with_context!(global_prefix)(context)(remaining)?;
+    let (remaining, _references) =
+        many0(parser_with_context!(citation_reference)(context))(remaining)?;
+    let (remaining, _suffix) = parser_with_context!(global_suffix)(context)(remaining)?;
+    let (remaining, _) = tag("]")(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)?;
+    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)
 }

src/parser/citation_reference.rs

@@ -30,7 +30,7 @@ pub fn citation_reference<'r, 's>(
     input: &'s str,
 ) -> Res<&'s str, CitationReference<'s>> {
     let (remaining, _prefix) = parser_with_context!(key_prefix)(context)(input)?;
-    let (remaining, _key) = parser_with_context!(key)(context)(remaining)?;
+    let (remaining, _key) = parser_with_context!(citation_reference_key)(context)(remaining)?;
     let (remaining, _suffix) = parser_with_context!(key_suffix)(context)(remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -38,7 +38,10 @@ pub fn citation_reference<'r, 's>(
 }
 
 #[tracing::instrument(ret, level = "debug")]
-fn key<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
+pub fn citation_reference_key<'r, 's>(
+    context: Context<'r, 's>,
+    input: &'s str,
+) -> Res<&'s str, &'s str> {
     let (remaining, source) = recognize(tuple((
         tag("@"),
         many1(verify(
@@ -99,7 +102,7 @@ fn key_suffix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
 }
 
 #[tracing::instrument(ret, level = "debug")]
-fn get_bracket_depth<'r, 's>(context: Context<'r, 's>) -> Option<&'r CitationBracket<'s>> {
+pub fn get_bracket_depth<'r, 's>(context: Context<'r, 's>) -> Option<&'r CitationBracket<'s>> {
     for node in context.iter() {
         match node.get_data() {
             ContextElement::CitationBracket(depth) => return Some(depth),
@@ -135,7 +138,10 @@ fn key_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
             return close_bracket;
         }
     }
-    alt((tag(";"), recognize(parser_with_context!(key)(context))))(input)
+    alt((
+        tag(";"),
+        recognize(parser_with_context!(citation_reference_key)(context)),
+    ))(input)
 }
 
 #[tracing::instrument(ret, level = "debug")]