SQUASH ME

Author: Byron

crates/but-graph/src/init/mod.rs

@@ -36,6 +36,7 @@ pub struct Overlay {
     overriding_references: Vec<gix::refs::Reference>,
     meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
     workspace: Option<(gix::refs::FullName, ref_metadata::Workspace)>,
+    skip_out_of_workspace_stack_tracking_once: bool,
 }
 
 pub(super) type PetGraph = petgraph::stable_graph::StableGraph<Segment, Edge>;
@@ -81,6 +82,12 @@ pub struct Options {
     /// the workspace.
     /// Typically, it's a past position of an existing target, or a target chosen by the user.
     pub extra_target_commit_id: Option<gix::ObjectId>,
+    /// If `true`, we will not be able to find stacks that have advanced outside the workspace, along with their out-of-workspace commits.
+    ///
+    /// This is useful if you want to check for the presence of stacks in the workspace, for the purpose of adding them if they are not.
+    /// Otherwise, if `false`, otherwise anonymous segments might appear like they are part of a stack, one that is known in the workspace
+    /// metadata and reachable towards the descendants of these anonymous stacks.
+    pub skip_out_of_workspace_stack_tracking: bool,
     /// Enabling this will prevent the postprocessing step to run which is what makes the graph useful through clean-up
     /// and to make it more amenable to a workspace project.
     ///
@@ -155,7 +162,8 @@ impl Graph {
                 let mut graph = Graph::default();
                 // It's OK to default-initialise this here as overlays are only used when redoing
                 // the traversal.
-                let (_repo, meta, _entrypoint) = Overlay::default().into_parts(repo, meta);
+                let (_repo, meta, _entrypoint, _skip_stack_tracking) =
+                    Overlay::default().into_parts(repo, meta);
                 let wt_by_branch = {
                     // Assume linked worktrees are never unborn!
                     let mut m = BTreeMap::new();
@@ -249,7 +257,8 @@ impl Graph {
         meta: &impl RefMetadata,
         options: Options,
     ) -> anyhow::Result<Self> {
-        let (repo, meta, _entrypoint) = Overlay::default().into_parts(tip.repo, meta);
+        let (repo, meta, _entrypoint, _skip_stack_tracking) =
+            Overlay::default().into_parts(tip.repo, meta);
         Graph::from_commit_traversal_inner(tip.detach(), &repo, ref_name.into(), &meta, options)
     }
 
@@ -277,6 +286,7 @@ impl Graph {
             commits_limit_hint: limit,
             commits_limit_recharge_location: mut max_commits_recharge_location,
             hard_limit,
+            skip_out_of_workspace_stack_tracking: _,
             dangerously_skip_postprocessing_for_debugging,
         } = options;
 
@@ -752,7 +762,8 @@ impl Graph {
         meta: &impl RefMetadata,
         overlay: Overlay,
     ) -> anyhow::Result<Self> {
-        let (repo, meta, entrypoint) = overlay.into_parts(repo, meta);
+        let (repo, meta, entrypoint, skip_out_of_workspace_stack_tracking_once) =
+            overlay.into_parts(repo, meta);
         let (tip, ref_name) = match entrypoint {
             Some(t) => t,
             None => {
@@ -768,7 +779,15 @@ impl Graph {
                 (tip, ref_name)
             }
         };
-        Graph::from_commit_traversal_inner(tip, &repo, ref_name, &meta, self.options.clone())
+        let mut opts = self.options.clone();
+        if skip_out_of_workspace_stack_tracking_once {
+            opts.skip_out_of_workspace_stack_tracking = true;
+        }
+        let mut graph = Graph::from_commit_traversal_inner(tip, &repo, ref_name, &meta, opts)?;
+        if skip_out_of_workspace_stack_tracking_once {
+            graph.options.skip_out_of_workspace_stack_tracking = false;
+        }
+        Ok(graph)
     }
 
     /// Like [`Self::redo_traversal_with_overlay()`], but replaces this instance, without overlay, and returns

crates/but-graph/src/init/overlay.rs

@@ -27,6 +27,16 @@ impl Overlay {
         self
     }
 
+    /// Call this and will not be able to find stacks that have advanced outside the workspace, along with their out-of-workspace commits
+    /// just this once.
+    ///
+    /// This is useful if you want to check for the presence of stacks in the workspace, for the purpose of adding them if they are not.
+    /// Since this may be undesirable unless it's used in specific situations, it's turned on only once when used here.
+    pub fn without_stack_tracking_once(mut self) -> Self {
+        self.skip_out_of_workspace_stack_tracking_once = true;
+        self
+    }
+
     /// Override the starting position of the traversal by setting it to `id`,
     /// and optionally, by providing the `ref_name` that points to `id`.
     pub fn with_entrypoint(
@@ -71,7 +81,12 @@ impl Overlay {
         self,
         repo: &'repo gix::Repository,
         meta: &'meta T,
-    ) -> (OverlayRepo<'repo>, OverlayMetadata<'meta, T>, Entrypoint)
+    ) -> (
+        OverlayRepo<'repo>,
+        OverlayMetadata<'meta, T>,
+        Entrypoint,
+        bool,
+    )
     where
         T: RefMetadata,
     {
@@ -81,6 +96,7 @@ impl Overlay {
             meta_branches,
             workspace,
             entrypoint,
+            skip_out_of_workspace_stack_tracking_once: skip_out_of_workspace_stack_tracking,
         } = self;
         (
             OverlayRepo {
@@ -100,6 +116,7 @@ impl Overlay {
                 workspace,
             },
             entrypoint,
+            skip_out_of_workspace_stack_tracking,
         )
     }
 }

crates/but-graph/src/init/post.rs

@@ -848,51 +848,53 @@ impl Graph {
         }
 
         // Setup sibling IDs for all unnamed segments with a known segment ref in its future.
-        for sidx in ws_stacks.iter().flat_map(|s| {
-            s.segments
-                .iter()
-                .flat_map(|s| s.commits_by_segment.iter().map(|(sidx, _)| *sidx))
-        }) {
-            // The workspace might be stale by now as we delete empty segments.
-            // Thus be careful, and ignore non-existing ones - after all our workspace
-            // is temporary, nothing to worry about.
-            let Some(s) = self.inner.node_weight(sidx) else {
-                continue;
-            };
-            if s.ref_info.is_some() || s.sibling_segment_id.is_some() {
-                continue;
-            }
-
-            let num_outgoing = self
-                .inner
-                .neighbors_directed(sidx, Direction::Incoming)
-                .count();
-            if num_outgoing < 2 {
-                continue;
-            }
+        if !self.options.skip_out_of_workspace_stack_tracking {
+            for sidx in ws_stacks.iter().flat_map(|s| {
+                s.segments
+                    .iter()
+                    .flat_map(|s| s.commits_by_segment.iter().map(|(sidx, _)| *sidx))
+            }) {
+                // The workspace might be stale by now as we delete empty segments.
+                // Thus, be careful, and ignore non-existing ones - after all our workspace
+                // is temporary, nothing to worry about.
+                let Some(s) = self.inner.node_weight(sidx) else {
+                    continue;
+                };
+                if s.ref_info.is_some() || s.sibling_segment_id.is_some() {
+                    continue;
+                }
 
-            let mut named_segment_id = None;
-            self.visit_all_segments_excluding_start_until(sidx, Direction::Incoming, |s| {
-                let prune = true;
-                if named_segment_id.is_some()
-                    || s.commits
-                        .first()
-                        .is_some_and(|c| c.flags.contains(CommitFlags::InWorkspace))
-                {
-                    return prune;
+                let num_outgoing = self
+                    .inner
+                    .neighbors_directed(sidx, Direction::Incoming)
+                    .count();
+                if num_outgoing < 2 {
+                    continue;
                 }
 
-                s.ref_info.as_ref().is_some_and(|ri| {
-                    let is_known_to_workspace = ws_data
-                        .stacks(AppliedAndUnapplied)
-                        .any(|s| s.branches.iter().any(|b| b.ref_name == ri.ref_name));
-                    if is_known_to_workspace {
-                        named_segment_id = Some(s.id);
+                let mut named_segment_id = None;
+                self.visit_all_segments_excluding_start_until(sidx, Direction::Incoming, |s| {
+                    let prune = true;
+                    if named_segment_id.is_some()
+                        || s.commits
+                            .first()
+                            .is_some_and(|c| c.flags.contains(CommitFlags::InWorkspace))
+                    {
+                        return prune;
                     }
-                    is_known_to_workspace
-                })
-            });
-            self[sidx].sibling_segment_id = named_segment_id;
+
+                    s.ref_info.as_ref().is_some_and(|ri| {
+                        let is_known_to_workspace = ws_data
+                            .stacks(AppliedAndUnapplied)
+                            .any(|s| s.branches.iter().any(|b| b.ref_name == ri.ref_name));
+                        if is_known_to_workspace {
+                            named_segment_id = Some(s.id);
+                        }
+                        is_known_to_workspace
+                    })
+                });
+                self[sidx].sibling_segment_id = named_segment_id;
+            }
         }
 
         // The named-segment check is needed as we don't want to double-split unnamed segments.

crates/but-graph/src/projection/stack.rs

@@ -245,6 +245,7 @@ impl std::fmt::Debug for StackSegment {
         f.debug_struct(&format!("StackSegment({})", self.debug_string()))
             .field("commits", &self.commits)
             .field("commits_on_remote", &self.commits_on_remote)
+            .field("commits_outside", &self.commits_outside)
             .finish()
     }
 }
@@ -258,7 +259,7 @@ impl StackSegment {
     /// is an unambiguous ref pointing to a commit, or when it splits a segment by incoming connection.
     ///
     /// `graph` is used to look up the remote segment and find its commits.
-    pub fn from_graph_segments(
+    pub(crate) fn from_graph_segments(
         segments: &[&crate::Segment],
         graph: &Graph,
     ) -> anyhow::Result<Self> {

crates/but-graph/tests/graph/init/mod.rs

@@ -43,6 +43,7 @@ fn unborn() -> anyhow::Result<()> {
             commits_limit_recharge_location: [],
             hard_limit: None,
             extra_target_commit_id: None,
+            skip_out_of_workspace_stack_tracking: false,
             dangerously_skip_postprocessing_for_debugging: false,
         },
     }
@@ -148,6 +149,7 @@ fn detached() -> anyhow::Result<()> {
             commits_limit_recharge_location: [],
             hard_limit: None,
             extra_target_commit_id: None,
+            skip_out_of_workspace_stack_tracking: false,
             dangerously_skip_postprocessing_for_debugging: false,
         },
     }

crates/but-graph/tests/graph/init/utils.rs

@@ -151,6 +151,7 @@ pub fn standard_options() -> but_graph::init::Options {
         commits_limit_recharge_location: vec![],
         hard_limit: None,
         extra_target_commit_id: None,
+        skip_out_of_workspace_stack_tracking: false,
         dangerously_skip_postprocessing_for_debugging: false,
     }
 }

crates/but-workspace/src/branch/apply.rs

@@ -388,6 +388,8 @@ pub(crate) mod function {
             .redo_traversal_with_overlay(repo, meta, overlay.clone())?;
 
         let workspace = graph.to_workspace()?;
+        dbg!(&graph);
+        dbg!(&workspace);
         let all_applied_branches_are_already_visible = branches_to_apply
             .iter()
             .all(|rn| workspace.refname_is_segment(rn));

crates/but-workspace/tests/workspace/branch/apply_unapply_commit_uncommit.rs

@@ -619,8 +619,8 @@ fn new_workspace_exists_elsewhere_and_to_be_applied_branch_exists_there() -> any
 }
 
 #[test]
-fn apply_multiple_without_target_or_metadata() -> anyhow::Result<()> {
-    let (_tmp, graph, repo, mut meta, _description) =
+fn apply_multiple_without_target_or_metadata_or_base() -> anyhow::Result<()> {
+    let (_tmp, mut graph, repo, mut meta, _description) =
         named_writable_scenario_with_description_and_graph("one-fork", |meta| {
             meta.data_mut().default_target = None;
         })?;
@@ -634,6 +634,8 @@ fn apply_multiple_without_target_or_metadata() -> anyhow::Result<()> {
     * e31e6ca (origin/main, origin/HEAD) add init
     ");
 
+    graph.options.extra_target_commit_id = None;
+    let graph = graph.redo_traversal_with_overlay(&repo, &meta, Overlay::default())?;
     let ws = graph.to_workspace()?;
     insta::assert_snapshot!(graph_workspace(&ws), @r"
     ⌂:0:main[🌳] <> ✓!
@@ -660,9 +662,9 @@ fn apply_multiple_without_target_or_metadata() -> anyhow::Result<()> {
     ├── ≡📙:2:A on e31e6ca {41}
     │   └── 📙:2:A
     │       └── ·bf53300 (🏘️)
-    └── ≡📙:4:main on e31e6ca {1a5}
-        └── 📙:4:main
-            └── ·b1540e5 (🏘️|✓)
+    └── ≡📙:1:main on e31e6ca {1a5}
+        └── 📙:1:main
+            └── ·b1540e5 (🏘️)
     ");
 
     insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
@@ -701,9 +703,9 @@ fn apply_multiple_without_target_or_metadata() -> anyhow::Result<()> {
     ├── ≡📙:2:A on e31e6ca {41}
     │   └── 📙:2:A
     │       └── ·bf53300 (🏘️)
-    └── ≡📙:5:main on e31e6ca {1a5}
-        └── 📙:5:main
-            └── ·b1540e5 (🏘️|✓)
+    └── ≡📙:1:main on e31e6ca {1a5}
+        └── 📙:1:main
+            └── ·b1540e5 (🏘️)
     ");
 
     insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
@@ -1890,6 +1892,7 @@ mod utils {
             commits_limit_recharge_location: vec![],
             hard_limit: None,
             extra_target_commit_id: None,
+            skip_out_of_workspace_stack_tracking: false,
             dangerously_skip_postprocessing_for_debugging: false,
         }
     }