Replace all relevant occurrences of integration with workspace

Author: mtsgrd

crates/gitbutler-branch-actions/benches/branches.rs

@@ -18,7 +18,7 @@ pub fn benchmark_list_branches(c: &mut Criterion) {
         (
             "list-branches[tiny repo]",
             3,
-            ("one-vbranch-on-integration-two-remotes", "for-listing.sh"),
+            ("one-vbranch-in-workspace-two-remotes", "for-listing.sh"),
         ),
         (
             "list-branches[many local branches [packed]]",
@@ -59,7 +59,7 @@ pub fn benchmark_branch_details(c: &mut Criterion) {
         (
             "branch-details [tiny no change]",
             (
-                "one-vbranch-on-integration-two-remotes",
+                "one-vbranch-in-workspace-two-remotes",
                 "main",
                 0,
                 "for-listing.sh",

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

@@ -17,7 +17,7 @@ use crate::{
     branch_manager::BranchManagerExt,
     conflicts::RepoConflictsExt,
     hunk::VirtualBranchHunk,
-    integration::update_gitbutler_integration,
+    integration::update_workspace_commit,
     remote::{commit_to_remote_commit, RemoteCommit},
     status::get_applied_status,
     VirtualBranchesExt,
@@ -105,7 +105,7 @@ fn go_back_to_integration(ctx: &CommandContext, default_target: &Target) -> Resu
         .context("failed to checkout tree")?;
 
     let base = target_to_base_branch(ctx, default_target)?;
-    update_gitbutler_integration(&vb_state, ctx)?;
+    update_workspace_commit(&vb_state, ctx)?;
     Ok(base)
 }
 
@@ -260,7 +260,7 @@ pub(crate) fn set_base_branch(
 
     set_exclude_decoration(ctx)?;
 
-    update_gitbutler_integration(&vb_state, ctx)?;
+    update_workspace_commit(&vb_state, ctx)?;
 
     let base = target_to_base_branch(ctx, &target)?;
     Ok(base)
@@ -549,7 +549,7 @@ pub(crate) fn update_base_branch(
     })?;
 
     // Rewriting the integration commit is necessary after changing target sha.
-    crate::integration::update_gitbutler_integration(&vb_state, ctx)?;
+    crate::integration::update_workspace_commit(&vb_state, ctx)?;
     Ok(unapplied_branch_names)
 }
 

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

@@ -16,7 +16,7 @@ use crate::{
     conflicts::{self, RepoConflictsExt},
     ensure_selected_for_changes,
     hunk::VirtualBranchHunk,
-    integration::update_gitbutler_integration,
+    integration::update_workspace_commit,
     set_ownership, undo_commit, VirtualBranchesExt,
 };
 
@@ -514,7 +514,7 @@ impl BranchManager<'_> {
             }
         }
 
-        update_gitbutler_integration(&vb_state, self.ctx)?;
+        update_workspace_commit(&vb_state, self.ctx)?;
 
         Ok(branch.name)
     }

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

@@ -49,7 +49,7 @@ impl BranchManager<'_> {
         // Ensure we still have a default target
         ensure_selected_for_changes(&vb_state).context("failed to ensure selected for changes")?;
 
-        crate::integration::update_gitbutler_integration(&vb_state, self.ctx)?;
+        crate::integration::update_workspace_commit(&vb_state, self.ctx)?;
 
         real_branch.reference_name()
     }

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

@@ -27,7 +27,7 @@ pub const GITBUTLER_WORKSPACE_COMMIT_TITLE: &str = "GitButler Workspace Commit";
 /// what files have been modified.
 ///
 /// This should be used to update the `gitbutler/workspace` ref with, which is usually
