rust: tarnsformation module is part of semantic pakcage

Author: rizsotto

rust/bear/src/modes/mod.rs

@@ -3,7 +3,6 @@
 mod input;
 mod intercept;
 mod recognition;
-mod transformation;
 
 use crate::ipc::Envelope;
 use crate::output::OutputWriter;
@@ -14,7 +13,8 @@ use intercept::{CollectorService, InterceptEnvironment};
 use recognition::Recognition;
 use std::io::BufWriter;
 use std::process::ExitCode;
-use transformation::Transformation;
+use crate::semantic::Transform;
+use crate::semantic::transformation::Transformation;
 
 /// Declare the environment variables used by the intercept mode.
 pub const KEY_DESTINATION: &str = "INTERCEPT_REPORTER_ADDRESS";

rust/bear/src/semantic/mod.rs

@@ -11,9 +11,11 @@
 //! ones that are relevant to build a JSON compilation database.
 
 pub mod interpreters;
+pub mod transformation;
 
 use super::ipc::Execution;
 use std::path::PathBuf;
+use crate::semantic;
 
 /// Represents an executed command semantic.
 #[derive(Debug, PartialEq)]
@@ -63,3 +65,12 @@ pub enum Recognition<T> {
     /// The command was not recognized.
     Unknown,
 }
+
+/// 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 Transform {
+    fn apply(&self, _: CompilerCall) -> Option<CompilerCall>;
+}

rust/bear/src/modes/transformation.rs renamed to rust/bear/src/semantic/transformation.rs

@@ -6,8 +6,9 @@
 //! It can also alter the compiler flags of the compiler calls. The actions
 //! are defined in the configuration this module is given.
 
-use super::super::semantic;
-use super::config;
+use crate::semantic;
+use crate::config;
+use crate::semantic::Transform;
 
 pub enum Transformation {
     None,
@@ -30,34 +31,34 @@ impl From<&config::Output> for Transformation {
     }
 }
 
-impl Transformation {
-    pub fn apply(&self, input: semantic::CompilerCall) -> Option<semantic::CompilerCall> {
+impl Transform for Transformation {
+    fn apply(&self, input: semantic::CompilerCall) -> Option<semantic::CompilerCall> {
         let semantic::CompilerCall {
             compiler,
             passes,
             working_dir,
         } = &input;
         match self.lookup(compiler) {
             Some(config::Compiler {
-                ignore: config::Ignore::Always,
-                ..
-            }) => None,
+                     ignore: config::Ignore::Always,
+                     ..
+                 }) => None,
             Some(config::Compiler {
-                ignore: config::Ignore::Conditional,
-                arguments,
-                ..
-            }) => {
+                     ignore: config::Ignore::Conditional,
+                     arguments,
+                     ..
+                 }) => {
                 if Self::filter(arguments, passes) {
                     None
                 } else {
                     Some(input)
                 }
             }
             Some(config::Compiler {
-                ignore: config::Ignore::Never,
-                arguments,
-                ..
-            }) => {
+                     ignore: config::Ignore::Never,
+                     arguments,
+                     ..
+                 }) => {
                 let new_passes = Transformation::execute(arguments, passes);
                 Some(semantic::CompilerCall {
                     compiler: compiler.clone(),
@@ -68,7 +69,9 @@ impl Transformation {
             None => Some(input),
         }
     }
+}
 
+impl Transformation {
     // TODO: allow multiple matches for the same compiler
     fn lookup(&self, compiler: &std::path::Path) -> Option<&config::Compiler> {
         match self {