rust: settle on function name for creating objects

Author: rizsotto

rust/bear/src/bin/bear.rs

@@ -49,15 +49,15 @@ impl Application {
         match args.mode {
             args::Mode::Intercept { input, output } => {
                 log::debug!("Mode: intercept");
-                Intercept::from(input, output, config).map(Application::Intercept)
+                Intercept::create(input, output, config).map(Application::Intercept)
             }
             args::Mode::Semantic { input, output } => {
                 log::debug!("Mode: semantic analysis");
-                Semantic::from(input, output, config).map(Application::Semantic)
+                Semantic::create(input, output, config).map(Application::Semantic)
             }
             args::Mode::Combined { input, output } => {
                 log::debug!("Mode: intercept and semantic analysis");
-                Combined::from(input, output, config).map(Application::Combined)
+                Combined::create(input, output, config).map(Application::Combined)
             }
         }
     }

rust/bear/src/intercept/mod.rs

@@ -123,12 +123,12 @@ impl CollectorService {
     ///
     /// The `consumer` is a function that receives the events and processes them.
     /// The function is executed in a separate thread.
-    pub fn new<F>(consumer: F) -> anyhow::Result<Self>
+    pub fn create<F>(consumer: F) -> anyhow::Result<Self>
     where
         F: FnOnce(Receiver<Event>) -> anyhow::Result<()>,
         F: Send + 'static,
     {
-        let collector = tcp::CollectorOnTcp::new()?;
+        let collector = tcp::CollectorOnTcp::create()?;
         let collector_arc = Arc::new(collector);
         let (sender, receiver) = channel();
 
@@ -202,7 +202,10 @@ impl InterceptEnvironment {
     /// The `config` is the intercept configuration that specifies the mode and the
     /// required parameters for the mode. The `collector` is the service to collect
     /// the execution events.
-    pub fn new(config: &config::Intercept, collector: &CollectorService) -> anyhow::Result<Self> {
+    pub fn create(
+        config: &config::Intercept,
+        collector: &CollectorService,
+    ) -> anyhow::Result<Self> {
         // Validate the configuration.
         let valid_config = config.validate()?;
 

rust/bear/src/intercept/tcp.rs

@@ -56,7 +56,7 @@ impl CollectorOnTcp {
     ///
     /// The collector listens to a random port on the loopback interface.
     /// The address of the collector can be obtained by the `address` method.
-    pub fn new() -> Result<Self, anyhow::Error> {
+    pub fn create() -> Result<Self, anyhow::Error> {
         let shutdown = Arc::new(AtomicBool::new(false));
         let listener = TcpListener::bind("127.0.0.1:0")?;
         let address = listener.local_addr()?;
@@ -191,7 +191,7 @@ mod tests {
     // if they are the same as the original events.
     #[test]
     fn tcp_reporter_and_collectors_work() {
-        let collector = CollectorOnTcp::new().unwrap();
+        let collector = CollectorOnTcp::create().unwrap();
         let reporter = ReporterOnTcp::new(collector.address()).unwrap();
 
         // Create wrapper to share the collector across threads.

rust/bear/src/modes/intercept.rs

@@ -17,15 +17,15 @@ pub(super) struct BuildInterceptor {
 
 impl BuildInterceptor {
     /// Create a new process execution interceptor.
-    pub(super) fn new<F>(config: config::Main, consumer: F) -> anyhow::Result<Self>
+    pub(super) fn create<F>(config: config::Main, consumer: F) -> anyhow::Result<Self>
     where
         F: FnOnce(Receiver<Event>) -> anyhow::Result<()>,
         F: Send + 'static,
     {
-        let service = CollectorService::new(consumer)
+        let service = CollectorService::create(consumer)
             .with_context(|| "Failed to create the intercept service")?;
 
-        let environment = InterceptEnvironment::new(&config.intercept, &service)
+        let environment = InterceptEnvironment::create(&config.intercept, &service)
             .with_context(|| "Failed to create the intercept environment")?;
 
         Ok(Self {

rust/bear/src/modes/mod.rs

@@ -3,7 +3,7 @@
 pub mod intercept;
 pub mod semantic;
 
-use crate::intercept::persistence::{read, write};
+use crate::intercept::persistence;
 use crate::modes::intercept::BuildInterceptor;
 use crate::modes::semantic::SemanticAnalysisPipeline;
 use crate::{args, config};
@@ -27,7 +27,7 @@ pub struct Intercept {
 
 impl Intercept {
     /// Create a new intercept mode instance.
-    pub fn from(
+    pub fn create(
         command: args::BuildCommand,
         output: args::BuildEvents,
         config: config::Main,
@@ -41,8 +41,9 @@ impl Intercept {
             .map(io::BufWriter::new)
             .with_context(|| format!("Failed to open file: {:?}", file_name))?;
 
-        let interceptor =
-            BuildInterceptor::new(config, move |envelopes| write(output_file, envelopes))?;
+        let interceptor = BuildInterceptor::create(config, move |events| {
+            persistence::write(output_file, events)
+        })?;
 
         Ok(Self {
             command,
@@ -70,7 +71,7 @@ pub struct Semantic {
 }
 
 impl Semantic {
-    pub fn from(
+    pub fn create(
         input: args::BuildEvents,
         output: args::BuildSemantic,
         config: config::Main,
@@ -82,7 +83,7 @@ impl Semantic {
             .map(BufReader::new)
             .with_context(|| format!("Failed to open file: {:?}", file_name))?;
 
-        let semantic = SemanticAnalysisPipeline::from(output, &config)?;
+        let semantic = SemanticAnalysisPipeline::create(output, &config)?;
 
         Ok(Self {
             event_file,
@@ -97,7 +98,7 @@ impl Mode for Semantic {
     /// The exit code is based on the result of the output writer.
     fn run(self) -> anyhow::Result<ExitCode> {
         self.semantic
-            .analyze_and_write(read(self.event_file))
+            .analyze_and_write(persistence::read(self.event_file))
             .map(|_| ExitCode::SUCCESS)
     }
 }
@@ -110,15 +111,14 @@ pub struct Combined {
 
 impl Combined {
     /// Create a new all mode instance.
-    pub fn from(
+    pub fn create(
         command: args::BuildCommand,
         output: args::BuildSemantic,
         config: config::Main,
     ) -> anyhow::Result<Self> {
-        let semantic = SemanticAnalysisPipeline::from(output, &config)?;
-        let interceptor = BuildInterceptor::new(config, move |envelopes| {
-            semantic.analyze_and_write(envelopes)
-        })?;
+        let semantic = SemanticAnalysisPipeline::create(output, &config)?;
+        let interceptor =
+            BuildInterceptor::create(config, move |events| semantic.analyze_and_write(events))?;
 
         Ok(Self {
             command,

rust/bear/src/modes/semantic.rs

@@ -2,7 +2,7 @@
 
 use crate::intercept::Event;
 use crate::output::OutputWriter;
-use crate::semantic::interpreters::create_interpreter;
+use crate::semantic::interpreters;
 use crate::semantic::transformation;
 use crate::semantic::transformation::FilterAndFormat;
 use crate::{args, config, output, semantic};
@@ -20,8 +20,11 @@ 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 = create_interpreter(config);
+    pub(super) fn create(
+        output: args::BuildSemantic,
+        config: &config::Main,
+    ) -> anyhow::Result<Self> {
+        let interpreter = interpreters::create(config);
         let transformation = FilterAndFormat::try_from(&config.output)?;
         let output_writer = OutputWriterImpl::create(&output, &config.output)?;
 
@@ -136,7 +139,7 @@ impl OutputWriter for ClangOutputWriter {
         let entries = semantics.flat_map(|semantic| self.formatter.apply(semantic));
         if self.append && self.output.exists() {
             let entries_from_db = Self::read_from_compilation_db(self.output.as_path())?;
-            let final_entries = entries.chain(entries_from_db);
+            let final_entries = entries_from_db.chain(entries);
             self.write_into_compilation_db(final_entries)
         } else {
             if self.append {

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

@@ -21,7 +21,7 @@ mod matchers;
 //       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 {
+pub fn create<'a>(config: &config::Main) -> impl Interpreter + 'a {
     let compilers_to_include = match &config.intercept {
         config::Intercept::Wrapper { executables, .. } => executables.clone(),
         _ => vec![],
@@ -79,7 +79,7 @@ mod test {
     fn test_create_interpreter_with_default_config() {
         let config = config::Main::default();
 
-        let interpreter = create_interpreter(&config);
+        let interpreter = create(&config);
         let input = any_execution();
 
         match interpreter.recognize(&input) {
@@ -99,7 +99,7 @@ mod test {
             ..Default::default()
         };
 
-        let interpreter = create_interpreter(&config);
+        let interpreter = create(&config);
         let input = any_execution();
 
         match interpreter.recognize(&input) {
@@ -124,7 +124,7 @@ mod test {
             ..Default::default()
         };
 
-        let interpreter = create_interpreter(&config);
+        let interpreter = create(&config);
         let input = any_execution();
 
         let result = interpreter.recognize(&input);