oxide_core 0.4.0

Rust engine primitives for Oxide (store, snapshot streams, error model, optional persistence).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use oxide_core::{CoreResult, InitContext, Reducer, ReducerEngine, StateChange};

#[derive(Debug, Clone, PartialEq, Eq)]
struct SlicedState {
    a: u64,
    b: u64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SlicedStateSlice {
    A,
    B,
}

#[derive(Clone)]
enum SlicedAction {
    IncA,
    IncB,
    ExplicitA,
    Full,
}

enum SlicedSideEffect {}

#[derive(Default)]
struct SlicedReducer;

impl Reducer<SlicedStateSlice> for SlicedReducer {
    type State = SlicedState;
    type Action = SlicedAction;
    type SideEffect = SlicedSideEffect;

    async fn init(&mut self, _ctx: InitContext<Self::SideEffect>) {}

    fn reduce(
        &mut self,
        state: &mut Self::State,
        ctx: oxide_core::Context<'_, Self::Action, Self::State, SlicedStateSlice>,
    ) -> CoreResult<StateChange<SlicedStateSlice>> {
        match ctx.input {
            SlicedAction::IncA => {
                state.a = state.a.saturating_add(1);
                Ok(StateChange::Infer)
            }
            SlicedAction::IncB => {
                state.b = state.b.saturating_add(1);
                Ok(StateChange::Infer)
            }
            SlicedAction::ExplicitA => {
                state.a = state.a.saturating_add(1);
                Ok(StateChange::Slices(&[SlicedStateSlice::A]))
            }
            SlicedAction::Full => {
                state.a = state.a.saturating_add(1);
                Ok(StateChange::Full)
            }
        }
    }

    fn effect(
        &mut self,
        _state: &mut Self::State,
        _ctx: oxide_core::Context<'_, Self::SideEffect, Self::State, SlicedStateSlice>,
    ) -> CoreResult<StateChange<SlicedStateSlice>> {
        Ok(StateChange::None)
    }

    fn infer_slices(&self, before: &Self::State, after: &Self::State) -> Vec<SlicedStateSlice> {
        let mut slices = Vec::new();
        if before.a != after.a {
            slices.push(SlicedStateSlice::A);
        }
        if before.b != after.b {
            slices.push(SlicedStateSlice::B);
        }
        slices
    }
}

fn thread_pool() -> &'static flutter_rust_bridge::SimpleThreadPool {
    static POOL: std::sync::OnceLock<flutter_rust_bridge::SimpleThreadPool> =
        std::sync::OnceLock::new();
    POOL.get_or_init(flutter_rust_bridge::SimpleThreadPool::default)
}

fn init_test_runtime() {
    let _ = oxide_core::runtime::init(thread_pool);
    #[cfg(feature = "navigation-binding")]
    {
        let _ = oxide_core::init_navigation();
    }
}

#[tokio::test]
async fn infer_emits_changed_slice() {
    init_test_runtime();

    let engine = ReducerEngine::<SlicedReducer, SlicedStateSlice>::new(
        SlicedReducer::default(),
        SlicedState { a: 0, b: 0 },
    )
    .await
    .unwrap();

    let snap = engine.dispatch(SlicedAction::IncA).await.unwrap();
    assert_eq!(snap.state, SlicedState { a: 1, b: 0 });
    assert_eq!(snap.slices, vec![SlicedStateSlice::A]);

    let snap = engine.dispatch(SlicedAction::IncB).await.unwrap();
    assert_eq!(snap.state, SlicedState { a: 1, b: 1 });
    assert_eq!(snap.slices, vec![SlicedStateSlice::B]);
}

#[tokio::test]
async fn explicit_slices_bypass_inference() {
    init_test_runtime();

    let engine = ReducerEngine::<SlicedReducer, SlicedStateSlice>::new(
        SlicedReducer::default(),
        SlicedState { a: 0, b: 0 },
    )
    .await
    .unwrap();

    let snap = engine.dispatch(SlicedAction::ExplicitA).await.unwrap();
    assert_eq!(snap.state, SlicedState { a: 1, b: 0 });
    assert_eq!(snap.slices, vec![SlicedStateSlice::A]);
}

#[tokio::test]
async fn full_emits_empty_slices() {
    init_test_runtime();

    let engine = ReducerEngine::<SlicedReducer, SlicedStateSlice>::new(
        SlicedReducer::default(),
        SlicedState { a: 0, b: 0 },
    )
    .await
    .unwrap();

    let full = engine.dispatch(SlicedAction::Full).await.unwrap();
    assert_eq!(full.state, SlicedState { a: 1, b: 0 });
    assert!(full.slices.is_empty());
}