Add V3 support for discarding files

For now, no hunks or hunk-ranges.

Author: Byron

crates/but-testsupport/src/lib.rs

@@ -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,46 @@ 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.
+/// As it's intended for tests, this can't be called on Windows were modes don't exist.
+#[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-workspace/src/commit_engine/index.rs

@@ -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/mod.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/tree.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,

crates/but-workspace/src/discard/function.rs

@@ -0,0 +1,261 @@
+use crate::discard::DiscardSpec;
+use anyhow::{Context, bail};
+use bstr::{BStr, ByteSlice};
+use but_core::{ChangeState, TreeStatus};
+use gix::filter::plumbing::driver::apply::Delay;
+use gix::object::tree::EntryKind;
+use gix::prelude::ObjectIdExt;
+use std::ops::Deref;
+use std::path::Path;
+
+/// Discard the given `changes` in the worktree of `repo`. If a change could not be matched with an actual worktree change, for
+/// instance due to a race, that's not an error, instead it will be returned in the result Vec.
+/// The returned Vec is typically empty, meaning that all `changes` could be discarded.
+///
+/// Discarding a change is really more of an 'undo' of a change as it will restore the previous state to the desired extent - Git
+/// doesn't have a notion of this.
+///
+/// Each of the `changes` will be matched against actual worktree changes to make this operation as safe as possible, after all, it
+/// discards changes without recovery.
+///
+/// In practice, this is like a selective 'inverse-checkout', as such it must have a lot of the capabilities of checkout, but focussed
+/// on just a couple of paths, and with special handling for renamed files, something that `checkout` can't naturally handle
+/// as it's only dealing with single file-paths.
+pub fn discard_workspace_changes(
+    repo: &gix::Repository,
+    changes: impl IntoIterator<Item = DiscardSpec>,
+) -> anyhow::Result<Vec<DiscardSpec>> {
+    let wt_changes = but_core::diff::worktree_changes(repo)?;
+    let mut dropped = Vec::new();
+    // Have to go from shared state to mutable one, needs clone, unfortunately.
+    let mut index = repo.index_or_empty()?.deref().clone();
+    let initial_entries_len = index.entries().len();
+    let (mut pipeline, _) = repo.filter_pipeline(Some(repo.empty_tree().id))?;
+
+    let mut path_check = gix::status::plumbing::SymlinkCheck::new(
+        repo.workdir().context("non-bare repository")?.into(),
+    );
+    for spec in changes {
+        let Some(wt_change) = wt_changes.changes.iter().find(|c| {
+            c.path == spec.path
+                && c.previous_path() == spec.previous_path.as_ref().map(|p| p.as_bstr())
+        }) else {
+            dropped.push(spec);
+            continue;
+        };
+
+        if spec.hunk_headers.is_empty() {
+            match wt_change.status {
+                TreeStatus::Addition { is_untracked, .. } => {
+                    std::fs::remove_file(
+                        path_check
+                            .verified_path(&gix::path::from_bstr(wt_change.path.as_bstr()))?,
+                    )?;
+                    if !is_untracked {
+                        index::mark_entry_for_deletion(&mut index, wt_change.path.as_bstr());
+                    }
+                }
+                TreeStatus::Deletion { previous_state } => {
+                    restore_state_to_worktree(
+                        &mut pipeline,
+                        &mut index,
+                        wt_change.path.as_bstr(),
+                        previous_state,
+                        RestoreMode::Deleted,
+                        &mut path_check,
+                    )?;
+                }
+                TreeStatus::Modification { .. } => {}
+                TreeStatus::Rename { .. } => {}
+            }
+        } else {
+            todo!("hunk-based undo")
+        }
+    }
+
+    let has_removals_or_updates = index.entries().iter().any(|e| {
+        e.flags
+            .intersects(gix::index::entry::Flags::REMOVE | gix::index::entry::Flags::UPDATE)
+    });
+    if has_removals_or_updates {
+        index.remove_tree();
+        index.remove_resolve_undo();
+        // This works because we delete entries by marking them, so only additions change the count.
+        if initial_entries_len != index.entries().len() {
+            index.sort_entries();
+        }
+        index.write(Default::default())?;
+    }
+    Ok(dropped)
+}
+
+enum RestoreMode {
+    /// Assume the resource to be restored doesn't exist as it was deleted.
+    Deleted,
+    /// A similar resource is in its place that needs to be updated.
+    Update,
+}
+
+/// Restore `state` by writing it into the worktree of `repo`, possibly re-adding or updating the
+/// `index` with it so that it matches the worktree.
+fn restore_state_to_worktree(
+    pipeline: &mut gix::filter::Pipeline<'_>,
+    index: &mut gix::index::State,
+    rela_path: &BStr,
+    state: ChangeState,
+    mode: RestoreMode,
+    path_check: &mut gix::status::plumbing::SymlinkCheck,
+) -> anyhow::Result<()> {
+    if state.id.is_null() {
+        bail!(
+            "Change to discard at '{rela_path}' didn't have a last-known tracked state - this is a bug"
+        );
+    }
+
+    let mut update_index = |md| -> anyhow::Result<()> {
+        let mut num_sorted_entries = index.entries().len();
+        let newly_added = crate::commit_engine::index::upsert_index_entry(
+            index,
+            rela_path,
+            &md,
+            state.id,
+            state.kind.into(),
+            gix::index::entry::Flags::UPDATE,
+            &mut num_sorted_entries,
+        )?;
+        assert_eq!(
+            num_sorted_entries,
+            index.entries().len() - usize::from(newly_added),
+            "BUG: cannot currently discard conflicts - there is no notion of it"
+        );
+        Ok(())
+    };
+
+    let repo = pipeline.repo;
+    let file_path = path_check.verified_path(&gix::path::from_bstr(rela_path))?;
+    match state.kind {
+        EntryKind::Blob | EntryKind::BlobExecutable => {
+            let mut dest_lock_file = locked_resource_at(file_path, state.kind)?;
+            let obj_in_git = state.id.attach(repo).object()?;
+            let mut stream =
+                pipeline.convert_to_worktree(&obj_in_git.data, rela_path, Delay::Forbid)?;
+            std::io::copy(&mut stream, &mut dest_lock_file)?;
+
+            let (file_path, maybe_file) = dest_lock_file.commit()?;
+            update_index(match maybe_file {
+                None => gix::index::fs::Metadata::from_path_no_follow(&file_path)?,
+                Some(file) => gix::index::fs::Metadata::from_file(&file)?,
+            })?;
+        }
+        EntryKind::Link => {
+            let link_path = file_path;
+            if let RestoreMode::Update = mode {
+                std::fs::remove_file(link_path)?;
+            }
+            let link_target = state.id.attach(repo).object()?;
+            let link_target = gix::path::from_bstr(link_target.data.as_bstr());
+            gix::fs::symlink::create(&link_target, link_path)?;
+            update_index(gix::index::fs::Metadata::from_path_no_follow(link_path)?)?;
+        }
+        EntryKind::Commit => {
+            if let RestoreMode::Update = mode {
+                todo!("checkout the desired revision")
+            } else {
+                let sm = repo.submodules()?.into_iter().flatten().find_map(|sm| {
+                    let is_active = sm.is_active().ok()?;
+                    is_active
+                        .then(|| {
+                            if sm.path().ok().is_some_and(|sm_path| sm_path == rela_path) {
+                                sm.url().ok()
+                            } else {
+                                None
+                            }
+                        })
+                        .flatten()
+                });
+                match sm {
+                    None => {
+                        // A directory is what git creates with `git restore` even if the thing to restore is a submodule.
+                        // We are trying to be better than that if we find a submodule, hoping that this is what users expect.
+                        // We do that as baseline as there is no need to fail here.
+                    }
+                    Some(url) => {
+                        // Must use `git` directly as `gix` isn't 100% compatible, nor is `git2`.
+                        // TODO(compat): use `gix` once it can clone Azure repos, and otherwise also is 99% compatible,
+                        //               for better performance.
+                        let output = std::process::Command::new(gix::path::env::exe_invocation())
+                            .current_dir(repo.workdir().context("non-bare repository")?)
+                            .arg("clone")
+                            .arg(gix::path::from_bstring(url.to_bstring()))
+                            .arg(file_path)
+                            .output();
+                        match output {
+                            Ok(out) => {
+                                if !out.status.success() {
+                                    tracing::warn!(
+                                        "Failed to clone repository from {url} to {}: {}",
+                                        file_path.display(),
+                                        out.stderr.as_bstr()
+                                    )
+                                }
+                            }
+                            Err(err) => {
+                                tracing::warn!("Could not clone submodule into place: {err}");
+                            }
+                        }
+                    }
+                }
+                std::fs::create_dir(file_path).or_else(|err| {
+                    if err.kind() == std::io::ErrorKind::AlreadyExists {
+                        Ok(())
+                    } else {
+                        Err(err)
+                    }
+                })?;
+            }
+            update_index(gix::index::fs::Metadata::from_path_no_follow(file_path)?)?;
+        }
+        EntryKind::Tree => {
+            unreachable!("BUG: should not attempt to create a tree")
+        }
+    };
+    Ok(())
+}
+
+mod index {
+    use bstr::BStr;
+    use gix::index::entry::Stage;
+
+    pub fn mark_entry_for_deletion(state: &mut gix::index::State, rela_path: &BStr) {
+        for stage in [Stage::Unconflicted, Stage::Base, Stage::Ours, Stage::Theirs] {
+            // TODO(perf): `gix` should offer a way to get the *first* index by path so the
+            //             binary search doesn't have to be repeated.
+            let Some(entry) = state.entry_mut_by_path_and_stage(rela_path, stage) else {
+                continue;
+            };
+            entry.flags.insert(gix::index::entry::Flags::REMOVE);
+        }
+    }
+}
+
+#[cfg(unix)]
+fn locked_resource_at(path: &Path, kind: EntryKind) -> anyhow::Result<gix::lock::File> {
+    use std::os::unix::fs::PermissionsExt;
+    Ok(
+        gix::lock::File::acquire_to_update_resource_with_permissions(
+            path,
+            gix::lock::acquire::Fail::Immediately,
+            None,
+            || std::fs::Permissions::from_mode(kind as u32),
+        )?,
+    )
+}
+
+#[cfg(windows)]
+fn locked_resource_at(path: &Path, _kind: EntryKind) -> anyhow::Result<gix::lock::File> {
+    Ok(gix::lock::File::acquire_to_update_resource(
+        path,
+        gix::lock::acquire::Fail::Immediately,
+        None,
+    )?)
+}