Add non-workspace commit limit to deal with graphs

Also provide means to obtain next chunks akin to pages.

Author: Byron

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

@@ -21,12 +21,48 @@ mod walk;
 pub(super) type PetGraph = petgraph::Graph<Segment, Edge>;
 
 /// Options for use in [`Graph::from_head()`] and [`Graph::from_commit_traversal()`].
-#[derive(Default, Debug, Copy, Clone)]
+#[derive(Default, Debug, Clone)]
 pub struct Options {
     /// Associate tag references with commits.
     ///
     /// If `false`, tags are not collected.
     pub collect_tags: bool,
+    /// The maximum number of commits we should traverse outside any workspace *with a target branch*.
+    /// Workspaces with a target branch automatically have unlimited traversals as they rely on the target
+    /// branch to eventually stop the traversal.
+    ///
+    /// If `None`, there is no limit, which typically means that when lacking a workspace, the traversal
+    /// will end only when no commit is left to traverse.
+    /// `Some(0)` means nothing is going to be returned.
+    ///
+    /// Note that this doesn't affect the traversal of integrated commits, which is always stopped once there
+    /// is nothing interesting left to traverse.
+    ///
+    /// Also note: This is not a perfectly exact measure, and it's always possible to receive a few more commits
+    /// than the maximum as for simplicity, we assign each 'split' the same limit, effectively doubling it.
+    pub max_commits_outside_of_workspace: Option<usize>,
+    /// A list of the last commits of partial segments previously returned that reset the amount of available
+    /// commits to traverse back to `max_commits_outside_of_workspace`.
+    /// Imagine it like a gas station that can be chosen to direct where the commit-budge should be spent.
+    pub max_commits_recharge_location: Vec<gix::ObjectId>,
+}
+
+/// Builder
+impl Options {
+    /// Set the maximum amount of commits that each lane in a tip may traverse.
+    pub fn with_limit(mut self, limit: usize) -> Self {
+        self.max_commits_outside_of_workspace = Some(limit);
+        self
+    }
+
+    /// Keep track of commits at which the traversal limit should be reset to the [`limit`](Self::with_limit()).
+    pub fn with_limit_extension_at(
+        mut self,
+        commits: impl IntoIterator<Item = gix::ObjectId>,
+    ) -> Self {
+        self.max_commits_recharge_location.extend(commits);
+        self
+    }
 }
 
 /// Lifecycle
@@ -106,7 +142,11 @@ impl Graph {
         tip: gix::Id<'_>,
         ref_name: impl Into<Option<gix::refs::FullName>>,
         meta: &impl RefMetadata,
-        Options { collect_tags }: Options,
+        Options {
+            collect_tags,
+            max_commits_outside_of_workspace: limit,
+            mut max_commits_recharge_location,
+        }: Options,
     ) -> anyhow::Result<Self> {
         // TODO: also traverse (outside)-branches that ought to be in the workspace. That way we have the desired ones
         //       automatically and just have to find a way to prune the undesired ones.
@@ -168,6 +208,7 @@ impl Graph {
                 tip.detach(),
                 tip_flags,
                 Instruction::CollectCommit { into: current },
+                limit,
             ));
         }
         for (ws_ref, workspace_info) in workspaces {
@@ -198,6 +239,12 @@ impl Graph {
                 CommitFlags::empty()
             };
             let mut ws_segment = branch_segment_from_name_and_meta(Some(ws_ref), meta, None)?;
+            // Drop the limit if we have a target ref
+            let limit = if workspace_info.target_ref.is_some() {
+                None
+            } else {
+                limit
+            };
             ws_segment.metadata = Some(SegmentMetadata::Workspace(workspace_info));
             let ws_segment = graph.insert_root(ws_segment);
             // As workspaces typically have integration branches which can help us to stop the traversal,
@@ -210,6 +257,7 @@ impl Graph {
                     // their status for now.
                     CommitFlags::NotInRemote | add_flags,
                 Instruction::CollectCommit { into: ws_segment },
+                limit,
             ));
             if let Some((target_ref, target_ref_id)) = target {
                 let target_segment = graph.insert_root(branch_segment_from_name_and_meta(
@@ -223,11 +271,22 @@ impl Graph {
                     Instruction::CollectCommit {
                         into: target_segment,
                     },
+                    /* unlimited traversal for 'negative' commits */
+                    None,
                 ));
             }
         }
 
