use std::{
mem,
path::{Path, PathBuf},
sync::mpsc::{self, Receiver, RecvTimeoutError},
thread,
time::{Duration, Instant},
};
use notify::{Config, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
use tokio::sync::broadcast;
use crate::{ReloadType, filter};
const DEBOUNCE_TIME: Duration = Duration::from_millis(200);
const IDLE_TIME: Duration = Duration::from_secs(3600);
pub fn watch(
app_event_tx: broadcast::Sender<(ReloadType, Vec<PathBuf>)>,
dir: impl AsRef<Path>,
filter: &[&str],
) -> Result<(), String> {
let dir = dir.as_ref().to_path_buf();
let filter = filter::normalize(filter)?;
let (watcher_event_tx, watcher_event_rx) = mpsc::channel::<Result<Event, notify::Error>>();
let watcher = watcher_build(dir, watcher_event_tx, filter).map_err(|err| err.to_string())?;
thread::spawn(move || {
let _watcher = watcher;
event_on_change_emit(watcher_event_rx, app_event_tx);
});
Ok(())
}
fn watcher_build(
dir: PathBuf,
watcher_event_tx: mpsc::Sender<Result<Event, notify::Error>>,
filter: Vec<String>,
) -> Result<RecommendedWatcher, notify::Error> {
let mut watcher = RecommendedWatcher::new(
move |filesystem_event: Result<Event, notify::Error>| {
let option = match filesystem_event {
Err(error) => Some(Err(error)),
Ok(event) => event_filter(event, &filter).map(Ok),
};
if let Some(event_or_error) = option {
let _ = watcher_event_tx.send(event_or_error);
}
},
Config::default(),
)?;
watcher.watch(&dir, RecursiveMode::Recursive)?;
Ok(watcher)
}
fn event_filter(mut event: Event, filter: &[String]) -> Option<Event> {
if !event_kind_check(&event.kind) {
return None;
}
event.paths.retain(|path| filter::matches(path, filter));
if event.paths.is_empty() {
return None;
}
Some(event)
}
fn event_kind_check(kind: &EventKind) -> bool {
matches!(
kind,
EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_)
)
}
fn event_on_change_emit(
watcher_event_rx: Receiver<Result<Event, notify::Error>>,
app_event_tx: broadcast::Sender<(ReloadType, Vec<PathBuf>)>,
) {
let mut changes = Changes::default();
while let Some(paths) = changes_wait(&watcher_event_rx, &mut changes) {
let reload_type = reload_type_find(&paths);
let _ = app_event_tx.send((reload_type, paths));
}
}
fn reload_type_find(paths: &[PathBuf]) -> ReloadType {
let css_only = !paths.is_empty()
&& paths
.iter()
.all(|p| p.extension().and_then(|e| e.to_str()) == Some("css"));
if css_only {
ReloadType::Css
} else {
ReloadType::Page
}
}
fn changes_wait(
watcher_event_rx: &Receiver<Result<Event, notify::Error>>,
changes: &mut Changes,
) -> Option<Vec<PathBuf>> {
loop {
if let Some(paths) = changes.emit() {
return Some(paths);
}
match watcher_event_rx.recv_timeout(changes.wait()) {
Ok(Ok(event)) => changes.enqueue(&event.paths),
Ok(Err(err)) => eprintln!("File watcher error: {err:?}"),
Err(RecvTimeoutError::Timeout) => continue,
Err(RecvTimeoutError::Disconnected) => return None,
}
}
}
#[derive(Default)]
struct Changes {
paths: Vec<PathBuf>,
time: Option<Instant>,
}
impl Changes {
fn enqueue(&mut self, paths: &[PathBuf]) {
let new_paths = paths_filter(&self.paths, paths);
if !new_paths.is_empty() {
self.paths.extend(new_paths);
self.time = Some(Instant::now());
}
}
fn wait(&self) -> Duration {
match self.time {
Some(time) => DEBOUNCE_TIME.saturating_sub(time.elapsed()),
None => IDLE_TIME,
}
}
fn emit(&mut self) -> Option<Vec<PathBuf>> {
let debounce_time_elapsed = self.time.is_some_and(|t| t.elapsed() >= DEBOUNCE_TIME);
if self.paths.is_empty() || !debounce_time_elapsed {
return None;
}
self.time = None;
Some(mem::take(&mut self.paths))
}
}
fn paths_filter(paths: &[PathBuf], event_paths: &[PathBuf]) -> Vec<PathBuf> {
event_paths
.iter()
.filter(|p| !paths.contains(p))
.cloned()
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use notify::event::{AccessKind, AccessMode, CreateKind, DataChange, ModifyKind, RemoveKind};
#[test]
fn event_kind_check_reads_are_false() {
assert!(!event_kind_check(&EventKind::Access(AccessKind::Open(
AccessMode::Any
))));
assert!(!event_kind_check(&EventKind::Access(AccessKind::Close(
AccessMode::Write
))));
}
#[test]
fn event_kind_check_writes_creates_and_removes_are_true() {
assert!(event_kind_check(&EventKind::Modify(ModifyKind::Data(
DataChange::Any
))));
assert!(event_kind_check(&EventKind::Create(CreateKind::File)));
assert!(event_kind_check(&EventKind::Remove(RemoveKind::File)));
assert!(!event_kind_check(&EventKind::Any));
assert!(!event_kind_check(&EventKind::Other));
}
#[test]
fn reload_type_find_css_only_is_css() {
let paths = vec![PathBuf::from("a.css"), PathBuf::from("b.css")];
assert_eq!(reload_type_find(&paths), ReloadType::Css);
}
#[test]
fn reload_type_find_mixed_body_is_page() {
let paths = vec![PathBuf::from("a.css"), PathBuf::from("index.html")];
assert_eq!(reload_type_find(&paths), ReloadType::Page);
}
#[test]
fn reload_type_find_single_non_css_is_page() {
let paths = vec![PathBuf::from("app.js")];
assert_eq!(reload_type_find(&paths), ReloadType::Page);
}
#[test]
fn reload_type_find_empty_is_page() {
assert_eq!(reload_type_find(&[]), ReloadType::Page);
}
fn event(kind: EventKind, paths: &[&str]) -> Event {
paths.iter().fold(Event::new(kind), |event, path| {
event.add_path(PathBuf::from(path))
})
}
#[test]
fn event_filter_trims_unworthy_paths_with_filter() {
let filter = vec!["js".to_string()];
let filtered = event_filter(
event(EventKind::Create(CreateKind::File), &["a.js"]),
&filter,
)
.unwrap();
assert_eq!(filtered.paths, vec![PathBuf::from("a.js")]);
let filtered = event_filter(
event(
EventKind::Modify(ModifyKind::Data(DataChange::Any)),
&["a.js", "a.log"],
),
&filter,
)
.unwrap();
assert_eq!(filtered.paths, vec![PathBuf::from("a.js")]);
}
#[test]
fn event_filter_custom_filter_allows_toml() {
let filter = vec!["html".to_string(), "toml".to_string()];
let filtered = event_filter(
event(EventKind::Create(CreateKind::File), &["a.toml"]),
&filter,
)
.unwrap();
assert_eq!(filtered.paths, vec![PathBuf::from("a.toml")]);
}
#[test]
fn event_filter_empty_filter_allows_all() {
let filter: Vec<String> = vec![];
let filtered = event_filter(
event(EventKind::Create(CreateKind::File), &["a.md"]),
&filter,
)
.unwrap();
assert_eq!(filtered.paths, vec![PathBuf::from("a.md")]);
}
}