Merge pull request #10525 from gitbutlerapp/integrate-upstream-workspace-update

integrate-upstream-workspace-update

Author: estib-vega

apps/desktop/cypress/e2e/support/index.ts

@@ -180,6 +180,11 @@ Cypress.on('window:before:load', (win) => {
 				return await Promise.resolve({});
 			case 'plugin:log|log':
 				return await Promise.resolve({});
+			case 'plugin:window|title':
+			case 'plugin:app|name':
+				return 'GitButler';
+			case 'plugin:app|version':
+				return '0.0.0';
 			default:
 				return raiseMissingMockError(command);
 		}

apps/desktop/cypress/e2e/upstreamIntegration.cy.ts

@@ -84,27 +84,27 @@ describe('Upstream Integration', () => {
 			projectId: PROJECT_ID,
 			resolutions: [
 				{
-					branchId: 'stack-a-id',
+					stackId: 'stack-a-id',
 					approach: { type: 'rebase' },
 					deleteIntegratedBranches: true,
 					forceIntegratedBranches: []
 				},
 				{
-					branchId: 'stack-b-id',
+					stackId: 'stack-b-id',
 					approach: { type: 'delete' },
 					deleteIntegratedBranches: false,
 					forceIntegratedBranches: []
 				},
 				{
-					branchId: 'stack-c-id',
+					stackId: 'stack-c-id',
 					approach: {
 						type: 'delete'
 					},
 					deleteIntegratedBranches: true,
 					forceIntegratedBranches: []
 				}
 			],
-			branchResolution: undefined
+			baseBranchResolution: undefined
 		});
 	});
 });

apps/desktop/src/components/IntegrateUpstreamModal.svelte

@@ -107,7 +107,7 @@
 				const dontDelete = someBranchesShouldNotBeDeleted(status.stack.heads.map((b) => b.name));
 
 				results.set(status.stack.id, {
-					branchId: status.stack.id,
+					stackId: status.stack.id,
 					approach: getResolutionApproachV3(status),
 					deleteIntegratedBranches: !dontDelete,
 					forceIntegratedBranches

apps/desktop/src/lib/upstream/types.ts

@@ -49,7 +49,7 @@ export type ResolutionApproach = {
 };
 
 export type Resolution = {
-	branchId: string;
+	stackId: string;
 	approach: ResolutionApproach;
 	deleteIntegratedBranches: boolean;
 	forceIntegratedBranches: string[];

crates/but-workspace/src/stack_ext.rs

@@ -65,3 +65,44 @@ impl StackExt for gitbutler_stack::Stack {
         Ok(steps)
     }
 }
+
+/// Extension trait for `but_workspace::ui::StackDetails`.
+pub trait StackDetailsExt {
+    /// Return the stack as a series of rebase steps in the order the steps should be applied.
+    fn as_rebase_steps(&self, repo: &gix::Repository) -> anyhow::Result<Vec<RebaseStep>>;
+    /// Return the stack as a series of rebase steps in reverse order, i.e. in the order they were generated.
+    ///
+    /// The generation order starts at the top of the stack (tip first) and goes down to the merge base (parent most commit).
+    /// This is useful for operations that need to process the stack in reverse order.
+    fn as_rebase_steps_rev(&self, repo: &gix::Repository) -> anyhow::Result<Vec<RebaseStep>>;
+}
+
+impl StackDetailsExt for crate::ui::StackDetails {
+    fn as_rebase_steps(&self, repo: &gix::Repository) -> anyhow::Result<Vec<RebaseStep>> {
+        self.as_rebase_steps_rev(repo).map(|mut steps| {
+            steps.reverse();
+            steps
+        })
+    }
+
+    fn as_rebase_steps_rev(&self, repo: &gix::Repository) -> anyhow::Result<Vec<RebaseStep>> {
+        let mut steps: Vec<RebaseStep> = Vec::new();
+        for branch in &self.branch_details {
+            let reference_step = if let Some(reference) = repo.try_find_reference(&branch.name)? {
+                RebaseStep::Reference(but_core::Reference::Git(reference.name().to_owned()))
+            } else {
+                RebaseStep::Reference(but_core::Reference::Virtual(branch.name.to_string()))
+            };
+            steps.push(reference_step);
+            let commits = &branch.commits;
+            for commit in commits {
+                let pick_step = RebaseStep::Pick {
+                    commit_id: commit.id,
+                    new_message: None,
+                };
+                steps.push(pick_step);
+            }
+        }
+        Ok(steps)
+    }
+}

crates/but-workspace/src/ui/mod.rs

@@ -1,5 +1,6 @@
 use anyhow::Context;
 use bstr::{BStr, BString, ByteSlice};
+use gix::refs::transaction::{Change, PreviousValue, RefEdit, RefLog};
 use serde::Serialize;
 
 /// Utilities for diffing, with workspace integration.
@@ -83,6 +84,27 @@ pub struct StackHeadInfo {
     pub is_checked_out: bool,
 }
 
+impl StackHeadInfo {
+    /// Delete the reference for this head from the repository if it exists and matches the expected OID.
+    pub fn delete_reference(&self, repo: &gix::Repository) -> anyhow::Result<()> {
+        let oid = self.tip;
+        let ref_name = format!("refs/heads/{}", self.name.to_str()?.trim_matches('/'));
+        let current_name: BString = ref_name.into();
+        if let Some(reference) = repo.try_find_reference(&current_name)? {
+            let delete = RefEdit {
+                change: Change::Delete {
+                    expected: PreviousValue::MustExistAndMatch(oid.into()),
+                    log: RefLog::AndReference,
+                },
+                name: reference.name().into(),
+                deref: false,
+            };
+            repo.edit_reference(delete)?;
+        }
+        Ok(())
+    }
+}
+
 /// Represents a lightweight version of a [`Stack`] for listing.
 /// NOTE: this is a UI type mostly because it's still modeled after the legacy stack with StackId, something that doesn't exist anymore.
 #[derive(Debug, Clone, Serialize)]

crates/but/src/base/mod.rs

@@ -125,7 +125,11 @@ pub fn handle(cmd: &Subcommands, project: &Project, json: bool) -> anyhow::Resul
                     } else {
                         println!("🔄 Updating branches...");
                         let mut resolutions = vec![];
-                        for (id, status) in statuses {
+                        for (maybe_stack_id, status) in statuses {
+                            let Some(stack_id) = maybe_stack_id else {
+                                println!("No stack ID, assuming we're on single-branch mode...",);
+                                continue;
+                            };
                             let approach = if status
                                 .branch_statuses
                                 .iter()
@@ -137,7 +141,7 @@ pub fn handle(cmd: &Subcommands, project: &Project, json: bool) -> anyhow::Resul
                                     ResolutionApproach::Rebase
                                 };
                             let resolution = Resolution {
-                                branch_id: id, // This is StackId
+                                stack_id,
                                 approach,
                                 delete_integrated_branches: true,
                                 force_integrated_branches: vec![],