diff_tree: Add a rust helper around git-diff-tree

Author: glandium

helper/cinnabar-helper.c

@@ -390,10 +390,28 @@ static void do_rev_list(struct string_list *args)
 	rev_list_finish(revs);
 }
 
-static void strbuf_diff_tree(struct diff_queue_struct *q,
-                             struct diff_options *opt, void *data)
+struct diff_tree_file {
+	struct object_id *oid;
+	char *path;
+	unsigned short mode;
+};
+
+struct diff_tree_item {
+	struct diff_tree_file a;
+	struct diff_tree_file b;
+	unsigned short int score;
+	char status;
+};
+
+struct diff_tree_ctx {
+	void (*cb)(void *, struct diff_tree_item *);
+	void *context;
+};
+
+static void diff_tree_cb(struct diff_queue_struct *q,
+                         struct diff_options *opt, void *data)
 {
-	struct strbuf *buf = data;
+	struct diff_tree_ctx *ctx = data;
 	int i;
 
 	for (i = 0; i < q->nr; i++) {
@@ -402,45 +420,30 @@ static void strbuf_diff_tree(struct diff_queue_struct *q,
 			die("internal diff status error");
 		if (p->status == DIFF_STATUS_UNKNOWN)
 			continue;
-		strbuf_addf(buf, "%06o %06o %s %s %c",
-		            p->one->mode,
-		            p->two->mode,
-		            oid_to_hex(&p->one->oid),
-		            oid_to_hex(&p->two->oid),
-		            p->status);
-		if (p->score)
-			strbuf_addf(buf, "%03d",
-			            (int)(p->score * 100 / MAX_SCORE));
-		strbuf_addch(buf, '\t');
-		if (p->status == DIFF_STATUS_COPIED ||
-		    p->status == DIFF_STATUS_RENAMED) {
-			strbuf_addstr(buf, p->one->path);
-			strbuf_addch(buf, '\0');
-			strbuf_addstr(buf, p->two->path);
-		} else {
-			strbuf_addstr(buf, p->one->mode ? p->one->path
-			                                : p->two->path);
-		}
-		strbuf_addch(buf, '\0');
+		struct diff_tree_item item = {
+			{ &p->one->oid, p->one->path, p->one->mode },
+			{ &p->two->oid, p->two->path, p->two->mode },
+			p->score,
+			p->status,
+		};
+		ctx->cb(ctx->context, &item);
 	}
 }
 
-static void do_diff_tree(struct string_list *args)
+void diff_tree_(int argc, const char **argv, void (*cb)(void *, struct diff_tree_item *), void *context)
 {
+	struct diff_tree_ctx ctx = { cb, context };
 	struct rev_info revs;
-	struct strbuf buf = STRBUF_INIT;
-	const char **argv = string_list_to_argv(args);
 
 	init_revisions(&revs, NULL);
 	revs.diff = 1;
 	// Note: we do a pass through, but don't make much effort to actually
 	// support all the options properly.
-	setup_revisions(args->nr + 1, argv, &revs, NULL);
+	setup_revisions(argc, argv, &revs, NULL);
 	revs.diffopt.output_format = DIFF_FORMAT_CALLBACK;
-	revs.diffopt.format_callback = strbuf_diff_tree;
-	revs.diffopt.format_callback_data = &buf;
+	revs.diffopt.format_callback = diff_tree_cb;
+	revs.diffopt.format_callback_data = &ctx;
 	revs.diffopt.flags.recursive = 1;
-	free(argv);
 
 	if (revs.pending.nr != 2)
 		die("diff-tree needs two revs");
@@ -449,9 +452,44 @@ static void do_diff_tree(struct string_list *args)
 	              &revs.pending.objects[1].item->oid,
 	              "", &revs.diffopt);
 	log_tree_diff_flush(&revs);
+	rev_info_release(&revs);
+}
+
+static void strbuf_diff_tree(void *ctx, struct diff_tree_item *item)
+{
+	struct strbuf *buf = ctx;
+	strbuf_addf(buf, "%06o %06o %s %s %c",
+	            item->a.mode,
+	            item->b.mode,
+	            oid_to_hex(item->a.oid),
+	            oid_to_hex(item->b.oid),
+	            item->status);
+	if (item->score)
+		strbuf_addf(buf, "%03d",
+		            (int)(item->score * 100 / MAX_SCORE));
+	strbuf_addch(buf, '\t');
+	if (item->status == DIFF_STATUS_COPIED ||
+	    item->status == DIFF_STATUS_RENAMED) {
+		strbuf_addstr(buf, item->a.path);
+		strbuf_addch(buf, '\0');
+		strbuf_addstr(buf, item->b.path);
+	} else {
+		strbuf_addstr(buf, item->a.mode ? item->a.path
+		                                : item->b.path);
+	}
+	strbuf_addch(buf, '\0');
+}
+
+static void do_diff_tree(struct string_list *args)
+{
+	struct strbuf buf = STRBUF_INIT;
+	const char **argv = string_list_to_argv(args);
+
+	diff_tree_(args->nr + 1, argv, strbuf_diff_tree, &buf);
+	free(argv);
+
 	send_buffer(&buf);
 	strbuf_release(&buf);
-	rev_info_release(&revs);
 }
 
 void ensure_notes(struct notes_tree *notes)

