mod overlay_refresh;
mod schedule;
use std::path::{Path, PathBuf};
use std::sync::mpsc::{self, RecvTimeoutError};
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use std::thread::JoinHandle;
use std::time::{Duration, Instant};
use notify::{RecommendedWatcher, RecursiveMode, Watcher as _};
use crate::graph::CodeGraph;
use crate::types::Tier;
pub use overlay_refresh::OverlayRefresh;
pub use schedule::{is_watch_relevant, Debouncer, TierBatch, TieredScheduler};
pub trait TierHandler: Send {
fn tree_sitter(&mut self, paths: &[PathBuf]);
fn heavy(&mut self, paths: &[PathBuf]);
}
pub struct GraphRefresh {
root: PathBuf,
}
impl GraphRefresh {
#[must_use]
pub fn new(root: PathBuf) -> Self {
Self { root }
}
}
impl TierHandler for GraphRefresh {
fn tree_sitter(&mut self, paths: &[PathBuf]) {
for path in paths {
match std::fs::read_to_string(path) {
Ok(source) => match crate::extract::extract_structure(&source, "rust") {
Ok(structure) => tracing::info!(
file = %path.display(),
symbols = structure.symbols.len(),
calls = structure.calls.len(),
tier = Tier::TreeSitter.as_str(),
"re-extracted (tree-sitter)"
),
Err(e) => {
tracing::debug!(file = %path.display(), error = %e, "tree-sitter re-parse skipped");
}
},
Err(e) => {
tracing::debug!(file = %path.display(), error = %e, "unreadable (removed?)");
}
}
}
}
fn heavy(&mut self, paths: &[PathBuf]) {
match CodeGraph::build(&self.root) {
Ok(graph) => {
let (nodes, edges) = graph.stats();
tracing::info!(
changed = paths.len(),
nodes,
edges,
"graph rebuilt (heavy tier)"
);
}
Err(e) => tracing::warn!(error = %e, "heavy-tier graph rebuild failed"),
}
}
}
pub struct Watcher {
_inner: RecommendedWatcher,
running: Arc<AtomicBool>,
worker: Option<JoinHandle<()>>,
}
impl Watcher {
pub fn start(
root: &Path,
mut scheduler: TieredScheduler,
mut handler: Box<dyn TierHandler>,
poll_interval: Duration,
) -> crate::Result<Self> {
let (tx, rx) = mpsc::channel::<PathBuf>();
let ignore = build_gitignore(root);
let mut inner = notify::recommended_watcher(move |res: notify::Result<notify::Event>| {
if let Ok(event) = res {
if !(event.kind.is_create() || event.kind.is_modify() || event.kind.is_remove()) {
return;
}
for path in event.paths {
if is_watch_relevant(&path)
&& !ignore.matched_path_or_any_parents(&path, false).is_ignore()
{
let _ = tx.send(path);
}
}
}
})
.map_err(|e| watch_err(&e))?;
inner
.watch(root, RecursiveMode::Recursive)
.map_err(|e| watch_err(&e))?;
let running = Arc::new(AtomicBool::new(true));
let worker_running = Arc::clone(&running);
let worker = std::thread::spawn(move || {
while worker_running.load(Ordering::Relaxed) {
let wait = scheduler.next_deadline().map_or(poll_interval, |d| {
d.saturating_duration_since(Instant::now())
.min(poll_interval)
});
match rx.recv_timeout(wait) {
Ok(path) => scheduler.record(path, Instant::now()),
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break,
}
let batch = scheduler.poll(Instant::now());
if !batch.tree_sitter.is_empty() {
handler.tree_sitter(&batch.tree_sitter);
}
if !batch.heavy.is_empty() {
handler.heavy(&batch.heavy);
}
}
});
Ok(Self {
_inner: inner,
running,
worker: Some(worker),
})
}
pub fn stop(mut self) {
self.shutdown();
}
fn shutdown(&mut self) {
self.running.store(false, Ordering::Relaxed);
if let Some(worker) = self.worker.take() {
let _ = worker.join();
}
}
}
impl Drop for Watcher {
fn drop(&mut self) {
self.shutdown();
}
}
fn watch_err(e: ¬ify::Error) -> crate::Error {
crate::Error::Config(format!("file-watch: {e}"))
}
fn build_gitignore(root: &Path) -> ignore::gitignore::Gitignore {
let mut builder = ignore::gitignore::GitignoreBuilder::new(root);
let _ = builder.add(root.join(".gitignore"));
builder
.build()
.unwrap_or_else(|_| ignore::gitignore::Gitignore::empty())
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
#[derive(Clone, Default)]
struct Recorder {
tree_sitter: Arc<Mutex<Vec<PathBuf>>>,
heavy: Arc<Mutex<Vec<PathBuf>>>,
}
impl TierHandler for Recorder {
fn tree_sitter(&mut self, paths: &[PathBuf]) {
self.tree_sitter.lock().unwrap().extend_from_slice(paths);
}
fn heavy(&mut self, paths: &[PathBuf]) {
self.heavy.lock().unwrap().extend_from_slice(paths);
}
}
#[test]
fn gitignore_excludes_ignored_rust_files() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join(".gitignore"), "generated/\n*.gen.rs\n").unwrap();
std::fs::create_dir(dir.path().join("generated")).unwrap();
let ignore = build_gitignore(dir.path());
let ignored = |rel: &str| {
ignore
.matched_path_or_any_parents(dir.path().join(rel), false)
.is_ignore()
};
assert!(
ignored("generated/x.rs"),
"a file under an ignored dir is excluded"
);
assert!(
ignored("build.gen.rs"),
"a file matching an ignore glob is excluded"
);
assert!(!ignored("src/lib.rs"), "a normal source file is watched");
}
#[test]
fn watcher_dispatches_a_real_file_change() {
let dir = tempfile::tempdir().unwrap();
let rec = Recorder::default();
let seen_heavy = Arc::clone(&rec.heavy);
let scheduler = TieredScheduler::new(Duration::from_millis(50), Duration::from_millis(120));
let watcher = Watcher::start(
dir.path(),
scheduler,
Box::new(rec.clone()),
Duration::from_millis(20),
)
.unwrap();
std::thread::sleep(Duration::from_millis(100));
let file = dir.path().join("thing.rs");
std::fs::write(&file, "fn a() {}\n").unwrap();
std::thread::sleep(Duration::from_millis(30));
std::fs::write(&file, "fn a() {}\nfn b() { a(); }\n").unwrap();
let mut got = false;
for _ in 0..150 {
if !seen_heavy.lock().unwrap().is_empty() {
got = true;
break;
}
std::thread::sleep(Duration::from_millis(20));
}
watcher.stop();
if got {
assert!(
rec.tree_sitter.lock().unwrap().iter().any(|p| p == &file),
"tree-sitter tier must have re-extracted the changed file"
);
} else {
eprintln!("note: no filesystem events delivered; watcher dispatch not exercised");
}
}
}