rust: rename semantic module trait

Author: rizsotto

rust/bear/src/recognition.rs

@@ -5,10 +5,10 @@ use std::convert::TryFrom;
 
 /// Responsible for recognizing the semantic meaning of the executed commands.
 ///
-/// The recognition logic is implemented in the `tools` module. Here we only handle
+/// The recognition logic is implemented in the `interpreters` module. Here we only handle
 /// the errors and logging them to the console.
 pub struct Recognition {
-    tool: Box<dyn semantic::Tool>,
+    interpreter: Box<dyn semantic::Interpreter>,
 }
 
 impl TryFrom<&config::Main> for Recognition {
@@ -27,20 +27,20 @@ impl TryFrom<&config::Main> for Recognition {
                 .collect(),
             _ => vec![],
         };
-        let tool = semantic::tools::Builder::new()
+        let interpreter = semantic::interpreters::Builder::new()
             .compilers_to_recognize(compilers_to_include.as_slice())
             .compilers_to_exclude(compilers_to_exclude.as_slice())
             .build();
 
         Ok(Recognition {
-            tool: Box::new(tool),
+            interpreter: Box::new(interpreter),
         })
     }
 }
 
 impl Recognition {
     pub fn apply(&self, execution: Execution) -> Option<semantic::Meaning> {
-        match self.tool.recognize(&execution) {
+        match self.interpreter.recognize(&execution) {
             semantic::Recognition::Success(semantic::Meaning::Ignored) => {
                 log::debug!("execution recognized, but ignored: {:?}", execution);
                 None

rust/bear/src/semantic/tools/combinators.rs renamed to rust/bear/src/semantic/interpreters/combinators.rs

@@ -1,24 +1,26 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use super::super::{Meaning, Recognition, Tool};
+use super::super::{Interpreter, Meaning, Recognition};
 use intercept::Execution;
 
-/// Represents a set of tools, where any of them can recognize the semantic.
-/// The evaluation is done in the order of the tools. The first one which
+/// Represents a set of interpreters, where any of them can recognize the semantic.
+/// The evaluation is done in the order of the interpreters. The first one which
 /// recognizes the semantic will be returned as result.
 pub(super) struct Any {
-    tools: Vec<Box<dyn Tool>>,
+    interpreters: Vec<Box<dyn Interpreter>>,
 }
 
 impl Any {
-    pub(super) fn new(tools: Vec<Box<dyn Tool>>) -> impl Tool {
-        Any { tools }
+    pub(super) fn new(tools: Vec<Box<dyn Interpreter>>) -> impl Interpreter {
+        Any {
+            interpreters: tools,
+        }
     }
 }
 
-impl Tool for Any {
+impl Interpreter for Any {
     fn recognize(&self, x: &Execution) -> Recognition<Meaning> {
-        for tool in &self.tools {
+        for tool in &self.interpreters {
             match tool.recognize(x) {
                 Recognition::Unknown => continue,
                 result => return result,
@@ -39,7 +41,7 @@ mod test {
     #[test]
     fn test_any_when_no_match() {
         let sut = Any {
-            tools: vec![
+            interpreters: vec![
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::NotRecognize),
@@ -57,7 +59,7 @@ mod test {
     #[test]
     fn test_any_when_match() {
         let sut = Any {
-            tools: vec![
+            interpreters: vec![
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::Recognize),
                 Box::new(MockTool::NotRecognize),
@@ -75,7 +77,7 @@ mod test {
     #[test]
     fn test_any_when_match_fails() {
         let sut = Any {
-            tools: vec![
+            interpreters: vec![
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::RecognizeFailed),
                 Box::new(MockTool::Recognize),
@@ -97,7 +99,7 @@ mod test {
         NotRecognize,
     }
 
-    impl Tool for MockTool {
+    impl Interpreter for MockTool {
         fn recognize(&self, _: &Execution) -> Recognition<Meaning> {
             match self {
                 MockTool::Recognize => Recognition::Success(Meaning::Ignored),

rust/bear/src/semantic/tools/gcc.rs renamed to rust/bear/src/semantic/interpreters/gcc.rs

@@ -4,19 +4,19 @@ use nom::branch::alt;
 use nom::multi::many1;
 use nom::sequence::preceded;
 
-use super::super::{Meaning, Recognition, Tool};
+use super::super::{Interpreter, Meaning, Recognition};
 use intercept::Execution;
 use internal::Argument;
 
 pub(super) struct Gcc {}
 
 impl Gcc {
-    pub(super) fn new() -> Box<dyn Tool> {
+    pub(super) fn new() -> Box<dyn Interpreter> {
         Box::new(Gcc {})
     }
 }
 
-impl Tool for Gcc {
+impl Interpreter for Gcc {
     fn recognize(&self, execution: &Execution) -> Recognition<Meaning> {
         let mut parser = preceded(
             internal::compiler,

rust/bear/src/semantic/tools/generic.rs renamed to rust/bear/src/semantic/interpreters/generic.rs

@@ -4,7 +4,7 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 use std::vec;
 
-use super::super::{CompilerPass, Meaning, Recognition, Tool};
+use super::super::{CompilerPass, Interpreter, Meaning, Recognition};
 use super::matchers::source::looks_like_a_source_file;
 use intercept::Execution;
 
@@ -14,13 +14,13 @@ pub(super) struct Generic {
 }
 
 impl Generic {
-    pub(super) fn from(compilers: &[PathBuf]) -> Box<dyn Tool> {
+    pub(super) fn from(compilers: &[PathBuf]) -> Box<dyn Interpreter> {
         let executables = compilers.iter().map(|compiler| compiler.clone()).collect();
         Box::new(Self { executables })
     }
 }
 
-impl Tool for Generic {
+impl Interpreter for Generic {
     /// This tool is a naive implementation only considering:
     /// - the executable name,
     /// - one of the arguments is a source file,

rust/bear/src/semantic/tools/ignore.rs renamed to rust/bear/src/semantic/interpreters/ignore.rs

@@ -3,7 +3,7 @@
 use std::collections::HashSet;
 use std::path::PathBuf;
 
-use super::super::{Meaning, Recognition, Tool};
+use super::super::{Interpreter, Meaning, Recognition};
 use intercept::Execution;
 
 /// A tool to ignore a command execution by executable name.
@@ -12,19 +12,19 @@ pub(super) struct IgnoreByPath {
 }
 
 impl IgnoreByPath {
-    pub(super) fn new() -> Box<dyn Tool> {
+    pub(super) fn new() -> Box<dyn Interpreter> {
         let executables = COREUTILS_FILES.iter().map(PathBuf::from).collect();
         Box::new(Self { executables })
     }
 
-    pub(super) fn from(compilers: &[PathBuf]) -> Box<dyn Tool> {
+    pub(super) fn from(compilers: &[PathBuf]) -> Box<dyn Interpreter> {
         let executables = compilers.iter().map(|compiler| compiler.clone()).collect();
         Box::new(Self { executables })
     }
 }
 
 /// A tool to ignore a command execution by arguments.
-impl Tool for IgnoreByPath {
+impl Interpreter for IgnoreByPath {
     fn recognize(&self, execution: &Execution) -> Recognition<Meaning> {
         if self.executables.contains(&execution.executable) {
             Recognition::Success(Meaning::Ignored)

rust/bear/src/semantic/tools/matchers/mod.rs renamed to rust/bear/src/semantic/interpreters/matchers/mod.rs

@@ -2,10 +2,10 @@
 
 use std::path::PathBuf;
 
-use super::tools::combinators::Any;
-use super::tools::generic::Generic;
-use super::tools::ignore::IgnoreByPath;
-use super::Tool;
+use super::interpreters::combinators::Any;
+use super::interpreters::generic::Generic;
+use super::interpreters::ignore::IgnoreByPath;
+use super::Interpreter;
 
 mod combinators;
 mod gcc;
@@ -16,15 +16,15 @@ mod matchers;
 /// A builder for creating a tool which can recognize the semantic of a compiler,
 /// or ignore known non-compilers.
 pub struct Builder {
-    tools: Vec<Box<dyn Tool>>,
+    interpreters: Vec<Box<dyn Interpreter>>,
 }
 
 impl Builder {
     /// Creates a new builder with default settings.
     pub fn new() -> Self {
         // FIXME: replace generic with gcc, when it's implemented
         Builder {
-            tools: vec![
+            interpreters: vec![
                 // ignore executables which are not compilers,
                 IgnoreByPath::new(),
                 // recognize default compiler
@@ -34,26 +34,26 @@ impl Builder {
     }
 
     /// Factory method to create a new tool from the builder.
-    pub fn build(self) -> impl Tool {
-        Any::new(self.tools)
+    pub fn build(self) -> impl Interpreter {
+        Any::new(self.interpreters)
     }
 
-    /// Adds new tools to recognize as compilers by executable name.
+    /// Adds new interpreters to recognize as compilers by executable name.
     pub fn compilers_to_recognize(mut self, compilers: &[PathBuf]) -> Self {
         if !compilers.is_empty() {
-            // Add the new compilers at the end of the tools.
+            // Add the new compilers at the end of the interpreters.
             let tool = Generic::from(compilers);
-            self.tools.push(tool);
+            self.interpreters.push(tool);
         }
         self
     }
 
-    /// Adds new tools to recognize as non-compilers by executable names.
+    /// Adds new interpreters to recognize as non-compilers by executable names.
     pub fn compilers_to_exclude(mut self, compilers: &[PathBuf]) -> Self {
         if !compilers.is_empty() {
-            // Add these new compilers at the front of the tools.
+            // Add these new compilers at the front of the interpreters.
             let tool = IgnoreByPath::from(compilers);
-            self.tools.insert(0, tool);
+            self.interpreters.insert(0, tool);
         }
         self
     }

rust/bear/src/semantic/tools/matchers/source.rs renamed to rust/bear/src/semantic/interpreters/matchers/source.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pub mod tools;
+pub mod interpreters;
 
 use intercept::Execution;
 use std::path::PathBuf;
@@ -33,9 +33,9 @@ pub enum CompilerPass {
 ///
 /// A single tool has a potential to recognize a command execution and
 /// identify the semantic of that command. This abstraction is also can
-/// represent a set of tools, and the recognition process can be distributed
-/// amongst the tools.
-pub trait Tool: Send {
+/// represent a set of interpreters, and the recognition process can be
+/// distributed amongst the interpreters.
+pub trait Interpreter: Send {
     fn recognize(&self, _: &Execution) -> Recognition<Meaning>;
 }