Do not dynamically calculate the head commit when listing virtual branches.

That way, the head is static which allows to re-use the worktree status across
multiple related calls.

Also, add a way to quickly get the `head_commit()` from a `git2::Repository`.

Note that this may cause breakage in the app, as now it will see the actual
head, not a computed one, but that should also help us to find places that
didn't properly update their state.

Author: Byron

crates/gitbutler-branch-actions/src/branch.rs

@@ -8,6 +8,7 @@ use gitbutler_branch::{
 use gitbutler_command_context::{CommandContext, GixRepositoryExt};
 use gitbutler_project::access::WorktreeReadPermission;
 use gitbutler_reference::normalize_branch_name;
+use gitbutler_repo::RepositoryExt;
 use gitbutler_serde::BStringForFrontend;
 use gix::object::tree::diff::Action;
 use gix::prelude::ObjectIdExt;
@@ -27,12 +28,7 @@ pub(crate) fn get_uncommited_files(
     _permission: &WorktreeReadPermission,
 ) -> Result<Vec<RemoteBranchFile>> {
     let repository = context.repository();
-    let head_commit = repository
-        .head()
-        .context("Failed to get head")?
-        .peel_to_commit()
-        .context("Failed to get head commit")?;
-
+    let head_commit = repository.head_commit()?;
     let files = gitbutler_diff::workdir(repository, &head_commit.id())
         .context("Failed to list uncommited files")?
         .into_iter()

crates/gitbutler-branch-actions/src/status.rs

@@ -1,5 +1,11 @@
 use std::{collections::HashMap, path::PathBuf, vec};
 
+use crate::{
+    conflicts::RepoConflictsExt,
+    file::{virtual_hunks_into_virtual_files, VirtualBranchFile},
+    hunk::{file_hunks_from_diffs, HunkLock, VirtualBranchHunk},
+    BranchManagerExt, VirtualBranchesExt,
+};
 use anyhow::{bail, Context, Result};
 use git2::Tree;
 use gitbutler_branch::{
@@ -10,16 +16,9 @@ use gitbutler_command_context::CommandContext;
 use gitbutler_diff::{diff_files_into_hunks, GitHunk, Hunk, HunkHash};
 use gitbutler_operating_modes::assure_open_workspace_mode;
 use gitbutler_project::access::WorktreeWritePermission;
+use gitbutler_repo::RepositoryExt;
 use tracing::instrument;
 
-use crate::{
-    conflicts::RepoConflictsExt,
-    file::{virtual_hunks_into_virtual_files, VirtualBranchFile},
-    hunk::{file_hunks_from_diffs, HunkLock, VirtualBranchHunk},
-    integration::get_workspace_head,
-    BranchManagerExt, VirtualBranchesExt,
-};
-
 /// Represents the uncommitted status of the applied virtual branches in the workspace.
 pub struct VirtualBranchesStatus {
     /// A collection of branches and their associated uncommitted file changes.
@@ -37,13 +36,18 @@ pub fn get_applied_status(
     perm: Option<&mut WorktreeWritePermission>,
 ) -> Result<VirtualBranchesStatus> {
     assure_open_workspace_mode(ctx).context("ng applied status requires open workspace mode")?;
-    let integration_commit = get_workspace_head(ctx)?;
+    // TODO(ST): this was `get_workspace_head()`, which is slow and ideally, we don't dynamically
+    //           calculate which should already be 'fixed' - why do we have the integration branch
+    //           if we can't assume it's in the right state? So ideally, we assure that the code
+    //           that affects the integration branch also updates it?
+    let integration_commit_id = ctx.repository().head_commit()?.id();
     let mut virtual_branches = ctx
         .project()
         .virtual_branches()
         .list_branches_in_workspace()?;
-    let base_file_diffs = gitbutler_diff::workdir(ctx.repository(), &integration_commit.to_owned())
-        .context("failed to diff workdir")?;
+    let base_file_diffs =
+        gitbutler_diff::workdir(ctx.repository(), &integration_commit_id.to_owned())
+            .context("failed to diff workdir")?;
 
     let mut skipped_files: Vec<gitbutler_diff::FileDiff> = Vec::new();
     for file_diff in base_file_diffs.values() {

crates/gitbutler-branch-actions/tests/extra/mod.rs

@@ -973,6 +973,7 @@ fn merge_vbranch_upstream_conflict() -> Result<()> {
     )?;
 
     // make gb see the conflict resolution
+    gitbutler_branch_actions::update_gitbutler_integration(&vb_state, ctx)?;
     let (branches, _) = list_virtual_branches(ctx, guard.write_permission())?;
     assert!(branches[0].conflicted);
 

crates/gitbutler-branch-actions/tests/virtual_branches/convert_to_real_branch.rs

@@ -1,6 +1,3 @@
-use gitbutler_branch::BranchCreateRequest;
-use gitbutler_reference::Refname;
-
 use super::*;
 
 #[test]
@@ -101,6 +98,9 @@ fn conflicting() {
             "<<<<<<< ours\nconflict\n=======\nsecond\n>>>>>>> theirs\n"
         );
 
+        let vb_state = VirtualBranchesHandle::new(project.gb_dir());
+        let ctx = CommandContext::open(project).unwrap();
+        update_gitbutler_integration(&vb_state, &ctx).unwrap();
         let (branches, _) = controller.list_virtual_branches(project).unwrap();
 
         assert_eq!(branches.len(), 1);

crates/gitbutler-branch-actions/tests/virtual_branches/mod.rs

@@ -1,7 +1,8 @@
 use std::{fs, path, path::PathBuf, str::FromStr};
 
-use gitbutler_branch::BranchCreateRequest;
-use gitbutler_branch_actions::VirtualBranchActions;
+use gitbutler_branch::{BranchCreateRequest, VirtualBranchesHandle};
+use gitbutler_branch_actions::{update_gitbutler_integration, VirtualBranchActions};
+use gitbutler_command_context::CommandContext;
 use gitbutler_error::error::Marker;
 use gitbutler_project::{self as projects, Project, ProjectId};
 use gitbutler_reference::Refname;
@@ -137,6 +138,9 @@ fn resolve_conflict_flow() {
             .create_virtual_branch_from_branch(project, &unapplied_branch, None)
             .unwrap();
 
+        let vb_state = VirtualBranchesHandle::new(project.gb_dir());
+        let ctx = CommandContext::open(project).unwrap();
+        update_gitbutler_integration(&vb_state, &ctx).unwrap();
         let (branches, _) = controller.list_virtual_branches(project).unwrap();
         assert_eq!(branches.len(), 1);
         assert!(branches[0].active);

crates/gitbutler-branch-actions/tests/virtual_branches/update_base_branch.rs

@@ -731,6 +731,9 @@ mod applied_branch {
                 )
                 .unwrap();
 
+            let vb_state = VirtualBranchesHandle::new(project.gb_dir());
+            let ctx = CommandContext::open(project).unwrap();
+            update_gitbutler_integration(&vb_state, &ctx).unwrap();
             let (branches, _) = controller.list_virtual_branches(project).unwrap();
             assert_eq!(branches.len(), 1);
             assert!(branches[0].active);

crates/gitbutler-oplog/src/oplog.rs

@@ -260,6 +260,7 @@ impl OplogExt for Project {
         restore_snapshot(self, snapshot_commit_id, guard.write_permission())
     }
 
+    #[instrument(level = tracing::Level::DEBUG, skip(self), err(Debug))]
     fn should_auto_snapshot(&self, check_if_last_snapshot_older_than: Duration) -> Result<bool> {
         let last_snapshot_time = OplogHandle::new(&self.gb_dir()).modified_at()?;
         if last_snapshot_time.elapsed()? <= check_if_last_snapshot_older_than {
@@ -711,6 +712,7 @@ fn write_conflicts_tree(
 
 /// Exclude files that are larger than the limit (eg. database.sql which may never be intended to be committed)
 /// TODO(ST): refactor this to be path-safe and ' ' save - the returned list is space separated (!!)
+#[instrument(level = tracing::Level::DEBUG, skip(repo), err(Debug))]
 fn worktree_files_larger_than_limit_as_git2_ignore_rule(
     repo: &git2::Repository,
     worktree_dir: &Path,
@@ -765,6 +767,7 @@ fn lines_since_snapshot(project: &Project, repo: &git2::Repository) -> Result<us
     Ok(lines_changed)
 }
 
+#[instrument(level = tracing::Level::DEBUG, skip(branch, repo), err(Debug))]
 fn branch_lines_since_snapshot(
     branch: &Branch,
     repo: &git2::Repository,

crates/gitbutler-repo/src/repository_ext.rs

@@ -17,6 +17,7 @@ use tracing::instrument;
 ///
 /// For now, it collects useful methods from `gitbutler-core::git::Repository`
 pub trait RepositoryExt {
+    fn head_commit(&self) -> Result<git2::Commit<'_>>;
     fn remote_branches(&self) -> Result<Vec<RemoteRefname>>;
     fn remotes_as_string(&self) -> Result<Vec<String>>;
     /// Open a new in-memory repository and executes the provided closure using it.
@@ -72,6 +73,13 @@ pub trait RepositoryExt {
 }
 
 impl RepositoryExt for git2::Repository {
+    fn head_commit(&self) -> Result<git2::Commit<'_>> {
+        self.head()
+            .context("Failed to get head")?
+            .peel_to_commit()
+            .context("Failed to get head commit")
+    }
+
     fn in_memory<T, F>(&self, f: F) -> Result<T>
     where
         F: FnOnce(&git2::Repository) -> Result<T>,