rust: Transformation trait refactoring

Author: rizsotto

rust/bear/src/modes/semantic.rs

@@ -3,6 +3,7 @@
 use crate::intercept::Envelope;
 use crate::output::OutputWriter;
 use crate::semantic::interpreters::create_interpreter;
+use crate::semantic::transformation;
 use crate::semantic::transformation::FilterAndFormat;
 use crate::{args, config, output, semantic};
 use anyhow::Context;
@@ -13,7 +14,7 @@ use std::path::{Path, PathBuf};
 /// The semantic analysis that is independent of the event source.
 pub(super) struct SemanticAnalysisPipeline {
     interpreter: Box<dyn semantic::Interpreter>,
-    transformation: Box<dyn semantic::Transformation>,
+    transformation: Box<dyn transformation::Transformation>,
     output_writer: OutputWriterImpl,
 }
 

rust/bear/src/semantic/mod.rs

@@ -79,15 +79,6 @@ impl<T> IntoIterator for Recognition<T> {
     }
 }
 
-/// Responsible to transform the semantic of an executed command.
-///
-/// It conditionally removes compiler calls based on compiler names or flags.
-/// It can also alter the compiler flags of the compiler calls. The actions
-/// are defined in the configuration this module is given.
-pub trait Transformation: Send {
-    fn apply(&self, _: CompilerCall) -> anyhow::Result<CompilerCall>;
-}
-
 /// Serialize compiler calls into a JSON array.
 pub fn serialize(
     writer: impl std::io::Write,

rust/bear/src/semantic/transformation.rs

@@ -8,13 +8,18 @@
 
 use crate::{config, semantic};
 
+/// Responsible to transform the semantic of an executed command.
+pub trait Transformation: Send {
+    fn apply(&self, _: semantic::CompilerCall) -> anyhow::Result<semantic::CompilerCall>;
+}
+
 /// FilterAndFormat is a transformation that filters and formats the compiler calls.
 pub struct FilterAndFormat {
     filter: filter::SemanticFilter,
     formatter: formatter::PathFormatter,
 }
 
-impl semantic::Transformation for FilterAndFormat {
+impl Transformation for FilterAndFormat {
     fn apply(&self, input: semantic::CompilerCall) -> anyhow::Result<semantic::CompilerCall> {
         let candidate = self.filter.apply(input)?;
         let formatted = self.formatter.apply(candidate)?;
@@ -67,7 +72,7 @@ mod formatter {
     //! file paths. In the current implementation, the `arguments` attribute is not
     //! transformed.
 
-    use crate::{config, semantic};
+    use super::*;
     use std::env;
     use std::path::{Path, PathBuf};
 
@@ -78,7 +83,7 @@ mod formatter {
         SkipFormat,
     }
 
-    impl semantic::Transformation for PathFormatter {
+    impl Transformation for PathFormatter {
         fn apply(&self, call: semantic::CompilerCall) -> anyhow::Result<semantic::CompilerCall> {
             match self {
                 PathFormatter::SkipFormat => Ok(call),
@@ -169,7 +174,7 @@ mod formatter {
 }
 
 mod filter {
-    use crate::{config, semantic};
+    use super::*;
     use anyhow::anyhow;
     use std::collections::HashMap;
     use std::path::PathBuf;
@@ -184,7 +189,7 @@ mod filter {
         compilers: HashMap<PathBuf, Vec<config::Compiler>>,
     }
 
-    impl semantic::Transformation for SemanticFilter {
+    impl Transformation for SemanticFilter {
         fn apply(&self, input: semantic::CompilerCall) -> anyhow::Result<semantic::CompilerCall> {
             if let Some(configs) = self.compilers.get(&input.compiler) {
                 Self::apply_when_match_compiler(configs.as_slice(), input)
@@ -310,7 +315,8 @@ mod filter {
     mod tests {
         use super::*;
         use crate::config::{Arguments, Compiler, IgnoreOrConsider};
-        use crate::semantic::{CompilerCall, CompilerPass, Transformation};
+        use crate::semantic::transformation::Transformation;
+        use crate::semantic::{CompilerCall, CompilerPass};
         use std::path::PathBuf;
 
         #[test]