rust: intercept is part of bear

Author: rizsotto

rust/Cargo.toml

@@ -2,8 +2,7 @@
 
 [workspace]
 members = [
-  "bear",
-  "intercept"
+  "bear"
 ]
 resolver = "2"
 

rust/bear/Cargo.toml

@@ -17,10 +17,13 @@ path = "src/lib.rs"
 
 [[bin]]
 name = "bear"
-path = "src/bin/main.rs"
+path = "src/bin/bear.rs"
+
+[[bin]]
+name = "wrapper"
+path = "src/bin/wrapper.rs"
 
 [dependencies]
-intercept = { path = "../intercept" }
 thiserror.workspace = true
 anyhow.workspace = true
 lazy_static.workspace = true
@@ -36,3 +39,6 @@ path-absolutize.workspace = true
 shell-words.workspace = true
 nom.workspace = true
 regex.workspace = true
+crossbeam.workspace = true
+crossbeam-channel.workspace = true
+rand.workspace = true

rust/bear/src/bin/main.rs renamed to rust/bear/src/bin/bear.rs

@@ -18,8 +18,8 @@
 extern crate core;
 
 use anyhow::{Context, Result};
-use intercept::reporter::{Reporter, TcpReporter};
-use intercept::KEY_DESTINATION;
+use bear::intercept::reporter::{Reporter, TcpReporter};
+use bear::intercept::{Event, Execution, ProcessId, KEY_DESTINATION};
 use std::path::{Path, PathBuf};
 
 /// Implementation of the wrapper process.
@@ -98,9 +98,9 @@ fn next_in_path(target: &Path) -> Result<PathBuf> {
         .ok_or_else(|| anyhow::anyhow!("Cannot find the real executable"))
 }
 
-fn report(execution: intercept::Execution) -> Result<()> {
-    let event = intercept::Event {
-        pid: intercept::ProcessId(std::process::id() as u32),
+fn report(execution: Execution) -> Result<()> {
+    let event = Event {
+        pid: ProcessId(std::process::id() as u32),
         execution,
     };
 
@@ -115,10 +115,10 @@ fn report(execution: intercept::Execution) -> Result<()> {
         .with_context(|| "Sending execution failed")
 }
 
-fn into_execution(path_buf: &Path) -> Result<intercept::Execution> {
+fn into_execution(path_buf: &Path) -> Result<Execution> {
     std::env::current_dir()
         .with_context(|| "Cannot get current directory")
-        .map(|working_dir| intercept::Execution {
+        .map(|working_dir| Execution {
             executable: path_buf.to_path_buf(),
             // FIXME: substitute the executable name on the first position
             arguments: std::env::args().collect(),

rust/intercept/src/bin/wrapper.rs renamed to rust/bear/src/bin/wrapper.rs

@@ -8,7 +8,7 @@ use std::io::BufReader;
 use std::path::PathBuf;
 
 use super::args;
-use intercept::Execution;
+use super::intercept::Execution;
 
 /// Responsible for reading the build events from the intercept mode.
 ///

rust/bear/src/input.rs

@@ -4,6 +4,7 @@ pub mod args;
 pub mod config;
 mod fixtures;
 pub mod input;
+pub mod intercept;
 pub mod output;
 pub mod recognition;
 pub mod semantic;

rust/intercept/src/collector.rs renamed to rust/bear/src/intercept/collector.rs

@@ -5,8 +5,7 @@
 //! The recognition logic is implemented in the `interpreters` module.
 //! Here we only handle the errors and logging them to the console.
 
-use super::{config, semantic};
-use intercept::Execution;
+use super::{config, intercept, semantic};
 use std::convert::TryFrom;
 
 pub struct Recognition {
@@ -51,7 +50,7 @@ impl TryFrom<&config::Main> for Recognition {
 impl Recognition {
     /// Simple call the semantic module to recognize the execution.
     /// Forward only the compiler calls, and log each recognition result.
-    pub fn apply(&self, execution: Execution) -> Option<semantic::CompilerCall> {
+    pub fn apply(&self, execution: intercept::Execution) -> Option<semantic::CompilerCall> {
         match self.interpreter.recognize(&execution) {
             semantic::Recognition::Success(semantic) => {
                 log::debug!(