1 //! Deserializing TOML into Rust structures.
2 //!
3 //! This module contains all the Serde support for deserializing TOML documents
4 //! into Rust structures. Note that some top-level functions here are also
5 //! provided at the top of the crate.
6
7 use std::borrow::Cow;
8 use std::error;
9 use std::f64;
10 use std::fmt;
11 use std::str;
12 use std::vec;
13
14 use serde::de;
15 use serde::de::value::BorrowedStrDeserializer;
16 use serde::de::IntoDeserializer;
17
18 use datetime;
19 use spanned;
20 use tokens::{Error as TokenError, Span, Token, Tokenizer};
21
22 /// Deserializes a byte slice into a type.
23 ///
24 /// This function will attempt to interpret `bytes` as UTF-8 data and then
25 /// deserialize `T` from the TOML document provided.
from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error> where T: de::Deserialize<'de>,26 pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
27 where
28 T: de::Deserialize<'de>,
29 {
30 match str::from_utf8(bytes) {
31 Ok(s) => from_str(s),
32 Err(e) => Err(Error::custom(e.to_string())),
33 }
34 }
35
36 /// Deserializes a string into a type.
37 ///
38 /// This function will attempt to interpret `s` as a TOML document and
39 /// deserialize `T` from the document.
40 ///
41 /// # Examples
42 ///
43 /// ```
44 /// #[macro_use]
45 /// extern crate serde_derive;
46 /// extern crate toml;
47 ///
48 /// #[derive(Deserialize)]
49 /// struct Config {
50 /// title: String,
51 /// owner: Owner,
52 /// }
53 ///
54 /// #[derive(Deserialize)]
55 /// struct Owner {
56 /// name: String,
57 /// }
58 ///
59 /// fn main() {
60 /// let config: Config = toml::from_str(r#"
61 /// title = 'TOML Example'
62 ///
63 /// [owner]
64 /// name = 'Lisa'
65 /// "#).unwrap();
66 ///
67 /// assert_eq!(config.title, "TOML Example");
68 /// assert_eq!(config.owner.name, "Lisa");
69 /// }
70 /// ```
from_str<'de, T>(s: &'de str) -> Result<T, Error> where T: de::Deserialize<'de>,71 pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
72 where
73 T: de::Deserialize<'de>,
74 {
75 let mut d = Deserializer::new(s);
76 let ret = T::deserialize(&mut d)?;
77 d.end()?;
78 Ok(ret)
79 }
80
81 /// Errors that can occur when deserializing a type.
82 #[derive(Debug, PartialEq, Clone)]
83 pub struct Error {
84 inner: Box<ErrorInner>,
85 }
86
87 #[derive(Debug, PartialEq, Clone)]
88 struct ErrorInner {
89 kind: ErrorKind,
90 line: Option<usize>,
91 col: usize,
92 message: String,
93 key: Vec<String>,
94 }
95
96 /// Errors that can occur when deserializing a type.
97 #[derive(Debug, PartialEq, Clone)]
98 enum ErrorKind {
99 /// EOF was reached when looking for a value
100 UnexpectedEof,
101
102 /// An invalid character not allowed in a string was found
103 InvalidCharInString(char),
104
105 /// An invalid character was found as an escape
106 InvalidEscape(char),
107
108 /// An invalid character was found in a hex escape
109 InvalidHexEscape(char),
110
111 /// An invalid escape value was specified in a hex escape in a string.
112 ///
113 /// Valid values are in the plane of unicode codepoints.
114 InvalidEscapeValue(u32),
115
116 /// A newline in a string was encountered when one was not allowed.
117 NewlineInString,
118
119 /// An unexpected character was encountered, typically when looking for a
120 /// value.
121 Unexpected(char),
122
123 /// An unterminated string was found where EOF was found before the ending
124 /// EOF mark.
125 UnterminatedString,
126
127 /// A newline was found in a table key.
128 NewlineInTableKey,
129
130 /// A number failed to parse
131 NumberInvalid,
132
133 /// A date or datetime was invalid
134 DateInvalid,
135
136 /// Wanted one sort of token, but found another.
137 Wanted {
138 /// Expected token type
139 expected: &'static str,
140 /// Actually found token type
141 found: &'static str,
142 },
143
144 /// An array was decoded but the types inside of it were mixed, which is
145 /// disallowed by TOML.
146 MixedArrayType,
147
148 /// A duplicate table definition was found.
149 DuplicateTable(String),
150
151 /// A previously defined table was redefined as an array.
152 RedefineAsArray,
153
154 /// An empty table key was found.
155 EmptyTableKey,
156
157 /// Multiline strings are not allowed for key
158 MultilineStringKey,
159
160 /// A custom error which could be generated when deserializing a particular
161 /// type.
162 Custom,
163
164 /// A tuple with a certain number of elements was expected but something
165 /// else was found.
166 ExpectedTuple(usize),
167
168 /// Expected table keys to be in increasing tuple index order, but something
169 /// else was found.
170 ExpectedTupleIndex {
171 /// Expected index.
172 expected: usize,
173 /// Key that was specified.
174 found: String,
175 },
176
177 /// An empty table was expected but entries were found
178 ExpectedEmptyTable,
179
180 /// Dotted key attempted to extend something that is not a table.
181 DottedKeyInvalidType,
182
183 /// An unexpected key was encountered.
184 ///
185 /// Used when deserializing a struct with a limited set of fields.
186 UnexpectedKeys {
187 /// The unexpected keys.
188 keys: Vec<String>,
189 /// Keys that may be specified.
190 available: &'static [&'static str],
191 },
192
193 #[doc(hidden)]
194 __Nonexhaustive,
195 }
196
197 /// Deserialization implementation for TOML.
198 pub struct Deserializer<'a> {
199 require_newline_after_table: bool,
200 allow_duplciate_after_longer_table: bool,
201 input: &'a str,
202 tokens: Tokenizer<'a>,
203 }
204
205 impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
206 type Error = Error;
207
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,208 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
209 where
210 V: de::Visitor<'de>,
211 {
212 let mut tables = self.tables()?;
213
214 visitor.visit_map(MapVisitor {
215 values: Vec::new().into_iter(),
216 next_value: None,
217 depth: 0,
218 cur: 0,
219 cur_parent: 0,
220 max: tables.len(),
221 tables: &mut tables,
222 array: false,
223 de: self,
224 })
225 }
226
227 // Called when the type to deserialize is an enum, as opposed to a field in the type.
deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,228 fn deserialize_enum<V>(
229 self,
230 _name: &'static str,
231 _variants: &'static [&'static str],
232 visitor: V,
233 ) -> Result<V::Value, Error>
234 where
235 V: de::Visitor<'de>,
236 {
237 let (value, name) = self.string_or_table()?;
238 match value.e {
239 E::String(val) => visitor.visit_enum(val.into_deserializer()),
240 E::InlineTable(values) => {
241 if values.len() != 1 {
242 Err(Error::from_kind(ErrorKind::Wanted {
243 expected: "exactly 1 element",
244 found: if values.is_empty() {
245 "zero elements"
246 } else {
247 "more than 1 element"
248 },
249 }))
250 } else {
251 visitor.visit_enum(InlineTableDeserializer {
252 values: values.into_iter(),
253 next_value: None,
254 })
255 }
256 }
257 E::DottedTable(_) => visitor.visit_enum(DottedTableDeserializer {
258 name: name.expect("Expected table header to be passed."),
259 value: value,
260 }),
261 e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
262 expected: "string or table",
263 found: e.type_name(),
264 })),
265 }
266 }
267
268 forward_to_deserialize_any! {
269 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
270 bytes byte_buf map struct unit newtype_struct
271 ignored_any unit_struct tuple_struct tuple option identifier
272 }
273 }
274
275 struct Table<'a> {
276 at: usize,
277 header: Vec<Cow<'a, str>>,
278 values: Option<Vec<(Cow<'a, str>, Value<'a>)>>,
279 array: bool,
280 }
281
282 #[doc(hidden)]
283 pub struct MapVisitor<'de: 'b, 'b> {
284 values: vec::IntoIter<(Cow<'de, str>, Value<'de>)>,
285 next_value: Option<(Cow<'de, str>, Value<'de>)>,
286 depth: usize,
287 cur: usize,
288 cur_parent: usize,
289 max: usize,
290 tables: &'b mut [Table<'de>],
291 array: bool,
292 de: &'b mut Deserializer<'de>,
293 }
294
295 impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
296 type Error = Error;
297
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,298 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
299 where
300 K: de::DeserializeSeed<'de>,
301 {
302 if self.cur_parent == self.max || self.cur == self.max {
303 return Ok(None);
304 }
305
306 loop {
307 assert!(self.next_value.is_none());
308 if let Some((key, value)) = self.values.next() {
309 let ret = seed.deserialize(StrDeserializer::new(key.clone()))?;
310 self.next_value = Some((key, value));
311 return Ok(Some(ret));
312 }
313
314 let next_table = {
315 let prefix = &self.tables[self.cur_parent].header[..self.depth];
316 self.tables[self.cur..self.max]
317 .iter()
318 .enumerate()
319 .find(|&(_, t)| {
320 if t.values.is_none() {
321 return false;
322 }
323 match t.header.get(..self.depth) {
324 Some(header) => header == prefix,
325 None => false,
326 }
327 })
328 .map(|(i, _)| i + self.cur)
329 };
330
331 let pos = match next_table {
332 Some(pos) => pos,
333 None => return Ok(None),
334 };
335 self.cur = pos;
336
337 // Test to see if we're duplicating our parent's table, and if so
338 // then this is an error in the toml format
339 if self.cur_parent != pos {
340 if self.tables[self.cur_parent].header == self.tables[pos].header {
341 let at = self.tables[pos].at;
342 let name = self.tables[pos].header.join(".");
343 return Err(self.de.error(at, ErrorKind::DuplicateTable(name)));
344 }
345
346 // If we're here we know we should share the same prefix, and if
347 // the longer table was defined first then we want to narrow
348 // down our parent's length if possible to ensure that we catch
349 // duplicate tables defined afterwards.
350 if !self.de.allow_duplciate_after_longer_table {
351 let parent_len = self.tables[self.cur_parent].header.len();
352 let cur_len = self.tables[pos].header.len();
353 if cur_len < parent_len {
354 self.cur_parent = pos;
355 }
356 }
357 }
358
359 let table = &mut self.tables[pos];
360
361 // If we're not yet at the appropriate depth for this table then we
362 // just next the next portion of its header and then continue
363 // decoding.
364 if self.depth != table.header.len() {
365 let key = &table.header[self.depth];
366 let key = seed.deserialize(StrDeserializer::new(key.clone()))?;
367 return Ok(Some(key));
368 }
369
370 // Rule out cases like:
371 //
372 // [[foo.bar]]
373 // [[foo]]
374 if table.array {
375 let kind = ErrorKind::RedefineAsArray;
376 return Err(self.de.error(table.at, kind));
377 }
378
379 self.values = table
380 .values
381 .take()
382 .expect("Unable to read table values")
383 .into_iter();
384 }
385 }
386
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,387 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
388 where
389 V: de::DeserializeSeed<'de>,
390 {
391 if let Some((k, v)) = self.next_value.take() {
392 match seed.deserialize(ValueDeserializer::new(v)) {
393 Ok(v) => return Ok(v),
394 Err(mut e) => {
395 e.add_key_context(&k);
396 return Err(e);
397 }
398 }
399 }
400
401 let array =
402 self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1;
403 self.cur += 1;
404 let res = seed.deserialize(MapVisitor {
405 values: Vec::new().into_iter(),
406 next_value: None,
407 depth: self.depth + if array { 0 } else { 1 },
408 cur_parent: self.cur - 1,
409 cur: 0,
410 max: self.max,
411 array: array,
412 tables: &mut *self.tables,
413 de: &mut *self.de,
414 });
415 res.map_err(|mut e| {
416 e.add_key_context(&self.tables[self.cur - 1].header[self.depth]);
417 e
418 })
419 }
420 }
421
422 impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
423 type Error = Error;
424
next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,425 fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
426 where
427 K: de::DeserializeSeed<'de>,
428 {
429 assert!(self.next_value.is_none());
430 assert!(self.values.next().is_none());
431
432 if self.cur_parent == self.max {
433 return Ok(None);
434 }
435
436 let next = self.tables[..self.max]
437 .iter()
438 .enumerate()
439 .skip(self.cur_parent + 1)
440 .find(|&(_, table)| table.array && table.header == self.tables[self.cur_parent].header)
441 .map(|p| p.0)
442 .unwrap_or(self.max);
443
444 let ret = seed.deserialize(MapVisitor {
445 values: self.tables[self.cur_parent]
446 .values
447 .take()
448 .expect("Unable to read table values")
449 .into_iter(),
450 next_value: None,
451 depth: self.depth + 1,
452 cur_parent: self.cur_parent,
453 max: next,
454 cur: 0,
455 array: false,
456 tables: &mut self.tables,
457 de: &mut self.de,
458 })?;
459 self.cur_parent = next;
460 Ok(Some(ret))
461 }
462 }
463
464 impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
465 type Error = Error;
466
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,467 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
468 where
469 V: de::Visitor<'de>,
470 {
471 if self.array {
472 visitor.visit_seq(self)
473 } else {
474 visitor.visit_map(self)
475 }
476 }
477
478 // `None` is interpreted as a missing field so be sure to implement `Some`
479 // as a present field.
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,480 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
481 where
482 V: de::Visitor<'de>,
483 {
484 visitor.visit_some(self)
485 }
486
deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,487 fn deserialize_newtype_struct<V>(
488 self,
489 _name: &'static str,
490 visitor: V,
491 ) -> Result<V::Value, Error>
492 where
493 V: de::Visitor<'de>,
494 {
495 visitor.visit_newtype_struct(self)
496 }
497
498 forward_to_deserialize_any! {
499 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
500 bytes byte_buf map struct unit identifier
501 ignored_any unit_struct tuple_struct tuple enum
502 }
503 }
504
505 struct StrDeserializer<'a> {
506 key: Cow<'a, str>,
507 }
508
509 impl<'a> StrDeserializer<'a> {
new(key: Cow<'a, str>) -> StrDeserializer<'a>510 fn new(key: Cow<'a, str>) -> StrDeserializer<'a> {
511 StrDeserializer { key: key }
512 }
513 }
514
515 impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
516 type Error = Error;
517
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,518 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
519 where
520 V: de::Visitor<'de>,
521 {
522 match self.key {
523 Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
524 Cow::Owned(s) => visitor.visit_string(s),
525 }
526 }
527
528 forward_to_deserialize_any! {
529 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
530 bytes byte_buf map struct option unit newtype_struct
531 ignored_any unit_struct tuple_struct tuple enum identifier
532 }
533 }
534
535 struct ValueDeserializer<'a> {
536 value: Value<'a>,
537 validate_struct_keys: bool,
538 }
539
540 impl<'a> ValueDeserializer<'a> {
new(value: Value<'a>) -> ValueDeserializer<'a>541 fn new(value: Value<'a>) -> ValueDeserializer<'a> {
542 ValueDeserializer {
543 value: value,
544 validate_struct_keys: false,
545 }
546 }
547
with_struct_key_validation(mut self) -> Self548 fn with_struct_key_validation(mut self) -> Self {
549 self.validate_struct_keys = true;
550 self
551 }
552 }
553
554 impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
555 type Error = Error;
556
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,557 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
558 where
559 V: de::Visitor<'de>,
560 {
561 match self.value.e {
562 E::Integer(i) => visitor.visit_i64(i),
563 E::Boolean(b) => visitor.visit_bool(b),
564 E::Float(f) => visitor.visit_f64(f),
565 E::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
566 E::String(Cow::Owned(s)) => visitor.visit_string(s),
567 E::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
568 date: s,
569 visited: false,
570 }),
571 E::Array(values) => {
572 let mut s = de::value::SeqDeserializer::new(values.into_iter());
573 let ret = visitor.visit_seq(&mut s)?;
574 s.end()?;
575 Ok(ret)
576 }
577 E::InlineTable(values) | E::DottedTable(values) => {
578 visitor.visit_map(InlineTableDeserializer {
579 values: values.into_iter(),
580 next_value: None,
581 })
582 }
583 }
584 }
585
deserialize_struct<V>( self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,586 fn deserialize_struct<V>(
587 self,
588 name: &'static str,
589 fields: &'static [&'static str],
590 visitor: V,
591 ) -> Result<V::Value, Error>
592 where
593 V: de::Visitor<'de>,
594 {
595 if name == datetime::NAME && fields == &[datetime::FIELD] {
596 if let E::Datetime(s) = self.value.e {
597 return visitor.visit_map(DatetimeDeserializer {
598 date: s,
599 visited: false,
600 });
601 }
602 }
603
604 if self.validate_struct_keys {
605 match &self.value.e {
606 &E::InlineTable(ref values) | &E::DottedTable(ref values) => {
607 let extra_fields = values
608 .iter()
609 .filter_map(|key_value| {
610 let (ref key, ref _val) = *key_value;
611 if !fields.contains(&&(**key)) {
612 Some(key.clone())
613 } else {
614 None
615 }
616 })
617 .collect::<Vec<Cow<'de, str>>>();
618
619 if !extra_fields.is_empty() {
620 return Err(Error::from_kind(ErrorKind::UnexpectedKeys {
621 keys: extra_fields
622 .iter()
623 .map(|k| k.to_string())
624 .collect::<Vec<_>>(),
625 available: fields,
626 }));
627 }
628 }
629 _ => {}
630 }
631 }
632
633 if name == spanned::NAME && fields == &[spanned::START, spanned::END, spanned::VALUE] {
634 let start = self.value.start;
635 let end = self.value.end;
636
637 return visitor.visit_map(SpannedDeserializer {
638 start: Some(start),
639 value: Some(self.value),
640 end: Some(end),
641 });
642 }
643
644 self.deserialize_any(visitor)
645 }
646
647 // `None` is interpreted as a missing field so be sure to implement `Some`
648 // as a present field.
deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,649 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
650 where
651 V: de::Visitor<'de>,
652 {
653 visitor.visit_some(self)
654 }
655
deserialize_enum<V>( self, _name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,656 fn deserialize_enum<V>(
657 self,
658 _name: &'static str,
659 _variants: &'static [&'static str],
660 visitor: V,
661 ) -> Result<V::Value, Error>
662 where
663 V: de::Visitor<'de>,
664 {
665 match self.value.e {
666 E::String(val) => visitor.visit_enum(val.into_deserializer()),
667 E::InlineTable(values) => {
668 if values.len() != 1 {
669 Err(Error::from_kind(ErrorKind::Wanted {
670 expected: "exactly 1 element",
671 found: if values.is_empty() {
672 "zero elements"
673 } else {
674 "more than 1 element"
675 },
676 }))
677 } else {
678 visitor.visit_enum(InlineTableDeserializer {
679 values: values.into_iter(),
680 next_value: None,
681 })
682 }
683 }
684 e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
685 expected: "string or inline table",
686 found: e.type_name(),
687 })),
688 }
689 }
690
deserialize_newtype_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value, Error> where V: de::Visitor<'de>,691 fn deserialize_newtype_struct<V>(
692 self,
693 _name: &'static str,
694 visitor: V,
695 ) -> Result<V::Value, Error>
696 where
697 V: de::Visitor<'de>,
698 {
699 visitor.visit_newtype_struct(self)
700 }
701
702 forward_to_deserialize_any! {
703 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
704 bytes byte_buf map unit identifier
705 ignored_any unit_struct tuple_struct tuple
706 }
707 }
708
709 impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
710 type Deserializer = ValueDeserializer<'de>;
711
into_deserializer(self) -> Self::Deserializer712 fn into_deserializer(self) -> Self::Deserializer {
713 ValueDeserializer::new(self)
714 }
715 }
716
717 struct SpannedDeserializer<'a> {
718 start: Option<usize>,
719 end: Option<usize>,
720 value: Option<Value<'a>>,
721 }
722
723 impl<'de> de::MapAccess<'de> for SpannedDeserializer<'de> {
724 type Error = Error;
725
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,726 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
727 where
728 K: de::DeserializeSeed<'de>,
729 {
730 if self.start.is_some() {
731 seed.deserialize(BorrowedStrDeserializer::new(spanned::START))
732 .map(Some)
733 } else if self.end.is_some() {
734 seed.deserialize(BorrowedStrDeserializer::new(spanned::END))
735 .map(Some)
736 } else if self.value.is_some() {
737 seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE))
738 .map(Some)
739 } else {
740 Ok(None)
741 }
742 }
743
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,744 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
745 where
746 V: de::DeserializeSeed<'de>,
747 {
748 if let Some(start) = self.start.take() {
749 seed.deserialize(start.into_deserializer())
750 } else if let Some(end) = self.end.take() {
751 seed.deserialize(end.into_deserializer())
752 } else if let Some(value) = self.value.take() {
753 seed.deserialize(value.into_deserializer())
754 } else {
755 panic!("next_value_seed called before next_key_seed")
756 }
757 }
758 }
759
760 struct DatetimeDeserializer<'a> {
761 visited: bool,
762 date: &'a str,
763 }
764
765 impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
766 type Error = Error;
767
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,768 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
769 where
770 K: de::DeserializeSeed<'de>,
771 {
772 if self.visited {
773 return Ok(None);
774 }
775 self.visited = true;
776 seed.deserialize(DatetimeFieldDeserializer).map(Some)
777 }
778
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,779 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
780 where
781 V: de::DeserializeSeed<'de>,
782 {
783 seed.deserialize(StrDeserializer::new(self.date.into()))
784 }
785 }
786
787 struct DatetimeFieldDeserializer;
788
789 impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
790 type Error = Error;
791
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> where V: de::Visitor<'de>,792 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
793 where
794 V: de::Visitor<'de>,
795 {
796 visitor.visit_borrowed_str(datetime::FIELD)
797 }
798
799 forward_to_deserialize_any! {
800 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
801 bytes byte_buf map struct option unit newtype_struct
802 ignored_any unit_struct tuple_struct tuple enum identifier
803 }
804 }
805
806 struct DottedTableDeserializer<'a> {
807 name: Cow<'a, str>,
808 value: Value<'a>,
809 }
810
811 impl<'de> de::EnumAccess<'de> for DottedTableDeserializer<'de> {
812 type Error = Error;
813 type Variant = TableEnumDeserializer<'de>;
814
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: de::DeserializeSeed<'de>,815 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
816 where
817 V: de::DeserializeSeed<'de>,
818 {
819 let (name, value) = (self.name, self.value);
820 seed.deserialize(StrDeserializer::new(name))
821 .map(|val| (val, TableEnumDeserializer { value: value }))
822 }
823 }
824
825 struct InlineTableDeserializer<'a> {
826 values: vec::IntoIter<(Cow<'a, str>, Value<'a>)>,
827 next_value: Option<Value<'a>>,
828 }
829
830 impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
831 type Error = Error;
832
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> where K: de::DeserializeSeed<'de>,833 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
834 where
835 K: de::DeserializeSeed<'de>,
836 {
837 let (key, value) = match self.values.next() {
838 Some(pair) => pair,
839 None => return Ok(None),
840 };
841 self.next_value = Some(value);
842 seed.deserialize(StrDeserializer::new(key)).map(Some)
843 }
844
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> where V: de::DeserializeSeed<'de>,845 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
846 where
847 V: de::DeserializeSeed<'de>,
848 {
849 let value = self.next_value.take().expect("Unable to read table values");
850 seed.deserialize(ValueDeserializer::new(value))
851 }
852 }
853
854 impl<'de> de::EnumAccess<'de> for InlineTableDeserializer<'de> {
855 type Error = Error;
856 type Variant = TableEnumDeserializer<'de>;
857
variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: de::DeserializeSeed<'de>,858 fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
859 where
860 V: de::DeserializeSeed<'de>,
861 {
862 let (key, value) = match self.values.next() {
863 Some(pair) => pair,
864 None => {
865 return Err(Error::from_kind(ErrorKind::Wanted {
866 expected: "table with exactly 1 entry",
867 found: "empty table",
868 }))
869 }
870 };
871
872 seed.deserialize(StrDeserializer::new(key))
873 .map(|val| (val, TableEnumDeserializer { value: value }))
874 }
875 }
876
877 /// Deserializes table values into enum variants.
878 struct TableEnumDeserializer<'a> {
879 value: Value<'a>,
880 }
881
882 impl<'de> de::VariantAccess<'de> for TableEnumDeserializer<'de> {
883 type Error = Error;
884
unit_variant(self) -> Result<(), Self::Error>885 fn unit_variant(self) -> Result<(), Self::Error> {
886 match self.value.e {
887 E::InlineTable(values) | E::DottedTable(values) => {
888 if values.len() == 0 {
889 Ok(())
890 } else {
891 Err(Error::from_kind(ErrorKind::ExpectedEmptyTable))
892 }
893 }
894 e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
895 expected: "table",
896 found: e.type_name(),
897 })),
898 }
899 }
900
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error> where T: de::DeserializeSeed<'de>,901 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
902 where
903 T: de::DeserializeSeed<'de>,
904 {
905 seed.deserialize(ValueDeserializer::new(self.value))
906 }
907
tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,908 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
909 where
910 V: de::Visitor<'de>,
911 {
912 match self.value.e {
913 E::InlineTable(values) | E::DottedTable(values) => {
914 let tuple_values = values
915 .into_iter()
916 .enumerate()
917 .map(|(index, (key, value))| match key.parse::<usize>() {
918 Ok(key_index) if key_index == index => Ok(value),
919 Ok(_) | Err(_) => Err(Error::from_kind(ErrorKind::ExpectedTupleIndex {
920 expected: index,
921 found: key.to_string(),
922 })),
923 })
924 // Fold all values into a `Vec`, or return the first error.
925 .fold(Ok(Vec::with_capacity(len)), |result, value_result| {
926 result.and_then(move |mut tuple_values| match value_result {
927 Ok(value) => {
928 tuple_values.push(value);
929 Ok(tuple_values)
930 }
931 // `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
932 Err(e) => Err(e),
933 })
934 })?;
935
936 if tuple_values.len() == len {
937 de::Deserializer::deserialize_seq(
938 ValueDeserializer::new(Value {
939 e: E::Array(tuple_values),
940 start: self.value.start,
941 end: self.value.end,
942 }),
943 visitor,
944 )
945 } else {
946 Err(Error::from_kind(ErrorKind::ExpectedTuple(len)))
947 }
948 }
949 e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
950 expected: "table",
951 found: e.type_name(),
952 })),
953 }
954 }
955
struct_variant<V>( self, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: de::Visitor<'de>,956 fn struct_variant<V>(
957 self,
958 fields: &'static [&'static str],
959 visitor: V,
960 ) -> Result<V::Value, Self::Error>
961 where
962 V: de::Visitor<'de>,
963 {
964 de::Deserializer::deserialize_struct(
965 ValueDeserializer::new(self.value).with_struct_key_validation(),
966 "", // TODO: this should be the variant name
967 fields,
968 visitor,
969 )
970 }
971 }
972
973 impl<'a> Deserializer<'a> {
974 /// Creates a new deserializer which will be deserializing the string
975 /// provided.
new(input: &'a str) -> Deserializer<'a>976 pub fn new(input: &'a str) -> Deserializer<'a> {
977 Deserializer {
978 tokens: Tokenizer::new(input),
979 input: input,
980 require_newline_after_table: true,
981 allow_duplciate_after_longer_table: false,
982 }
983 }
984
985 /// The `Deserializer::end` method should be called after a value has been
986 /// fully deserialized. This allows the `Deserializer` to validate that the
987 /// input stream is at the end or that it only has trailing
988 /// whitespace/comments.
end(&mut self) -> Result<(), Error>989 pub fn end(&mut self) -> Result<(), Error> {
990 Ok(())
991 }
992
993 /// Historical versions of toml-rs accidentally allowed a newline after a
994 /// table definition, but the TOML spec requires a newline after a table
995 /// definition header.
996 ///
997 /// This option can be set to `false` (the default is `true`) to emulate
998 /// this behavior for backwards compatibility with older toml-rs versions.
set_require_newline_after_table(&mut self, require: bool)999 pub fn set_require_newline_after_table(&mut self, require: bool) {
1000 self.require_newline_after_table = require;
1001 }
1002
1003 /// Historical versions of toml-rs accidentally allowed a duplicate table
1004 /// header after a longer table header was previously defined. This is
1005 /// invalid according to the TOML spec, however.
1006 ///
1007 /// This option can be set to `true` (the default is `false`) to emulate
1008 /// this behavior for backwards compatibility with older toml-rs versions.
set_allow_duplicate_after_longer_table(&mut self, allow: bool)1009 pub fn set_allow_duplicate_after_longer_table(&mut self, allow: bool) {
1010 self.allow_duplciate_after_longer_table = allow;
1011 }
1012
tables(&mut self) -> Result<Vec<Table<'a>>, Error>1013 fn tables(&mut self) -> Result<Vec<Table<'a>>, Error> {
1014 let mut tables = Vec::new();
1015 let mut cur_table = Table {
1016 at: 0,
1017 header: Vec::new(),
1018 values: None,
1019 array: false,
1020 };
1021
1022 while let Some(line) = self.line()? {
1023 match line {
1024 Line::Table {
1025 at,
1026 mut header,
1027 array,
1028 } => {
1029 if !cur_table.header.is_empty() || cur_table.values.is_some() {
1030 tables.push(cur_table);
1031 }
1032 cur_table = Table {
1033 at: at,
1034 header: Vec::new(),
1035 values: Some(Vec::new()),
1036 array: array,
1037 };
1038 loop {
1039 let part = header.next().map_err(|e| self.token_error(e));
1040 match part? {
1041 Some(part) => cur_table.header.push(part),
1042 None => break,
1043 }
1044 }
1045 }
1046 Line::KeyValue(key, value) => {
1047 if cur_table.values.is_none() {
1048 cur_table.values = Some(Vec::new());
1049 }
1050 self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
1051 }
1052 }
1053 }
1054 if !cur_table.header.is_empty() || cur_table.values.is_some() {
1055 tables.push(cur_table);
1056 }
1057 Ok(tables)
1058 }
1059
line(&mut self) -> Result<Option<Line<'a>>, Error>1060 fn line(&mut self) -> Result<Option<Line<'a>>, Error> {
1061 loop {
1062 self.eat_whitespace()?;
1063 if self.eat_comment()? {
1064 continue;
1065 }
1066 if self.eat(Token::Newline)? {
1067 continue;
1068 }
1069 break;
1070 }
1071
1072 match self.peek()? {
1073 Some((_, Token::LeftBracket)) => self.table_header().map(Some),
1074 Some(_) => self.key_value().map(Some),
1075 None => Ok(None),
1076 }
1077 }
1078
table_header(&mut self) -> Result<Line<'a>, Error>1079 fn table_header(&mut self) -> Result<Line<'a>, Error> {
1080 let start = self.tokens.current();
1081 self.expect(Token::LeftBracket)?;
1082 let array = self.eat(Token::LeftBracket)?;
1083 let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table);
1084 if self.require_newline_after_table {
1085 self.tokens.skip_to_newline();
1086 } else {
1087 loop {
1088 match self.next()? {
1089 Some((_, Token::RightBracket)) => {
1090 if array {
1091 self.eat(Token::RightBracket)?;
1092 }
1093 break;
1094 }
1095 Some((_, Token::Newline)) | None => break,
1096 _ => {}
1097 }
1098 }
1099 self.eat_whitespace()?;
1100 }
1101 Ok(Line::Table {
1102 at: start,
1103 header: ret,
1104 array: array,
1105 })
1106 }
1107
key_value(&mut self) -> Result<Line<'a>, Error>1108 fn key_value(&mut self) -> Result<Line<'a>, Error> {
1109 let key = self.dotted_key()?;
1110 self.eat_whitespace()?;
1111 self.expect(Token::Equals)?;
1112 self.eat_whitespace()?;
1113
1114 let value = self.value()?;
1115 self.eat_whitespace()?;
1116 if !self.eat_comment()? {
1117 self.eat_newline_or_eof()?;
1118 }
1119
1120 Ok(Line::KeyValue(key, value))
1121 }
1122
value(&mut self) -> Result<Value<'a>, Error>1123 fn value(&mut self) -> Result<Value<'a>, Error> {
1124 let at = self.tokens.current();
1125 let value = match self.next()? {
1126 Some((Span { start, end }, Token::String { val, .. })) => Value {
1127 e: E::String(val),
1128 start: start,
1129 end: end,
1130 },
1131 Some((Span { start, end }, Token::Keylike("true"))) => Value {
1132 e: E::Boolean(true),
1133 start: start,
1134 end: end,
1135 },
1136 Some((Span { start, end }, Token::Keylike("false"))) => Value {
1137 e: E::Boolean(false),
1138 start: start,
1139 end: end,
1140 },
1141 Some((span, Token::Keylike(key))) => self.number_or_date(span, key)?,
1142 Some((span, Token::Plus)) => self.number_leading_plus(span)?,
1143 Some((Span { start, .. }, Token::LeftBrace)) => {
1144 self.inline_table().map(|(Span { end, .. }, table)| Value {
1145 e: E::InlineTable(table),
1146 start: start,
1147 end: end,
1148 })?
1149 }
1150 Some((Span { start, .. }, Token::LeftBracket)) => {
1151 self.array().map(|(Span { end, .. }, array)| Value {
1152 e: E::Array(array),
1153 start: start,
1154 end: end,
1155 })?
1156 }
1157 Some(token) => {
1158 return Err(self.error(
1159 at,
1160 ErrorKind::Wanted {
1161 expected: "a value",
1162 found: token.1.describe(),
1163 },
1164 ))
1165 }
1166 None => return Err(self.eof()),
1167 };
1168 Ok(value)
1169 }
1170
number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error>1171 fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> {
1172 if s.contains('T')
1173 || s.contains('t')
1174 || (s.len() > 1 && s[1..].contains('-') && !s.contains("e-") && !s.contains("E-"))
1175 {
1176 self.datetime(span, s, false)
1177 .map(|(Span { start, end }, d)| Value {
1178 e: E::Datetime(d),
1179 start: start,
1180 end: end,
1181 })
1182 } else if self.eat(Token::Colon)? {
1183 self.datetime(span, s, true)
1184 .map(|(Span { start, end }, d)| Value {
1185 e: E::Datetime(d),
1186 start: start,
1187 end: end,
1188 })
1189 } else {
1190 self.number(span, s)
1191 }
1192 }
1193
1194 /// Returns a string or table value type.
1195 ///
1196 /// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
1197 /// structures (tuple, newtype, struct) must be represented as a table.
string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error>1198 fn string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error> {
1199 match self.peek()? {
1200 Some((_, Token::LeftBracket)) => {
1201 let tables = self.tables()?;
1202 if tables.len() != 1 {
1203 return Err(Error::from_kind(ErrorKind::Wanted {
1204 expected: "exactly 1 table",
1205 found: if tables.is_empty() {
1206 "zero tables"
1207 } else {
1208 "more than 1 table"
1209 },
1210 }));
1211 }
1212
1213 let table = tables
1214 .into_iter()
1215 .next()
1216 .expect("Expected exactly one table");
1217 let header = table
1218 .header
1219 .last()
1220 .expect("Expected at least one header value for table.");
1221
1222 let start = table.at;
1223 let end = table
1224 .values
1225 .as_ref()
1226 .and_then(|values| values.last())
1227 .map(|&(_, ref val)| val.end)
1228 .unwrap_or_else(|| header.len());
1229 Ok((
1230 Value {
1231 e: E::DottedTable(table.values.unwrap_or_else(Vec::new)),
1232 start: start,
1233 end: end,
1234 },
1235 Some(header.clone()),
1236 ))
1237 }
1238 Some(_) => self.value().map(|val| (val, None)),
1239 None => Err(self.eof()),
1240 }
1241 }
1242
1243 fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> {
1244 let to_integer = |f| Value {
1245 e: E::Integer(f),
1246 start: start,
1247 end: end,
1248 };
1249 if s.starts_with("0x") {
1250 self.integer(&s[2..], 16).map(to_integer)
1251 } else if s.starts_with("0o") {
1252 self.integer(&s[2..], 8).map(to_integer)
1253 } else if s.starts_with("0b") {
1254 self.integer(&s[2..], 2).map(to_integer)
1255 } else if s.contains('e') || s.contains('E') {
1256 self.float(s, None).map(|f| Value {
1257 e: E::Float(f),
1258 start: start,
1259 end: end,
1260 })
1261 } else if self.eat(Token::Period)? {
1262 let at = self.tokens.current();
1263 match self.next()? {
1264 Some((Span { start, end }, Token::Keylike(after))) => {
1265 self.float(s, Some(after)).map(|f| Value {
1266 e: E::Float(f),
1267 start: start,
1268 end: end,
1269 })
1270 }
1271 _ => Err(self.error(at, ErrorKind::NumberInvalid)),
1272 }
1273 } else if s == "inf" {
1274 Ok(Value {
1275 e: E::Float(f64::INFINITY),
1276 start: start,
1277 end: end,
1278 })
1279 } else if s == "-inf" {
1280 Ok(Value {
1281 e: E::Float(f64::NEG_INFINITY),
1282 start: start,
1283 end: end,
1284 })
1285 } else if s == "nan" {
1286 Ok(Value {
1287 e: E::Float(f64::NAN),
1288 start: start,
1289 end: end,
1290 })
1291 } else if s == "-nan" {
1292 Ok(Value {
1293 e: E::Float(-f64::NAN),
1294 start: start,
1295 end: end,
1296 })
1297 } else {
1298 self.integer(s, 10).map(to_integer)
1299 }
1300 }
1301
1302 fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> {
1303 let start_token = self.tokens.current();
1304 match self.next()? {
1305 Some((Span { end, .. }, Token::Keylike(s))) => self.number(
1306 Span {
1307 start: start,
1308 end: end,
1309 },
1310 s,
1311 ),
1312 _ => Err(self.error(start_token, ErrorKind::NumberInvalid)),
1313 }
1314 }
1315
integer(&self, s: &'a str, radix: u32) -> Result<i64, Error>1316 fn integer(&self, s: &'a str, radix: u32) -> Result<i64, Error> {
1317 let allow_sign = radix == 10;
1318 let allow_leading_zeros = radix != 10;
1319 let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?;
1320 let start = self.tokens.substr_offset(s);
1321 if suffix != "" {
1322 return Err(self.error(start, ErrorKind::NumberInvalid));
1323 }
1324 i64::from_str_radix(&prefix.replace("_", "").trim_left_matches('+'), radix)
1325 .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
1326 }
1327
parse_integer( &self, s: &'a str, allow_sign: bool, allow_leading_zeros: bool, radix: u32, ) -> Result<(&'a str, &'a str), Error>1328 fn parse_integer(
1329 &self,
1330 s: &'a str,
1331 allow_sign: bool,
1332 allow_leading_zeros: bool,
1333 radix: u32,
1334 ) -> Result<(&'a str, &'a str), Error> {
1335 let start = self.tokens.substr_offset(s);
1336
1337 let mut first = true;
1338 let mut first_zero = false;
1339 let mut underscore = false;
1340 let mut end = s.len();
1341 for (i, c) in s.char_indices() {
1342 let at = i + start;
1343 if i == 0 && (c == '+' || c == '-') && allow_sign {
1344 continue;
1345 }
1346
1347 if c == '0' && first {
1348 first_zero = true;
1349 } else if c.to_digit(radix).is_some() {
1350 if !first && first_zero && !allow_leading_zeros {
1351 return Err(self.error(at, ErrorKind::NumberInvalid));
1352 }
1353 underscore = false;
1354 } else if c == '_' && first {
1355 return Err(self.error(at, ErrorKind::NumberInvalid));
1356 } else if c == '_' && !underscore {
1357 underscore = true;
1358 } else {
1359 end = i;
1360 break;
1361 }
1362 first = false;
1363 }
1364 if first || underscore {
1365 return Err(self.error(start, ErrorKind::NumberInvalid));
1366 }
1367 Ok((&s[..end], &s[end..]))
1368 }
1369
float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error>1370 fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> {
1371 let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?;
1372 let start = self.tokens.substr_offset(integral);
1373
1374 let mut fraction = None;
1375 if let Some(after) = after_decimal {
1376 if suffix != "" {
1377 return Err(self.error(start, ErrorKind::NumberInvalid));
1378 }
1379 let (a, b) = self.parse_integer(after, false, true, 10)?;
1380 fraction = Some(a);
1381 suffix = b;
1382 }
1383
1384 let mut exponent = None;
1385 if suffix.starts_with('e') || suffix.starts_with('E') {
1386 let (a, b) = if suffix.len() == 1 {
1387 self.eat(Token::Plus)?;
1388 match self.next()? {
1389 Some((_, Token::Keylike(s))) => self.parse_integer(s, false, false, 10)?,
1390 _ => return Err(self.error(start, ErrorKind::NumberInvalid)),
1391 }
1392 } else {
1393 self.parse_integer(&suffix[1..], true, false, 10)?
1394 };
1395 if b != "" {
1396 return Err(self.error(start, ErrorKind::NumberInvalid));
1397 }
1398 exponent = Some(a);
1399 }
1400
1401 let mut number = integral
1402 .trim_left_matches('+')
1403 .chars()
1404 .filter(|c| *c != '_')
1405 .collect::<String>();
1406 if let Some(fraction) = fraction {
1407 number.push_str(".");
1408 number.extend(fraction.chars().filter(|c| *c != '_'));
1409 }
1410 if let Some(exponent) = exponent {
1411 number.push_str("E");
1412 number.extend(exponent.chars().filter(|c| *c != '_'));
1413 }
1414 number
1415 .parse()
1416 .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
1417 .and_then(|n: f64| {
1418 if n.is_finite() {
1419 Ok(n)
1420 } else {
1421 Err(self.error(start, ErrorKind::NumberInvalid))
1422 }
1423 })
1424 }
1425
datetime( &mut self, mut span: Span, date: &'a str, colon_eaten: bool, ) -> Result<(Span, &'a str), Error>1426 fn datetime(
1427 &mut self,
1428 mut span: Span,
1429 date: &'a str,
1430 colon_eaten: bool,
1431 ) -> Result<(Span, &'a str), Error> {
1432 let start = self.tokens.substr_offset(date);
1433
1434 // Check for space separated date and time.
1435 let mut lookahead = self.tokens.clone();
1436 if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() {
1437 // Check if hour follows.
1438 if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() {
1439 self.next()?; // skip space
1440 self.next()?; // skip keylike hour
1441 }
1442 }
1443
1444 if colon_eaten || self.eat(Token::Colon)? {
1445 // minutes
1446 match self.next()? {
1447 Some((_, Token::Keylike(_))) => {}
1448 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1449 }
1450 // Seconds
1451 self.expect(Token::Colon)?;
1452 match self.next()? {
1453 Some((Span { end, .. }, Token::Keylike(_))) => {
1454 span.end = end;
1455 }
1456 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1457 }
1458 // Fractional seconds
1459 if self.eat(Token::Period)? {
1460 match self.next()? {
1461 Some((Span { end, .. }, Token::Keylike(_))) => {
1462 span.end = end;
1463 }
1464 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1465 }
1466 }
1467
1468 // offset
1469 if self.eat(Token::Plus)? {
1470 match self.next()? {
1471 Some((Span { end, .. }, Token::Keylike(_))) => {
1472 span.end = end;
1473 }
1474 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1475 }
1476 }
1477 if self.eat(Token::Colon)? {
1478 match self.next()? {
1479 Some((Span { end, .. }, Token::Keylike(_))) => {
1480 span.end = end;
1481 }
1482 _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1483 }
1484 }
1485 }
1486
1487 let end = self.tokens.current();
1488 Ok((span, &self.tokens.input()[start..end]))
1489 }
1490
1491 // TODO(#140): shouldn't buffer up this entire table in memory, it'd be
1492 // great to defer parsing everything until later.
inline_table(&mut self) -> Result<(Span, Vec<(Cow<'a, str>, Value<'a>)>), Error>1493 fn inline_table(&mut self) -> Result<(Span, Vec<(Cow<'a, str>, Value<'a>)>), Error> {
1494 let mut ret = Vec::new();
1495 self.eat_whitespace()?;
1496 if let Some(span) = self.eat_spanned(Token::RightBrace)? {
1497 return Ok((span, ret));
1498 }
1499 loop {
1500 let key = self.dotted_key()?;
1501 self.eat_whitespace()?;
1502 self.expect(Token::Equals)?;
1503 self.eat_whitespace()?;
1504 let value = self.value()?;
1505 self.add_dotted_key(key, value, &mut ret)?;
1506
1507 self.eat_whitespace()?;
1508 if let Some(span) = self.eat_spanned(Token::RightBrace)? {
1509 return Ok((span, ret));
1510 }
1511 self.expect(Token::Comma)?;
1512 self.eat_whitespace()?;
1513 }
1514 }
1515
1516 // TODO(#140): shouldn't buffer up this entire array in memory, it'd be
1517 // great to defer parsing everything until later.
array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error>1518 fn array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error> {
1519 let mut ret = Vec::new();
1520
1521 let intermediate = |me: &mut Deserializer| {
1522 loop {
1523 me.eat_whitespace()?;
1524 if !me.eat(Token::Newline)? && !me.eat_comment()? {
1525 break;
1526 }
1527 }
1528 Ok(())
1529 };
1530
1531 loop {
1532 intermediate(self)?;
1533 if let Some(span) = self.eat_spanned(Token::RightBracket)? {
1534 return Ok((span, ret));
1535 }
1536 let at = self.tokens.current();
1537 let value = self.value()?;
1538 if let Some(last) = ret.last() {
1539 if !value.same_type(last) {
1540 return Err(self.error(at, ErrorKind::MixedArrayType));
1541 }
1542 }
1543 ret.push(value);
1544 intermediate(self)?;
1545 if !self.eat(Token::Comma)? {
1546 break;
1547 }
1548 }
1549 intermediate(self)?;
1550 let span = self.expect_spanned(Token::RightBracket)?;
1551 Ok((span, ret))
1552 }
1553
table_key(&mut self) -> Result<Cow<'a, str>, Error>1554 fn table_key(&mut self) -> Result<Cow<'a, str>, Error> {
1555 self.tokens
1556 .table_key()
1557 .map(|t| t.1)
1558 .map_err(|e| self.token_error(e))
1559 }
1560
dotted_key(&mut self) -> Result<Vec<Cow<'a, str>>, Error>1561 fn dotted_key(&mut self) -> Result<Vec<Cow<'a, str>>, Error> {
1562 let mut result = Vec::new();
1563 result.push(self.table_key()?);
1564 self.eat_whitespace()?;
1565 while self.eat(Token::Period)? {
1566 self.eat_whitespace()?;
1567 result.push(self.table_key()?);
1568 self.eat_whitespace()?;
1569 }
1570 Ok(result)
1571 }
1572
1573 /// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
1574 ///
1575 /// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
1576 /// intermediate parts which are mapped to the relevant fields in the deserialized type's data
1577 /// hierarchy.
1578 ///
1579 /// # Parameters
1580 ///
1581 /// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
1582 /// `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
1583 /// * `value`: The parsed value.
1584 /// * `values`: The `Vec` to store the value in.
add_dotted_key( &self, mut key_parts: Vec<Cow<'a, str>>, value: Value<'a>, values: &mut Vec<(Cow<'a, str>, Value<'a>)>, ) -> Result<(), Error>1585 fn add_dotted_key(
1586 &self,
1587 mut key_parts: Vec<Cow<'a, str>>,
1588 value: Value<'a>,
1589 values: &mut Vec<(Cow<'a, str>, Value<'a>)>,
1590 ) -> Result<(), Error> {
1591 let key = key_parts.remove(0);
1592 if key_parts.is_empty() {
1593 values.push((key, value));
1594 return Ok(());
1595 }
1596 match values.iter_mut().find(|&&mut (ref k, _)| *k == key) {
1597 Some(&mut (
1598 _,
1599 Value {
1600 e: E::DottedTable(ref mut v),
1601 ..
1602 },
1603 )) => {
1604 return self.add_dotted_key(key_parts, value, v);
1605 }
1606 Some(&mut (_, Value { start, .. })) => {
1607 return Err(self.error(start, ErrorKind::DottedKeyInvalidType));
1608 }
1609 None => {}
1610 }
1611 // The start/end value is somewhat misleading here.
1612 let table_values = Value {
1613 e: E::DottedTable(Vec::new()),
1614 start: value.start,
1615 end: value.end,
1616 };
1617 values.push((key, table_values));
1618 let last_i = values.len() - 1;
1619 if let (
1620 _,
1621 Value {
1622 e: E::DottedTable(ref mut v),
1623 ..
1624 },
1625 ) = values[last_i]
1626 {
1627 self.add_dotted_key(key_parts, value, v)?;
1628 }
1629 Ok(())
1630 }
1631
eat_whitespace(&mut self) -> Result<(), Error>1632 fn eat_whitespace(&mut self) -> Result<(), Error> {
1633 self.tokens
1634 .eat_whitespace()
1635 .map_err(|e| self.token_error(e))
1636 }
1637
eat_comment(&mut self) -> Result<bool, Error>1638 fn eat_comment(&mut self) -> Result<bool, Error> {
1639 self.tokens.eat_comment().map_err(|e| self.token_error(e))
1640 }
1641
eat_newline_or_eof(&mut self) -> Result<(), Error>1642 fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
1643 self.tokens
1644 .eat_newline_or_eof()
1645 .map_err(|e| self.token_error(e))
1646 }
1647
eat(&mut self, expected: Token<'a>) -> Result<bool, Error>1648 fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
1649 self.tokens.eat(expected).map_err(|e| self.token_error(e))
1650 }
1651
eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error>1652 fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
1653 self.tokens
1654 .eat_spanned(expected)
1655 .map_err(|e| self.token_error(e))
1656 }
1657
expect(&mut self, expected: Token<'a>) -> Result<(), Error>1658 fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
1659 self.tokens
1660 .expect(expected)
1661 .map_err(|e| self.token_error(e))
1662 }
1663
expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error>1664 fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
1665 self.tokens
1666 .expect_spanned(expected)
1667 .map_err(|e| self.token_error(e))
1668 }
1669
next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error>1670 fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
1671 self.tokens.next().map_err(|e| self.token_error(e))
1672 }
1673
peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error>1674 fn peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
1675 self.tokens.peek().map_err(|e| self.token_error(e))
1676 }
1677
eof(&self) -> Error1678 fn eof(&self) -> Error {
1679 self.error(self.input.len(), ErrorKind::UnexpectedEof)
1680 }
1681
token_error(&self, error: TokenError) -> Error1682 fn token_error(&self, error: TokenError) -> Error {
1683 match error {
1684 TokenError::InvalidCharInString(at, ch) => {
1685 self.error(at, ErrorKind::InvalidCharInString(ch))
1686 }
1687 TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)),
1688 TokenError::InvalidEscapeValue(at, v) => {
1689 self.error(at, ErrorKind::InvalidEscapeValue(v))
1690 }
1691 TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)),
1692 TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString),
1693 TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)),
1694 TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString),
1695 TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey),
1696 TokenError::Wanted {
1697 at,
1698 expected,
1699 found,
1700 } => self.error(
1701 at,
1702 ErrorKind::Wanted {
1703 expected: expected,
1704 found: found,
1705 },
1706 ),
1707 TokenError::EmptyTableKey(at) => self.error(at, ErrorKind::EmptyTableKey),
1708 TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey),
1709 }
1710 }
1711
error(&self, at: usize, kind: ErrorKind) -> Error1712 fn error(&self, at: usize, kind: ErrorKind) -> Error {
1713 let mut err = Error::from_kind(kind);
1714 let (line, col) = self.to_linecol(at);
1715 err.inner.line = Some(line);
1716 err.inner.col = col;
1717 err
1718 }
1719
1720 /// Converts a byte offset from an error message to a (line, column) pair
1721 ///
1722 /// All indexes are 0-based.
to_linecol(&self, offset: usize) -> (usize, usize)1723 fn to_linecol(&self, offset: usize) -> (usize, usize) {
1724 let mut cur = 0;
1725 for (i, line) in self.input.lines().enumerate() {
1726 if cur + line.len() + 1 > offset {
1727 return (i, offset - cur);
1728 }
1729 cur += line.len() + 1;
1730 }
1731 (self.input.lines().count(), 0)
1732 }
1733 }
1734
1735 impl Error {
1736 /// Produces a (line, column) pair of the position of the error if available
1737 ///
1738 /// All indexes are 0-based.
line_col(&self) -> Option<(usize, usize)>1739 pub fn line_col(&self) -> Option<(usize, usize)> {
1740 self.inner.line.map(|line| (line, self.inner.col))
1741 }
1742
from_kind(kind: ErrorKind) -> Error1743 fn from_kind(kind: ErrorKind) -> Error {
1744 Error {
1745 inner: Box::new(ErrorInner {
1746 kind: kind,
1747 line: None,
1748 col: 0,
1749 message: String::new(),
1750 key: Vec::new(),
1751 }),
1752 }
1753 }
1754
custom(s: String) -> Error1755 fn custom(s: String) -> Error {
1756 Error {
1757 inner: Box::new(ErrorInner {
1758 kind: ErrorKind::Custom,
1759 line: None,
1760 col: 0,
1761 message: s,
1762 key: Vec::new(),
1763 }),
1764 }
1765 }
1766
1767 /// Do not call this method, it may be removed at any time, it's just an
1768 /// internal implementation detail.
1769 #[doc(hidden)]
add_key_context(&mut self, key: &str)1770 pub fn add_key_context(&mut self, key: &str) {
1771 self.inner.key.insert(0, key.to_string());
1772 }
1773 }
1774
1775 impl fmt::Display for Error {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1776 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1777 match self.inner.kind {
1778 ErrorKind::UnexpectedEof => "unexpected eof encountered".fmt(f)?,
1779 ErrorKind::InvalidCharInString(c) => write!(
1780 f,
1781 "invalid character in string: `{}`",
1782 c.escape_default().collect::<String>()
1783 )?,
1784 ErrorKind::InvalidEscape(c) => write!(
1785 f,
1786 "invalid escape character in string: `{}`",
1787 c.escape_default().collect::<String>()
1788 )?,
1789 ErrorKind::InvalidHexEscape(c) => write!(
1790 f,
1791 "invalid hex escape character in string: `{}`",
1792 c.escape_default().collect::<String>()
1793 )?,
1794 ErrorKind::InvalidEscapeValue(c) => write!(f, "invalid escape value: `{}`", c)?,
1795 ErrorKind::NewlineInString => "newline in string found".fmt(f)?,
1796 ErrorKind::Unexpected(ch) => write!(
1797 f,
1798 "unexpected character found: `{}`",
1799 ch.escape_default().collect::<String>()
1800 )?,
1801 ErrorKind::UnterminatedString => "unterminated string".fmt(f)?,
1802 ErrorKind::NewlineInTableKey => "found newline in table key".fmt(f)?,
1803 ErrorKind::Wanted { expected, found } => {
1804 write!(f, "expected {}, found {}", expected, found)?
1805 }
1806 ErrorKind::NumberInvalid => "invalid number".fmt(f)?,
1807 ErrorKind::DateInvalid => "invalid date".fmt(f)?,
1808 ErrorKind::MixedArrayType => "mixed types in an array".fmt(f)?,
1809 ErrorKind::DuplicateTable(ref s) => {
1810 write!(f, "redefinition of table `{}`", s)?;
1811 }
1812 ErrorKind::RedefineAsArray => "table redefined as array".fmt(f)?,
1813 ErrorKind::EmptyTableKey => "empty table key found".fmt(f)?,
1814 ErrorKind::MultilineStringKey => "multiline strings are not allowed for key".fmt(f)?,
1815 ErrorKind::Custom => self.inner.message.fmt(f)?,
1816 ErrorKind::ExpectedTuple(l) => write!(f, "expected table with length {}", l)?,
1817 ErrorKind::ExpectedTupleIndex {
1818 expected,
1819 ref found,
1820 } => write!(f, "expected table key `{}`, but was `{}`", expected, found)?,
1821 ErrorKind::ExpectedEmptyTable => "expected empty table".fmt(f)?,
1822 ErrorKind::DottedKeyInvalidType => {
1823 "dotted key attempted to extend non-table type".fmt(f)?
1824 }
1825 ErrorKind::UnexpectedKeys {
1826 ref keys,
1827 available,
1828 } => write!(
1829 f,
1830 "unexpected keys in table: `{:?}`, available keys: `{:?}`",
1831 keys, available
1832 )?,
1833 ErrorKind::__Nonexhaustive => panic!(),
1834 }
1835
1836 if !self.inner.key.is_empty() {
1837 write!(f, " for key `")?;
1838 for (i, k) in self.inner.key.iter().enumerate() {
1839 if i > 0 {
1840 write!(f, ".")?;
1841 }
1842 write!(f, "{}", k)?;
1843 }
1844 write!(f, "`")?;
1845 }
1846
1847 if let Some(line) = self.inner.line {
1848 write!(f, " at line {}", line + 1)?;
1849 }
1850
1851 Ok(())
1852 }
1853 }
1854
1855 impl error::Error for Error {
description(&self) -> &str1856 fn description(&self) -> &str {
1857 match self.inner.kind {
1858 ErrorKind::UnexpectedEof => "unexpected eof encountered",
1859 ErrorKind::InvalidCharInString(_) => "invalid char in string",
1860 ErrorKind::InvalidEscape(_) => "invalid escape in string",
1861 ErrorKind::InvalidHexEscape(_) => "invalid hex escape in string",
1862 ErrorKind::InvalidEscapeValue(_) => "invalid escape value in string",
1863 ErrorKind::NewlineInString => "newline in string found",
1864 ErrorKind::Unexpected(_) => "unexpected or invalid character",
1865 ErrorKind::UnterminatedString => "unterminated string",
1866 ErrorKind::NewlineInTableKey => "found newline in table key",
1867 ErrorKind::Wanted { .. } => "expected a token but found another",
1868 ErrorKind::NumberInvalid => "invalid number",
1869 ErrorKind::DateInvalid => "invalid date",
1870 ErrorKind::MixedArrayType => "mixed types in an array",
1871 ErrorKind::DuplicateTable(_) => "duplicate table",
1872 ErrorKind::RedefineAsArray => "table redefined as array",
1873 ErrorKind::EmptyTableKey => "empty table key found",
1874 ErrorKind::MultilineStringKey => "invalid multiline string for key",
1875 ErrorKind::Custom => "a custom error",
1876 ErrorKind::ExpectedTuple(_) => "expected table length",
1877 ErrorKind::ExpectedTupleIndex { .. } => "expected table key",
1878 ErrorKind::ExpectedEmptyTable => "expected empty table",
1879 ErrorKind::DottedKeyInvalidType => "dotted key invalid type",
1880 ErrorKind::UnexpectedKeys { .. } => "unexpected keys in table",
1881 ErrorKind::__Nonexhaustive => panic!(),
1882 }
1883 }
1884 }
1885
1886 impl de::Error for Error {
custom<T: fmt::Display>(msg: T) -> Error1887 fn custom<T: fmt::Display>(msg: T) -> Error {
1888 Error::custom(msg.to_string())
1889 }
1890 }
1891
1892 enum Line<'a> {
1893 Table {
1894 at: usize,
1895 header: Header<'a>,
1896 array: bool,
1897 },
1898 KeyValue(Vec<Cow<'a, str>>, Value<'a>),
1899 }
1900
1901 struct Header<'a> {
1902 first: bool,
1903 array: bool,
1904 require_newline_after_table: bool,
1905 tokens: Tokenizer<'a>,
1906 }
1907
1908 impl<'a> Header<'a> {
new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a>1909 fn new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a> {
1910 Header {
1911 first: true,
1912 array: array,
1913 tokens: tokens,
1914 require_newline_after_table: require_newline_after_table,
1915 }
1916 }
1917
next(&mut self) -> Result<Option<Cow<'a, str>>, TokenError>1918 fn next(&mut self) -> Result<Option<Cow<'a, str>>, TokenError> {
1919 self.tokens.eat_whitespace()?;
1920
1921 if self.first || self.tokens.eat(Token::Period)? {
1922 self.first = false;
1923 self.tokens.eat_whitespace()?;
1924 self.tokens.table_key().map(|t| t.1).map(Some)
1925 } else {
1926 self.tokens.expect(Token::RightBracket)?;
1927 if self.array {
1928 self.tokens.expect(Token::RightBracket)?;
1929 }
1930
1931 self.tokens.eat_whitespace()?;
1932 if self.require_newline_after_table {
1933 if !self.tokens.eat_comment()? {
1934 self.tokens.eat_newline_or_eof()?;
1935 }
1936 }
1937 Ok(None)
1938 }
1939 }
1940 }
1941
1942 #[derive(Debug)]
1943 struct Value<'a> {
1944 e: E<'a>,
1945 start: usize,
1946 end: usize,
1947 }
1948
1949 #[derive(Debug)]
1950 enum E<'a> {
1951 Integer(i64),
1952 Float(f64),
1953 Boolean(bool),
1954 String(Cow<'a, str>),
1955 Datetime(&'a str),
1956 Array(Vec<Value<'a>>),
1957 InlineTable(Vec<(Cow<'a, str>, Value<'a>)>),
1958 DottedTable(Vec<(Cow<'a, str>, Value<'a>)>),
1959 }
1960
1961 impl<'a> E<'a> {
type_name(&self) -> &'static str1962 fn type_name(&self) -> &'static str {
1963 match *self {
1964 E::String(..) => "string",
1965 E::Integer(..) => "integer",
1966 E::Float(..) => "float",
1967 E::Boolean(..) => "boolean",
1968 E::Datetime(..) => "datetime",
1969 E::Array(..) => "array",
1970 E::InlineTable(..) => "inline table",
1971 E::DottedTable(..) => "dotted table",
1972 }
1973 }
1974 }
1975
1976 impl<'a> Value<'a> {
same_type(&self, other: &Value<'a>) -> bool1977 fn same_type(&self, other: &Value<'a>) -> bool {
1978 match (&self.e, &other.e) {
1979 (&E::String(..), &E::String(..))
1980 | (&E::Integer(..), &E::Integer(..))
1981 | (&E::Float(..), &E::Float(..))
1982 | (&E::Boolean(..), &E::Boolean(..))
1983 | (&E::Datetime(..), &E::Datetime(..))
1984 | (&E::Array(..), &E::Array(..))
1985 | (&E::InlineTable(..), &E::InlineTable(..)) => true,
1986 (&E::DottedTable(..), &E::DottedTable(..)) => true,
1987
1988 _ => false,
1989 }
1990 }
1991 }
1992