facet-json 0.46.1

JSON serialization for facet using the new format architecture
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

// Test for issue #1873: Enum variant with #[facet(opaque, proxy = ...)] fails to serialize

use facet::Facet;
use facet_testhelpers::test;
use tendril::StrTendril;

// Simple opaque type that doesn't implement Facet
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OpaqueType {
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Facet)]
pub struct OpaqueTypeProxy {
    pub value: String,
}

impl TryFrom<OpaqueTypeProxy> for OpaqueType {
    type Error = &'static str;
    fn try_from(proxy: OpaqueTypeProxy) -> Result<Self, Self::Error> {
        Ok(OpaqueType { value: proxy.value })
    }
}

#[allow(clippy::infallible_try_from)]
impl TryFrom<&OpaqueType> for OpaqueTypeProxy {
    type Error = std::convert::Infallible;
    fn try_from(opaque: &OpaqueType) -> Result<Self, Self::Error> {
        Ok(OpaqueTypeProxy {
            value: opaque.value.clone(),
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Facet)]
#[repr(u8)]
pub enum PropKey {
    Text,
    Attr(#[facet(opaque, proxy = OpaqueTypeProxy)] OpaqueType),
}

#[derive(Debug, Clone, PartialEq, Eq, Facet)]
#[repr(u8)]
pub enum PropKeyStruct {
    Text,
    Attr {
        #[facet(opaque, proxy = OpaqueTypeProxy)]
        opaque: OpaqueType,
    },
}

// Also test with StrTendril from the original issue
#[derive(Debug, Clone, PartialEq, Eq, Facet)]
pub struct TendrilProxy {
    pub value: String,
}

impl TryFrom<TendrilProxy> for StrTendril {
    type Error = &'static str;
    fn try_from(proxy: TendrilProxy) -> Result<Self, Self::Error> {
        Ok(StrTendril::from(proxy.value))
    }
}

#[allow(clippy::infallible_try_from)]
impl TryFrom<&StrTendril> for TendrilProxy {
    type Error = std::convert::Infallible;
    fn try_from(tendril: &StrTendril) -> Result<Self, Self::Error> {
        Ok(TendrilProxy {
            value: tendril.to_string(),
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Facet)]
#[repr(u8)]
pub enum TendrilKey {
    Text,
    Attr(#[facet(opaque, proxy = TendrilProxy)] StrTendril),
}

#[test]
fn test_simple_opaque_proxy_serializes_alone() {
    let opaque = OpaqueType {
        value: "test".to_string(),
    };
    let proxy = OpaqueTypeProxy::try_from(&opaque).expect("works");
    let json = facet_json::to_string(&proxy).expect("proxy serializes fine");
    assert_eq!(json, r#"{"value":"test"}"#);
}

#[test]
fn test_simple_opaque_proxy_in_enum_tuple_variant() {
    let opaque = OpaqueType {
        value: "class".to_string(),
    };
    let prop_key = PropKey::Attr(opaque);
    let json = facet_json::to_string(&prop_key)
        .expect("enum tuple variant with opaque proxy field should serialize");
    // Should serialize as: {"Attr": {"value":"class"}}
    assert_eq!(json, r#"{"Attr":{"value":"class"}}"#);
}

#[test]
fn test_simple_opaque_proxy_in_enum_struct_variant() {
    let opaque = OpaqueType {
        value: "class".to_string(),
    };
    let prop_key = PropKeyStruct::Attr { opaque };
    let json = facet_json::to_string(&prop_key)
        .expect("enum struct variant with opaque proxy field should serialize");
    // Should serialize as: {"Attr": {"opaque": {"value":"class"}}}
    assert_eq!(json, r#"{"Attr":{"opaque":{"value":"class"}}}"#);
}

#[test]
fn test_enum_unit_variant() {
    let prop_key = PropKey::Text;
    let json = facet_json::to_string(&prop_key).expect("unit variant should serialize");
    assert_eq!(json, r#""Text""#);
}

#[test]
fn test_tendril_proxy_serializes_alone() {
    let tendril = StrTendril::from("class");
    let proxy = TendrilProxy::try_from(&tendril).expect("works");
    let json = facet_json::to_string(&proxy).expect("proxy serializes fine");
    assert_eq!(json, r#"{"value":"class"}"#);
}

#[test]
fn test_tendril_opaque_proxy_in_enum_variant() {
    let tendril = StrTendril::from("class");
    let prop_key = TendrilKey::Attr(tendril);
    let json =
        facet_json::to_string(&prop_key).expect("enum with opaque proxy field should serialize");
    // Should serialize as: {"Attr": {"value":"class"}}
    assert_eq!(json, r#"{"Attr":{"value":"class"}}"#);
}