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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(index): let Go to File find git-ignored files such as .env (#1313)
Jaw9a9266f61bfd
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex e45d346a0..372cb97a6 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -305,12 +305,13 @@ impl Host {sink.clone(),Box::new(move |batch| {let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();- index.update(&changed, &batch.removed);+ let (ignored, ignored_gone) = ignored_changes(batch);+ index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));lsp.project_files_changed(batch.created.iter().chain(&batch.removed));lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed, &batch.excluded_dirs);// Atomic saves by external tools surface as `created`.- documents.on_disk_changed(&changed);+ documents.on_disk_changed(&[&changed[..], &ignored].concat());// A framework's root marker (`angular.json`) created or deleted: its// templates gain or lose their mode. Markers in `node_modules` only// count here when the folder isn't excluded (it is by default).@@ -961,6 +962,11 @@ const HISTORY_BATCH_LIMIT: usize = 500;/// Local History for changes made outside the IDE (other tools, VCS, deletions)./// Contents equal to the last snapshot (e.g. the IDE's own saves) are skipped.+/// The batch's ignored files (`.env`), split into those still on disk and those removed.+fn ignored_changes(batch: &ide_vfs::FsBatch) -> (Vec<PathBuf>, Vec<PathBuf>) {+ batch.ignored.iter().cloned().partition(|p| p.symlink_metadata().is_ok())+}+fn record_external_changes(history: &LocalHistory, changed: &[PathBuf], removed: &[PathBuf]) {for path in changed.iter().take(HISTORY_BATCH_LIMIT) {if let Err(e) = history.record_file(path, "External change", false) {@@ -1045,11 +1051,12 @@ fn content_root_watcher(sink.clone(),Box::new(move |batch| {let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();- index.update(&changed, &batch.removed);+ let (ignored, ignored_gone) = ignored_changes(batch);+ index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());if let Some(bridge) = &kotlin_bridge {bridge.files_changed(changed.iter().chain(&batch.removed));}- documents.on_disk_changed(&changed);+ documents.on_disk_changed(&[&changed[..], &ignored].concat());record_external_changes(&history, &changed, &batch.removed);}),)diff --git a/crates/ide-index/src/data.rs b/crates/ide-index/src/data.rsindex 57bb76e42..1bda8c243 100644--- a/crates/ide-index/src/data.rs+++ b/crates/ide-index/src/data.rs@@ -40,6 +40,8 @@ pub(crate) struct FileRecord {pub size: u64,pub hash: [u8; 32],pub symbols: Vec<StoredSymbol>,+ /// Matched by an ignore file: listed by name only (no hash, no symbols).+ pub ignored: bool,}#[derive(Clone, Debug, Serialize, Deserialize)]@@ -72,6 +74,7 @@ pub(crate) struct FileEntry {pub size: u64,pub hash: [u8; 32],pub symbols: Box<[Sym]>,+ pub ignored: bool,}impl FileEntry {@@ -100,6 +103,7 @@ impl FileEntry {size: record.size,hash: record.hash,symbols,+ ignored: record.ignored,}}@@ -126,8 +130,14 @@ impl FileEntry {range: s.range,}).collect(),+ ignored: self.ignored,}}++ /// Whether the entry is out of date for `found` on disk.+ pub(crate) fn stale_for(&self, found: &crate::filter::Found) -> bool {+ self.mtime != found.mtime || self.size != found.size || self.ignored != found.ignored+ }}#[derive(Default)]diff --git a/crates/ide-index/src/filter.rs b/crates/ide-index/src/filter.rsindex 0a612b31a..bae11d654 100644--- a/crates/ide-index/src/filter.rs+++ b/crates/ide-index/src/filter.rs@@ -1,10 +1,16 @@//! Which paths belong in the index: `.gitignore`/`.ignore` rules (via the//! `ignore` crate) plus the user's `files.exclude` globs, below the project root//! and the extra content roots (Project Structure).+//!+//! Like IDEA, ignored directories are left out entirely, while ignored files in+//! the remaining directories (`.env`) are listed by name only, so Go to File finds+//! them but their symbols stay out of the index.use globset::{GlobBuilder, GlobSet, GlobSetBuilder};use ignore::gitignore::{Gitignore, GitignoreBuilder};use ignore::{WalkBuilder, WalkState};+use std::collections::HashMap;+use std::collections::hash_map::Entry;use std::path::{Path, PathBuf};use std::sync::atomic::{AtomicBool, Ordering};use std::sync::mpsc;@@ -57,11 +63,25 @@ fn rel_string(rel: &Path) -> String {out}+/// Whether `path` below `root` matches the exclude globs.+fn glob_excluded(excludes: &GlobSet, root: &Path, path: &Path) -> bool {+ match path.strip_prefix(root) {+ Ok(rel) if !rel.as_os_str().is_empty() => {+ let rel = rel.to_string_lossy();+ let rel = if std::path::MAIN_SEPARATOR == '/' { rel } else { rel.replace('\\', "/").into() };+ excludes.is_match(rel.as_ref())+ }+ _ => false,+ }+}+#[derive(Clone, Debug)]pub(crate) struct Found {pub path: PathBuf,pub mtime: u64,pub size: u64,+ /// Matched by an ignore file: listed by name only.+ pub ignored: bool,}pub(crate) fn mtime_of(meta: &std::fs::Metadata) -> u64 {@@ -177,8 +197,9 @@ impl PathFilter {ALWAYS_SKIP.contains(&name)}- /// Whether a path reported by the watcher should be ignored (outside the- /// root, inside an excluded/ignored directory, or ignored itself).+ /// Whether a path reported by the watcher should be left out (outside the+ /// root, excluded, or an ignored directory or inside one). Ignored files+ /// elsewhere stay in, listed by name only.pub(crate) fn is_excluded(&self, path: &Path, is_dir: bool) -> bool {let Some((base, _, gitignore)) = self.base_of(path) else { return true };let rel = path.strip_prefix(base).map(rel_string).unwrap_or_default();@@ -198,16 +219,27 @@ impl PathFilter {return true;}}- gitignore.matched_path_or_any_parents(path, is_dir).is_ignore()+ let dir = if is_dir { Some(path) } else { path.parent().filter(|p| *p != base) };+ dir.is_some_and(|d| gitignore.matched_path_or_any_parents(d, true).is_ignore())}/// All indexable files at or below `dir`, walked in parallel./// Stops early (returning what was found so far) once `cancel` is set.pub(crate) fn walk(&self, dir: &Path, cancel: &AtomicBool) -> Vec<Found> {+ self.walk_to(dir, None, cancel)+ }++ /// The indexable files directly in `dir`, classified by the same rules as [`Self::walk`].+ pub(crate) fn list_dir(&self, dir: &Path) -> Vec<Found> {+ self.walk_to(dir, Some(1), &AtomicBool::new(false))+ }++ fn walk_to(&self, dir: &Path, max_depth: Option<usize>, cancel: &AtomicBool) -> Vec<Found> {let (tx, rx) = mpsc::channel::<Vec<Found>>();let Some((root, _, _)) = self.base_of(dir) else { return Vec::new() };let root = root.to_path_buf();let excludes = self.excludes.clone();+ let (walk_root, walk_excludes) = (root.clone(), excludes.clone());let walker = WalkBuilder::new(dir).hidden(false).parents(true)@@ -217,41 +249,63 @@ impl PathFilter {.git_exclude(true).require_git(ide_core::ignored::inside_git_repo(dir)).follow_links(false)+ .max_depth(max_depth).filter_entry(move |e| {let name = e.file_name().to_string_lossy();- if Self::skip_name(&name) {- return false;- }- match e.path().strip_prefix(&root) {- Ok(rel) if !rel.as_os_str().is_empty() => {- let rel = rel.to_string_lossy();- let rel = if std::path::MAIN_SEPARATOR == '/' { rel } else { rel.replace('\\', "/").into() };- !excludes.is_match(rel.as_ref())- }- _ => true,- }+ !Self::skip_name(&name) && !glob_excluded(&walk_excludes, &walk_root, e.path())}).build_parallel();walker.run(|| {+ let (root, excludes) = (&root, &excludes);let mut batch = Batch { tx: tx.clone(), items: Vec::with_capacity(256) };Box::new(move |entry| {if cancel.load(Ordering::Relaxed) {return WalkState::Quit;}let Ok(entry) = entry else { return WalkState::Continue };- if entry.file_type().is_some_and(|t| t.is_file())+ let Some(file_type) = entry.file_type() else { return WalkState::Continue };+ if file_type.is_dir() && max_depth.is_none_or(|max| entry.depth() < max) {+ // The walker drops ignored files unseen: list every file of a+ // walked directory; those the walker doesn't report are ignored.+ 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_type().is_ok_and(|t| t.is_file())+ && !Self::skip_name(&child.file_name().to_string_lossy())+ && !glob_excluded(excludes, root, &path)+ && let Ok(meta) = child.metadata()+ {+ batch.items.push(Found { path, mtime: mtime_of(&meta), size: meta.len(), ignored: true });+ }+ }+ } else if file_type.is_file()&& let Ok(meta) = entry.metadata(){- batch.items.push(Found { path: entry.into_path(), mtime: mtime_of(&meta), size: meta.len() });- if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {- return WalkState::Quit;- }+ batch.items.push(Found {+ path: entry.into_path(),+ mtime: mtime_of(&meta),+ size: meta.len(),+ ignored: false,+ });+ }+ if batch.items.len() >= 256 && batch.tx.send(std::mem::take(&mut batch.items)).is_err() {+ return WalkState::Quit;}WalkState::Continue})});drop(tx);- rx.into_iter().flatten().collect()+ // Each file comes once from its directory listing and, unless ignored, once from the walker.+ let mut by_path: HashMap<PathBuf, Found> = HashMap::new();+ for f in rx.into_iter().flatten() {+ match by_path.entry(f.path.clone()) {+ Entry::Occupied(mut e) => e.get_mut().ignored &= f.ignored,+ Entry::Vacant(e) => {+ e.insert(f);+ }+ }+ }+ by_path.into_values().collect()}}@@ -311,6 +365,84 @@ mod tests {assert!(!filter.is_excluded(&root.join("src/new.rs"), false));}+ #[test]+ fn ignored_files_are_listed_but_ignored_directories_are_not() {+ let dir = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(dir.path()).unwrap();+ for f in [+ ".env",+ "src/a.rs",+ "src/debug.log",+ "src/local/secrets.json",+ "pkg/.gitignore",+ "pkg/gen.rs",+ "pkg/keep.rs",+ "build/out.rs",+ "build/nested/deep.rs",+ "logs/app.log",+ "node_modules/x/.env",+ "src/.DS_Store",+ "src/.git",+ ] {+ touch(&root, f);+ }+ std::fs::write(+ root.join(".gitignore"),+ ".env+*.log+build/+logs/+src/local/+",+ )+ .unwrap();+ std::fs::write(+ root.join("pkg/.gitignore"),+ "gen.rs+",+ )+ .unwrap();+ let filter = PathFilter::new(&root, &vec![].into(), &["**/node_modules".into(), "**/.DS_Store".into()]);+ let mut found: Vec<(String, bool)> = filter+ .walk(&root, &AtomicBool::new(false))+ .iter()+ .filter_map(|f| Some((filter.rel(&f.path)?, f.ignored)))+ .collect();+ found.sort();+ let expected = [+ (".env", true),+ (".gitignore", false),+ ("pkg/.gitignore", false),+ ("pkg/gen.rs", true),+ ("pkg/keep.rs", false),+ ("src/a.rs", false),+ ("src/debug.log", true),+ ];+ assert_eq!(found, expected.map(|(p, i)| (p.to_owned(), i)));++ // One directory at a time (watcher updates): same classification, no descent.+ let mut listed: Vec<(String, bool)> =+ filter.list_dir(&root.join("pkg")).iter().filter_map(|f| Some((filter.rel(&f.path)?, f.ignored))).collect();+ listed.sort();+ let expected = [("pkg/.gitignore", false), ("pkg/gen.rs", true), ("pkg/keep.rs", false)];+ assert_eq!(listed, expected.map(|(p, i)| (p.to_owned(), i)));+ let top: Vec<String> = filter.list_dir(&root).iter().filter_map(|f| filter.rel(&f.path)).collect();+ assert!(top.iter().all(|p| !p.contains('/')), "{top:?}");++ for (rel, excluded) in [+ (".env", false),+ ("src/new.log", false),+ ("src/new.rs", false),+ ("build/x.rs", true),+ ("logs/app.log", true),+ ("src/local/x.json", true),+ ] {+ assert_eq!(filter.is_excluded(&root.join(rel), false), excluded, "{rel}");+ }+ assert!(filter.is_excluded(&root.join("build"), true));+ assert!(!filter.is_excluded(&root.join("src"), true));+ }+#[test]fn a_nested_repository_is_not_hidden_by_the_outer_repositorys_gitignore() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/ide-index/src/store.rs b/crates/ide-index/src/store.rsindex 7419c7092..f32dac55a 100644--- a/crates/ide-index/src/store.rs+++ b/crates/ide-index/src/store.rs@@ -8,7 +8,7 @@ use std::path::Path;const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");/// Bump when [`FileRecord`] or its encoding changes.-const SCHEMA: &str = "openidea-index-2";+const SCHEMA: &str = "openidea-index-3";type Result<T> = std::result::Result<T, String>;diff --git a/crates/ide-index/src/tests.rs b/crates/ide-index/src/tests.rsindex 667e9f505..ba610dc7f 100644--- a/crates/ide-index/src/tests.rs+++ b/crates/ide-index/src/tests.rs@@ -293,6 +293,56 @@ fn binary_and_huge_files_are_listed_without_symbols() {assert_eq!(idx.status().symbols, 0);}+#[test]+fn go_to_file_finds_ignored_files_but_not_their_symbols() {+ let fx = Fixture::new(&[+ (".gitignore", ".env\n*.local.ts\ndist/\n"),+ (".env", "SECRET=1\n"),+ ("src/app.ts", "export function app() {}\n"),+ ("src/config.local.ts", "export function localOnly() {}\n"),+ ("dist/bundle.js", "function bundled() {}\n"),+ ]);+ let idx = fx.open();+ assert_eq!(files(&idx, ".env"), vec![".env"], "the reported case: a git-ignored root file");+ assert_eq!(files(&idx, "config.local"), vec!["src/config.local.ts"]);+ assert!(files(&idx, "bundle").is_empty(), "ignored directories stay out");+ assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty(), "ignored files are listed by name only");+ assert_eq!(symbols(&idx, "app", SymbolFilter::All), vec!["app"]);++ // Watcher updates keep the distinction.+ let fresh = fx.write("src/fresh.local.ts", "export function freshLocal() {}\n");+ let bundled = fx.write("dist/more.js", "function more() {}\n");+ idx.update(&[fresh, bundled], &[]);+ assert!(idx.wait_idle(WAIT));+ assert_eq!(files(&idx, "fresh.local"), vec!["src/fresh.local.ts"]);+ assert!(symbols(&idx, "freshLocal", SymbolFilter::All).is_empty());+ assert!(files(&idx, "more.js").is_empty());++ // Nested ignore files apply to watcher updates as they do to the scan.+ fx.write("pkg/.gitignore", "gen.ts\n");+ let generated = fx.write("pkg/gen.ts", "export function generatedThing() {}\n");+ let kept = fx.write("pkg/kept.ts", "export function keptThing() {}\n");+ idx.update(&[generated, kept], &[]);+ assert!(idx.wait_idle(WAIT));+ assert_eq!(files(&idx, "pkg/gen"), vec!["pkg/gen.ts"]);+ assert!(symbols(&idx, "generatedThing", SymbolFilter::All).is_empty());+ assert_eq!(symbols(&idx, "keptThing", SymbolFilter::All), vec!["keptThing"]);+ drop(idx);++ // No longer ignored: the next scan parses it although its mtime is unchanged.+ std::fs::write(fx.root.join(".gitignore"), ".env\ndist/\n").unwrap();+ let idx = fx.open();+ assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), vec!["localOnly"]);+ assert_eq!(files(&idx, ".env"), vec![".env"]);+ drop(idx);++ // Ignored again: its symbols are dropped.+ std::fs::write(fx.root.join(".gitignore"), "*.local.ts\n").unwrap();+ let idx = fx.open();+ assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());+ assert_eq!(files(&idx, "bundle"), vec!["dist/bundle.js"]);+}+#[test]fn second_window_on_same_project_works_in_memory() {let fx = sample();diff --git a/crates/ide-index/src/worker.rs b/crates/ide-index/src/worker.rsindex a69472713..3928edd42 100644--- a/crates/ide-index/src/worker.rs+++ b/crates/ide-index/src/worker.rs@@ -2,13 +2,13 @@//! updates queued by the watcher.use crate::data::{FileEntry, FileRecord, IndexData, StoredSymbol};-use crate::filter::{Found, PathFilter, mtime_of};+use crate::filter::{Found, PathFilter};use crate::store::Store;use ide_core::{IdeEvent, SharedSink, TaskId};use ide_language::{LanguageRegistry, Syntax};use parking_lot::{Condvar, Mutex, RwLock};use rayon::prelude::*;-use std::collections::{HashSet, VecDeque};+use std::collections::{HashMap, HashSet, VecDeque};use std::io::Read;use std::path::{Path, PathBuf};use std::sync::atomic::{AtomicBool, Ordering};@@ -233,10 +233,7 @@ impl Shared {let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {let d = self.data.read();- let todo = found- .iter()- .filter(|f| d.get(&f.path).is_none_or(|e| e.mtime != f.mtime || e.size != f.size))- .collect();+ let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();let stale = d.paths().filter(|p| !seen.contains(p.as_path())).cloned().collect();(todo, stale)};@@ -311,6 +308,7 @@ impl Shared {let mut rec = d.get(&f.path)?.record();rec.mtime = f.mtime;rec.size = f.size;+ rec.ignored = f.ignored;Some((rel, rec, f.path.clone()))}Extracted::New(rec) => Some((rel, rec, f.path.clone())),@@ -342,8 +340,8 @@ impl Shared {}fn extract(&self, f: &Found, prev_hash: Option<[u8; 32]>) -> Extracted {- let mut rec = FileRecord { mtime: f.mtime, size: f.size, ..Default::default() };- if f.size > MAX_SYMBOL_FILE {+ let mut rec = FileRecord { mtime: f.mtime, size: f.size, ignored: f.ignored, ..Default::default() };+ if f.ignored || f.size > MAX_SYMBOL_FILE {return Extracted::New(rec);}let mut bytes = Vec::with_capacity(f.size as usize);@@ -420,6 +418,7 @@ impl Shared {let mut files: Vec<Found> = Vec::new();let mut seen = HashSet::new();+ let mut by_dir: HashMap<PathBuf, HashSet<PathBuf>> = HashMap::new();for path in changed {if !seen.insert(path.clone()) {continue;@@ -430,16 +429,19 @@ impl Shared {}if meta.is_dir() {files.extend(filter.walk(&path, &self.cancelled));- } else if meta.is_file() {- files.push(Found { mtime: mtime_of(&meta), size: meta.len(), path });+ } else if meta.is_file()+ && let Some(dir) = path.parent()+ {+ by_dir.entry(dir.to_owned()).or_default().insert(path);}}+ // Listing the folder applies every ignore file (nested, global) to tell ignored files apart.+ for (dir, wanted) in by_dir {+ files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));+ }let files: Vec<Found> = {let d = self.data.read();- files- .into_iter()- .filter(|f| d.get(&f.path).is_none_or(|e| e.mtime != f.mtime || e.size != f.size))- .collect()+ files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()};if !files.is_empty() {touched = true;@@ -457,7 +459,7 @@ impl Shared {.filter(|p| before.detect(p, None) != self.languages.detect(p, None)).filter_map(|p| {let e = d.get(p)?;- Some(Found { path: p.clone(), mtime: e.mtime, size: e.size })+ Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })}).collect()};diff --git a/crates/ide-vfs/src/lib.rs b/crates/ide-vfs/src/lib.rsindex c8059984d..2dd5a0e44 100644--- a/crates/ide-vfs/src/lib.rs+++ b/crates/ide-vfs/src/lib.rs@@ -325,6 +325,11 @@ pub struct FsBatch {/// Folders holding changes filtered out as excluded or ignored. Only a view already/// showing such a folder cares, so they don't count as worktree changes.pub excluded_dirs: Vec<PathBuf>,+ /// Files changed, created or removed that an ignore rule matches while their folder+ /// is not ignored (`.env`). Kept apart from the worktree changes above (no Local+ /// History, deployment or `fsChanged`), but the index lists them and open editors+ /// follow them, like IDEA, where only ignored folders leave the project.+ pub ignored: Vec<PathBuf>,}impl FsBatch {@@ -334,6 +339,7 @@ impl FsBatch {&& self.removed.is_empty()&& self.vcs.is_empty()&& self.excluded_dirs.is_empty()+ && self.ignored.is_empty()}}diff --git a/crates/ide-vfs/src/watch.rs b/crates/ide-vfs/src/watch.rsindex d9309d90b..39c1d35b0 100644--- a/crates/ide-vfs/src/watch.rs+++ b/crates/ide-vfs/src/watch.rs@@ -531,6 +531,13 @@ impl EventFilter {&& !self.gitignore.is_ignored(path, is_dir)}+ /// Whether a filtered-out file is ignored by a rule on the file itself, in a folder+ /// that is neither excluded nor ignored.+ fn is_ignored_file(&self, path: &Path, rel: &Path) -> bool {+ !self.excludes.read().is_excluded(rel)+ && path.parent().is_some_and(|dir| dir == self.root || !self.gitignore.is_ignored(dir, true))+ }+fn classify(&self, path: &Path, change: Change, out: &mut BTreeMap<PathBuf, Change>) {let rel = match path.strip_prefix(&self.root) {Ok(rel) if rel.as_os_str().is_empty() => return,@@ -642,6 +649,9 @@ impl EventFilter {if change != Change::Modified {excluded_dirs.extend(path.parent().map(Path::to_path_buf));}+ if !is_dir && self.is_ignored_file(&path, rel) {+ batch.ignored.push(path);+ }continue;}}@@ -700,6 +710,7 @@ mod tests {assert_eq!(batch.vcs, vec![root.join(".git/HEAD"), root.join(".git/refs/heads/feature")]);assert_eq!(batch.modified, vec![root.join("kept.txt")]);assert_eq!(batch.removed, vec![root.join("from.txt"), root.join("gone.txt"), root.join("old.txt")]);+ assert_eq!(batch.ignored, vec![root.join("debug.log")], "ignored files are reported apart");}#[test]@@ -751,6 +762,20 @@ mod tests {]);assert!(batch.created.is_empty() && batch.modified.is_empty() && batch.removed.is_empty(), "{batch:?}");assert_eq!(batch.excluded_dirs, vec![root.clone(), root.join("dist"), root.join("target/debug")]);+ assert_eq!(batch.ignored, vec![root.join("debug.log")], "only the ignored file outside ignored folders");++ // An ignored file's edit and removal reach the index too (nothing else changes).+ let modify = EventKind::Modify(ModifyKind::Data(DataChange::Content));+ let batch = filter.batch(&[ev(modify, vec![root.join("debug.log")])]);+ assert_eq!(batch.ignored, vec![root.join("debug.log")]);+ assert!(!batch.is_empty() && batch.excluded_dirs.is_empty());+ std::fs::remove_file(root.join("debug.log")).unwrap();+ let batch = filter.batch(&[+ ev(EventKind::Remove(RemoveKind::File), vec![root.join("debug.log")]),+ ev(EventKind::Remove(RemoveKind::File), vec![root.join("dist/app.js")]),+ ]);+ // A removed path can't tell file from folder: it goes out as a removal, as before.+ assert_eq!(batch.removed, vec![root.join("debug.log")]);// Sibling files in unignored directories still come through.let batch = filter.batch(&[ev(create_file, vec![root.join("src/main.rs")])]);@@ -801,6 +826,7 @@ mod tests {|paths: &[&str]| -> Vec<DebouncedEvent> { paths.iter().map(|p| ev(modify, vec![root.join(p)])).collect() };let (batch, rules) = filter.batch_detailed(&touch(&["pkg/a.tmp", "pkg/gen/x.rs", "pkg/keep.rs", "b.tmp"]));assert_eq!(batch.modified, vec![root.join("b.tmp"), root.join("pkg/keep.rs")]);+ assert_eq!(batch.ignored, vec![root.join("pkg/a.tmp")], "nested rules, but not inside ignored folders");assert!(rules.is_empty());assert!(!filter.should_watch_dir(&root.join("pkg/gen")));@@ -818,7 +844,8 @@ mod tests {std::fs::create_dir_all(root.join(".git/info")).unwrap();std::fs::write(root.join(".git/info/exclude"), "b.tmp\n").unwrap();let (batch, rules) = filter.batch_detailed(&touch(&[".git/info/exclude", "b.tmp"]));- assert!(batch.is_empty(), "{batch:?}");+ assert!(batch.modified.is_empty() && batch.vcs.is_empty(), "{batch:?}");+ assert_eq!(batch.ignored, vec![root.join("b.tmp")]);assert_eq!(rules, vec![root.clone()]);}