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

//! Explicitly disallow merging of values.
//!
//! See: [`NoMerge`].

use super::prelude::*;

merge_thin_wrapper! {
    /// An unmergeable value.
    ///
    /// This wrapper can wrap any type and make it "unmergeable". This means
    /// that any attempt to merge it will result in a collision error.
    ///
    /// # Example
    ///
    /// ```rust
    /// # use module::types::NoMerge;
    /// # use module::merge::{Merge, ErrorKind};
    /// let a = NoMerge(vec![0, 1]);
    /// let b = NoMerge(vec![2]);
    ///
    /// let err = a.merge(b).unwrap_err();
    ///
    /// assert_eq!(err.kind, ErrorKind::Collision);
    /// ```
    ///
    /// # serde
    ///
    /// This type deserializes like `T`.
    pub struct NoMerge;
}

impl<T> Merge for NoMerge<T> {
    fn merge(self, _other: Self) -> Result<Self, Error> {
        Err(Error::collision())
    }

    fn merge_ref(&mut self, _other: Self) -> Result<(), Error> {
        Err(Error::collision())
    }
}

#[cfg(feature = "serde")]
mod serde_impl {
    use super::*;

    use serde::de::{Deserialize, Deserializer};

    impl<'de, T> Deserialize<'de> for NoMerge<T>
    where
        T: Deserialize<'de>,
    {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            <T as Deserialize>::deserialize(deserializer).map(Into::into)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test::*;

    #[test]
    fn test_merge() {
        let a = NoMerge(42);
        let b = NoMerge(43);

        let err = a.merge(b).unwrap_err();
        assert_eq!(err.kind, ErrorKind::Collision);
    }
}

#[cfg(test)]
#[cfg(feature = "serde")]
mod serde_tests {
    use super::*;

    #[test]
    fn test_deserialize() {
        let x: NoMerge<i32> = serde_json::from_str("42").unwrap();
        assert_eq!(*x, 42);
    }
}