Automatically setup the remote tracking of branches on apply

Author: Byron

crates/but-core/src/lib.rs

@@ -83,6 +83,28 @@ pub use repo_ext::RepositoryExt;
 pub mod ref_metadata;
 use crate::ref_metadata::ValueInfo;
 
+/// A utility to extra the name of the remote from a remote tracking ref with `ref_name`.
+/// If it's not a remote tracking ref, or no remote in `remote_names` (like `origin`) matches,
+/// `None` is returned.
+pub fn extract_remote_name(
+    ref_name: &gix::refs::FullNameRef,
+    remote_names: &gix::remote::Names<'_>,
+) -> Option<String> {
+    let (category, shorthand_name) = ref_name.category_and_short_name()?;
+    if !matches!(category, gix::refs::Category::RemoteBranch) {
+        return None;
+    }
+
+    let longest_remote = remote_names
+        .iter()
+        .rfind(|reference_name| shorthand_name.starts_with(reference_name))
+        .ok_or(anyhow::anyhow!(
+            "Failed to find remote branch's corresponding remote"
+        ))
+        .ok()?;
+    Some(longest_remote.to_string())
+}
+
 /// A trait to associate arbitrary metadata with any *Git reference name*.
 /// Note that a single reference name can have multiple distinct pieces of metadata associated with it.
 pub trait RefMetadata {

crates/but-core/src/repo_ext.rs

@@ -1,6 +1,7 @@
 use anyhow::Context;
 use gitbutler_error::error::Code;
 use gix::prelude::ObjectIdExt;
+use std::io::Write;
 
 use crate::{GitConfigSettings, commit::TreeKind};
 
@@ -14,6 +15,13 @@ pub trait RepositoryExt {
     fn commit_signatures(&self) -> anyhow::Result<(gix::actor::Signature, gix::actor::Signature)>;
     /// Return labels that would be written into the conflict markers when merging blobs.
     fn default_merge_labels(&self) -> gix::merge::blob::builtin_driver::text::Labels<'static>;
+
+    /// Return the configuration freshly loaded from `.git/config` so that it can be changed in memory,
+    /// and possibly written back with [Self::write_local_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<()>;
     /// 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.
@@ -105,9 +113,40 @@ impl RepositoryExt for gix::Repository {
         let config = repo.config_snapshot();
         GitConfigSettings::try_from_snapshot(&config)
     }
+
     fn set_git_settings(&self, settings: &GitConfigSettings) -> anyhow::Result<()> {
         settings.persist_to_local_config(self)
     }
+
+    fn local_common_config_for_editing(&self) -> anyhow::Result<gix::config::File<'static>> {
+        let local_config_path = self.common_dir().join("config");
+        let config = gix::config::File::from_path_no_includes(
+            local_config_path.clone(),
+            gix::config::Source::Local,
+        )?;
+        Ok(config)
+    }
+
+    fn write_local_common_config(&self, local_config: &gix::config::File) -> anyhow::Result<()> {
+        // 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(&mut config_file)?;
+        config_file.flush()?;
+        Ok(())
+    }
 }
 
 const GITBUTLER_COMMIT_AUTHOR_NAME: &str = "GitButler";

crates/but-core/src/settings.rs

@@ -1,6 +1,6 @@
 /// A module to bundle configuration we *write* per repository, but read as normal.
 pub mod git {
-    use std::{borrow::Cow, ffi::OsString, io::Write, path::Path};
+    use std::{borrow::Cow, ffi::OsString};
 
     use anyhow::Result;
     use bstr::{BString, ByteSlice};
@@ -106,6 +106,7 @@ pub mod git {
             pub gpg_ssh_program: Option<OsString>,
         }
     }
+    use crate::RepositoryExt;
     use types::GitConfigSettings;
 
     impl GitConfigSettings {
@@ -134,11 +135,7 @@ pub mod git {
         pub fn persist_to_local_config(&self, repo: &gix::Repository) -> Result<()> {
             // TODO: make this easier in `gix`. Could use config-snapshot-mut, but there is no way to
             //       auto-reload it/assure it's uptodate.
-            let local_config_path = repo.path().join("config");
-            let mut config = gix::config::File::from_path_no_includes(
-                local_config_path.clone(),
-                gix::config::Source::Local,
-            )?;
+            let mut config = repo.local_common_config_for_editing()?;
             if let Some(sign_commits) = self.gitbutler_sign_commits {
                 config.set_raw_value(
                     &GITBUTLER_SIGN_COMMITS,
@@ -162,31 +159,11 @@ pub mod git {
                 config.set_raw_value(&GPG_SSH_PROGRAM, gpg_ssh_program.as_bstr())?;
             }
 
-            write_config(&mut config, &local_config_path)?;
+            repo.write_local_common_config(&config)?;
             Ok(())
         }
     }
 
-    fn write_config(config: &mut gix::config::File<'_>, local_config_path: &Path) -> Result<()> {
-        // 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 _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)?,
-        );
-        config.write_to(&mut config_file)?;
-        config_file.flush()?;
-        Ok(())
-    }
-
     fn osstring_into_bstring(s: &OsString) -> Option<BString> {
         match gix::path::os_str_into_bstr(s) {
             Ok(s) => Some(s.to_owned()),

crates/but-graph/src/init/mod.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context, bail};
 use bstr::ByteSlice;
-use but_core::{RefMetadata, ref_metadata};
+use but_core::{RefMetadata, extract_remote_name, ref_metadata};
 use gix::{
     hashtable::hash_map::Entry,
     prelude::{ObjectIdExt, ReferenceExt},
@@ -320,7 +320,7 @@ impl Graph {
                     data.target_ref
                         .as_ref()
                         .and_then(|target| {
-                            remotes::extract_remote_name(target.as_ref(), &remote_names)
+                            extract_remote_name(target.as_ref(), &remote_names)
                                 .map(|remote| (1, remote))
                         })
                         .into_iter()
@@ -329,7 +329,7 @@ impl Graph {
                 .chain(workspaces.iter().flat_map(|(_, _, data)| {
                     data.stacks.iter().flat_map(|s| {
                         s.branches.iter().flat_map(|b| {
-                            remotes::extract_remote_name(b.ref_name.as_ref(), &remote_names)
+                            extract_remote_name(b.ref_name.as_ref(), &remote_names)
                                 .map(|remote| (1, remote))
                         })
                     })

crates/but-graph/src/init/remotes.rs

@@ -60,25 +60,6 @@ pub fn lookup_remote_tracking_branch_or_deduce_it(
     }))
 }
 
-pub fn extract_remote_name(
-    ref_name: &gix::refs::FullNameRef,
-    remotes: &gix::remote::Names<'_>,
-) -> Option<String> {
-    let (category, shorthand_name) = ref_name.category_and_short_name()?;
-    if !matches!(category, Category::RemoteBranch) {
-        return None;
-    }
-
-    let longest_remote = remotes
-        .iter()
-        .rfind(|reference_name| shorthand_name.starts_with(reference_name))
-        .ok_or(anyhow::anyhow!(
-            "Failed to find remote branch's corresponding remote"
-        ))
-        .ok()?;
-    Some(longest_remote.to_string())
-}
-
 pub fn lookup_remote_tracking_branch(
     repo: &OverlayRepo<'_>,
     ref_name: &gix::refs::FullNameRef,