rust: file format read-and-ignore takes reporter method

Author: rizsotto

rust/bear/src/modes/mod.rs

@@ -62,7 +62,6 @@ impl Mode for Intercept {
 /// executed commands from the build process.
 pub struct Semantic {
     event_file: BufReader<fs::File>,
-    event_file_name: path::PathBuf,
     semantic: SemanticAnalysisPipeline,
 }
 
@@ -81,7 +80,6 @@ impl Semantic {
 
         Ok(Self {
             event_file,
-            event_file_name,
             semantic,
         })
     }
@@ -95,7 +93,9 @@ impl Mode for Semantic {
         self.semantic
             .analyze_and_write(ExecutionEventDatabase::read_and_ignore(
                 self.event_file,
-                self.event_file_name,
+                |error| {
+                    log::warn!("Event file reading issue: {:?}", error);
+                },
             ))
             .map(|_| ExitCode::SUCCESS)
     }

rust/bear/src/output/clang/mod.rs

@@ -106,13 +106,13 @@ impl<T: IteratorWriter<Entry>> AppendClangOutputWriter<T> {
     fn read_from_compilation_db(
         source: &path::Path,
     ) -> anyhow::Result<impl Iterator<Item = Entry>> {
-        let source_copy = source.to_path_buf();
-
         let file = fs::File::open(source)
             .map(io::BufReader::new)
             .with_context(|| format!("Failed to open file: {:?}", source))?;
 
-        let entries = JsonCompilationDatabase::read_and_ignore(file, source_copy);
+        let entries = JsonCompilationDatabase::read_and_ignore(file, |error| {
+            log::warn!("Problems to read previous entries: {:?}", error);
+        });
         Ok(entries)
     }
 }

rust/bear/src/output/formats.rs

@@ -11,7 +11,7 @@ use super::{clang, json};
 use crate::{intercept, semantic};
 use serde_json::de::IoRead;
 use serde_json::StreamDeserializer;
-use std::{io, path};
+use std::io;
 use thiserror::Error;
 
 /// The trait represents a file format that can be written to and read from.
@@ -25,11 +25,14 @@ pub trait FileFormat<T> {
 
     /// Reads the entries from the file and ignores any errors.
     /// This is not always feasible, when the file format is strict.
-    fn read_and_ignore(reader: impl io::Read, source: path::PathBuf) -> impl Iterator<Item = T> {
+    fn read_and_ignore(
+        reader: impl io::Read,
+        message_writer: impl Fn(&str),
+    ) -> impl Iterator<Item = T> {
         Self::read(reader).filter_map(move |result| match result {
             Ok(value) => Some(value),
             Err(error) => {
-                log::warn!("Failed to read entry: {:?} from {:?}", error, source);
+                message_writer(&error.to_string());
                 None
             }
         })
@@ -400,7 +403,6 @@ mod test {
         use serde_json::json;
         use std::collections::HashMap;
         use std::io::{Cursor, Seek, SeekFrom};
-        use std::path::PathBuf;
 
         #[test]
         fn read_write() {
@@ -453,13 +455,17 @@ mod test {
                 }
             });
             let content = format!("{}\n{}\n{}\n", line1, line2, line3);
-            let source = PathBuf::from("/home/user/project.json");
 
             let mut cursor = Cursor::new(content);
-            let read_events: Vec<_> = Sut::read_and_ignore(&mut cursor, source).collect();
+            let warnings = std::cell::RefCell::new(Vec::new());
+            let read_events: Vec<_> = Sut::read_and_ignore(&mut cursor, |error| {
+                warnings.borrow_mut().push(format!("Warning: {:?}", error));
+            })
+            .collect();
 
-            // Only the fist event is read, all other lines are ignored.
+            // Only the first event is read, all other lines are ignored.
             assert_eq!(expected_values()[0..1], read_events);
+            assert_eq!(warnings.borrow().len(), 1);
         }
 
         fn expected_values() -> Vec<Event> {