Implement snapshot::create_tree() with worktree snapshot supports

Author: Byron

crates/but-core/src/lib.rs

@@ -332,9 +332,9 @@ pub enum IgnoredWorktreeTreeChangeStatus {
 pub struct IgnoredWorktreeChange {
     /// The worktree-relative path to the change.
     #[serde(serialize_with = "gitbutler_serde::bstring_lossy::serialize")]
-    path: BString,
+    pub path: BString,
     /// The status that caused this change to be ignored.
-    status: IgnoredWorktreeTreeChangeStatus,
+    pub status: IgnoredWorktreeTreeChangeStatus,
 }
 
 /// The type returned by [`worktree_changes()`](diff::worktree_changes).

crates/but-workspace/src/snapshot.rs

@@ -3,16 +3,19 @@
 ///
 pub mod create_tree {
     use bstr::BString;
+    use but_graph::VirtualBranchesTomlMetadata;
+    use std::collections::BTreeSet;
 
     /// A way to determine what should be included in the snapshot when calling [create_tree()](function::create_tree).
-    pub struct State<'a> {
+    #[derive(Debug, Clone)]
+    pub struct State {
         /// The result of a previous worktree changes call.
         ///
         /// It contains detailed information about the complete set of possible changes to become part of the worktree.
-        pub changes: &'a but_core::WorktreeChanges,
+        pub changes: but_core::WorktreeChanges,
         /// Repository-relative and slash-separated paths that match any change in the  [`changes`](State::changes) field.
         /// **It's an error if there is no match.** as there is not supposed to be a snapshot without a change to the working tree.
-        pub selection: Vec<BString>,
+        pub selection: BTreeSet<BString>,
         /// If `true`, store the current `HEAD` reference, i.e. its target, as well as the targets of all refs it's pointing to by symbolic link.
         pub head: bool,
     }
@@ -40,11 +43,21 @@ pub mod create_tree {
         pub metadata: Option<gix::ObjectId>,
     }
 
+    /// A utility to more easily use *no* workspace or metadata.
+    pub fn no_workspace_and_meta() -> Option<(
+        &'static but_graph::projection::Workspace<'static>,
+        &'static VirtualBranchesTomlMetadata,
+    )> {
+        None
+    }
+
     pub(super) mod function {
         use super::{Outcome, State};
         use but_core::RefMetadata;
+
         /// Create a tree that represents the snapshot for the given `selection`, with the basis for everything
         /// being the `head_tree_id` (i.e. the tree to which `HEAD` is ultimately pointing to).
+        /// Make this an empty tree if the `HEAD` is unborn.
         ///
         /// If `workspace_and_meta` is not `None`, the workspace and metadata to store in the snapshot.
         /// We will only store reference positions, and assume that their commits are safely stored in the reflog to not
@@ -53,10 +66,17 @@ pub mod create_tree {
         /// Note that objects will be written into the repository behind `head_tree_id` unless it's configured
         /// to keep everything in memory.
         pub fn create_tree(
-            _head_tree_id: gix::Id<'_>,
-            _selection: State,
+            head_tree_id: gix::Id<'_>,
+            State {
+                changes: _,
+                selection: _,
+                head: _,
+            }: State,
             _workspace_and_meta: Option<(&but_graph::projection::Workspace, &impl RefMetadata)>,
         ) -> anyhow::Result<Outcome> {
+            let repo = head_tree_id.repo;
+            // TODO: refactor tree-creation to not assume commits anymore.
+            // commit_engine::tree::create_tree(repo, )
             todo!()
         }
     }
@@ -91,6 +111,7 @@ pub mod resolve_tree {
 
     pub(super) mod function {
         use super::Outcome;
+        use crate::commit_engine;
 
         /// Given the `snapshot_tree` as previously returned via [super::create_tree::Outcome::snapshot_tree], extract data and…
         ///

crates/but-workspace/tests/workspace/main.rs

@@ -5,6 +5,7 @@ mod branch_details;
 mod commit_engine;
 mod flatten_diff_specs;
 mod ref_info;
+mod snapshot;
 mod tree_manipulation;
 mod ui;
 

crates/but-workspace/tests/workspace/snapshot.rs

@@ -0,0 +1,46 @@
+mod create_tree {
+    use crate::utils::read_only_in_memory_scenario;
+    use but_graph::VirtualBranchesTomlMetadata;
+    use but_testsupport::visualize_tree;
+    use but_workspace::snapshot;
+    use gix::prelude::ObjectIdExt;
+
+    #[test]
+    fn worktree_all_filetypes() -> anyhow::Result<()> {
+        let repo = read_only_in_memory_scenario("all-file-types-changed")?;
+        let (head_tree_id, state, no_workspace_and_meta) = args_for_worktree_changes(&repo)?;
+
+        let out = snapshot::create_tree(head_tree_id, state, no_workspace_and_meta)?;
+        insta::assert_snapshot!(visualize_tree(out.snapshot_tree.attach(&repo)), @r"");
+
+        insta::assert_debug_snapshot!(out, @r"");
+        Ok(())
+    }
+
+    /// Produce all args needed for creating a snapshot tree, and assure everything is selected.
+    fn args_for_worktree_changes(
+        repo: &gix::Repository,
+    ) -> anyhow::Result<(
+        gix::Id<'_>,
+        snapshot::create_tree::State,
+        Option<(
+            &'static but_graph::projection::Workspace<'static>,
+            &'static VirtualBranchesTomlMetadata,
+        )>,
+    )> {
+        let changes = but_core::diff::worktree_changes(repo)?;
+        let state = snapshot::create_tree::State {
+            selection: changes
+                .changes
+                .iter()
+                .map(|c| c.path.clone())
+                .chain(changes.ignored_changes.iter().map(|c| c.path.clone()))
+                .collect(),
+            changes,
+            head: false,
+        };
+        let head_tree_id = repo.head_tree_id_or_empty()?;
+
+        Ok((head_tree_id, state, None))
+    }
+}