but-testing apply to test new implementation more easily in the real-world.

Author: Byron

crates/but-testing/src/args.rs

@@ -36,6 +36,14 @@ pub struct Args {
 
 #[derive(Debug, clap::Subcommand)]
 pub enum Subcommands {
+    /// Make an existing branch appear in the workspace.
+    Apply {
+        /// The 0-based place in the worktree into which the branch should be inserted.
+        #[clap(long, short = 'o')]
+        order: Option<usize>,
+        /// The name of the branch to apply to the workspace, like `feature` or `origin/other`.
+        branch_name: String,
+    },
     /// Add the given Git repository as project for use with GitButler.
     AddProject {
         /// The long name of the remote reference to track, like `refs/remotes/origin/main`,

crates/but-testing/src/command/mod.rs

@@ -3,6 +3,9 @@ use but_core::UnifiedDiff;
 use but_db::poll::ItemKind;
 use but_graph::VirtualBranchesTomlMetadata;
 use but_settings::AppSettings;
+use but_workspace::branch::OnWorkspaceMergeConflict;
+use but_workspace::branch::apply::{IntegrationMode, WorkspaceReferenceNaming};
+use but_workspace::branch::checkout::UncommitedWorktreeChanges;
 use but_workspace::branch::create_reference::{Anchor, Position};
 use but_workspace::{DiffSpec, HunkHeader};
 use gitbutler_project::{Project, ProjectId};
@@ -634,6 +637,32 @@ pub fn remove_reference(
     Ok(())
 }
 
+pub fn apply(args: &super::Args, short_name: &str, order: Option<usize>) -> anyhow::Result<()> {
+    let (repo, project, graph, mut meta) =
+        repo_and_maybe_project_and_graph(args, RepositoryOpenMode::Merge)?;
+    let branch = repo.find_reference(short_name)?;
+    let ws = graph.to_workspace()?;
+    _ = but_workspace::branch::apply(
+        branch.name(),
+        &ws,
+        &repo,
+        &mut *meta,
+        but_workspace::branch::apply::Options {
+            integration_mode: IntegrationMode::AlwaysMerge,
+            on_workspace_conflict: OnWorkspaceMergeConflict::MaterializeAndReportConflictingStacks,
+            workspace_reference_naming: WorkspaceReferenceNaming::Default,
+            uncommitted_changes: UncommitedWorktreeChanges::KeepAndAbortOnConflict,
+            order,
+        },
+    )?;
+
+    if project.is_some() {
+        // write metadata if there are projects - this is a special case while we use vb.toml.
+        ManuallyDrop::into_inner(meta);
+    }
+    Ok(())
+}
+
 pub fn create_reference(
     args: &super::Args,
     short_name: &str,

crates/but-testing/src/main.rs

@@ -7,6 +7,7 @@ use command::parse_diff_spec;
 use gix::bstr::BString;
 
 mod args;
+use crate::args::Subcommands;
 use crate::command::{RepositoryOpenMode, repo_and_maybe_project};
 use args::Args;
 
@@ -31,6 +32,7 @@ async fn main() -> Result<()> {
     }
 
     match &args.cmd {
+        Subcommands::Apply { branch_name, order } => command::apply(&args, branch_name, *order),
         args::Subcommands::AddProject {
             switch_to_workspace,
             path,
@@ -39,7 +41,6 @@ async fn main() -> Result<()> {
             path.to_owned(),
             switch_to_workspace.to_owned(),
         ),
-
         args::Subcommands::RemoveReference {
             permit_empty_stacks,
             keep_metadata,

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

@@ -157,6 +157,7 @@ pub(crate) mod function {
                 repo,
                 checkout::Options {
                     uncommitted_changes,
+                    skip_head_update: false,
                 },
             )?;
             let graph = workspace.graph.redo_traversal_with_overlay(
@@ -353,31 +354,55 @@ pub(crate) mod function {
             });
         }
 
-        // All work is done, persist and exit.
-        // Note that it could be that some stacks aren't merged in,
-        // while being present in the workspace metadata.
-        // This is OK for us. We also trust that the hero-branch was merged in, no matter what.
-        if let Some(storage) = in_memory_repo.objects.take_object_memory() {
-            storage.persist(repo)?;
-            drop(in_memory_repo);
-        }
         let prev_head_id = graph
             .entrypoint_commit()
             .context("BUG: how is it possible that there is no head commit?")?
             .id;
         let new_head_id = merge_result.workspace_commit_id;
         let graph = graph.redo_traversal_with_overlay(
-            repo,
+            &in_memory_repo,
             meta,
             overlay.with_entrypoint(new_head_id, Some(workspace_ref_name_to_update.clone())),
         )?;
+
+        let workspace = graph.to_workspace()?;
+        let unapplied_branches: Vec<_> = branches_to_apply
+            .iter()
+            .filter_map(|rn| {
+                if workspace.refname_is_segment(rn) {
+                    None
+                } else {
+                    Some(rn)
+                }
+            })
+            .collect();
+        if !unapplied_branches.is_empty() {
+            bail!(
+                "Unexpectedly failed to apply {branches} which is/are still not in the workspace",
+                branches = unapplied_branches
+                    .iter()
+                    .map(|rn| rn.shorten().to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        }
+
+        // All work is done, persist and exit.
+        // Note that it could be that some stacks aren't merged in,
+        // while being present in the workspace metadata.
+        // This is OK for us. We also trust that the hero-branch was merged in, no matter what.
+        if let Some(storage) = in_memory_repo.objects.take_object_memory() {
+            storage.persist(repo)?;
+            drop(in_memory_repo);
+        }
         persist_metadata(meta, &branches_to_apply, &ws_md)?;
         crate::branch::safe_checkout(
             prev_head_id,
             new_head_id,
             repo,
             checkout::Options {
                 uncommitted_changes,
+                skip_head_update: true,
             },
         )?;
 
@@ -416,10 +441,9 @@ pub(crate) mod function {
         new_ref_target: gix::ObjectId,
         new_ref: Option<&gix::refs::FullNameRef>,
     ) -> anyhow::Result<()> {
-        // This also means we want HEAD to point to it.
-        let head_message = "GitButler switch to workspace during apply-branch".into();
         let edits = match new_ref {
             None => {
+                let head_message = "GitButler checkout workspace during apply-branch".into();
                 vec![RefEdit {
                     change: Change::Update {
                         log: LogChange {
@@ -435,6 +459,8 @@ pub(crate) mod function {
                 }]
             }
             Some(new_ref) => {
+                // This also means we want HEAD to point to it.
+                let head_message = "GitButler switch to workspace during apply-branch".into();
                 vec![
                     RefEdit {
                         change: Change::Update {

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

@@ -50,6 +50,7 @@ pub fn safe_checkout(
     repo: &gix::Repository,
     Options {
         uncommitted_changes: conflicting_worktree_changes_opts,
+        skip_head_update,
     }: Options,
 ) -> anyhow::Result<Outcome> {
     let source_tree = current_head_id.attach(repo).object()?.peel_to_tree()?;
@@ -138,7 +139,7 @@ pub fn safe_checkout(
     }
 
     let mut head_update = None;
-    if new_object.kind.is_commit() {
+    if new_object.kind.is_commit() && !skip_head_update {
         let needs_update = repo
             .head()?
             .id()

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

@@ -17,6 +17,10 @@ pub enum UncommitedWorktreeChanges {
 pub struct Options {
     /// How to deal with uncommitted changes.
     pub uncommitted_changes: UncommitedWorktreeChanges,
+    /// If `true`, do not change `HEAD` to the new commit.
+    ///
+    /// This is typically to be avoided, but may be used if you want to change the HEAD location yourself.
+    pub skip_head_update: bool,
 }
 
 /// The successful outcome of [super::safe_checkout()] operation.

crates/but-workspace/tests/fixtures/scenario/no-ws-ref-stack-and-dependent-branch.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -eu -o pipefail
+
+source "${BASH_SOURCE[0]%/*}/shared.sh"
+
+### General Description
+
+# A target branch along with a stack and a depdendent branch at the same tip, without workspace commit.
+git init
+commit M
+setup_target_to_match_main
+git checkout -b A
+commit A1
+git branch D
+git branch E
+commit A2
+git branch B
+git branch C
+
+git checkout main

crates/but-workspace/tests/workspace/branch/apply_unapply_commit_uncommit.rs

@@ -521,6 +521,79 @@ fn detached_head_journey() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn apply_two_ambiguous_stacks_with_target() -> anyhow::Result<()> {
+    let (_tmp, graph, repo, mut meta, _description) =
+        named_writable_scenario_with_description_and_graph(
+            "no-ws-ref-stack-and-dependent-branch",
+            |_meta| {},
+        )?;
+    insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
+    * f084d61 (C, B, A) A2
+    * 7076dee (E, D) A1
+    * 85efbe4 (HEAD -> main, origin/main) M
+    ");
+
+    let ws = graph.to_workspace()?;
+    insta::assert_snapshot!(graph_workspace(&ws), @r"
+    ⌂:0:main <> ✓!
+    └── ≡:0:main
+        └── :0:main
+            └── ·85efbe4
+    ");
+
+    // Apply `A` first.
+    let out =
+        but_workspace::branch::apply(r("refs/heads/A"), &ws, &repo, &mut meta, default_options())?;
+    insta::assert_debug_snapshot!(out, @r"
+    Outcome {
+        workspace_changed: true,
+        workspace_ref_created: true,
+    }
+    ");
+    let graph = out.graph;
+    let ws = graph.to_workspace()?;
+    insta::assert_snapshot!(graph_workspace(&ws), @r"
+    📕🏘️:0:gitbutler/workspace <> ✓refs/remotes/origin/main on 85efbe4
+    └── ≡📙:3:A on 85efbe4
+        └── 📙:3:A
+            ├── ·f084d61 (🏘️) ►B, ►C
+            └── ·7076dee (🏘️) ►D, ►E
+    ");
+    insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
+    * 6a706b7 (HEAD -> gitbutler/workspace) GitButler Workspace Commit
+    * f084d61 (C, B, A) A2
+    * 7076dee (E, D) A1
+    * 85efbe4 (origin/main, main) M
+    ");
+
+    // Apply `B` - the only sane way is to make it its own stack, but allow it to diverge.
+    let out =
+        but_workspace::branch::apply(r("refs/heads/B"), &ws, &repo, &mut meta, default_options())
+            .expect("apply actually works");
+    insta::assert_debug_snapshot!(out, @r"
+    Outcome {
+        workspace_changed: true,
+        workspace_ref_created: false,
+    }
+    ");
+
+    // TODO: Make it work as dependent branch
+    let graph = out.graph;
+    let ws = graph.to_workspace()?;
+    insta::assert_snapshot!(graph_workspace(&ws), @r"");
+    insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
+    * ccbee14 (HEAD -> gitbutler/workspace) GitButler Workspace Commit
+    |\
+    | * 6a706b7 (main) GitButler Workspace Commit
+    |/  
+    * f084d61 (B, A) A2
+    * 7076dee A1
+    * 85efbe4 (origin/main) M
+    ");
+    Ok(())
+}
+
 #[test]
 fn auto_checkout_of_enclosing_workspace_flat() -> anyhow::Result<()> {
     let (_tmp, graph, repo, mut meta, _description) =

crates/but-workspace/tests/workspace/branch/checkout.rs

@@ -827,6 +827,7 @@ fn unrelated_additions_do_not_affect_worktree_changes() -> anyhow::Result<()> {
 fn overwrite_options() -> checkout::Options {
     checkout::Options {
         uncommitted_changes: UncommitedWorktreeChanges::KeepConflictingInSnapshotAndOverwrite,
+        skip_head_update: false,
     }
 }
 

crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs

@@ -168,7 +168,7 @@ impl BranchManager<'_> {
             let applied_branch_stack_id = ws
                 .find_segment_and_stack_by_refname(branch_to_apply)
                 .with_context(||
-                    format!("Failed to apply branch and we probably have to handle more of the outcome\n{out:?}")
+                    format!("BUG: Can't find the branch to apply in workspace, but the 'apply' function should have failed instead \n{out:?}")
                 )?
                 .0
                 .id