Remove PartialEq from Object.

This is to remove the ambiguity between calling iter on the specific structs like Document and calling iter on an AstNode by having an explicitly-named function to create the iterator.

Makefile

@@ -45,10 +45,6 @@ dockerclippy:
 clippy:
 > cargo clippy --no-deps --all-targets --all-features -- -D warnings
 
-.PHONY: clippyfix
-clippyfix:
-> cargo clippy --fix --lib -p organic --all-features
-
 .PHONY: test
 test:
 > cargo test --no-default-features --features compare --no-fail-fast --lib --test test_loader -- --test-threads $(TESTJOBS)

docker/organic_clippy/Makefile

@@ -25,13 +25,13 @@ ifdef REMOTE_REPO
 else
 	@echo "REMOTE_REPO not defined, not removing from remote repo."
 endif
-	docker volume rm cargo-cache
+	docker volume rm rust-cache cargo-cache
 
 # NOTE: This target will write to folders underneath the git-root
 .PHONY: run
 run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry $(IMAGE_NAME)
+	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)
 
 .PHONY: shell
 shell: build
-	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry $(IMAGE_NAME)
+	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)

org_mode_samples/object/target/simple.org

@@ -1,3 +0,0 @@
-foo <<bar>> baz
-
-lorem << ipsum >> dolar

src/compare/compare_field.rs

@@ -1,3 +1,5 @@
+use std::borrow::Borrow;
+use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::str::FromStr;
@@ -262,11 +264,11 @@ pub(crate) fn compare_property_set_of_quoted_string<
         .iter()
         .map(|e| e.as_atom())
         .collect::<Result<Vec<_>, _>>()?;
-    let value: Vec<String> = value
+    let value: Vec<Cow<'_, str>> = value
         .into_iter()
         .map(unquote)
         .collect::<Result<Vec<_>, _>>()?;
