rust: configuration for path formatting

rizsotto · rizsotto · commit 122d48ac2960 · 2025-04-12T21:11:07.000+10:00
diff --git a/rust/bear/src/config.rs b/rust/bear/src/config.rs
@@ -66,9 +66,9 @@
 //!       - file
 //!       - directory
 //!   format:
-//!     command_as_array: true
-//!     drop_output_field: false
-//!     paths_as: canonical
+//!     paths:
+//!       resolver: original
+//!       relative: false
 //! ```
 //!
 //! ```yaml
@@ -104,6 +104,16 @@ pub struct Main {
     pub output: Output,
 }
 
+impl Default for Main {
+    fn default() -> Self {
+        Main {
+            schema: String::from(SUPPORTED_SCHEMA_VERSION),
+            intercept: Intercept::default(),
+            output: Output::default(),
+        }
+    }
+}
+
 impl Main {
     /// Loads the configuration from the specified file or the default locations.
     ///
@@ -184,16 +194,6 @@ impl Main {
     }
 }
 
-impl Default for Main {
-    fn default() -> Self {
-        Main {
-            schema: String::from(SUPPORTED_SCHEMA_VERSION),
-            intercept: Intercept::default(),
-            output: Output::default(),
-        }
-    }
-}
-
 /// Intercept configuration is either a wrapper or a preload mode.
 ///
 /// In wrapper mode, the compiler is wrapped with a script that intercepts the compiler calls.
@@ -413,52 +413,45 @@ pub enum OutputFields {
 }
 
 /// Format configuration of the JSON compilation database.
-#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
 pub struct Format {
-    #[serde(default = "default_enabled")]
-    pub command_as_array: bool,
-    #[serde(default = "default_disabled")]
-    pub drop_output_field: bool,
-    #[serde(default)]
-    pub paths_as: PathFormat,
+    pub paths: PathFormat,
 }
 
-impl Default for Format {
-    fn default() -> Self {
-        Format {
-            command_as_array: true,
-            drop_output_field: false,
-            paths_as: PathFormat::default(),
-        }
-    }
+/// 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,
 }
 
-/// Path format configuration describes how the paths should be formatted.
+/// Path resolver configuration.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
-pub enum PathFormat {
+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.
     #[serde(rename = "canonical")]
     Canonical,
 }
 
 /// The default path format is the original path.