-        while let Some((id, mut propagated_flags, instruction)) = next.pop_front() {
+        max_commits_recharge_location.sort();
+        // Set max-limit so that we compensate for the way this is counted.
+        let max_limit = limit.map(|l| l + 1);
+        while let Some((id, mut propagated_flags, instruction, mut limit)) = next.pop_front() {
+            if max_commits_recharge_location.binary_search(&id).is_ok() {
+                limit = max_limit;
+            }
+            if limit.is_some_and(|l| l == 0) {
+                continue;
+            }
             let info = find(commit_graph.as_ref(), repo, id, &mut buf)?;
             let src_flags = graph[instruction.segment_idx()]
                 .commits
@@ -363,6 +422,7 @@ impl Graph {
                 propagated_flags,
                 segment_idx_for_id,
                 commit_idx_for_possible_fork,
+                limit,
             );
 
             let refs_at_commit_before_removal = refs_by_id.remove(&id).unwrap_or_default();
@@ -392,6 +452,7 @@ impl Graph {
                 &configured_remote_tracking_branches,
                 &target_refs,
                 meta,
+                limit,
             )?;
 
             prune_integrated_tips(&mut graph.inner, &mut next, &desired_refs);
@@ -442,7 +503,7 @@ impl Instruction {
     }
 }
 
-type QueueItem = (ObjectId, CommitFlags, Instruction);
+type QueueItem = (ObjectId, CommitFlags, Instruction, Option<usize>);
 
 #[derive(Debug)]
 pub(crate) struct EdgeOwned {

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

@@ -150,7 +150,7 @@ pub fn replace_queued_segments(
     find: SegmentIndex,
     replace: SegmentIndex,
 ) {
-    for instruction_to_replace in queue.iter_mut().map(|(_, _, instruction)| instruction) {
+    for instruction_to_replace in queue.iter_mut().map(|(_, _, instruction, _)| instruction) {
         let cmp = instruction_to_replace.segment_idx();
         if cmp == find {
             *instruction_to_replace = instruction_to_replace.with_replaced_sidx(replace);
@@ -159,7 +159,7 @@ pub fn replace_queued_segments(
 }
 
 pub fn swap_queued_segments(queue: &mut VecDeque<QueueItem>, a: SegmentIndex, b: SegmentIndex) {
-    for instruction_to_replace in queue.iter_mut().map(|(_, _, instruction)| instruction) {
+    for instruction_to_replace in queue.iter_mut().map(|(_, _, instruction, _)| instruction) {
         let cmp = instruction_to_replace.segment_idx();
         if cmp == a {
             *instruction_to_replace = instruction_to_replace.with_replaced_sidx(b);
@@ -236,28 +236,47 @@ pub fn try_split_non_empty_segment_at_branch(
     Ok(Some(segment_below))
 }
 
+fn is_exhausted_or_decrement(limit: &mut Option<usize>) -> bool {
+    *limit = match limit {
+        Some(limit) => {
+            if *limit == 0 {
+                return true;
+            }
+            Some(*limit - 1)
+        }
+        None => None,
+    };
+    false
+}
+
 /// Queue the `parent_ids` of the current commit, whose additional information like `current_kind` and `current_index`
 /// are used.
+/// `limit` is used to determine if the tip is NOT supposed to be dropped, with `0` meaning it's depleted.
 pub fn queue_parents(
     next: &mut VecDeque<QueueItem>,
     parent_ids: &[gix::ObjectId],
     flags: CommitFlags,
     current_sidx: SegmentIndex,
     current_cidx: CommitIndex,
+    mut limit: Option<usize>,
 ) {
+    if is_exhausted_or_decrement(&mut limit) {
+        return;
+    }
     if parent_ids.len() > 1 {
         let instruction = Instruction::ConnectNewSegment {
             parent_above: current_sidx,
             at_commit: current_cidx,
         };
         for pid in parent_ids {
-            next.push_back((*pid, flags, instruction))
+            next.push_back((*pid, flags, instruction, limit))
         }
     } else if !parent_ids.is_empty() {
         next.push_back((
             parent_ids[0],
             flags,
             Instruction::CollectCommit { into: current_sidx },
+            limit,
         ));
     } else {
         return;
@@ -559,7 +578,12 @@ pub fn try_queue_remote_tracking_branches(
     configured_remote_tracking_branches: &BTreeSet<FullName>,
     target_refs: &[gix::refs::FullName],
     meta: &impl RefMetadata,
+    limit: Option<usize>,
 ) -> anyhow::Result<()> {
+    if limit.is_some_and(|l| l == 0) {
+        return Ok(());
+    }
+
     for rn in refs {
         let Some(remote_tracking_branch) = remotes::lookup_remote_tracking_branch_or_deduce_it(
             repo,
@@ -593,6 +617,7 @@ pub fn try_queue_remote_tracking_branches(
             Instruction::CollectCommit {
                 into: remote_segment,
             },
+            limit.map(|l| l - 1),
         ));
     }
     Ok(())
@@ -614,7 +639,7 @@ pub fn prune_integrated_tips(
     if !all_integated {
         return;
     }
-    next.retain(|(_id, _flags, instruction)| {
+    next.retain(|(_id, _flags, instruction, _limit)| {
         let sidx = instruction.segment_idx();
         let s = &graph[sidx];
         let any_segment_ref_is_contained_in_workspace = s

crates/but-graph/tests/fixtures/scenarios.sh

@@ -165,6 +165,30 @@ EOF
 
 )
 
+git init triple-merge
+(cd triple-merge
+  for c in $(seq 5); do
+    commit "$c"
+  done
+  git checkout -b A
+    git branch B
+    git branch C
+    for c in $(seq 3); do
+      commit "A$c"
+    done
+
+  git checkout B
+    for c in $(seq 3); do
+      commit "B$c"
+    done
+
+  git checkout C
+    for c in $(seq 3); do
+      commit "C$c"
+    done
+  git merge A B
+)
+
 mkdir ws
 (cd ws
   git init single-stack-ambiguous
@@ -355,6 +379,9 @@ EOF
     tick
     git checkout -b soon-origin-main main
       git merge --no-ff A
+      for c in $(seq 2); do
+        commit "remote-$c"
+      done
       setup_remote_tracking soon-origin-main main "move"
     git checkout gitbutler/workspace
   )