SQUASH ME

Author: Byron

crates/but-core/src/ref_metadata.rs

@@ -120,6 +120,14 @@ pub struct RefInfo {
     pub updated_at: Option<gix::date::Time>,
 }
 
+/// Mutations
+impl RefInfo {
+    /// Set the `updated_at` field to the current time.
+    pub fn update(&mut self) {
+        self.updated_at = Some(gix::date::Time::now_local_or_utc());
+    }
+}
+
 impl std::fmt::Debug for RefInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let format = gix::date::time::format::ISO8601;

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

@@ -1,5 +1,5 @@
 use anyhow::{Context, bail};
-use but_core::RefMetadata;
+use but_core::{RefMetadata, ref_metadata};
 use gix::{
     hashtable::hash_map::Entry,
     prelude::{ObjectIdExt, ReferenceExt},
@@ -13,12 +13,22 @@ mod walk;
 use walk::*;
 
 pub(crate) mod types;
+use crate::init::overlay::{OverlayMetadata, OverlayRepo};
 use types::{Goals, Instruction, Limit, Queue};
 
 mod remotes;
 
+mod overlay;
 mod post;
 
+/// A way to define information to be served from memory, instead of from the underlying data source, when
+/// [initializing](Graph::from_commit_traversal()) the graph.
+#[derive(Debug, Default)]
+pub struct Overlay {
+    references: Vec<gix::refs::Reference>,
+    meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
+}
+
 pub(super) type PetGraph = petgraph::stable_graph::StableGraph<Segment, Edge>;
 
 /// Options for use in [`Graph::from_head()`] and [`Graph::from_commit_traversal()`].
@@ -123,9 +133,12 @@ impl Graph {
         let (tip, maybe_name) = match head.kind {
             gix::head::Kind::Unborn(ref_name) => {
                 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) = Overlay::default().into_parts(repo, meta);
                 graph.insert_root(branch_segment_from_name_and_meta(
                     Some((ref_name, None)),
-                    meta,
+                    &meta,
                     None,
                 )?);
                 return Ok(graph);
@@ -208,6 +221,19 @@ impl Graph {
         ref_name: impl Into<Option<gix::refs::FullName>>,
         meta: &impl RefMetadata,
         options: Options,
+    ) -> anyhow::Result<Self> {
+        let (repo, meta) = Overlay::default().into_parts(tip.repo, meta);
+        // TODO: use repo
+        Graph::from_commit_traversal_inner(tip.detach(), tip.repo, ref_name, &meta, options)
+    }
+
+    fn from_commit_traversal_inner<T: RefMetadata>(
+        tip: gix::ObjectId,
+        // repo: &OverlayRepo<'_>,
+        repo: &gix::Repository,
+        ref_name: impl Into<Option<gix::refs::FullName>>,
+        meta: &OverlayMetadata<'_, T>,
+        options: Options,
     ) -> anyhow::Result<Self> {
         let mut graph = Graph {
             options: options.clone(),
@@ -221,7 +247,6 @@ impl Graph {
             hard_limit,
         } = options;
 
-        let repo = tip.repo;
         let max_limit = Limit::new(limit);
         // 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.
@@ -255,7 +280,7 @@ impl Graph {
         // The tip transports itself.
         let tip_flags = CommitFlags::NotInRemote
             | goals
-                .flag_for(tip.detach())
+                .flag_for(tip)
                 .expect("we more than one bitflags for this");
 
         let target_symbolic_remote_names = {
@@ -288,10 +313,10 @@ impl Graph {
             let current = graph.insert_root(branch_segment_from_name_and_meta(
                 ref_name.clone().map(|rn| (rn, None)),
                 meta,
-                Some((&ctx.refs_by_id, tip.detach())),
+                Some((&ctx.refs_by_id, tip)),
             )?);
             _ = next.push_back_exhausted((
-                tip.detach(),
+                tip,
                 tip_flags,
                 Instruction::CollectCommit { into: current },
                 max_limit,
@@ -331,7 +356,7 @@ impl Graph {
             } else {
                 (
                     CommitFlags::empty(),
-                    max_limit.with_indirect_goal(tip.detach(), &mut goals),
+                    max_limit.with_indirect_goal(tip, &mut goals),
                 )
             };
             let mut ws_segment =
@@ -374,10 +399,10 @@ impl Graph {
                         CommitFlags::NotInRemote | goal,
                         Instruction::CollectCommit { into: local_sidx },
                         max_limit
-                            .with_indirect_goal(tip.detach(), &mut goals)
+                            .with_indirect_goal(tip, &mut goals)
                             .without_allowance(),
                     ));
-                    next.add_goal_to(tip.detach(), goal);
+                    next.add_goal_to(tip, goal);
                     (Some(local_sidx), goal)
                 } else {
                     (None, CommitFlags::empty())
@@ -391,7 +416,7 @@ impl Graph {
                     // Once the goal was found, be done immediately,
                     // we are not interested in these.
                     max_limit
-                        .with_indirect_goal(tip.detach(), &mut goals)
+                        .with_indirect_goal(tip, &mut goals)
                         .additional_goal(local_goal)
                         .without_allowance(),
                 ));
@@ -421,7 +446,7 @@ impl Graph {
                         into: extra_target_sidx,
                     },
                     max_limit
-                        .with_indirect_goal(tip.detach(), &mut goals)
+                        .with_indirect_goal(tip, &mut goals)
                         .without_allowance(),
                 ));
                 extra_target_sidx
@@ -571,7 +596,7 @@ impl Graph {
                 limit,
             );
             if hard_limit_hit {
-                return graph.post_processed(meta, tip.detach(), ctx.with_hard_limit());
+                return graph.post_processed(meta, tip, ctx.with_hard_limit());
             }
 
             segment.commits.push(
@@ -592,14 +617,36 @@ impl Graph {
 
             for item in remote_items {
                 if next.push_back_exhausted(item) {
-                    return graph.post_processed(meta, tip.detach(), ctx.with_hard_limit());
+                    return graph.post_processed(meta, tip, ctx.with_hard_limit());
                 }
             }
 
             prune_integrated_tips(&mut graph, &mut next);
         }
 
-        graph.post_processed(meta, tip.detach(), ctx)
+        graph.post_processed(meta, tip, ctx)
+    }
+
+    /// Repeat the traversal that generated this graph using `repo` and `meta`, but allow to set an in-memory
+    /// `overlay` to amend the data available from `repo` and `meta`.
+    /// This way, one can see this graph as it will be in the future once the changes to `repo` and `meta` are actually made.
+    pub fn redo_traversal_with_overlay(
+        &self,
+        repo: &gix::Repository,
+        meta: &impl RefMetadata,
+        overlay: Overlay,
+    ) -> anyhow::Result<Self> {
+        let (_repo, meta) = overlay.into_parts(repo, meta);
+        let tip_sidx = self
+            .entrypoint
+            .context("BUG: entrypoint must always be set")?
+            .0;
+        let tip = self
+            .tip_skip_empty(tip_sidx)
+            .context("BUG: entrypoint must eventually point to a commit")?
+            .id;
+        let ref_name = self[tip_sidx].ref_name.clone();
+        Graph::from_commit_traversal_inner(tip, repo, ref_name, &meta, self.options.clone())
     }
 }
 

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

@@ -0,0 +1,97 @@
+use crate::init::Overlay;
+use but_core::{RefMetadata, ref_metadata};
+
+impl Overlay {
+    /// Serve the given `refs` from memory, as if they would exist.
+    pub fn with_references(mut self, refs: impl IntoIterator<Item = gix::refs::Reference>) -> Self {
+        self.references = refs.into_iter().collect();
+        self
+    }
+
+    /// Serve the given `branches` metadata from memory, as if they would exist.
+    pub fn with_branch_metadata(
+        mut self,
+        refs: impl IntoIterator<Item = (gix::refs::FullName, ref_metadata::Branch)>,
+    ) -> Self {
+        self.meta_branches = refs.into_iter().collect();
+        self
+    }
+}
+
+impl Overlay {
+    pub(crate) fn into_parts<'repo, 'meta, T>(
+        self,
+        repo: &'repo gix::Repository,
+        meta: &'meta T,
+    ) -> (OverlayRepo<'repo>, OverlayMetadata<'meta, T>)
+    where
+        T: RefMetadata,
+    {
+        let Overlay {
+            references,
+            meta_branches,
+        } = self;
+        (
+            OverlayRepo {
+                references,
+                inner: repo,
+            },
+            OverlayMetadata {
+                inner: meta,
+                meta_branches,
+            },
+        )
+    }
+}
+
+pub(crate) struct OverlayRepo<'repo> {
+    inner: &'repo gix::Repository,
+    references: Vec<gix::refs::Reference>,
+}
+
+pub(crate) struct OverlayMetadata<'meta, T> {
+    inner: &'meta T,
+    meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
+}
+
+impl<T> OverlayMetadata<'_, T>
+where
+    T: RefMetadata,
+{
+    pub fn iter_workspaces(
+        &self,
+    ) -> impl Iterator<Item = (gix::refs::FullName, ref_metadata::Workspace)> {
+        self.inner
+            .iter()
+            .filter_map(Result::ok)
+            .filter_map(|(ref_name, item)| {
+                item.downcast::<ref_metadata::Workspace>()
+                    .ok()
+                    .map(|ws| (ref_name, ws))
+            })
+            .map(|(ref_name, ws)| (ref_name, (*ws).clone()))
+    }
+
+    pub fn workspace_opt(
+        &self,
+        ref_name: &gix::refs::FullNameRef,
+    ) -> anyhow::Result<Option<ref_metadata::Workspace>> {
+        let opt = self.inner.workspace_opt(ref_name)?;
+        Ok(opt.map(|ws_data| ws_data.clone()))
+    }
+
+    pub fn branch_opt(
+        &self,
+        ref_name: &gix::refs::FullNameRef,
+    ) -> anyhow::Result<Option<ref_metadata::Branch>> {
+        if let Some(overlay_branch) = self
+            .meta_branches
+            .iter()
+            .find_map(|(rn, branch)| (rn.as_ref() == ref_name).then(|| branch.clone()))
+        {
+            return Ok(Some(overlay_branch));
+        }
+        let opt = self.inner.branch_opt(ref_name)?;
+        Ok(opt.map(|data| data.clone()))
+    }
+}

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

@@ -1,3 +1,4 @@
+use crate::init::overlay::OverlayMetadata;
 use crate::init::types::{EdgeOwned, TopoWalk};
 use crate::init::walk::{RefsById, disambiguate_refs_by_branch_metadata};
 use crate::init::{PetGraph, branch_segment_from_name_and_meta, remotes};
@@ -34,9 +35,9 @@ impl Graph {
     /// the requirement of them to be computationally cheap.
     #[instrument(skip(self, meta, repo, refs_by_id), err(Debug))]
     #[allow(clippy::too_many_arguments)]
-    pub(super) fn post_processed(
+    pub(super) fn post_processed<T: RefMetadata>(
         mut self,
-        meta: &impl RefMetadata,
+        meta: &OverlayMetadata<'_, T>,
         tip: gix::ObjectId,
         Context {
             repo,
@@ -87,11 +88,11 @@ impl Graph {
 
     /// Assure that workspace segments with managed commits only have that commit, and move all others
     /// into a new segment.
-    fn fixup_workspace_segments(
+    fn fixup_workspace_segments<T: RefMetadata>(
         &mut self,
         repo: &gix::Repository,
         refs_by_id: &RefsById,
-        meta: &impl RefMetadata,
+        meta: &OverlayMetadata<'_, T>,
     ) -> anyhow::Result<()> {
         let workspace_segments_with_multiple_commits: Vec<_> = self
             .inner
@@ -156,9 +157,9 @@ impl Graph {
     /// * segments have a name, but the same name is still visible in the refs of the first commit.
     ///
     /// Only perform disambiguation on proxy segments (i.e. those inserted segments to prevent commit-ownership).
-    fn fixup_segment_names(
+    fn fixup_segment_names<T: RefMetadata>(
         &mut self,
-        meta: &impl RefMetadata,
+        meta: &OverlayMetadata<'_, T>,
         inserted_proxy_segments: &[SegmentIndex],
     ) {
         let segments_with_refs_on_first_commit: Vec<_> = self
@@ -307,9 +308,9 @@ impl Graph {
     /// * insert empty segments as defined by the workspace that affects its downstream.
     /// * put workspace connection into the order defined in the workspace metadata.
     /// * set sibling segment IDs for unnamed segments that are descendents of an out-of-workspace but known segment.
-    fn workspace_upgrades(
+    fn workspace_upgrades<T: RefMetadata>(
         &mut self,
-        meta: &impl RefMetadata,
+        meta: &OverlayMetadata<'_, T>,
         repo: &gix::Repository,
     ) -> anyhow::Result<()> {
         let Some((ws_sidx, ws_stacks, ws_data, ws_target)) = self
@@ -740,12 +741,12 @@ fn delete_anon_if_empty_and_reconnect(graph: &mut Graph, sidx: SegmentIndex) {
 
 /// Create as many new segments as refs in `matching_refs`, connect them to each other in order, and finally connect them
 /// with `above_idx` and `below_idx` to integrate them into the workspace that is bounded by these segments.
-fn create_independent_segments(
+fn create_independent_segments<T: RefMetadata>(
     graph: &mut Graph,
     above_idx: SegmentIndex,
     below_idx: SegmentIndex,
     matching_refs: Vec<gix::refs::FullName>,
-    meta: &impl RefMetadata,
+    meta: &OverlayMetadata<'_, T>,
 ) -> anyhow::Result<()> {
     assert!(!matching_refs.is_empty());
 
@@ -803,13 +804,13 @@ fn create_independent_segments(
 /// Note that the Segment at `bottom_segment_index` will own `commit`.
 /// Also note that we reconnect commit-by-commit, so the outer processing has to do that.
 /// Note that it may avoid creating a new segment.
-fn maybe_create_multiple_segments(
+fn maybe_create_multiple_segments<T: RefMetadata>(
     graph: &mut Graph,
     mut above_idx: SegmentIndex,
     commit_parent: SegmentIndex,
     commit_idx: CommitIndex,
     mut matching_refs: Vec<gix::refs::FullName>,
-    meta: &impl RefMetadata,
+    meta: &OverlayMetadata<'_, T>,
 ) -> anyhow::Result<Option<SegmentIndex>> {
     assert!(!matching_refs.is_empty());
     let commit = &graph[commit_parent].commits[commit_idx];