-impl Default for PathFormat {
+impl Default for PathResolver {
     fn default() -> Self {
-        PathFormat::Original
+        PathResolver::Original
     }
 }
 
 fn default_disabled() -> bool {
     false
 }
 
-fn default_enabled() -> bool {
-    true
-}
-
 /// The default directory where the wrapper executables will be stored.
 fn default_wrapper_directory() -> PathBuf {
     std::env::temp_dir()
@@ -544,9 +537,9 @@ mod test {
               - file
               - directory
           format:
-            command_as_array: true
-            drop_output_field: false
-            paths_as: canonical
+            paths:
+              resolver: canonical
+              relative: false
         "#;
 
         let result = Main::from_reader(content).unwrap();
@@ -617,9 +610,10 @@ mod test {
                     by_fields: vec![OutputFields::File, OutputFields::Directory],
                 },
                 format: Format {
-                    command_as_array: true,
-                    drop_output_field: false,
-                    paths_as: PathFormat::Canonical,
+                    paths: PathFormat {
+                        resolver: PathResolver::Canonical,
+                        relative: false,
+                    },
                 },
             },
             schema: String::from("4.0"),
@@ -646,8 +640,6 @@ mod test {
             by_fields:
               - file
               - directory
-          format:
-            command_as_array: true
         "#;
 
         let result = Main::from_reader(content).unwrap();
@@ -668,9 +660,10 @@ mod test {
                     by_fields: vec![OutputFields::File, OutputFields::Directory],
                 },
                 format: Format {
-                    command_as_array: true,
-                    drop_output_field: false,
-                    paths_as: PathFormat::Original,
+                    paths: PathFormat {
+                        resolver: PathResolver::Original,
+                        relative: false,
+                    },
                 },
             },
             schema: String::from("4.0"),
@@ -726,9 +719,9 @@ mod test {
             by_fields:
               - file
           format:
-            command_as_array: true
-            drop_output_field: true
-            use_absolute_path: false
+            paths:
+              resolver: canonical
+              relative: true
         "#;
 
         let result = Main::from_reader(content).unwrap();
@@ -768,9 +761,10 @@ mod test {
                     by_fields: vec![OutputFields::File],
                 },
                 format: Format {
-                    command_as_array: true,
-                    drop_output_field: true,
-                    paths_as: PathFormat::Original,
+                    paths: PathFormat {
+                        resolver: PathResolver::Canonical,
+                        relative: true,
+                    },
                 },
             },
             schema: String::from("4.0"),
diff --git a/rust/bear/src/modes/semantic.rs b/rust/bear/src/modes/semantic.rs
@@ -81,18 +81,16 @@ impl OutputWriterImpl {
         // TODO: This method should fail early if the output file is not writable.
         match config {
             config::Output::Clang {
-                format,
                 sources,
                 duplicates,
                 ..
             } => {
                 let result = ClangOutputWriter {
                     output: PathBuf::from(&args.file_name),
                     append: args.append,
+                    formatter: output::formatter::EntryFormatter::new(),
                     source_filter: sources.clone(),
                     duplicate_filter: duplicates.clone(),
-                    command_as_array: format.command_as_array,
-                    formatter: From::from(format),
                 };
                 Ok(OutputWriterImpl::Clang(result))
             }
@@ -133,19 +131,15 @@ impl OutputWriter for SemanticOutputWriter {
 pub(crate) struct ClangOutputWriter {
     output: PathBuf,
     append: bool,
+    formatter: output::formatter::EntryFormatter,
     source_filter: config::SourceFilter,
     duplicate_filter: config::DuplicateFilter,
-    command_as_array: bool,
-    formatter: output::formatter::EntryFormatter,
 }
 
 impl OutputWriter for ClangOutputWriter {
     /// Implements the main logic of the output writer.
-    fn run(
-        &self,
-        compiler_calls: impl Iterator<Item = semantic::CompilerCall>,
-    ) -> anyhow::Result<()> {
-        let entries = compiler_calls.flat_map(|compiler_call| self.formatter.apply(compiler_call));
+    fn run(&self, semantics: impl Iterator<Item = semantic::CompilerCall>) -> anyhow::Result<()> {
+        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);
@@ -200,7 +194,7 @@ impl ClangOutputWriter {
             .map(BufWriter::new)
             .with_context(|| format!("Failed to create file: {:?}", file_name.as_path()))?;
         // Write the entries to the file.
-        output::clang::write(self.command_as_array, file, entries)
+        output::clang::write(file, entries)
             .with_context(|| format!("Failed to write entries: {:?}", file_name.as_path()))?;
         // Return the temporary file name.
         Ok(file_name)
diff --git a/rust/bear/src/output/clang/mod.rs b/rust/bear/src/output/clang/mod.rs
@@ -18,7 +18,6 @@ use serde_json::Error;
 mod iterator;
 mod tests;
 mod type_de;
-mod type_ser;
 
 /// Represents an entry of the compilation database.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
@@ -46,46 +45,16 @@ pub fn read(reader: impl std::io::Read) -> impl Iterator<Item = Result<Entry, Er
     iterator::iter_json_array(reader)
 }
 
-/// The entries are written in the format specified by the configuration.
-pub fn write(
-    command_as_array: bool,
-    writer: impl std::io::Write,
-    entries: impl Iterator<Item = Entry>,
-) -> Result<(), Error> {
-    let method = if command_as_array {
-        write_with_arguments
-    } else {
-        write_with_command
-    };
-    method(writer, entries)
-}
-
 /// Serialize entries from an iterator into a JSON array.
 ///
 /// It uses the `arguments` field of the `Entry` struct to serialize the array of strings.
-pub(super) fn write_with_arguments(
-    writer: impl std::io::Write,
-    entries: impl Iterator<Item = Entry>,
-) -> Result<(), Error> {
-    let mut ser = serde_json::Serializer::pretty(writer);
-    let mut seq = ser.serialize_seq(None)?;
-    for entry in entries {
-        seq.serialize_element(&entry)?;
-    }
-    seq.end()
-}
-
-/// Serialize entries from an iterator into a JSON array.
-///
-/// It uses the `arguments` field of the `Entry` struct to serialize the array of strings.
-pub(super) fn write_with_command(
+pub fn write(
     writer: impl std::io::Write,
     entries: impl Iterator<Item = Entry>,
 ) -> Result<(), Error> {
     let mut ser = serde_json::Serializer::pretty(writer);
     let mut seq = ser.serialize_seq(None)?;
     for entry in entries {
-        let entry = type_ser::EntryWithCommand::from(entry);
         seq.serialize_element(&entry)?;
     }
     seq.end()
diff --git a/rust/bear/src/output/clang/tests.rs b/rust/bear/src/output/clang/tests.rs
@@ -165,7 +165,7 @@ mod success {
 
             // Create fake "file"
             let mut buffer = Cursor::new(Vec::new());
-            let result = write_with_arguments(&mut buffer, input.into_iter());
+            let result = write(&mut buffer, input.into_iter());
             assert!(result.is_ok());
 
             // Use the fake "file" as input
@@ -176,24 +176,6 @@ mod success {
 
             Ok(())
         }
-
-        #[test]
-        fn save_with_string_command_syntax() -> Result<(), Error> {
-            let input = expected_values();
-
-            // Create fake "file"
-            let mut buffer = Cursor::new(Vec::new());
-            let result = write_with_command(&mut buffer, input.into_iter());
-            assert!(result.is_ok());
-
-            // Use the fake "file" as input
-            buffer.seek(SeekFrom::Start(0)).unwrap();
-            let content: serde_json::Value = serde_json::from_reader(&mut buffer)?;
-
-            assert_eq!(expected_with_string_syntax(), content);
-
-            Ok(())
-        }
     }
 
     mod quoted {
@@ -276,37 +258,29 @@ mod success {
         }
 
         #[test]
-        fn save_with_array_command_syntax() -> Result<(), Error> {
-            let input = expected_values();
-
-            // Create fake "file"
-            let mut buffer = Cursor::new(Vec::new());
-            let result = write_with_arguments(&mut buffer, input.into_iter());
-            assert!(result.is_ok());
-
-            // Use the fake "file" as input
-            buffer.seek(SeekFrom::Start(0)).unwrap();
-            let content: Value = serde_json::from_reader(&mut buffer)?;
+        fn load_content_with_string_command_syntax() {
+            let content = expected_with_string_syntax().to_string();
 
-            assert_eq!(expected_with_array_syntax(), content);
+            let result = read(content.as_bytes());
+            let entries: Vec<Entry> = result.map(|e| e.unwrap()).collect();
 
-            Ok(())
+            assert_eq!(expected_values(), entries);
         }
 
         #[test]
-        fn save_with_string_command_syntax() -> Result<(), Error> {
+        fn save_with_array_command_syntax() -> Result<(), Error> {
             let input = expected_values();
 
             // Create fake "file"
             let mut buffer = Cursor::new(Vec::new());
-            let result = write_with_command(&mut buffer, input.into_iter());
+            let result = write(&mut buffer, input.into_iter());
             assert!(result.is_ok());
 
             // Use the fake "file" as input
             buffer.seek(SeekFrom::Start(0)).unwrap();
             let content: Value = serde_json::from_reader(&mut buffer)?;
 
-            assert_eq!(expected_with_string_syntax(), content);
+            assert_eq!(expected_with_array_syntax(), content);
 
             Ok(())
         }
diff --git a/rust/bear/src/output/clang/type_ser.rs b/rust/bear/src/output/clang/type_ser.rs
diff --git a/rust/bear/src/output/formatter.rs b/rust/bear/src/output/formatter.rs
