feat: add Repository::workdir() as replacement for Repository::work_dir().

Keep the latter as deprecated though.

Author: Byron

gix/examples/clone.rs

@@ -27,11 +27,11 @@ fn main() -> anyhow::Result<()> {
 
     println!(
         "Checking out into {:?} ...",
-        prepare_checkout.repo().work_dir().expect("should be there")
+        prepare_checkout.repo().workdir().expect("should be there")
     );
 
     let (repo, _) = prepare_checkout.main_worktree(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;
-    println!("Repo cloned into {:?}", repo.work_dir().expect("directory pre-created"));
+    println!("Repo cloned into {:?}", repo.workdir().expect("directory pre-created"));
 
     let remote = repo
         .find_default_remote(gix::remote::Direction::Fetch)

gix/examples/stats.rs

@@ -4,7 +4,7 @@ use gix::{prelude::ObjectIdExt, Reference};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut repo = gix::discover(".")?;
-    println!("Repo: {}", repo.work_dir().unwrap_or_else(|| repo.git_dir()).display());
+    println!("Repo: {}", repo.workdir().unwrap_or_else(|| repo.git_dir()).display());
     let mut max_parents = 0;
     let mut avg_parents = 0;
     repo.object_cache_size(32 * 1024);

gix/src/clone/access.rs

@@ -68,7 +68,7 @@ impl PrepareFetch {
 impl Drop for PrepareFetch {
     fn drop(&mut self) {
         if let Some(repo) = self.repo.take() {
-            std::fs::remove_dir_all(repo.work_dir().unwrap_or_else(|| repo.path())).ok();
+            std::fs::remove_dir_all(repo.workdir().unwrap_or_else(|| repo.path())).ok();
         }
     }
 }

gix/src/clone/checkout.rs

@@ -92,7 +92,7 @@ pub mod main_worktree {
                 .repo
                 .as_ref()
                 .expect("BUG: this method may only be called until it is successful");
-            let workdir = repo.work_dir().ok_or_else(|| Error::BareRepository {
+            let workdir = repo.workdir().ok_or_else(|| Error::BareRepository {
                 git_dir: repo.git_dir().to_owned(),
             })?;
 
@@ -173,7 +173,7 @@ impl PrepareCheckout {
 impl Drop for PrepareCheckout {
     fn drop(&mut self) {
         if let Some(repo) = self.repo.take() {
-            std::fs::remove_dir_all(repo.work_dir().unwrap_or_else(|| repo.path())).ok();
+            std::fs::remove_dir_all(repo.workdir().unwrap_or_else(|| repo.path())).ok();
         }
     }
 }

gix/src/config/cache/init.rs

@@ -303,7 +303,7 @@ impl crate::Repository {
     }
 
     fn apply_changed_values(&mut self) {
-        self.refs.write_reflog = util::reflog_or_default(self.config.reflog, self.work_dir().is_some());
+        self.refs.write_reflog = util::reflog_or_default(self.config.reflog, self.workdir().is_some());
         self.refs.namespace.clone_from(&self.config.refs_namespace);
     }
 }

gix/src/dirwalk/iter.rs

@@ -34,7 +34,7 @@ pub struct Outcome {
     /// The pathspecs used to guide the operation,
     pub pathspec: PathspecDetached,
     /// The root actually being used for the traversal, and useful to transform the paths returned for the user.
-    /// It's always within the [`work-dir`](Repository::work_dir).
+    /// It's always within the [`work-dir`](Repository::workdir).
     pub traversal_root: PathBuf,
     /// The actual result of the dirwalk.
     pub dirwalk: gix_dir::walk::Outcome,

gix/src/dirwalk/mod.rs

@@ -64,7 +64,7 @@ pub struct Outcome<'repo> {
     /// The pathspecs used to guide the operation,
     pub pathspec: Pathspec<'repo>,
     /// The root actually being used for the traversal, and useful to transform the paths returned for the user.
-    /// It's always within the [`work-dir`](crate::Repository::work_dir).
+    /// It's always within the [`work-dir`](crate::Repository::workdir).
     pub traversal_root: PathBuf,
     /// The actual result of the dirwalk.
     pub dirwalk: gix_dir::walk::Outcome,

gix/src/filter.rs

@@ -228,7 +228,7 @@ impl Pipeline<'_> {
 
         let rela_path_as_path = gix_path::from_bstr(rela_path);
         let repo = self.repo;
-        let worktree_dir = repo.work_dir().ok_or(Error::MissingWorktree)?;
+        let worktree_dir = repo.workdir().ok_or(Error::MissingWorktree)?;
         let path = worktree_dir.join(&rela_path_as_path);
         let md = match std::fs::symlink_metadata(&path) {
             Ok(md) => md,

gix/src/pathspec.rs

@@ -60,7 +60,7 @@ impl<'repo> Pathspec<'repo> {
             patterns,
             prefix,
             &gix_path::realpath_opts(
-                repo.work_dir().unwrap_or_else(|| repo.git_dir()),
+                repo.workdir().unwrap_or_else(|| repo.git_dir()),
                 repo.options.current_dir_or_empty(),
                 gix_path::realpath::MAX_SYMLINKS,
             )?,

gix/src/remote/connection/fetch/update_refs/mod.rs

@@ -444,7 +444,7 @@ fn insert_head(
     head: Option<crate::Head<'_>>,
     out: &mut BTreeMap<gix_ref::FullName, Vec<PathBuf>>,
 ) -> Result<(), update::Error> {
-    if let Some((head, wd)) = head.and_then(|head| head.repo.work_dir().map(|wd| (head, wd))) {
+    if let Some((head, wd)) = head.and_then(|head| head.repo.workdir().map(|wd| (head, wd))) {
         out.entry("HEAD".try_into().expect("valid"))
             .or_default()
             .push(wd.to_owned());

gix/src/remote/connection/fetch/update_refs/tests.rs

@@ -126,7 +126,7 @@ mod update {
             (
                 "+refs/remotes/origin/g:refs/heads/main",
                 fetch::refs::update::Mode::RejectedCurrentlyCheckedOut {
-                    worktree_dirs: vec![repo.work_dir().expect("present").to_owned()],
+                    worktree_dirs: vec![repo.workdir().expect("present").to_owned()],
                 },
                 None,
                 "checked out branches cannot be written, as it requires a merge of sorts which isn't done here",
@@ -498,7 +498,7 @@ mod update {
                 "refs/heads/main",
                 fetch::refs::Update {
                     mode: fetch::refs::update::Mode::RejectedCurrentlyCheckedOut {
-                        worktree_dirs: vec![repo.work_dir().expect("present").to_owned()],
+                        worktree_dirs: vec![repo.workdir().expect("present").to_owned()],
                     },
                     type_change: None,
                     edit_index: None,

gix/src/repository/attributes.rs

@@ -50,7 +50,7 @@ impl Repository {
         Ok(AttributeStack::new(
             gix_worktree::Stack::new(
                 // this is alright as we don't cause mutation of that directory, it's virtual.
-                self.work_dir().unwrap_or(self.git_dir()),
+                self.workdir().unwrap_or(self.git_dir()),
                 state,
                 case,
                 buf,
@@ -82,7 +82,7 @@ impl Repository {
         Ok(AttributeStack::new(
             gix_worktree::Stack::new(
                 // this is alright as we don't cause mutation of that directory, it's virtual.
-                self.work_dir().unwrap_or(self.git_dir()),
+                self.workdir().unwrap_or(self.git_dir()),
                 state,
                 case,
                 buf,
@@ -127,7 +127,7 @@ impl Repository {
         Ok(AttributeStack::new(
             gix_worktree::Stack::new(
                 // this is alright as we don't cause mutation of that directory, it's virtual.
-                self.work_dir().unwrap_or(self.git_dir()),
+                self.workdir().unwrap_or(self.git_dir()),
                 state,
                 case,
                 buf,

gix/src/repository/config/mod.rs

@@ -107,7 +107,7 @@ impl crate::Repository {
                     .into()
             },
             git_dir: self.git_dir().to_owned().into(),
-            worktree_dir: self.work_dir().map(ToOwned::to_owned),
+            worktree_dir: self.workdir().map(ToOwned::to_owned),
             no_replace_objects: config::shared::is_replace_refs_enabled(
                 &self.config.resolved,
                 self.config.lenient_config,

gix/src/repository/dirwalk.rs

@@ -36,7 +36,7 @@ impl Repository {
         delegate: &mut dyn gix_dir::walk::Delegate,
     ) -> Result<dirwalk::Outcome<'_>, dirwalk::Error> {
         let _span = gix_trace::coarse!("gix::dirwalk");
-        let workdir = self.work_dir().ok_or(dirwalk::Error::MissingWorkDir)?;
+        let workdir = self.workdir().ok_or(dirwalk::Error::MissingWorkDir)?;
         let mut excludes = self.excludes(
             index,
             None,
@@ -56,7 +56,7 @@ impl Repository {
         let accelerate_lookup = fs_caps.ignore_case.then(|| index.prepare_icase_backing());
         let mut opts = gix_dir::walk::Options::from(options);
         let worktree_relative_worktree_dirs_storage;
-        if let Some(workdir) = self.work_dir().filter(|_| opts.for_deletion.is_some()) {
+        if let Some(workdir) = self.workdir().filter(|_| opts.for_deletion.is_some()) {
             let linked_worktrees = self.worktrees()?;
             if !linked_worktrees.is_empty() {
                 let real_workdir = gix_path::realpath_opts(

gix/src/repository/impls.rs

@@ -31,7 +31,7 @@ impl std::fmt::Debug for crate::Repository {
         f.debug_struct("Repository")
             .field("kind", &self.kind())
             .field("git_dir", &self.git_dir())
-            .field("work_dir", &self.work_dir())
+            .field("workdir", &self.workdir())
             .finish()
     }
 }

gix/src/repository/location.rs

@@ -39,7 +39,7 @@ impl crate::Repository {
     /// The path to the `.gitmodules` file in the worktree, if a worktree is available.
     #[cfg(feature = "attributes")]
     pub fn modules_path(&self) -> Option<PathBuf> {
-        self.work_dir().map(|wtd| wtd.join(crate::submodule::MODULES_FILE))
+        self.workdir().map(|wtd| wtd.join(crate::submodule::MODULES_FILE))
     }
 
     /// The path to the `.git` directory itself, or equivalent if this is a bare repository.
@@ -48,11 +48,17 @@ impl crate::Repository {
     }
 
     /// Return the work tree containing all checked out files, if there is one.
+    #[deprecated = "Use `workdir()` instead"]
     #[doc(alias = "workdir", alias = "git2")]
     pub fn work_dir(&self) -> Option<&std::path::Path> {
         self.work_tree.as_deref()
     }
 
+    /// 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()
+    }
+
     // TODO: tests, respect precomposeUnicode
     /// The directory of the binary path of the current process.
     pub fn install_dir(&self) -> std::io::Result<PathBuf> {
@@ -65,7 +71,7 @@ impl crate::Repository {
     /// Note that the CWD is obtained once upon instantiation of the repository.
     // TODO: tests, details - there is a lot about environment variables to change things around.
     pub fn prefix(&self) -> Result<Option<&Path>, gix_path::realpath::Error> {
-        let (root, current_dir) = match self.work_dir().zip(self.options.current_dir.as_deref()) {
+        let (root, current_dir) = match self.workdir().zip(self.options.current_dir.as_deref()) {
             Some((work_dir, cwd)) => (work_dir, cwd),
             None => return Ok(None),
         };

gix/src/repository/mailmap.rs

@@ -33,7 +33,7 @@ impl crate::Repository {
                 .map(Id::detach)
                 .ok()
         });
-        match self.work_dir() {
+        match self.workdir() {
             None => {
                 blob_id = blob_id.or_else(|| {
                     self.head().ok().and_then(|mut head| {

gix/src/repository/worktree.rs

@@ -45,15 +45,15 @@ impl crate::Repository {
     /// 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<'_>> {
-        self.work_dir().map(|path| Worktree { parent: self, path })
+        self.workdir().map(|path| Worktree { parent: self, path })
     }
 
     /// 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
     /// was opened in a worktree that was created separately.
     pub fn is_bare(&self) -> bool {
-        self.config.is_bare && self.work_dir().is_none()
+        self.config.is_bare && self.workdir().is_none()
     }
 
     /// If `id` points to a tree, produce a stream that yields one worktree entry after the other. The index of the tree at `id`

gix/src/revision/spec/parse/delegate/navigate.rs

@@ -334,7 +334,7 @@ impl delegate::Navigate for Delegate<'_> {
                         .find_map(|stage| index.entry_index_by_path_and_stage(path, *stage).map(|_| *stage));
                     let exists = self
                         .repo
-                        .work_dir()
+                        .workdir()
                         .is_some_and(|root| root.join(gix_path::from_bstr(path)).exists());
                     self.err.push(Error::IndexLookup {
                         desired_path: path.into(),

gix/src/status/index_worktree.rs

@@ -103,7 +103,7 @@ impl Repository {
         E: std::error::Error + Send + Sync + 'static,
     {
         let _span = gix_trace::coarse!("gix::index_worktree_status");
-        let workdir = self.work_dir().ok_or(Error::MissingWorkDir)?;
+        let workdir = self.workdir().ok_or(Error::MissingWorkDir)?;
         let attrs_and_excludes = self.attributes(
             index,
             crate::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,

gix/src/submodule/mod.rs

@@ -209,7 +209,7 @@ impl Submodule<'_> {
     /// doesn't have a working dir set.
     pub fn work_dir(&self) -> Result<PathBuf, config::path::Error> {
         let worktree_git = gix_path::from_bstr(self.path()?);
-        Ok(match self.state.repo.work_dir() {
+        Ok(match self.state.repo.workdir() {
             None => worktree_git.into_owned(),
             Some(prefix) => prefix.join(worktree_git),
         })

gix/tests/gix/clone.rs

@@ -503,7 +503,7 @@ mod blocking_io {
         let index = repo.index()?;
         assert_eq!(index.entries().len(), 1, "All entries are known as per HEAD tree");
 
-        assure_index_entries_on_disk(&index, repo.work_dir().expect("non-bare"));
+        assure_index_entries_on_disk(&index, repo.workdir().expect("non-bare"));
         Ok(())
     }
     #[test]
@@ -550,7 +550,7 @@ mod blocking_io {
         let index = repo.index()?;
         assert_eq!(index.entries().len(), 1, "All entries are known as per HEAD tree");
 
-        assure_index_entries_on_disk(&index, repo.work_dir().expect("non-bare"));
+        assure_index_entries_on_disk(&index, repo.workdir().expect("non-bare"));
         Ok(())
     }
 

gix/tests/gix/id.rs

@@ -14,7 +14,7 @@ fn hex_to_id(hex: &str) -> gix_hash::ObjectId {
 #[test]
 fn prefix() -> crate::Result {
     let repo = crate::repo("make_repo_with_fork_and_dates.sh")?.to_thread_local();
-    let work_dir = repo.work_dir().expect("non-bare");
+    let work_dir = repo.workdir().expect("non-bare");
     let id = hex_to_id("288e509293165cb5630d08f4185bdf2445bf6170").attach(&repo);
     let prefix = id.shorten()?;
     assert_eq!(prefix.cmp_oid(&id), Ordering::Equal);

gix/tests/gix/init.rs

@@ -8,7 +8,7 @@ mod bare {
         let repo = gix::init_bare(&git_dir)?;
         assert_eq!(repo.kind(), gix::repository::Kind::Bare);
         assert!(
-            repo.work_dir().is_none(),
+            repo.workdir().is_none(),
             "a worktree isn't present in bare repositories"
         );
         assert_eq!(
@@ -26,7 +26,7 @@ mod bare {
         let repo = gix::init_bare(tmp.path())?;
         assert_eq!(repo.kind(), gix::repository::Kind::Bare);
         assert!(
-            repo.work_dir().is_none(),
+            repo.workdir().is_none(),
             "a worktree isn't present in bare repositories"
         );
         assert_eq!(
@@ -79,14 +79,14 @@ mod non_bare {
         let tmp = tempfile::tempdir()?;
         let repo = gix::init(tmp.path())?;
         assert_eq!(repo.kind(), gix::repository::Kind::WorkTree { is_linked: false });
-        assert_eq!(repo.work_dir(), Some(tmp.path()), "there is a work tree by default");
+        assert_eq!(repo.workdir(), Some(tmp.path()), "there is a work tree by default");
         assert_eq!(
             repo.git_dir(),
             tmp.path().join(".git"),
             "there is a work tree by default"
         );
         assert_eq!(gix::open(repo.git_dir())?, repo);
-        assert_eq!(gix::open(repo.work_dir().as_ref().expect("non-bare repo"))?, repo);
+        assert_eq!(gix::open(repo.workdir().as_ref().expect("non-bare repo"))?, repo);
         Ok(())
     }
 
@@ -117,7 +117,7 @@ mod non_bare {
         std::fs::write(tmp.path().join("existing.txt"), b"I was here before you")?;
 
         let repo = gix::init(tmp.path())?;
-        assert_eq!(repo.work_dir().expect("present"), tmp.path());
+        assert_eq!(repo.workdir().expect("present"), tmp.path());
         assert_eq!(
             repo.git_dir(),
             tmp.path().join(".git"),

gix/tests/gix/remote/fetch.rs

@@ -243,7 +243,7 @@ mod blocking_and_async_io {
             ] {
                 let (mut client_repo, _tmp) = {
                     let client_repo = remote::repo("multi_round/client");
-                    let daemon = spawn_git_daemon_if_async(client_repo.work_dir().expect("non-bare"))?;
+                    let daemon = spawn_git_daemon_if_async(client_repo.workdir().expect("non-bare"))?;
                     let tmp = TempDir::new()?;
                     let repo = gix::prepare_clone_bare(
                         daemon.as_ref().map_or_else(
@@ -270,9 +270,9 @@ mod blocking_and_async_io {
                     )?;
                 }
                 let server_repo = remote::repo("multi_round/server");
-                let daemon = spawn_git_daemon_if_async(server_repo.work_dir().expect("non-bare"))?;
+                let daemon = spawn_git_daemon_if_async(server_repo.workdir().expect("non-bare"))?;
                 let remote = into_daemon_remote_if_async(
-                    client_repo.remote_at(server_repo.work_dir().expect("non-bare"))?,
+                    client_repo.remote_at(server_repo.workdir().expect("non-bare"))?,
                     daemon.as_ref(),
                     None,
                 );
@@ -433,7 +433,7 @@ mod blocking_and_async_io {
                         },
                     )?;
                     let daemon = spawn_git_daemon_if_async(
-                        repo.work_dir()
+                        repo.workdir()
                             .expect("non-bare")
                             .ancestors()
                             .nth(1)

gix/tests/gix/repository/config/identity.rs

@@ -25,7 +25,7 @@ fn author_included_by_hasconfig() -> crate::Result {
 fn author_and_committer_and_fallback() -> crate::Result {
     for trust in [gix_sec::Trust::Full, gix_sec::Trust::Reduced] {
         let repo = named_repo("make_config_repo.sh")?;
-        let work_dir = repo.work_dir().expect("present").canonicalize()?;
+        let work_dir = repo.workdir().expect("present").canonicalize()?;
         let _env = Env::new()
             .set(
                 "GIT_CONFIG_SYSTEM",
@@ -140,7 +140,7 @@ fn author_and_committer_and_fallback() -> crate::Result {
 #[serial]
 fn author_from_different_config_sections() -> crate::Result {
     let repo = named_repo("make_signatures_repo.sh")?;
-    let work_dir = repo.work_dir().unwrap().canonicalize()?;
+    let work_dir = repo.workdir().unwrap().canonicalize()?;
 
     let _env = Env::new()
         .set("GIT_CONFIG_GLOBAL", work_dir.join("global.config").to_str().unwrap())