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