Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

fix(search): search hidden and git-ignored files outside ignored folders (#1318)

Jawc2dd4663052f
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index c0ed65146..59860e912 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -844,7 +844,8 @@ impl Project {
/// Project files of `q.languages` under `q.root` containing `q.word` as a whole
/// word (unsaved buffers included; excluded roots, ignored names and
- /// `.gitignore`d files skipped): the files a references search opens on its server.
+ /// `.gitignore`d folders skipped, while `.gitignore`d files elsewhere count, as
+ /// in IDEA's project scope): the files a references search opens on its server.
pub fn reference_candidates(
&self,
q: &ide_lsp::CandidateQuery,
diff --git a/crates/ide-search/src/engine.rs b/crates/ide-search/src/engine.rs
index ccb3e356a..638c1016f 100644
--- a/crates/ide-search/src/engine.rs
+++ b/crates/ide-search/src/engine.rs
@@ -142,42 +142,16 @@ pub(crate) fn run(req: Request<'_>) -> IdeResult<SearchSummary> {
}
}
- if let Some((first, rest)) = on_disk.split_first()
- && !ctx.ctl.should_stop()
- {
- let mut walk = WalkBuilder::new(first);
- for path in rest {
- walk.add(path);
- }
- walk.hidden(true)
- .ignore(true)
- .git_ignore(true)
- .git_global(true)
- .git_exclude(true)
- .parents(true)
- .require_git(ide_core::ignored::inside_git_repo(first))
- .follow_links(false)
- .threads(std::thread::available_parallelism().map_or(4, |n| n.get()).min(12))
- .filter_entry(|e| e.file_name() != ".git");
- walk.build_parallel().run(|| {
+ if !ctx.ctl.should_stop() {
+ walk_files(&on_disk, || {
let mut searcher = searcher_builder.build();
let matcher = matcher.clone();
let ctx = &ctx;
- Box::new(move |entry| {
+ Box::new(move |path| {
if ctx.ctl.should_stop() {
return WalkState::Quit;
}
- let entry = match entry {
- Ok(entry) => entry,
- Err(err) => {
- tracing::debug!("search walk: {err}");
- return WalkState::Continue;
- }
- };
- // Archives (jar, zip) are browsed, not searched (IDEA skips them too).
- if entry.file_type().is_some_and(|t| t.is_file()) && !ide_vfs::is_archive_file(entry.path()) {
- ctx.search_file(entry.path(), &matcher, &mut searcher);
- }
+ ctx.search_file(path, &matcher, &mut searcher);
if ctx.ctl.stopped() { WalkState::Quit } else { WalkState::Continue }
})
});
@@ -193,6 +167,67 @@ pub(crate) fn run(req: Request<'_>) -> IdeResult<SearchSummary> {
})
}
+/// A per-thread file visitor of [`walk_files`].
+pub(crate) type VisitFile<'s> = Box<dyn FnMut(&Path) -> WalkState + Send + 's>;
+
+/// Visits the files below `roots` (and the roots that are files) in parallel,
+/// the way IDEA's project scope sees them: directories ignored by
+/// `.gitignore` / `.ignore` / `info/exclude` are skipped with everything in
+/// them, while ignored files elsewhere (`.env`) and hidden files and folders
+/// (`.github`, `.eslintrc`) are visited. `.git`, symlinks and archives (jar,
+/// zip: browsed, not searched) are never visited.
+pub(crate) fn walk_files<'s>(roots: &[PathBuf], mut visitor: impl FnMut() -> VisitFile<'s> + Send) {
+ let Some((first, rest)) = roots.split_first() else { return };
+ let mut walk = WalkBuilder::new(first);
+ for path in rest {
+ walk.add(path);
+ }
+ walk.hidden(false)
+ .ignore(true)
+ .git_ignore(true)
+ .git_global(true)
+ .git_exclude(true)
+ .parents(true)
+ .require_git(ide_core::ignored::inside_git_repo(first))
+ .follow_links(false)
+ .threads(std::thread::available_parallelism().map_or(4, |n| n.get()).min(12))
+ .filter_entry(|e| e.file_name() != ".git");
+ walk.build_parallel().run(|| {
+ let mut visit = visitor();
+ Box::new(move |entry| {
+ let entry = match entry {
+ Ok(entry) => entry,
+ Err(err) => {
+ tracing::debug!("search walk: {err}");
+ return WalkState::Continue;
+ }
+ };
+ let Some(file_type) = entry.file_type() else { return WalkState::Continue };
+ if file_type.is_dir() {
+ // The walker drops ignored files unseen, so the files of every walked
+ // directory come from listing it; the walker only picks the directories.
+ let Ok(children) = std::fs::read_dir(entry.path()) else { return WalkState::Continue };
+ for child in children.flatten() {
+ let path = child.path();
+ if child.file_name() != ".git"
+ && child.file_type().is_ok_and(|t| t.is_file())
+ && !ide_vfs::is_archive_file(&path)
+ && matches!(visit(&path), WalkState::Quit)
+ {
+ return WalkState::Quit;
+ }
+ }
+ WalkState::Continue
+ } else if file_type.is_file() && entry.depth() == 0 && !ide_vfs::is_archive_file(entry.path()) {
+ // A root that is a file (an explicit file list); files below roots come from listings.
+ visit(entry.path())
+ } else {
+ WalkState::Continue
+ }
+ })
+ });
+}
+
/// Walk roots for a scope; relative paths are resolved against `root`.
pub(crate) fn roots(root: &Path, scope: &SearchScope) -> IdeResult<Vec<PathBuf>> {
let dir = |path: &Path| -> IdeResult<PathBuf> {
diff --git a/crates/ide-search/src/files.rs b/crates/ide-search/src/files.rs
index bada88309..97b3805d3 100644
--- a/crates/ide-search/src/files.rs
+++ b/crates/ide-search/src/files.rs
@@ -1,10 +1,10 @@
//! The files of a search scope, for analyses that read whole files
//! (Inspect Code, Locate Duplicates, Structural Search).
-use crate::engine::{rel_path, roots};
+use crate::engine::{rel_path, roots, walk_files};
use crate::{FileMask, PathFilter, SearchScope};
use ide_core::{CancellationToken, IdeResult};
-use ignore::{WalkBuilder, WalkState};
+use ignore::WalkState;
use std::path::PathBuf;
use std::sync::Mutex;
@@ -16,7 +16,7 @@ pub struct ScopeFile {
}
/// Lists the files of `scope` under `root` the way Find in Files walks them
-/// (`.gitignore` honoured, hidden files and `.git` skipped), filtered by
+/// (ignored folders and `.git` skipped; ignored and hidden files kept), filtered by
/// `mask` and `filter`, sorted by relative path. Explicitly listed files are
/// kept even when they do not exist on disk (unsaved buffers). Returns what was
/// found so far when cancelled.
@@ -43,42 +43,23 @@ pub fn scope_files(
on_disk.push(path);
}
}
- if let Some((first, rest)) = on_disk.split_first() {
- let mut walk = WalkBuilder::new(first);
- for path in rest {
- walk.add(path);
- }
- walk.hidden(true)
- .ignore(true)
- .git_ignore(true)
- .git_global(true)
- .git_exclude(true)
- .parents(true)
- .require_git(ide_core::ignored::inside_git_repo(first))
- .follow_links(false)
- .threads(std::thread::available_parallelism().map_or(4, |n| n.get()).min(12))
- .filter_entry(|e| e.file_name() != ".git");
- walk.build_parallel().run(|| {
- let found = &found;
- let keep = &keep;
- Box::new(move |entry| {
- if cancel.is_cancelled() {
- return WalkState::Quit;
- }
- let Ok(entry) = entry else { return WalkState::Continue };
- if entry.file_type().is_some_and(|t| t.is_file()) && !ide_vfs::is_archive_file(entry.path()) {
- let rel = rel_path(root, entry.path());
- if keep(&rel) {
- found
- .lock()
- .unwrap_or_else(|e| e.into_inner())
- .push(ScopeFile { path: entry.into_path(), rel_path: rel });
- }
- }
- WalkState::Continue
- })
- });
- }
+ walk_files(&on_disk, || {
+ let found = &found;
+ let keep = &keep;
+ Box::new(move |path| {
+ if cancel.is_cancelled() {
+ return WalkState::Quit;
+ }
+ let rel = rel_path(root, path);
+ if keep(&rel) {
+ found
+ .lock()
+ .unwrap_or_else(|e| e.into_inner())
+ .push(ScopeFile { path: path.to_path_buf(), rel_path: rel });
+ }
+ WalkState::Continue
+ })
+ });
let mut files = found.into_inner().unwrap_or_else(|e| e.into_inner());
files.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
files.dedup_by(|a, b| a.path == b.path);
@@ -107,12 +88,12 @@ mod tests {
}
#[test]
- fn project_scope_honours_gitignore_and_masks() {
+ fn project_scope_skips_ignored_folders_and_honours_masks() {
let dir = tree();
let none = FileMask::new(&[], &[]).unwrap();
let cancel = CancellationToken::new();
let all = scope_files(dir.path(), &SearchScope::Project, &none, None, &cancel).unwrap();
- assert_eq!(rels(&all), vec!["src/a.rs", "src/c.txt", "src/sub/b.rs"]);
+ assert_eq!(rels(&all), vec![".gitignore", "src/a.rs", "src/c.txt", "src/sub/b.rs"]);
let rs = FileMask::new(&["*.rs".into()], &[]).unwrap();
let only_rs = scope_files(dir.path(), &SearchScope::Project, &rs, None, &cancel).unwrap();
@@ -120,7 +101,7 @@ mod tests {
let not_sub: PathFilter<'_> = &|rel: &str| !rel.starts_with("src/sub/");
let filtered = scope_files(dir.path(), &SearchScope::Project, &none, Some(not_sub), &cancel).unwrap();
- assert_eq!(rels(&filtered), vec!["src/a.rs", "src/c.txt"]);
+ assert_eq!(rels(&filtered), vec![".gitignore", "src/a.rs", "src/c.txt"]);
}
#[test]
diff --git a/crates/ide-search/src/lib.rs b/crates/ide-search/src/lib.rs
index 975155105..eb220fbb3 100644
--- a/crates/ide-search/src/lib.rs
+++ b/crates/ide-search/src/lib.rs
@@ -1,7 +1,8 @@
//! Find / Replace in Files (⌘⇧F / ⌘⇧R).
//!
-//! Built on ripgrep's engine crates: a parallel `ignore` walk (honouring
-//! `.gitignore` / `.ignore`, skipping hidden files and `.git`) feeding
+//! Built on ripgrep's engine crates: a parallel `ignore` walk (skipping the
+//! folders `.gitignore` / `.ignore` exclude and `.git`, but like IDEA keeping
+//! ignored files elsewhere and hidden files) feeding
//! `grep-searcher` with a `grep-regex` matcher. Binary files are skipped,
//! unsaved editor buffers (the overlay) take precedence over disk content,
//! and all columns are UTF-16.
diff --git a/crates/ide-search/src/words.rs b/crates/ide-search/src/words.rs
index ceb94a255..722ebe638 100644
--- a/crates/ide-search/src/words.rs
+++ b/crates/ide-search/src/words.rs
@@ -25,8 +25,8 @@ pub struct WordFiles {
}
/// Files under `query.dir` containing `query.word` as a whole word, in walk
-/// order (unsaved buffers through `overlay`, `.gitignore`d and hidden files
-/// skipped like Find in Files). Stops at `query.limit` files or when cancelled.
+/// order (unsaved buffers through `overlay`; ignored folders skipped, ignored
+/// and hidden files searched, like Find in Files). Stops at `query.limit` files or when cancelled.
pub fn files_with_word(
root: &std::path::Path,
query: &WordQuery,
@@ -74,7 +74,9 @@ mod tests {
let root = dir.path();
fs::create_dir_all(root.join("pkg/ignored")).unwrap();
fs::create_dir_all(root.join("build")).unwrap();
- fs::write(root.join(".gitignore"), "ignored/\n").unwrap();
+ fs::write(root.join(".gitignore"), "ignored/\nlocal.py\n").unwrap();
+ // An ignored file outside ignored folders is still a candidate, as in IDEA.
+ fs::write(root.join("pkg/local.py"), "get_value\n").unwrap();
fs::write(root.join("pkg/use.py"), "x.get_value(1)\n").unwrap();
fs::write(root.join("pkg/longer.py"), "get_values()\n").unwrap();
fs::write(root.join("pkg/case.py"), "Get_Value()\n").unwrap();
@@ -90,7 +92,10 @@ mod tests {
found.files.sort();
assert_eq!(
found,
- WordFiles { files: vec![root.join("pkg/open.py"), root.join("pkg/use.py")], limit_hit: false }
+ WordFiles {
+ files: vec![root.join("pkg/local.py"), root.join("pkg/open.py"), root.join("pkg/use.py")],
+ limit_hit: false
+ }
);
}
diff --git a/crates/ide-search/tests/search.rs b/crates/ide-search/tests/search.rs
index b63c97220..f4207d054 100644
--- a/crates/ide-search/tests/search.rs
+++ b/crates/ide-search/tests/search.rs
@@ -187,24 +187,59 @@ fn file_masks() {
assert_eq!(with(&[], &["*.kt,*.ts"]), ["notes.md", "src/Util.java"]);
}
-#[test]
-fn honours_ignore_files_hidden_and_git() {
- let p = project(&[
- (".gitignore", b"target/\n*.log\n"),
- (".ignore", b"generated.rs\n"),
- ("src/a.rs", b"needle\n"),
- ("src/generated.rs", b"needle\n"),
- ("target/debug/out.rs", b"needle\n"),
- ("build.log", b"needle\n"),
- (".hidden/secret.rs", b"needle\n"),
- (".env", b"needle\n"),
- (".git/config", b"needle\n"),
- ("sub/.gitignore", b"local.txt\n"),
- ("sub/local.txt", b"needle\n"),
- ("sub/kept.txt", b"needle\n"),
- ]);
+/// The files of `scope` under `root` (relative), sorted.
+fn scope_rels(root: &Path, scope: &SearchScope) -> Vec<String> {
+ let none = ide_search::FileMask::new(&[], &[]).unwrap();
+ let files = ide_search::scope_files(root, scope, &none, None, &CancellationToken::new()).unwrap();
+ let mut rels: Vec<_> = files.into_iter().map(|f| f.rel_path).collect();
+ rels.sort();
+ rels
+}
+
+#[test]
+fn searches_ignored_and_hidden_files_but_not_ignored_folders() {
+ // #1317: like IDEA, only ignored folders are left out; ignored files and dotfiles are searched.
+ // (path, content, walked): every file mentions `needle`.
+ let files: &[(&str, &[u8], bool)] = &[
+ (".gitignore", b"# needle\ntarget/\n*.log\n.env\nsrc/local/\n", true),
+ (".ignore", b"# needle\ngenerated.rs\nout/\n", true),
+ ("src/a.rs", b"needle\n", true),
+ // Ignored files outside ignored folders.
+ ("src/generated.rs", b"needle\n", true),
+ ("build.log", b"needle\n", true),
+ (".env", b"needle\n", true),
+ ("sub/.gitignore", b"# needle\nlocal.txt\ncache/\n", true),
+ ("sub/local.txt", b"needle\n", true),
+ ("sub/kept.txt", b"needle\n", true),
+ // Hidden files and folders.
+ (".eslintrc", b"needle\n", true),
+ (".github/workflows/ci.yml", b"needle\n", true),
+ (".hidden/secret.rs", b"needle\n", true),
+ // Ignored folders, whatever they hold.
+ ("target/debug/out.rs", b"needle\n", false),
+ ("target/.env", b"needle\n", false),
+ ("src/local/notes.txt", b"needle\n", false),
+ ("out/gen.rs", b"needle\n", false),
+ ("sub/cache/blob.txt", b"needle\n", false),
+ // Never: Git's own folder.
+ (".git/config", b"needle\n", false),
+ ];
+ let p = project(&files.iter().map(|(path, text, _)| (*path, *text)).collect::<Vec<_>>());
+ let mut expected: Vec<&str> = files.iter().filter(|(_, _, walked)| *walked).map(|(path, _, _)| *path).collect();
+ expected.sort();
+
let (views, _) = run(p.path(), &query("needle"));
- assert_eq!(paths(&views), ["src/a.rs", "sub/kept.txt"]);
+ assert_eq!(paths(&views), expected, "Find in Files");
+
+ assert_eq!(scope_rels(p.path(), &SearchScope::Project), expected, "scope files");
+
+ // A directory scope and an explicit ignored file are searched the same way.
+ let dir = SearchScope::Directory { path: ide_core::IpcPath(p.path().join("sub")) };
+ let (views, _) = run(p.path(), &SearchQuery { scope: dir, ..query("needle") });
+ assert_eq!(paths(&views), ["sub/.gitignore", "sub/kept.txt", "sub/local.txt"]);
+ let one = SearchScope::Files { paths: vec![ide_core::IpcPath(p.path().join("build.log"))] };
+ let (views, _) = run(p.path(), &SearchQuery { scope: one, ..query("needle") });
+ assert_eq!(paths(&views), ["build.log"]);
}
#[test]
@@ -214,25 +249,15 @@ fn nested_repository_ignores_outer_repository_rules() {
(".git/HEAD", b"ref: refs/heads/main\n"),
("projects/.gitignore", b"*\n!.gitignore\n"),
("projects/nested/.git/HEAD", b"ref: refs/heads/main\n"),
- ("projects/nested/.gitignore", b"*.log\n"),
+ ("projects/nested/.gitignore", b"logs/\n"),
("projects/nested/search-test.txt", b"somesss\n"),
- ("projects/nested/debug.log", b"somesss\n"),
+ ("projects/nested/src/main.txt", b"somesss\n"),
+ ("projects/nested/logs/debug.txt", b"somesss\n"),
]);
let nested = p.path().join("projects/nested");
let (views, _) = run(&nested, &query("somesss"));
- assert_eq!(paths(&views), ["search-test.txt"]);
-
- let files = ide_search::scope_files(
- &nested,
- &SearchScope::Project,
- &ide_search::FileMask::new(&[], &[]).unwrap(),
- None,
- &CancellationToken::new(),
- )
- .unwrap();
- let mut rels: Vec<_> = files.iter().map(|f| f.rel_path.as_str()).collect();
- rels.sort();
- assert_eq!(rels, ["search-test.txt"]);
+ assert_eq!(paths(&views), ["search-test.txt", "src/main.txt"]);
+ assert_eq!(scope_rels(&nested, &SearchScope::Project), [".gitignore", "search-test.txt", "src/main.txt"]);
}
#[test]
@@ -678,13 +703,18 @@ fn a_nested_repository_is_not_hidden_by_the_outer_repositorys_gitignore() {
let p = project(&[
("projects/.gitignore", b"*\n!.gitignore\n"),
("projects/nested/search-test.txt", b"somesss\n"),
- ("projects/nested/.gitignore", b"*.log\n"),
- ("projects/nested/debug.log", b"somesss\n"),
+ ("projects/nested/src/main.txt", b"somesss\n"),
+ ("projects/nested/.gitignore", b"logs/\n"),
+ ("projects/nested/logs/debug.txt", b"somesss\n"),
]);
std::fs::create_dir(p.path().join(".git")).unwrap();
std::fs::create_dir(p.path().join("projects/nested/.git")).unwrap();
let (views, _) = run(&p.path().join("projects/nested"), &query("somesss"));
- assert_eq!(paths(&views), ["search-test.txt"], "the nested repository's own .gitignore still applies");
+ assert_eq!(
+ paths(&views),
+ ["search-test.txt", "src/main.txt"],
+ "the nested repository's own .gitignore still applies"
+ );
}
#[test]