Expose the git_diff_blobs API.

Fixes #547

Author: staktrace

src/diff.rs

@@ -109,11 +109,11 @@ pub type BinaryCb<'a> = dyn FnMut(DiffDelta<'_>, DiffBinary<'_>) -> bool + 'a;
 pub type HunkCb<'a> = dyn FnMut(DiffDelta<'_>, DiffHunk<'_>) -> bool + 'a;
 pub type LineCb<'a> = dyn FnMut(DiffDelta<'_>, Option<DiffHunk<'_>>, DiffLine<'_>) -> bool + 'a;
 
-struct DiffCallbacks<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> {
-    file: Option<&'a mut FileCb<'b>>,
-    binary: Option<&'c mut BinaryCb<'d>>,
-    hunk: Option<&'e mut HunkCb<'f>>,
-    line: Option<&'g mut LineCb<'h>>,
+pub struct DiffCallbacks<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> {
+    pub file: Option<&'a mut FileCb<'b>>,
+    pub binary: Option<&'c mut BinaryCb<'d>>,
+    pub hunk: Option<&'e mut HunkCb<'f>>,
+    pub line: Option<&'g mut LineCb<'h>>,
 }
 
 impl<'repo> Diff<'repo> {
@@ -267,7 +267,7 @@ pub extern "C" fn print_cb(
     }
 }
 
-extern "C" fn file_cb_c(
+pub extern "C" fn file_cb_c(
     delta: *const raw::git_diff_delta,
     progress: f32,
     data: *mut c_void,
@@ -290,7 +290,7 @@ extern "C" fn file_cb_c(
     }
 }
 
-extern "C" fn binary_cb_c(
+pub extern "C" fn binary_cb_c(
     delta: *const raw::git_diff_delta,
     binary: *const raw::git_diff_binary,
     data: *mut c_void,
@@ -314,7 +314,7 @@ extern "C" fn binary_cb_c(
     }
 }
 
-extern "C" fn hunk_cb_c(
+pub extern "C" fn hunk_cb_c(
     delta: *const raw::git_diff_delta,
     hunk: *const raw::git_diff_hunk,
     data: *mut c_void,
@@ -338,7 +338,7 @@ extern "C" fn hunk_cb_c(
     }
 }
 
-extern "C" fn line_cb_c(
+pub extern "C" fn line_cb_c(
     delta: *const raw::git_diff_delta,
     hunk: *const raw::git_diff_hunk,
     line: *const raw::git_diff_line,

src/repo.rs

@@ -8,6 +8,9 @@ use std::ptr;
 use std::str;
 
 use crate::build::{CheckoutBuilder, RepoBuilder};
+use crate::diff::{
+    binary_cb_c, file_cb_c, hunk_cb_c, line_cb_c, BinaryCb, DiffCallbacks, FileCb, HunkCb, LineCb,
+};
 use crate::oid_array::OidArray;
 use crate::stash::{stash_cb, StashApplyOptions, StashCbData};
 use crate::string_array::StringArray;
@@ -2249,6 +2252,78 @@ impl Repository {
         }
     }
 
+    /// Directly run a diff on two blobs.
+    ///
+    /// Compared to a file, a blob lacks some contextual information. As such, the
+    /// `DiffFile` given to the callback will have some fake data; i.e. mode will be
+    /// 0 and path will be `None`.
+    ///
+    /// `None` is allowed for either `old_blob` or `new_blob` and will be treated
+    /// as an empty blob, with the oid set to zero in the `DiffFile`. Passing `None`
+    /// for both blobs is a noop; no callbacks will be made at all.
+    ///
+    /// We do run a binary content check on the blob content and if either blob looks
+    /// like binary data, the `DiffFile` binary attribute will be set to 1 and no call to
+    /// the `hunk_cb` nor `line_cb` will be made (unless you set the `force_text`
+    /// option).
+    pub fn diff_blobs(
+        &self,
+        old_blob: Option<&Blob<'_>>,
+        old_as_path: Option<&str>,
+        new_blob: Option<&Blob<'_>>,
+        new_as_path: Option<&str>,
+        opts: Option<&mut DiffOptions>,
+        file_cb: Option<&mut FileCb<'_>>,
+        binary_cb: Option<&mut BinaryCb<'_>>,
+        hunk_cb: Option<&mut HunkCb<'_>>,
+        line_cb: Option<&mut LineCb<'_>>,
+    ) -> Result<(), Error> {
+        let old_as_path = crate::opt_cstr(old_as_path)?;
+        let new_as_path = crate::opt_cstr(new_as_path)?;
+        let mut cbs = DiffCallbacks {
+            file: file_cb,
+            binary: binary_cb,
+            hunk: hunk_cb,
+            line: line_cb,
+        };
+        let ptr = &mut cbs as *mut _;
+        unsafe {
+            let file_cb_c: raw::git_diff_file_cb = if cbs.file.is_some() {
+                Some(file_cb_c)
+            } else {
+                None
+            };
+            let binary_cb_c: raw::git_diff_binary_cb = if cbs.binary.is_some() {
+                Some(binary_cb_c)
+            } else {
+                None
+            };
+            let hunk_cb_c: raw::git_diff_hunk_cb = if cbs.hunk.is_some() {
+                Some(hunk_cb_c)
+            } else {
+                None
+            };
+            let line_cb_c: raw::git_diff_line_cb = if cbs.line.is_some() {
+                Some(line_cb_c)
+            } else {
+                None
+            };
+            try_call!(raw::git_diff_blobs(
+                old_blob.map(|s| s.raw()),
+                old_as_path,
+                new_blob.map(|s| s.raw()),
+                new_as_path,
+                opts.map(|s| s.raw()),
+                file_cb_c,
+                binary_cb_c,
+                hunk_cb_c,
+                line_cb_c,
+                ptr as *mut _
+            ));
+            Ok(())
+        }
+    }
+
     /// Create a diff with the difference between two tree objects.
     ///
     /// This is equivalent to `git diff <old-tree> <new-tree>`