freenet-scaffold 0.2.2

Support library for building Freenet apps
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
145
146
147
148
149

use super::*;
use crate as freenet_scaffold;
use serde::Deserialize;

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct ContractualI32(pub i32);

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct ContractualString(pub String);

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct TestStructParameters;

impl ComposableState for ContractualI32 {
    type ParentState = TestStruct;
    type Summary = i32;
    type Delta = i32;
    type Parameters = TestStructParameters;

    fn verify(
        &self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
    ) -> Result<(), String> {
        Ok(())
    }

    fn summarize(
        &self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
    ) -> Self::Summary {
        self.0
    }

    fn delta(
        &self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
        old_state_summary: &Self::Summary,
    ) -> Option<Self::Delta> {
        Some(self.0 - old_state_summary)
    }

    fn apply_delta(
        &mut self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
        delta: &Option<Self::Delta>,
    ) -> Result<(), String> {
        match delta {
            Some(delta) => {
                self.0 += *delta;
                Ok(())
            }
            None => Ok(()),
        }
    }
}

impl ComposableState for ContractualString {
    type ParentState = TestStruct;
    type Summary = String;
    type Delta = String;
    type Parameters = TestStructParameters;

    fn verify(
        &self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
    ) -> Result<(), String> {
        Ok(())
    }

    fn summarize(
        &self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
    ) -> Self::Summary {
        self.0.clone()
    }

    fn delta(
        &self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
        old_state_summary: &Self::Summary,
    ) -> Option<Self::Delta> {
        if self.0 == *old_state_summary {
            Some(String::new())
        } else {
            Some(self.0.clone())
        }
    }

    fn apply_delta(
        &mut self,
        _parent_state: &Self::ParentState,
        _parameters: &Self::Parameters,
        delta: &Option<Self::Delta>,
    ) -> Result<(), String> {
        if let Some(delta) = delta {
            self.0 = delta.clone()
        }
        Ok(())
    }
}

#[composable]
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub struct TestStruct {
    number: ContractualI32,
    text: ContractualString,
}

impl TestStruct {
    fn new(number: i32, text: &str) -> Self {
        TestStruct {
            number: ContractualI32(number),
            text: ContractualString(text.to_string()),
        }
    }
}

#[test]
fn test_contractual_macro() {
    let mut test_struct = TestStruct::new(42, "hello");
    let parameters = TestStructParameters {};

    // Test verify
    assert!(test_struct.verify(&test_struct, &parameters).is_ok());

    // Test summarize
    let summary = test_struct.summarize(&test_struct, &parameters);
    assert_eq!(summary.number, 42);
    assert_eq!(summary.text, "hello");

    // Test delta
    let new_state = TestStruct::new(84, "world");
    let delta = new_state.delta(&test_struct.clone(), &parameters, &summary);
    assert_eq!(delta.clone().unwrap().number, Some(42)); // The delta should be the difference: 84 - 42 = 42
    assert_eq!(delta.clone().unwrap().text, Some("world".to_string()));

    // Test apply_delta
    assert!(test_struct
        .apply_delta(&test_struct.clone(), &parameters, &delta)
        .is_ok());
    assert_eq!(test_struct, new_state);
}