feat: add Repository::set_workdir().

Force this repository instance to use the given worktree directory.

Author: Byron

gitoxide-core/src/repository/merge_base.rs

@@ -16,7 +16,6 @@ pub fn merge_base(
     let first_id = repo.rev_parse_single(first.as_str())?;
     let other_ids: Vec<_> = others
         .iter()
-        .cloned()
         .map(|other| repo.rev_parse_single(other.as_str()).map(gix::Id::detach))
         .collect::<Result<_, _>>()?;
 

gix/src/repository/location.rs

@@ -58,6 +58,36 @@ impl crate::Repository {
         self.work_tree.as_deref()
     }
 
+    /// Forcefully set the given `workdir` to be the worktree of this repository, *in memory*,
+    /// no matter if it had one or not, or unset it with `None`.
+    /// Return the previous working directory if one existed.
+    ///
+    /// Fail if the `workdir`, if not `None`, isn't accessible or isn't a directory.
+    /// No change is performed on error.
+    ///
+    /// ### About Worktrees
+    ///
+    /// * When setting a main worktree to a linked worktree directory, this repository instance
+    ///   will still claim that it is the [main worktree](crate::Worktree::is_main()) as that depends
+    ///   on the `git_dir`, not the worktree dir.
+    /// * When setting a linked worktree to a main worktree directory, this repository instance
+    ///   will still claim that it is *not* a [main worktree](crate::Worktree::is_main()) as that depends
+    ///   on the `git_dir`, not the worktree dir.
+    #[doc(alias = "git2")]
+    pub fn set_workdir(&mut self, workdir: impl Into<Option<PathBuf>>) -> Result<Option<PathBuf>, std::io::Error> {
+        let workdir = workdir.into();
+        Ok(match workdir {
+            None => self.work_tree.take(),
+            Some(new_workdir) => {
+                _ = std::fs::read_dir(&new_workdir)?;
+
+                let old = self.work_tree.take();
+                self.work_tree = Some(new_workdir);
+                old
+            }
+        })
+    }
+
     /// Return the work tree containing all checked out files, if there is one.
     pub fn workdir(&self) -> Option<&std::path::Path> {
         self.work_tree.as_deref()

gix/src/repository/worktree.rs

@@ -30,6 +30,7 @@ impl crate::Repository {
         res.sort_by(|a, b| a.git_dir.cmp(&b.git_dir));
         Ok(res)
     }
+
     /// Return the repository owning the main worktree, typically from a linked worktree.
     ///
     /// Note that it might be the one that is currently open if this repository doesn't point to a linked worktree.
@@ -41,7 +42,7 @@ impl crate::Repository {
 
     /// Return the currently set worktree if there is one, acting as platform providing a validated worktree base path.
     ///
-    /// Note that there would be `None` if this repository is `bare` and the parent [`Repository`][crate::Repository] was instantiated without
+    /// Note that there would be `None` if this repository is `bare` and the parent [`Repository`](crate::Repository) was instantiated without
     /// registered worktree in the current working dir, even if no `.git` file or directory exists.
     /// It's merely based on configuration, see [Worktree::dot_git_exists()] for a way to perform more validation.
     pub fn worktree(&self) -> Option<Worktree<'_>> {
@@ -50,7 +51,7 @@ impl crate::Repository {
 
     /// Return true if this repository is bare, and has no main work tree.
     ///
-    /// This is not to be confused with the [`worktree()`][crate::Repository::worktree()] worktree, which may exists if this instance
+    /// This is not to be confused with the [`worktree()`](crate::Repository::worktree()) method, which may exist if this instance
     /// was opened in a worktree that was created separately.
     pub fn is_bare(&self) -> bool {
         self.config.is_bare && self.workdir().is_none()

gix/tests/gix/repository/open.rs

@@ -154,7 +154,7 @@ fn non_bare_non_git_repo_without_worktree() -> crate::Result {
 
 #[test]
 fn none_bare_repo_without_index() -> crate::Result {
-    let repo = named_subrepo_opts(
+    let mut repo = named_subrepo_opts(
         "make_basic_repo.sh",
         "non-bare-repo-without-index",
         gix::open::Options::isolated(),
@@ -175,6 +175,28 @@ fn none_bare_repo_without_index() -> crate::Result {
             .is_ok(),
         "this is a minimal path"
     );
+
+    let old = repo.set_workdir(None).expect("should never fail");
+    assert_eq!(
+        old.as_ref().and_then(|wd| wd.file_name()?.to_str()),
+        Some("non-bare-repo-without-index")
+    );
+    assert!(repo.workdir().is_none(), "the workdir was unset");
+    assert!(repo.worktree().is_none(), "the worktree was unset");
+    assert!(
+        !repo.is_bare(),
+        "this is based on `core.bare`, not on the lack of worktree"
+    );
+
+    assert_eq!(
+        repo.set_workdir(old.clone()).expect("does not fail as it exists"),
+        None,
+        "nothing was set before"
+    );
+    assert_eq!(repo.workdir(), old.as_deref());
+
+    let worktree = repo.worktree().expect("should be present after setting");
+    assert!(worktree.is_main(), "it's still the main worktree");
     Ok(())
 }
 

gix/tests/gix/repository/worktree.rs

@@ -254,6 +254,43 @@ fn from_nonbare_parent_repo() {
     run_assertions(repo, false /* bare */);
 }
 
+#[test]
+fn from_nonbare_parent_repo_set_workdir() -> gix_testtools::Result {
+    if gix_testtools::should_skip_as_git_version_is_smaller_than(2, 31, 0) {
+        return Ok(());
+    }
+
+    let dir = gix_testtools::scripted_fixture_read_only("make_worktree_repo.sh").unwrap();
+    let mut repo = gix::open(dir.join("repo")).unwrap();
+
+    assert!(repo.worktree().is_some_and(|wt| wt.is_main()), "we have main worktree");
+
+    let worktrees = repo.worktrees()?;
+    assert_eq!(worktrees.len(), 6);
+
+    let linked_wt_dir = worktrees.first().unwrap().base().expect("this linked worktree exists");
+    repo.set_workdir(linked_wt_dir).expect("works as the dir exists");
+
+    assert!(
+        repo.worktree().is_some_and(|wt| wt.is_main()),
+        "it's still the main worktree as that depends on the git_dir"
+    );
+
+    let mut wt_repo = repo.worktrees()?.first().unwrap().clone().into_repo()?;
+    assert!(
+        wt_repo.worktree().is_some_and(|wt| !wt.is_main()),
+        "linked worktrees are never main"
+    );
+
+    wt_repo.set_workdir(Some(repo.workdir().unwrap().to_owned()))?;
+    assert!(
+        wt_repo.worktree().is_some_and(|wt| !wt.is_main()),
+        "it's still the linked worktree as that depends on the git_dir"
+    );
+
+    Ok(())
+}
+
 fn run_assertions(main_repo: gix::Repository, should_be_bare: bool) {
     assert_eq!(main_repo.is_bare(), should_be_bare);
     let mut baseline = Baseline::collect(