Fix clippy.

org_mode_samples/document/only_line_breaks.org

@@ -0,0 +1,4 @@
+
+
+
+

org_mode_samples/document/post_blank.org

@@ -0,0 +1,5 @@
+* foo
+
+
+
+

org_mode_samples/lesser_element/fixed_width_area/blank_line_in_middle.org

@@ -0,0 +1,3 @@
+: foo
+:
+: bar

org_mode_samples/lesser_element/fixed_width_area/list_post_blank.org

@@ -0,0 +1,6 @@
+1. foo
+   #+begin_src text
+
+   #+end_src
+
+2. baz

org_mode_samples/object/target/simple.org

@@ -0,0 +1,3 @@
+<<FOO>> bar
+
+[[FOO][baz]]

org_mode_samples/sections_and_headings/heading_with_subheading_post_blank.org

@@ -0,0 +1,5 @@
+* foo
+
+** bar
+
+* baz

src/compare/util.rs

@@ -285,7 +285,7 @@ where
 pub(crate) fn compare_children<'b, 's, 'x, RC>(
     source: &'s str,
     emacs: &'b Token<'s>,
-    rust_children: &'x Vec<RC>,
+    rust_children: &'x [RC],
     child_status: &mut Vec<DiffEntry<'b, 's>>,
     this_status: &mut DiffStatus,
     message: &mut Option<String>,

src/event_count/database.rs

@@ -27,7 +27,7 @@ pub(crate) fn record_event(event_type: EventType, input: OrgSource<'_>) {
 pub fn report(original_document: &str) {
     let mut db = GLOBAL_DATA.lock().unwrap();
     let db = db.get_or_insert_with(HashMap::new);
-    let mut results: Vec<_> = db.iter().map(|(k, v)| (k, v)).collect();
+    let mut results: Vec<_> = db.iter().collect();
     results.sort_by_key(|(_k, v)| *v);
     // This would put the most common at the top, but that is a pain when there is already a lot of output from the parser.
     // results.sort_by(|(_ak, av), (_bk, bv)| bv.cmp(av));

src/parser/bullshitium.rs

@@ -84,7 +84,7 @@ pub(crate) fn broken_end<'b, 'g, 'r, 's>(
             Paragraph::of_text(
                 input.get_until(remaining).into(),
                 body,
-                if body.len() > 0 { Some(body) } else { None },
+                if !body.is_empty() { Some(body) } else { None },
                 post_blank.map(Into::<&str>::into),
             ),
         ))
@@ -145,7 +145,7 @@ pub(crate) fn broken_dynamic_block<'b, 'g, 'r, 's>(
             Paragraph::of_text(
                 input.get_until(remaining).into(),
                 body,
-                if body.len() > 0 { Some(body) } else { None },
+                if !body.is_empty() { Some(body) } else { None },
                 post_blank.map(Into::<&str>::into),
             ),
         ))

src/parser/document.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use nom::combinator::all_consuming;
 use nom::combinator::opt;
 use nom::multi::many0;
+use nom::InputTake;
 
 use super::headline::heading;
 use super::in_buffer_settings::apply_in_buffer_settings;
@@ -195,9 +196,9 @@ fn _document<'b, 'g, 'r, 's>(
             zeroth_section,
             children,
             contents: if contents.len() > 0 {
-                Some(Into::<&str>::into(contents))
+                Into::<&str>::into(contents)
             } else {
-                None
+                Into::<&str>::into(remaining.take(0))
             },
         },
     ))

src/parser/fixed_width_area.rs

@@ -14,7 +14,7 @@ use nom::InputTake;
 
 use super::affiliated_keyword::parse_affiliated_keywords;
 use super::org_source::OrgSource;
-use super::util::maybe_consume_trailing_whitespace_if_not_exiting_mid_line;
+use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
 use super::util::org_line_ending;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
@@ -48,8 +48,11 @@ where
         ),
     ))(remaining)?;
 
-    let (remaining, post_blank) =
+    let post_blank_begin = remaining;
-        maybe_consume_trailing_whitespace_if_not_exiting_mid_line(context, remaining)?;
+    let (remaining, _first_line_break) = org_line_ending(remaining)?;
+    let (remaining, _additional_post_blank) =
+        maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
+    let post_blank = get_consumed(post_blank_begin, remaining);
     let source = get_consumed(input, remaining);
     let mut value = Vec::with_capacity(remaining_lines.len() + 1);
     value.push(Into::<&str>::into(first_line));
@@ -63,7 +66,11 @@ where
                 affiliated_keywords,
             ),
             value,
