Rebase identity tests

Author: Caleb-T-Owens

crates/but-rebase/src/graph_rebase/creation.rs

@@ -87,7 +87,7 @@ impl GraphExt for Graph {
                 }
             }
 
-            last_inserted = Some(ni.clone());
+            last_inserted = Some(ni);
             steps_for_commits.insert(c.id, ni);
         }
 

crates/but-rebase/src/graph_rebase/materialize.rs

@@ -0,0 +1,29 @@
+//! Functions for materializing a rebase
+use crate::graph_rebase::rebase::SuccessfulRebase;
+use anyhow::Result;
+use but_core::worktree::{
+    checkout::{Options, UncommitedWorktreeChanges},
+    safe_checkout,
+};
+
+impl SuccessfulRebase {
+    /// Materializes a history rewrite
+    pub fn materialize(&self, repo: &gix::Repository) -> Result<()> {
+        for checkout in &self.checkouts {
+            // TODO(CTO): improve safe_checkout to allow for speculation
+            safe_checkout(
+                checkout.old_head_id,
+                checkout.head_id,
+                repo,
+                Options {
+                    uncommitted_changes: UncommitedWorktreeChanges::KeepAndAbortOnConflict,
+                    skip_head_update: true,
+                },
+            )?;
+        }
+
+        repo.edit_references(self.ref_edits.clone())?;
+
+        Ok(())
+    }
+}

crates/but-rebase/src/graph_rebase/mod.rs

@@ -10,6 +10,8 @@ mod creation;
 pub mod rebase;
 pub use creation::GraphExt;
 pub mod cherry_pick;
+pub mod materialize;
+pub mod mutate;
 
 /// Utilities for testing
 pub mod testing;
@@ -49,7 +51,7 @@ type StepGraph = petgraph::stable_graph::StableDiGraph<Step, Edge>;
 /// Points to a step in the rebase editor.
 #[derive(Debug, Clone)]
 pub struct Selector {
-    id: NodeIndex<StepGraphIndex>,
+    id: StepGraphIndex,
 }
 
 /// Used to manipulate a set of picks.

crates/but-rebase/src/graph_rebase/mutate.rs

@@ -0,0 +1,41 @@
+//! Operations for mutation the editor
+
+use crate::graph_rebase::{Editor, Selector, Step};
+
+/// Operations for mutating the commit graph
+impl Editor {
+    /// Get a selector to a particular commit in the graph
+    pub fn select_commit(&self, target: gix::ObjectId) -> Option<Selector> {
+        for node_idx in self.graph.node_indices() {
+            if let Step::Pick { id } = self.graph[node_idx]
+                && id == target
+            {
+                return Some(Selector { id: node_idx });
+            }
+        }
+
+        None
+    }
+
+    /// Get a selector to a particular reference in the graph
+    pub fn select_reference(&self, target: &gix::refs::FullNameRef) -> Option<Selector> {
+        for node_idx in self.graph.node_indices() {
+            if let Step::Reference { refname } = &self.graph[node_idx]
+                && target == refname.as_ref()
+            {
+                return Some(Selector { id: node_idx });
+            }
+        }
+
+        None
+    }
+
+    /// Replaces the node that the function was pointing to.
+    ///
+    /// Returns the replaced step.
+    pub fn replace(&mut self, target: &Selector, step: Step) -> Step {
+        let old = self.graph[target.id].clone();
+        self.graph[target.id] = step;
+        old
+    }
+}

crates/but-rebase/src/graph_rebase/rebase.rs

@@ -13,6 +13,15 @@ use gix::refs::{
 };
 use petgraph::visit::EdgeRef;
 
+/// Represents somethign to be checked out - I'm not quite sure how
+/// `safe_checkout` knows what is the main checkout & what is a worktree - but
+/// that is some voodoo I'm not touching right now
+#[derive(Debug, Clone)]
+pub struct CheckoutSpec {
+    pub(crate) old_head_id: gix::ObjectId,
+    pub(crate) head_id: gix::ObjectId,
+}
+
 /// Represents a successful rebase, and any valid, but potentially conflicting scenarios it had.
 #[allow(unused)]
 #[derive(Debug, Clone)]
@@ -26,6 +35,10 @@ pub struct SuccessfulRebase {
     pub(crate) ref_edits: Vec<RefEdit>,
     /// The new step graph
     pub(crate) graph: StepGraph,
+    /// Heads
+    pub(crate) heads: Vec<StepGraphIndex>,
+    /// To checkout
+    pub(crate) checkouts: Vec<CheckoutSpec>,
 }
 
 /// Represents the rebase output and the varying degrees of success it had.
