@browsersync/bslive 0.0.5 → 0.0.9

package/crates/bsnext_fs/src/stream.rs

@@ -0,0 +1,167 @@
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use std::fmt::Debug;
+use std::time::Duration;
+
+use futures::{Future, Stream};
+use pin_project_lite::pin_project;
+
+use tokio::time::{Instant, Sleep};
+
+use tracing::trace;
+
+pin_project! {
+    #[must_use = "streams do nothing unless polled"]
+    pub struct Debounce<St: Stream> {
+        #[pin]
+        dropped_count: usize,
+        #[pin]
+        value: St,
+        #[pin]
+        delay: Sleep,
+        #[pin]
+        debounce_time: Duration,
+        #[pin]
+        last_state: Option<St::Item>,
+        #[pin]
+        child_ended: bool
+    }
+}
+
+pub trait StreamOpsExt: Stream {
+    fn debounce(self, debounce_time: Duration) -> Debounce<Self>
+    where
+        Self: Sized + Unpin,
+    {
+        Debounce::new(self, debounce_time)
+    }
+}
+
+impl<T: ?Sized> StreamOpsExt for T where T: Stream {}
+
+impl<St> Debounce<St>
+where
+    St: Stream + Unpin,
+{
+    #[allow(dead_code)]
+    fn new(stream: St, debounce_time: Duration) -> Debounce<St> {
+        Debounce {
+            value: stream,
+            dropped_count: 0,
+            delay: tokio::time::sleep(debounce_time),
+            debounce_time,
+            last_state: None,
+            child_ended: false,
+        }
+    }
+}
+
+impl<St, Item> Stream for Debounce<St>
+where
+    St: Stream<Item = Item>,
+    Item: Clone + Unpin + Debug + 'static,
+{
+    type Item = St::Item;
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut me = self.project();
+        trace!("+ polled!");
+
+        match me.value.poll_next(cx) {
+            Poll::Ready(Some(v)) => {
+                trace!("recorded a child value");
+                *me.last_state = Some(v);
+                *me.dropped_count += 1;
+
+                trace!("resetting the deadline to be `debounce_time` from `now`");
+                let dur = *me.debounce_time;
+                me.delay.as_mut().reset(Instant::now() + dur);
+
+                trace!("wake to ensure we're polled again");
+                cx.waker().wake_by_ref();
+                return Poll::Pending;
+            }
+            Poll::Ready(None) => {
+                trace!("child ended, nothing more to do?");
+                *me.child_ended = true;
+            }
+            Poll::Pending => {
+                trace!("child was pending, nothing to do");
+            }
+        }
+
+        match me.delay.poll(cx) {
+            Poll::Ready(_) => {
+                trace!("timer elapsed");
+                match (*me.last_state).clone() {
+                    Some(v) => {
+                        trace!("buffered {} events", me.dropped_count);
+                        *me.last_state = None;
+                        *me.dropped_count = 0;
+                        trace!("sending value");
+                        Poll::Ready(Some(v))
+                    }
+                    None => {
+                        if *me.child_ended {
+                            Poll::Ready(None)
+                        } else {
+                            Poll::Pending
+                        }
+                    }
+                }
+            }
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use tokio::sync::mpsc;
+    use tokio::time::sleep;
+    use tokio::time::Instant;
+    use tokio_stream::wrappers::ReceiverStream;
+    use tokio_stream::StreamExt;
+    #[tokio::test]
+    async fn test_stream() {
+        let (tx, rx) = mpsc::channel::<&str>(10);
+        let handle = tokio::spawn(async move {
+            let events = ["A", "B", "C", "D", "E", "F"];
+
+            // 6 events all happening together
+            for evt in events {
+                tx.send(evt).await.unwrap();
+            }
+
+            // a gap in events, just under the debounce duration
+            sleep(Duration::from_millis(50)).await;
+
+            tx.send("G").await.unwrap();
+            tx.send("H").await.unwrap();
+            tx.send("I").await.unwrap();
+            tx.send("J").await.unwrap();
+
+            // drop the sender to complete the stream
+            drop(tx);
+        });
+
+        let start_time = Instant::now();
+        let stream = Box::pin(
+            ReceiverStream::new(rx)
+                .debounce(Duration::from_millis(100))
+                .collect::<Vec<_>>(),
+        );
+
+        let results = stream.await;
+        let end_time = Instant::now();
+        let total_duration = end_time
+            .checked_duration_since(start_time)
+            .expect("checked");
+
+        println!("{:?}", results);
+        println!("duration: {:?}", total_duration);
+
+        assert!(handle.await.is_ok());
+        assert_eq!(vec!["J"], results);
+    }
+}

package/crates/bsnext_fs/src/test/mod.rs

@@ -0,0 +1,213 @@
+use crate::actor::FsWatcher;
+use crate::watch_path_handler::RequestWatchPath;
+use crate::{Debounce, FsEvent, FsEventKind};
+use actix::{Actor, Addr};
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+use tempfile::TempDir;
+
+use crate::filter::Filter;
+use tokio::time::sleep;
+
+struct A {
+    events: Vec<FsEvent>,
+}
+
+impl Actor for A {
+    type Context = actix::Context<Self>;
+}
+#[derive(actix::Message)]
+#[rtype(result = "Vec<FsEvent>")]
+struct GetEvents;
+
+impl actix::Handler<GetEvents> for A {
+    type Result = Vec<FsEvent>;
+
+    fn handle(&mut self, _msg: GetEvents, _ctx: &mut Self::Context) -> Self::Result {
+        self.events.clone()
+    }
+}
+impl actix::Handler<FsEvent> for A {
+    type Result = ();
+
+    fn handle(&mut self, msg: FsEvent, _ctx: &mut Self::Context) -> Self::Result {
+        self.events.push(msg);
+    }
+}
+
+fn create_file(base: &Path, name: &str) -> PathBuf {
+    let file_path = base.join(name);
+    let mut file = File::create(&file_path).expect("create file");
+    file.write_all(name.as_bytes())
+        .expect(format!("write {name}").as_str());
+    file_path
+}
+
+struct TestCase {
+    addr: Addr<FsWatcher>,
+    recip_addr: Addr<A>,
+    dir: PathBuf,
+    #[allow(dead_code)]
+    tmp_dir: TempDir,
+}
+
+impl TestCase {
+    pub fn new(debounce: Debounce, filter: Option<Filter>) -> Self {
+        let tmp_dir = tempfile::tempdir().unwrap();
+        let mut fs = FsWatcher::new(tmp_dir.path(), 0);
+        fs.with_debounce(debounce);
+        if let Some(filter) = filter {
+            fs.with_filter(filter);
+        }
+        let addr = fs.start();
+        let a = A { events: vec![] };
+        let recip_addr = a.start();
+        Self {
+            recip_addr: recip_addr.clone(),
+            addr: addr.clone(),
+            dir: tmp_dir.path().to_path_buf(),
+            tmp_dir,
+        }
+    }
+
+    async fn watch(&self) {
+        let r = RequestWatchPath {
+            recipients: vec![self.recip_addr.clone().recipient()],
+            path: self.dir.to_path_buf(),
+        };
+
+        let _ = self.addr.send(r).await;
+    }
+
+    async fn write_file(&self, p: &str) {
+        create_file(self.dir.as_path(), p);
+    }
+
+    async fn get_events_after(&self, d: Duration) -> Vec<FsEvent> {
+        sleep(d).await;
+        let events = self.recip_addr.send(GetEvents).await.unwrap();
+        events
+    }
+    async fn change_events_after(&self, d: Duration) -> (Vec<FsEvent>, Vec<FsEvent>, usize) {
+        sleep(d).await;
+        let events = self.recip_addr.send(GetEvents).await.unwrap();
+        let len = events.len();
+        let (change_events, other_events) = events
+            .into_iter()
+            .partition(|e| matches!(e.kind, FsEventKind::Change(..)));
+        (change_events, other_events, len)
+    }
+    async fn buffered_change_after(&self, d: Duration) -> (Vec<FsEvent>, Vec<FsEvent>, usize) {
+        sleep(d).await;
+        let events = self.recip_addr.send(GetEvents).await.unwrap();
+        let len = events.len();
+        let (change_events, other_events) = events
+            .into_iter()
+            .partition(|e| matches!(e.kind, FsEventKind::ChangeBuffered(..)));
+        (change_events, other_events, len)
+    }
+
+    fn file_names(events: Vec<FsEvent>) -> Vec<String> {
+        events
+            .into_iter()
+            .flat_map(|evt| match evt.kind {
+                FsEventKind::Change(_) => vec![],
+                FsEventKind::ChangeBuffered(buf) => buf
+                    .events
+                    .iter()
+                    .map(|p| p.absolute.to_path_buf())
+                    .collect(),
+                FsEventKind::PathAdded(_) => vec![],
+                FsEventKind::PathRemoved(_) => vec![],
+            })
+            .map(|pb| pb.file_name().unwrap().to_string_lossy().to_string())
+            .collect()
+    }
+}
+
+async fn test_single_file_impl() -> Result<(), Box<dyn std::error::Error>> {
+    let tc = TestCase::new(Debounce::trailing_ms(10), None);
+    tc.watch().await;
+    tc.write_file("test_file.txt").await;
+    let events = tc.get_events_after(Duration::from_millis(300)).await;
+    assert_eq!(events.len(), 2);
+    assert_eq!(
+        matches!(events.get(0).unwrap().kind, FsEventKind::PathAdded(..)),
+        true
+    );
+    assert_eq!(
+        matches!(events.get(1).unwrap().kind, FsEventKind::Change(..)),
+        true
+    );
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_single_file() -> Result<(), Box<dyn std::error::Error>> {
+    test_single_file_impl().await
+}
+
+async fn test_trailing_drops_impl() -> Result<(), Box<dyn std::error::Error>> {
+    let tc = TestCase::new(Debounce::trailing_ms(10), None);
+    tc.watch().await;
+    tc.write_file("test_file.txt").await;
+    tc.write_file("test_file.css").await;
+    let (change, other, _total_count) = tc.change_events_after(Duration::from_millis(500)).await;
+    assert_eq!(change.len(), 1, "Should be a single change event");
+    assert_eq!(other.len(), 1, "Should be 2 in total");
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_trailing_drops() -> Result<(), Box<dyn std::error::Error>> {
+    test_trailing_drops_impl().await
+}
+
+async fn test_buffer_impl() -> Result<(), Box<dyn std::error::Error>> {
+    let tc = TestCase::new(Debounce::buffered_ms(10), None);
+    tc.watch().await;
+    tc.write_file("test_file.txt").await;
+    tc.write_file("test_file.css").await;
+    let (change, other, total_count) = tc.buffered_change_after(Duration::from_millis(500)).await;
+    assert_eq!(change.len(), 1, "Should be 1 change event (buffered)");
+    assert_eq!(other.len(), 1, "Should be 1 other event (path added)");
+    assert_eq!(total_count, 2, "Should be 2 in total");
+
+    let names = TestCase::file_names(change);
+    assert!(names.contains(&"test_file.txt".to_string()));
+    assert!(names.contains(&"test_file.css".to_string()));
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_buffer() -> Result<(), Box<dyn std::error::Error>> {
+    test_buffer_impl().await
+}
+
+async fn test_buffer_filter_impl() -> Result<(), Box<dyn std::error::Error>> {
+    let tc = TestCase::new(
+        Debounce::buffered_ms(10),
+        Some(Filter::Extension {
+            ext: "css".to_string(),
+        }),
+    );
+    tc.watch().await;
+    tc.write_file("test_file.txt").await;
+    tc.write_file("test_file.css").await;
+    let (change, other, total_count) = tc.buffered_change_after(Duration::from_millis(500)).await;
+    assert_eq!(change.len(), 1, "Should be 1 change event (buffered)");
+    assert_eq!(other.len(), 1, "Should be 1 other event (path added)");
+    assert_eq!(total_count, 2, "Should be 2 in total");
+
+    let names = TestCase::file_names(change);
+    assert_eq!(names.len(), 1);
+    assert!(names.contains(&"test_file.css".to_string()));
+    Ok(())
+}
+
+#[actix_rt::test]
+async fn test_buffer_filter() -> Result<(), Box<dyn std::error::Error>> {
+    test_buffer_filter_impl().await
+}

package/crates/bsnext_fs/src/watch_path_handler.rs

@@ -0,0 +1,67 @@
+use crate::actor::FsWatcher;
+use crate::{FsEvent, FsEventKind, FsWatchError, PathAddedEvent};
+use actix::{ActorContext, Handler, Recipient};
+use notify::{RecursiveMode, Watcher};
+use std::path::PathBuf;
+
+#[derive(actix::Message)]
+#[rtype(result = "Result<(), FsWatchError>")]
+pub struct RequestWatchPath {
+    pub recipients: Vec<Recipient<FsEvent>>,
+    pub path: PathBuf,
+}
+
+impl Handler<RequestWatchPath> for FsWatcher {
+    type Result = Result<(), FsWatchError>;
+
+    // todo: ensure this isn't sent for every input change
+    fn handle(&mut self, msg: RequestWatchPath, _ctx: &mut Self::Context) -> Self::Result {
+        tracing::trace!(path = ?msg.path, "-> WatchPath");
+        if let Some(watcher) = self.watcher.as_mut() {
+            match watcher.watch(&msg.path, RecursiveMode::Recursive) {
+                Ok(_) => {
+                    let new_recipients = msg
+                        .recipients
+                        .into_iter()
+                        .filter(|r| !self.receivers.contains(r))
+                        .collect::<Vec<_>>();
+                    self.receivers.extend(new_recipients);
+
+                    tracing::debug!(path = ?msg.path, "👀 watching! {} receivers", self.receivers.len());
+                    tracing::debug!(?self.cwd);
+                    tracing::debug!(?self.receivers);
+
+                    let matched = msg.path == self.cwd;
+
+                    let relative = if matched {
+                        msg.path.clone()
+                    } else {
+                        match msg.path.strip_prefix(&self.cwd) {
+                            Ok(stripped) => stripped.to_path_buf(),
+                            Err(e) => {
+                                tracing::debug!(?e, "could not extract the CWD from a path");
+                                msg.path.clone()
+                            }
+                        }
+                    };
+                    for recip in &self.receivers {
+                        let evt = FsEventKind::PathAdded(PathAddedEvent {
+                            path: relative.clone(),
+                            debounce: self.debounce,
+                        });
+                        recip.do_send(FsEvent {
+                            kind: evt,
+                            ctx: self.ctx.clone(),
+                        })
+                    }
+                }
+                Err(err) => {
+                    tracing::error!("cannot watch: {}", err);
+                    _ctx.stop();
+                    return Err(FsWatchError::Watcher(err));
+                }
+            }
+        }
+        Ok(())
+    }
+}