module 0.3.1

Modular NixOS-style configuration crate.
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

#[allow(unused_imports)]
use crate::test::*;

#[test]
#[cfg(feature = "derive")]
fn test_derive_merge_unit() {
    #[derive(Merge)]
    struct Unit;

    let a = Unit;
    let b = Unit;

    let _: Unit = a.merge(b).unwrap();
}

#[test]
#[cfg(feature = "derive")]
fn test_derive_merge_tuple() {
    #[derive(Default, Merge)]
    struct MyType(Merged, Merged);

    let a = MyType::default();
    let b = MyType::default();

    let c = a.merge(b).unwrap();

    assert!(c.0.0);
    assert!(c.1.0);
}

#[test]
#[cfg(feature = "derive")]
fn test_derive_merge_named() {
    #[derive(Default, Merge)]
    struct MyType {
        a: Merged,
        b: Merged,
        c: Merged,
    }

    let a = MyType::default();
    let b = MyType::default();

    let c = a.merge(b).unwrap();

    assert!(c.a.0);
    assert!(c.b.0);
    assert!(c.c.0);
}

#[test]
#[cfg(feature = "derive")]
fn test_derive_merge_rename() {
    use alloc::string::ToString;

    #[derive(Debug, Default, Merge)]
    struct MyType(#[merge(rename = "foo")] i32);

    let a = MyType::default();
    let b = MyType::default();

    let err = a.merge(b).unwrap_err();

    let mut iter = err.value.components().map(|x| x.to_string());
    assert_eq!(iter.next().as_deref(), Some("foo"));
}

#[test]
#[cfg(feature = "derive")]
fn test_derive_merge_skip() {
    #[derive(Default, Merge)]
    struct MyType {
        #[merge(skip)]
        a: Merged,
        b: Merged,
        c: Merged,
    }

    let a = MyType::default();
    let b = MyType::default();

    let merged = a.merge(b).unwrap();

    assert!(!merged.a.0);
    assert!(merged.b.0);
    assert!(merged.c.0);
}

#[test]
#[cfg(feature = "derive")]
fn test_derive_merge_with() {
    mod custom {
        use super::*;

        pub fn merge(a: i32, b: i32) -> Result<i32, Error> {
            Ok(a + b)
        }

        pub fn merge_ref(a: &mut i32, b: i32) -> Result<(), Error> {
            *a += b;
            Ok(())
        }

        pub mod nested {
            pub use super::{merge, merge_ref};
        }
    }

    #[derive(Merge)]
    struct MyType {
        #[merge(with = custom)]
        a: i32,
        #[merge(with = custom::nested)]
        b: i32,
    }

    let a = MyType { a: 5, b: 12 };
    let b = MyType { a: -2, b: 42 };

    let merged = a.merge(b).unwrap();

    assert_eq!(merged.a, 3);
    assert_eq!(merged.b, 54);
}