rust: compiler recoginze ignore is verbose about the reason

Author: rizsotto

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

@@ -86,7 +86,7 @@ mod test {
         let input = any_execution();
 
         match sut.recognize(&input) {
-            Recognition::Ignored => assert!(true),
+            Recognition::Ignored(_) => assert!(true),
             _ => assert!(false),
         }
     }
@@ -121,8 +121,8 @@ mod test {
         fn recognize(&self, _: &Execution) -> Recognition<CompilerCall> {
             match self {
                 MockTool::Recognize => Recognition::Success(any_compiler_call()),
-                MockTool::RecognizeIgnored => Recognition::Ignored,
-                MockTool::RecognizeFailed => Recognition::Error(String::from("problem")),
+                MockTool::RecognizeIgnored => Recognition::Ignored("reason".into()),
+                MockTool::RecognizeFailed => Recognition::Error("problem".into()),
                 MockTool::NotRecognize => Recognition::Unknown,
             }
         }

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

@@ -5,20 +5,30 @@ use std::path::PathBuf;
 
 use super::super::{CompilerCall, Execution, Interpreter, Recognition};
 
+const COREUTILS_MESSAGE: &str = "coreutils executable";
+const COMPILER_MESSAGE: &str = "compiler specified in config to ignore";
+
 /// A tool to ignore a command execution by executable name.
 pub(super) struct IgnoreByPath {
     executables: HashSet<PathBuf>,
+    reason: String,
 }
 
 impl IgnoreByPath {
     pub(super) fn new() -> Self {
         let executables = COREUTILS_FILES.iter().map(PathBuf::from).collect();
-        Self { executables }
+        Self {
+            executables,
+            reason: COREUTILS_MESSAGE.into(),
+        }
     }
 
     pub(super) fn from(compilers: &[PathBuf]) -> Self {
         let executables = compilers.iter().cloned().collect();
-        Self { executables }
+        Self {
+            executables,
+            reason: COMPILER_MESSAGE.into(),
+        }
     }
 }
 
@@ -32,7 +42,7 @@ impl Default for IgnoreByPath {
 impl Interpreter for IgnoreByPath {
     fn recognize(&self, execution: &Execution) -> Recognition<CompilerCall> {
         if self.executables.contains(&execution.executable) {
-            Recognition::Ignored
+            Recognition::Ignored(self.reason.clone())
         } else {
             Recognition::Unknown
         }
@@ -166,8 +176,9 @@ mod test {
             environment: HashMap::new(),
         };
         let sut = IgnoreByPath::new();
+        let result = sut.recognize(&input);
 
-        assert_eq!(Recognition::Ignored, sut.recognize(&input))
+        assert!(matches!(result, Recognition::Ignored(_)));
     }
 
     #[test]

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

@@ -127,9 +127,11 @@ mod test {
         let interpreter = create_interpreter(&config);
         let input = any_execution();
 
-        match interpreter.recognize(&input) {
-            Recognition::Ignored => assert!(true),
-            _ => assert!(false),
-        }
+        let result = interpreter.recognize(&input);
+
+        assert_eq!(
+            result,
+            Recognition::Ignored("compiler specified in config to ignore".into())
+        );
     }
 }

rust/bear/src/semantic/mod.rs

@@ -89,7 +89,7 @@ pub enum Recognition<T> {
     /// The command was recognized and the semantic was identified.
     Success(T),
     /// The command was recognized, but the semantic was ignored.
-    Ignored,
+    Ignored(String),
     /// The command was recognized, but the semantic was broken.
     Error(String),
     /// The command was not recognized.