fix: assure binary-detection also works if ODB files are below the big-file threshold.

Author: Byron

gix-diff/src/blob/pipeline.rs

@@ -377,8 +377,11 @@ impl Pipeline {
                         .try_header(id)
                         .map_err(gix_object::find::existing_object::Error::Find)?
                         .ok_or_else(|| gix_object::find::existing_object::Error::NotFound { oid: id.to_owned() })?;
-                    if is_binary.is_none() && self.options.large_file_threshold_bytes > 0 {
-                        is_binary = Some(header.size > self.options.large_file_threshold_bytes);
+                    if is_binary.is_none()
+                        && self.options.large_file_threshold_bytes > 0
+                        && header.size > self.options.large_file_threshold_bytes
+                    {
+                        is_binary = Some(true);
                     };
                     let data = if is_binary == Some(true) {
                         Data::Binary { size: header.size }
@@ -425,7 +428,18 @@ impl Pipeline {
                                 })?;
                             match cmd_and_file {
                                 Some((cmd, mut tmp_file)) => {
-                                    tmp_file.write_all(out).map_err(|err| {
+                                    match res {
+                                        ToWorktreeOutcome::Unchanged(buf) | ToWorktreeOutcome::Buffer(buf) => {
+                                            tmp_file.write_all(buf)
+                                        }
+                                        ToWorktreeOutcome::Process(MaybeDelayed::Immediate(mut stream)) => {
+                                            std::io::copy(&mut stream, &mut tmp_file).map(|_| ())
+                                        }
+                                        ToWorktreeOutcome::Process(MaybeDelayed::Delayed(_)) => {
+                                            unreachable!("we prohibit this")
+                                        }
+                                    }
+                                    .map_err(|err| {
                                         convert_to_diffable::Error::CreateTempfile {
                                             source: err,
                                             rela_path: rela_path.to_owned(),

gix-diff/tests/blob/pipeline.rs

@@ -93,6 +93,61 @@ pub(crate) mod convert_to_diffable {
         Ok(())
     }
 
+    #[test]
+    fn binary_below_large_file_threshold() -> crate::Result {
+        let tmp = gix_testtools::tempfile::TempDir::new()?;
+        let mut filter = gix_diff::blob::Pipeline::new(
+            WorktreeRoots {
+                old_root: None,
+                new_root: Some(tmp.path().to_owned()),
+            },
+            gix_filter::Pipeline::default(),
+            vec![],
+            gix_diff::blob::pipeline::Options {
+                large_file_threshold_bytes: 5,
+                ..default_options()
+            },
+        );
+
+        let does_not_matter = gix_hash::Kind::Sha1.null();
+        let mut buf = Vec::new();
+        let a_name = "a";
+        let large_content = "a\0b";
+        std::fs::write(tmp.path().join(a_name), large_content.as_bytes())?;
+        let out = filter.convert_to_diffable(
+            &does_not_matter,
+            EntryKind::BlobExecutable,
+            a_name.into(),
+            ResourceKind::NewOrDestination,
+            &mut |_, _| {},
+            &gix_object::find::Never,
+            pipeline::Mode::default(),
+            &mut buf,
+        )?;
+        assert!(out.driver_index.is_none(), "there was no driver");
+        assert_eq!(out.data, Some(pipeline::Data::Binary { size: 3 }), "detected in buffer");
+        assert_eq!(buf.len(), 0, "it should avoid querying that data in the first place");
+
+        let mut db = ObjectDb::default();
+        let id = db.insert(large_content);
+        let out = filter.convert_to_diffable(
+            &id,
+            EntryKind::Blob,
+            a_name.into(),
+            ResourceKind::OldOrSource,
+            &mut |_, _| {},
+            &db,
+            pipeline::Mode::default(),
+            &mut buf,
+        )?;
+
+        assert!(out.driver_index.is_none(), "there was no driver");
+        assert_eq!(out.data, Some(pipeline::Data::Binary { size: 3 }));
+        assert_eq!(buf.len(), 0, "it should avoid querying that data in the first place");
+
+        Ok(())
+    }
+
     #[test]
     fn above_large_file_threshold() -> crate::Result {
         let tmp = gix_testtools::tempfile::TempDir::new()?;