agent_first_data/document/
typed.rs

1//! Fallible serde adapters over the format-independent [`Value`] IR.
2
3#![allow(clippy::items_after_test_module)]
4
5use crate::document::{DocumentError, DocumentResult, Value};
6use serde::{
7    Deserializer, Serialize,
8    de::{self, DeserializeOwned},
9    ser,
10};
11
12/// Deserialize a typed configuration from a value view.
13pub fn from_value<T: DeserializeOwned>(value: &Value, path: &str) -> DocumentResult<T> {
14    T::deserialize(ValueDeserializer(value)).map_err(|error| DocumentError::from_serde(path, error))
15}
16
17/// Serialize a typed configuration into the format-independent value view.
18pub fn to_value<T: Serialize>(value: &T) -> DocumentResult<Value> {
19    value
20        .serialize(ValueSerializer)
21        .map_err(|error| DocumentError::ParseError {
22            format: "serde".to_string(),
23            detail: error.to_string(),
24        })
25}
26
27struct ValueSerializer;
28
29#[derive(Debug)]
30struct SerializeError(String);
31
32impl std::fmt::Display for SerializeError {
33    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34        formatter.write_str(&self.0)
35    }
36}
37
38impl std::error::Error for SerializeError {}
39
40impl serde::ser::Error for SerializeError {
41    fn custom<T: std::fmt::Display>(message: T) -> Self {
42        Self(message.to_string())
43    }
44}
45
46type Result<T, E = SerializeError> = std::result::Result<T, E>;
47
48impl serde::Serializer for ValueSerializer {
49    type Ok = Value;
50    type Error = SerializeError;
51    type SerializeSeq = SequenceSerializer;
52    type SerializeTuple = SequenceSerializer;
53    type SerializeTupleStruct = SequenceSerializer;
54    type SerializeTupleVariant = VariantSequenceSerializer;
55    type SerializeMap = MapSerializer;
56    type SerializeStruct = MapSerializer;
57    type SerializeStructVariant = VariantMapSerializer;
58
59    fn serialize_bool(self, value: bool) -> Result<Value> {
60        Ok(Value::Bool(value))
61    }
62    fn serialize_i8(self, value: i8) -> Result<Value> {
63        Ok(Value::Integer(i64::from(value)))
64    }
65    fn serialize_i16(self, value: i16) -> Result<Value> {
66        Ok(Value::Integer(i64::from(value)))
67    }
68    fn serialize_i32(self, value: i32) -> Result<Value> {
69        Ok(Value::Integer(i64::from(value)))
70    }
71    fn serialize_i64(self, value: i64) -> Result<Value> {
72        Ok(Value::Integer(value))
73    }
74    fn serialize_u8(self, value: u8) -> Result<Value> {
75        Ok(Value::Unsigned(u64::from(value)))
76    }
77    fn serialize_u16(self, value: u16) -> Result<Value> {
78        Ok(Value::Unsigned(u64::from(value)))
79    }
80    fn serialize_u32(self, value: u32) -> Result<Value> {
81        Ok(Value::Unsigned(u64::from(value)))
82    }
83    fn serialize_u64(self, value: u64) -> Result<Value> {
84        Ok(Value::Unsigned(value))
85    }
86    fn serialize_f32(self, value: f32) -> Result<Value> {
87        self.serialize_f64(f64::from(value))
88    }
89    fn serialize_f64(self, value: f64) -> Result<Value> {
90        if value.is_finite() {
91            Ok(Value::Float(value))
92        } else {
93            Err(SerializeError(
94                "non-finite float is not a document value".to_string(),
95            ))
96        }
97    }
98    fn serialize_char(self, value: char) -> Result<Value> {
99        Ok(Value::String(value.to_string()))
100    }
101    fn serialize_str(self, value: &str) -> Result<Value> {
102        Ok(Value::String(value.to_string()))
103    }
104    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
105        Err(SerializeError(
106            "bytes require an explicit string or sequence representation".to_string(),
107        ))
108    }
109    fn serialize_none(self) -> Result<Value> {
110        Ok(Value::Null)
111    }
112    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Value> {
113        value.serialize(self)
114    }
115    fn serialize_unit(self) -> Result<Value> {
116        Ok(Value::Null)
117    }
118    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
119        Ok(Value::Null)
120    }
121    fn serialize_unit_variant(
122        self,
123        _name: &'static str,
124        _index: u32,
125        variant: &'static str,
126    ) -> Result<Value> {
127        Ok(Value::String(variant.to_string()))
128    }
129    fn serialize_newtype_struct<T: ?Sized + Serialize>(
130        self,
131        _name: &'static str,
132        value: &T,
133    ) -> Result<Value> {
134        value.serialize(self)
135    }
136    fn serialize_newtype_variant<T: ?Sized + Serialize>(
137        self,
138        _name: &'static str,
139        _index: u32,
140        variant: &'static str,
141        value: &T,
142    ) -> Result<Value> {
143        let mut map = BTreeMap::new();
144        map.insert(variant.to_string(), value.serialize(ValueSerializer)?);
145        Ok(Value::Object(map))
146    }
147    fn serialize_seq(self, len: Option<usize>) -> Result<SequenceSerializer> {
148        Ok(SequenceSerializer {
149            values: Vec::with_capacity(len.unwrap_or(0)),
150        })
151    }
152    fn serialize_tuple(self, len: usize) -> Result<SequenceSerializer> {
153        self.serialize_seq(Some(len))
154    }
155    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<SequenceSerializer> {
156        self.serialize_seq(Some(len))
157    }
158    fn serialize_tuple_variant(
159        self,
160        _name: &'static str,
161        _index: u32,
162        variant: &'static str,
163        len: usize,
164    ) -> Result<VariantSequenceSerializer> {
165        Ok(VariantSequenceSerializer {
166            variant: variant.to_string(),
167            values: Vec::with_capacity(len),
168        })
169    }
170    fn serialize_map(self, _len: Option<usize>) -> Result<MapSerializer> {
171        Ok(MapSerializer {
172            values: BTreeMap::new(),
173            next_key: None,
174        })
175    }
176    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<MapSerializer> {
177        self.serialize_map(Some(len))
178    }
179    fn serialize_struct_variant(
180        self,
181        _name: &'static str,
182        _index: u32,
183        variant: &'static str,
184        _len: usize,
185    ) -> Result<VariantMapSerializer> {
186        Ok(VariantMapSerializer {
187            variant: variant.to_string(),
188            map: MapSerializer {
189                values: BTreeMap::new(),
190                next_key: None,
191            },
192        })
193    }
194}
195
196use serde::ser::{
197    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
198    SerializeTupleStruct, SerializeTupleVariant,
199};
200use std::collections::BTreeMap;
201
202struct SequenceSerializer {
203    values: Vec<Value>,
204}
205impl SerializeSeq for SequenceSerializer {
206    type Ok = Value;
207    type Error = SerializeError;
208    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
209        self.values.push(value.serialize(ValueSerializer)?);
210        Ok(())
211    }
212    fn end(self) -> Result<Value> {
213        Ok(Value::Array(self.values))
214    }
215}
216impl SerializeTuple for SequenceSerializer {
217    type Ok = Value;
218    type Error = SerializeError;
219    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
220        self.values.push(value.serialize(ValueSerializer)?);
221        Ok(())
222    }
223    fn end(self) -> Result<Value> {
224        Ok(Value::Array(self.values))
225    }
226}
227impl SerializeTupleStruct for SequenceSerializer {
228    type Ok = Value;
229    type Error = SerializeError;
230    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
231        self.values.push(value.serialize(ValueSerializer)?);
232        Ok(())
233    }
234    fn end(self) -> Result<Value> {
235        Ok(Value::Array(self.values))
236    }
237}
238
239struct VariantSequenceSerializer {
240    variant: String,
241    values: Vec<Value>,
242}
243impl SerializeTupleVariant for VariantSequenceSerializer {
244    type Ok = Value;
245    type Error = SerializeError;
246    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
247        self.values.push(value.serialize(ValueSerializer)?);
248        Ok(())
249    }
250    fn end(self) -> Result<Value> {
251        let mut map = BTreeMap::new();
252        map.insert(self.variant, Value::Array(self.values));
253        Ok(Value::Object(map))
254    }
255}
256
257struct MapSerializer {
258    values: BTreeMap<String, Value>,
259    next_key: Option<String>,
260}
261impl SerializeMap for MapSerializer {
262    type Ok = Value;
263    type Error = SerializeError;
264    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<()> {
265        let Value::String(key) = key.serialize(ValueKeySerializer)? else {
266            return Err(SerializeError("map keys must be strings".to_string()));
267        };
268        self.next_key = Some(key);
269        Ok(())
270    }
271    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
272        let key = self
273            .next_key
274            .take()
275            .ok_or_else(|| SerializeError("map value without key".to_string()))?;
276        self.values.insert(key, value.serialize(ValueSerializer)?);
277        Ok(())
278    }
279    fn end(self) -> Result<Value> {
280        Ok(Value::Object(self.values))
281    }
282}
283impl SerializeStruct for MapSerializer {
284    type Ok = Value;
285    type Error = SerializeError;
286    fn serialize_field<T: ?Sized + Serialize>(
287        &mut self,
288        key: &'static str,
289        value: &T,
290    ) -> Result<()> {
291        self.values
292            .insert(key.to_string(), value.serialize(ValueSerializer)?);
293        Ok(())
294    }
295    fn end(self) -> Result<Value> {
296        Ok(Value::Object(self.values))
297    }
298}
299
300struct VariantMapSerializer {
301    variant: String,
302    map: MapSerializer,
303}
304impl SerializeStructVariant for VariantMapSerializer {
305    type Ok = Value;
306    type Error = SerializeError;
307    fn serialize_field<T: ?Sized + Serialize>(
308        &mut self,
309        key: &'static str,
310        value: &T,
311    ) -> Result<()> {
312        self.map.serialize_field(key, value)
313    }
314    fn end(self) -> Result<Value> {
315        let mut outer = BTreeMap::new();
316        outer.insert(self.variant, Value::Object(self.map.values));
317        Ok(Value::Object(outer))
318    }
319}
320
321struct ValueKeySerializer;
322impl serde::Serializer for ValueKeySerializer {
323    type Ok = Value;
324    type Error = SerializeError;
325    type SerializeSeq = ser::Impossible<Value, SerializeError>;
326    type SerializeTuple = ser::Impossible<Value, SerializeError>;
327    type SerializeTupleStruct = ser::Impossible<Value, SerializeError>;
328    type SerializeTupleVariant = ser::Impossible<Value, SerializeError>;
329    type SerializeMap = ser::Impossible<Value, SerializeError>;
330    type SerializeStruct = ser::Impossible<Value, SerializeError>;
331    type SerializeStructVariant = ser::Impossible<Value, SerializeError>;
332    fn serialize_str(self, value: &str) -> Result<Value> {
333        Ok(Value::String(value.to_string()))
334    }
335    fn serialize_bool(self, _: bool) -> Result<Value> {
336        Err(SerializeError("map keys must be strings".to_string()))
337    }
338    fn serialize_i8(self, _: i8) -> Result<Value> {
339        Err(SerializeError("map keys must be strings".to_string()))
340    }
341    fn serialize_i16(self, _: i16) -> Result<Value> {
342        Err(SerializeError("map keys must be strings".to_string()))
343    }
344    fn serialize_i32(self, _: i32) -> Result<Value> {
345        Err(SerializeError("map keys must be strings".to_string()))
346    }
347    fn serialize_i64(self, _: i64) -> Result<Value> {
348        Err(SerializeError("map keys must be strings".to_string()))
349    }
350    fn serialize_u8(self, _: u8) -> Result<Value> {
351        Err(SerializeError("map keys must be strings".to_string()))
352    }
353    fn serialize_u16(self, _: u16) -> Result<Value> {
354        Err(SerializeError("map keys must be strings".to_string()))
355    }
356    fn serialize_u32(self, _: u32) -> Result<Value> {
357        Err(SerializeError("map keys must be strings".to_string()))
358    }
359    fn serialize_u64(self, _: u64) -> Result<Value> {
360        Err(SerializeError("map keys must be strings".to_string()))
361    }
362    fn serialize_f32(self, _: f32) -> Result<Value> {
363        Err(SerializeError("map keys must be strings".to_string()))
364    }
365    fn serialize_f64(self, _: f64) -> Result<Value> {
366        Err(SerializeError("map keys must be strings".to_string()))
367    }
368    fn serialize_char(self, _: char) -> Result<Value> {
369        Err(SerializeError("map keys must be strings".to_string()))
370    }
371    fn serialize_bytes(self, _: &[u8]) -> Result<Value> {
372        Err(SerializeError("map keys must be strings".to_string()))
373    }
374    fn serialize_none(self) -> Result<Value> {
375        Err(SerializeError("map keys must be strings".to_string()))
376    }
377    fn serialize_some<T: ?Sized + Serialize>(self, _: &T) -> Result<Value> {
378        Err(SerializeError("map keys must be strings".to_string()))
379    }
380    fn serialize_unit(self) -> Result<Value> {
381        Err(SerializeError("map keys must be strings".to_string()))
382    }
383    fn serialize_unit_struct(self, _: &'static str) -> Result<Value> {
384        Err(SerializeError("map keys must be strings".to_string()))
385    }
386    fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<Value> {
387        Err(SerializeError("map keys must be strings".to_string()))
388    }
389    fn serialize_newtype_struct<T: ?Sized + Serialize>(
390        self,
391        _: &'static str,
392        _: &T,
393    ) -> Result<Value> {
394        Err(SerializeError("map keys must be strings".to_string()))
395    }
396    fn serialize_newtype_variant<T: ?Sized + Serialize>(
397        self,
398        _: &'static str,
399        _: u32,
400        _: &'static str,
401        _: &T,
402    ) -> Result<Value> {
403        Err(SerializeError("map keys must be strings".to_string()))
404    }
405    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq> {
406        Err(SerializeError("map keys must be strings".to_string()))
407    }
408    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple> {
409        Err(SerializeError("map keys must be strings".to_string()))
410    }
411    fn serialize_tuple_struct(
412        self,
413        _: &'static str,
414        _: usize,
415    ) -> Result<Self::SerializeTupleStruct> {
416        Err(SerializeError("map keys must be strings".to_string()))
417    }
418    fn serialize_tuple_variant(
419        self,
420        _: &'static str,
421        _: u32,
422        _: &'static str,
423        _: usize,
424    ) -> Result<Self::SerializeTupleVariant> {
425        Err(SerializeError("map keys must be strings".to_string()))
426    }
427    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap> {
428        Err(SerializeError("map keys must be strings".to_string()))
429    }
430    fn serialize_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeStruct> {
431        Err(SerializeError("map keys must be strings".to_string()))
432    }
433    fn serialize_struct_variant(
434        self,
435        _: &'static str,
436        _: u32,
437        _: &'static str,
438        _: usize,
439    ) -> Result<Self::SerializeStructVariant> {
440        Err(SerializeError("map keys must be strings".to_string()))
441    }
442}
443
444/// Best-effort numeric visit for a [`Value::Number`] literal: integer first
445/// (covers a magnitude-only-oversized integer literal), else lossy `f64`.
446fn visit_number_literal<'de, V: de::Visitor<'de>>(
447    text: &str,
448    visitor: V,
449) -> Result<V::Value, serde::de::value::Error> {
450    if let Ok(value) = text.parse::<i64>() {
451        return visitor.visit_i64(value);
452    }
453    if let Ok(value) = text.parse::<u64>() {
454        return visitor.visit_u64(value);
455    }
456    match text.parse::<f64>() {
457        Ok(value) => visitor.visit_f64(value),
458        Err(_) => Err(de::Error::custom(format!(
459            "invalid numeric literal `{text}`"
460        ))),
461    }
462}
463
464struct ValueDeserializer<'a>(&'a Value);
465
466impl<'de, 'a> serde::Deserializer<'de> for ValueDeserializer<'a>
467where
468    'a: 'de,
469{
470    type Error = serde::de::value::Error;
471
472    fn deserialize_any<V: serde::de::Visitor<'de>>(
473        self,
474        visitor: V,
475    ) -> Result<V::Value, Self::Error> {
476        match self.0 {
477            Value::Null => visitor.visit_unit(),
478            Value::Bool(value) => visitor.visit_bool(*value),
479            Value::Integer(value) => visitor.visit_i64(*value),
480            Value::Unsigned(value) => visitor.visit_u64(*value),
481            Value::Float(value) => visitor.visit_f64(*value),
482            // A `Value::Number` literal only exists because it does not fit
483            // `i64`/`u64`/`f64` cleanly at the source-text level (e.g. an
484            // integer beyond `u64::MAX`), but a typed Rust struct field can
485            // only ever hold one of those three widths anyway — so a
486            // best-effort numeric visit (integer first, else lossy `f64`) is
487            // the most faithful a generic typed decode can be here. Callers
488            // that need the exact digits read the untyped `Value` via
489            // `Value::as_number_literal` instead of decoding through serde.
490            Value::Number(text) => visit_number_literal(text, visitor),
491            Value::String(value) => visitor.visit_string(value.clone()),
492            Value::Array(values) => visitor.visit_seq(BorrowedSeqAccess {
493                values: values.iter(),
494            }),
495            Value::Object(values) => visitor.visit_map(BorrowedMapAccess {
496                values: values.iter(),
497                pending: None,
498            }),
499        }
500    }
501
502    fn deserialize_option<V: serde::de::Visitor<'de>>(
503        self,
504        visitor: V,
505    ) -> Result<V::Value, Self::Error> {
506        if self.0.is_null() {
507            visitor.visit_none()
508        } else {
509            visitor.visit_some(self)
510        }
511    }
512
513    fn deserialize_enum<V: serde::de::Visitor<'de>>(
514        self,
515        _name: &'static str,
516        _variants: &'static [&'static str],
517        visitor: V,
518    ) -> Result<V::Value, Self::Error> {
519        match self.0 {
520            Value::String(variant) => visitor.visit_enum(EnumAccess {
521                variant: variant.clone(),
522                value: None,
523            }),
524            Value::Object(values) if values.len() == 1 => {
525                let mut entries = values.iter();
526                if let Some((variant, value)) = entries.next() {
527                    visitor.visit_enum(EnumAccess {
528                        variant: variant.clone(),
529                        value: Some(value),
530                    })
531                } else {
532                    Err(de::Error::custom("missing enum variant"))
533                }
534            }
535            _ => Err(de::Error::custom(
536                "expected enum variant string or single-key object",
537            )),
538        }
539    }
540
541    serde::forward_to_deserialize_any! {
542        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64
543        char str string bytes byte_buf
544        unit unit_struct newtype_struct seq tuple tuple_struct map struct identifier ignored_any
545    }
546}
547
548struct BorrowedSeqAccess<'a> {
549    values: std::slice::Iter<'a, Value>,
550}
551
552impl<'de, 'a> serde::de::SeqAccess<'de> for BorrowedSeqAccess<'a>
553where
554    'a: 'de,
555{
556    type Error = serde::de::value::Error;
557    fn next_element_seed<T: serde::de::DeserializeSeed<'de>>(
558        &mut self,
559        seed: T,
560    ) -> Result<Option<T::Value>, Self::Error> {
561        self.values
562            .next()
563            .map(|value| seed.deserialize(ValueDeserializer(value)))
564            .transpose()
565    }
566}
567
568struct BorrowedMapAccess<'a> {
569    values: std::collections::btree_map::Iter<'a, String, Value>,
570    pending: Option<&'a Value>,
571}
572
573impl<'de, 'a> serde::de::MapAccess<'de> for BorrowedMapAccess<'a>
574where
575    'a: 'de,
576{
577    type Error = serde::de::value::Error;
578    fn next_key_seed<K: serde::de::DeserializeSeed<'de>>(
579        &mut self,
580        seed: K,
581    ) -> Result<Option<K::Value>, Self::Error> {
582        match self.values.next() {
583            Some((key, value)) => {
584                self.pending = Some(value);
585                seed.deserialize(serde::de::IntoDeserializer::into_deserializer(key.clone()))
586                    .map(Some)
587            }
588            None => Ok(None),
589        }
590    }
591    fn next_value_seed<V: serde::de::DeserializeSeed<'de>>(
592        &mut self,
593        seed: V,
594    ) -> Result<V::Value, Self::Error> {
595        let value = self
596            .pending
597            .take()
598            .ok_or_else(|| de::Error::custom("map value without key"))?;
599        seed.deserialize(ValueDeserializer(value))
600    }
601}
602
603struct EnumAccess<'a> {
604    variant: String,
605    value: Option<&'a Value>,
606}
607
608impl<'de, 'a> serde::de::EnumAccess<'de> for EnumAccess<'a>
609where
610    'a: 'de,
611{
612    type Error = serde::de::value::Error;
613    type Variant = VariantAccess<'a>;
614    fn variant_seed<V: serde::de::DeserializeSeed<'de>>(
615        self,
616        seed: V,
617    ) -> Result<(V::Value, Self::Variant), Self::Error> {
618        let variant =
619            seed.deserialize(serde::de::IntoDeserializer::into_deserializer(self.variant))?;
620        Ok((variant, VariantAccess { value: self.value }))
621    }
622}
623
624struct VariantAccess<'a> {
625    value: Option<&'a Value>,
626}
627
628#[cfg(test)]
629mod tests {
630    use super::{from_value, to_value};
631    use crate::document::Value;
632    use serde::{Deserialize, Serialize};
633
634    #[derive(Debug, PartialEq, Serialize, Deserialize)]
635    struct Config {
636        name: String,
637        enabled: Option<bool>,
638        #[serde(flatten)]
639        extra: Extra,
640    }
641
642    #[derive(Debug, PartialEq, Serialize, Deserialize)]
643    struct Extra {
644        count: u64,
645    }
646
647    #[derive(Debug, PartialEq, Serialize, Deserialize)]
648    enum Mode {
649        Fast,
650        Custom { level: u32 },
651    }
652
653    #[test]
654    fn round_trips_struct_optional_flatten_and_enum() {
655        let value = Value::Object(std::collections::BTreeMap::from([
656            ("name".to_string(), Value::String("demo".to_string())),
657            ("enabled".to_string(), Value::Null),
658            ("count".to_string(), Value::Unsigned(9)),
659        ]));
660        let config: Config = from_value(&value, "root").unwrap_or_else(|error| panic!("{error}"));
661        assert_eq!(config.name, "demo");
662        assert_eq!(config.enabled, None);
663        assert_eq!(config.extra.count, 9);
664        let mode = Mode::Custom { level: 3 };
665        assert_eq!(
666            from_value(&to_value(&mode).unwrap_or(Value::Null), "mode").unwrap_or(Mode::Fast),
667            mode
668        );
669    }
670
671    #[derive(Debug, Deserialize)]
672    #[serde(deny_unknown_fields)]
673    struct Strict {
674        #[allow(dead_code)]
675        name: String,
676    }
677
678    #[test]
679    fn reports_typed_path_and_unknown_field() {
680        let value = Value::Object(std::collections::BTreeMap::from([
681            ("name".to_string(), Value::String("demo".to_string())),
682            ("extra".to_string(), Value::Bool(true)),
683        ]));
684        let error = from_value::<Strict>(&value, "settings").expect_err("unknown field must fail");
685        assert!(error.to_string().contains("settings"));
686        assert!(error.to_string().contains("unknown field"));
687    }
688
689    #[test]
690    fn string_leaves_do_not_guess_typed_scalars() {
691        let value = Value::Object(std::collections::BTreeMap::from([
692            ("enabled".to_string(), Value::String("yes".to_string())),
693            ("count".to_string(), Value::String("42".to_string())),
694        ]));
695        #[derive(Debug, Deserialize, PartialEq)]
696        struct StringBacked {
697            enabled: bool,
698            count: u64,
699        }
700        let error = from_value::<StringBacked>(&value, "env")
701            .expect_err("string-to-bool/number guessing must fail");
702        assert!(error.to_string().contains("env"));
703
704        let leading_zero = Value::String("007".to_string());
705        assert!(from_value::<u64>(&leading_zero, "code").is_err());
706    }
707}
708impl<'de, 'a> serde::de::VariantAccess<'de> for VariantAccess<'a>
709where
710    'a: 'de,
711{
712    type Error = serde::de::value::Error;
713    fn unit_variant(self) -> Result<(), Self::Error> {
714        if self.value.is_none() {
715            Ok(())
716        } else {
717            Err(de::Error::custom("expected unit variant"))
718        }
719    }
720    fn newtype_variant_seed<T: serde::de::DeserializeSeed<'de>>(
721        self,
722        seed: T,
723    ) -> Result<T::Value, Self::Error> {
724        seed.deserialize(ValueDeserializer(
725            self.value
726                .ok_or_else(|| de::Error::custom("missing newtype value"))?,
727        ))
728    }
729    fn tuple_variant<V: serde::de::Visitor<'de>>(
730        self,
731        _len: usize,
732        visitor: V,
733    ) -> Result<V::Value, Self::Error> {
734        ValueDeserializer(
735            self.value
736                .ok_or_else(|| de::Error::custom("missing tuple value"))?,
737        )
738        .deserialize_seq(visitor)
739    }
740    fn struct_variant<V: serde::de::Visitor<'de>>(
741        self,
742        _fields: &'static [&'static str],
743        visitor: V,
744    ) -> Result<V::Value, Self::Error> {
745        ValueDeserializer(
746            self.value
747                .ok_or_else(|| de::Error::custom("missing struct value"))?,
748        )
749        .deserialize_map(visitor)
750    }
751}
agent_first_data/document/typed.rs

agent_first_data/document/
typed.rs
