1use crate::errors::SimpleError;
2use serde::de::{
3 self, DeserializeSeed, Deserializer, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
4 VariantAccess, Visitor,
5};
6use serde::forward_to_deserialize_any;
7
8#[derive(Debug)]
9pub struct SimpleDeserializer<'de> {
10 input: &'de [String],
11 start: usize,
12 consuming: Option<Result<usize, &'static [&'static str]>>,
14
15 pub option_hatch: Option<&'de str>,
17}
18
19pub fn deserialize<'de, T>(input: &'de [String]) -> Result<T, SimpleError>
20where
21 T: de::Deserialize<'de> + std::fmt::Debug,
22{
23 let mut de = SimpleDeserializer::from_slice(input);
24 let value = T::deserialize(&mut de)?;
25
26 if de.start != input.len() {
27 return Err(SimpleError::TrailingTokens { index: de.start });
28 }
29
30 Ok(value)
31}
32
33impl<'de> SimpleDeserializer<'de> {
34 pub fn from_slice(input: &'de [String]) -> Self {
35 Self {
36 input,
37 start: 0,
38 consuming: None,
39 option_hatch: None,
40 }
41 }
42
43 fn expect_single(&self) -> Result<&'de str, SimpleError> {
44 self.input
45 .get(self.start)
46 .map(|s| s.as_str())
47 .ok_or(SimpleError::ExpectedSingle)
48 }
49
50 fn with_sub<T, F>(
51 &mut self,
52 f: F,
53 consuming: impl Into<Option<Result<usize, &'static [&'static str]>>>,
54 ) -> Result<T, SimpleError>
55 where
56 F: FnOnce(&mut Self) -> Result<T, SimpleError>,
57 {
58 let mut sub = Self {
59 input: &self.input[self.start..],
60 start: 0,
61 consuming: None,
62 option_hatch: self.option_hatch,
63 };
64 sub.consuming = consuming.into();
65 let ret = f(&mut sub)?;
66 self.start += sub.start;
67 Ok(ret)
68 }
69}
70
71macro_rules! impl_number {
72 ($name:ident, $ty:ty, $visit:ident, $expect:literal) => {
73 fn $name<V>(self, visitor: V) -> Result<V::Value, Self::Error>
74 where
75 V: Visitor<'de>,
76 {
77 let s = self.expect_single()?;
78 let v: $ty = s.parse().map_err(|_| SimpleError::InvalidType {
79 expected: $expect,
80 found: s.to_string(),
81 })?;
82 self.start += 1;
83 visitor.$visit(v)
84 }
85 };
86}
87
88impl<'de> Deserializer<'de> for &mut SimpleDeserializer<'de> {
89 type Error = SimpleError;
90
91 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
92 where
93 V: Visitor<'de>,
94 {
95 let remaining = self.input.len() - self.start;
96
97 let no_sequences = matches!(self.consuming, Some(Err(_fields)));
98
99 if remaining > 1 && !no_sequences {
100 return self.deserialize_seq(visitor);
101 }
102
103 if remaining == 0 {
104 return self.deserialize_seq(visitor);
105 }
106
107 let s = &self.input[self.start];
108 let val = if s == "true" {
109 visitor.visit_bool(true)?
110 } else if s == "false" {
111 visitor.visit_bool(false)?
112 } else if s.is_empty() || s == "()" {
113 visitor.visit_unit()?
114 } else if let Ok(i) = s.parse::<i64>() {
115 visitor.visit_i64(i)?
116 } else if let Ok(f) = s.parse::<f64>() {
117 visitor.visit_f64(f)?
118 } else {
119 visitor.visit_str(s)?
120 };
121
122 self.start += 1;
123 Ok(val)
124 }
125
126 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
127 where
128 V: Visitor<'de>,
129 {
130 let s = self.expect_single()?;
131 let val = match s {
135 "true" | "" => visitor.visit_bool(true)?,
136 "false" => visitor.visit_bool(false)?,
137 _ => {
138 return Err(SimpleError::InvalidType {
139 expected: "a boolean",
140 found: s.to_string(),
141 });
142 }
143 };
144 self.start += 1;
145 Ok(val)
146 }
147
148 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
149 where
150 V: Visitor<'de>,
151 {
152 let s = self.expect_single()?;
153 let mut chars = s.chars();
154 let c = chars.next().ok_or(SimpleError::InvalidType {
155 expected: "a char",
156 found: s.to_string(),
157 })?;
158 if chars.next().is_some() {
159 return Err(SimpleError::InvalidType {
160 expected: "a single character",
161 found: s.to_string(),
162 });
163 }
164 self.start += 1;
165 visitor.visit_char(c)
166 }
167
168 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
169 where
170 V: Visitor<'de>,
171 {
172 let val = visitor.visit_str(self.expect_single()?)?;
173 self.start += 1;
174 Ok(val)
175 }
176
177 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
178 where
179 V: Visitor<'de>,
180 {
181 let val = visitor.visit_string(self.expect_single()?.to_string())?;
182 self.start += 1;
183 Ok(val)
184 }
185
186 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
187 where
188 V: Visitor<'de>,
189 {
190 self.deserialize_str(visitor)
191 }
192
193 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
194 where
195 V: Visitor<'de>,
196 {
197 let s = self.expect_single()?;
198 if s.is_empty() || s == "()" {
199 self.start += 1;
200 visitor.visit_unit()
201 } else {
202 Err(SimpleError::InvalidType {
203 expected: "unit",
204 found: s.to_string(),
205 })
206 }
207 }
208
209 fn deserialize_unit_struct<V>(
210 self,
211 _name: &'static str,
212 visitor: V,
213 ) -> Result<V::Value, Self::Error>
214 where
215 V: Visitor<'de>,
216 {
217 self.deserialize_unit(visitor)
218 }
219
220 fn deserialize_newtype_struct<V>(
221 self,
222 _name: &'static str,
223 visitor: V,
224 ) -> Result<V::Value, Self::Error>
225 where
226 V: Visitor<'de>,
227 {
228 visitor.visit_newtype_struct(self)
229 }
230
231 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
232 where
233 V: Visitor<'de>,
234 {
235 if self.start >= self.input.len() {
236 visitor.visit_none()
237 } else if self.option_hatch == Some(&self.input[self.start]) {
238 self.start += 1;
239 visitor.visit_none()
240 } else {
241 visitor.visit_some(self)
242 }
243 }
244
245 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
246 where
247 V: Visitor<'de>,
248 {
249 self.with_sub(|s| visitor.visit_seq(s), None)
250 }
251
252 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
253 where
254 V: Visitor<'de>,
255 {
256 self.with_sub(|s| visitor.visit_seq(s), Ok(len))
257 }
258
259 fn deserialize_tuple_struct<V>(
260 self,
261 _name: &'static str,
262 len: usize,
263 visitor: V,
264 ) -> Result<V::Value, Self::Error>
265 where
266 V: Visitor<'de>,
267 {
268 self.deserialize_tuple(len, visitor)
269 }
270
271 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
272 where
273 V: Visitor<'de>,
274 {
275 self.with_sub(|s| visitor.visit_map(s), None)
276 }
277
278 fn deserialize_struct<V>(
279 self,
280 _name: &'static str,
281 fields: &'static [&'static str],
282 visitor: V,
283 ) -> Result<V::Value, Self::Error>
284 where
285 V: Visitor<'de>,
286 {
287 self.with_sub(|s| visitor.visit_map(s), Err(fields))
288 }
289
290 fn deserialize_enum<V>(
291 self,
292 _name: &'static str,
293 variants: &'static [&'static str],
294 visitor: V,
295 ) -> Result<V::Value, Self::Error>
296 where
297 V: Visitor<'de>,
298 {
299 self.with_sub(|s| visitor.visit_enum(s), Err(variants))
301 }
302
303 impl_number!(deserialize_i8, i8, visit_i8, "an i8");
304 impl_number!(deserialize_i16, i16, visit_i16, "an i16");
305 impl_number!(deserialize_i32, i32, visit_i32, "an i32");
306 impl_number!(deserialize_i64, i64, visit_i64, "an i64");
307 impl_number!(deserialize_u8, u8, visit_u8, "a u8");
308 impl_number!(deserialize_u16, u16, visit_u16, "a u16");
309 impl_number!(deserialize_u32, u32, visit_u32, "a u32");
310 impl_number!(deserialize_u64, u64, visit_u64, "a u64");
311 impl_number!(deserialize_f32, f32, visit_f32, "an f32");
312 impl_number!(deserialize_f64, f64, visit_f64, "an f64");
313
314 forward_to_deserialize_any! { bytes byte_buf ignored_any }
315}
316
317impl<'de> SeqAccess<'de> for &mut SimpleDeserializer<'de> {
320 type Error = SimpleError;
321
322 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
323 where
324 T: DeserializeSeed<'de>,
325 {
326 if let Some(Ok(len)) = self.consuming
327 && len == 0
328 {
329 return Ok(None);
330 }
331
332 if self.start >= self.input.len() {
333 return Ok(None);
334 }
335
336 let val = self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?;
338
339 if let Some(Ok(ref mut len)) = self.consuming {
340 *len -= 1;
341 }
342
343 Ok(Some(val))
344 }
345}
346
347impl<'de> MapAccess<'de> for &mut SimpleDeserializer<'de> {
348 type Error = SimpleError;
349
350 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
351 where
352 K: DeserializeSeed<'de>,
353 {
354 if self.start >= self.input.len() {
355 return Ok(None);
356 }
357
358 let key = if let Some(Err(fields)) = self.consuming {
359 let key = &self.input[self.start];
360 if !fields.contains(&key.as_str()) {
361 return Ok(None);
362 } else {
363 self.start += 1;
364 seed.deserialize(key.clone().into_deserializer())?
365 }
366 } else {
367 self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?
368 };
369
370 Ok(Some(key))
371 }
372
373 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
374 where
375 V: DeserializeSeed<'de>,
376 {
377 let val = self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?;
378 Ok(val)
379 }
380}
381
382impl<'de> EnumAccess<'de> for &mut SimpleDeserializer<'de> {
383 type Error = SimpleError;
384 type Variant = Self;
385
386 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
387 where
388 V: DeserializeSeed<'de>,
389 {
390 let val = self.with_sub(|s| seed.deserialize(s), Err(&[][..]))?;
391 Ok((val, self))
392 }
393}
394
395impl<'de> VariantAccess<'de> for &mut SimpleDeserializer<'de> {
396 type Error = SimpleError;
397
398 fn unit_variant(self) -> Result<(), Self::Error> {
399 Ok(())
400 }
401
402 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
403 where
404 T: DeserializeSeed<'de>,
405 {
406 self.with_sub(|s| seed.deserialize(s), None)
407 }
408
409 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
410 where
411 V: Visitor<'de>,
412 {
413 self.deserialize_tuple(len, visitor)
414 }
415
416 fn struct_variant<V>(
417 self,
418 fields: &'static [&'static str],
419 visitor: V,
420 ) -> Result<V::Value, Self::Error>
421 where
422 V: Visitor<'de>,
423 {
424 self.deserialize_struct("", fields, visitor)
425 }
426}