Merge pull request #10645 from gitbutlerapp/but-worktree-list

But worktree list

Author: Caleb-T-Owens

Cargo.lock

@@ -1,6 +1,7 @@
 use crate::error::Error;
 use but_api_macros::api_cmd;
 use but_settings::AppSettings;
+use but_worktrees::list::ListWorktreeOutcome;
 use but_worktrees::new::NewWorktreeOutcome;
 use gitbutler_command_context::CommandContext;
 use gitbutler_project::ProjectId;
@@ -17,3 +18,14 @@ pub fn worktree_new(project_id: ProjectId, reference: String) -> Result<NewWorkt
     but_worktrees::new::worktree_new(&mut ctx, guard.read_permission(), &reference)
         .map_err(Into::into)
 }
+
+#[api_cmd]
+#[cfg_attr(feature = "tauri", tauri::command(async))]
+#[instrument(err(Debug))]
+pub fn worktree_list(project_id: ProjectId) -> Result<ListWorktreeOutcome, Error> {
+    let project = gitbutler_project::get(project_id)?;
+    let guard = project.exclusive_worktree_access();
+    let mut ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+
+    but_worktrees::list::worktree_list(&mut ctx, guard.read_permission()).map_err(Into::into)
+}

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

@@ -25,6 +25,7 @@ tracing.workspace = true
 
 [dev-dependencies]
 gix-testtools.workspace = true
+gitbutler-branch-actions.workspace = true
 gitbutler-testsupport.workspace = true
 gitbutler-oxidize.workspace = true
 insta.workspace = true

crates/but-worktrees/Cargo.toml

@@ -13,6 +13,7 @@ pub fn save_worktree(ctx: &mut CommandContext, worktree: Worktree) -> Result<()>
 }
 
 /// Retrieve a worktree by its path.
+#[allow(unused)]
 pub fn get_worktree(ctx: &mut CommandContext, path: &Path) -> Result<Option<Worktree>> {
     let path_str = path.to_string_lossy();
     let worktree = ctx.db()?.worktrees().get(&path_str)?;
@@ -23,6 +24,7 @@ pub fn get_worktree(ctx: &mut CommandContext, path: &Path) -> Result<Option<Work
 }
 
 /// Delete a worktree from the database.
