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

Integrate upstream & update stacks logic in workspace

Author: estib-vega

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![],