make clippy happy

Author: michael-kerscher

i18n-book-to-po/src/structure/align.rs

@@ -12,7 +12,6 @@ use crate::structure::{
 /// This is splitting by "." and replacing these elements by a Vector of Sentence Elements
 fn generate_sentence_structure(text: &str) -> Vec<CmarkEvent> {
     text.split(".")
-        .into_iter()
         .filter_map(|sentence| {
             if sentence.is_empty() {
                 None
@@ -26,7 +25,7 @@ fn generate_sentence_structure(text: &str) -> Vec<CmarkEvent> {
 /// Parse the structure of the provided cmark events and return a Markdown structure
 /// It leverages additional sentence elements as structural elements if feature_sentence is set
 fn parse_structure(
-    markdown: &Vec<pulldown_cmark::Event<'_>>,
+    markdown: &[pulldown_cmark::Event<'_>],
     feature_sentence: bool,
 ) -> Vec<CmarkEvent> {
     let structure: Vec<_> = markdown
@@ -38,15 +37,15 @@ fn parse_structure(
                 if let pulldown_cmark::Event::Text(text) = event {
                     // prepend the sentence elements with the Text variant
                     let mut result = vec![(event).into()];
-                    result.extend(generate_sentence_structure(&text));
+                    result.extend(generate_sentence_structure(text));
                     return result;
                 }
             };
             vec![(event).into()]
         })
         .collect();
 
-    return structure;
+    structure
 }
 
 /// normalize the event stream
@@ -67,7 +66,7 @@ fn normalize_events(events: Vec<pulldown_cmark::Event>) -> Vec<pulldown_cmark::E
                         normalized_events.last_mut()
                     {
                         // merge text events (with space as this is a soft break)
-                        *prev_text = format!("{} {}", prev_text, text).into();
+                        *prev_text = format!("{prev_text} {text}").into();
                     } else {
                         // add the text event unmodified
                         normalized_events.push(pulldown_cmark::Event::Text(text));
@@ -100,7 +99,7 @@ fn read_structure(content: &str) -> anyhow::Result<Vec<pulldown_cmark::Event<'_>
     opts.insert(pulldown_cmark::Options::ENABLE_TASKLISTS);
     opts.insert(pulldown_cmark::Options::ENABLE_HEADING_ATTRIBUTES);
 
-    Ok(pulldown_cmark::Parser::new_ext(&content, opts).collect())
+    Ok(pulldown_cmark::Parser::new_ext(content, opts).collect())
 }
 
 /// apply the diff to align the markdown events.
@@ -159,29 +158,23 @@ fn minimize_aligned_events<'a>(
     source
         .into_iter()
         .zip(translated)
-        .filter_map(|(s, t)| {
-            if s.is_some() && t.is_some() {
-                Some((s.unwrap(), t.unwrap()))
-            } else {
-                None
-            }
-        })
+        .filter_map(|(s, t)| s.zip(t))
         .unzip()
 }
 
 /// this is a debug variant of minimize_aligned_events() that returns all events on both sides
 /// that don't have a pendant in the other document. This is mostly useful for debugging if the
 /// markdown cannot be properly reconstructed.
 fn debug_get_unaligned_events<'a>(
-    source: Vec<Option<Event<'a>>>,
-    translated: Vec<Option<Event<'a>>>,
-) -> (Vec<Option<Event<'a>>>, Vec<Option<Event<'a>>>) {
+    source: &'a [Option<Event<'a>>],
+    translated: &'a [Option<Event<'a>>],
+) -> (Vec<Option<&'a Event<'a>>>, Vec<Option<&'a Event<'a>>>) {
     source
-        .into_iter()
+        .iter()
         .zip(translated)
         .filter_map(|(s, t)| {
             if s.is_none() || t.is_none() {
-                Some((s, t))
+                Some((s.as_ref(), t.as_ref()))
             } else {
                 None
             }
@@ -238,13 +231,12 @@ pub fn align_markdown_docs(
         None,
     );
     if let Err(e) = reconstructed_source {
-        println!("Error reconstructing source markdown: {:?}", e);
-        dbg!(&aligned_source);
-        dbg!(&aligned_translated);
-        dbg!(debug_get_unaligned_events(
-            aligned_source,
-            aligned_translated
-        ));
+        println!(
+            "Error reconstructing sourcemarkdown: {e:?}\n{:?}\n{:?}\n{:?}",
+            &aligned_source,
+            &aligned_translated,
+            debug_get_unaligned_events(&aligned_source, &aligned_translated)
+        );
         return Err(e.into());
     }
     let reconstructed_source = reconstructed_source.unwrap();
@@ -257,13 +249,12 @@ pub fn align_markdown_docs(
         None,
     );
     if let Err(e) = reconstructed_translated {
-        println!("Error reconstructing translated markdown: {:?}", e);
-        dbg!(&aligned_source);
-        dbg!(&aligned_translated);
-        dbg!(debug_get_unaligned_events(
-            aligned_source,
-            aligned_translated
-        ));
+        println!(
+            "Error reconstructing translated markdown: {e:?}\n{:?}\n{:?}\n{:?}",
+            &aligned_source,
+            &aligned_translated,
+            debug_get_unaligned_events(&aligned_source, &aligned_translated)
+        );
         return Err(e.into());
     }
     let reconstructed_translated = reconstructed_translated.unwrap();
@@ -489,14 +480,14 @@ new sentence";
             .into_iter()
             .flatten()
             .cloned()
-            .collect();
+            .collect::<Vec<_>>();
 
         // the untranslated paragraph is missing but a new sentence was added by the translator
         let translated_events = [&translated_a, &translated_b, &new_paragraph_in_translation]
             .into_iter()
             .flatten()
             .cloned()
-            .collect();
+            .collect::<Vec<_>>();
         let original_structure = parse_structure(&original_events, false);
         let translated_structure = parse_structure(&translated_events, false);
         let diff = diff_structure(

i18n-book-to-po/src/structure/diff.rs

@@ -4,7 +4,7 @@ use crate::structure::types::{AlignAction, CmarkEvent, DiffAlgorithm};
 
 /// this diffs the structure in how the original needs to be modified in order to create the translation.
 /// lcs_diff:diff() already does the job, but we transform this to a better understandable datastructure
-fn diff_structure_lcs(source: &Vec<CmarkEvent>, translated: &Vec<CmarkEvent>) -> Vec<AlignAction> {
+fn diff_structure_lcs(source: &[CmarkEvent], translated: &[CmarkEvent]) -> Vec<AlignAction> {
     lcs_diff::diff(translated, source)
         .into_iter()
         .map(|change| {
@@ -23,8 +23,8 @@ fn diff_structure_lcs(source: &Vec<CmarkEvent>, translated: &Vec<CmarkEvent>) ->
 /// this diffs the structure in how the original needs to be modified in order to create the translation.
 /// We use the global alignment algorithm NeedlemanWunsch and transform the result into a understandable datastructure
 fn diff_structure_seal(
-    source: &Vec<CmarkEvent>,
-    translation: &Vec<CmarkEvent>,
+    source: &[CmarkEvent],
+    translation: &[CmarkEvent],
 ) -> Vec<AlignAction> {
     // equal is good, align operation is not good
     let strategy = seal::pair::NeedlemanWunsch::new(1, -1, -1, 0);
@@ -36,7 +36,6 @@ fn diff_structure_seal(
     let global_alignment = set.global_alignment();
     global_alignment
         .steps()
-        .into_iter()
         .map(|step| {
             // x is valid in source and y is valid in target
             match step {
@@ -67,8 +66,8 @@ fn diff_structure_seal(
 
 /// diff the structure of to content-less CmarkEvent streams with the specified algorithm
 pub fn diff_structure(
-    source: &Vec<CmarkEvent>,
-    translated: &Vec<CmarkEvent>,
+    source: &[CmarkEvent],
+    translated: &[CmarkEvent],
     algorithm: &DiffAlgorithm,
 ) -> Vec<AlignAction> {
     match algorithm {