-            post_blank: post_blank.map(Into::<&str>::into),
+            post_blank: if post_blank.len() > 0 {
+                Some(Into::<&str>::into(post_blank))
+            } else {
+                None
+            },
         },
     ))
 }
@@ -72,8 +79,8 @@ where
 fn fixed_width_area_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     start_of_line(input)?;
     let (remaining, _) = tuple((space0, tag(":")))(input)?;
-    if let Ok((remain, _line_break)) = org_line_ending(remaining) {
+    if let Ok((_remain, _line_break)) = org_line_ending(remaining) {
-        return Ok((remain, remaining.take(0)));
+        return Ok((remaining, remaining.take(0)));
     }
     let (remaining, _) = tag(" ")(remaining)?;
     let (remaining, value) = recognize(many_till(anychar, peek(org_line_ending)))(remaining)?;

src/parser/target.rs

@@ -46,7 +46,7 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
         )));
     }
     let (remaining, _) = tag(">>")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -55,6 +55,7 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
         Target {
             source: source.into(),
             value: body.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/util.rs

@@ -72,13 +72,6 @@ fn element_trailing_whitespace<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, O
     alt((eof, recognize(many0(blank_line))))(input)
 }
 
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn element_trailing_whitespace_mid_line<'s>(
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, OrgSource<'s>> {
-    alt((eof, recognize(many0(blank_line))))(input)
-}
-
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
@@ -121,22 +114,6 @@ pub(crate) fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
     }
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(context))
-)]
-pub(crate) fn maybe_consume_trailing_whitespace_if_not_exiting_mid_line<'b, 'g, 'r, 's>(
-    context: RefContext<'b, 'g, 'r, 's>,
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
-    if context.should_consume_trailing_whitespace() && exit_matcher_parser(context, input).is_err()
-    {
-        Ok(opt(element_trailing_whitespace_mid_line)(input)?)
-    } else {
-        Ok((input, None))
-    }
-}
-
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))

src/types/document.rs

@@ -17,7 +17,7 @@ pub struct Document<'s> {
     pub path: Option<PathBuf>,
     pub zeroth_section: Option<Section<'s>>,
     pub children: Vec<Heading<'s>>,
-    pub contents: Option<&'s str>,
+    pub contents: &'s str,
 }
 
 #[derive(Debug)]
@@ -64,14 +64,11 @@ impl<'s> StandardProperties<'s> for Document<'s> {
     }
 
     fn get_contents<'b>(&'b self) -> Option<&'s str> {
-        self.contents
+        Some(self.contents)
     }
 
     fn get_post_blank(&self) -> PostBlank {
-        self.into_iter()
+        0
-            .last()
-            .map(|child| child.get_post_blank())
-            .unwrap_or(0)
     }
 }
 
@@ -103,16 +100,11 @@ impl<'s> StandardProperties<'s> for Heading<'s> {
     }
 
     fn get_post_blank(&self) -> PostBlank {
-        self.children
+        self.post_blank
-            .last()
+            .map(|text| text.lines().count())
-            .map(|child| child.get_post_blank())
+            .unwrap_or(0)
-            .unwrap_or(
+            .try_into()
-                self.post_blank
+            .expect("Too much post-blank to fit into a PostBlank.")
-                    .map(|text| text.lines().count())
-                    .unwrap_or(0)
-                    .try_into()
-                    .expect("Too much post-blank to fit into a PostBlank."),
-            )
     }
 }
 

src/types/object.rs

@@ -266,6 +266,7 @@ pub struct LineBreak<'s> {
 pub struct Target<'s> {
     pub source: &'s str,
     pub value: &'s str,
+    pub post_blank: Option<&'s str>,
 }
 
 #[derive(Debug)]
@@ -923,11 +924,15 @@ impl<'s> StandardProperties<'s> for Target<'s> {
     }
 
     fn get_contents<'b>(&'b self) -> Option<&'s str> {
-        todo!()
+        None
     }
 
     fn get_post_blank(&self) -> PostBlank {
-        todo!()
+        self.post_blank
+            .map(|post_blank| post_blank.chars().count())
+            .unwrap_or(0)
+            .try_into()
+            .expect("Too much post-blank to fit into a PostBlank.")
     }
 }
 
@@ -1009,11 +1014,13 @@ impl<'s> StandardProperties<'s> for PlainText<'s> {
     }
 
     fn get_contents<'b>(&'b self) -> Option<&'s str> {
-        todo!()
+        // This field does not actually exist in emacs for plaintext
+        Some(self.source)
     }
 
     fn get_post_blank(&self) -> PostBlank {
-        todo!()
+        // This field does not actually exist in emacs for plaintext
+        0
     }
 }