clippy fixes

Author: martinzink

minifi_rust/extensions/minifi_rs_playground/src/processors/get_file/tests.rs

@@ -120,7 +120,7 @@ fn test_complex_dir_with_filter(
                 .flow_file
                 .attributes
                 .get("filename")
-                .and_then(|filename| Some(filename.contains(expected_filename_part)))
+                .map(|filename| filename.contains(expected_filename_part))
                 .unwrap_or(false)
     }));
     let sum_file_len = transferred_flow_files

minifi_rust/minifi_native/src/c_ffi/c_ffi_streams.rs

@@ -13,6 +13,13 @@ pub struct CffiInputStream<'a> {
     _marker: std::marker::PhantomData<&'a ()>,
 }
 
+// SAFETY: The wrapped `minifi_input_stream*` points at a
+// `minifi::io::InputStream` on the C++ side. That interface has no
+// thread-affine state (no `thread_local`, no owning-thread assertions in the
+// concrete implementations — see
+// `minifi-api/common/include/minifi-cpp/io/InputStream.h` and the impls under
+// `libminifi/src/core/`). The stream also cannot escape the FFI callback it
+// was constructed in: the `'a` lifetime is bound to that call frame.
 unsafe impl<'a> Send for CffiInputStream<'a> {}
 
 impl<'a> CffiInputStream<'a> {
@@ -93,6 +100,9 @@ impl<'a> CffiOutputStream<'a> {
     }
 }
 
+// SAFETY: Same reasoning as `CffiInputStream` above — the underlying
+// `minifi::io::OutputStream` has no thread affinity, and the `'a` lifetime keeps
+// the stream inside its FFI callback frame.
 unsafe impl<'a> Send for CffiOutputStream<'a> {}
 
 impl<'a> std::io::Write for CffiOutputStream<'a> {

minifi_rust/minifi_native/src/mock/mock_logger.rs

@@ -66,22 +66,14 @@ mod tests {
 
         let mut call_count = 0;
 
-        trace!(
-            mock_logger,
-            "This is a trace message {}",
-            || -> u32 {
-                call_count += 1;
-                call_count
-            }()
-        );
-        error!(
-            mock_logger,
-            "This is an error message {}",
-            || -> u32 {
-                call_count += 1;
-                call_count
-            }()
-        );
+        trace!(mock_logger, "This is a trace message {}", {
+            call_count += 1;
+            call_count
+        });
+        error!(mock_logger, "This is an error message {}", {
+            call_count += 1;
+            call_count
+        });
 
         assert_eq!(mock_logger.logs.lock().unwrap().len(), 1);
         assert_eq!(call_count, 1);

minifi_rust/minifi_native/src/mock/mock_process_session.rs

@@ -156,11 +156,13 @@ mod tests {
     #[test]
     fn test_read_in_batches() {
         let session = MockProcessSession::new();
-        let mut flow_file = MockFlowFile::new();
-        flow_file.content = RefCell::from("Hello, World!".to_string().as_bytes().to_vec());
+        let flow_file = MockFlowFile::new();
+        flow_file
+            .content
+            .replace("Hello, World!".as_bytes().to_vec());
         let mut vec: Vec<u8> = Vec::new();
 
-        let res = session.read_in_batches(&mut flow_file, 1, |batch| {
+        let res = session.read_in_batches(&flow_file, 1, |batch| {
             assert_eq!(batch.len(), 1);
             vec.push(batch[0]);
             Ok(())