+#[allow(unused)]
 pub fn delete_worktree(ctx: &mut CommandContext, path: &Path) -> Result<()> {
     let path_str = path.to_string_lossy();
     ctx.db()?.worktrees().delete(&path_str)?;

crates/but-worktrees/src/db.rs

@@ -0,0 +1,40 @@
+use crate::{Worktree, WorktreeHealthStatus, WorktreeSource};
+use anyhow::Result;
+use bstr::BStr;
+use but_workspace::ui::StackHeadInfo;
+
+pub fn get_health(
+    repo: &gix::Repository,
+    worktree: &Worktree,
+    heads: &[StackHeadInfo],
+) -> Result<WorktreeHealthStatus> {
+    if !heads.iter().any(|h| match &worktree.source {
+        WorktreeSource::Branch(b) => h.name == BStr::new(&b),
+    }) {
+        return Ok(WorktreeHealthStatus::WorkspaceBranchMissing);
+    };
+
+    let git_worktrees = repo.worktrees()?;
+    let Some(git_worktree) = git_worktrees
+        .iter()
+        .find(|w| w.base().map(|b| b == worktree.path).unwrap_or(false))
+    else {
+        return Ok(WorktreeHealthStatus::WorktreeMissing);
+    };
+
+    if repo.try_find_reference(&worktree.reference)?.is_none() {
+        return Ok(WorktreeHealthStatus::BranchMissing);
+    };
+    let worktree_repo = git_worktree.clone().into_repo()?;
+
+    if !worktree_repo
+        .head()?
+        .referent_name()
+        .map(|n| n.as_bstr() == worktree.reference)
+        .unwrap_or(false)
+    {
+        return Ok(WorktreeHealthStatus::BranchNotCheckedOut);
+    }
+
+    Ok(WorktreeHealthStatus::Normal)
+}

crates/but-worktrees/src/gc.rs

@@ -5,8 +5,10 @@ use std::path::PathBuf;
 use serde::{Deserialize, Serialize};
 
 /// Database operations for worktrees.
-pub mod db;
-pub mod git;
+pub(crate) mod db;
+pub(crate) mod gc;
+pub(crate) mod git;
+pub mod list;
 pub mod new;
 
 /// The source from which a worktree was created.
@@ -26,7 +28,7 @@ pub enum WorktreeSource {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Worktree {
-    /// The filesystem path to the worktree.
+    /// The canonicalized filesystem path to the worktree.
     pub path: PathBuf,
     /// The git reference this worktree was created from. This is a fully
     /// qualified reference
@@ -36,3 +38,21 @@ pub struct Worktree {
     /// The source from which this worktree was created.
     pub source: WorktreeSource,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(tag = "type", content = "data", rename_all = "camelCase")]
+/// This gets used as a public API in the CLI so be careful when modifying.
+pub enum WorktreeHealthStatus {
+    /// The worktree is in a healthy state
+    Normal,
+    /// The worktree has a different branch checked out than expected
+    /// This is not strictly an issue & could be an intened user state
+    BranchMissing,
+    /// The branch we expect to be checked out does not exist
+    /// This is not strictly an issue & could be an intened user state
+    BranchNotCheckedOut,
+    /// The actual worktree doesn't exist - should GC
+    WorktreeMissing,
+    /// No cooresponding branch name in workspace - should GC
+    WorkspaceBranchMissing,
+}

crates/but-worktrees/src/lib.rs

@@ -0,0 +1,48 @@
+use anyhow::Result;
+use but_graph::VirtualBranchesTomlMetadata;
+use but_workspace::{StacksFilter, stacks_v3};
+use gitbutler_command_context::CommandContext;
+use gitbutler_project::access::WorktreeReadPermission;
+use serde::{Deserialize, Serialize};
+
+use crate::{Worktree, WorktreeHealthStatus, db::list_worktrees, gc::get_health};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+/// This gets used as a public API in the CLI so be careful when modifying.
+pub struct ListWorktreeOutcome {
+    pub entries: Vec<WorktreeListEntry>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+/// This gets used as a public API in the CLI so be careful when modifying.
+pub struct WorktreeListEntry {
+    pub status: WorktreeHealthStatus,
+    pub worktree: Worktree,
+}
+
+/// Creates a new worktree off of a branches given name.
+pub fn worktree_list(
+    ctx: &mut CommandContext,
+    _perm: &WorktreeReadPermission,
+) -> Result<ListWorktreeOutcome> {
+    let repo = ctx.gix_repo_for_merging()?;
+    let meta = VirtualBranchesTomlMetadata::from_path(
+        ctx.project().gb_dir().join("virtual_branches.toml"),
+    )?;
+    let stacks = stacks_v3(&repo, &meta, StacksFilter::InWorkspace, None)?;
+    let heads = stacks.into_iter().flat_map(|s| s.heads).collect::<Vec<_>>();
+
+    let entries = list_worktrees(ctx)?
+        .into_iter()
+        .map(|w| {
+            Ok(WorktreeListEntry {
+                status: get_health(&repo, &w, &heads)?,
+                worktree: w,
+            })
+        })
+        .collect::<Result<Vec<_>>>()?;
+
+    Ok(ListWorktreeOutcome { entries })
+}

crates/but-worktrees/src/list.rs

@@ -43,7 +43,7 @@ pub fn worktree_new(
     git_worktree_add(&ctx.project().path, &path, &branch_name, head.tip)?;
 
     let worktree = Worktree {
-        path,
+        path: path.canonicalize()?,
         reference: format!("refs/heads/{}", branch_name),
         base: head.tip,
         source: WorktreeSource::Branch(head.name.to_string()),

crates/but-worktrees/src/new.rs

@@ -20,18 +20,15 @@ git clone remote stacked-and-parallel
   git config user.name "Author"
   git config user.email "[email protected]"
 
-  echo A
   # Initialize GitButler project
   $CLI init
-  echo B
 
   # Create feature-a stack (base branch)
   $CLI branch new feature-a
   echo "feature-a line 1" >> file.txt
   $CLI commit -m "feature-a: add line 1" feature-a
   echo "feature-a line 2" >> file.txt
   $CLI commit -m "feature-a: add line 2" feature-a
-  echo C
 
   # Create feature-b stack (stacked on feature-a)
   $CLI branch new feature-b --anchor feature-a
@@ -46,4 +43,4 @@ git clone remote stacked-and-parallel
   $CLI commit -m "feature-c: add new file" feature-c
   echo "feature-c line 2" >> feature-c.txt
   $CLI commit -m "feature-c: add line 2" feature-c
-)
+)

crates/but-worktrees/tests/fixtures/worktree.sh

@@ -23,7 +23,7 @@ mod util {
     }
 }
 
-mod stacked_and_parallel {
+mod worktree_new {
     use super::*;
     use anyhow::Context;
     use but_graph::VirtualBranchesTomlMetadata;
@@ -187,3 +187,104 @@ mod stacked_and_parallel {
         Ok(())
     }
 }
+
+mod worktree_list {
+    use super::*;
+    use but_graph::VirtualBranchesTomlMetadata;
+    use but_workspace::{StacksFilter, stacks_v3};
+    use but_worktrees::{WorktreeHealthStatus, list::worktree_list, new::worktree_new};
+    use gitbutler_branch_actions::BranchManagerExt as _;
+    use gix::refs::transaction::PreviousValue;
+    use util::test_ctx;
+
+    #[test]
+    fn can_list_worktrees() -> anyhow::Result<()> {
+        let test_ctx = test_ctx("stacked-and-parallel")?;
+        let mut ctx = test_ctx.ctx;
+
+        let repo = ctx.gix_repo()?;
+
+        let mut guard = ctx.project().exclusive_worktree_access();
+
+        let a = worktree_new(&mut ctx, guard.read_permission(), "feature-a")?; // To stay Normal
+        let b = worktree_new(&mut ctx, guard.read_permission(), "feature-a")?; // To be BranchMissing
+        let c = worktree_new(&mut ctx, guard.read_permission(), "feature-a")?; // To be BranchNotCheckedOut
+        let d = worktree_new(&mut ctx, guard.read_permission(), "feature-a")?; // To be WorktreeMissing
+        let e = worktree_new(&mut ctx, guard.read_permission(), "feature-c")?; // To be WorkspaceBranchMissing
+
+        let all = &[&a, &b, &c, &d, &e];
+
+        // All should start normal
+        assert!(
+            worktree_list(&mut ctx, guard.read_permission())?
+                .entries
+                .iter()
+                .all(|e| all.iter().any(|a| a.created == e.worktree)
+                    && e.status == WorktreeHealthStatus::Normal)
+        );
+
+        // remove b's branch
+        repo.find_reference(&b.created.reference)?.delete()?;
+
+        // checkout a different branch on c
+        repo.reference(
+            "refs/heads/new-ref",
+            c.created.base,
+            PreviousValue::Any,
+            "New reference :D",
+        )?;
+        std::process::Command::from(gix::command::prepare(gix::path::env::exe_invocation()))
+            .current_dir(&c.created.path)
+            .arg("switch")
+            .arg("new-ref")
+            .output()?;
+
+        // delete d's worktree
+        std::process::Command::from(gix::command::prepare(gix::path::env::exe_invocation()))
+            .current_dir(&ctx.project().path)
+            .arg("worktree")
+            .arg("remove")
+            .arg("-f")
+            .arg(d.created.path.as_os_str())
+            .output()?;
+
+        // remove `feature-c` branch from workspace
+        // It would be nice to invoke the `but` cli here...
+        let meta = VirtualBranchesTomlMetadata::from_path(
+            ctx.project().gb_dir().join("virtual_branches.toml"),
+        )?;
+        let stack = stacks_v3(&repo, &meta, StacksFilter::InWorkspace, None)?
+            .into_iter()
+            .find(|s| s.heads.iter().any(|h| h.name == b"feature-c"))
+            .unwrap();
+        let branch_manager = ctx.branch_manager();
+        branch_manager.unapply(
+            stack.id.unwrap(),
+            guard.write_permission(),
+            false,
+            vec![],
+            ctx.app_settings().feature_flags.cv3,
+        )?;
+
+        assert!(
+            worktree_list(&mut ctx, guard.read_permission())?
+                .entries
+                .into_iter()
+                .all(|entry| if entry.worktree == a.created {
+                    entry.status == WorktreeHealthStatus::Normal
+                } else if entry.worktree == b.created {
+                    entry.status == WorktreeHealthStatus::BranchMissing
+                } else if entry.worktree == c.created {
+                    entry.status == WorktreeHealthStatus::BranchNotCheckedOut
+                } else if entry.worktree == d.created {
+                    entry.status == WorktreeHealthStatus::WorktreeMissing
+                } else if entry.worktree == e.created {
+                    entry.status == WorktreeHealthStatus::WorkspaceBranchMissing
+                } else {
+                    false
+                })
+        );
+
+        Ok(())
+    }
+}