feat: add Repository::reopen() as quick way to reload all configuration and drop caches.

gix/src/repository/config/mod.rs

@@ -5,6 +5,8 @@ use crate::{bstr::ByteSlice, config};
 /// General Configuration
 impl crate::Repository {
     /// Return a snapshot of the configuration as seen upon opening the repository.
+    ///
+    /// Use [`reload()`](Self::reload()) to refresh it from disk.
     pub fn config_snapshot(&self) -> config::Snapshot<'_> {
         config::Snapshot { repo: self }
     }
@@ -13,7 +15,8 @@ impl crate::Repository {
     /// When the returned instance is dropped, it is applied in full, even if the reason for the drop is an error.
     ///
     /// Note that changes to the configuration are in-memory only and are observed only this instance
-    /// of the [`Repository`](crate::Repository).
+    /// of the [`Repository`](crate::Repository). Use [`reload()`](Self::reload()) to discard them and
+    /// refresh the snapshot from disk.
     pub fn config_snapshot_mut(&mut self) -> config::SnapshotMut<'_> {
         let config = self.config.resolved.as_ref().clone();
         config::SnapshotMut {

gix/src/repository/init.rs

@@ -34,6 +34,32 @@ impl crate::Repository {
     pub fn into_sync(self) -> crate::ThreadSafeRepository {
         self.into()
     }
+
+    /// Reopen this repository in place using the stored open options.
+    /// Use this to forcefully refresh Git configuration, drop caches, and release system resources
+    /// for opened object database resources.
+    ///
+    /// This discards in-memory-only configuration edits and any other transient repository state that is recreated
+    /// during opening.
+    ///
+    /// # Notes on relative paths
+    ///
+    /// When the [`git_dir`](Self::git_dir()) is relative and the current working dir changed,
+    /// then a reload will be performed on the joined path of both to make it succeed, which makes
+    /// the reloaded repository git-dir absolute.
+    pub fn reload(&mut self) -> Result<&mut Self, crate::open::Error> {
+        let mut git_dir = self.git_dir().to_owned();
+        let options = self.options.clone().open_path_as_is(true);
+        if git_dir.is_relative() {
+            if let Some((prev_cwd, cwd)) = options.current_dir.as_ref().zip(std::env::current_dir().ok()) {
+                if *prev_cwd != cwd {
+                    git_dir = prev_cwd.join(git_dir);
+                }
+            }
+        }
+        *self = crate::ThreadSafeRepository::open_opts(git_dir, options)?.to_thread_local();
+        Ok(self)
+    }
 }
 
 #[cfg_attr(not(feature = "max-performance-safe"), allow(unused_variables, unused_mut))]

gix/tests/gix/repository/config/config_snapshot/mod.rs

@@ -1,6 +1,6 @@
 use gix::config::tree::{gitoxide, Branch, Core, Key};
 
-use crate::named_repo;
+use crate::{named_repo, repo_rw};
 
 #[cfg(feature = "credentials")]
 mod credential_helpers;
@@ -170,3 +170,32 @@ fn apply_cli_overrides() -> crate::Result {
 
     Ok(())
 }
+
+#[test]
+fn reload_reloads_on_disk_changes() -> crate::Result {
+    use std::io::Write;
+
+    let (mut repo, _tmp) = repo_rw("make_config_repo.sh")?;
+    assert_eq!(repo.config_snapshot().integer("core.abbrev"), None);
+
+    let config_path = repo.git_dir().join("config");
+    let mut config = std::fs::OpenOptions::new().append(true).open(config_path)?;
+    writeln!(config, "\n[core]\n\tabbrev = 4")?;
+
+    assert_eq!(repo.config_snapshot().integer("core.abbrev"), None);
+    repo.reload()?;
+    assert_eq!(repo.config_snapshot().integer("core.abbrev"), Some(4));
+    Ok(())
+}
+
+#[test]
+fn reload_discards_in_memory_only_changes() -> crate::Result {
+    let mut repo = named_repo("make_config_repo.sh")?;
+
+    repo.config_snapshot_mut().set_raw_value(&Core::ABBREV, "4")?;
+    assert_eq!(repo.config_snapshot().integer("core.abbrev"), Some(4));
+
+    repo.reload()?;
+    assert_eq!(repo.config_snapshot().integer("core.abbrev"), None);
+    Ok(())
+}