rust: prepare semantic package to be a module in bear

rizsotto · Oct 6, 2024 · 4452195 · 4452195
1 parent 5475e2f
commit 4452195
Show file tree

Hide file tree

Showing 10 changed files with 279 additions and 259 deletions.
diff --git a/rust/semantic/src/fixtures.rs b/rust/semantic/src/fixtures.rs
@@ -1,4 +1,3 @@
-
 #[cfg(test)]
 mod fixtures {
     #[macro_export]

diff --git a/rust/semantic/src/lib.rs b/rust/semantic/src/lib.rs
@@ -17,11 +17,11 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-pub mod tools;
 mod fixtures;
+pub mod tools;
 
-use std::path::PathBuf;
 use intercept::ipc::Execution;
+use std::path::PathBuf;
 
 /// Represents a semantic recognition result.
 #[derive(Debug, PartialEq)]

diff --git a/rust/semantic/src/tools.rs b/rust/semantic/src/tools.rs
@@ -19,20 +19,19 @@
 
 use std::path::PathBuf;
 
+use super::tools::configured::Configured;
+use super::tools::ignore::{IgnoreByArgs, IgnoreByPath};
+use super::tools::unix::Unix;
+use super::tools::wrapper::Wrapper;
+use super::{Meaning, RecognitionResult, Tool};
 use intercept::ipc::Execution;
-use crate::{RecognitionResult, Meaning, Tool};
-use crate::tools::configured::Configured;
-use crate::tools::ignore::{IgnoreByArgs, IgnoreByPath};
-use crate::tools::unix::Unix;
-use crate::tools::wrapper::Wrapper;
 
 mod configured;
-mod wrapper;
-mod matchers;
-mod unix;
 mod gcc;
 mod ignore;
-
+mod matchers;
+mod unix;
+mod wrapper;
 
 pub struct Builder {
     tools: Vec<Box<dyn Tool>>,
@@ -41,7 +40,9 @@ pub struct Builder {
 // TODO: write unit test for this!!!
 impl Builder {
     pub fn new() -> Self {
-        Builder { tools: vec![Unix::new(), Wrapper::new()] }
+        Builder {
+            tools: vec![Unix::new(), Wrapper::new()],
+        }
     }
 
     pub fn build(self) -> impl Tool {
@@ -78,7 +79,6 @@ impl Builder {
     }
 }
 
-
 struct Any {
     tools: Vec<Box<dyn Tool>>,
 }
@@ -94,8 +94,9 @@ impl Tool for Any {
     fn recognize(&self, x: &Execution) -> RecognitionResult {
         for tool in &self.tools {
             match tool.recognize(x) {
-                RecognitionResult::Recognized(result) =>
-                    return RecognitionResult::Recognized(result),
+                RecognitionResult::Recognized(result) => {
+                    return RecognitionResult::Recognized(result)
+                }
                 _ => continue,
             }
         }
@@ -119,7 +120,7 @@ mod test {
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::NotRecognize),
-            ]
+            ],
         };
 
         let input = any_execution();
@@ -137,14 +138,14 @@ mod test {
                 Box::new(MockTool::NotRecognize),
                 Box::new(MockTool::Recognize),
                 Box::new(MockTool::NotRecognize),
-            ]
+            ],
         };
 
         let input = any_execution();
 
         match sut.recognize(&input) {
             RecognitionResult::Recognized(Ok(_)) => assert!(true),
-            _ => assert!(false)
+            _ => assert!(false),
         }
     }
 
@@ -156,7 +157,7 @@ mod test {
                 Box::new(MockTool::RecognizeFailed),
                 Box::new(MockTool::Recognize),
                 Box::new(MockTool::NotRecognize),
-            ]
+            ],
         };
 
         let input = any_execution();
