1 use std::fmt::Display;
2 use std::fmt::Write as _;
3 
4 use serde::ser;
5 
6 use crate::error::{ConfigError, Result};
7 use crate::value::{Value, ValueKind};
8 use crate::Config;
9 
10 #[derive(Default, Debug)]
11 pub struct ConfigSerializer {
12     keys: Vec<SerKey>,
13     pub output: Config,
14 }
15 
16 #[derive(Debug)]
17 enum SerKey {
18     Named(String),
19     Seq(usize),
20 }
21 
22 /// Serializer for numbered sequences
23 ///
24 /// This wrapper is present when we are outputting a sequence (numbered indices).
25 /// Making this a separate type centralises the handling of sequences
26 /// and ensures we don't have any call sites for `ser::SerializeSeq::serialize_element`
27 /// that don't do the necessary work of `SeqSerializer::new`.
28 ///
29 /// Existence of this wrapper implies that `.0.keys.last()` is
30 /// `Some(SerKey::Seq(next_index))`.
31 pub struct SeqSerializer<'a>(&'a mut ConfigSerializer);
32 
33 impl ConfigSerializer {
serialize_primitive<T>(&mut self, value: T) -> Result<()> where T: Into<Value> + Display,34     fn serialize_primitive<T>(&mut self, value: T) -> Result<()>
35     where
36         T: Into<Value> + Display,
37     {
38         // At some future point we could perhaps retain a cursor into the output `Config`,
39         // rather than reifying the whole thing into a single string with `make_full_key`
40         // and passing that whole path to the `set` method.
41         //
42         // That would be marginally more performant, but more fiddly.
43         let key = self.make_full_key()?;
44 
45         #[allow(deprecated)]
46         self.output.set(&key, value.into())?;
47         Ok(())
48     }
49 
make_full_key(&self) -> Result<String>50     fn make_full_key(&self) -> Result<String> {
51         let mut keys = self.keys.iter();
52 
53         let mut whole = match keys.next() {
54             Some(SerKey::Named(s)) => s.clone(),
55             _ => {
56                 return Err(ConfigError::Message(
57                     "top level is not a struct".to_string(),
58                 ))
59             }
60         };
61 
62         for k in keys {
63             match k {
64                 SerKey::Named(s) => write!(whole, ".{}", s),
65                 SerKey::Seq(i) => write!(whole, "[{}]", i),
66             }
67             .expect("write! to a string failed");
68         }
69 
70         Ok(whole)
71     }
72 
push_key(&mut self, key: &str)73     fn push_key(&mut self, key: &str) {
74         self.keys.push(SerKey::Named(key.to_string()));
75     }
76 
pop_key(&mut self)77     fn pop_key(&mut self) {
78         self.keys.pop();
79     }
80 }
81 
82 impl<'a> ser::Serializer for &'a mut ConfigSerializer {
83     type Ok = ();
84     type Error = ConfigError;
85     type SerializeSeq = SeqSerializer<'a>;
86     type SerializeTuple = SeqSerializer<'a>;
87     type SerializeTupleStruct = SeqSerializer<'a>;
88     type SerializeTupleVariant = SeqSerializer<'a>;
89     type SerializeMap = Self;
90     type SerializeStruct = Self;
91     type SerializeStructVariant = Self;
92 
serialize_bool(self, v: bool) -> Result<Self::Ok>93     fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
94         self.serialize_primitive(v)
95     }
96 
serialize_i8(self, v: i8) -> Result<Self::Ok>97     fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
98         self.serialize_i64(v.into())
99     }
100 
serialize_i16(self, v: i16) -> Result<Self::Ok>101     fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
102         self.serialize_i64(v.into())
103     }
104 
serialize_i32(self, v: i32) -> Result<Self::Ok>105     fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
106         self.serialize_i64(v.into())
107     }
108 
serialize_i64(self, v: i64) -> Result<Self::Ok>109     fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
110         self.serialize_primitive(v)
111     }
112 
serialize_u8(self, v: u8) -> Result<Self::Ok>113     fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
114         self.serialize_u64(v.into())
115     }
116 
serialize_u16(self, v: u16) -> Result<Self::Ok>117     fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
118         self.serialize_u64(v.into())
119     }
120 
serialize_u32(self, v: u32) -> Result<Self::Ok>121     fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
122         self.serialize_u64(v.into())
123     }
124 
serialize_u64(self, v: u64) -> Result<Self::Ok>125     fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
126         if v > (i64::max_value() as u64) {
127             Err(ConfigError::Message(format!(
128                 "value {} is greater than the max {}",
129                 v,
130                 i64::max_value()
131             )))
132         } else {
133             self.serialize_i64(v as i64)
134         }
135     }
136 
serialize_f32(self, v: f32) -> Result<Self::Ok>137     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
138         self.serialize_f64(v.into())
139     }
140 
serialize_f64(self, v: f64) -> Result<Self::Ok>141     fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
142         self.serialize_primitive(v)
143     }
144 
serialize_char(self, v: char) -> Result<Self::Ok>145     fn serialize_char(self, v: char) -> Result<Self::Ok> {
146         self.serialize_primitive(v.to_string())
147     }
148 
serialize_str(self, v: &str) -> Result<Self::Ok>149     fn serialize_str(self, v: &str) -> Result<Self::Ok> {
150         self.serialize_primitive(v.to_string())
151     }
152 
serialize_bytes(self, v: &[u8]) -> Result<Self::Ok>153     fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
154         use serde::ser::SerializeSeq;
155         let mut seq = self.serialize_seq(Some(v.len()))?;
156         for byte in v {
157             seq.serialize_element(byte)?;
158         }
159         seq.end();
160         Ok(())
161     }
162 
serialize_none(self) -> Result<Self::Ok>163     fn serialize_none(self) -> Result<Self::Ok> {
164         self.serialize_unit()
165     }
166 
serialize_some<T>(self, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,167     fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
168     where
169         T: ?Sized + ser::Serialize,
170     {
171         value.serialize(self)
172     }
173 
serialize_unit(self) -> Result<Self::Ok>174     fn serialize_unit(self) -> Result<Self::Ok> {
175         self.serialize_primitive(Value::from(ValueKind::Nil))
176     }
177 
serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok>178     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
179         self.serialize_unit()
180     }
181 
serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<Self::Ok>182     fn serialize_unit_variant(
183         self,
184         _name: &'static str,
185         _variant_index: u32,
186         variant: &'static str,
187     ) -> Result<Self::Ok> {
188         self.serialize_str(variant)
189     }
190 
serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,191     fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
192     where
193         T: ?Sized + ser::Serialize,
194     {
195         value.serialize(self)
196     }
197 
serialize_newtype_variant<T>( self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T, ) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,198     fn serialize_newtype_variant<T>(
199         self,
200         _name: &'static str,
201         _variant_index: u32,
202         variant: &'static str,
203         value: &T,
204     ) -> Result<Self::Ok>
205     where
206         T: ?Sized + ser::Serialize,
207     {
208         self.push_key(variant);
209         value.serialize(&mut *self)?;
210         self.pop_key();
211         Ok(())
212     }
213 
serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq>214     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
215         SeqSerializer::new(self)
216     }
217 
serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple>218     fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
219         self.serialize_seq(Some(len))
220     }
221 
serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result<Self::SerializeTupleStruct>222     fn serialize_tuple_struct(
223         self,
224         _name: &'static str,
225         len: usize,
226     ) -> Result<Self::SerializeTupleStruct> {
227         self.serialize_seq(Some(len))
228     }
229 
serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result<Self::SerializeTupleVariant>230     fn serialize_tuple_variant(
231         self,
232         _name: &'static str,
233         _variant_index: u32,
234         variant: &'static str,
235         len: usize,
236     ) -> Result<Self::SerializeTupleVariant> {
237         self.push_key(variant);
238         self.serialize_seq(Some(len))
239     }
240 
serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap>241     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
242         Ok(self)
243     }
244 
serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct>245     fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
246         self.serialize_map(Some(len))
247     }
248 
serialize_struct_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant>249     fn serialize_struct_variant(
250         self,
251         _name: &'static str,
252         _variant_index: u32,
253         variant: &'static str,
254         _len: usize,
255     ) -> Result<Self::SerializeStructVariant> {
256         self.push_key(variant);
257         Ok(self)
258     }
259 }
260 
261 impl<'a> SeqSerializer<'a> {
new(inner: &'a mut ConfigSerializer) -> Result<Self>262     fn new(inner: &'a mut ConfigSerializer) -> Result<Self> {
263         inner.keys.push(SerKey::Seq(0));
264 
265         Ok(SeqSerializer(inner))
266     }
267 
end(self) -> &'a mut ConfigSerializer268     fn end(self) -> &'a mut ConfigSerializer {
269         // This ought to be Some(SerKey::Seq(..)) but we don't want to panic if we are buggy
270         let _: Option<SerKey> = self.0.keys.pop();
271         self.0
272     }
273 }
274 
275 impl<'a> ser::SerializeSeq for SeqSerializer<'a> {
276     type Ok = ();
277     type Error = ConfigError;
278 
serialize_element<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,279     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
280     where
281         T: ?Sized + ser::Serialize,
282     {
283         value.serialize(&mut *(self.0))?;
284         match self.0.keys.last_mut() {
285             Some(SerKey::Seq(i)) => *i += 1,
286             _ => {
287                 return Err(ConfigError::Message(
288                     "config-rs internal error (ser._element but last not Seq!".to_string(),
289                 ))
290             }
291         };
292         Ok(())
293     }
294 
end(self) -> Result<Self::Ok>295     fn end(self) -> Result<Self::Ok> {
296         self.end();
297         Ok(())
298     }
299 }
300 
301 impl<'a> ser::SerializeTuple for SeqSerializer<'a> {
302     type Ok = ();
303     type Error = ConfigError;
304 
serialize_element<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,305     fn serialize_element<T>(&mut self, value: &T) -> Result<()>
306     where
307         T: ?Sized + ser::Serialize,
308     {
309         ser::SerializeSeq::serialize_element(self, value)
310     }
311 
end(self) -> Result<Self::Ok>312     fn end(self) -> Result<Self::Ok> {
313         ser::SerializeSeq::end(self)
314     }
315 }
316 
317 impl<'a> ser::SerializeTupleStruct for SeqSerializer<'a> {
318     type Ok = ();
319     type Error = ConfigError;
320 
serialize_field<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,321     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
322     where
323         T: ?Sized + ser::Serialize,
324     {
325         ser::SerializeSeq::serialize_element(self, value)
326     }
327 
end(self) -> Result<Self::Ok>328     fn end(self) -> Result<Self::Ok> {
329         ser::SerializeSeq::end(self)
330     }
331 }
332 
333 impl<'a> ser::SerializeTupleVariant for SeqSerializer<'a> {
334     type Ok = ();
335     type Error = ConfigError;
336 
serialize_field<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,337     fn serialize_field<T>(&mut self, value: &T) -> Result<()>
338     where
339         T: ?Sized + ser::Serialize,
340     {
341         ser::SerializeSeq::serialize_element(self, value)
342     }
343 
end(self) -> Result<Self::Ok>344     fn end(self) -> Result<Self::Ok> {
345         let inner = self.end();
346         inner.pop_key();
347         Ok(())
348     }
349 }
350 
351 impl<'a> ser::SerializeMap for &'a mut ConfigSerializer {
352     type Ok = ();
353     type Error = ConfigError;
354 
serialize_key<T>(&mut self, key: &T) -> Result<()> where T: ?Sized + ser::Serialize,355     fn serialize_key<T>(&mut self, key: &T) -> Result<()>
356     where
357         T: ?Sized + ser::Serialize,
358     {
359         let key_serializer = StringKeySerializer;
360         let key = key.serialize(key_serializer)?;
361         self.push_key(&key);
362         Ok(())
363     }
364 
serialize_value<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,365     fn serialize_value<T>(&mut self, value: &T) -> Result<()>
366     where
367         T: ?Sized + ser::Serialize,
368     {
369         value.serialize(&mut **self)?;
370         self.pop_key();
371         Ok(())
372     }
373 
end(self) -> Result<Self::Ok>374     fn end(self) -> Result<Self::Ok> {
375         Ok(())
376     }
377 }
378 
379 impl<'a> ser::SerializeStruct for &'a mut ConfigSerializer {
380     type Ok = ();
381     type Error = ConfigError;
382 
serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,383     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
384     where
385         T: ?Sized + ser::Serialize,
386     {
387         self.push_key(key);
388         value.serialize(&mut **self)?;
389         self.pop_key();
390         Ok(())
391     }
392 
end(self) -> Result<Self::Ok>393     fn end(self) -> Result<Self::Ok> {
394         Ok(())
395     }
396 }
397 
398 impl<'a> ser::SerializeStructVariant for &'a mut ConfigSerializer {
399     type Ok = ();
400     type Error = ConfigError;
401 
serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,402     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
403     where
404         T: ?Sized + ser::Serialize,
405     {
406         self.push_key(key);
407         value.serialize(&mut **self)?;
408         self.pop_key();
409         Ok(())
410     }
411 
end(self) -> Result<Self::Ok>412     fn end(self) -> Result<Self::Ok> {
413         self.pop_key();
414         Ok(())
415     }
416 }
417 
418 pub struct StringKeySerializer;
419 
420 impl ser::Serializer for StringKeySerializer {
421     type Ok = String;
422     type Error = ConfigError;
423     type SerializeSeq = Self;
424     type SerializeTuple = Self;
425     type SerializeTupleStruct = Self;
426     type SerializeTupleVariant = Self;
427     type SerializeMap = Self;
428     type SerializeStruct = Self;
429     type SerializeStructVariant = Self;
430 
serialize_bool(self, v: bool) -> Result<Self::Ok>431     fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
432         Ok(v.to_string())
433     }
434 
serialize_i8(self, v: i8) -> Result<Self::Ok>435     fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
436         Ok(v.to_string())
437     }
438 
serialize_i16(self, v: i16) -> Result<Self::Ok>439     fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
440         Ok(v.to_string())
441     }
442 
serialize_i32(self, v: i32) -> Result<Self::Ok>443     fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
444         Ok(v.to_string())
445     }
446 
serialize_i64(self, v: i64) -> Result<Self::Ok>447     fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
448         Ok(v.to_string())
449     }
450 
serialize_u8(self, v: u8) -> Result<Self::Ok>451     fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
452         Ok(v.to_string())
453     }
454 
serialize_u16(self, v: u16) -> Result<Self::Ok>455     fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
456         Ok(v.to_string())
457     }
458 
serialize_u32(self, v: u32) -> Result<Self::Ok>459     fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
460         Ok(v.to_string())
461     }
462 
serialize_u64(self, v: u64) -> Result<Self::Ok>463     fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
464         Ok(v.to_string())
465     }
466 
serialize_f32(self, v: f32) -> Result<Self::Ok>467     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
468         Ok(v.to_string())
469     }
470 
serialize_f64(self, v: f64) -> Result<Self::Ok>471     fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
472         Ok(v.to_string())
473     }
474 
serialize_char(self, v: char) -> Result<Self::Ok>475     fn serialize_char(self, v: char) -> Result<Self::Ok> {
476         Ok(v.to_string())
477     }
478 
serialize_str(self, v: &str) -> Result<Self::Ok>479     fn serialize_str(self, v: &str) -> Result<Self::Ok> {
480         Ok(v.to_string())
481     }
482 
serialize_bytes(self, v: &[u8]) -> Result<Self::Ok>483     fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> {
484         Ok(String::from_utf8_lossy(v).to_string())
485     }
486 
serialize_none(self) -> Result<Self::Ok>487     fn serialize_none(self) -> Result<Self::Ok> {
488         self.serialize_unit()
489     }
490 
serialize_some<T>(self, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,491     fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
492     where
493         T: ?Sized + ser::Serialize,
494     {
495         value.serialize(self)
496     }
497 
serialize_unit(self) -> Result<Self::Ok>498     fn serialize_unit(self) -> Result<Self::Ok> {
499         Ok(String::new())
500     }
501 
serialize_unit_struct(self, _name: &str) -> Result<Self::Ok>502     fn serialize_unit_struct(self, _name: &str) -> Result<Self::Ok> {
503         self.serialize_unit()
504     }
505 
serialize_unit_variant( self, _name: &str, _variant_index: u32, variant: &str, ) -> Result<Self::Ok>506     fn serialize_unit_variant(
507         self,
508         _name: &str,
509         _variant_index: u32,
510         variant: &str,
511     ) -> Result<Self::Ok> {
512         Ok(variant.to_string())
513     }
514 
serialize_newtype_struct<T>(self, _name: &str, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,515     fn serialize_newtype_struct<T>(self, _name: &str, value: &T) -> Result<Self::Ok>
516     where
517         T: ?Sized + ser::Serialize,
518     {
519         value.serialize(self)
520     }
521 
serialize_newtype_variant<T>( self, _name: &str, _variant_index: u32, _variant: &str, value: &T, ) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,522     fn serialize_newtype_variant<T>(
523         self,
524         _name: &str,
525         _variant_index: u32,
526         _variant: &str,
527         value: &T,
528     ) -> Result<Self::Ok>
529     where
530         T: ?Sized + ser::Serialize,
531     {
532         value.serialize(self)
533     }
534 
serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq>535     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
536         Err(ConfigError::Message(
537             "seq can't serialize to string key".to_string(),
538         ))
539     }
540 
serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple>541     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
542         Err(ConfigError::Message(
543             "tuple can't serialize to string key".to_string(),
544         ))
545     }
546 
serialize_tuple_struct(self, name: &str, _len: usize) -> Result<Self::SerializeTupleStruct>547     fn serialize_tuple_struct(self, name: &str, _len: usize) -> Result<Self::SerializeTupleStruct> {
548         Err(ConfigError::Message(format!(
549             "tuple struct {} can't serialize to string key",
550             name
551         )))
552     }
553 
serialize_tuple_variant( self, name: &str, _variant_index: u32, variant: &str, _len: usize, ) -> Result<Self::SerializeTupleVariant>554     fn serialize_tuple_variant(
555         self,
556         name: &str,
557         _variant_index: u32,
558         variant: &str,
559         _len: usize,
560     ) -> Result<Self::SerializeTupleVariant> {
561         Err(ConfigError::Message(format!(
562             "tuple variant {}::{} can't serialize to string key",
563             name, variant
564         )))
565     }
566 
serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap>567     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
568         Err(ConfigError::Message(
569             "map can't serialize to string key".to_string(),
570         ))
571     }
572 
serialize_struct(self, name: &str, _len: usize) -> Result<Self::SerializeStruct>573     fn serialize_struct(self, name: &str, _len: usize) -> Result<Self::SerializeStruct> {
574         Err(ConfigError::Message(format!(
575             "struct {} can't serialize to string key",
576             name
577         )))
578     }
579 
serialize_struct_variant( self, name: &str, _variant_index: u32, variant: &str, _len: usize, ) -> Result<Self::SerializeStructVariant>580     fn serialize_struct_variant(
581         self,
582         name: &str,
583         _variant_index: u32,
584         variant: &str,
585         _len: usize,
586     ) -> Result<Self::SerializeStructVariant> {
587         Err(ConfigError::Message(format!(
588             "struct variant {}::{} can't serialize to string key",
589             name, variant
590         )))
591     }
592 }
593 
594 impl ser::SerializeSeq for StringKeySerializer {
595     type Ok = String;
596     type Error = ConfigError;
597 
serialize_element<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,598     fn serialize_element<T>(&mut self, _value: &T) -> Result<()>
599     where
600         T: ?Sized + ser::Serialize,
601     {
602         unreachable!()
603     }
604 
end(self) -> Result<Self::Ok>605     fn end(self) -> Result<Self::Ok> {
606         unreachable!()
607     }
608 }
609 
610 impl ser::SerializeTuple for StringKeySerializer {
611     type Ok = String;
612     type Error = ConfigError;
613 
serialize_element<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,614     fn serialize_element<T>(&mut self, _value: &T) -> Result<()>
615     where
616         T: ?Sized + ser::Serialize,
617     {
618         unreachable!()
619     }
620 
end(self) -> Result<Self::Ok>621     fn end(self) -> Result<Self::Ok> {
622         unreachable!()
623     }
624 }
625 
626 impl ser::SerializeTupleStruct for StringKeySerializer {
627     type Ok = String;
628     type Error = ConfigError;
629 
serialize_field<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,630     fn serialize_field<T>(&mut self, _value: &T) -> Result<()>
631     where
632         T: ?Sized + ser::Serialize,
633     {
634         unreachable!()
635     }
636 
end(self) -> Result<Self::Ok>637     fn end(self) -> Result<Self::Ok> {
638         unreachable!()
639     }
640 }
641 
642 impl ser::SerializeTupleVariant for StringKeySerializer {
643     type Ok = String;
644     type Error = ConfigError;
645 
serialize_field<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,646     fn serialize_field<T>(&mut self, _value: &T) -> Result<()>
647     where
648         T: ?Sized + ser::Serialize,
649     {
650         unreachable!()
651     }
652 
end(self) -> Result<Self::Ok>653     fn end(self) -> Result<Self::Ok> {
654         unreachable!()
655     }
656 }
657 
658 impl ser::SerializeMap for StringKeySerializer {
659     type Ok = String;
660     type Error = ConfigError;
661 
serialize_key<T>(&mut self, _key: &T) -> Result<()> where T: ?Sized + ser::Serialize,662     fn serialize_key<T>(&mut self, _key: &T) -> Result<()>
663     where
664         T: ?Sized + ser::Serialize,
665     {
666         unreachable!()
667     }
668 
serialize_value<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,669     fn serialize_value<T>(&mut self, _value: &T) -> Result<()>
670     where
671         T: ?Sized + ser::Serialize,
672     {
673         unreachable!()
674     }
675 
end(self) -> Result<Self::Ok>676     fn end(self) -> Result<Self::Ok> {
677         unreachable!()
678     }
679 }
680 
681 impl ser::SerializeStruct for StringKeySerializer {
682     type Ok = String;
683     type Error = ConfigError;
684 
serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,685     fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()>
686     where
687         T: ?Sized + ser::Serialize,
688     {
689         unreachable!()
690     }
691 
end(self) -> Result<Self::Ok>692     fn end(self) -> Result<Self::Ok> {
693         unreachable!()
694     }
695 }
696 
697 impl ser::SerializeStructVariant for StringKeySerializer {
698     type Ok = String;
699     type Error = ConfigError;
700 
serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,701     fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()>
702     where
703         T: ?Sized + ser::Serialize,
704     {
705         unreachable!()
706     }
707 
end(self) -> Result<Self::Ok>708     fn end(self) -> Result<Self::Ok> {
709         unreachable!()
710     }
711 }
712 
713 #[cfg(test)]
714 mod test {
715     use super::*;
716     use serde::{Deserialize, Serialize};
717 
718     #[test]
test_struct()719     fn test_struct() {
720         #[derive(Debug, Serialize, Deserialize, PartialEq)]
721         struct Test {
722             int: u32,
723             seq: Vec<String>,
724         }
725 
726         let test = Test {
727             int: 1,
728             seq: vec!["a".to_string(), "b".to_string()],
729         };
730         let config = Config::try_from(&test).unwrap();
731 
732         let actual: Test = config.try_deserialize().unwrap();
733         assert_eq!(test, actual);
734     }
735 
736     #[test]
test_nest()737     fn test_nest() {
738         let val = serde_json::json! { {
739             "top": {
740                 "num": 1,
741                 "array": [2],
742                 "nested": [[3,4]],
743                 "deep": [{
744                     "yes": true,
745                 }],
746                 "mixed": [
747                     { "boolish": false, },
748                     42,
749                     ["hi"],
750                     { "inner": 66 },
751                     23,
752                 ],
753             }
754         } };
755         let config = Config::try_from(&val).unwrap();
756         let output: serde_json::Value = config.try_deserialize().unwrap();
757         assert_eq!(val, output);
758     }
759 }
760