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/commit_engine/mod.rs

@@ -231,11 +231,28 @@ pub fn create_commit(
         bail!("cannot currently handle more than 1 parent")
     }
 
+    let target_tree = match &destination {
+        Destination::NewCommit {
+            parent_commit_id: None,
+            ..
+        } => gix::ObjectId::empty_tree(repo.object_hash()),
+        Destination::NewCommit {
+            parent_commit_id: Some(base_commit),
+            ..
+        }
+        | Destination::AmendCommit {
+            commit_id: base_commit,
+            ..
+        } => but_core::Commit::from_id(base_commit.attach(repo))?
+            .tree_id_or_auto_resolution()?
+            .detach(),
+    };
+
     let CreateTreeOutcome {
         rejected_specs,
         destination_tree,
         changed_tree_pre_cherry_pick,
-    } = create_tree(repo, &destination, move_source, changes, context_lines)?;
+    } = create_tree(repo, target_tree, move_source, changes, context_lines)?;
     let new_commit = if let Some(new_tree) = destination_tree {
         match destination {
             Destination::NewCommit {

crates/but-workspace/src/commit_engine/tree/mod.rs

@@ -1,4 +1,4 @@
-use crate::commit_engine::{Destination, MoveSourceCommit, RejectionReason, apply_hunks};
+use crate::commit_engine::{MoveSourceCommit, RejectionReason, apply_hunks};
 use crate::{DiffSpec, HunkHeader};
 use bstr::{BStr, ByteSlice};
 use but_core::{RepositoryExt, UnifiedDiff};
@@ -17,8 +17,8 @@ pub struct CreateTreeOutcome {
     /// when merging the workspace commit, or because the specified hunks didn't match exactly due to changes
     /// that happened in the meantime, or if a file without a change was specified.
     pub rejected_specs: Vec<(RejectionReason, DiffSpec)>,
-    /// The newly created seen from tree that acts as the destination of the changes, or `None` if no commit could be
-    /// created as all changes-requests were rejected.
+    /// The newly created seen from tree that acts as the destination of the changes, or `None` if no tree could be
+    /// created as all changes-requests were rejected (or there was no change).
     pub destination_tree: Option<gix::ObjectId>,
     /// If `destination_tree` is `Some(_)`, this field is `Some(_)` as well and denotes the base-tree + all changes.
     /// If the applied changes were from the worktree, it's `HEAD^{tree}` + changes.
@@ -29,28 +29,11 @@ pub struct CreateTreeOutcome {
 /// Like [`create_commit()`], but lower-level and only returns a new tree, without finally associating it with a commit.
 pub fn create_tree(
     repo: &gix::Repository,
-    destination: &Destination,
+    target_tree: gix::ObjectId,
     move_source: Option<MoveSourceCommit>,
     changes: Vec<DiffSpec>,
     context_lines: u32,
 ) -> anyhow::Result<CreateTreeOutcome> {
-    let target_tree = match destination {
-        Destination::NewCommit {
-            parent_commit_id: None,
-            ..
-        } => gix::ObjectId::empty_tree(repo.object_hash()),
-        Destination::NewCommit {
-            parent_commit_id: Some(base_commit),
-            ..
-        }
-        | Destination::AmendCommit {
-            commit_id: base_commit,
-            ..
-        } => but_core::Commit::from_id(base_commit.attach(repo))?
-            .tree_id_or_auto_resolution()?
-            .detach(),
-    };
-
     let mut changes: Vec<_> = changes.into_iter().map(Ok).collect();
     let (new_tree, changed_tree_pre_cherry_pick) = if changes.is_empty() {
         (Some(target_tree), None)
@@ -81,7 +64,7 @@ pub fn create_tree(
             let tree_with_changes = if new_tree == actual_base_tree
                 && changes.iter().all(|c| {
                     c.is_ok()
-                        // Some rejections are OK and we want to create a commit anyway.
+                        // Some rejections are OK, and we want to create a commit anyway.
                         || !matches!(
                             c,
                             Err((RejectionReason::CherryPickMergeConflict,_))

crates/but-workspace/src/snapshot/create_tree.rs

@@ -0,0 +1,155 @@
+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).
+#[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: but_core::WorktreeChanges,
+    /// Repository-relative and slash-separated paths that match any change in the  [`changes`](State::changes) field.
+    /// It is *not* error if there is no match, as there can be snapshots without working tree changes, but with other changes.
+    /// It's up to the caller to check for that via [`Outcome::is_empty()`].
+    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,
+}
+
+/// Contains all state that the snapshot contains.
+#[derive(Debug, Copy, Clone)]
+pub struct Outcome {
+    /// The snapshot itself, with all the subtrees available that are also listed in this structure.
+    pub snapshot_tree: gix::ObjectId,
+    /// For good measure, the input `HEAD^{tree}` that is used as the basis to learn about worktree changes.
+    pub head_tree: gix::ObjectId,
+    /// The `head_tree`  with the selected worktree changes applied, suitable for being stored in a commit,
+    /// or `None` if there was no change in the worktree.
+    pub worktree: Option<gix::ObjectId>,
+    /// The tree representing the current changed index, without conflicts, or `None` if there was no change to the index.
+    pub index: Option<gix::ObjectId>,
+    /// A tree with files in a custom storage format to allow keeping conflicting blobs reachable, along with detailed conflict information
+    /// to allow restoring the conflict entries in the index.
+    pub index_conflicts: Option<gix::ObjectId>,
+    /// The tree representing the reference targets of all references within the *workspace*.
+    pub workspace_references: Option<gix::ObjectId>,
+    /// The tree representing the reference targets of all references reachable from `HEAD`, so typically `HEAD` itself, and the
+    /// target object of the reference it is pointing to.
+    pub head_references: Option<gix::ObjectId>,
+    /// The tree representing the metadata of all references within the *workspace*.
+    pub metadata: Option<gix::ObjectId>,
+}
+
+impl Outcome {
+    /// Return `true` if the snapshot contains no information whatsoever, which is equivalent to being an empty tree.
+    pub fn is_empty(&self) -> bool {
+        self.snapshot_tree.is_empty_tree()
+    }
+}
+
+/// 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 crate::{DiffSpec, commit_engine};
+    use anyhow::bail;
+    use but_core::RefMetadata;
+    use gix::object::tree::EntryKind;
+    use tracing::instrument;
+
+    /// 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
+    /// be garbage collected. Metadata is only stored for the references that are included in the `workspace`.
+    ///
+    /// Note that objects will be written into the repository behind `head_tree_id` unless it's configured
+    /// to keep everything in memory.
+    ///
+    /// ### Snapshot Tree Format
+    ///
+    /// There are the following top-level trees, with their own sub-formats which aren't specified here.
+    /// However, it's notable that they have to be implemented so that they remain compatible to prior versions
+    /// of the tree.
+    ///
+    /// Note that all top-level entries are optional, and only present if there is a snapshot to store.
+    ///
+    /// * `HEAD`
+    ///     - the tree to which `HEAD` was pointing at the time the snapshot was created.
+    ///     - this is relevant when re-applying the worktree-changes and when recreating the `index`.
+    ///     - only set if it is needed to restore some of the snapshot state.
+    /// * `worktree`
+    ///     - the tree of `HEAD + uncommitted files`. Technically this means that now possibly untracked files are known to Git,
+    ///       even though it might be that the respective objects aren't written to disk yet.
+    ///     - Note that this tree may contain files with conflict markers as it will pick up the conflicting state visible on disk.
+    /// * `index`
+    ///     - A representation of the non-conflicting portions of the index, without its meta-data.
+    #[instrument(skip(changes, _workspace_and_meta), err(Debug))]
+    pub fn create_tree(
+        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.
+        let mut changes_to_apply: Vec<_> = changes
+            .changes
+            .iter()
+            .filter(|c| selection.contains(&c.path))
+            .map(|c| Ok(DiffSpec::from(c)))
+            .collect();
+        let (new_tree, base_tree) = commit_engine::tree::apply_worktree_changes(
+            head_tree_id.into(),
+            repo,
+            &mut changes_to_apply,
+            0, /* context lines don't matter */
+        )?;
+
+        let rejected = changes_to_apply
+            .into_iter()
+            .filter_map(Result::err)
+            .collect::<Vec<_>>();
+        if !rejected.is_empty() {
+            bail!(
+                "It should be impossible to fail to apply changes that are in the tree that was provided as HEAD^{{tree}} - {rejected:?}"
+            )
+        }
+
+        let mut edit = repo.empty_tree().edit()?;
+
+        let worktree = (new_tree != base_tree).then_some(new_tree.detach());
+        let mut needs_head = false;
+        if let Some(worktree) = worktree {
+            edit.upsert("worktree", EntryKind::Tree, worktree)?;
+            needs_head = true;
+        }
+
+        if needs_head {
+            edit.upsert("HEAD", EntryKind::Tree, head_tree_id)?;
+        }
+
+        Ok(Outcome {
+            snapshot_tree: edit.write()?.into(),
+            head_tree: head_tree_id.into(),
+            worktree,
+            index: None,
+            index_conflicts: None,
+            workspace_references: None,
+            head_references: None,
+            metadata: None,
+        })
+    }
+}

crates/but-workspace/src/snapshot.rs renamed to crates/but-workspace/src/snapshot/mod.rs

@@ -1,66 +1,7 @@
 //! The ability to create a Git representation of diverse 'state' that can be restored at a later time.
 
-///
-pub mod create_tree {
-    use bstr::BString;
-
-    /// A way to determine what should be included in the snapshot when calling [create_tree()](function::create_tree).
-    pub struct State<'a> {
-        /// 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,
-        /// 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>,
-        /// 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,
-    }
-
-    /// Contains all state that the snapshot contains.
-    #[derive(Debug, Copy, Clone)]
-    pub struct Outcome {
-        /// The snapshot itself, with all the subtrees available that are also listed in this structure.
-        pub snapshot_tree: gix::ObjectId,
-        /// For good measure, the input `HEAD^{tree}` that is used as the basis to learn about worktree changes.
-        pub head_tree: gix::ObjectId,
-        /// The `head_tree`  with the selected worktree changes applied, suitable for being stored in a commit.
-        pub wortree: gix::ObjectId,
-        /// The tree representing the current changed index, without conflicts, or `None` if there was no change to the index.
-        pub index: Option<gix::ObjectId>,
-        /// A tree with files in a custom storage format to allow keeping conflicting blobs reachable, along with detailed conflict information
-        /// to allow restoring the conflict entries in the index.
-        pub index_conflicts: Option<gix::ObjectId>,
-        /// The tree representing the reference targets of all references within the *workspace*.
-        pub workspace_references: Option<gix::ObjectId>,
-        /// The tree representing the reference targets of all references reachable from `HEAD`, so typically `HEAD` itself, and the
-        /// target object of the reference it is pointing to.
-        pub head_references: Option<gix::ObjectId>,
-        /// The tree representing the metadata of all references within the *workspace*.
-        pub metadata: Option<gix::ObjectId>,
-    }
-
-    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).
-        ///
-        /// 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
-        /// be garbage collected. Metadata is only stored for the references that are included in the `workspace`.
-        ///
-        /// 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,
-            _workspace_and_meta: Option<(&but_graph::projection::Workspace, &impl RefMetadata)>,
-        ) -> anyhow::Result<Outcome> {
-            todo!()
-        }
-    }
-}
+/// Structures to call the [create_tree()] function.
+pub mod create_tree;
 pub use create_tree::function::create_tree;
 
 /// Utilities related to resolving previously created snapshots.
@@ -70,9 +11,12 @@ pub mod resolve_tree {
     pub struct Outcome<'repo> {
         /// The cherry-pick result as merge between the target worktree and the snapshot, **possibly with conflicts**.
         ///
-        /// This tree, may be checked out to the working tree, with or without conflicts.
-        pub workspace_cherry_pick: gix::merge::tree::Outcome<'repo>,
+        /// This tree, may be checked out to the working tree, with or without conflicts - it's entirely left to the caller.
+        /// It's `None` if the was no worktree change.
+        pub workspace_cherry_pick: Option<gix::merge::tree::Outcome<'repo>>,
         /// If an index was stored in the snapshot, this is the reconstructed index, including conflicts.
+        ///
+        /// It's `None` if there were no index-only changes.
         pub index: Option<gix::index::State>,
         /// Reference edits that when applied in a transaction will set the workspace back to where it was. Only available
         /// if it was part of the snapshot to begin with.
@@ -89,22 +33,33 @@ pub mod resolve_tree {
         pub branches: Vec<(gix::refs::FullName, but_core::ref_metadata::Branch)>,
     }
 
-    pub(super) mod function {
-        use super::Outcome;
+    /// Options for use in [super::resolve_tree()].
+    #[derive(Debug, Clone)]
+    pub struct Options {
+        /// If set, the non-default options to use when cherry-picking the worktree changes onto the target tree.
+        ///
+        /// If `None`, perform the merge just like Git.
+        pub workspace_cherry_pick: Option<gix::merge::tree::Options>,
+    }
 
+    pub(super) mod function {
+        use super::{Options, Outcome};
         /// Given the `snapshot_tree` as previously returned via [super::create_tree::Outcome::snapshot_tree], extract data and…
         ///
         /// * …cherry-pick the worktree changes onto the `target_worktree_tree_id`, which is assumed to represent the future working directory state
-        ///    and which either contains the worktree changes or *preferably* is the `HEAD^{tree}` as the working directory is clean.
+        ///   and which either contains the worktree changes or *preferably* is the `HEAD^{tree}` as the working directory is clean.
         /// * …reconstruct the index to write into `.git/index`, assuming that the current `.git/index` is clean.
         /// * …produce reference edits to put the workspace refs back into place with.
         /// * …produce metadata that if set will represent the metadata of the entire workspace.
         ///
         /// Note that none of this data is actually manifested in the repository or working tree, they only exists as objects in the Git database,
         /// assuming in-memory objects aren't used in the repository.
-        pub fn resolve_tree<'repo>(
+        pub fn resolve_tree(
             _snapshot_tree: gix::Id<'_>,
             _target_worktree_tree_id: gix::ObjectId,
+            Options {
+                workspace_cherry_pick: _,
+            }: Options,
         ) -> anyhow::Result<Outcome<'_>> {
             todo!()
         }
@@ -152,13 +107,13 @@ mod commit {
         type Err = anyhow::Error;
 
         fn from_str(s: &str) -> anyhow::Result<Self, Self::Err> {
-            let parts: Vec<&str> = s.splitn(2, ':').collect();
-            if parts.len() != 2 {
+            let mut parts = s.splitn(2, ':');
+            let (Some(key), Some(value)) = (parts.next(), parts.next()) else {
                 return Err(anyhow!("Invalid trailer format, expected `key: value`"));
-            }
-            let unescaped_value = parts[1].trim().replace("\\n", "\n");
+            };
+            let unescaped_value = value.trim().replace("\\n", "\n");
             Ok(Self {
-                key: parts[0].trim().to_string(),
+                key: key.trim().to_string(),
                 value: unescaped_value,
             })
         }