entry format config is tuneable

rizsotto · rizsotto · commit 995a1cad1efc · 2025-06-23T21:43:25.000+10:00
diff --git a/bear/src/config.rs b/bear/src/config.rs
@@ -66,6 +66,9 @@
 //!       directory: canonical
 //!       file: canonical
 //!       output: canonical
+//!     entry:
+//!       command_as_array: true
+//!       keep_output_field: true
 //! ```
 //!
 //! ```yaml
@@ -334,6 +337,8 @@ mod types {
     pub struct Format {
         #[serde(default)]
         pub paths: PathFormat,
+        #[serde(default)]
+        pub entry: EntryFormat,
     }
 
     /// Format configuration of paths in the JSON compilation database.
@@ -358,6 +363,24 @@ mod types {
         Relative,
     }
 
+    /// Configuration for formatting output entries.
+    #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+    pub struct EntryFormat {
+        #[serde(default = "default_enabled")]
+        pub command_field_as_array: bool,
+        #[serde(default = "default_enabled")]
+        pub keep_output_field: bool,
+    }
+
+    impl Default for EntryFormat {
+        fn default() -> Self {
+            Self {
+                command_field_as_array: true,
+                keep_output_field: true,
+            }
+        }
+    }
+
     pub(super) const SUPPORTED_SCHEMA_VERSION: &str = "4.0";
     const PRELOAD_LIBRARY_PATH: &str = env!("PRELOAD_LIBRARY_PATH");
     const WRAPPER_EXECUTABLE_PATH: &str = env!("WRAPPER_EXECUTABLE_PATH");
@@ -382,14 +405,14 @@ mod types {
     }
 
     // Custom deserialization function to validate the schema version
-    fn validate_schema_version<'de, D>(deserializer: D) -> std::result::Result<String, D::Error>
+    fn validate_schema_version<'de, D>(deserializer: D) -> Result<String, D::Error>
     where
         D: serde::Deserializer<'de>,
     {
         let schema: String = Deserialize::deserialize(deserializer)?;
         if schema != SUPPORTED_SCHEMA_VERSION {
             use serde::de::Error;
-            Err(D::Error::custom(format!(
+            Err(Error::custom(format!(
                 "Unsupported schema version: {}. Expected: {}",
                 schema, SUPPORTED_SCHEMA_VERSION
             )))
@@ -624,6 +647,10 @@ pub mod loader {
                             file: PathResolver::Canonical,
                             output: PathResolver::Canonical,
                         },
+                        entry: EntryFormat {
+                            command_field_as_array: true,
+                            keep_output_field: true,
+                        },
                     },
                 },
                 schema: String::from("4.0"),
@@ -678,6 +705,10 @@ pub mod loader {
                             file: PathResolver::Canonical,
                             output: PathResolver::Canonical,
                         },
+                        entry: EntryFormat {
+                            command_field_as_array: true,
+                            keep_output_field: true,
+                        },
                     },
                 },
                 schema: String::from("4.0"),
@@ -737,6 +768,9 @@ pub mod loader {
               directory: relative
               file: relative
               output: relative
+            entry:
+              command_field_as_array: false
+              keep_output_field: false
         "#;
 
             let result = Loader::from_reader(content).unwrap();
@@ -781,6 +815,10 @@ pub mod loader {
                             file: PathResolver::Relative,
                             output: PathResolver::Relative,
                         },
+                        entry: EntryFormat {
+                            command_field_as_array: false,
+                            keep_output_field: false,
+                        },
                     },
                 },
                 schema: String::from("4.0"),
