@browsersync/bslive 0.0.13 → 0.0.15

package/crates/bsnext_fs/src/stop_handler.rs

@@ -1,15 +0,0 @@
-use crate::actor::FsWatcher;
-use actix::{ActorContext, Handler};
-
-#[derive(actix::Message, Debug, Clone)]
-#[rtype(result = "()")]
-pub struct StopWatcher;
-
-impl Handler<StopWatcher> for FsWatcher {
-    type Result = ();
-
-    fn handle(&mut self, _msg: StopWatcher, ctx: &mut Self::Context) -> Self::Result {
-        self.watcher = None;
-        ctx.stop();
-    }
-}

package/crates/bsnext_fs/src/stream.rs

@@ -1,167 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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(500)).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

@@ -1,67 +0,0 @@
-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!("{} receivers", self.receivers.len());
-
-                    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(())
-    }
-}