fluvio_jolt/dsl/
deserialize.rs

1use std::collections::HashSet;
2use std::fmt;
3
4use serde::de::{self, Visitor};
5use serde::{
6    de::{Error as _, Deserializer},
7    Deserialize,
8};
9
10use super::ast::{Rhs, Lhs, Stars};
11
12#[derive(Debug, PartialEq, Eq, Clone)]
13pub enum InfallibleLhs {
14    DollarSign(usize, usize),
15    At(usize, Box<Rhs>),
16    Square(String),
17}
18
19#[derive(Debug, Clone, PartialEq, Eq, Default)]
20pub struct Object {
21    pub infallible: Vec<(InfallibleLhs, Vec<Rhs>)>,
22    pub literal: Vec<(String, REntry)>,
23    pub amp: Vec<((usize, usize), REntry)>,
24    pub pipes: Vec<(Vec<Stars>, REntry)>,
25}
26
27#[derive(Debug, Clone, PartialEq, Eq)]
28pub enum REntry {
29    Obj(Box<Object>),
30    Rhs(Vec<Rhs>),
31    Thrash,
32}
33
34struct RhsVisitor;
35
36impl<'de> Visitor<'de> for RhsVisitor {
37    type Value = Rhs;
38
39    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
40        formatter.write_str("right hand side expression")
41    }
42
43    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
44    where
45        E: de::Error,
46    {
47        self.visit_str(&v)
48    }
49
50    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
51    where
52        E: de::Error,
53    {
54        Rhs::parse(value).map_err(|e| E::custom(format!("failed to parse: {value}.error={e}")))
55    }
56}
57
58impl<'de> Deserialize<'de> for Rhs {
59    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
60    where
61        D: Deserializer<'de>,
62    {
63        deserializer.deserialize_any(RhsVisitor)
64    }
65}
66
67struct RhssVisitor;
68
69impl<'de> Visitor<'de> for RhssVisitor {
70    type Value = Vec<Rhs>;
71
72    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
73        formatter.write_str("Right hand side expression or a array of rhs expressions")
74    }
75
76    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
77    where
78        E: de::Error,
79    {
80        self.visit_str(&v)
81    }
82
83    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
84    where
85        E: de::Error,
86    {
87        let r = Rhs::parse(value)
88            .map_err(|e| E::custom(format!("failed to parse: {value}.error={e}")))?;
89        Ok(vec![r])
90    }
91
92    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
93    where
94        A: de::SeqAccess<'de>,
95    {
96        let mut arr = Vec::new();
97        while let Some(rhs) = seq.next_element::<Rhss>()? {
98            arr.extend_from_slice(&rhs.0);
99        }
100        Ok(arr)
101    }
102}
103
104struct Rhss(Vec<Rhs>);
105
106impl<'de> Deserialize<'de> for Rhss {
107    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
108    where
109        D: Deserializer<'de>,
110    {
111        deserializer.deserialize_any(RhssVisitor).map(Rhss)
112    }
113}
114
115struct ObjectVisitor;
116
117impl<'de> Visitor<'de> for ObjectVisitor {
118    type Value = Object;
119
120    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
121        formatter.write_str("map")
122    }
123
124    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
125    where
126        A: de::MapAccess<'de>,
127        A::Error: de::Error,
128    {
129        let mut obj = Object::default();
130
131        let mut key_set = HashSet::new();
132
133        while let Some(lhs_s) = map.next_key::<String>()? {
134            let lhs = LhsVisitor.visit_str(&lhs_s)?;
135
136            if !key_set.insert(lhs_s) {
137                return Err(A::Error::custom("duplicate lhs"));
138            }
139
140            match lhs {
141                Lhs::DollarSign(idx0, idx1) => {
142                    obj.infallible.push((
143                        InfallibleLhs::DollarSign(idx0, idx1),
144                        map.next_value::<Rhss>()?.0,
145                    ));
146                }
147                Lhs::Amp(idx0, idx1) => {
148                    obj.amp.push(((idx0, idx1), map.next_value()?));
149                }
150                Lhs::At(idx, rhs) => {
151                    obj.infallible
152                        .push((InfallibleLhs::At(idx, rhs), map.next_value::<Rhss>()?.0));
153                }
154                Lhs::Square(lit) => {
155                    obj.infallible
156                        .push((InfallibleLhs::Square(lit), map.next_value::<Rhss>()?.0));
157                }
158                Lhs::Pipes(pipes) => {
159                    obj.pipes.push((pipes, map.next_value()?));
160                }
161                Lhs::Literal(lit) => {
162                    obj.literal.push((lit, map.next_value()?));
163                }
164            }
165        }
166
167        Ok(obj)
168    }
169}
170
171impl<'de> Deserialize<'de> for Object {
172    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
173    where
174        D: Deserializer<'de>,
175    {
176        deserializer.deserialize_map(ObjectVisitor)
177    }
178}
179
180struct LhsVisitor;
181
182impl<'de> Visitor<'de> for LhsVisitor {
183    type Value = Lhs;
184
185    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
186        formatter.write_str("Left hand side expression")
187    }
188
189    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
190    where
191        E: de::Error,
192    {
193        self.visit_str(&v)
194    }
195
196    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
197    where
198        E: de::Error,
199    {
200        Lhs::parse(value).map_err(|e| E::custom(format!("failed to parse: {value}.error={e}")))
201    }
202}
203
204impl<'de> Deserialize<'de> for Lhs {
205    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
206    where
207        D: Deserializer<'de>,
208    {
209        deserializer.deserialize_any(LhsVisitor)
210    }
211}
212
213struct REntryVisitor;
214
215impl<'de> Visitor<'de> for REntryVisitor {
216    type Value = REntry;
217
218    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
219        formatter.write_str("Right hand side object or expression")
220    }
221
222    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
223    where
224        E: de::Error,
225    {
226        self.visit_str(&v)
227    }
228
229    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
230    where
231        E: de::Error,
232    {
233        RhsVisitor.visit_str(value).map(|r| REntry::Rhs(vec![r]))
234    }
235
236    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
237    where
238        A: de::SeqAccess<'de>,
239    {
240        let mut arr = Vec::new();
241
242        while let Some(rhs) = seq.next_element()? {
243            arr.push(rhs);
244        }
245
246        Ok(REntry::Rhs(arr))
247    }
248
249    fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
250    where
251        A: de::MapAccess<'de>,
252    {
253        ObjectVisitor
254            .visit_map(map)
255            .map(|obj| REntry::Obj(Box::new(obj)))
256    }
257
258    fn visit_none<E>(self) -> Result<Self::Value, E>
259    where
260        E: de::Error,
261    {
262        Ok(REntry::Thrash)
263    }
264
265    fn visit_unit<E>(self) -> Result<Self::Value, E>
266    where
267        E: de::Error,
268    {
269        self.visit_none()
270    }
271}
272
273impl<'de> Deserialize<'de> for REntry {
274    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
275    where
276        D: Deserializer<'de>,
277    {
278        deserializer.deserialize_any(REntryVisitor)
279    }
280}
fluvio_jolt/dsl/deserialize.rs

fluvio_jolt/dsl/
deserialize.rs
