Convert all functions to using the wrapped input type.

src/parser/table.rs

@@ -12,6 +12,7 @@ use nom::multi::many1;
 use nom::multi::many_till;
 use nom::sequence::tuple;
 
+use super::org_source::OrgSource;
 use super::Context;
 use crate::error::Res;
 use crate::parser::exiting::ExitClass;
@@ -31,7 +32,10 @@ use crate::parser::Table;
 ///
 /// This is not the table.el style.
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_mode_table<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Table<'s>> {
+pub fn org_mode_table<'r, 's>(
+    context: Context<'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Table<'s>> {
     start_of_line(context, input)?;
     peek(tuple((space0, tag("|"))))(input)?;
 
@@ -52,11 +56,20 @@ pub fn org_mode_table<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&
     // TODO: Consume trailing formulas
     let source = get_consumed(input, remaining);
 
-    Ok((remaining, Table { source, children }))
+    Ok((
+        remaining,
+        Table {
+            source: source.into(),
+            children,
+        },
+    ))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn table_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
+fn table_end<'r, 's>(
+    context: Context<'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
     start_of_line(context, input)?;
     recognize(tuple((space0, not(tag("|")))))(input)
 }
@@ -64,8 +77,8 @@ fn table_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_row<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, TableRow<'s>> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, TableRow<'s>> {
     alt((
         parser_with_context!(org_mode_table_row_rule)(context),
         parser_with_context!(org_mode_table_row_regular)(context),
@@ -75,15 +88,15 @@ pub fn org_mode_table_row<'r, 's>(
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_row_rule<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, TableRow<'s>> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, TableRow<'s>> {
     start_of_line(context, input)?;
     let (remaining, _) = tuple((space0, tag("|-"), is_not("\r\n"), line_ending))(input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         TableRow {
-            source,
+            source: source.into(),
             children: Vec::new(),
         },
     ))
@@ -92,22 +105,28 @@ pub fn org_mode_table_row_rule<'r, 's>(
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_row_regular<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, TableRow<'s>> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, TableRow<'s>> {
     start_of_line(context, input)?;
     let (remaining, _) = tuple((space0, tag("|")))(input)?;
     let (remaining, children) =
         many1(parser_with_context!(org_mode_table_cell)(context))(remaining)?;
     let (remaining, _tail) = recognize(tuple((space0, alt((line_ending, eof)))))(remaining)?;
     let source = get_consumed(input, remaining);
-    Ok((remaining, TableRow { source, children }))
+    Ok((
+        remaining,
+        TableRow {
+            source: source.into(),
+            children,
+        },
+    ))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_cell<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, TableCell<'s>> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, TableCell<'s>> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
             class: ExitClass::Beta,
@@ -118,29 +137,37 @@ pub fn org_mode_table_cell<'r, 's>(
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
     let (remaining, (children, _exit_contents)) = verify(
         many_till(table_cell_set_object_matcher, exit_matcher),
-        |(children, exit_contents)| !children.is_empty() || exit_contents.ends_with("|"),
+        |(children, exit_contents)| {
+            !children.is_empty() || Into::<&str>::into(exit_contents).ends_with("|")
+        },
     )(input)?;
 
     let (remaining, _tail) = org_mode_table_cell_end(&parser_context, remaining)?;
 
     let source = get_consumed(input, remaining);
 
-    Ok((remaining, TableCell { source, children }))
+    Ok((
+        remaining,
+        TableCell {
+            source: source.into(),
+            children,
+        },
+    ))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_cell_end<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, &'s str> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
     recognize(tuple((space0, alt((tag("|"), peek(line_ending))))))(input)
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn table_cell_set_object<'r, 's>(
     context: Context<'r, 's>,
-    input: &'s str,
-) -> Res<&'s str, Object<'s>> {
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Object<'s>> {
     not(|i| context.check_exit_matcher(i))(input)?;
 
     parser_with_context!(minimal_set_object)(context)(input)