diff --git a/bear/src/output/mod.rs b/bear/src/output/mod.rs
@@ -48,7 +48,9 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
     fn try_from(value: (&args::BuildSemantic, &config::Output)) -> Result<Self, Self::Error> {
         let (args, config) = value;
         match config {
-            config::Output::Clang { duplicates, .. } => {
+            config::Output::Clang {
+                duplicates, format, ..
+            } => {
                 let final_file_name = path::Path::new(&args.file_name);
                 let temp_file_name = final_file_name.with_extension("tmp");
 
@@ -58,7 +60,8 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
                     AtomicClangOutputWriter::new(unique_writer, &temp_file_name, final_file_name);
                 let append_writer =
                     AppendClangOutputWriter::new(atomic_writer, args.append, final_file_name);
-                let formatted_writer = ConverterClangOutputWriter::new(append_writer);
+                let formatted_writer =
+                    ConverterClangOutputWriter::new(append_writer, &format.entry);
 
                 Ok(Self::Clang(formatted_writer))
             }
diff --git a/bear/src/output/writers.rs b/bear/src/output/writers.rs
@@ -2,7 +2,7 @@
 
 use super::formats::{FileFormat, JsonCompilationDatabase, JsonSemanticDatabase};
 use crate::semantic::clang::{DuplicateEntryFilter, Entry};
-use crate::semantic::{FormatConfig, Formattable};
+use crate::semantic::Formattable;
 use crate::{config, semantic};
 use anyhow::Context;
 use std::{fs, io, path};
@@ -49,14 +49,16 @@ impl IteratorWriter<semantic::Command> for SemanticOutputWriter {
 
 /// Formats `semantic::CompilerCall` instances into `Entry` objects.
 pub(super) struct ConverterClangOutputWriter<T: IteratorWriter<Entry>> {
-    format: FormatConfig,
+    format: config::EntryFormat,
     writer: T,
 }
 
 impl<T: IteratorWriter<Entry>> ConverterClangOutputWriter<T> {
-    pub(super) fn new(writer: T) -> Self {
-        let format = FormatConfig::default();
-        Self { format, writer }
+    pub(super) fn new(writer: T, format: &config::EntryFormat) -> Self {
+        Self {
+            format: format.clone(),
+            writer,
+        }
     }
 }
 
diff --git a/bear/src/semantic/command.rs b/bear/src/semantic/command.rs
@@ -5,7 +5,7 @@
 //! It defines how to classify arguments, group them, and convert them into entries
 //! for the final compilation database.
 
-use crate::semantic::{clang, FormatConfig, Formattable};
+use crate::semantic::{clang, EntryFormat, Formattable};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
@@ -92,7 +92,7 @@ impl Formattable for CompilerCommand {
     ///
     /// It processes the command arguments, identifies source files, and constructs
     /// entries with the executable, arguments, working directory, and output file if present.
-    fn to_entries(&self, config: &FormatConfig) -> Vec<clang::Entry> {
+    fn to_entries(&self, config: &EntryFormat) -> Vec<clang::Entry> {
         // Find all source files in the arguments
         let source_files: Vec<String> = self
             .arguments
@@ -161,7 +161,7 @@ mod test {
             ],
         );
 
-        let config = FormatConfig::default();
+        let config = EntryFormat::default();
         let entries = sut.to_entries(&config);
 
         let expected = vec![clang::Entry::from_arguments_str(
@@ -188,7 +188,7 @@ mod test {
             ],
         );
 
-        let config = FormatConfig::default();
+        let config = EntryFormat::default();
         let entries = sut.to_entries(&config);
 
         let expected = vec![
@@ -219,7 +219,7 @@ mod test {
             )],
         );
 
-        let config = FormatConfig::default();
+        let config = EntryFormat::default();
         let entries = sut.to_entries(&config);
 
         let expected: Vec<clang::Entry> = vec![];
@@ -240,7 +240,7 @@ mod test {
                 (ArgumentKind::Output, vec!["-o", "main.o"]),
             ],
         );
-        let config = FormatConfig {
+        let config = EntryFormat {
             keep_output_field: true,
             command_field_as_array: false,
         };
@@ -269,7 +269,7 @@ mod test {
                 (ArgumentKind::Output, vec!["-o", "main.o"]),
             ],
         );
-        let config = FormatConfig {
+        let config = EntryFormat {
             command_field_as_array: true,
             keep_output_field: false,
         };
diff --git a/bear/src/semantic/mod.rs b/bear/src/semantic/mod.rs
@@ -10,19 +10,20 @@
 //! - [`Command`]: Enum representing recognized command types.
 //! - [`Interpreter`]: Trait for recognizing the semantic meaning of an `Execution`.
 //! - [`Formattable`]: Trait for converting recognized commands into output entries.
-//! - [`FormatConfig`]: Configuration for formatting output entries.
+//! - [`EntryFormat`]: Configuration for formatting output entries.
 //!
 //! Implementers of [`Interpreter`] analyze an `Execution` and determine if it matches a known command.
 //! If recognized, they return a boxed [`Command`] representing the semantic meaning of the execution.
 //!
 //! The [`Formattable`] trait allows recognized commands to be transformed into output entries (e.g.,
-//! for a compilation database), using the provided [`FormatConfig`].
+//! for a compilation database), using the provided [`EntryFormat`].
 
 pub mod clang;
 pub mod command;
 pub mod interpreters;
 
 use super::intercept::Execution;
+use crate::config::EntryFormat;
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 
@@ -50,33 +51,14 @@ pub trait Interpreter: Send {
     fn recognize(&self, execution: &Execution) -> Option<Command>;
 }
 
-/// Configuration for formatting output entries.
-///
-/// This struct can be extended to control how recognized commands are
-/// transformed into output entries (e.g., for a compilation database).
-#[derive(Debug)]
-pub struct FormatConfig {
-    command_field_as_array: bool,
-    keep_output_field: bool,
-}
-
-impl Default for FormatConfig {
-    fn default() -> Self {
-        Self {
-            command_field_as_array: true,
-            keep_output_field: true,
-        }
-    }
-}
-
 /// Trait for types that can be formatted into output entries.
 pub trait Formattable {
     /// Converts the command into a list of entries, using the provided format configuration.
-    fn to_entries(&self, config: &FormatConfig) -> Vec<clang::Entry>;
+    fn to_entries(&self, config: &EntryFormat) -> Vec<clang::Entry>;
 }
 
 impl Formattable for Command {
-    fn to_entries(&self, config: &FormatConfig) -> Vec<clang::Entry> {
+    fn to_entries(&self, config: &EntryFormat) -> Vec<clang::Entry> {
         match self {
             Command::Compiler(cmd) => cmd.to_entries(config),
             Command::Ignored(_) => vec![],
