Add but-core git-config utility to quickly read-change-write a Git configuration file.

Use it where possible.

Co-authored-by: Sebastian Thiel <sebastian.thiel@icloud.com>

Author: codex

AGENTS.md

@@ -3,3 +3,5 @@
 When asked about general development workflow, project structure, building, testing, or contributing to GitButler, please read `@.github/copilot-instructions.md` for context.
 
 When working on the `but` CLI (Rust command-line tool in `crates/but`), please read `@crates/but/agents.md` for context on API usage patterns, output formatting, and testing conventions.
+
+When tests need to observe repository changes written to disk, prefer `repo.reload()` over reopening the repository.

Cargo.lock

@@ -75,7 +75,6 @@ legacy = [
 but-serde.workspace = true
 but-path.workspace = true
 but-api-macros.workspace = true
-but-oxidize.workspace = true
 but-error.workspace = true
 but-core.workspace = true
 but-graph.workspace = true

crates/but-api/Cargo.toml

@@ -3,7 +3,7 @@ use anyhow::{Context as _, Result};
 use bstr::ByteSlice;
 use but_api_macros::but_api;
 use but_core::git_config::{
-    open_user_global_config_for_editing, remove_config_value, set_config_value, write_config,
+    edit_config, open_global_config_for_reading, remove_config_value, set_config_value,
 };
 use gitbutler_reference::RemoteRefname;
 use gitbutler_repo_actions::RepoActionsExt as _;
@@ -80,25 +80,27 @@ pub fn delete_all_data() -> Result<()> {
 #[but_api]
 #[instrument(err(Debug))]
 pub fn git_set_global_config(key: String, value: String) -> Result<String> {
-    let (mut config, path) = open_user_global_config_for_editing()?;
-    set_config_value(&mut config, &key, &value)?;
-    write_config(&path, &config)?;
+    _ = edit_config(None, gix::config::Source::User, |config| {
+        set_config_value(config, &key, &value)?;
+        Ok(())
+    })?;
     Ok(value)
 }
 
 #[but_api]
 #[instrument(err(Debug))]
 pub fn git_remove_global_config(key: String) -> Result<()> {
-    let (mut config, path) = open_user_global_config_for_editing()?;
-    remove_config_value(&mut config, &key)?;
-    write_config(&path, &config)?;
+    _ = edit_config(None, gix::config::Source::User, |config| {
+        remove_config_value(config, &key)?;
+        Ok(())
+    })?;
     Ok(())
 }
 
 #[but_api]
 #[instrument(err(Debug))]
 pub fn git_get_global_config(key: String) -> Result<Option<String>> {
-    let (config, _) = open_user_global_config_for_editing()?;
+    let config = open_global_config_for_reading()?;
     Ok(get_config_string(&config, &key))
 }
 

crates/but-api/src/legacy/git.rs

@@ -1,54 +1,120 @@
 //! Utilities for mutating Git configuration entries by dotted key.
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
-use anyhow::{Context as _, Result};
+use anyhow::{Context as _, Result, bail};
 use bstr::ByteSlice as _;
 use gix::config::AsKey as _;
 
-/// Open the user-global Git config for editing, creating it first if needed.
-pub fn open_user_global_config_for_editing() -> Result<(gix::config::File<'static>, PathBuf)> {
-    let path = gix::config::Source::User
+fn config_path(repo: Option<&gix::Repository>, source: gix::config::Source) -> Result<PathBuf> {
+    let path = source
         .storage_location(&mut |name| std::env::var_os(name))
-        .context("failed to determine global git config location")?
-        .into_owned();
+        .with_context(|| format!("failed to determine {source:?} git config location"))?;
+    let path = if path.is_relative() {
+        let repo = repo.with_context(|| {
+            format!("determining the {source:?} git config location requires a repository")
+        })?;
+        if source == gix::config::Source::Local {
+            repo.common_dir().join(path.as_ref())
+        } else {
+            repo.git_dir().join(path.as_ref())
+        }
+    } else {
+        path.into_owned()
+    };
+    Ok(path)
+}
+
+/// Open the Git config for `source` for editing, creating it first if needed.
+/// `repo` is used to resolve repo-local paths, depending on `source`.
+/// Return `(config, lock)`.
+/// Write it back with [`write_locked_config()`].
+pub fn open_config_for_editing(
+    repo: Option<&gix::Repository>,
+    source: gix::config::Source,
+) -> Result<(gix::config::File<'static>, gix::lock::File)> {
+    let path = config_path(repo, source)?;
+    std::fs::create_dir_all(path.parent().context("git config path has no parent")?)?;
+    let lock = gix::lock::File::acquire_to_update_resource(
+        &path,
+        gix::lock::acquire::Fail::Immediately,
+        None,
+    )?;
     if !path.exists() {
-        std::fs::create_dir_all(
-            path.parent()
-                .context("global git config path has no parent")?,
-        )?;
         std::fs::File::create(&path)?;
     }
-    let config = gix::config::File::from_path_no_includes(path.clone(), gix::config::Source::User)
-        .with_context(|| format!("failed to open global git config at {}", path.display()))?;
-    Ok((config, path))
+    let config = gix::config::File::from_path_no_includes(path.clone(), source)
+        .with_context(|| format!("failed to open {source:?} git config at {}", path.display()))?;
+    Ok((config, lock))
+}
+
+/// Open the user-global Git config for reading without acquiring a write lock.
+///
+/// If the config file doesn't exist yet, an empty in-memory config is returned.
+pub fn open_global_config_for_reading() -> Result<gix::config::File<'static>> {
+    let path = config_path(None, gix::config::Source::User)?;
+    if !path.exists() {
+        return Ok(gix::config::File::new(gix::config::file::Metadata::from(
+            gix::config::Source::User,
+        )));
+    }
+    gix::config::File::from_path_no_includes(path.clone(), gix::config::Source::User)
+        .with_context(|| format!("failed to open User git config at {}", path.display()))
 }
 
-/// Serialize a Git `config` file back to disk at `path`.
-pub fn write_config(path: &Path, config: &gix::config::File<'_>) -> Result<()> {
-    let mut file = std::io::BufWriter::new(
-        std::fs::OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .create(true)
-            .open(path)
-            .with_context(|| {
-                format!(
-                    "failed to open git config for writing at {}",
-                    path.display()
-                )
-            })?,
-    );
+/// Serialize a Git `config` file back to disk at `lock`.
+pub fn write_locked_config(
+    config: &gix::config::File<'_>,
+    mut lock: gix::lock::File,
+) -> Result<()> {
+    let path = lock.resource_path();
     config
-        .write_to(&mut file)
+        .write_to(&mut lock)
         .with_context(|| format!("failed to serialize git config at {}", path.display()))?;
-    std::io::Write::flush(&mut file)
+    std::io::Write::flush(&mut lock)
         .with_context(|| format!("failed to flush git config at {}", path.display()))?;
+    lock.commit()
+        .map_err(|err| err.error)
+        .with_context(|| format!("failed to commit git config at {}", path.display()))?;
     Ok(())
 }
 
+/// Open the Git config for `source` using `repo` when needed, let `edit` mutate it, and
+/// write it back if the edited configuration differs from its original state.
+/// Return `true` if the file changed and was written, `false` otherwise.
+pub fn edit_config(
+    repo: Option<&gix::Repository>,
+    source: gix::config::Source,
+    edit: impl FnOnce(&mut gix::config::File<'static>) -> Result<()>,
+) -> Result<bool> {
+    let (mut config, lock) = open_config_for_editing(repo, source)?;
+    let previous_contents = config.to_bstring();
+    edit(&mut config)?;
+    let changed = config.to_bstring() != previous_contents;
+    if changed {
+        write_locked_config(&config, lock)?;
+    }
+    Ok(changed)
+}
+
+/// Open the Git config for `source` relative to `repo`, let `edit` mutate it, and write it back
+/// if the edited configuration differs from its original state.
+pub fn edit_repo_config(
+    repo: &gix::Repository,
+    source: gix::config::Source,
+    edit: impl FnOnce(&mut gix::config::File<'static>) -> Result<()>,
+) -> Result<bool> {
+    if matches!(
+        source,
+        gix::config::Source::System | gix::config::Source::GitInstallation
+    ) {
+        bail!("editing {source:?} config through a repository is not supported");
+    }
+    edit_config(Some(repo), source, edit)
+}
+
 /// Set the entry in `config` identified by the dotted `key` (like `section.value` or `section.subsection.value`) to `value`.
-/// This will create sections as needed.
+/// This will create sections as needed, and remove all previous values under the same section with the same name.
 pub fn set_config_value(
     config: &mut gix::config::File<'static>,
     key: &str,

crates/but-core/src/git_config.rs

@@ -74,12 +74,20 @@ pub trait RepositoryExt: Sized {
     /// Return all signatures that would be needed to perform a commit as configured in Git: `(author, committer)`.
     fn commit_signatures(&self) -> anyhow::Result<(gix::actor::Signature, gix::actor::Signature)>;
 
-    /// Return the configuration freshly loaded from `.git/config` so that it can be changed in memory,
-    /// and possibly written back with [`Self::write_local_common_config()`].
-    fn local_common_config_for_editing(&self) -> anyhow::Result<gix::config::File<'static>>;
-    /// Write the given `local_config` to `.git/config` of the common repository.
-    /// Note that we never write linked worktree-local configuration.
-    fn write_local_common_config(&self, local_config: &gix::config::File) -> anyhow::Result<()>;
+    /// Return the configuration freshly loaded from `.git/config` together with an acquired lock
+    /// for that file so it can be changed in memory and safely written back without another writer
+    /// racing the read-modify-write cycle.
+    fn local_common_config_for_editing(
+        &self,
+    ) -> anyhow::Result<(gix::config::File<'static>, gix::lock::File)>;
+    /// Write the given `local_config` to the file at `lock` of the while consuming
+    /// the lock previously acquired with [`Self::local_common_config_for_editing()`].
+    /// Note that only local configuraiton is written, so it's safe to use it with `repo.config_snapshot_mut()`.
+    fn write_locked_config(
+        &self,
+        local_config: &gix::config::File,
+        lock: gix::lock::File,
+    ) -> anyhow::Result<()>;
     /// Cherry-pick the changes in the tree of `to_rebase_commit_id` onto `new_base_commit_id`.
     /// This method deals with the presence of conflicting commits to select the correct trees
     /// for the cheery-pick merge.
@@ -184,37 +192,28 @@ impl RepositoryExt for gix::Repository {
         Ok((author.into(), committer))
     }
 
-    fn local_common_config_for_editing(&self) -> anyhow::Result<gix::config::File<'static>> {
+    fn local_common_config_for_editing(
+        &self,
+    ) -> anyhow::Result<(gix::config::File<'static>, gix::lock::File)> {
         let local_config_path = self.common_dir().join("config");
+        let lock = gix::lock::File::acquire_to_update_resource(
+            &local_config_path,
+            gix::lock::acquire::Fail::Immediately,
+            None,
+        )?;
         let config = gix::config::File::from_path_no_includes(
             local_config_path.clone(),
             gix::config::Source::Local,
         )?;
-        Ok(config)
+        Ok((config, lock))
     }
 
-    fn write_local_common_config(&self, local_config: &gix::config::File) -> anyhow::Result<()> {
-        use std::io::Write;
-        // Note: we don't use a lock file here to not risk changing the mode, and it's what Git does.
-        //       But we lock the file so there is no raciness.
-        let local_config_path = self.common_dir().join("config");
-        let _lock = gix::lock::Marker::acquire_to_hold_resource(
-            &local_config_path,
-            gix::lock::acquire::Fail::Immediately,
-            None,
-        )?;
-        let mut config_file = std::io::BufWriter::new(
-            std::fs::File::options()
-                .write(true)
-                .truncate(true)
-                .create(false)
-                .open(local_config_path)?,
-        );
-        local_config.write_to_filter(&mut config_file, |section| {
-            section.meta().source.kind() == gix::config::source::Kind::Repository
-        })?;
-        config_file.flush()?;
-        Ok(())
+    fn write_locked_config(
+        &self,
+        local_config: &gix::config::File,
+        lock: gix::lock::File,
+    ) -> anyhow::Result<()> {
+        crate::git_config::write_locked_config(local_config, lock)
     }
 
     fn cherry_pick_commits_to_tree(