Merge pull request #10338 from Byron/next

V3 apply/unapply: spread safe checkout

Author: Byron

Cargo.lock

@@ -114,6 +114,7 @@ incremental = false
 
 # Assure that `gix` is always fast so debug builds aren't unnecessarily slow.
 [profile.dev.package]
+gix = { opt-level = 3 }
 gix-object = { opt-level = 3 }
 gix-ref = { opt-level = 3 }
 gix-pack = { opt-level = 3 }

Cargo.toml

@@ -36,3 +36,11 @@ This builds the **web** target, points it to the but-server on `http://localhost
 #### 3. Go to the browser
 
 Open Chrome (let's not kid ourselves) and got to `http://localhost:1420` and enjoy
+
+### Development
+
+#### Auto-build the server on Rust changes
+
+```bash
+watchexec -w crates -r -- cargo run -p but-server
+```

apps/desktop/README.md

@@ -487,7 +487,7 @@ pub fn uncommit_changes(
 
 /// This API allows the user to quickly "stash" a bunch of uncommitted changes - getting them out of the worktree.
 /// Unlike the regular stash, the user specifies a new branch where those changes will be 'saved'/committed.
-/// Immediatelly after the changes are committed, the branch is unapplied from the workspace, and the "stash" branch can be re-applied at a later time
+/// Immediately after the changes are committed, the branch is unapplied from the workspace, and the "stash" branch can be re-applied at a later time
 /// In theory it should be possible to specify an existing "dumping" branch for this, but currently this endpoint expects a new branch.
 #[api_cmd]
 #[tauri::command(async)]
@@ -542,7 +542,13 @@ pub fn stash_into_branch(
     gitbutler_branch_actions::update_workspace_commit(&vb_state, &ctx)
         .context("failed to update gitbutler workspace")?;
 
-    branch_manager.unapply(stack.id, perm, false, Vec::new())?;
+    branch_manager.unapply(
+        stack.id,
+        perm,
+        false,
+        Vec::new(),
+        ctx.app_settings().feature_flags.cv3,
+    )?;
 
     let outcome = outcome?;
     Ok(outcome.into())

crates/but-api/src/commands/workspace.rs

@@ -35,6 +35,9 @@ but-broadcaster.workspace = true
 but-path.workspace = true
 but-settings.workspace = true
 but-feedback.workspace = true
-gitbutler-user.workspace = true
 gitbutler-project.workspace = true
 gitbutler-watcher.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+tracing-forest = { version = "0.2.0" }
+gitbutler-secret.workspace = true

crates/but-server/Cargo.toml

@@ -1,4 +1,32 @@
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
+    trace::init()?;
+    // On macOS, in dev mode with debug assertions, we encounter popups each time
+    // the binary is rebuilt. To counter that, use a git-credential based implementation.
+    // This isn't an issue for actual release build (i.e. nightly, production),
+    // hence the specific condition.
+    if cfg!(debug_assertions) && cfg!(target_os = "macos") {
+        gitbutler_secret::secret::git_credentials::setup().ok();
+    }
     but_server::run().await;
+    Ok(())
+}
+
+mod trace {
+    use tracing::metadata::LevelFilter;
+    use tracing_subscriber::Layer;
+    use tracing_subscriber::layer::SubscriberExt;
+    use tracing_subscriber::util::SubscriberInitExt;
+
+    pub fn init() -> anyhow::Result<()> {
+        tracing_subscriber::registry()
+            .with(
+                tracing_forest::ForestLayer::from(
+                    tracing_forest::printer::PrettyPrinter::new().writer(std::io::stderr),
+                )
+                .with_filter(LevelFilter::DEBUG),
+            )
+            .init();
+        Ok(())
+    }
 }

crates/but-server/src/main.rs

@@ -11,9 +11,22 @@ use gix::refs::transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog};
 use std::collections::BTreeSet;
 use tracing::instrument;
 
+/// Like [`safe_checkout()`], but the current tree will always be fetched from
+pub fn safe_checkout_from_head(
+    new_head_id: gix::ObjectId,
+    repo: &gix::Repository,
+    opts: Options,
+) -> anyhow::Result<Outcome> {
+    safe_checkout(
+        repo.head_tree_id_or_empty()?.detach(),
+        new_head_id,
+        repo,
+        opts,
+    )
+}
 /// Given the `current_head_id^{tree}` for the tree that matches what `HEAD` points to, perform all file operations necessary
 /// to turn the *worktree* of `repo` into `new_head_id^{tree}`. Note that the current *worktree* is assumed to be at the state of
-/// `current_head_tree_id` along with arbitrary uncommitted user changes.
+/// `current_head_id` along with arbitrary uncommitted user changes.
 ///
 /// Note that we don't care if the worktree actually matches the `new_head_id^{tree}`, we only care about the operations from
 /// `current_head_id^{tree}` to be performed, and if there are none, we will do nothing.

crates/but-workspace/src/branch/checkout/function.rs

@@ -458,7 +458,7 @@ impl Stack {
 
 /// Functions related to workspace checkouts.
 pub mod checkout;
-pub use checkout::function::safe_checkout;
+pub use checkout::function::{safe_checkout, safe_checkout_from_head};
 
 /// Functions and types related to applying a workspace branch.
 pub mod apply;

crates/but-workspace/src/branch/mod.rs

@@ -2,9 +2,7 @@
 use anyhow::{Context, Result};
 use gitbutler_cherry_pick::RepositoryExt as _;
 use gitbutler_command_context::CommandContext;
-use gitbutler_oxidize::{
-    GixRepositoryExt, ObjectIdExt, OidExt, RepoExt, git2_to_gix_object_id, gix_to_git2_oid,
-};
+use gitbutler_oxidize::{GixRepositoryExt, ObjectIdExt, OidExt};
 use gitbutler_repo::{RepositoryExt, SignaturePurpose};
 use gitbutler_stack::{Stack, VirtualBranchesHandle};
 use gix::merge::tree::TreatAsUnresolved;
@@ -24,7 +22,7 @@ pub fn merge_worktree_with_workspace<'a>(
 
     // The tree of where the gitbutler workspace is at
     let workspace_tree = gix_repo
-        .find_commit(super::head(ctx)?.to_gix())?
+        .find_commit(super::remerged_workspace_commit_v2(ctx)?.to_gix())?
         .tree_id()?
         .detach();
 
@@ -42,36 +40,32 @@ pub fn merge_worktree_with_workspace<'a>(
     Ok((outcome, conflict_kind))
 }
 
