rust: bear event reading module is renamed

Author: rizsotto

rust/bear/src/events.rs renamed to rust/bear/src/input.rs

@@ -17,63 +17,110 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+use anyhow::Context;
+use serde_json::{Deserializer, Error, Value};
 use std::collections::HashMap;
+use std::fs::{File, OpenOptions};
+use std::io::BufReader;
 use std::path::PathBuf;
 
-use serde_json::{Deserializer, Error, Value};
-
+use super::args;
 use intercept::Execution;
 
+/// Responsible for reading the build events from the intercept mode.
+///
+/// The file syntax is defined by the `events` module, and the parsing logic is implemented there.
+/// Here we only handle the file opening and the error handling.
+pub struct EventFileReader {
+    reader: BufReader<File>,
+}
+
+impl TryFrom<args::BuildEvents> for EventFileReader {
+    type Error = anyhow::Error;
+
+    /// Open the file and create a new instance of the event file reader.
+    ///
+    /// If the file cannot be opened, the error will be logged and escalated.
+    fn try_from(value: args::BuildEvents) -> Result<Self, Self::Error> {
+        let file_name = PathBuf::from(value.file_name);
+        let file = OpenOptions::new()
+            .read(true)
+            .open(file_name.as_path())
+            .with_context(|| format!("Failed to open input file: {:?}", file_name))?;
+        let reader = BufReader::new(file);
+
+        Ok(EventFileReader { reader })
+    }
+}
+
+impl EventFileReader {
+    /// Generate the build events from the file.
+    ///
+    /// Returns an iterator over the build events. Any error during the reading
+    /// of the file will be logged and the failed entries will be skipped.
+    pub fn generate(self) -> impl Iterator<Item = Execution> {
+        // Process the file line by line.
+        from_reader(self.reader)
+            // Log the errors and skip the failed entries.
+            .flat_map(|candidate| match candidate {
+                Ok(execution) => Some(execution),
+                Err(error) => {
+                    log::warn!("Failed to read entry from input: {}", error);
+                    None
+                }
+            })
+    }
+}
+
 // Based on stream serializer from `serde_json` crate.
 //
 //   https://docs.rs/serde_json/latest/serde_json/struct.StreamDeserializer.html
