Intial support for working with worktrees

Author: mkeeler

libgit2-sys/lib.rs

@@ -1758,6 +1758,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: u32 = 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: u32 = 1;
+
 extern "C" {
     // threads
     pub fn git_libgit2_init() -> c_int;
@@ -3645,6 +3673,27 @@ extern "C" {
         location: git_apply_location_t,
         options: *const git_apply_options,
     ) -> 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_init_options(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_init_options(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/call.rs

@@ -92,6 +92,10 @@ mod impls {
             self.as_ptr()
         }
     }
+    
+    impl Convert<*mut libc::c_char> for CString {
+        fn convert(&self) -> *mut libc::c_char { self.as_ptr() as *mut libc::c_char }
+    }
 
     impl<T, U: Convert<*const T>> Convert<*const T> for Option<U> {
         fn convert(&self) -> *const T {

src/lib.rs

@@ -129,6 +129,8 @@ 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 {
@@ -666,6 +668,7 @@ mod tag;
 mod time;
 mod tree;
 mod treebuilder;
+mod worktree;
 
 fn init() {
     static INIT: Once = Once::new();

src/repo.rs

@@ -15,6 +15,7 @@ use crate::oid_array::OidArray;
 use crate::stash::{stash_cb, StashApplyOptions, StashCbData};
 use crate::string_array::StringArray;
 use crate::util::{self, path_to_repo_path, Binding};
+use crate::worktree::{Worktree, WorktreeAddOptions};
 use crate::CherrypickOptions;
 use crate::{
     init, raw, AttrCheckFlags, Buf, Error, Object, Remote, RepositoryOpenFlags, RepositoryState,
@@ -2700,6 +2701,57 @@ impl Repository {
             Ok(())
         }
     }
+    
+       
+    /// Lists all the worktrees for the repository
+    pub fn worktrees(&self) -> Result<StringArray, Error> {
+        let mut arr = raw::git_strarray {
+            strings: 0 as *mut *mut c_char,
+            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 worktree_lookup(&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 worktree_open_from_repository(&self) -> Result<Worktree, Error> {
+        let mut raw = ptr::null_mut();
+        unsafe {
+            try_call!(raw::git_worktree_open_from_repository(&mut raw, self.raw));
+            Ok(Binding::from_raw(raw))
+        }
+    }
+    
+    /// Creates a new worktree for the repository
+    pub fn worktree_add(&self, name: &str, path: &Path, opts: &WorktreeAddOptions<'_>) -> Result<Worktree, Error> {
+        let mut raw = ptr::null_mut();
+        let raw_name = CString::new(name)?;
+        let raw_path = path.into_c_string()?;
+
+        unsafe {
+            try_call!(raw::git_worktree_add(&mut raw, self.raw, raw_name, raw_path, &opts.raw()));
+            Ok(Binding::from_raw(raw))
+        }
+    }
+
 }
 
 impl Binding for Repository {

src/test.rs

@@ -6,7 +6,7 @@ use std::ptr;
 use tempfile::TempDir;
 use url::Url;
 
-use crate::{Oid, Repository};
+use crate::{Branch, Oid, Repository};
 
 macro_rules! t {
     ($e:expr) => {
@@ -54,6 +54,15 @@ pub fn path2url(path: &Path) -> String {
     Url::from_file_path(path).unwrap().to_string()
 }
 
+pub fn worktrees_env_init(repo: &Repository) -> (TempDir, Branch<'_>) {
+    let oid = repo.head().unwrap().target().unwrap();
+    let commit = repo.find_commit(oid).unwrap();
+    let branch = repo.branch("wt-branch", &commit, true).unwrap();
+    let wtdir = TempDir::new().unwrap();
+    (wtdir, branch)
+}
+
+
 #[cfg(windows)]
 pub fn realpath(original: &Path) -> io::Result<PathBuf> {
     Ok(original.to_path_buf())