@@ -176,12 +177,11 @@ mod test {
     impl Tool for MockTool {
         fn recognize(&self, _: &Execution) -> RecognitionResult {
             match self {
-                MockTool::Recognize =>
-                    RecognitionResult::Recognized(Ok(Meaning::Ignored)),
-                MockTool::RecognizeFailed =>
-                    RecognitionResult::Recognized(Err(String::from("problem"))),
-                MockTool::NotRecognize =>
-                    RecognitionResult::NotRecognized,
+                MockTool::Recognize => RecognitionResult::Recognized(Ok(Meaning::Ignored)),
+                MockTool::RecognizeFailed => {
+                    RecognitionResult::Recognized(Err(String::from("problem")))
+                }
+                MockTool::NotRecognize => RecognitionResult::NotRecognized,
             }
         }
     }

diff --git a/rust/semantic/src/tools/configured.rs b/rust/semantic/src/tools/configured.rs
@@ -20,18 +20,19 @@
 use std::path::{Path, PathBuf};
 use std::vec;
 
+use super::super::{CompilerPass, Meaning, RecognitionResult, Tool};
+use super::matchers::source::looks_like_a_source_file;
 use intercept::ipc::Execution;
-use crate::{RecognitionResult, CompilerPass, Meaning, Tool};
-use crate::tools::matchers::source::looks_like_a_source_file;
-use crate::tools::RecognitionResult::{NotRecognized, Recognized};
 
 pub struct Configured {
     pub executable: PathBuf,
 }
 
 impl Configured {
     pub fn new(compiler: &Path) -> Box<dyn Tool> {
-        Box::new(Self { executable: compiler.to_path_buf() })
+        Box::new(Self {
+            executable: compiler.to_path_buf(),
+        })
     }
 }
 
@@ -52,28 +53,23 @@ impl Tool for Configured {
             }
 
             if sources.is_empty() {
-                Recognized(Err(String::from("source file is not found")))
+                RecognitionResult::Recognized(Err(String::from("source file is not found")))
             } else {
-                Recognized(
-                    Ok(
-                        Meaning::Compiler {
-                            compiler: x.executable.clone(),
-                            working_dir: x.working_dir.clone(),
-                            passes: sources.iter()
-                                .map(|source| {
-                                    CompilerPass::Compile {
-                                        source: source.clone(),
-                                        output: None,
-                                        flags: flags.clone(),
-                                    }
-                                })
-                                .collect(),
-                        }
-                    )
-                )
+                RecognitionResult::Recognized(Ok(Meaning::Compiler {
+                    compiler: x.executable.clone(),
+                    working_dir: x.working_dir.clone(),
+                    passes: sources
+                        .iter()
+                        .map(|source| CompilerPass::Compile {
+                            source: source.clone(),
+                            output: None,
+                            flags: flags.clone(),
+                        })
+                        .collect(),
+                }))
             }
         } else {
-            NotRecognized
+            RecognitionResult::NotRecognized
         }
     }
 }
@@ -92,24 +88,32 @@ mod test {
     fn test_matching() {
         let input = Execution {
             executable: PathBuf::from("/usr/bin/something"),
-            arguments: vec_of_strings!["something", "-Dthis=that", "-I.", "source.c", "-o", "source.c.o"],
+            arguments: vec_of_strings![
+                "something",
+                "-Dthis=that",
+                "-I.",
+                "source.c",
+                "-o",
+                "source.c.o"
+            ],
             working_dir: PathBuf::from("/home/user"),
             environment: HashMap::new(),
         };
 
         let expected = Meaning::Compiler {
             compiler: PathBuf::from("/usr/bin/something"),
             working_dir: PathBuf::from("/home/user"),
-            passes: vec![
-                CompilerPass::Compile {
-                    flags: vec_of_strings!["-Dthis=that", "-I.", "-o", "source.c.o"],
-                    source: PathBuf::from("source.c"),
-                    output: None,
-                }
-            ],
+            passes: vec![CompilerPass::Compile {
+                flags: vec_of_strings!["-Dthis=that", "-I.", "-o", "source.c.o"],
+                source: PathBuf::from("source.c"),
+                output: None,
+            }],
         };
 
-        assert_eq!(Recognized(Ok(expected)), SUT.recognize(&input));
+        assert_eq!(
+            RecognitionResult::Recognized(Ok(expected)),
+            SUT.recognize(&input)
+        );
     }
 
     #[test]
@@ -121,7 +125,10 @@ mod test {
             environment: HashMap::new(),
         };
 
-        assert_eq!(Recognized(Err(String::from("source file is not found"))), SUT.recognize(&input));
+        assert_eq!(
+            RecognitionResult::Recognized(Err(String::from("source file is not found"))),
+            SUT.recognize(&input)
+        );
     }
 
     #[test]
@@ -133,7 +140,7 @@ mod test {
             environment: HashMap::new(),
         };
 
-        assert_eq!(NotRecognized, SUT.recognize(&input));
+        assert_eq!(RecognitionResult::NotRecognized, SUT.recognize(&input));
     }
 
     lazy_static! {