-    let value: BTreeSet<&str> = value.iter().map(|e| e.as_str()).collect();
+    let value: BTreeSet<&str> = value.iter().map(|e| e.borrow()).collect();
     let mismatched: Vec<_> = value.symmetric_difference(&rust_value).copied().collect();
     if !mismatched.is_empty() {
         let this_status = DiffStatus::Bad;
@@ -653,7 +655,7 @@ pub(crate) fn compare_property_number_lines<
         (Some(number_lines), Some(rust_number_lines)) => {
             let token_list = number_lines.as_list()?;
             let number_type = token_list
-                .get(0)
+                .first()
                 .map(Token::as_atom)
                 .map_or(Ok(None), |r| r.map(Some))?
                 .ok_or(":number-lines should have a type.")?;

src/compare/diff.rs

@@ -128,7 +128,7 @@ pub struct DiffResult<'b, 's> {
     emacs_token: &'b Token<'s>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub(crate) enum DiffStatus {
     Good,
     Bad,
@@ -164,7 +164,7 @@ impl<'b, 's> DiffEntry<'b, 's> {
 
     fn is_immediately_bad(&self) -> bool {
         match self {
-            DiffEntry::DiffResult(diff) => diff.status == DiffStatus::Bad,
+            DiffEntry::DiffResult(diff) => matches!(diff.status, DiffStatus::Bad),
             DiffEntry::DiffLayer(_) => false,
         }
     }
@@ -1576,7 +1576,7 @@ fn compare_example_block<'b, 's>(
         [],
         (
             EmacsField::Required(":value"),
-            |r| Some(r.contents.as_str()),
+            |r| Some(&r.contents),
             compare_property_quoted_string
         ),
         (
@@ -1654,7 +1654,7 @@ fn compare_export_block<'b, 's>(
         ),
         (
             EmacsField::Required(":value"),
-            |r| Some(r.contents.as_str()),
+            |r| Some(&r.contents),
             compare_property_quoted_string
         )
     ) {
@@ -1702,7 +1702,7 @@ fn compare_src_block<'b, 's>(
         ),
         (
             EmacsField::Required(":value"),
-            |r| Some(r.contents.as_str()),
+            |r| Some(&r.contents),
             compare_property_quoted_string
         ),
         (
@@ -2153,7 +2153,7 @@ fn compare_plain_text<'b, 's>(
     let text = emacs.as_text()?;
     let start_ind: usize = text
         .properties
-        .get(0)
+        .first()
         .expect("Should have start index.")
         .as_atom()?
         .parse()?;

src/compare/sexp.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::HashMap;
 
 use nom::branch::alt;
@@ -36,12 +37,6 @@ pub struct TextWithProperties<'s> {
     pub(crate) properties: Vec<Token<'s>>,
 }
 
-enum ParseState {
-    Normal,
-    Escape,
-    Octal(Vec<u8>),
-}
-
 impl<'s> Token<'s> {
     pub(crate) fn as_vector<'p>(
         &'p self,
@@ -117,8 +112,27 @@ fn get_consumed<'s>(input: &'s str, remaining: &'s str) -> &'s str {
     &input[..offset]
 }
 
-pub(crate) fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
-    let mut out: Vec<u8> = Vec::with_capacity(text.len());
+#[derive(Debug)]
+enum UnquoteState {
+    Normal,
+    Escape,
+    HasEscape {
+        out: Vec<u8>,
+    },
+    HasEscapeEscape {
+        out: Vec<u8>,
+    },
+    Octal {
+        octal_begin_offset: usize,
+        octal: Vec<u8>,
+    },
+    HasEscapeOctal {
+        out: Vec<u8>,
+        octal: Vec<u8>,
+    },
+}
+
+pub(crate) fn unquote(text: &str) -> Result<Cow<'_, str>, Box<dyn std::error::Error>> {
     if !text.starts_with('"') {
         return Err("Quoted text does not start with quote.".into());
     }
@@ -126,54 +140,143 @@ pub(crate) fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>>
         return Err("Quoted text does not end with quote.".into());
     }
     let interior_text = &text[1..(text.len() - 1)];
-    let mut state = ParseState::Normal;
-    for current_char in interior_text.bytes() {
+    let mut state = UnquoteState::Normal;
+    for (offset, current_char) in interior_text.bytes().enumerate() {
         // Check to see if octal finished
         state = match (state, current_char) {
-            (ParseState::Octal(octal), b'0'..=b'7') if octal.len() < MAX_OCTAL_LENGTH => {
-                ParseState::Octal(octal)
+            (
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    octal,
+                },
+                b'0'..=b'7',
+            ) if octal.len() < MAX_OCTAL_LENGTH => UnquoteState::Octal {
+                octal_begin_offset,
+                octal,
+            },
+            (
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    octal,
+                },
+                _,
+            ) => {
+                let octal_number_string = String::from_utf8(octal)?;
+                let decoded_byte = u8::from_str_radix(&octal_number_string, 8)?;
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                out.extend_from_slice(&interior_text.as_bytes()[..octal_begin_offset]);
+                out.push(decoded_byte);
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Octal(octal), _) => {
+            (UnquoteState::HasEscapeOctal { out, octal }, b'0'..=b'7')
+                if octal.len() < MAX_OCTAL_LENGTH =>
+            {
+                UnquoteState::HasEscapeOctal { out, octal }
+            }
+            (UnquoteState::HasEscapeOctal { mut out, octal }, _) => {
                 let octal_number_string = String::from_utf8(octal)?;
                 let decoded_byte = u8::from_str_radix(&octal_number_string, 8)?;
                 out.push(decoded_byte);
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
             (state, _) => state,
         };
 
         state = match (state, current_char) {
-            (ParseState::Normal, b'\\') => ParseState::Escape,
-            (ParseState::Normal, _) => {
+            (UnquoteState::Normal, b'\\') => UnquoteState::Escape,
+            (UnquoteState::Normal, _) => UnquoteState::Normal,
+            (UnquoteState::HasEscape { out }, b'\\') => UnquoteState::HasEscapeEscape { out },
+            (UnquoteState::HasEscape { mut out }, _) => {
                 out.push(current_char);
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'n') => {
+            (UnquoteState::Escape, b'n') => {
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                // Subtract 1 from offset to account for backslash.
+                out.extend_from_slice(&interior_text.as_bytes()[..(offset - 1)]);
                 out.push(b'\n');
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'\\') => {
+            (UnquoteState::HasEscapeEscape { mut out }, b'n') => {
+                out.push(b'\n');
+                UnquoteState::HasEscape { out }
+            }
+            (UnquoteState::Escape, b'\\') => {
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                // Subtract 1 from offset to account for backslash.
+                out.extend_from_slice(&interior_text.as_bytes()[..(offset - 1)]);
                 out.push(b'\\');
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'"') => {
+            (UnquoteState::HasEscapeEscape { mut out }, b'\\') => {
+                out.push(b'\\');
+                UnquoteState::HasEscape { out }
+            }
+            (UnquoteState::Escape, b'"') => {
+                let mut out: Vec<u8> = Vec::with_capacity(interior_text.len());
+                // Subtract 1 from offset to account for backslash.
+                out.extend_from_slice(&interior_text.as_bytes()[..(offset - 1)]);
                 out.push(b'"');
-                ParseState::Normal
+                UnquoteState::HasEscape { out }
             }
-            (ParseState::Escape, b'0'..=b'7') => {
+            (UnquoteState::HasEscapeEscape { mut out }, b'"') => {
+                out.push(b'"');
+                UnquoteState::HasEscape { out }
+            }
+            (UnquoteState::Escape, b'0'..=b'7') => {
                 let mut octal = Vec::with_capacity(MAX_OCTAL_LENGTH);
                 octal.push(current_char);
-                ParseState::Octal(octal)
+                // Substract 1 from offset to account for backslash
+                UnquoteState::Octal {
+                    octal_begin_offset: offset - 1,
+                    octal,
+                }
             }
-            (ParseState::Octal(mut octal), b'0'..=b'7') => {
+            (UnquoteState::HasEscapeEscape { out }, b'0'..=b'7') => {
+                let mut octal = Vec::with_capacity(MAX_OCTAL_LENGTH);
                 octal.push(current_char);
-                ParseState::Octal(octal)
+                // Substract 1 from offset to account for backslash
+                UnquoteState::HasEscapeOctal { out, octal }
             }
-            _ => panic!("Invalid state unquoting string."),
+            (
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    mut octal,
+                },
+                b'0'..=b'7',
+            ) => {
+                octal.push(current_char);
+                UnquoteState::Octal {
+                    octal_begin_offset,
+                    octal,
+                }
+            }
+            (UnquoteState::HasEscapeOctal { out, mut octal }, b'0'..=b'7') => {
+                octal.push(current_char);
+                UnquoteState::HasEscapeOctal { out, octal }
+            }
+            (state, _) => panic!(
+                "Invalid state unquoting string: {:?} | {} | {:?}",
+                state, offset, interior_text
+            ),
         };
     }
 
-    Ok(String::from_utf8(out)?)
+    match state {
+        UnquoteState::Normal | UnquoteState::Escape | UnquoteState::Octal { .. } => {
+            Ok(Cow::Borrowed(interior_text))
+        }
+        UnquoteState::HasEscape { out } => Ok(Cow::Owned(String::from_utf8(out)?)),
+        UnquoteState::HasEscapeEscape { mut out } => {
+            out.push(b'\\');
+            Ok(Cow::Owned(String::from_utf8(out)?))
+        }
+        UnquoteState::HasEscapeOctal { mut out, octal } => {
+            out.push(b'\\');
+            out.extend(octal);
+            Ok(Cow::Owned(String::from_utf8(out)?))
+        }
+    }
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/compare/util.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::str::FromStr;
 
 use super::compare_field::compare_property_list_of_quoted_string;
@@ -206,10 +207,10 @@ pub(crate) fn get_property_unquoted_atom<'s>(
 /// Get a named property containing an quoted string from the emacs token.
 ///
 /// Returns None if key is not found.
-pub(crate) fn get_property_quoted_string(
-    emacs: &Token<'_>,
+pub(crate) fn get_property_quoted_string<'s>(
+    emacs: &Token<'s>,
     key: &str,
-) -> Result<Option<String>, Box<dyn std::error::Error>> {
+) -> Result<Option<Cow<'s, str>>, Box<dyn std::error::Error>> {
     get_property(emacs, key)?
         .map(Token::as_atom)
         .map_or(Ok(None), |r| r.map(Some))?

src/error/error.rs

@@ -6,8 +6,6 @@ pub(crate) type Res<T, U> = IResult<T, U, CustomError>;
 
 #[derive(Debug)]
 pub enum CustomError {
-    #[allow(dead_code)]
-    Text(String),
     Static(&'static str),
     IO(std::io::Error),
     Parser(ErrorKind),
@@ -35,9 +33,3 @@ impl From<&'static str> for CustomError {
         CustomError::Static(value)
     }
 }
-
-impl From<String> for CustomError {
-    fn from(value: String) -> Self {
-        CustomError::Text(value)
-    }
-}

src/iter/all_ast_node_iter.rs

@@ -90,12 +90,11 @@ impl<'r, 's> Iterator for AllAstNodeIter<'r, 's> {
     }
 }
 
-impl<'r, 's> IntoIterator for AstNode<'r, 's> {
-    type Item = AstNode<'r, 's>;
-
-    type IntoIter = AllAstNodeIter<'r, 's>;
-
-    fn into_iter(self) -> Self::IntoIter {
+impl<'r, 's> AstNode<'r, 's> {
+    /// Iterate all AST nodes.
+    ///
+    /// This is different from the iter/into_iter functions which iterate a single level of the children. This iterates the entire tree including returning the root node itself.
+    pub fn iter_all_ast_nodes(self) -> AllAstNodeIter<'r, 's> {
         AllAstNodeIter {
             root: Some(self),
             queue: VecDeque::new(),

src/parser/babel_call.rs

@@ -225,7 +225,7 @@ fn impl_balanced_bracket<
     let contents_end = remaining;
 
     let (remaining, _) = end_parser(remaining)?;
-    let contents = if contents_start != contents_end {
+    let contents = if Into::<&str>::into(contents_start) != Into::<&str>::into(contents_end) {
         Some(contents_start.get_until(contents_end))
     } else {
         None
@@ -244,7 +244,7 @@ mod tests {
         let input = OrgSource::new("()");
         let (remaining, call) = opt(babel_call_call)(input)?;
         assert_eq!(Into::<&str>::into(remaining), "()");
-        assert_eq!(call, None);
+        assert!(matches!(call, None));
         Ok(())
     }
 }

src/parser/bullshitium.rs

@@ -15,10 +15,8 @@ use crate::context::RefContext;
 use crate::error::CustomError;
 use crate::error::Res;
 use crate::parser::macros::element;
-use crate::types::AffiliatedKeywords;
 use crate::types::Object;
 use crate::types::Paragraph;
-use crate::types::PlainText;
 
 #[cfg_attr(
     feature = "tracing",
@@ -80,13 +78,10 @@ pub(crate) fn broken_end<'b, 'g, 'r, 's>(
 
         Ok((
             remaining,
-            Paragraph {
-                source: input.get_until(remaining).into(),
-                affiliated_keywords: AffiliatedKeywords::default(),
-                children: vec![Object::PlainText(PlainText {
-                    source: input.get_until(lead_in_remaining).into(),
-                })],
-            },
+            Paragraph::of_text(
+                input.get_until(remaining).into(),
+                input.get_until(lead_in_remaining).into(),
+            ),
         ))
     }
 }
@@ -139,13 +134,10 @@ pub(crate) fn broken_dynamic_block<'b, 'g, 'r, 's>(
 
         Ok((
             remaining,
-            Paragraph {
-                source: input.get_until(remaining).into(),
-                affiliated_keywords: AffiliatedKeywords::default(),
-                children: vec![Object::PlainText(PlainText {
-                    source: input.get_until(lead_in_remaining).into(),
-                })],
-            },
+            Paragraph::of_text(
+                input.get_until(remaining).into(),
+                input.get_until(lead_in_remaining).into(),
+            ),
         ))
     }
 }

src/parser/citation.rs

@@ -210,12 +210,12 @@ mod tests {
     use crate::context::GlobalSettings;
     use crate::context::List;
     use crate::parser::element_parser::element;
-    use crate::types::CitationReference;
     use crate::types::Element;
     use crate::types::GetStandardProperties;
+    use crate::types::StandardProperties;
 
     #[test]
-    fn citation_simple() {
+    fn citation_simple() -> Result<(), Box<dyn std::error::Error>> {
         let input = OrgSource::new("[cite:@foo]");
         let global_settings = GlobalSettings::default();
         let initial_context = ContextElement::document_context();
@@ -232,23 +232,31 @@ mod tests {
             "[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]",
-                style: None,
-                prefix: vec![],
-                suffix: vec![],
-                children: vec![CitationReference {
-                    source: "@foo",
-                    key: "foo",
-                    prefix: vec![],
-                    suffix: vec![]
-                }]
-            })
-        );
+
+        match first_paragraph
+            .children
+            .first()
+            .expect("Len already asserted to be 1.")
+        {
+            Object::Citation(inner) => {
+                assert_eq!(inner.get_source(), "[cite:@foo]");
+                assert_eq!(inner.children.len(), 1);
+                assert!(inner.prefix.is_empty());
+                assert!(inner.suffix.is_empty());
+                assert!(inner.style.is_none());
+                let citation_reference = inner
+                    .children
+                    .first()
+                    .expect("Len already asserted to be 1.");
+                assert_eq!(citation_reference.get_source(), "@foo");
+                assert_eq!(citation_reference.key, "foo");
+                assert!(citation_reference.prefix.is_empty());
+                assert!(citation_reference.suffix.is_empty());
+            }
+            _ => {
+                return Err("Child should be a citation.".into());
+            }
+        };
+        Ok(())
     }
 }

src/parser/document.rs

@@ -143,7 +143,7 @@ fn document_org_source<'b, 'g, 'r, 's>(
     {
         // If there are radio targets in this document then we need to parse the entire document again with the knowledge of the radio targets.
         let all_radio_targets: Vec<&Vec<Object<'_>>> = Into::<AstNode>::into(&document)
-            .into_iter()
+            .iter_all_ast_nodes()
             .filter_map(|ast_node| {
                 if let AstNode::RadioTarget(ast_node) = ast_node {
                     Some(ast_node)

src/parser/drawer.rs

@@ -31,7 +31,6 @@ use crate::types::Drawer;
 use crate::types::Element;
 use crate::types::Keyword;
 use crate::types::Paragraph;
-use crate::types::SetSource;
 
 #[cfg_attr(
     feature = "tracing",
@@ -81,9 +80,8 @@ where
     ))(remaining)
     {
         Ok((remain, (_not_immediate_exit, first_line, (_trailing_whitespace, _exit_contents)))) => {
-            let mut element = Element::Paragraph(Paragraph::of_text(first_line.into()));
             let source = get_consumed(remaining, remain);
-            element.set_source(source.into());
+            let element = Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()));
             (remain, vec![element])
         }
         Err(_) => {

src/parser/dynamic_block.rs

@@ -37,7 +37,6 @@ use crate::types::DynamicBlock;
 use crate::types::Element;
 use crate::types::Keyword;
 use crate::types::Paragraph;
-use crate::types::SetSource;
 
 #[cfg_attr(
     feature = "tracing",
@@ -88,9 +87,7 @@ where
     ))))(remaining)?;
     let leading_blank_lines =
         leading_blank_lines.map(|(source, (first_line, _remaining_lines))| {
-            let mut element = Element::Paragraph(Paragraph::of_text(first_line.into()));
-            element.set_source(source.into());
-            element
+            Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()))
         });
     let (remaining, (mut children, _exit_contents)) =
         many_till(element_matcher, exit_matcher)(remaining)?;

src/parser/greater_block.rs

@@ -39,7 +39,6 @@ use crate::types::Element;
 use crate::types::Keyword;
 use crate::types::Paragraph;
 use crate::types::QuoteBlock;
-use crate::types::SetSource;
 use crate::types::SpecialBlock;
 
 #[cfg_attr(
@@ -257,9 +256,7 @@ fn greater_block_body<'c, 'b, 'g, 'r, 's>(
     ))))(remaining)?;
     let leading_blank_lines =
         leading_blank_lines.map(|(source, (first_line, _remaining_lines))| {
-            let mut element = Element::Paragraph(Paragraph::of_text(first_line.into()));
-            element.set_source(source.into());
-            element
+            Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()))
         });
     let (remaining, (mut children, _exit_contents)) =
         many_till(element_matcher, exit_matcher)(remaining)?;

src/parser/in_buffer_settings.rs

@@ -102,7 +102,7 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
     }) {
         let (_, (in_progress_words, complete_words)) =
             todo_keywords(kw.value).map_err(|err| match err {
-                nom::Err::Incomplete(_) => CustomError::Text(err.to_string()),
+                nom::Err::Incomplete(_) => panic!("This parser does not support streaming."),
                 nom::Err::Error(e) => e,
                 nom::Err::Failure(e) => e,
             })?;
@@ -123,7 +123,7 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
             kw.value,
         )
         .map_err(|err: nom::Err<_>| match err {
-            nom::Err::Incomplete(_) => CustomError::Text(err.to_string()),
+            nom::Err::Incomplete(_) => panic!("This parser does not support streaming."),
             nom::Err::Error(e) => e,
             nom::Err::Failure(e) => e,
         })?;
@@ -141,7 +141,7 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
         .filter(|kw| kw.key.eq_ignore_ascii_case("link"))
     {
         let (_, (link_key, link_value)) = link_template(kw.value).map_err(|err| match err {
-            nom::Err::Incomplete(_) => CustomError::Text(err.to_string()),
+            nom::Err::Incomplete(_) => panic!("This parser does not support streaming."),
             nom::Err::Error(e) => e,
             nom::Err::Failure(e) => e,
         })?;
@@ -157,7 +157,7 @@ pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub(crate) fn apply_post_parse_in_buffer_settings<'g, 's, 'sf>(document: &mut Document<'s>) {
     document.category = Into::<AstNode>::into(&*document)
-        .into_iter()
+        .iter_all_ast_nodes()
         .filter_map(|ast_node| {
             if let AstNode::Keyword(ast_node) = ast_node {
                 if ast_node.key.eq_ignore_ascii_case("category") {

src/parser/lesser_block.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use nom::branch::alt;
 use nom::bytes::complete::is_not;
 use nom::bytes::complete::tag;
@@ -651,6 +653,11 @@ fn switch_word<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     ))(input)
 }
 
+enum ContentState {
+    Normal,
+    Modified(String),
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
@@ -658,8 +665,8 @@ fn switch_word<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
 pub(crate) fn content<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, String> {
-    let mut ret = String::new();
+) -> Res<OrgSource<'s>, Cow<'s, str>> {
+    let mut state = ContentState::Normal;
     let mut remaining = input;
     let exit_matcher_parser = parser_with_context!(exit_matcher_parser)(context);
     loop {
@@ -669,13 +676,28 @@ pub(crate) fn content<'b, 'g, 'r, 's>(
 
         let (remain, (pre_escape_whitespace, line)) = content_line(remaining)?;
         if let Some(val) = pre_escape_whitespace {
-            ret.push_str(Into::<&str>::into(val));
+            if let ContentState::Modified(ref mut ret) = state {
+                ret.push_str(Into::<&str>::into(val));
+            } else {
+                let mut ret = String::new();
+                ret.push_str(Into::<&str>::into(input.get_until(remaining)));
+                ret.push_str(Into::<&str>::into(val));
+                state = ContentState::Modified(ret);
+            }
+        }
+        if let ContentState::Modified(ref mut ret) = state {
+            ret.push_str(line.into());
         }
-        ret.push_str(line.into());
         remaining = remain;
     }
 
-    Ok((remaining, ret))
+    match state {
+        ContentState::Normal => Ok((
+            remaining,
+            Cow::Borrowed(Into::<&str>::into(input.get_until(remaining))),
+        )),
+        ContentState::Modified(ret) => Ok((remaining, Cow::Owned(ret))),
+    }
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]

src/parser/org_source.rs

@@ -12,7 +12,7 @@ use nom::Slice;
 
 pub(crate) type BracketDepth = i16;
 
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Copy, Clone)]
 pub(crate) struct OrgSource<'s> {
     full_source: &'s str,
     start: usize,

src/parser/radio_link.rs

@@ -179,7 +179,7 @@ mod tests {
     use crate::types::PlainText;
 
     #[test]
-    fn plain_text_radio_target() {
+    fn plain_text_radio_target() -> Result<(), Box<dyn std::error::Error>> {
         let input = OrgSource::new("foo bar baz");
         let radio_target_match = vec![Object::PlainText(PlainText { source: "bar" })];
         let global_settings = GlobalSettings {
@@ -200,21 +200,31 @@ mod tests {
             "foo bar baz"
         );
         assert_eq!(first_paragraph.children.len(), 3);
-        assert_eq!(
-            first_paragraph
-                .children
-                .get(1)
-                .expect("Len already asserted to be 3"),
-            &Object::RadioLink(RadioLink {
-                source: "bar ",
-                children: vec![Object::PlainText(PlainText { source: "bar" })],
-                path: "bar"
-            })
-        );
+        match first_paragraph
+            .children
+            .get(1)
+            .expect("Len already asserted to be 3.")
+        {
+            Object::RadioLink(inner) => {
+                assert_eq!(inner.get_standard_properties().get_source(), "bar ");
+                assert_eq!(inner.path, "bar");
+                assert_eq!(inner.children.len(), 1);
+                let child = inner
+                    .children
+                    .get(0)
+                    .expect("Length already asserted to be 1.");
+                assert!(matches!(child, Object::PlainText(_)));
+                assert_eq!(child.get_standard_properties().get_source(), "bar");
+            }
+            _ => {
+                return Err("Child should be a radio link.".into());
+            }
+        };
+        Ok(())
     }
 
     #[test]
-    fn bold_radio_target() {
+    fn bold_radio_target() -> Result<(), Box<dyn std::error::Error>> {
         let input = OrgSource::new("foo *bar* baz");
         let radio_target_match = vec![Object::Bold(Bold {
             source: "*bar*",
@@ -239,19 +249,41 @@ mod tests {
             "foo *bar* baz"
         );
         assert_eq!(first_paragraph.children.len(), 3);
-        assert_eq!(
-            first_paragraph
-                .children
-                .get(1)
-                .expect("Len already asserted to be 3"),
-            &Object::RadioLink(RadioLink {
-                source: "*bar* ",
-                children: vec![Object::Bold(Bold {
-                    source: "*bar* ",
-                    children: vec![Object::PlainText(PlainText { source: "bar" })]
-                })],
-                path: "*bar* "
-            })
-        );
+        match first_paragraph
+            .children
+            .get(1)
+            .expect("Len already asserted to be 3.")
+        {
+            Object::RadioLink(inner) => {
+                assert_eq!(inner.get_standard_properties().get_source(), "*bar* ");
+                assert_eq!(inner.path, "*bar* ");
+                assert_eq!(inner.children.len(), 1);
+                let child = inner
+                    .children
+                    .get(0)
+                    .expect("Length already asserted to be 1.");
+                assert!(matches!(child, Object::Bold(_)));
+                assert_eq!(child.get_standard_properties().get_source(), "*bar* ");
+            }
+            _ => {
+                return Err("Child should be a radio link.".into());
+            }
+        };
+        Ok(())
+
+        // assert_eq!(
+        //     first_paragraph
+        //         .children
+        //         .get(1)
+        //         .expect("Len already asserted to be 3"),
+        //     &Object::RadioLink(RadioLink {
+        //         source: "*bar* ",
+        //         children: vec![Object::Bold(Bold {
+        //             source: "*bar* ",
+        //             children: vec![Object::PlainText(PlainText { source: "bar" })]
+        //         })],
+        //         path: "*bar* "
+        //     })
+        // );
     }
 }

src/types/element.rs

@@ -22,7 +22,6 @@ use super::CenterBlock;
 use super::Drawer;
 use super::GetStandardProperties;
 use super::QuoteBlock;
-use super::SetSource;
 use super::SpecialBlock;
 use super::StandardProperties;
 
@@ -55,38 +54,6 @@ pub enum Element<'s> {
     LatexEnvironment(LatexEnvironment<'s>),
 }
 
-impl<'s> SetSource<'s> for Element<'s> {
-    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-    fn set_source(&mut self, source: &'s str) {
-        match self {
-            Element::Paragraph(obj) => obj.source = source,
-            Element::PlainList(obj) => obj.source = source,
-            Element::CenterBlock(obj) => obj.source = source,
-            Element::QuoteBlock(obj) => obj.source = source,
-            Element::SpecialBlock(obj) => obj.source = source,
-            Element::DynamicBlock(obj) => obj.source = source,
-            Element::FootnoteDefinition(obj) => obj.source = source,
-            Element::Comment(obj) => obj.source = source,
-            Element::Drawer(obj) => obj.source = source,
-            Element::PropertyDrawer(obj) => obj.source = source,
-            Element::Table(obj) => obj.source = source,
-            Element::VerseBlock(obj) => obj.source = source,
-            Element::CommentBlock(obj) => obj.source = source,
-            Element::ExampleBlock(obj) => obj.source = source,
-            Element::ExportBlock(obj) => obj.source = source,
-            Element::SrcBlock(obj) => obj.source = source,
-            Element::Clock(obj) => obj.source = source,
-            Element::DiarySexp(obj) => obj.source = source,
-            Element::Planning(obj) => obj.source = source,
-            Element::FixedWidthArea(obj) => obj.source = source,
-            Element::HorizontalRule(obj) => obj.source = source,
-            Element::Keyword(obj) => obj.source = source,
-            Element::BabelCall(obj) => obj.source = source,
-            Element::LatexEnvironment(obj) => obj.source = source,
-        }
-    }
-}
-
 impl<'s> GetStandardProperties<'s> for Element<'s> {
     fn get_standard_properties<'b>(&'b self) -> &'b dyn StandardProperties<'s> {
         match self {

src/types/lesser_element.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use super::object::Object;
 use super::AffiliatedKeywords;
 use super::GetAffiliatedKeywords;
@@ -59,7 +61,7 @@ pub struct ExampleBlock<'s> {
     pub retain_labels: RetainLabels,
     pub use_labels: bool,
     pub label_format: Option<&'s str>,
-    pub contents: String,
+    pub contents: Cow<'s, str>,
 }
 
 #[derive(Debug)]
@@ -68,7 +70,7 @@ pub struct ExportBlock<'s> {
     pub affiliated_keywords: AffiliatedKeywords<'s>,
     pub export_type: Option<&'s str>,
     pub data: Option<&'s str>,
-    pub contents: String,
+    pub contents: Cow<'s, str>,
 }
 
 #[derive(Debug)]
@@ -83,7 +85,7 @@ pub struct SrcBlock<'s> {
     pub retain_labels: RetainLabels,
     pub use_labels: bool,
     pub label_format: Option<&'s str>,
-    pub contents: String,
+    pub contents: Cow<'s, str>,
 }
 
 #[derive(Debug)]
@@ -169,11 +171,11 @@ impl<'s> Paragraph<'s> {
     /// Generate a paragraph of the passed in text with no additional properties.
     ///
     /// This is used for elements that support an "empty" content like greater blocks.
-    pub(crate) fn of_text(input: &'s str) -> Self {
+    pub(crate) fn of_text(source: &'s str, body: &'s str) -> Self {
         Paragraph {
-            source: input,
+            source,
             affiliated_keywords: AffiliatedKeywords::default(),
-            children: vec![Object::PlainText(PlainText { source: input })],
+            children: vec![Object::PlainText(PlainText { source: body })],
         }
     }
 }

src/types/mod.rs

@@ -7,14 +7,13 @@ mod greater_element;
 mod lesser_element;
 mod macros;
 mod object;
-mod source;
 mod standard_properties;
 mod util;
 pub use affiliated_keyword::AffiliatedKeyword;
 pub use affiliated_keyword::AffiliatedKeywordValue;
 pub use affiliated_keyword::AffiliatedKeywords;
 pub use affiliated_keyword::GetAffiliatedKeywords;
-pub(crate) use ast_node::AstNode;
+pub use ast_node::AstNode;
 pub use document::Document;
 pub use document::DocumentElement;
 pub use document::Heading;
@@ -113,5 +112,4 @@ pub use object::WarningDelay;
 pub use object::WarningDelayType;
 pub use object::Year;
 pub use object::YearInner;
-pub(crate) use source::SetSource;
 pub use standard_properties::StandardProperties;

src/types/object.rs

@@ -9,8 +9,7 @@ use super::util::to_lowercase;
 use super::GetStandardProperties;
 use super::StandardProperties;
 
-// TODO: Why did we make Object implement PartialEq again? Was it just for tests?
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum Object<'s> {
     Bold(Bold<'s>),
     Italic(Italic<'s>),
@@ -41,48 +40,48 @@ pub enum Object<'s> {
     Timestamp(Timestamp<'s>),
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Bold<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Italic<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Underline<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct StrikeThrough<'s> {
     pub source: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Code<'s> {
     pub source: &'s str,
     pub contents: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Verbatim<'s> {
     pub source: &'s str,
     pub contents: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct PlainText<'s> {
     pub source: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RegularLink<'s> {
     pub source: &'s str,
     pub link_type: LinkType<'s>,
@@ -105,21 +104,21 @@ pub struct RegularLink<'s> {
     pub application: Option<Cow<'s, str>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RadioTarget<'s> {
     pub source: &'s str,
     pub value: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct RadioLink<'s> {
     pub source: &'s str,
     pub path: &'s str,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct PlainLink<'s> {
     pub source: &'s str,
     pub link_type: LinkType<'s>,
@@ -129,7 +128,7 @@ pub struct PlainLink<'s> {
     pub application: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct AngleLink<'s> {
     pub source: &'s str,
     pub link_type: LinkType<'s>,
@@ -147,7 +146,7 @@ pub struct AngleLink<'s> {
     pub application: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct OrgMacro<'s> {
     pub source: &'s str,
 
@@ -164,7 +163,7 @@ pub struct OrgMacro<'s> {
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Entity<'s> {
     pub source: &'s str,
     pub name: &'s str,
@@ -177,27 +176,27 @@ pub struct Entity<'s> {
     pub use_brackets: bool,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct LatexFragment<'s> {
     pub source: &'s str,
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct ExportSnippet<'s> {
     pub source: &'s str,
     pub backend: &'s str,
     pub contents: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct FootnoteReference<'s> {
     pub source: &'s str,
     pub label: Option<&'s str>,
     pub definition: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Citation<'s> {
     pub source: &'s str,
     pub style: Option<&'s str>,
@@ -206,7 +205,7 @@ pub struct Citation<'s> {
     pub children: Vec<CitationReference<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct CitationReference<'s> {
     pub source: &'s str,
     pub key: &'s str,
@@ -214,7 +213,7 @@ pub struct CitationReference<'s> {
     pub suffix: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct InlineBabelCall<'s> {
     pub source: &'s str,
     pub value: &'s str,
@@ -224,7 +223,7 @@ pub struct InlineBabelCall<'s> {
     pub end_header: Option<&'s str>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct InlineSourceBlock<'s> {
     pub source: &'s str,
     pub language: &'s str,
@@ -232,31 +231,31 @@ pub struct InlineSourceBlock<'s> {
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct LineBreak<'s> {
     pub source: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Target<'s> {
     pub source: &'s str,
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct StatisticsCookie<'s> {
     pub source: &'s str,
     pub value: &'s str,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Subscript<'s> {
     pub source: &'s str,
     pub use_brackets: bool,
     pub children: Vec<Object<'s>>,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct Superscript<'s> {
     pub source: &'s str,
     pub use_brackets: bool,
@@ -264,7 +263,7 @@ pub struct Superscript<'s> {
 }
 
 // TODO: Perhaps there is an optimization of converting to unix time we can do to shrink this struct. (ref: clippy::large_enum_variant on Element)
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Timestamp<'s> {
     pub source: &'s str,
     pub timestamp_type: TimestampType,
@@ -277,7 +276,7 @@ pub struct Timestamp<'s> {
     pub warning_delay: Option<WarningDelay>,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum TimestampType {
     Diary,
     Active,
@@ -286,7 +285,7 @@ pub enum TimestampType {
     InactiveRange,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum TimestampRangeType {
     None,
     DateRange,
@@ -299,19 +298,19 @@ pub type DayOfMonthInner = u8;
 pub type HourInner = u8;
 pub type MinuteInner = u8;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Year(YearInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Month(MonthInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct DayOfMonth(DayOfMonthInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Hour(HourInner);
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Minute(MinuteInner);
 
 impl Year {
@@ -386,7 +385,7 @@ impl Minute {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Date<'s> {
     year: Year,
     month: Month,
@@ -444,7 +443,7 @@ impl<'s> Date<'s> {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Time<'s> {
     hour: Hour,
     minute: Minute,
@@ -478,20 +477,20 @@ impl<'s> Time<'s> {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum RepeaterType {
     Cumulative,
     CatchUp,
     Restart,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum WarningDelayType {
     All,
     First,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub enum TimeUnit {
     Hour,
     Day,
@@ -502,14 +501,14 @@ pub enum TimeUnit {
 
 pub type RepeaterWarningDelayValueType = u16;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct Repeater {
     pub repeater_type: RepeaterType,
     pub value: RepeaterWarningDelayValueType,
     pub unit: TimeUnit,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone)]
 pub struct WarningDelay {
     pub warning_delay_type: WarningDelayType,
     pub value: RepeaterWarningDelayValueType,
@@ -718,7 +717,7 @@ impl<'s> Timestamp<'s> {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum LinkType<'s> {
     File,
     Protocol(Cow<'s, str>),
@@ -787,7 +786,7 @@ impl<'s> OrgMacro<'s> {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum FootnoteReferenceType {
     Standard,
     Inline,

src/types/source.rs

@@ -1,3 +0,0 @@
-pub(crate) trait SetSource<'s> {
-    fn set_source(&mut self, source: &'s str);
-}