x-bow: better tests and fire_immediately option for signal_stream

Author: wishawa

x-bow/Cargo.toml

@@ -14,4 +14,5 @@ x-bow-macros = { path = "../x-bow-macros/" }
 pin-project-lite = "0.2"
 
 [dev-dependencies]
-futures-lite = "1.13.0"
+futures-lite = "1.13.0"
+pollster = { version = "0.3.0", features = ["macro"] }

x-bow/src/path_ext.rs

@@ -198,9 +198,12 @@ pub trait PathExt: Path {
         UntilChange::new(self.store_wakers(), self)
     }
 
-    /// Get a [Stream][futures_core::Stream] that fires **once now** and once
+    /// Get a [Stream][futures_core::Stream] that fires once
     /// every time the data changes, yielding [Ref]s to the data.
     ///
+    /// If the `fire_immediately` argument is `true`, then the stream will fire
+    /// on the first poll too.
+    ///
     /// The stream ends when the data cannot be borrowed (when [borrow_opt][Self::borrow_opt]
     /// returns None).
     ///
@@ -217,7 +220,7 @@ pub trait PathExt: Path {
     /// # }
     /// // set the text with the current data
     /// // and update the text whenever the data change
-    /// path.signal_stream().for_each(|data: Ref<'_, String>| {
+    /// path.signal_stream(true).for_each(|data: Ref<'_, String>| {
     ///     let s: &str = &**data;
     ///     ui_element.set_text(s);
     /// }).await;
@@ -243,16 +246,16 @@ pub trait PathExt: Path {
     /// # async fn example(path: &impl Path) {
     /// let stream = path.signal_stream();
     /// // is equivalent to
-    /// let stream = futures_lite::stream::once(()) // fire once in the beginning...
+    /// let stream = futures_lite::stream::once(()) // fire immediately in the beginning...
     ///     .chain(path.until_change()) // and after every change
     ///     .map(|_| path.borrow_opt()) // borrow the data into a Ref
     ///     .take_while(Option::is_some) // end the stream if the data is unavailable
     ///     .map(Option::unwrap); // we've already checked that the data isn't none
     /// # }
     /// ```
     #[must_use = "the returned Stream is lazy; poll it or use StreamExt on it"]
-    fn signal_stream(&self) -> signal_stream::SignalStream<'_, Self> {
-        signal_stream::SignalStream::new(self, self.until_change())
+    fn signal_stream(&self, fire_immediately: bool) -> signal_stream::SignalStream<'_, Self> {
+        signal_stream::SignalStream::new(self, self.until_change(), fire_immediately)
     }
 
     /// Execute the given function with the data as argument. Repeat every time

x-bow/src/path_ext/signal_stream.rs

@@ -8,11 +8,16 @@ use crate::{until_change::UntilChange, Path, PathExt};
 pub struct SignalStream<'a, P: Path + ?Sized> {
     path: &'a P,
     until_change: UntilChange<'a>,
+    fire_immediately: bool,
 }
 
 impl<'a, P: Path + ?Sized> SignalStream<'a, P> {
-    pub(super) fn new(path: &'a P, until_change: UntilChange<'a>) -> Self {
-        Self { path, until_change }
+    pub(super) fn new(path: &'a P, until_change: UntilChange<'a>, fire_immediately: bool) -> Self {
+        Self {
+            path,
+            until_change,
+            fire_immediately,
+        }
     }
 }
 
@@ -25,7 +30,9 @@ impl<'a, P: Path + ?Sized> Stream for SignalStream<'a, P> {
     ) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
         let first = !this.until_change.has_been_polled();
-        if first | Pin::new(&mut this.until_change).poll_next(cx).is_ready() {
+        if (first && this.fire_immediately)
+            | Pin::new(&mut this.until_change).poll_next(cx).is_ready()
+        {
             Poll::Ready(this.path.borrow_opt())
         } else {
             Poll::Pending

x-bow/tests/basic_typecheck.rs

@@ -5,7 +5,7 @@ use x_bow::Trackable;
 
 #[test]
 fn just_leaf() {
-    let mut a: i32 = 5;
+    let a: i32 = 5;
     let store = Store::new(a);
     let _ = async {
         let _ = store.build_path().until_change();
@@ -49,12 +49,12 @@ fn struct_project() {
         let _: String = store.build_path().field_3().t1().borrow().clone();
     }
     let _ = async {
-        store.build_path().field_1().until_change();
-        store.build_path().field_1().field_1().until_change();
-        store.build_path().field_2().until_change();
-        store.build_path().field_3().until_change();
-        store.build_path().field_3().t0().until_change();
-        store.build_path().field_3().t1().until_change();
+        let _ = store.build_path().field_1().until_change();
+        let _ = store.build_path().field_1().field_1().until_change();
+        let _ = store.build_path().field_2().until_change();
+        let _ = store.build_path().field_3().until_change();
+        let _ = store.build_path().field_3().t0().until_change();
+        let _ = store.build_path().field_3().t1().until_change();
     };
 }
 

x-bow/tests/changes.rs

@@ -0,0 +1,206 @@
+mod types;
+mod utils;
+
+use std::pin::pin;
+
+use types::*;
+use utils::{is_all_pending, is_all_ready};
+use x_bow::{PathExt, PathExtGuaranteed, Store};
+
+#[pollster::test]
+async fn regular_changes() {
+    let state = Root::default();
+    let state = Store::new(state);
+    state
+        .build_path()
+        .field_1()
+        .field_12()
+        .borrow_mut()
+        .push(());
+    state
+        .build_path()
+        .field_2()
+        .borrow_mut()
+        .push(Enum2::VariantA(Default::default()));
+    state
+        .build_path()
+        .field_2()
+        .borrow_mut()
+        .push(Enum2::VariantB {
+            field: Default::default(),
+        });
+
+    let stream = state.build_path();
+    let mut stream = pin!(stream.until_change());
+    let stream_1 = state.build_path().field_1();
+    let mut stream_1 = pin!(stream_1.until_change());
+    let stream_1_11 = state.build_path().field_1().field_11();
+    let mut stream_1_11 = pin!(stream_1_11.until_change());
+    let stream_1_12 = state.build_path().field_1().field_12();
+    let mut stream_1_12 = pin!(stream_1_12.until_change());
+    let stream_2 = state.build_path().field_2();
+    let mut stream_2 = pin!(stream_2.until_change());
+    let stream_2_1 = state.build_path().field_2().index(1);
+    let mut stream_2_1 = pin!(stream_2_1.until_change());
+    let stream_2_1_a = state.build_path().field_2().index(1).VariantA_0();
+    let mut stream_2_1_a = pin!(stream_2_1_a.until_change());
+    let stream_2_1_b = state.build_path().field_2().index(1).VariantB_field();
+    let mut stream_2_1_b = pin!(stream_2_1_b.until_change());
+    let stream_2_1_b_d = state
+        .build_path()
+        .field_2()
+        .index(1)
+        .VariantB_field()
+        .data();
+    let mut stream_2_1_b_d = pin!(stream_2_1_b_d.until_change());
+
+    assert!(
+        is_all_pending([
+            stream.as_mut(),
+            stream_1.as_mut(),
+            stream_1_11.as_mut(),
+            stream_1_12.as_mut(),
+            stream_2.as_mut(),
+            stream_2_1.as_mut(),
+            stream_2_1_a.as_mut(),
+            stream_2_1_b.as_mut(),
+            stream_2_1_b_d.as_mut(),
+        ]),
+        "all pending in the beginning"
+    );
+
+    state.build_path().field_2().borrow_mut();
+
+    assert!(
+        is_all_pending([
+            stream.as_mut(),
+            stream_1.as_mut(),
+            stream_1_11.as_mut(),
+            stream_1_12.as_mut(),
+        ]),
+        "field_1 not woken by field_2 change"
+    );
+    assert!(
+        is_all_ready([
+            stream_2.as_mut(),
+            stream_2_1.as_mut(),
+            stream_2_1_a.as_mut(),
+            stream_2_1_b.as_mut(),
+            stream_2_1_b_d.as_mut(),
+        ]),
+        "field_2 and descendants all woken"
+    );
+    assert!(
+        is_all_pending([
+            stream_2.as_mut(),
+            stream_2_1.as_mut(),
+            stream_2_1_a.as_mut(),
+            stream_2_1_b.as_mut(),
+            stream_2_1_b_d.as_mut(),
+        ]),
+        "woken once, pending later"
+    );
+
+    state.build_path().field_1().borrow_mut();
+    assert!(
+        is_all_ready([
+            stream_1.as_mut(),
+            stream_1_11.as_mut(),
+            stream_1_12.as_mut(),
+        ]),
+        "field_1 and descendants all woken"
+    );
+    assert!(
+        is_all_pending([
+            stream.as_mut(),
+            stream_2.as_mut(),
+            stream_2_1.as_mut(),
+            stream_2_1_a.as_mut(),
+            stream_2_1_b.as_mut(),
+            stream_2_1_b_d.as_mut(),
+        ]),
+        "field_2 not woken by field_1 change"
+    );
+
+    state.build_path().borrow_mut();
+    assert!(
+        is_all_ready([
+            stream.as_mut(),
+            stream_1.as_mut(),
+            stream_1_11.as_mut(),
+            stream_1_12.as_mut(),
+            stream_2.as_mut(),
+            stream_2_1.as_mut(),
+            stream_2_1_a.as_mut(),
+            stream_2_1_b.as_mut(),
+            stream_2_1_b_d.as_mut(),
+        ]),
+        "all ready after root change"
+    );
+
+    {
+        let deep_stream = state.build_path().field_1().field_12().index(0);
+        let mut deep_stream = pin!(deep_stream.until_change());
+        assert!(
+            is_all_pending([deep_stream.as_mut()]),
+            "deep stream starts off pending"
+        );
+        state
+            .build_path()
+            .field_1()
+            .field_12()
+            .index(0)
+            .borrow_opt_mut();
+        assert!(
+            is_all_pending([
+                stream.as_mut(),
+                stream_1.as_mut(),
+                stream_1_11.as_mut(),
+                stream_1_12.as_mut(),
+                stream_2.as_mut(),
+                stream_2_1.as_mut(),
+                stream_2_1_a.as_mut(),
+                stream_2_1_b.as_mut(),
+                stream_2_1_b_d.as_mut(),
+            ]),
+            "deep change wakes no one above"
+        );
+        assert!(
+            is_all_ready([deep_stream.as_mut()]),
+            "the deep change is woken"
+        );
+    }
+
+    {
+        let deep_stream = state.build_path().field_1().field_12().index(1);
+        let mut deep_stream = pin!(deep_stream.until_change());
+        assert!(
+            is_all_pending([deep_stream.as_mut()]),
+            "deep stream starts off pending"
+        );
+        state
+            .build_path()
+            .field_1()
+            .field_12()
+            .index(1)
+            .borrow_opt_mut();
+        assert!(
+            is_all_pending([
+                stream.as_mut(),
+                stream_1.as_mut(),
+                stream_1_11.as_mut(),
+                stream_1_12.as_mut(),
+                stream_2.as_mut(),
+                stream_2_1.as_mut(),
+                stream_2_1_a.as_mut(),
+                stream_2_1_b.as_mut(),
+                stream_2_1_b_d.as_mut(),
+            ]),
+            "deep change wakes no one above"
+        );
+        assert!(
+            is_all_pending([deep_stream.as_mut()]),
+            "the deep change is not woken because borrow_opt_mut failed"
+        );
+    }
+}

x-bow/tests/types.rs

@@ -0,0 +1,37 @@
+use std::collections::HashMap;
+
+use x_bow::Trackable;
+
+#[derive(Trackable, Default)]
+#[track(deep)]
+pub struct Root {
+    pub field_1: Struct1,
+    pub field_2: Vec<Enum2>,
+}
+
+#[derive(Trackable, Default)]
+#[track(deep)]
+pub struct Struct1 {
+    pub field_11: String,
+    pub field_12: Vec<()>,
+}
+
+#[derive(Trackable, Default)]
+#[track(deep)]
+pub struct Struct3<T> {
+    pub data: HashMap<i32, T>,
+}
+
+#[derive(Trackable)]
+#[track(deep)]
+pub enum Enum2 {
+    VariantA(Struct1),
+    VariantB { field: Struct3<String> },
+    VariantC,
+}
+
+impl Default for Enum2 {
+    fn default() -> Self {
+        Self::VariantC
+    }
+}

x-bow/tests/utils.rs

@@ -0,0 +1,18 @@
+use core::{pin::Pin, task::Context};
+
+use async_ui_internal_utils::dummy_waker::dummy_waker;
+use futures_core::Stream;
+
+pub fn is_ready(s: Pin<&mut dyn Stream<Item = ()>>) -> bool {
+    let waker = dummy_waker();
+    let mut ctx = Context::from_waker(&waker);
+    s.poll_next(&mut ctx).is_ready()
+}
+
+pub fn is_all_pending<const N: usize>(s: [Pin<&mut dyn Stream<Item = ()>>; N]) -> bool {
+    s.into_iter().all(|one| !is_ready(one))
+}
+
+pub fn is_all_ready<const N: usize>(s: [Pin<&mut dyn Stream<Item = ()>>; N]) -> bool {
+    s.into_iter().all(|one| is_ready(one))
+}