reikland 0.2.0

A serde-compatible Ruby marshal parser and deserializer
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

use serde_core::de::{DeserializeSeed, Visitor};

use super::{Deserializer, ErrorKind, MarshalDeserializeError, map::SymbolNameDeserializer};

pub(crate) struct UnitVariantDeserializer<'de> {
    pub(crate) name: &'de str,
}

impl<'de> serde_core::de::EnumAccess<'de> for UnitVariantDeserializer<'de> {
    type Error = MarshalDeserializeError;
    type Variant = UnitOnly;

    fn variant_seed<V: DeserializeSeed<'de>>(
        self,
        seed: V,
    ) -> Result<(V::Value, Self::Variant), MarshalDeserializeError> {
        let val = seed.deserialize(SymbolNameDeserializer { name: self.name })?;
        Ok((val, UnitOnly))
    }
}

pub(crate) struct UnitOnly;

impl<'de> serde_core::de::VariantAccess<'de> for UnitOnly {
    type Error = MarshalDeserializeError;

    fn unit_variant(self) -> Result<(), MarshalDeserializeError> {
        Ok(())
    }

    fn newtype_variant_seed<T: DeserializeSeed<'de>>(
        self,
        _seed: T,
    ) -> Result<T::Value, MarshalDeserializeError> {
        Err(ErrorKind::TypeMismatch {
            expected: "unit variant",
            got: "newtype variant",
        }
        .into())
    }

    fn tuple_variant<V: Visitor<'de>>(
        self,
        _: usize,
        _: V,
    ) -> Result<V::Value, MarshalDeserializeError> {
        Err(ErrorKind::TypeMismatch {
            expected: "unit variant",
            got: "tuple variant",
        }
        .into())
    }

    fn struct_variant<V: Visitor<'de>>(
        self,
        _: &'static [&'static str],
        _: V,
    ) -> Result<V::Value, MarshalDeserializeError> {
        Err(ErrorKind::TypeMismatch {
            expected: "unit variant",
            got: "struct variant",
        }
        .into())
    }
}

pub(crate) struct MapVariantDeserializer<'de, 'a> {
    pub(crate) de: &'a mut Deserializer<'de>,
}

impl<'de, 'a> serde_core::de::EnumAccess<'de> for MapVariantDeserializer<'de, 'a> {
    type Error = MarshalDeserializeError;
    type Variant = MapVariantAccess<'de, 'a>;

    fn variant_seed<V: DeserializeSeed<'de>>(
        self,
        seed: V,
    ) -> Result<(V::Value, Self::Variant), MarshalDeserializeError> {
        let val = seed.deserialize(&mut *self.de)?;
        Ok((val, MapVariantAccess { de: self.de }))
    }
}

pub(crate) struct MapVariantAccess<'de, 'a> {
    de: &'a mut Deserializer<'de>,
}

impl<'de> serde_core::de::VariantAccess<'de> for MapVariantAccess<'de, '_> {
    type Error = MarshalDeserializeError;

    fn unit_variant(self) -> Result<(), MarshalDeserializeError> {
        Err(ErrorKind::TypeMismatch {
            expected: "variant with data",
            got: "unit",
        }
        .into())
    }

    fn newtype_variant_seed<T: DeserializeSeed<'de>>(
        self,
        seed: T,
    ) -> Result<T::Value, MarshalDeserializeError> {
        seed.deserialize(self.de)
    }

    fn tuple_variant<V: Visitor<'de>>(
        self,
        _: usize,
        visitor: V,
    ) -> Result<V::Value, MarshalDeserializeError> {
        serde_core::Deserializer::deserialize_seq(self.de, visitor)
    }

    fn struct_variant<V: Visitor<'de>>(
        self,
        _: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, MarshalDeserializeError> {
        serde_core::Deserializer::deserialize_map(self.de, visitor)
    }
}