tmp

Author: Caleb-T-Owens

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

@@ -6,21 +6,37 @@ use crate::{
     ReferenceSpec,
     cherry_pick::EmptyCommit,
     cherry_pick_one,
-    graph_rebase::{Editor, Step, StepGraph, StepGraphIndex},
+    graph_rebase::{
+        Editor, Step, StepGraph, StepGraphIndex,
+        cherry_pick::{CherryPickOutcome, cherry_pick},
+    },
     to_commit,
 };
-use anyhow::{Context, Result};
+use anyhow::{Context, Result, bail};
 use petgraph::visit::EdgeRef;
 
-/// Represents the rebase output and the varying degrees of success it had.
-pub struct RebaseResult {
+/// Represents a successful rebase, and any valid, but potentially conflicting scenarios it had.
+#[derive(Debug, Clone)]
+pub struct SuccessfulRebase {
     references: Vec<ReferenceSpec>,
     commit_map: HashMap<gix::ObjectId, gix::ObjectId>,
 }
 
+/// Represents the rebase output and the varying degrees of success it had.
+#[derive(Debug, Clone)]
+pub enum RebaseOutcome {
+    /// The rebase
+    Success(SuccessfulRebase),
+    /// The graph rebase failed because we encountered a situation where we
+    /// couldn't merge bases.
+    ///
+    /// Holds the gix::ObjectId of the commit it failed to pick
+    MergePickFailed(gix::ObjectId),
+}
+
 impl Editor {
     /// Perform the rebase
-    pub fn rebase(&self, repo: &gix::Repository) -> Result<RebaseResult> {
+    pub fn rebase(&self, repo: &gix::Repository) -> Result<RebaseOutcome> {
         // First we want to get a list of nodes that can be reached by
         // traversing downwards from the heads that we care about.
         // Usually there would be just one "head" which is an index to access
@@ -41,41 +57,52 @@ impl Editor {
             let step = self.graph[step_idx].clone();
             match step {
                 Step::Pick { id } => {
-                    let commit = to_commit(repo, id)?;
                     let graph_parents = collect_ordered_parents(&self.graph, step_idx);
-
-                    match (commit.parents.len(), graph_parents.len()) {
-                        (0, 0) => {
-                            let new_idx = output_graph.add_node(step);
+                    let ontos = graph_parents
+                        .iter()
+                        .map(|idx| {
+                            let Some(new_idx) = graph_mapping.get(idx) else {
+                                bail!("A matching parent can't be found in the output graph");
+                            };
+
+                            match output_graph[*new_idx] {
+                                Step::Pick { id } => Ok(id),
+                                _ => bail!("A parent in the output graph is not a pick"),
+                            }
+                        })
+                        .collect::<Result<Vec<_>>>()?;
+
+                    let outcome = cherry_pick(repo, id, &ontos)?;
+
+                    match outcome {
+                        CherryPickOutcome::Commit(new_id)
+                        | CherryPickOutcome::ConflictedCommit(new_id)
+                        | CherryPickOutcome::Identity(new_id) => {
+                            let new_idx = output_graph.add_node(Step::Pick { id: new_id });
                             graph_mapping.insert(step_idx, new_idx);
                         }
-                        (1, 0) => {
-                            todo!("1 to 0 cherry pick is not implemented yet");
-                        }
-                        (0, 1) => {
-                            todo!("0 to 1 cherry pick is not implemented yet");
-                        }
-                        (1, 1) => {
-                            let (_, parent_id) = graph_parents.first().expect("Impossible");
-
-                            let new_commit = cherry_pick_one(
-                                repo,
-                                *parent_id,
-                                id,
-                                pick_mode,
-                                EmptyCommit::Keep,
-                            )?;
-
-                            let new_idx = output_graph.add_node(Step::Pick { id: new_commit });
-                            graph_mapping.insert(step_idx, new_idx);
-                        }
-                        (_, _) => {
-                            todo!("N to >2 parents & >2 parents to N is not implemented yet");
+                        CherryPickOutcome::FailedToMergeBases => {
+                            // Exit early - the rebase failed because it encountered a commit it couldn't pick
+                            return Ok(RebaseOutcome::MergePickFailed(id));
                         }
                     };
                 }
-                Step::Reference { refname } => {}
-                Step::None => {}
+                Step::Reference { refname } => {
+                    let graph_parents = collect_ordered_parents(&self.graph, step_idx);
+                    let first_parent_idx = graph_parents.first().context("References ")
+                    let Some(new_idx) = graph_mapping.get(idx) else {
+                        bail!("A matching parent can't be found in the output graph");
+                    };
+
+                    let to_reference = match output_graph[*new_idx] {
+                        Step::Pick { id } => id,
+                        _ => bail!("A parent in the output graph is not a pick"),
+                    };
+                }
+                Step::None => {
+                    let new_idx = output_graph.add_node(Step::None);
+                    graph_mapping.insert(step_idx, new_idx);
+                }
             };
         }
 
@@ -87,10 +114,7 @@ impl Editor {
 /// ordering.
 ///
 /// We do this via a pruned depth first search.
-fn collect_ordered_parents(
-    graph: &StepGraph,
-    target: StepGraphIndex,
-) -> Vec<(StepGraphIndex, gix::ObjectId)> {
+fn collect_ordered_parents(graph: &StepGraph, target: StepGraphIndex) -> Vec<StepGraphIndex> {
     let mut potential_parent_edges = graph
         .edges_directed(target, petgraph::Direction::Outgoing)
         .collect::<Vec<_>>();
@@ -106,7 +130,7 @@ fn collect_ordered_parents(
 
     while let Some(candidate) = potential_parent_edges.pop() {
         if let Step::Pick { id } = graph[candidate.target()] {
-            parents.push((candidate.target(), id));
+            parents.push(candidate.target());
             // Don't persue the children
             continue;
         };
@@ -223,7 +247,7 @@ mod test {
             graph.add_edge(c, e, Edge { order: 1 });
 
             let parents = collect_ordered_parents(&graph, a);
-            assert_eq!(&parents, &[(b, b_id), (d, d_id), (e, e_id), (f, f_id)]);
+            assert_eq!(&parents, &[b, d, e, f]);
 
             Ok(())
         }
@@ -260,7 +284,7 @@ mod test {
             graph.add_edge(c, e, Edge { order: 0 });
 
             let parents = collect_ordered_parents(&graph, a);
-            assert_eq!(&parents, &[(b, b_id), (e, e_id), (d, d_id), (f, f_id)]);
+            assert_eq!(&parents, &[b, e, d, f]);
 
             Ok(())
         }