-/// Creates and returns a merge commit of all active branch heads.
-///
-/// This is the base against which we diff the working directory to understand
-/// what files have been modified.
-///
-/// This should be used to update the `gitbutler/workspace` ref with, which is usually
-/// done from [`update_workspace_commit()`], after any of its input changes.
-/// This is namely the conflicting state, or any head of the virtual branches.
-#[instrument(level = tracing::Level::DEBUG, skip(ctx))]
-pub fn head(ctx: &CommandContext) -> Result<git2::Oid> {
+/// Merge all currently stored stacks together into a new tree and return `(merged_tree, stacks, target_commit)` id accordingly.
+/// `gix_repo` should be optimised for merging.
+pub fn remerged_workspace_tree_v2<'git2_repo>(
+    ctx: &'git2_repo CommandContext,
+    gix_repo: &gix::Repository,
+) -> Result<(git2::Oid, Vec<Stack>, git2::Commit<'git2_repo>)> {
     let vb_state = VirtualBranchesHandle::new(ctx.project().gb_dir());
     let target = vb_state
         .get_default_target()
         .context("failed to get target")?;
-    let repo: &git2::Repository = ctx.repo();
-
+    let repo = ctx.repo();
     let mut stacks: Vec<Stack> = vb_state.list_stacks_in_workspace()?;
 
     let target_commit = repo.find_commit(target.sha)?;
-    let mut workspace_tree = repo.find_real_tree(&target_commit, Default::default())?;
-    let mut workspace_tree_id = git2_to_gix_object_id(workspace_tree.id());
+    let workspace_tree = repo.find_real_tree(&target_commit, Default::default())?;
+    let mut workspace_tree_id = workspace_tree.id().to_gix();
 
-    let gix_repo = ctx.gix_repo_for_merging()?;
     let (merge_options_fail_fast, conflict_kind) = gix_repo.merge_options_fail_fast()?;
-    let merge_tree_id = git2_to_gix_object_id(repo.find_commit(target.sha)?.tree_id());
+    let merge_tree_id = repo.find_commit(target.sha)?.tree_id().to_gix();
     for stack in stacks.iter_mut() {
-        stack.migrate_change_ids(ctx).ok(); // If it fails thats ok - best effort migration
-        let branch_head = repo.find_commit(stack.head_oid(&gix_repo)?.to_git2())?;
-        let branch_tree_id =
-            git2_to_gix_object_id(repo.find_real_tree(&branch_head, Default::default())?.id());
+        stack.migrate_change_ids(ctx).ok(); // If it fails that's ok - best effort migration
+        let branch_head = repo.find_commit(stack.head_oid(gix_repo)?.to_git2())?;
+        let branch_tree_id = repo
+            .find_real_tree(&branch_head, Default::default())?
+            .id()
+            .to_gix();
 
         let mut merge = gix_repo.merge_trees(
             merge_tree_id,
@@ -90,11 +84,26 @@ pub fn head(ctx: &CommandContext) -> Result<git2::Oid> {
             vb_state.set_stack(stack.clone())?;
         }
     }
-    workspace_tree = repo.find_tree(gix_to_git2_oid(workspace_tree_id))?;
+    Ok((workspace_tree_id.to_git2(), stacks, target_commit))
+}
+
+/// Creates and returns a merge commit of all active branch heads.
+///
+/// This is the base against which we diff the working directory to understand
+/// what files have been modified.
+///
+/// This should be used to update the `gitbutler/workspace` ref with, which is usually
+/// done from [`update_workspace_commit()`], after any of its input changes.
+/// This is namely the conflicting state, or any head of the virtual branches.
+#[instrument(level = tracing::Level::DEBUG, skip(ctx))]
+pub fn remerged_workspace_commit_v2(ctx: &CommandContext) -> Result<git2::Oid> {
+    let repo = ctx.repo();
+    let gix_repo = ctx.gix_repo_for_merging()?;
+    let (workspace_tree_id, stacks, target_commit) = remerged_workspace_tree_v2(ctx, &gix_repo)?;
+    let workspace_tree = repo.find_tree(workspace_tree_id)?;
 
     let committer = gitbutler_repo::signature(SignaturePurpose::Committer)?;
     let author = gitbutler_repo::signature(SignaturePurpose::Author)?;
-    let gix_repo = repo.to_gix()?;
     let mut heads: Vec<git2::Commit<'_>> = stacks
         .iter()
         .filter_map(|stack| stack.head_oid(&gix_repo).ok())

crates/but-workspace/src/head.rs

@@ -49,7 +49,9 @@ pub use tree_manipulation::{
     split_commit::{CommitFiles, CommmitSplitOutcome, split_commit},
 };
 pub mod head;
-pub use head::{head, merge_worktree_with_workspace};
+pub use head::{
+    merge_worktree_with_workspace, remerged_workspace_commit_v2, remerged_workspace_tree_v2,
+};
 
 /// 🚧utilities for applying and unapplying branches 🚧.
 /// Ignore the name of this module; it's just a place to put code by now.