A first shot at producing stacks from a graph

Author: Byron

crates/but-graph/src/api.rs

@@ -94,20 +94,25 @@ impl Graph {
     /// aren't fully defined as traversal stopped due to some abort condition being met.
     /// Valid partial segments always have at least one commit.
     pub fn partial_segments(&self) -> impl Iterator<Item = SegmentIndex> {
-        self.base_segments().filter(|s| {
-            let has_outgoing = self
-                .inner
-                .edges_directed(*s, Direction::Outgoing)
-                .next()
-                .is_some();
-            if has_outgoing {
-                return false;
-            }
-            self[*s]
-                .commits
-                .first()
-                .is_none_or(|c| !c.parent_ids.is_empty())
-        })
+        self.base_segments().filter(|s| self.is_partial_segment(*s))
+    }
+
+    /// Return `true` if the segment behind `sidx`
+    /// isn't fully defined as traversal stopped due to some abort condition.
+    /// Valid partial segments always have at least one commit.
+    pub fn is_partial_segment(&self, sidx: SegmentIndex) -> bool {
+        let has_outgoing = self
+            .inner
+            .edges_directed(sidx, Direction::Outgoing)
+            .next()
+            .is_some();
+        if has_outgoing {
+            return false;
+        }
+        self[sidx]
+            .commits
+            .first()
+            .is_none_or(|c| !c.parent_ids.is_empty())
     }
 
     /// Return all segments that sit on top of the `sidx` segment as `(source_commit_index(of sidx), destination_segment_index)`,

crates/but-graph/src/debug.rs

@@ -1,5 +1,5 @@
 use crate::init::PetGraph;
-use crate::{CommitFlags, Edge, Graph, Segment, SegmentIndex};
+use crate::{Edge, Graph, Segment, SegmentIndex};
 use bstr::ByteSlice;
 use gix::reference::Category;
 use petgraph::graph::EdgeReference;
@@ -10,26 +10,24 @@ impl Graph {
     /// Produce a string that concisely represents `commit`, adding `extra` information as needed.
     pub fn commit_debug_string(
         commit: &crate::Commit,
-        has_conflicts: bool,
         is_entrypoint: bool,
         show_message: bool,
         is_early_end: bool,
         hard_limit: bool,
     ) -> String {
         format!(
-            "{ep}{end}{kind}{conflict}{hex}{flags}{msg}{refs}",
+            "{ep}{end}{kind}{hex}{flags}{msg}{refs}",
             ep = if is_entrypoint { "👉" } else { "" },
             end = if is_early_end {
                 if hard_limit { "❌" } else { "✂️" }
             } else {
                 ""
             },
-            kind = if commit.flags.contains(CommitFlags::NotInRemote) {
-                "·"
-            } else {
+            kind = if commit.flags.is_remote() {
                 "🟣"
+            } else {
+                "·"
             },
-            conflict = if has_conflicts { "💥" } else { "" },
             flags = if !commit.flags.is_empty() {
                 format!(" ({})", commit.flags.debug_string())
             } else {
@@ -173,10 +171,6 @@ impl Graph {
                 .map(|(cidx, c)| {
                     Self::commit_debug_string(
                         c,
-                        c.details
-                            .as_ref()
-                            .map(|d| d.has_conflicts)
-                            .unwrap_or_default(),
                         !show_segment_entrypoint && Some((sidx, Some(cidx))) == entrypoint,
                         false,
                         self.is_early_end_of_traversal(sidx, cidx),

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

@@ -451,8 +451,6 @@ pub fn find(
                 details: Some(CommitDetails {
                     message: message.context("Every valid commit must have a message")?,
                     author: author.context("Every valid commit must have an author signature")?,
-                    // TODO: make it clear that this is optionally computed as well, maybe `Option<bool>`?
-                    has_conflicts: false,
                 }),
             })
         }

crates/but-graph/src/lib.rs

@@ -43,6 +43,7 @@ pub use segment::{Commit, CommitDetails, CommitFlags, Segment, SegmentMetadata};
 mod api;
 /// Produce a graph from a Git repository.
 pub mod init;
+pub mod projection;
 
 mod ref_metadata_legacy;
 pub use ref_metadata_legacy::{VirtualBranchesTomlMetadata, is_workspace_ref_name};
@@ -80,6 +81,9 @@ pub struct EntryPoint<'graph> {
     /// The segment that served starting point for the traversal into this graph.
     pub segment: &'graph Segment,
     /// If present, the commit that started the traversal in the `segment`.
+    ///
+    /// It's usually the first commit of the segment due to the way we split segments, and even though
+    /// downstream code relies on this properly, the graph itself does not.
     pub commit: Option<&'graph Commit>,
 }
 

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

@@ -0,0 +1,15 @@
+//! A way to represent the graph in a simplified (but more usable) form.
+//!
+//! This is the current default way of GitButler to perceive its world, but most inexpensively generated to stay
+//! close to the source of truth, [The Graph](crate::Graph).
+//!
+//! These types are not for direct consumption, but should be processed further for consumption by the user.
+
+/// Types related to the stack representation for graphs.
+///
+/// Note that these are always a simplification, degenerating information, while maintaining a link back to the graph.
+mod stack;
+pub use stack::{Stack, StackCommit, StackCommitDebugFlags, StackCommitFlags, StackSegment};
+
+mod workspace;
+pub use workspace::{HeadLocation, Target, Workspace};