@@ -61,11 +74,13 @@ impl Editor {
         // The step graph with updated commit oids
         let mut output_graph = StepGraph::new();
         let mut commit_mapping = HashMap::new();
+        let mut checkouts = vec![];
+        let mut unchanged_references = vec![];
 
         for step_idx in steps_to_pick {
             // Do the frikkin rebase man!
             let step = self.graph[step_idx].clone();
-            match step {
+            let new_idx = match step {
                 Step::Pick { id } => {
                     let graph_parents = collect_ordered_parents(&self.graph, step_idx);
                     let ontos = graph_parents
@@ -93,12 +108,14 @@ impl Editor {
                             if id != new_id {
                                 commit_mapping.insert(id, new_id);
                             }
+
+                            new_idx
                         }
                         CherryPickOutcome::FailedToMergeBases => {
                             // Exit early - the rebase failed because it encountered a commit it couldn't pick
                             return Ok(RebaseOutcome::MergePickFailed(id));
                         }
-                    };
+                    }
                 }
                 Step::Reference { refname } => {
                     let graph_parents = collect_ordered_parents(&self.graph, step_idx);
@@ -120,7 +137,9 @@ impl Editor {
                         let target = reference.target();
                         match target {
                             gix::refs::TargetRef::Object(id) => {
-                                if id != to_reference {
+                                if id == to_reference {
+                                    unchanged_references.push(refname.clone());
+                                } else {
                                     ref_edits.push(RefEdit {
                                         name: refname.clone(),
                                         change: Change::Update {
@@ -132,6 +151,18 @@ impl Editor {
                                         },
                                         deref: false,
                                     });
+
+                                    // TODO(CTO): This is FAR from the full set
+                                    // of capabilities needed here.  This ommits
+                                    // any consideration of the head commit
+                                    // being replaced. This really needs to do
+                                    // some other lookup of all the heads
+                                    if self.heads.contains(&step_idx) {
+                                        checkouts.push(CheckoutSpec {
+                                            old_head_id: id.into(),
+                                            head_id: to_reference,
+                                        });
+                                    }
                                 }
                             }
                             gix::refs::TargetRef::Symbolic(name) => {
@@ -150,38 +181,67 @@ impl Editor {
                         });
                     };
 
-                    let new_idx = output_graph.add_node(Step::Reference { refname });
-                    graph_mapping.insert(step_idx, new_idx);
-                }
-                Step::None => {
-                    let new_idx = output_graph.add_node(Step::None);
-                    graph_mapping.insert(step_idx, new_idx);
+                    output_graph.add_node(Step::Reference { refname })
                 }
+                Step::None => output_graph.add_node(Step::None),
             };
 
-            // Find deleted references
-            for reference in self.initial_references.iter() {
-                if !ref_edits
+            graph_mapping.insert(step_idx, new_idx);
+
+            let mut edges = self
+                .graph
+                .edges_directed(step_idx, petgraph::Direction::Outgoing)
+                .collect::<Vec<_>>();
+            edges.sort_by_key(|e| e.weight().order);
+            edges.reverse();
+
+            for e in edges {
+                let Some(new_parent) = graph_mapping.get(&e.target()) else {
+                    bail!("Failed to find cooresponding parent");
+                };
+
+                output_graph.add_edge(new_idx, *new_parent, e.weight().clone());
+            }
+        }
+
+        // Find deleted references
+        for reference in self.initial_references.iter() {
+            if !ref_edits
+                .iter()
+                .any(|e| e.name.as_ref() == reference.as_ref())
+                && !unchanged_references
                     .iter()
-                    .any(|e| e.name.as_ref() == reference.as_ref())
-                {
-                    ref_edits.push(RefEdit {
-                        name: reference.clone(),
-                        change: Change::Delete {
-                            log: gix::refs::transaction::RefLog::AndReference,
-                            expected: PreviousValue::MustExist,
-                        },
-                        deref: false,
-                    });
-                }
+                    .any(|e| e.as_ref() == reference.as_ref())
+            {
+                ref_edits.push(RefEdit {
+                    name: reference.clone(),
+                    change: Change::Delete {
+                        log: gix::refs::transaction::RefLog::AndReference,
+                        expected: PreviousValue::MustExist,
+                    },
+                    deref: false,
+                });
             }
         }
 
+        let heads = self
+            .heads
+            .iter()
+            .map(|h| {
+                graph_mapping
+                    .get(h)
+                    .context("Failed to get new head")
+                    .cloned()
+            })
+            .collect::<Result<Vec<_>>>()?;
+
         Ok(RebaseOutcome::Success(SuccessfulRebase {
             ref_edits,
             commit_mapping,
             graph_mapping,
             graph: output_graph,
+            heads,
+            checkouts,
         }))
     }
 }