Add TreeUpdateBuidler to support git_tree_create_updated

git_tree_create_updated requires a length and a contiguous array of
git_tree_update structures, each of which has a pointer to a C string.
Create a builder, `TreeUpdateBuilder`, to wrap that safely without
excessive copies.

Author: joshtriplett

Cargo.toml

@@ -20,7 +20,7 @@ url = "2.0"
 bitflags = "1.1.0"
 libc = "0.2"
 log = "0.4.8"
-libgit2-sys = { path = "libgit2-sys", version = "0.12.15" }
+libgit2-sys = { path = "libgit2-sys", version = "0.12.16" }
 
 [target."cfg(all(unix, not(target_os = \"macos\")))".dependencies]
 openssl-sys = { version = "0.9.0", optional = true }

src/build.rs

@@ -7,7 +7,7 @@ use std::path::Path;
 use std::ptr;
 
 use crate::util::{self, Binding};
-use crate::{panic, raw, Error, FetchOptions, IntoCString, Repository};
+use crate::{panic, raw, Error, FetchOptions, IntoCString, Oid, Repository, Tree};
 use crate::{CheckoutNotificationType, DiffFile, Remote};
 
 /// A builder struct which is used to build configuration for cloning a new git
@@ -64,6 +64,12 @@ pub struct RepoBuilder<'cb> {
 pub type RemoteCreate<'cb> =
     dyn for<'a> FnMut(&'a Repository, &str, &str) -> Result<Remote<'a>, Error> + 'cb;
 
+/// A builder struct for git tree updates, for use with `git_tree_create_updated`.
+pub struct TreeUpdateBuilder {
+    updates: Vec<raw::git_tree_update>,
+    paths: Vec<CString>,
+}
+
 /// A builder struct for configuring checkouts of a repository.
 pub struct CheckoutBuilder<'cb> {
     their_label: Option<CString>,
@@ -674,9 +680,82 @@ extern "C" fn notify_cb(
     .unwrap_or(2)
 }
 
+impl Default for TreeUpdateBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TreeUpdateBuilder {
+    /// Create a new empty series of updates.
+    pub fn new() -> Self {
+        Self {
+            updates: Vec::new(),
+            paths: Vec::new(),
+        }
+    }
+
+    /// Add an update removing the specified `path` from a tree.
+    pub fn remove<T: IntoCString>(&mut self, path: T) -> &mut Self {
+        let path = util::cstring_to_repo_path(path).unwrap();
+        let path_ptr = path.as_ptr();
+        self.paths.push(path);
+        self.updates.push(raw::git_tree_update {
+            action: raw::GIT_TREE_UPDATE_REMOVE,
+            id: raw::git_oid {
+                id: [0; raw::GIT_OID_RAWSZ],
+            },
+            filemode: raw::GIT_FILEMODE_UNREADABLE,
+            path: path_ptr,
+        });
+        self
+    }
+
+    /// Add an update setting the specified `path` to a specific Oid, whether it currently exists
+    /// or not.
+    ///
+    /// Note that libgit2 does not support an upsert of a previously removed path, or an upsert
+    /// that changes the type of an object (such as from tree to blob or vice versa).
+    ///
+    /// The mode given must be one of 0o040000, 0o100644, 0o100755, 0o120000 or
+    /// 0o160000 currently.
+    pub fn upsert<T: IntoCString>(&mut self, path: T, id: Oid, filemode: i32) -> &mut Self {
+        let filemode = filemode as raw::git_filemode_t;
+        let path = util::cstring_to_repo_path(path).unwrap();
+        let path_ptr = path.as_ptr();
+        self.paths.push(path);
+        self.updates.push(raw::git_tree_update {
+            action: raw::GIT_TREE_UPDATE_UPSERT,
+            id: unsafe { *id.raw() },
+            filemode,
+            path: path_ptr,
+        });
+        self
+    }
+
+    /// Create a new tree from the specified baseline and this series of updates.
+    ///
+    /// The baseline tree must exist in the specified repository.
+    pub fn create_updated(&mut self, repo: &Repository, baseline: &Tree<'_>) -> Result<Oid, Error> {
+        let mut ret = raw::git_oid {
+            id: [0; raw::GIT_OID_RAWSZ],
+        };
+        unsafe {
+            try_call!(raw::git_tree_create_updated(
+                &mut ret,
+                repo.raw(),
+                baseline.raw(),
+                self.updates.len(),
+                self.updates.as_ptr()
+            ));
+            Ok(Binding::from_raw(&ret as *const _))
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{CheckoutBuilder, RepoBuilder};
+    use super::{CheckoutBuilder, RepoBuilder, TreeUpdateBuilder};
     use crate::{CheckoutNotificationType, Repository};
     use std::fs;
     use std::path::Path;
@@ -707,6 +786,23 @@ mod tests {
         assert!(RepoBuilder::new().branch("foo").clone(&url, &dst).is_err());
     }
 
+    #[test]
+    fn smoke_tree_create_updated() {
+        let (_tempdir, repo) = crate::test::repo_init();
+        let (_, tree_id) = crate::test::commit(&repo);
+        let tree = t!(repo.find_tree(tree_id));
+        assert!(tree.get_name("bar").is_none());
+        let foo_id = tree.get_name("foo").unwrap().id();
+        let tree2_id = t!(TreeUpdateBuilder::new()
+            .remove("foo")
+            .upsert("bar/baz", foo_id, 0o100644)
+            .create_updated(&repo, &tree));
+        let tree2 = t!(repo.find_tree(tree2_id));
+        assert!(tree2.get_name("foo").is_none());
+        let baz_id = tree2.get_path(Path::new("bar/baz")).unwrap().id();
+        assert_eq!(foo_id, baz_id);
+    }
+
     /// Issue regression test #365
     #[test]
     fn notify_callback() {