fix(graph): Gracefully handle squash-merges

Before, when doing a `git-stack --pull`, we'd rebase the merged branch
onto master.  `git` would the automatically detect the commit is merged
and drop it.  We'd then associate the branch name with the same commit
master points to and have to delete it manually.

This tries to detect that case so we can automatically delete the stale
branch on behalf of users.

This does not help if your branch is behind master because those extra
commits will impact how we are detecting this case (tree id).

This is a spiritual revert of 80f5158,
re-implementing 892117b to handle all
of our changes and with a little more experience and context.

This is a part of #28.

Author: epage

src/bin/git-stack/stack.rs

@@ -349,6 +349,7 @@ fn plan_rebase(state: &State, stack: &StackState) -> eyre::Result<git_stack::git
     git_stack::graph::protect_branches(&mut root, &state.repo, &state.protected_branches);
 
     git_stack::graph::rebase_branches(&mut root, stack.onto.id);
+    git_stack::graph::drop_by_tree_id(&mut root);
 
     let script = git_stack::graph::to_script(&root);
 
@@ -389,6 +390,7 @@ fn show(state: &State, colored_stdout: bool) -> eyre::Result<()> {
             if state.dry_run {
                 // Show as-if we performed all mutations
                 git_stack::graph::rebase_branches(&mut root, stack.onto.id);
+                git_stack::graph::drop_by_tree_id(&mut root);
             }
 
             eyre::Result::Ok(root)

src/git/repo.rs

@@ -77,6 +77,13 @@ impl Commit {
                 .next()
         }
     }
+
+    pub fn revert_summary(&self) -> Option<&bstr::BStr> {
+        self.summary
+            .strip_prefix(b"Revert ")
+            .and_then(|s| s.strip_suffix(b"\""))
+            .map(ByteSlice::as_bstr)
+    }
 }
 
 pub struct GitRepo {

src/graph/ops.rs

@@ -127,6 +127,93 @@ fn pushable_node(node: &mut Node, mut cause: Option<&str>) {
     }
 }
 
+/// Quick pass for what is droppable
+///
+/// We get into this state when a branch is squashed.  The id would be different due to metadata
+/// but the tree_id, associated with the repo, is the same if your branch is up-to-date.
+///
+/// The big risk is if a commit was reverted.  To protect against this, we only look at the final
+/// state of the branch and then check if it looks like a revert.
+///
+/// To avoid walking too much of the tree, we are going to assume only the first branch in a stack
+/// could have been squash-merged.
+///
+/// This assumes that the Node was rebased onto all of the new potentially squash-merged Nodes and
+/// we extract the potential tree_id's from those protected commits.
+pub fn drop_by_tree_id(node: &mut Node) {
+    if node.action.is_protected() {
+        track_protected_tree_id(node, std::collections::HashSet::new());
+    }
+}
+
+fn track_protected_tree_id(
+    node: &mut Node,
+    mut protected_tree_ids: std::collections::HashSet<git2::Oid>,
+) {
+    assert!(node.action.is_protected());
+    protected_tree_ids.insert(node.local_commit.tree_id);
+
+    match node.children.len() {
+        0 => (),
+        1 => {
+            let child = node.children.values_mut().next().unwrap();
+            if child.action.is_protected() {
+                track_protected_tree_id(child, protected_tree_ids);
+            } else {
+                drop_first_branch_by_tree_id(child, protected_tree_ids);
+            }
+        }
+        _ => {
+            for child in node.children.values_mut() {
+                if child.action.is_protected() {
+                    track_protected_tree_id(child, protected_tree_ids.clone());
+                } else {
+                    drop_first_branch_by_tree_id(child, protected_tree_ids.clone());
+                }
+            }
+        }
+    }
+}
+
+fn drop_first_branch_by_tree_id(
+    node: &mut Node,
+    protected_tree_ids: std::collections::HashSet<git2::Oid>,
+) -> bool {
+    assert!(!node.action.is_protected());
+    if node.branches.is_empty() {
+        match node.children.len() {
+            0 => false,
+            1 => {
+                let child = node.children.values_mut().next().unwrap();
+                let all_dropped = drop_first_branch_by_tree_id(child, protected_tree_ids);
+                if all_dropped {
+                    node.action = crate::graph::Action::Delete;
+                }
+                all_dropped
+            }
+            _ => {
+                let mut all_dropped = true;
+                for child in node.children.values_mut() {
+                    all_dropped &= drop_first_branch_by_tree_id(child, protected_tree_ids.clone());
+                }
+                if all_dropped {
+                    node.action = crate::graph::Action::Delete;
+                }
+                all_dropped
+            }
+        }
+    } else if !protected_tree_ids.contains(&node.local_commit.tree_id) {
+        false
+    } else if node.local_commit.revert_summary().is_some() {
+        // Might not *actually* be a revert or something more complicated might be going on.  Let's
+        // just be cautious.
+        false
+    } else {
+        node.action = crate::graph::Action::Delete;
+        true
+    }
+}
+
 pub fn to_script(node: &Node) -> crate::git::Script {
     let mut script = crate::git::Script::new();