refactor: extract common function for writing item data to pipe with fd argument

src/modes/diff.rs

@@ -124,26 +124,34 @@ pub fn mode_diff(
 
     log::debug!("MAIN: Creating threads for diff I/O");
 
+    // Create a function to write item data to a pipe
+    fn write_item_to_pipe(
+        item_path: PathBuf,
+        compression_type: CompressionType,
+        pipe_writer_raw: std::fs::File,
+    ) {
+        use std::io::BufWriter;
+        let mut buffered_pipe_writer = BufWriter::new(pipe_writer_raw);
+        let engine = crate::compression::get_engine(compression_type)
+            .expect("Unable to get compression engine");
+        log::debug!("THREAD: Sending item to diff");
+        engine
+            .copy(item_path, &mut buffered_pipe_writer)
+            .expect("Failed to copy/compress item");
+        log::debug!("THREAD: Done sending item to diff");
+    }
+
     // Thread to write Item A data to diff
     let writer_thread_a = {
-        // `File::from_raw_fd` takes ownership of fd_a_write.
         let pipe_writer_a_raw = unsafe { std::fs::File::from_raw_fd(fd_a_write) };
-        let item_path_a_clone = item_path_a.clone(); // Avoid lifetime issues if item_path_a is used later
+        let item_path_a_clone = item_path_a.clone();
         let compression_type_a_clone = compression_type_a.clone();
         std::thread::spawn(move || {
-            // Original code used .expect/.unwrap, implying panics on error.
+            write_item_to_pipe(
-            // This matches that style. For more robust error handling, return Result from thread.
+                item_path_a_clone,
-            use std::io::BufWriter;
+                compression_type_a_clone,
-            let mut buffered_pipe_writer_a = BufWriter::new(pipe_writer_a_raw);
+                pipe_writer_a_raw,
-            let engine_a = crate::compression::get_engine(compression_type_a_clone)
+            );
-                .expect("Unable to get compression engine for Item A");
-            log::debug!("THREAD_A: Sending item A to diff");
-            engine_a
-                .copy(item_path_a_clone, &mut buffered_pipe_writer_a)
-                .expect("Failed to copy/compress item A");
-            log::debug!("THREAD_A: Done Sending item A to diff");
-            // pipe_writer_a_raw (and buffered_pipe_writer_a) are dropped here, closing fd_a_write.
-            // This signals EOF to one of diff's inputs.
         })
     };
 
@@ -153,14 +161,11 @@ pub fn mode_diff(
         let item_path_b_clone = item_path_b.clone();
         let compression_type_b_clone = compression_type_b.clone();
         std::thread::spawn(move || {
-            let mut buffered_pipe_writer_b = std::io::BufWriter::new(pipe_writer_b_raw);
+            write_item_to_pipe(
-            let engine_b = crate::compression::get_engine(compression_type_b_clone)
+                item_path_b_clone,
-                .expect("Unable to get compression engine for Item B");
+                compression_type_b_clone,
-            log::debug!("THREAD_B: Sending item B to diff");
+                pipe_writer_b_raw,
-            engine_b
+            );
-                .copy(item_path_b_clone, &mut buffered_pipe_writer_b)
-                .expect("Failed to copy/compress item B");
-            log::debug!("THREAD_B: Done Sending item B to diff");
         })
     };