facet-reflect 0.46.5

Build and manipulate values of arbitrary Facet types at runtime while respecting invariants - safe runtime reflection
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

use facet::Facet;
use facet_reflect::Partial;
use facet_testhelpers::{IPanic, test};

#[test]
fn build_with_invariants() -> Result<(), IPanic> {
    #[derive(Facet, PartialEq, Debug)]
    #[facet(invariants = MyNonZeroU8::invariants)]
    struct MyNonZeroU8(u8);

    impl MyNonZeroU8 {
        fn invariants(&self) -> bool {
            self.0 != 0
        }
    }

    let mut partial: Partial<'_> = Partial::alloc::<MyNonZeroU8>()?;
    partial = partial.begin_nth_field(0)?;
    partial = partial.set(42u8)?;
    partial = partial.end()?;
    let wip: MyNonZeroU8 = partial.build()?.materialize::<MyNonZeroU8>()?;
    assert_eq!(wip, MyNonZeroU8(42));

    let mut partial: Partial<'_> = Partial::alloc::<MyNonZeroU8>()?;
    partial = partial.begin_nth_field(0)?;
    partial = partial.set(0_u8)?;
    partial = partial.end()?;
    let result = partial.build();
    assert!(result.is_err());
    Ok(())
}

// Enums don't support invariants, so we test with a struct containing an enum
#[test]
fn build_struct_with_enum_field() -> Result<(), IPanic> {
    #[derive(Facet, PartialEq, Debug)]
    #[repr(C)]
    enum Range {
        Low(u8),
        High(u8),
    }

    #[derive(Facet, PartialEq, Debug)]
    #[facet(invariants = ValidatedRange::invariants)]
    struct ValidatedRange {
        range: Range,
    }

    impl ValidatedRange {
        fn invariants(&self) -> bool {
            match &self.range {
                Range::Low(v) => *v <= 50,
                Range::High(v) => *v > 50,
            }
        }
    }

    // Valid Low variant
    let mut partial: Partial<'_> = Partial::alloc::<ValidatedRange>()?;
    partial = partial.begin_field("range")?;
    partial = partial.select_variant_named("Low")?;
    partial = partial.begin_nth_field(0)?;
    partial = partial.set(25u8)?;
    partial = partial.end()?;
    partial = partial.end()?;
    let value: ValidatedRange = partial.build()?.materialize::<ValidatedRange>()?;
    assert_eq!(value.range, Range::Low(25));

    // Invalid Low variant (too high)
    let mut partial: Partial<'_> = Partial::alloc::<ValidatedRange>()?;
    partial = partial.begin_field("range")?;
    partial = partial.select_variant_named("Low")?;
    partial = partial.begin_nth_field(0)?;
    partial = partial.set(75u8)?;
    partial = partial.end()?;
    partial = partial.end()?;
    let result = partial.build();
    assert!(result.is_err());

    // Valid High variant
    let mut partial: Partial<'_> = Partial::alloc::<ValidatedRange>()?;
    partial = partial.begin_field("range")?;
    partial = partial.select_variant_named("High")?;
    partial = partial.begin_nth_field(0)?;
    partial = partial.set(75u8)?;
    partial = partial.end()?;
    partial = partial.end()?;
    let value: ValidatedRange = partial.build()?.materialize::<ValidatedRange>()?;
    assert_eq!(value.range, Range::High(75));

    // Invalid High variant (too low)
    let mut partial: Partial<'_> = Partial::alloc::<ValidatedRange>()?;
    partial = partial.begin_field("range")?;
    partial = partial.select_variant_named("High")?;
    partial = partial.begin_nth_field(0)?;
    partial = partial.set(25u8)?;
    partial = partial.end()?;
    partial = partial.end()?;
    let result = partial.build();
    assert!(result.is_err());
    Ok(())
}

#[test]
fn build_nested_with_invariants() -> Result<(), IPanic> {
    #[derive(Facet, PartialEq, Debug)]
    #[facet(invariants = Point::invariants)]
    struct Point {
        x: i32,
        y: i32,
    }

    impl Point {
        fn invariants(&self) -> bool {
            // Point must be in first quadrant
            self.x >= 0 && self.y >= 0
        }
    }

    #[derive(Facet, PartialEq, Debug)]
    struct Container {
        point: Point,
    }

    // Valid point
    let mut partial: Partial<'_> = Partial::alloc::<Container>()?;
    partial = partial.begin_field("point")?;
    partial = partial.set_field("x", 10i32)?;
    partial = partial.set_field("y", 20i32)?;
    partial = partial.end()?;
    let container: Container = partial.build()?.materialize::<Container>()?;
    assert_eq!(container.point, Point { x: 10, y: 20 });

    // Invalid point (negative x)
    let mut partial: Partial<'_> = Partial::alloc::<Container>()?;
    partial = partial.begin_field("point")?;
    partial = partial.set_field("x", -10i32)?;
    partial = partial.set_field("y", 20i32)?;
    partial = partial.end()?;
    let result = partial.build();
    assert!(result.is_err());
    Ok(())
}