DevelopmentNodeEnvironment_MicrosoftVSCodeDependency_22NodeVersion_Bundle_Clean_Debug_ElectronProfile_EsbuildCompiler_Mountain/Environment/

FileWatcherIgnore.rs

#![allow(non_snake_case)]

//! Server-side ignore filter for file-watcher events.
//!
//! Events that match the ignore list never cross the
//! Mountain→Cocoon gRPC notification boundary. Stops the cargo /
//! pnpm / git-object churn from drowning the editor in dead
//! `$fileWatcher:event` traffic.
//!
//! Why server-side: the watcher root + glob pattern coming from
//! extensions (`**/*.md`, `**/package.json`, `**/*.ts`) does not
//! exclude build directories. Even with the per-event glob filter
//! a single `cargo check` produces thousands of `.rcgu.o` create /
//! delete events that all match `**/*.md`'s sibling traversal -
//! every one of them triggers a notification, which Cocoon then
//! tries to stat back through Mountain (returning a 404 because
//! cargo has already deleted the file). One side-effect per call.
//!
//! The list is deliberately conservative: only paths whose
//! contents are never meaningful to user-facing editor state are
//! excluded. The git work tree (`.git/index`, `.git/HEAD`,
//! `.git/refs/`) is NOT excluded because the Git extension relies
//! on those events to refresh branch / staged-files state.
//!
//! Override via `WatchIgnore` env var (colon-separated path
//! segments). Empty value disables the filter entirely. Useful
//! when debugging an extension that legitimately probes inside a
//! `Target/` tree.

use std::sync::OnceLock;

/// Default ignore segments. A match anywhere in the path's
/// component list (case-sensitive) suppresses the event. Tuned
/// against the segments most likely to host high-frequency build
/// churn without containing user-edited source.
const DEFAULT_IGNORE_SEGMENTS:&[&str] = &[
	// Rust
	"target",
	// Node
	"node_modules",
	// Git object database. Refs/HEAD/index changes still fire
	// because they're addressed via separate parent segments.
	".git/objects",
	".git/lfs",
	// macOS metadata
	".DS_Store",
	// Build outputs that mirror source one-to-one - watching the
	// output adds no signal the source watcher doesn't already
	// give us.
	"dist",
	".next",
	".turbo",
	".astro",
	".parcel-cache",
	".vite",
	".cache",
	// Test snapshots / coverage dumps - regenerated by CI, never
	// hand-edited.
	"coverage",
	"__snapshots__",
];

/// Lazily-resolved active ignore list. `WatchIgnore` overrides
/// the default; an empty string disables filtering entirely.
fn IgnoreSegments() -> &'static Vec<String> {
	static CACHE:OnceLock<Vec<String>> = OnceLock::new();

	CACHE.get_or_init(|| {
		match std::env::var("WatchIgnore") {
			Ok(Raw) if Raw.is_empty() => Vec::new(),
			Ok(Raw) => Raw.split(':').map(|S| S.trim().to_string()).filter(|S| !S.is_empty()).collect(),
			Err(_) => DEFAULT_IGNORE_SEGMENTS.iter().map(|S| (*S).to_string()).collect(),
		}
	})
}

/// `true` when the path should be silently dropped before any
/// IPC traffic is emitted. Implementation is a single linear
/// scan over the string - tested against `git/.git/objects/...`,
/// `Target/debug/build/.../foo.rcgu.o`, and
/// `node_modules/.bin/...`. Worst case is on every event so we
/// keep this allocation-free.
pub fn ShouldIgnore(Path:&str) -> bool {
	let Segments = IgnoreSegments();

	if Segments.is_empty() {
		return false;
	}

	for Needle in Segments {
		if Path_ContainsSegment(Path, Needle) {
			return true;
		}
	}

	false
}

/// Match a `/seg1/seg2` substring as a complete path segment so
/// `target` matches `/target/...` but not `/get-target-info/...`.
/// Slashes are platform-agnostic - matches both `/` and `\`. A
/// needle that itself contains a slash (`".git/objects"`) is
/// matched as a literal substring with leading-slash gating.
fn Path_ContainsSegment(Path:&str, Needle:&str) -> bool {
	if Needle.contains('/') || Needle.contains('\\') {
		// Composite needle - look for it as a substring with at
		// least one path-separator immediately before it (or at
		// the start of the path).
		let Bytes = Path.as_bytes();
		let NeedleBytes = Needle.as_bytes();

		let mut Start = 0;
		while let Some(Hit) = Path[Start..].find(Needle) {
			let Index = Start + Hit;
			let PreviousIsSep = Index == 0 || matches!(Bytes[Index - 1], b'/' | b'\\');
			let NextIsSepOrEnd = match Bytes.get(Index + NeedleBytes.len()) {
				None => true,
				Some(b) => matches!(*b, b'/' | b'\\'),
			};

			if PreviousIsSep && NextIsSepOrEnd {
				return true;
			}

			Start = Index + 1;
		}

		return false;
	}

	Path.split(|C| C == '/' || C == '\\').any(|Segment| Segment == Needle)
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn TargetSegmentMatchesCargoBuildPath() {
		assert!(ShouldIgnore(
			"/Volumes/CORSAIR/Land/Target/debug/build/foo-abc/build_script.rcgu.o"
		));
	}

	#[test]
	fn TargetSegmentDoesNotMatchUnrelatedSubstring() {
		// `Target` only excluded at top level (case-sensitive on
		// the default list); a directory called `target-info`
		// should not be swept up.
		assert!(!ShouldIgnore("/Volumes/CORSAIR/Land/target-info/source.ts"));
	}

	#[test]
	fn NodeModulesMatches() {
		assert!(ShouldIgnore("/repo/node_modules/.bin/eslint"));
	}

	#[test]
	fn GitObjectsCompositeMatches() {
		assert!(ShouldIgnore("/repo/.git/objects/ab/cdef1234"));
	}

	#[test]
	fn GitIndexNotIgnored() {
		// The Git extension needs index / HEAD events; the ignore
		// list must not swallow those.
		assert!(!ShouldIgnore("/repo/.git/index"));
		assert!(!ShouldIgnore("/repo/.git/HEAD"));
	}

	#[test]
	fn UserSourceFileNotIgnored() {
		assert!(!ShouldIgnore("/repo/Source/Application/Foo.ts"));
	}
}