Squash 11 commits that get started with allowing to checkout a particular branch

Author: Fernthedev

gix/src/clone/checkout.rs

@@ -5,6 +5,8 @@ use crate::{clone::PrepareCheckout, Repository};
 pub mod main_worktree {
     use std::{path::PathBuf, sync::atomic::AtomicBool};
 
+    use gix_ref::bstr::BStr;
+
     use crate::{clone::PrepareCheckout, Progress, Repository};
 
     /// The error returned by [`PrepareCheckout::main_worktree()`].
@@ -28,6 +30,8 @@ pub mod main_worktree {
         CheckoutOptions(#[from] crate::config::checkout_options::Error),
         #[error(transparent)]
         IndexCheckout(#[from] gix_worktree_state::checkout::Error),
+        #[error(transparent)]
+        Peel(#[from] crate::reference::peel::Error),
         #[error("Failed to reopen object database as Arc (only if thread-safety wasn't compiled in)")]
         OpenArcOdb(#[from] std::io::Error),
         #[error("The HEAD reference could not be located")]
@@ -72,13 +76,29 @@ pub mod main_worktree {
             P: gix_features::progress::NestedProgress,
             P::SubProgress: gix_features::progress::NestedProgress + 'static,
         {
-            self.main_worktree_inner(&mut progress, should_interrupt)
+            self.main_worktree_inner(&mut progress, should_interrupt, None)
+        }
+
+        /// Checkout the a worktree, determining how many threads to use by looking at `checkout.workers`, defaulting to using
+        /// on thread per logical core.
+        pub fn worktree<P>(
+            &mut self,
+            mut progress: P,
+            should_interrupt: &AtomicBool,
+            reference: Option<&BStr>,
+        ) -> Result<(Repository, gix_worktree_state::checkout::Outcome), Error>
+        where
+            P: gix_features::progress::NestedProgress,
+            P::SubProgress: gix_features::progress::NestedProgress + 'static,
+        {
+            self.main_worktree_inner(&mut progress, should_interrupt, reference)
         }
 
         fn main_worktree_inner(
             &mut self,
             progress: &mut dyn gix_features::progress::DynNestedProgress,
             should_interrupt: &AtomicBool,
+            reference: Option<&BStr>,
         ) -> Result<(Repository, gix_worktree_state::checkout::Outcome), Error> {
             let _span = gix_trace::coarse!("gix::clone::PrepareCheckout::main_worktree()");
             let repo = self
@@ -88,15 +108,22 @@ pub mod main_worktree {
             let workdir = repo.work_dir().ok_or_else(|| Error::BareRepository {
                 git_dir: repo.git_dir().to_owned(),
             })?;
-            let root_tree = match repo.head()?.try_peel_to_id_in_place()? {
+
+            let root_tree_id = match reference {
+                Some(reference_val) => Some(repo.find_reference(reference_val)?.peel_to_id_in_place()?),
+                None => repo.head()?.try_peel_to_id_in_place()?,
+            };
+
+            let root_tree = match root_tree_id {
                 Some(id) => id.object().expect("downloaded from remote").peel_to_tree()?.id,
                 None => {
                     return Ok((
                         self.repo.take().expect("still present"),
                         gix_worktree_state::checkout::Outcome::default(),
-                    ))
+                    ));
                 }
             };
+
             let index = gix_index::State::from_tree(&root_tree, &repo.objects, repo.config.protect_options()?)
                 .map_err(|err| Error::IndexFromTree {
                     id: root_tree,

gix/tests/clone/mod.rs

@@ -5,7 +5,7 @@ mod blocking_io {
     use std::{borrow::Cow, sync::atomic::AtomicBool};
 
     use gix::{
-        bstr::BString,
+        bstr::{BStr, BString},
         config::tree::{Clone, Core, Init, Key},
         remote::{
             fetch::{Shallow, SpecIndex},
@@ -507,6 +507,43 @@ mod blocking_io {
         }
         Ok(())
     }
+    #[test]
+    fn fetch_and_checkout_branch() -> crate::Result {
+        let tmp = gix_testtools::tempfile::TempDir::new()?;
+        let mut prepare = gix::clone::PrepareFetch::new(
+            remote::repo("base").path(),
+            tmp.path(),
+            gix::create::Kind::WithWorktree,
+            Default::default(),
+            restricted(),
+        )?;
+        let (mut checkout, _out) =
+            prepare.fetch_then_checkout(gix::progress::Discard, &std::sync::atomic::AtomicBool::default())?;
+
+        let branch_names = checkout.repo().branch_names();
+        let target_branch: &BStr = "a".into();
+        let branch_result = checkout.repo().find_reference(target_branch);
+
+        assert!(
+            branch_result.is_ok(),
+            "branch {target_branch} not found: {branch_result:?}. Available branches: {branch_names:?}"
+        );
+        let (repo, _) = checkout.worktree(
+            gix::progress::Discard,
+            &std::sync::atomic::AtomicBool::default(),
+            Some("a".into()),
+        )?;
+
+        let index = repo.index()?;
+        assert_eq!(index.entries().len(), 1, "All entries are known as per HEAD tree");
+
+        let work_dir = repo.work_dir().expect("non-bare");
+        for entry in index.entries() {
+            let entry_path = work_dir.join(gix_path::from_bstr(entry.path(&index)));
+            assert!(entry_path.is_file(), "{entry_path:?} not found on disk")
+        }
+        Ok(())
+    }
 
     #[test]
     fn fetch_and_checkout_empty_remote_repo() -> crate::Result {