use std::path::{Path, PathBuf};
use tokio::sync::broadcast::{self, Sender, error::RecvError};
use webadev::ReloadType;
use crate::{BuildOptions, build};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BuildCause {
Startup,
Change,
Lagged,
}
#[derive(Clone, Debug)]
pub enum WatchLog {
Built {
cause: BuildCause,
reload_type: ReloadType,
paths: Vec<PathBuf>,
},
Warn(String),
Error(String),
}
#[derive(Debug)]
pub struct Watch {
rx_src: broadcast::Receiver<(ReloadType, Vec<PathBuf>)>,
src: PathBuf,
dist: PathBuf,
options: BuildOptions,
tx_log: Sender<WatchLog>,
tx_dist: Option<Sender<(ReloadType, Vec<PathBuf>)>>,
}
pub async fn watch(
src: &Path,
dist: &Path,
options: &BuildOptions,
tx_log: Sender<WatchLog>,
filter: &[&str],
) -> Result<Watch, String> {
watch_setup(src, dist, options, tx_log, filter, None).await
}
pub(crate) async fn watch_setup(
src: &Path,
dist: &Path,
options: &BuildOptions,
tx_log: Sender<WatchLog>,
filter: &[&str],
tx_dist: Option<Sender<(ReloadType, Vec<PathBuf>)>>,
) -> Result<Watch, String> {
let (tx_src, rx_src) = broadcast::channel(100);
webadev::watch(tx_src, src, filter)
.map_err(|err| format!("failed to watch {}: {err}", src.display()))?;
build(src, dist, options)
.await
.map_err(|err| format!("build error: {err}"))?
.into_iter()
.for_each(|warning| {
let _ = tx_log.send(WatchLog::Warn(warning));
});
let _ = tx_log.send(WatchLog::Built {
cause: BuildCause::Startup,
reload_type: ReloadType::Page,
paths: vec![],
});
Ok(Watch {
rx_src,
src: src.to_path_buf(),
dist: dist.to_path_buf(),
options: options.clone(),
tx_log,
tx_dist,
})
}
async fn src_event_recv(
rx: &mut broadcast::Receiver<(ReloadType, Vec<PathBuf>)>,
) -> Option<(BuildCause, ReloadType, Vec<PathBuf>)> {
match rx.recv().await {
Ok((reload_type, paths)) => Some((BuildCause::Change, reload_type, paths)),
Err(RecvError::Lagged(_)) => Some((BuildCause::Lagged, ReloadType::Page, vec![])),
Err(RecvError::Closed) => None,
}
}
impl Watch {
pub async fn run(mut self) -> Result<(), String> {
while let Some((cause, reload_type, paths)) = src_event_recv(&mut self.rx_src).await {
match build(&self.src, &self.dist, &self.options).await {
Ok(warnings) => {
warnings.into_iter().for_each(|warning| {
let _ = self.tx_log.send(WatchLog::Warn(warning));
});
let reload_type = browser_reload(reload_type, &self.options);
if let Some(tx_dist) = &self.tx_dist {
let _ = tx_dist.send((reload_type, paths.clone()));
}
let _ = self.tx_log.send(WatchLog::Built {
cause,
reload_type,
paths,
});
}
Err(err) => {
let _ = self
.tx_log
.send(WatchLog::Error(format!("build error: {err}")));
}
}
}
Ok(())
}
}
fn browser_reload(reload_type: ReloadType, options: &BuildOptions) -> ReloadType {
if options.hash {
ReloadType::Page
} else {
reload_type
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hashed_css_changes_reload_full_page() {
assert_eq!(
browser_reload(ReloadType::Css, &BuildOptions::PROD),
ReloadType::Page
);
assert_eq!(
browser_reload(ReloadType::Page, &BuildOptions::PROD),
ReloadType::Page
);
}
#[test]
fn unhashed_css_changes_hot_reload() {
assert_eq!(
browser_reload(ReloadType::Css, &BuildOptions::DEV),
ReloadType::Css
);
assert_eq!(
browser_reload(ReloadType::Page, &BuildOptions::DEV),
ReloadType::Page
);
}
#[tokio::test]
async fn src_event_recovers_from_lag() {
let (tx, mut rx) = broadcast::channel::<(ReloadType, Vec<PathBuf>)>(1);
tx.send((ReloadType::Css, vec![PathBuf::from("a.css")]))
.unwrap();
tx.send((ReloadType::Css, vec![PathBuf::from("b.css")]))
.unwrap();
tx.send((ReloadType::Css, vec![PathBuf::from("c.css")]))
.unwrap();
drop(tx);
let (cause, reload_type, paths) = src_event_recv(&mut rx).await.expect("a lagged event");
assert_eq!(cause, BuildCause::Lagged);
assert_eq!(reload_type, ReloadType::Page);
assert!(paths.is_empty());
let (cause, reload_type, paths) = src_event_recv(&mut rx).await.expect("a buffered event");
assert_eq!(cause, BuildCause::Change);
assert_eq!(reload_type, ReloadType::Css);
assert_eq!(paths, vec![PathBuf::from("c.css")]);
assert!(src_event_recv(&mut rx).await.is_none(), "channel closed");
}
}