-pub fn from_reader(reader: impl std::io::Read) -> impl Iterator<Item=Result<Execution, Error>> {
+pub fn from_reader(reader: impl std::io::Read) -> impl Iterator<Item = Result<Execution, Error>> {
     Deserializer::from_reader(reader)
         .into_iter::<Value>()
-        .flat_map(|value| {
-            match value {
-                Ok(value) =>
-                    into_execution(value).map(Ok),
-                Err(error) =>
-                    Some(Err(error)),
-            }
+        .flat_map(|value| match value {
+            Ok(value) => into_execution(value).map(Ok),
+            Err(error) => Some(Err(error)),
         })
 }
 
 fn into_execution(value: Value) -> Option<Execution> {
-    value.get("started")
+    value
+        .get("started")
         .and_then(|started| started.get("execution"))
         .and_then(|execution| execution.as_object())
         .and_then(|map| {
-            let executable = map.get("executable")
+            let executable = map
+                .get("executable")
                 .and_then(Value::as_str)
                 .map(PathBuf::from);
-            let arguments = map.get("arguments")
-                .and_then(Value::as_array)
-                .map(|vs| vs.iter()
+            let arguments = map.get("arguments").and_then(Value::as_array).map(|vs| {
+                vs.iter()
                     .flat_map(Value::as_str)
                     .map(str::to_string)
                     .collect::<Vec<String>>()
-                );
-            let working_dir = map.get("working_dir")
+            });
+            let working_dir = map
+                .get("working_dir")
                 .and_then(Value::as_str)
                 .map(PathBuf::from);
-            let environment = map.get("environment")
-                .and_then(Value::as_object)
-                .map(|m| m.iter()
+            let environment = map.get("environment").and_then(Value::as_object).map(|m| {
+                m.iter()
                     .map(|kv| (kv.0.clone(), kv.1.as_str().unwrap().to_string()))
                     .collect::<HashMap<String, String>>()
-                );
-
-            if executable.is_some() && arguments.is_some() && working_dir.is_some() && environment.is_some() {
-                Some(
-                    Execution {
-                        executable: executable.unwrap(),
-                        arguments: arguments.unwrap(),
-                        working_dir: working_dir.unwrap(),
-                        environment: environment.unwrap(),
-                    }
-                )
+            });
+
+            if executable.is_some()
+                && arguments.is_some()
+                && working_dir.is_some()
+                && environment.is_some()
+            {
+                Some(Execution {
+                    executable: executable.unwrap(),
+                    arguments: arguments.unwrap(),
+                    working_dir: working_dir.unwrap(),
+                    environment: environment.unwrap(),
+                })
             } else {
                 None
             }
@@ -82,15 +129,17 @@ fn into_execution(value: Value) -> Option<Execution> {
 
 #[cfg(test)]
 mod test {
+    use crate::vec_of_strings;
     use std::collections::HashMap;
     use std::path::PathBuf;
-    use crate::vec_of_strings;
 
     use super::*;
 
     #[test]
     fn test_reading_events() {
-        let content = [into_single_line(r#"
+        let content = [
+            into_single_line(
+                r#"
             {
               "rid": "17014093296157802240",
               "started": {
@@ -117,8 +166,10 @@ mod test {
               },
               "timestamp": "2023-08-08T12:02:12.760865Z"
             }
-            "#),
-            into_single_line(r#"
+            "#,
+            ),
+            into_single_line(
+                r#"
             {
               "rid": "8533747834426684686",
               "started": {
@@ -143,36 +194,38 @@ mod test {
               },
               "timestamp": "2023-08-08T12:02:12.771258Z"
             }
-            "#),
-            into_single_line(r#"
+            "#,
+            ),
+            into_single_line(
+                r#"
             {
               "rid": "8533747834426684686",
               "terminated": {
                 "status": "0"
               },
               "timestamp": "2023-08-08T12:02:12.772584Z"
             }
-            "#),
-            into_single_line(r#"
+            "#,
+            ),
+            into_single_line(
+                r#"
             {
               "rid": "17014093296157802240",
               "terminated": {
                 "status": "0"
               },
               "timestamp": "2023-08-08T12:02:12.773568Z"
             }
-            "#)]
-            .join("\n");
+            "#,
+            ),
+        ]
+        .join("\n");
 
         let mut result = from_reader(content.as_bytes());
 
         let expected = Execution {
             executable: PathBuf::from("/usr/bin/sh"),
-            arguments: vec_of_strings![
-                "sh",
-                "-c",
-                "ls"
-            ],
+            arguments: vec_of_strings!["sh", "-c", "ls"],
             working_dir: PathBuf::from("/var/home/lnagy/Code/Bear.git"),
             environment: HashMap::from([
                 ("COLORTERM".to_string(), "truecolor".to_string()),

rust/bear/src/main.rs

@@ -16,19 +16,17 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+use std::process::ExitCode;
+
+use crate::input::EventFileReader;
 use crate::output::OutputWriter;
-use anyhow::Context;
 use intercept::Execution;
 use log;
 use semantic;
-use std::fs::{File, OpenOptions};
-use std::io::BufReader;
-use std::path::PathBuf;
-use std::process::ExitCode;
 
 mod args;
 mod config;
-pub mod events;
+mod input;
 mod filter;
 mod fixtures;
 mod output;
@@ -171,51 +169,6 @@ impl Application {
     }
 }
 
-/// Responsible for reading the build events from the intercept mode.
-///
-/// The file syntax is defined by the `events` module, and the parsing logic is implemented there.
-/// Here we only handle the file opening and the error handling.
-struct EventFileReader {
-    reader: BufReader<File>,
-}
-
-impl TryFrom<args::BuildEvents> for EventFileReader {
-    type Error = anyhow::Error;
-
-    /// Open the file and create a new instance of the event file reader.
-    ///
-    /// If the file cannot be opened, the error will be logged and escalated.
-    fn try_from(value: args::BuildEvents) -> Result<Self, Self::Error> {
-        let file_name = PathBuf::from(value.file_name);
-        let file = OpenOptions::new()
-            .read(true)
-            .open(file_name.as_path())
-            .with_context(|| format!("Failed to open input file: {:?}", file_name))?;
-        let reader = BufReader::new(file);
-
-        Ok(EventFileReader { reader })
-    }
-}
-
-impl EventFileReader {
-    /// Generate the build events from the file.
-    ///
-    /// Returns an iterator over the build events. Any error during the reading
-    /// of the file will be logged and the failed entries will be skipped.
-    fn generate(self) -> impl Iterator<Item = Execution> {
-        // Process the file line by line.
-        events::from_reader(self.reader)
-            // Log the errors and skip the failed entries.
-            .flat_map(|candidate| match candidate {
-                Ok(execution) => Some(execution),
-                Err(error) => {
-                    log::warn!("Failed to read entry from input: {}", error);
-                    None
-                }
-            })
-    }
-}
-
 /// Responsible for recognizing the semantic meaning of the executed commands.
 ///
 /// The recognition logic is implemented in the `tools` module. Here we only handle