rust: interpreter factory method simplified

Author: rizsotto

rust/bear/src/modes/semantic.rs

@@ -2,7 +2,7 @@
 
 use crate::intercept::Envelope;
 use crate::output::OutputWriter;
-use crate::semantic::interpreters::Builder;
+use crate::semantic::interpreters::create_interpreter;
 use crate::semantic::transformation::Transformation;
 use crate::{args, config, output, semantic};
 use anyhow::Context;
@@ -20,7 +20,7 @@ pub(super) struct SemanticAnalysisPipeline {
 impl SemanticAnalysisPipeline {
     /// Create a new semantic mode instance.
     pub(super) fn from(output: args::BuildSemantic, config: &config::Main) -> anyhow::Result<Self> {
-        let interpreter = Builder::from(config);
+        let interpreter = create_interpreter(config);
         let transform = Transformation::from(&config.output);
         let output_writer = OutputWriterImpl::create(&output, &config.output)?;
 

rust/bear/src/semantic/interpreters/ignore.rs

@@ -22,6 +22,12 @@ impl IgnoreByPath {
     }
 }
 
+impl Default for IgnoreByPath {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// A tool to ignore a command execution by arguments.
 impl Interpreter for IgnoreByPath {
     fn recognize(&self, execution: &Execution) -> Recognition<CompilerCall> {

rust/bear/src/semantic/interpreters/mod.rs

@@ -13,84 +13,47 @@ mod generic;
 mod ignore;
 mod matchers;
 
-/// A builder for creating a tool which can recognize the semantic of a compiler,
-/// or ignore known non-compilers.
-pub struct Builder {
-    interpreters: Vec<Box<dyn Interpreter>>,
-}
-
-impl Builder {
-    /// Creates an interpreter to recognize the compiler calls.
-    ///
-    /// Using the configuration we can define which compilers to include and exclude.
-    /// Also read the environment variables to detect the compiler to include (and
-    /// make sure those are not excluded either).
-    // TODO: Use the CC or CXX environment variables to detect the compiler to include.
-    //       Use the CC or CXX environment variables and make sure those are not excluded.
-    //       Make sure the environment variables are passed to the method.
-    // TODO: Take environment variables as input.
-    pub fn from(config: &config::Main) -> impl Interpreter {
-        let compilers_to_include = match &config.intercept {
-            config::Intercept::Wrapper { executables, .. } => executables.clone(),
-            _ => vec![],
-        };
-        let compilers_to_exclude = match &config.output {
-            config::Output::Clang { compilers, .. } => compilers
-                .iter()
-                .filter(|compiler| compiler.ignore == config::IgnoreOrConsider::Always)
-                .map(|compiler| compiler.path.clone())
-                .collect(),
-            _ => vec![],
-        };
-        Builder::new()
-            .compilers_to_recognize(compilers_to_include.as_slice())
-            .compilers_to_exclude(compilers_to_exclude.as_slice())
-            .build()
-    }
-
-    /// Creates a new builder with default settings.
-    fn new() -> Self {
-        // FIXME: replace generic with gcc, when it's implemented
-        Builder {
-            interpreters: vec![
-                // ignore executables which are not compilers,
-                Box::new(IgnoreByPath::new()),
-                // recognize default compiler
-                Box::new(Generic::from(&[PathBuf::from("/usr/bin/g++")])),
-            ],
-        }
+/// Creates an interpreter to recognize the compiler calls.
+///
+/// Using the configuration we can define which compilers to include and exclude.
+/// Also read the environment variables to detect the compiler to include (and
+/// make sure those are not excluded either).
+// TODO: Use the CC or CXX environment variables to detect the compiler to include.
+//       Use the CC or CXX environment variables and make sure those are not excluded.
+//       Make sure the environment variables are passed to the method.
+// TODO: Take environment variables as input.
+pub fn create_interpreter<'a>(config: &config::Main) -> impl Interpreter + 'a {
+    let compilers_to_include = match &config.intercept {
+        config::Intercept::Wrapper { executables, .. } => executables.clone(),
+        _ => vec![],
+    };
+    let compilers_to_exclude = match &config.output {
+        config::Output::Clang { compilers, .. } => compilers
+            .iter()
+            .filter(|compiler| compiler.ignore == config::IgnoreOrConsider::Always)
+            .map(|compiler| compiler.path.clone())
+            .collect(),
+        _ => vec![],
+    };
+
+    let mut interpreters: Vec<Box<dyn Interpreter>> = vec![
+        // ignore executables which are not compilers,
+        Box::new(IgnoreByPath::default()),
+        // recognize default compiler
+        Box::new(Generic::from(&[PathBuf::from("/usr/bin/cc")])),
+    ];
+
+    if !compilers_to_include.is_empty() {
+        let tool = Generic::from(&compilers_to_include);
+        interpreters.push(Box::new(tool));
     }
 
-    /// Factory method to create a new tool from the builder.
-    fn build(self) -> impl Interpreter {
-        Any::new(self.interpreters)
-    }
-
-    /// Adds new interpreters to recognize as compilers by executable name.
-    fn compilers_to_recognize(mut self, compilers: &[PathBuf]) -> Self {
-        if !compilers.is_empty() {
-            // Add the new compilers at the end of the interpreters.
-            let tool = Generic::from(compilers);
-            self.interpreters.push(Box::new(tool));
-        }
-        self
+    if !compilers_to_exclude.is_empty() {
+        let tool = IgnoreByPath::from(&compilers_to_exclude);
+        interpreters.insert(0, Box::new(tool));
     }
 
-    /// Adds new interpreters to recognize as non-compilers by executable names.
-    fn compilers_to_exclude(mut self, compilers: &[PathBuf]) -> Self {
-        if !compilers.is_empty() {
-            // Add these new compilers at the front of the interpreters.
-            let tool = IgnoreByPath::from(compilers);
-            self.interpreters.insert(0, Box::new(tool));
-        }
-        self
-    }
-}
-
-impl Default for Builder {
-    fn default() -> Self {
-        Builder::new()
-    }
+    Any::new(interpreters)
 }
 
 #[cfg(test)]
@@ -100,37 +63,74 @@ mod test {
 
     use super::super::{CompilerCall, Execution, Recognition};
     use super::*;
+    use crate::config;
+    use crate::config::{DuplicateFilter, Format, SourceFilter};
     use crate::{vec_of_pathbuf, vec_of_strings};
 
+    fn any_execution() -> Execution {
+        Execution {
+            executable: PathBuf::from("/usr/bin/cc"),
+            arguments: vec_of_strings!["cc", "-c", "-Wall", "main.c"],
+            environment: HashMap::new(),
+            working_dir: PathBuf::from("/home/user"),
+        }
+    }
+
     #[test]
-    fn test_builder() {
-        let sut = Builder::new().build();
+    fn test_create_interpreter_with_default_config() {
+        let config = config::Main::default();
 
+        let interpreter = create_interpreter(&config);
         let input = any_execution();
-        match sut.recognize(&input) {
+
+        match interpreter.recognize(&input) {
             Recognition::Success(CompilerCall { .. }) => assert!(true),
             _ => assert!(false),
         }
     }
 
     #[test]
-    fn test_builder_with_compilers_to_exclude() {
-        let compilers = vec_of_pathbuf!["/usr/bin/g++"];
-        let sut = Builder::new().compilers_to_exclude(&compilers).build();
+    fn test_create_interpreter_with_compilers_to_include() {
+        let config = config::Main {
+            intercept: config::Intercept::Wrapper {
+                executables: vec_of_pathbuf!["/usr/bin/cc"],
+                path: PathBuf::from("/usr/libexec/bear"),
+                directory: PathBuf::from("/tmp"),
+            },
+            ..Default::default()
+        };
 
+        let interpreter = create_interpreter(&config);
         let input = any_execution();
-        match sut.recognize(&input) {
-            Recognition::Ignored => assert!(true),
+
+        match interpreter.recognize(&input) {
+            Recognition::Success(CompilerCall { .. }) => assert!(true),
             _ => assert!(false),
         }
     }
 
-    fn any_execution() -> Execution {
-        Execution {
-            executable: PathBuf::from("/usr/bin/g++"),
-            arguments: vec_of_strings!["g++", "-c", "main.cpp"],
-            environment: HashMap::new(),
-            working_dir: PathBuf::from("/home/user"),
+    #[test]
+    fn test_create_interpreter_with_compilers_to_exclude() {
+        let config = config::Main {
+            output: config::Output::Clang {
+                compilers: vec![config::Compiler {
+                    path: PathBuf::from("/usr/bin/cc"),
+                    ignore: config::IgnoreOrConsider::Always,
+                    arguments: config::Arguments::default(),
+                }],
+                sources: SourceFilter::default(),
+                duplicates: DuplicateFilter::default(),
+                format: Format::default(),
+            },
+            ..Default::default()
+        };
+
+        let interpreter = create_interpreter(&config);
+        let input = any_execution();
+
+        match interpreter.recognize(&input) {
+            Recognition::Ignored => assert!(true),
+            _ => assert!(false),
         }
     }
 }