rust: output writer refactoring

Author: rizsotto

rust/bear/src/output/mod.rs

@@ -11,17 +11,6 @@ use anyhow::Context;
 use formats::{FileFormat, JsonCompilationDatabase, JsonSemanticDatabase};
 use std::{fs, io, path};
 
-/// The trait represents a writer for iterator type `T`.
-///
-/// This trait is implemented by types that can consume an iterator of type `T`
-/// and write its elements to some output. The writing process may succeed or fail,
-/// returning either `()` on success or an error.
-pub trait IteratorWriter<T> {
-    /// Writes the iterator as a sequence of elements.
-    /// It consumes the iterator and returns either a nothing or an error.
-    fn write_array(self, _: impl Iterator<Item = T>) -> anyhow::Result<()>;
-}
-
 /// Represents the output writer, which can handle different types of outputs.
 ///
 /// This enum provides two variants:
@@ -31,7 +20,11 @@ pub trait IteratorWriter<T> {
 /// The variants are selected at runtime based on the configuration provided.
 pub enum OutputWriter {
     #[allow(private_interfaces)]
-    Clang(FormattedClangOutputWriter),
+    Clang(
+        FormattedClangOutputWriter<
+            AppendClangOutputWriter<AtomicClangOutputWriter<ClangOutputWriter>>,
+        >,
+    ),
     #[allow(private_interfaces)]
     Semantic(SemanticOutputWriter),
 }
@@ -43,8 +36,18 @@ impl TryFrom<(&args::BuildSemantic, &config::Output)> for OutputWriter {
         let (args, config) = value;
         match config {
             config::Output::Clang { duplicates, .. } => {
-                let result = FormattedClangOutputWriter::try_from((args, duplicates))?;
-                Ok(Self::Clang(result))
+                let final_file_name = path::Path::new(&args.file_name);
+                let temp_file_name = final_file_name.with_extension("tmp");
+
+                let base_writer =
+                    ClangOutputWriter::try_from((temp_file_name.as_path(), duplicates))?;
+                let atomic_writer =
+                    AtomicClangOutputWriter::new(base_writer, &temp_file_name, final_file_name);
+                let append_writer =
+                    AppendClangOutputWriter::new(atomic_writer, args.append, final_file_name);
+                let formatted_writer = FormattedClangOutputWriter::new(append_writer);
+
+                Ok(Self::Clang(formatted_writer))
             }
             config::Output::Semantic { .. } => {
                 let path = path::Path::new(&args.file_name);
@@ -61,12 +64,23 @@ impl OutputWriter {
         semantics: impl Iterator<Item = semantic::CompilerCall>,
     ) -> anyhow::Result<()> {
         match self {
-            Self::Clang(writer) => writer.write_array(semantics),
-            Self::Semantic(writer) => writer.write_array(semantics),
+            Self::Clang(writer) => writer.write(semantics),
+            Self::Semantic(writer) => writer.write(semantics),
         }
     }
 }
 
+/// The trait represents a writer for iterator type `T`.
+///
+/// This trait is implemented by types that can consume an iterator of type `T`
+/// and write its elements to some output. The writing process may succeed or fail,
+/// returning either `()` on success or an error.
+pub trait IteratorWriter<T> {
+    /// Writes the iterator as a sequence of elements.
+    /// It consumes the iterator and returns either a nothing or an error.
+    fn write(self, _: impl Iterator<Item = T>) -> anyhow::Result<()>;
+}
+
 /// This writer is used to write the semantic analysis results to a file.
 ///
 /// # Note
@@ -89,44 +103,32 @@ impl TryFrom<&path::Path> for SemanticOutputWriter {
 }
 
 impl IteratorWriter<semantic::CompilerCall> for SemanticOutputWriter {
-    fn write_array(
-        self,
-        semantics: impl Iterator<Item = semantic::CompilerCall>,
-    ) -> anyhow::Result<()> {
+    fn write(self, semantics: impl Iterator<Item = semantic::CompilerCall>) -> anyhow::Result<()> {
         JsonSemanticDatabase::write(self.output, semantics)?;
 
         Ok(())
     }
 }
 
 /// Formats `semantic::CompilerCall` instances into `clang::Entry` objects.
-struct FormattedClangOutputWriter {
+struct FormattedClangOutputWriter<T: IteratorWriter<clang::Entry>> {
     formatter: formatter::EntryFormatter,
-    writer: AppendClangOutputWriter,
+    writer: T,
 }
 
-impl TryFrom<(&args::BuildSemantic, &config::DuplicateFilter)> for FormattedClangOutputWriter {
-    type Error = anyhow::Error;
-
-    fn try_from(
-        value: (&args::BuildSemantic, &config::DuplicateFilter),
-    ) -> Result<Self, Self::Error> {
-        let (args, config) = value;
-
+impl<T: IteratorWriter<clang::Entry>> FormattedClangOutputWriter<T> {
+    fn new(writer: T) -> Self {
         let formatter = formatter::EntryFormatter::new();
-        let writer = AppendClangOutputWriter::try_from((args, config))?;
-
-        Ok(Self { formatter, writer })
+        Self { formatter, writer }
     }
 }
 
-impl IteratorWriter<semantic::CompilerCall> for FormattedClangOutputWriter {
-    fn write_array(
-        self,
-        semantics: impl Iterator<Item = semantic::CompilerCall>,
-    ) -> anyhow::Result<()> {
+impl<T: IteratorWriter<clang::Entry>> IteratorWriter<semantic::CompilerCall>
+    for FormattedClangOutputWriter<T>
+{
+    fn write(self, semantics: impl Iterator<Item = semantic::CompilerCall>) -> anyhow::Result<()> {
         let entries = semantics.flat_map(|semantic| self.formatter.apply(semantic));
-        self.writer.write_array(entries)
+        self.writer.write(entries)
     }
 }
 
@@ -136,48 +138,24 @@ impl IteratorWriter<semantic::CompilerCall> for FormattedClangOutputWriter {
 /// combining them with new entries, and writing the result back to the file.
 /// If the file does not exist and the append option is enabled, it logs a warning
 /// and writes only the new entries.
-struct AppendClangOutputWriter {
-    writer: AtomicClangOutputWriter,
+struct AppendClangOutputWriter<T: IteratorWriter<clang::Entry>> {
+    writer: T,
     path: Option<path::PathBuf>,
 }
 
-impl TryFrom<(&args::BuildSemantic, &config::DuplicateFilter)> for AppendClangOutputWriter {
-    type Error = anyhow::Error;
-
-    fn try_from(
-        value: (&args::BuildSemantic, &config::DuplicateFilter),
-    ) -> Result<Self, Self::Error> {
-        let (args, config) = value;
-
-        let file_name = path::Path::new(&args.file_name);
+impl<T: IteratorWriter<clang::Entry>> AppendClangOutputWriter<T> {
+    fn new(writer: T, append: bool, file_name: &path::Path) -> Self {
         let path = if file_name.exists() {
             Some(file_name.to_path_buf())
         } else {
-            if args.append {
+            if append {
                 log::warn!("The output file does not exist, the append option is ignored.");
             }
             None
         };
-
-        let writer = AtomicClangOutputWriter::try_from((file_name, config))?;
-
-        Ok(Self { writer, path })
+        Self { writer, path }
     }
-}
-
-impl IteratorWriter<clang::Entry> for AppendClangOutputWriter {
-    fn write_array(self, entries: impl Iterator<Item = clang::Entry>) -> anyhow::Result<()> {
-        if let Some(path) = self.path {
-            let entries_from_db = Self::read_from_compilation_db(&path)?;
-            let final_entries = entries_from_db.chain(entries);
-            self.writer.write_array(final_entries)
-        } else {
-            self.writer.write_array(entries)
-        }
-    }
-}
 
-impl AppendClangOutputWriter {
     /// Reads the compilation database from a file.
     ///
     /// NOTE: The function is intentionally not getting any `&self` reference,
@@ -196,39 +174,44 @@ impl AppendClangOutputWriter {
     }
 }
 
+impl<T: IteratorWriter<clang::Entry>> IteratorWriter<clang::Entry> for AppendClangOutputWriter<T> {
+    fn write(self, entries: impl Iterator<Item = clang::Entry>) -> anyhow::Result<()> {
+        if let Some(path) = self.path {
+            let entries_from_db = Self::read_from_compilation_db(&path)?;
+            let final_entries = entries_from_db.chain(entries);
+            self.writer.write(final_entries)
+        } else {
+            self.writer.write(entries)
+        }
+    }
+}
+
 /// Responsible for writing a JSON compilation database file atomically.
 ///
 /// The file is first written to a temporary file and then renamed to the final file name.
 /// This ensures that the output file is not left in an inconsistent state in case of errors.
-struct AtomicClangOutputWriter {
-    writer: ClangOutputWriter,
+struct AtomicClangOutputWriter<T: IteratorWriter<clang::Entry>> {
+    writer: T,
     temp_file_name: path::PathBuf,
     final_file_name: path::PathBuf,
 }
 
-impl TryFrom<(&path::Path, &config::DuplicateFilter)> for AtomicClangOutputWriter {
-    type Error = anyhow::Error;
-
-    fn try_from(value: (&path::Path, &config::DuplicateFilter)) -> Result<Self, Self::Error> {
-        let (file_name, config) = value;
-
-        let temp_file_name = file_name.with_extension("tmp");
-        let writer = ClangOutputWriter::try_from((temp_file_name.as_path(), config))?;
-
-        Ok(Self {
+impl<T: IteratorWriter<clang::Entry>> AtomicClangOutputWriter<T> {
+    fn new(writer: T, temp_file_name: &path::Path, final_file_name: &path::Path) -> Self {
+        Self {
             writer,
             temp_file_name: temp_file_name.to_path_buf(),
-            final_file_name: file_name.to_path_buf(),
-        })
+            final_file_name: final_file_name.to_path_buf(),
+        }
     }
 }
 
-impl IteratorWriter<clang::Entry> for AtomicClangOutputWriter {
-    fn write_array(self, entries: impl Iterator<Item = clang::Entry>) -> anyhow::Result<()> {
+impl<T: IteratorWriter<clang::Entry>> IteratorWriter<clang::Entry> for AtomicClangOutputWriter<T> {
+    fn write(self, entries: impl Iterator<Item = clang::Entry>) -> anyhow::Result<()> {
         let temp_file_name = self.temp_file_name.clone();
         let final_file_name = self.final_file_name.clone();
 
-        self.writer.write_array(entries)?;
+        self.writer.write(entries)?;
 
         fs::rename(&temp_file_name, &final_file_name).with_context(|| {
             format!(
@@ -268,7 +251,7 @@ impl TryFrom<(&path::Path, &config::DuplicateFilter)> for ClangOutputWriter {
 }
 
 impl IteratorWriter<clang::Entry> for ClangOutputWriter {
-    fn write_array(self, entries: impl Iterator<Item = clang::Entry>) -> anyhow::Result<()> {
+    fn write(self, entries: impl Iterator<Item = clang::Entry>) -> anyhow::Result<()> {
         let mut filter = self.filter.clone();
         let filtered_entries = entries.filter(move |entry| filter.unique(entry));
         JsonCompilationDatabase::write(self.output, filtered_entries)?;