Changed file picker (#5645)

Co-authored-by: WJH <hou32hou@gmail.com>
Co-authored-by: Michael Davis <mcarsondavis@gmail.com>
Co-authored-by: Pascal Kuthe <pascalkuthe@pm.me>

helix-vcs/Cargo.toml

@@ -19,7 +19,7 @@ tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "p
 parking_lot = "0.12"
 arc-swap = { version = "1.7.1" }
 
-gix = { version = "0.61.0", features = ["attributes"], default-features = false, optional = true }
+gix = { version = "0.61.0", features = ["attributes", "status"], default-features = false, optional = true }
 imara-diff = "0.1.5"
 anyhow = "1"
 

helix-vcs/src/git.rs

@@ -5,15 +5,24 @@ use std::io::Read;
 use std::path::Path;
 use std::sync::Arc;
 
+use gix::bstr::ByteSlice;
+use gix::diff::Rewrites;
+use gix::dir::entry::Status;
 use gix::objs::tree::EntryKind;
 use gix::sec::trust::DefaultForLevel;
+use gix::status::{
+    index_worktree::iter::Item,
+    plumbing::index_as_worktree::{Change, EntryStatus},
+    UntrackedFiles,
+};
 use gix::{Commit, ObjectId, Repository, ThreadSafeRepository};
 
-use crate::DiffProvider;
+use crate::{DiffProvider, FileChange};
 
 #[cfg(test)]
 mod test;
 
+#[derive(Clone, Copy)]
 pub struct Git;
 
 impl Git {
@@ -61,10 +70,77 @@ impl Git {
 
         Ok(res)
     }
+
+    /// Emulates the result of running `git status` from the command line.
+    fn status(repo: &Repository, f: impl Fn(Result<FileChange>) -> bool) -> Result<()> {
+        let work_dir = repo
+            .work_dir()
+            .ok_or_else(|| anyhow::anyhow!("working tree not found"))?
+            .to_path_buf();
+
+        let status_platform = repo
+            .status(gix::progress::Discard)?
+            // Here we discard the `status.showUntrackedFiles` config, as it makes little sense in
+            // our case to not list new (untracked) files. We could have respected this config
+            // if the default value weren't `Collapsed` though, as this default value would render
+            // the feature unusable to many.
+            .untracked_files(UntrackedFiles::Files)
+            // Turn on file rename detection, which is off by default.
+            .index_worktree_rewrites(Some(Rewrites {
+                copies: None,
+                percentage: Some(0.5),
+                limit: 1000,
+            }));
+
+        // No filtering based on path
+        let empty_patterns = vec![];
+
+        let status_iter = status_platform.into_index_worktree_iter(empty_patterns)?;
+
+        for item in status_iter {
+            let Ok(item) = item.map_err(|err| f(Err(err.into()))) else {
+                continue;
+            };
+            let change = match item {
+                Item::Modification {
+                    rela_path, status, ..
+                } => {
+                    let path = work_dir.join(rela_path.to_path()?);
+                    match status {
+                        EntryStatus::Conflict(_) => FileChange::Conflict { path },
+                        EntryStatus::Change(Change::Removed) => FileChange::Deleted { path },
+                        EntryStatus::Change(Change::Modification { .. }) => {
+                            FileChange::Modified { path }
+                        }
+                        _ => continue,
+                    }
+                }
+                Item::DirectoryContents { entry, .. } if entry.status == Status::Untracked => {
+                    FileChange::Untracked {
+                        path: work_dir.join(entry.rela_path.to_path()?),
+                    }
+                }
+                Item::Rewrite {
+                    source,
+                    dirwalk_entry,
+                    ..
+                } => FileChange::Renamed {
+                    from_path: work_dir.join(source.rela_path().to_path()?),
+                    to_path: work_dir.join(dirwalk_entry.rela_path.to_path()?),
+                },
+                _ => continue,
+            };
+            if !f(Ok(change)) {
+                break;
+            }
+        }
+
+        Ok(())
+    }
 }
 
-impl DiffProvider for Git {
-    fn get_diff_base(&self, file: &Path) -> Result<Vec<u8>> {
+impl Git {
+    pub fn get_diff_base(&self, file: &Path) -> Result<Vec<u8>> {
         debug_assert!(!file.exists() || file.is_file());
         debug_assert!(file.is_absolute());
 
@@ -95,7 +171,7 @@ impl DiffProvider for Git {
         }
     }
 
-    fn get_current_head_name(&self, file: &Path) -> Result<Arc<ArcSwap<Box<str>>>> {
+    pub fn get_current_head_name(&self, file: &Path) -> Result<Arc<ArcSwap<Box<str>>>> {
         debug_assert!(!file.exists() || file.is_file());
         debug_assert!(file.is_absolute());
         let repo_dir = file.parent().context("file has no parent directory")?;
@@ -112,6 +188,20 @@ impl DiffProvider for Git {
 
         Ok(Arc::new(ArcSwap::from_pointee(name.into_boxed_str())))
     }
+
+    pub fn for_each_changed_file(
+        &self,
+        cwd: &Path,
+        f: impl Fn(Result<FileChange>) -> bool,
+    ) -> Result<()> {
+        Self::status(&Self::open_repo(cwd, None)?.to_thread_local(), f)
+    }
+}
+
+impl From<Git> for DiffProvider {
+    fn from(value: Git) -> Self {
+        DiffProvider::Git(value)
+    }
 }
 
 /// Finds the object that contains the contents of a file at a specific commit.

helix-vcs/src/git/test.rs

@@ -2,7 +2,7 @@ use std::{fs::File, io::Write, path::Path, process::Command};
 
 use tempfile::TempDir;
 
-use crate::{DiffProvider, Git};
+use crate::Git;
 
 fn exec_git_cmd(args: &str, git_dir: &Path) {
     let res = Command::new("git")

helix-vcs/src/lib.rs

@@ -1,6 +1,9 @@
-use anyhow::{bail, Result};
+use anyhow::{anyhow, bail, Result};
 use arc_swap::ArcSwap;
-use std::{path::Path, sync::Arc};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 #[cfg(feature = "git")]
 pub use git::Git;
@@ -14,18 +17,14 @@ mod diff;
 
 pub use diff::{DiffHandle, Hunk};
 
-pub trait DiffProvider {
-    /// Returns the data that a diff should be computed against
-    /// if this provider is used.
-    /// The data is returned as raw byte without any decoding or encoding performed
-    /// to ensure all file encodings are handled correctly.
-    fn get_diff_base(&self, file: &Path) -> Result<Vec<u8>>;
-    fn get_current_head_name(&self, file: &Path) -> Result<Arc<ArcSwap<Box<str>>>>;
-}
+mod status;
+
+pub use status::FileChange;
 
 #[doc(hidden)]
+#[derive(Clone, Copy)]
 pub struct Dummy;
-impl DiffProvider for Dummy {
+impl Dummy {
     fn get_diff_base(&self, _file: &Path) -> Result<Vec<u8>> {
         bail!("helix was compiled without git support")
     }
@@ -33,10 +32,25 @@ impl DiffProvider for Dummy {
     fn get_current_head_name(&self, _file: &Path) -> Result<Arc<ArcSwap<Box<str>>>> {
         bail!("helix was compiled without git support")
     }
+
+    fn for_each_changed_file(
+        &self,
+        _cwd: &Path,
+        _f: impl Fn(Result<FileChange>) -> bool,
+    ) -> Result<()> {
+        bail!("helix was compiled without git support")
+    }
 }
 
+impl From<Dummy> for DiffProvider {
+    fn from(value: Dummy) -> Self {
+        DiffProvider::Dummy(value)
+    }
+}
+
+#[derive(Clone)]
 pub struct DiffProviderRegistry {
-    providers: Vec<Box<dyn DiffProvider>>,
+    providers: Vec<DiffProvider>,
 }
 
 impl DiffProviderRegistry {
@@ -65,14 +79,71 @@ impl DiffProviderRegistry {
                 }
             })
     }
+
+    /// Fire-and-forget changed file iteration. Runs everything in a background task. Keeps
+    /// iteration until `on_change` returns `false`.
+    pub fn for_each_changed_file(
+        self,
+        cwd: PathBuf,
+        f: impl Fn(Result<FileChange>) -> bool + Send + 'static,
+    ) {
+        tokio::task::spawn_blocking(move || {
+            if self
+                .providers
+                .iter()
+                .find_map(|provider| provider.for_each_changed_file(&cwd, &f).ok())
+                .is_none()
+            {
+                f(Err(anyhow!("no diff provider returns success")));
+            }
+        });
+    }
 }
 
 impl Default for DiffProviderRegistry {
     fn default() -> Self {
         // currently only git is supported
         // TODO make this configurable when more providers are added
-        let git: Box<dyn DiffProvider> = Box::new(Git);
-        let providers = vec![git];
+        let providers = vec![Git.into()];
         DiffProviderRegistry { providers }
     }
 }
+
+/// A union type that includes all types that implement [DiffProvider]. We need this type to allow
+/// cloning [DiffProviderRegistry] as `Clone` cannot be used in trait objects.
+#[derive(Clone)]
+pub enum DiffProvider {
+    Dummy(Dummy),
+    #[cfg(feature = "git")]
+    Git(Git),
+}
+
+impl DiffProvider {
+    fn get_diff_base(&self, file: &Path) -> Result<Vec<u8>> {
+        match self {
+            Self::Dummy(inner) => inner.get_diff_base(file),
+            #[cfg(feature = "git")]
+            Self::Git(inner) => inner.get_diff_base(file),
+        }
+    }
+
+    fn get_current_head_name(&self, file: &Path) -> Result<Arc<ArcSwap<Box<str>>>> {
+        match self {
+            Self::Dummy(inner) => inner.get_current_head_name(file),
+            #[cfg(feature = "git")]
+            Self::Git(inner) => inner.get_current_head_name(file),
+        }
+    }
+
+    fn for_each_changed_file(
+        &self,
+        cwd: &Path,
+        f: impl Fn(Result<FileChange>) -> bool,
+    ) -> Result<()> {
+        match self {
+            Self::Dummy(inner) => inner.for_each_changed_file(cwd, f),
+            #[cfg(feature = "git")]
+            Self::Git(inner) => inner.for_each_changed_file(cwd, f),
+        }
+    }
+}

helix-vcs/src/status.rs

@@ -0,0 +1,32 @@
+use std::path::{Path, PathBuf};
+
+pub enum FileChange {
+    Untracked {
+        path: PathBuf,
+    },
+    Modified {
+        path: PathBuf,
+    },
+    Conflict {
+        path: PathBuf,
+    },
+    Deleted {
+        path: PathBuf,
+    },
+    Renamed {
+        from_path: PathBuf,
+        to_path: PathBuf,
+    },
+}
+
+impl FileChange {
+    pub fn path(&self) -> &Path {
+        match self {
+            Self::Untracked { path } => path,
+            Self::Modified { path } => path,
+            Self::Conflict { path } => path,
+            Self::Deleted { path } => path,
+            Self::Renamed { to_path, .. } => to_path,
+        }
+    }
+}