helper/libgit.rs

@@ -5,7 +5,7 @@
 use std::convert::TryInto;
 use std::ffi::{c_void, CStr, CString, OsStr};
 use std::io::{self, Write};
-use std::os::raw::{c_char, c_int, c_long, c_uint, c_ulong};
+use std::os::raw::{c_char, c_int, c_long, c_uint, c_ulong, c_ushort};
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
 
@@ -15,7 +15,7 @@ use derive_more::{Deref, Display};
 use getset::Getters;
 
 use crate::oid::{GitObjectId, ObjectId};
-use crate::util::{FromBytes, SliceExt};
+use crate::util::{BorrowKey, FromBytes, SliceExt};
 
 const GIT_MAX_RAWSZ: usize = 32;
 
@@ -456,3 +456,158 @@ impl Iterator for RevList {
         }
     }
 }
+
+const DIFF_STATUS_ADDED: c_char = b'A' as c_char;
+const DIFF_STATUS_COPIED: c_char = b'C' as c_char;
+const DIFF_STATUS_DELETED: c_char = b'D' as c_char;
+const DIFF_STATUS_MODIFIED: c_char = b'M' as c_char;
+const DIFF_STATUS_TYPE_CHANGED: c_char = b'T' as c_char;
+const DIFF_STATUS_RENAMED: c_char = b'R' as c_char;
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+struct diff_tree_file {
+    oid: *const object_id,
+    path: *const c_char,
+    mode: c_ushort,
+}
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+struct diff_tree_item {
+    a: diff_tree_file,
+    b: diff_tree_file,
+    score: c_ushort,
+    status: c_char,
+}
+
+extern "C" {
+    fn diff_tree_(
+        argc: c_int,
+        argv: *const *const c_char,
+        cb: unsafe extern "C" fn(*mut c_void, *const diff_tree_item),
+        context: *const c_void,
+    );
+}
+
+pub struct FileMode(u16);
+
+pub enum DiffTreeItem {
+    Added {
+        path: Box<[u8]>,
+        mode: FileMode,
+        oid: BlobId,
+    },
+    Deleted {
+        path: Box<[u8]>,
+        mode: FileMode,
+        oid: BlobId,
+    },
+    Modified {
+        path: Box<[u8]>,
+        from_mode: FileMode,
+        from_oid: BlobId,
+        to_mode: FileMode,
+        to_oid: BlobId,
+    },
+    Renamed {
+        to_path: Box<[u8]>,
+        to_mode: FileMode,
+        to_oid: BlobId,
+        from_path: Box<[u8]>,
+        from_mode: FileMode,
+        from_oid: BlobId,
+    },
+    Copied {
+        to_path: Box<[u8]>,
+        to_mode: FileMode,
+        to_oid: BlobId,
+        from_path: Box<[u8]>,
+        from_mode: FileMode,
+        from_oid: BlobId,
+    },
+}
+
+impl BorrowKey for DiffTreeItem {
+    type Key = Box<[u8]>;
+    fn borrow_key(&self) -> &Self::Key {
+        match self {
+            DiffTreeItem::Added { path, .. } => path,
+            DiffTreeItem::Deleted { path, .. } => path,
+            DiffTreeItem::Modified { path, .. } => path,
+            DiffTreeItem::Renamed { to_path, .. } => to_path,
+            DiffTreeItem::Copied { to_path, .. } => to_path,
+        }
+    }
+}
+
+unsafe extern "C" fn diff_tree_fill(diff_tree: *mut c_void, item: *const diff_tree_item) {
+    let diff_tree = (diff_tree as *mut Vec<DiffTreeItem>).as_mut().unwrap();
+    let item = item.as_ref().unwrap();
+    let item = match item.status {
+        DIFF_STATUS_MODIFIED | DIFF_STATUS_TYPE_CHANGED => DiffTreeItem::Modified {
+            path: {
+                let a_path: Box<[u8]> = CStr::from_ptr(item.a.path).to_bytes().into();
+                let b_path = CStr::from_ptr(item.b.path).to_bytes();
+                assert_eq!(a_path.as_bstr(), b_path.as_bstr());
+                a_path
+            },
+            from_oid: BlobId::from(GitObjectId::from(item.a.oid.as_ref().unwrap().clone())),
+            from_mode: FileMode(item.a.mode),
+            to_oid: BlobId::from(GitObjectId::from(item.b.oid.as_ref().unwrap().clone())),
+            to_mode: FileMode(item.b.mode),
+        },
+        DIFF_STATUS_ADDED => DiffTreeItem::Added {
+            path: CStr::from_ptr(item.b.path).to_bytes().into(),
+            oid: BlobId::from(GitObjectId::from(item.b.oid.as_ref().unwrap().clone())),
+            mode: FileMode(item.b.mode),
+        },
+        DIFF_STATUS_DELETED => DiffTreeItem::Deleted {
+            path: CStr::from_ptr(item.a.path).to_bytes().into(),
+            oid: BlobId::from(GitObjectId::from(item.a.oid.as_ref().unwrap().clone())),
+            mode: FileMode(item.a.mode),
+        },
+        DIFF_STATUS_RENAMED => DiffTreeItem::Renamed {
+            to_path: CStr::from_ptr(item.b.path).to_bytes().into(),
+            to_oid: BlobId::from(GitObjectId::from(item.b.oid.as_ref().unwrap().clone())),
+            to_mode: FileMode(item.b.mode),
+            from_path: CStr::from_ptr(item.a.path).to_bytes().into(),
+            from_oid: BlobId::from(GitObjectId::from(item.a.oid.as_ref().unwrap().clone())),
+            from_mode: FileMode(item.a.mode),
+        },
+        DIFF_STATUS_COPIED => DiffTreeItem::Copied {
+            to_path: CStr::from_ptr(item.b.path).to_bytes().into(),
+            to_oid: BlobId::from(GitObjectId::from(item.b.oid.as_ref().unwrap().clone())),
+            to_mode: FileMode(item.b.mode),
+            from_path: CStr::from_ptr(item.a.path).to_bytes().into(),
+            from_oid: BlobId::from(GitObjectId::from(item.a.oid.as_ref().unwrap().clone())),
+            from_mode: FileMode(item.a.mode),
+        },
+        c => panic!("Unknown diff state: {}", c),
+    };
+    diff_tree.push(item);
+}
+
+pub fn diff_tree(a: &CommitId, b: &CommitId) -> impl Iterator<Item = DiffTreeItem> {
+    let a = CString::new(format!("{}", a)).unwrap();
+    let b = CString::new(format!("{}", b)).unwrap();
+    let args = [
+        cstr!(""),
+        &a,
+        &b,
+        cstr!("--ignore-submodules=dirty"),
+        cstr!("--"),
+    ];
+    let mut argv: Vec<_> = args.iter().map(|a| a.as_ptr()).collect();
+    argv.push(std::ptr::null());
+    let mut result = Vec::<DiffTreeItem>::new();
+    unsafe {
+        diff_tree_(
+            args.len().try_into().unwrap(),
+            &argv[0],
+            diff_tree_fill,
+            &mut result as *mut _ as *mut c_void,
+        );
+    }
+    result.into_iter()
+}