-/// done from [`update_gitbutler_integration()`], after any of its input changes.
+/// done from [`update_workspace_commit()`], after any of its input changes.
 /// This is namely the conflicting state, or any head of the virtual branches.
 #[instrument(level = tracing::Level::DEBUG, skip(ctx))]
 pub(crate) fn get_workspace_head(ctx: &CommandContext) -> Result<git2::Oid> {
@@ -105,7 +105,7 @@ struct PreviousHead {
     sha: String,
 }
 
-fn read_integration_file(path: &PathBuf) -> Result<Option<PreviousHead>> {
+fn read_workspace_file(path: &PathBuf) -> Result<Option<PreviousHead>> {
     if let Ok(prev_data) = std::fs::read_to_string(path) {
         let parts: Vec<&str> = prev_data.split(':').collect();
         let prev_head = parts[0].to_string();
@@ -119,13 +119,13 @@ fn read_integration_file(path: &PathBuf) -> Result<Option<PreviousHead>> {
     }
 }
 
-fn write_integration_file(head: &git2::Reference, path: PathBuf) -> Result<()> {
+fn write_workspace_file(head: &git2::Reference, path: PathBuf) -> Result<()> {
     let sha = head.target().unwrap().to_string();
     std::fs::write(path, format!(":{}", sha))?;
     Ok(())
 }
 #[instrument(level = tracing::Level::DEBUG, skip(vb_state, ctx), err(Debug))]
-pub fn update_gitbutler_integration(
+pub fn update_workspace_commit(
     vb_state: &VirtualBranchesHandle,
     ctx: &CommandContext,
 ) -> Result<git2::Oid> {
@@ -137,13 +137,13 @@ pub fn update_gitbutler_integration(
 
     // get current repo head for reference
     let head_ref = repo.head()?;
-    let integration_filepath = repo.path().join("integration");
-    let mut prev_branch = read_integration_file(&integration_filepath)?;
+    let workspace_filepath = repo.path().join("workspace");
+    let mut prev_branch = read_workspace_file(&workspace_filepath)?;
     if let Some(branch) = &prev_branch {
         if branch.head != GITBUTLER_WORKSPACE_REFERENCE.to_string() {
             // we are moving from a regular branch to our gitbutler workspace branch, write a file to
-            // .git/integration with the previous head and name
-            write_integration_file(&head_ref, integration_filepath)?;
+            // .git/workspace with the previous head and name
+            write_workspace_file(&head_ref, workspace_filepath)?;
             prev_branch = Some(PreviousHead {
                 head: head_ref.target().unwrap().to_string(),
                 sha: head_ref.target().unwrap().to_string(),
@@ -230,7 +230,7 @@ pub fn update_gitbutler_integration(
         &GITBUTLER_WORKSPACE_REFERENCE.clone().to_string(),
         final_commit,
         true,
-        "updated integration commit",
+        "updated workspace commit",
     )?;
     repo.set_head(&GITBUTLER_WORKSPACE_REFERENCE.clone().to_string())?;
 
@@ -333,7 +333,7 @@ fn verify_head_is_clean(ctx: &CommandContext, perm: &mut WorktreeWritePermission
         .log(head_commit.id(), LogUntil::Commit(default_target.sha))
         .context("failed to get log")?;
 
-    let integration_index = commits
+    let workspace_index = commits
         .iter()
         .position(|commit| {
             commit.message().is_some_and(|message| {
@@ -342,8 +342,8 @@ fn verify_head_is_clean(ctx: &CommandContext, perm: &mut WorktreeWritePermission
             })
         })
         .context("GitButler workspace commit not found")?;
-    let integration_commit = &commits[integration_index];
-    let mut extra_commits = commits[..integration_index].to_vec();
+    let workspace_commit = &commits[workspace_index];
+    let mut extra_commits = commits[..workspace_index].to_vec();
     extra_commits.reverse();
 
     if extra_commits.is_empty() {
@@ -352,8 +352,8 @@ fn verify_head_is_clean(ctx: &CommandContext, perm: &mut WorktreeWritePermission
     }
 
     ctx.repository()
-        .reset(integration_commit.as_object(), git2::ResetType::Soft, None)
-        .context("failed to reset to integration commit")?;
+        .reset(workspace_commit.as_object(), git2::ResetType::Soft, None)
+        .context("failed to reset to workspace commit")?;
 
     let branch_manager = ctx.branch_manager();
     let mut new_branch = branch_manager

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

@@ -12,7 +12,7 @@ mod base;
 pub use base::BaseBranch;
 
 mod integration;
-pub use integration::{update_gitbutler_integration, verify_branch};
+pub use integration::{update_workspace_commit, verify_branch};
 
 mod file;
 pub use file::{Get, RemoteBranchFile};

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

@@ -55,8 +55,8 @@ pub fn get_applied_status_cached(
         // TODO(ST): Ideally, we can avoid calling `get_workspace_head()` as everyone who modifies
         //           any of its inputs will update the intragration commit right away.
         //           It's for another day though - right now the integration commit may be slightly stale.
-        let integration_commit_id = get_workspace_head(ctx)?;
-        gitbutler_diff::workdir(ctx.repository(), integration_commit_id.to_owned())
+        let workspace_head = get_workspace_head(ctx)?;
+        gitbutler_diff::workdir(ctx.repository(), workspace_head.to_owned())
             .context("failed to diff workdir")
     })?;
 
@@ -270,12 +270,12 @@ fn compute_locks(
         })
         .collect::<Vec<_>>();
 
-    let mut integration_hunks_by_path =
+    let mut workspace_hunks_by_path =
         HashMap::<PathBuf, Vec<(gitbutler_diff::GitHunk, &Branch)>>::new();
 
     for (branch, hunks_by_filepath) in branch_path_diffs {
         for (path, hunks) in hunks_by_filepath {
-            integration_hunks_by_path.entry(path).or_default().extend(
+            workspace_hunks_by_path.entry(path).or_default().extend(
                 hunks
                     .hunks
                     .iter()
@@ -288,17 +288,14 @@ fn compute_locks(
     let locked_hunks = unstaged_hunks_by_path
         .iter()
         .filter_map(|(path, hunks)| {
-            let integration_hunks = integration_hunks_by_path.get(path)?;
+            let workspace_hunks = workspace_hunks_by_path.get(path)?;
 
             let (unapplied_hunk, branches) = hunks.iter().find_map(|unapplied_hunk| {
                 // Find all branches that have a hunk that intersects with the unapplied hunk
-                let locked_to = integration_hunks
+                let locked_to = workspace_hunks
                     .iter()
-                    .filter_map(|(integration_hunk, branch)| {
-                        if GitHunk::integration_intersects_unapplied(
-                            integration_hunk,
-                            unapplied_hunk,
-                        ) {
+                    .filter_map(|(workspace_hunk, branch)| {
+                        if GitHunk::workspace_intersects_unapplied(workspace_hunk, unapplied_hunk) {
                             Some(*branch)
                         } else {
                             None