Add V3 support for discarding files

For now, no hunks or hunk-ranges.

Author: Byron

Cargo.lock

@@ -90,6 +90,13 @@ pub fn visualize_commit_graph(
     Ok(log.stdout.to_str().expect("no illformed UTF-8").to_string())
 }
 
+/// Run a condensed status on `repo`.
+pub fn git_status(repo: &gix::Repository) -> std::io::Result<String> {
+    let out = git(repo).args(["status", "--porcelain"]).output()?;
+    assert!(out.status.success());
+    Ok(out.stdout.to_str().expect("no illformed UTF-8").to_string())
+}
+
 /// Display a Git tree in the style of the `tree` CLI program, but include blob contents and usful Git metadata.
 pub fn visualize_tree(tree_id: gix::Id<'_>) -> termtree::Tree<String> {
     fn visualize_tree(
@@ -141,3 +148,51 @@ pub fn visualize_tree(tree_id: gix::Id<'_>) -> termtree::Tree<String> {
     }
     visualize_tree(tree_id.object().unwrap().peel_to_tree().unwrap().id(), None).unwrap()
 }
+
+/// Visualize a tree on disk with mode information.
+/// For convenience, skip `.git` and don't display the root.
+///
+/// # IMPORTANT: Portability
+///
+/// As it's intended for tests, this can't be called on Windows were modes don't exist.
+/// Further, be sure to set the `umask` of the process to something explicit, or else it may differ
+/// between runs and cause failures.
+#[cfg(unix)]
+pub fn visualize_disk_tree_skip_dot_git(root: &Path) -> anyhow::Result<termtree::Tree<String>> {
+    use std::os::unix::fs::MetadataExt;
+    fn label(p: &Path, md: &std::fs::Metadata) -> String {
+        format!(
+            "{name}:{mode:o}",
+            name = p.file_name().unwrap().to_str().unwrap(),
+            mode = md.mode(),
+        )
+    }
+
+    fn tree(p: &Path, show_label: bool) -> std::io::Result<termtree::Tree<String>> {
+        let mut cur = termtree::Tree::new(if show_label {
+            label(p, &p.symlink_metadata()?)
+        } else {
+            ".".into()
+        });
+
+        let mut entries: Vec<_> = std::fs::read_dir(p)?.filter_map(|e| e.ok()).collect();
+        entries.sort_by_key(|e| e.file_name());
+        for entry in entries {
+            let md = entry.metadata()?;
+            if md.is_dir() && entry.file_name() != ".git" {
+                cur.push(tree(&entry.path(), true)?);
+            } else {
+                cur.push(termtree::Tree::new(label(&entry.path(), &md)));
+            }
+        }
+        Ok(cur)
+    }
+
+    Ok(tree(root, false)?)
+}
+
+/// Windows dummy
+#[cfg(not(unix))]
+pub fn visualize_disk_tree(root: &Path) -> anyhow::Result<termtree::Tree<String>> {
+    anyhow::bail!("BUG: must not run on Windows - results won't be desirable");
+}

crates/but-testsupport/src/lib.rs

@@ -34,6 +34,7 @@ toml.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
+rustix = { version = "1.0.2", features = ["process", "fs"] }
 but-testsupport.workspace = true
 insta = "1.42.1"
 but-core = { workspace = true, features = ["testing"] }

crates/but-workspace/Cargo.toml

@@ -52,6 +52,7 @@ pub fn apply_lhs_to_rhs(
                     &md,
                     id.into_owned(),
                     entry_mode,
+                    gix::index::entry::Flags::empty(),
                     &mut num_sorted_entries,
                 )?;
             }
@@ -72,12 +73,13 @@ pub fn apply_lhs_to_rhs(
 // TODO(gix): this could be a platform in Gix which supports these kinds of edits while assuring
 //       consistency. It could use some tricks to not have worst-case performance like this has.
 //       It really is index-add that we need.
-fn upsert_index_entry(
+pub fn upsert_index_entry(
     index: &mut gix::index::State,
     rela_path: &BStr,
     md: &gix::index::fs::Metadata,
     id: gix::ObjectId,
     mode: gix::index::entry::Mode,
+    add_flags: gix::index::entry::Flags,
     num_sorted_entries: &mut usize,
 ) -> anyhow::Result<bool> {
     use gix::index::entry::Stage;
@@ -100,14 +102,15 @@ fn upsert_index_entry(
         //       This basically forces it to look closely, bad for performance, but at
         //       least correct. Usually it fixes itself as well.
         entry.stat = Default::default();
+        entry.flags |= add_flags;
         entry.id = id;
         entry.mode = mode;
         false
     } else {
         index.dangerously_push_entry(
             gix::index::entry::Stat::from_fs(md)?,
             id,
-            gix::index::entry::Flags::empty(),
+            add_flags,
             mode,
             rela_path,
         );

crates/but-workspace/src/commit_engine/index.rs

@@ -16,7 +16,7 @@ mod tree;
 use crate::commit_engine::reference_frame::InferenceMode;
 use tree::{CreateTreeOutcome, create_tree};
 
-mod index;
+pub(crate) mod index;
 /// Utility types
 pub mod reference_frame;
 mod refs;

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

@@ -263,6 +263,7 @@ fn apply_worktree_changes<'repo>(
                 entry.object()?.detach().data
             } else if entry.mode().is_blob() {
                 let mut obj_in_git = entry.object()?;
+
                 match pipeline.convert_to_worktree(
                     &obj_in_git.data,
                     base_rela_path,