Convert all functions to using the wrapped input type.

src/parser/citation_reference.rs

@@ -10,6 +10,7 @@ use nom::multi::many_till;
 use nom::sequence::preceded;
 use nom::sequence::tuple;
 
+use super::org_source::OrgSource;
 use super::Context;
 use crate::error::CustomError;
 use crate::error::Res;
@@ -28,21 +29,26 @@ use crate::parser::Object;
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn citation_reference<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, CitationReference<'s>> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, CitationReference<'s>> {
     let (remaining, _prefix) = opt(parser_with_context!(key_prefix)(context))(input)?;
     let (remaining, _key) = parser_with_context!(citation_reference_key)(context)(remaining)?;
     let (remaining, _suffix) = opt(parser_with_context!(key_suffix)(context))(remaining)?;
     let source = get_consumed(input, remaining);
 
-    Ok((remaining, CitationReference { source }))
+    Ok((
+        remaining,
+        CitationReference {
+            source: source.into(),
+        },
+    ))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn citation_reference_key<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, &'s str> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
     let (remaining, source) = recognize(tuple((
         tag("@"),
         many1(verify(
@@ -59,7 +65,10 @@ pub fn citation_reference_key<'r, 's>(
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn key_prefix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Vec<Object<'s>>> {
+fn key_prefix<'r, 's>(
+    context: Context<'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, 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 {
@@ -81,7 +90,10 @@ fn key_prefix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn key_suffix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Vec<Object<'s>>> {
+fn key_suffix<'r, 's>(
+    context: Context<'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, 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 {
@@ -114,12 +126,15 @@ pub fn get_bracket_depth<'r, 's>(context: Context<'r, 's>) -> Option<&'r Citatio
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn key_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
+fn key_prefix_end<'r, 's>(
+    context: Context<'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside a citation reference.");
     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() {
+    for c in Into::<&str>::into(text_since_context_entry).chars() {
         match c {
             '[' => {
                 current_depth += 1;
@@ -134,7 +149,7 @@ fn key_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
         }
     }
     if current_depth == 0 {
-        let close_bracket = tag::<&str, &str, CustomError<&str>>("]")(input);
+        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }
@@ -146,12 +161,15 @@ fn key_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn key_suffix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
+fn key_suffix_end<'r, 's>(
+    context: Context<'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside a citation reference.");
     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() {
+    for c in Into::<&str>::into(text_since_context_entry).chars() {
         match c {
             '[' => {
                 current_depth += 1;
@@ -166,7 +184,7 @@ fn key_suffix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
         }
     }
     if current_depth == 0 {
-        let close_bracket = tag::<&str, &str, CustomError<&str>>("]")(input);
+        let close_bracket = tag::<&str, OrgSource<'_>, CustomError<OrgSource<'_>>>("]")(input);
         if close_bracket.is_ok() {
             return close_bracket;
         }