rust: semantic transformation implements path transformation based on config

rizsotto · rizsotto · commit 603642eaea90 · 2025-04-18T12:52:01.000+10:00
diff --git a/rust/bear/src/config.rs b/rust/bear/src/config.rs
@@ -35,9 +35,9 @@
 //!   specification: clang
 //!   compilers:
 //!     - path: /usr/local/bin/cc
-//!       ignore: always
-//!     - path: /usr/bin/cc
 //!       ignore: never
+//!     - path: /usr/bin/cc
+//!       ignore: always
 //!     - path: /usr/bin/c++
 //!       ignore: conditional
 //!       arguments:
@@ -67,8 +67,9 @@
 //!       - directory
 //!   format:
 //!     paths:
-//!       resolver: original
-//!       relative: false
+//!       directory: canonical
+//!       file: canonical
+//!       output: canonical
 //! ```
 //!
 //! ```yaml
@@ -318,23 +319,17 @@ pub struct Compiler {
 /// - Always: Always ignore the compiler call.
 /// - Never: Never ignore the compiler call. (Default)
 /// - Conditional: Ignore the compiler call if the arguments match.
-#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
 pub enum IgnoreOrConsider {
     #[serde(rename = "always", alias = "true")]
     Always,
+    #[default]
     #[serde(rename = "never", alias = "false")]
     Never,
     #[serde(rename = "conditional")]
     Conditional,
 }
 
-/// The default ignore mode is never ignore.
-impl Default for IgnoreOrConsider {
-    fn default() -> Self {
-        IgnoreOrConsider::Never
-    }
-}
-
 /// Argument lists to match, add or remove.
 ///
 /// The `match` field is used to specify the arguments to match. Can be used only with the
@@ -415,37 +410,44 @@ pub enum OutputFields {
 /// Format configuration of the JSON compilation database.
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
 pub struct Format {
+    #[serde(default)]
     pub paths: PathFormat,
 }
 
 /// Format configuration of paths in the JSON compilation database.
 #[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
 pub struct PathFormat {
     #[serde(default)]
-    pub resolver: PathResolver,
-    #[serde(default = "default_disabled")]
-    pub relative: bool,
+    pub directory: DirectoryPathResolver,
+    #[serde(default)]
+    pub file: FilePathResolver,
+    #[serde(default)]
+    pub output: FilePathResolver,
 }
 
-/// Path resolver configuration.
-#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
-pub enum PathResolver {
-    /// The original path is the path as it is passed to the compiler.
-    #[serde(rename = "original", alias = "is")]
-    Original,
-    /// The absolute path from the original path. Symlinks are not resolved.
-    #[serde(rename = "absolute")]
-    Absolute,
-    /// The canonical path is the absolute path with the symlinks resolved.
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
+pub enum DirectoryPathResolver {
+    /// The directory path will be resolved to the canonical path. (Default)
+    #[default]
     #[serde(rename = "canonical")]
     Canonical,
+    /// The directory path will be resolved to the relative path to the current working directory.
+    #[serde(rename = "relative_to_cwd")]
+    RelativeToCwd,
 }
 
-/// The default path format is the original path.
-impl Default for PathResolver {
-    fn default() -> Self {
-        PathResolver::Original
-    }
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
+pub enum FilePathResolver {
+    /// The directory path will be resolved to the canonical path. (Default)
+    #[default]
+    #[serde(rename = "canonical")]
+    Canonical,
+    /// The directory path will be resolved to the relative path to the directory attribute.
+    #[serde(rename = "relative_to_directory")]
+    RelativeToDirectory,
+    /// The directory path will be resolved to the relative path to the current working directory.
+    #[serde(rename = "relative_to_cwd")]
+    RelativeToCwd,
 }
 
 fn default_disabled() -> bool {
@@ -538,8 +540,9 @@ mod test {
               - directory
           format:
             paths:
-              resolver: canonical
-              relative: false
+              directory: canonical
+              file: canonical
+              output: canonical
         "#;
 
         let result = Main::from_reader(content).unwrap();
@@ -611,8 +614,9 @@ mod test {
                 },
                 format: Format {
                     paths: PathFormat {
-                        resolver: PathResolver::Canonical,
-                        relative: false,
+                        directory: DirectoryPathResolver::Canonical,
+                        file: FilePathResolver::Canonical,
+                        output: FilePathResolver::Canonical,
                     },
                 },
             },
@@ -661,8 +665,9 @@ mod test {
                 },
                 format: Format {
                     paths: PathFormat {
-                        resolver: PathResolver::Original,
-                        relative: false,
+                        directory: DirectoryPathResolver::Canonical,
+                        file: FilePathResolver::Canonical,
+                        output: FilePathResolver::Canonical,
                     },
                 },
             },
@@ -720,8 +725,9 @@ mod test {
               - file
           format:
             paths:
-              resolver: canonical
-              relative: true
+              directory: relative_to_cwd
+              file: relative_to_directory
+              output: relative_to_directory
         "#;
 
         let result = Main::from_reader(content).unwrap();
@@ -762,8 +768,9 @@ mod test {
                 },
                 format: Format {
                     paths: PathFormat {
-                        resolver: PathResolver::Canonical,
-                        relative: true,
+                        directory: DirectoryPathResolver::RelativeToCwd,
+                        file: FilePathResolver::RelativeToDirectory,
+                        output: FilePathResolver::RelativeToCwd,
                     },
                 },
             },
diff --git a/rust/bear/src/modes/semantic.rs b/rust/bear/src/modes/semantic.rs
@@ -3,7 +3,7 @@
 use crate::intercept::Envelope;
 use crate::output::OutputWriter;
 use crate::semantic::interpreters::create_interpreter;
-use crate::semantic::transformation::Transformation;
+use crate::semantic::transformation::create_transformation;
 use crate::{args, config, output, semantic};
 use anyhow::Context;
 use std::fs::{File, OpenOptions};
@@ -13,20 +13,20 @@ use std::path::{Path, PathBuf};
 /// The semantic analysis that is independent of the event source.
 pub(super) struct SemanticAnalysisPipeline {
     interpreter: Box<dyn semantic::Interpreter>,
-    transform: Box<dyn semantic::Transform>,
+    transformation: Box<dyn semantic::Transformation>,
     output_writer: OutputWriterImpl,
 }
 
 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);
-        let transform = Transformation::from(&config.output);
+        let transformation = create_transformation(&config.output)?;
         let output_writer = OutputWriterImpl::create(&output, &config.output)?;
 
         Ok(Self {
             interpreter: Box::new(interpreter),
-            transform: Box::new(transform),
+            transformation,
             output_writer,
         })
     }
@@ -44,7 +44,7 @@ impl SemanticAnalysisPipeline {
             .map(|envelope| envelope.event.execution)
             .flat_map(|execution| self.interpreter.recognize(&execution))
             .inspect(|semantic| log::debug!("semantic: {:?}", semantic))
-            .flat_map(|semantic| self.transform.apply(semantic));
+            .flat_map(|semantic| self.transformation.apply(semantic));
         // Consume the entries and write them to the output file.
         // The exit code is based on the result of the output writer.
         self.output_writer.run(entries)
diff --git a/rust/bear/src/semantic/mod.rs b/rust/bear/src/semantic/mod.rs
@@ -84,7 +84,7 @@ impl<T> IntoIterator for Recognition<T> {
 /// It conditionally removes compiler calls based on compiler names or flags.
 /// It can also alter the compiler flags of the compiler calls. The actions
 /// are defined in the configuration this module is given.
-pub trait Transform: Send {
+pub trait Transformation: Send {
     fn apply(&self, _: CompilerCall) -> Option<CompilerCall>;
 }
 
diff --git a/rust/bear/src/semantic/transformation.rs b/rust/bear/src/semantic/transformation.rs

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ impl<T> IntoIterator for Recognition<T> {`
`84`	`84`	`/// It conditionally removes compiler calls based on compiler names or flags.`
`85`	`85`	`/// It can also alter the compiler flags of the compiler calls. The actions`
`86`	`86`	`/// are defined in the configuration this module is given.`
`87`		`-pub trait Transform: Send {`
	`87`	`+pub trait Transformation: Send {`
`88`	`88`	`fn apply(&self, _: CompilerCall) -> Option<CompilerCall>;`
`89`	`89`	`}`
`90`	`90`