More Better Worktree Support

Cargo.toml

@@ -31,6 +31,7 @@ structopt = "0.3"
 time = "0.1.39"
 tempfile = "3.1.0"
 thread-id = "3.3.0" # remove when we work with minimal-versions without it
+paste = "0.1.12"
 
 [features]
 unstable = []

libgit2-sys/lib.rs

@@ -1823,6 +1823,34 @@ git_enum! {
     }
 }
 
+#[repr(C)]
+pub struct git_worktree_add_options {
+    pub version: c_uint,
+    pub lock: c_int,
+    pub reference: *mut git_reference,
+}
+
+pub const GIT_WORKTREE_ADD_OPTIONS_VERSION: c_uint = 1;
+
+git_enum! {
+    pub enum git_worktree_prune_t {
+        /* Prune working tree even if working tree is valid */
+        GIT_WORKTREE_PRUNE_VALID = 1 << 0,
+        /* Prune working tree even if it is locked */
+        GIT_WORKTREE_PRUNE_LOCKED = 1 << 1,
+        /* Prune checked out working tree */
+        GIT_WORKTREE_PRUNE_WORKING_TREE = 1 << 2,
+    }
+}
+
+#[repr(C)]
+pub struct git_worktree_prune_options {
+    pub version: c_uint,
+    pub flags: u32,
+}
+
+pub const GIT_WORKTREE_PRUNE_OPTIONS_VERSION: c_uint = 1;
+
 extern "C" {
     // threads
     pub fn git_libgit2_init() -> c_int;
@@ -3780,6 +3808,48 @@ extern "C" {
     ) -> c_int;
 
     pub fn git_libgit2_opts(option: c_int, ...) -> c_int;
+
+    // Worktrees
+    pub fn git_worktree_list(out: *mut git_strarray, repo: *mut git_repository) -> c_int;
+    pub fn git_worktree_lookup(
+        out: *mut *mut git_worktree,
+        repo: *mut git_repository,
+        name: *const c_char,
+    ) -> c_int;
+    pub fn git_worktree_open_from_repository(
+        out: *mut *mut git_worktree,
+        repo: *mut git_repository,
+    ) -> c_int;
+    pub fn git_worktree_free(wt: *mut git_worktree);
+    pub fn git_worktree_validate(wt: *const git_worktree) -> c_int;
+    pub fn git_worktree_add_options_init(
+        opts: *mut git_worktree_add_options,
+        version: c_uint,
+    ) -> c_int;
+    pub fn git_worktree_add(
+        out: *mut *mut git_worktree,
+        repo: *mut git_repository,
+        name: *const c_char,
+        path: *const c_char,
+        opts: *const git_worktree_add_options,
+    ) -> c_int;
+    pub fn git_worktree_lock(wt: *mut git_worktree, reason: *const c_char) -> c_int;
+    pub fn git_worktree_unlock(wt: *mut git_worktree) -> c_int;
+    pub fn git_worktree_is_locked(reason: *mut git_buf, wt: *const git_worktree) -> c_int;
+    pub fn git_worktree_name(wt: *const git_worktree) -> *const c_char;
+    pub fn git_worktree_path(wt: *const git_worktree) -> *const c_char;
+    pub fn git_worktree_prune_options_init(
+        opts: *mut git_worktree_prune_options,
+        version: c_uint,
+    ) -> c_int;
+    pub fn git_worktree_is_prunable(
+        wt: *mut git_worktree,
+        opts: *mut git_worktree_prune_options,
+    ) -> c_int;
+    pub fn git_worktree_prune(
+        wt: *mut git_worktree,
+        opts: *mut git_worktree_prune_options,
+    ) -> c_int;
 }
 
 pub fn init() {

src/blame.rs

@@ -290,37 +290,41 @@ mod tests {
     use std::fs::{self, File};
     use std::path::Path;
 
-    #[test]
-    fn smoke() {
-        let (_td, repo) = crate::test::repo_init();
-        let mut index = repo.index().unwrap();
-
-        let root = repo.path().parent().unwrap();
-        fs::create_dir(&root.join("foo")).unwrap();
-        File::create(&root.join("foo/bar")).unwrap();
-        index.add_path(Path::new("foo/bar")).unwrap();
-
-        let id = index.write_tree().unwrap();
-        let tree = repo.find_tree(id).unwrap();
-        let sig = repo.signature().unwrap();
-        let id = repo.refname_to_id("HEAD").unwrap();
-        let parent = repo.find_commit(id).unwrap();
-        let commit = repo
-            .commit(Some("HEAD"), &sig, &sig, "commit", &tree, &[&parent])
-            .unwrap();
-
-        let blame = repo.blame_file(Path::new("foo/bar"), None).unwrap();
-
-        assert_eq!(blame.len(), 1);
-        assert_eq!(blame.iter().count(), 1);
-
-        let hunk = blame.get_index(0).unwrap();
-        assert_eq!(hunk.final_commit_id(), commit);
-        assert_eq!(hunk.final_signature().name(), sig.name());
-        assert_eq!(hunk.final_signature().email(), sig.email());
-        assert_eq!(hunk.final_start_line(), 1);
-        assert_eq!(hunk.path(), Some(Path::new("foo/bar")));
-        assert_eq!(hunk.lines_in_hunk(), 0);
-        assert!(!hunk.is_boundary())
-    }
+    use crate::Repository;
+
+    repo_test!(
+        smoke,
+        (Typical, TypicalWorktree, BareWorktree),
+        |repo: &Repository| {
+            let mut index = repo.index().unwrap();
+
+            let root = repo.workdir().unwrap();
+            fs::create_dir(&root.join("foo")).unwrap();
+            File::create(&root.join("foo/bar")).unwrap();
+            index.add_path(Path::new("foo/bar")).unwrap();
+
+            let id = index.write_tree().unwrap();
+            let tree = repo.find_tree(id).unwrap();
+            let sig = repo.signature().unwrap();
+            let id = repo.refname_to_id("HEAD").unwrap();
+            let parent = repo.find_commit(id).unwrap();
+            let commit = repo
+                .commit(Some("HEAD"), &sig, &sig, "commit", &tree, &[&parent])
+                .unwrap();
+
+            let blame = repo.blame_file(Path::new("foo/bar"), None).unwrap();
+
+            assert_eq!(blame.len(), 1);
+            assert_eq!(blame.iter().count(), 1);
+
+            let hunk = blame.get_index(0).unwrap();
+            assert_eq!(hunk.final_commit_id(), commit);
+            assert_eq!(hunk.final_signature().name(), sig.name());
+            assert_eq!(hunk.final_signature().email(), sig.email());
+            assert_eq!(hunk.final_start_line(), 1);
+            assert_eq!(hunk.path(), Some(Path::new("foo/bar")));
+            assert_eq!(hunk.lines_in_hunk(), 0);
+            assert!(!hunk.is_boundary())
+        }
+    );
 }

src/branch.rs

@@ -153,8 +153,7 @@ impl<'repo> Drop for Branches<'repo> {
 mod tests {
     use crate::BranchType;
 
-    #[test]
-    fn smoke() {
+    repo_test!(smoke, (Typical, TypicalWorktree, BareWorktree), |_| {
         let (_td, repo) = crate::test::repo_init();
         let head = repo.head().unwrap();
         let target = head.target().unwrap();
@@ -174,5 +173,5 @@ mod tests {
         b1.set_upstream(None).unwrap();
 
         b1.delete().unwrap();
-    }
+    });
 }

src/lib.rs

@@ -131,6 +131,7 @@ pub use crate::time::{IndexTime, Time};
 pub use crate::tree::{Tree, TreeEntry, TreeIter, TreeWalkMode, TreeWalkResult};
 pub use crate::treebuilder::TreeBuilder;
 pub use crate::util::IntoCString;
+pub use crate::worktree::{Worktree, WorktreeAddOptions, WorktreeLockStatus, WorktreePruneOptions};
 
 // Create a convinience method on bitflag struct which checks the given flag
 macro_rules! is_bit_set {
@@ -686,6 +687,7 @@ mod tagforeach;
 mod time;
 mod tree;
 mod treebuilder;
+mod worktree;
 
 fn init() {
     static INIT: Once = Once::new();

src/repo.rs

@@ -16,6 +16,7 @@ use crate::stash::{stash_cb, StashApplyOptions, StashCbData};
 use crate::string_array::StringArray;
 use crate::tagforeach::{tag_foreach_cb, TagForeachCB, TagForeachData};
 use crate::util::{self, path_to_repo_path, Binding};
+use crate::worktree::{Worktree, WorktreeAddOptions};
 use crate::CherrypickOptions;
 use crate::RevertOptions;
 use crate::{
@@ -162,6 +163,19 @@ impl Repository {
         }
     }
 
+    /// Attempt to open an already-existing repository from a worktree.
+    pub fn open_from_worktree(worktree: &Worktree) -> Result<Repository, Error> {
+        crate::init();
+        let mut ret = ptr::null_mut();
+        unsafe {
+            try_call!(raw::git_repository_open_from_worktree(
+                &mut ret,
+                worktree.raw()
+            ));
+            Ok(Binding::from_raw(ret))
+        }
+    }
+
     /// Attempt to open an already-existing repository at or above `path`
     ///
     /// This starts at `path` and looks up the filesystem hierarchy
@@ -2791,6 +2805,63 @@ impl Repository {
             Ok(Binding::from_raw(ret))
         }
     }
+
+    /// Lists all the worktrees for the repository
+    pub fn worktrees(&self) -> Result<StringArray, Error> {
+        let mut arr = raw::git_strarray {
+            strings: ptr::null_mut(),
+            count: 0,
+        };
+        unsafe {
+            try_call!(raw::git_worktree_list(&mut arr, self.raw));
+            Ok(Binding::from_raw(arr))
+        }
+    }
+
+    /// Opens a worktree by name for the given repository
+    ///
+    /// This can open any worktree that the worktrees method returns.
+    pub fn find_worktree(&self, name: &str) -> Result<Worktree, Error> {
+        let mut raw = ptr::null_mut();
+        let raw_name = CString::new(name)?;
+        unsafe {
+            try_call!(raw::git_worktree_lookup(&mut raw, self.raw, raw_name));
+            Ok(Binding::from_raw(raw))
+        }
+    }
+
+    /// Open a worktree of a the repository
+    ///
+    /// If a repository is not the main tree but a worktree, this
+    /// function will look up the worktree inside the parent
+    /// repository and create a new `git_worktree` structure.
+    pub fn to_worktree(&self) -> Result<Worktree, Error> {
+        Worktree::open_from_repository(self)
+    }
+
+    /// Creates a new worktree for the repository
+    pub fn worktree(
+        &self,
+        name: &str,
+        path: &Path,
+        opts: Option<&WorktreeAddOptions<'_>>,
+    ) -> Result<Worktree, Error> {
+        let mut raw = ptr::null_mut();
+        let raw_name = CString::new(name)?;
+        let raw_path = path.into_c_string()?;
+
+        unsafe {
+            let opts = opts.map(|o| o.raw());
+            try_call!(raw::git_worktree_add(
+                &mut raw,
+                self.raw,
+                raw_name,
+                raw_path,
+                opts.as_ref()
+            ));
+            Ok(Binding::from_raw(raw))
+        }
+    }
 }
 
 impl Binding for Repository {