diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/datetime.rs | 56 | ||||
| -rw-r--r-- | src/de.rs | 567 | ||||
| -rw-r--r-- | src/macros.rs | 7 | ||||
| -rw-r--r-- | src/ser.rs | 560 | ||||
| -rw-r--r-- | src/spanned.rs | 20 | ||||
| -rw-r--r-- | src/tokens.rs | 359 | ||||
| -rw-r--r-- | src/value.rs | 301 |
7 files changed, 1088 insertions, 782 deletions
diff --git a/src/datetime.rs b/src/datetime.rs index 3678f58..363160b 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -1,6 +1,6 @@ +use std::error; use std::fmt; use std::str::{self, FromStr}; -use std::error; use serde::{de, ser}; @@ -109,9 +109,7 @@ impl fmt::Display for Offset { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Offset::Z => write!(f, "Z"), - Offset::Custom { hours, minutes } => { - write!(f, "{:+03}:{:02}", hours, minutes) - } + Offset::Custom { hours, minutes } => write!(f, "{:+03}:{:02}", hours, minutes), } } } @@ -127,7 +125,7 @@ impl FromStr for Datetime { // 0000-00-00 // 00:00:00.00 if date.len() < 3 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } let mut offset_allowed = true; let mut chars = date.chars(); @@ -165,19 +163,19 @@ impl FromStr for Datetime { }; if date.month < 1 || date.month > 12 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } if date.day < 1 || date.day > 31 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } Some(date) }; // Next parse the "partial-time" if available - let partial_time = if full_date.is_some() && - (chars.clone().next() == Some('T') - || chars.clone().next() == Some(' ')) { + let partial_time = if full_date.is_some() + && (chars.clone().next() == Some('T') || chars.clone().next() == Some(' ')) + { chars.next(); true } else { @@ -208,7 +206,7 @@ impl FromStr for Datetime { let mut end = whole.len(); for (i, byte) in whole.bytes().enumerate() { match byte { - b'0' ... b'9' => { + b'0'...b'9' => { if i < 9 { let p = 10_u32.pow(8 - i as u32); nanosecond += p * (byte - b'0') as u32; @@ -221,7 +219,7 @@ impl FromStr for Datetime { } } if end == 0 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } chars = whole[end..].chars(); } @@ -234,16 +232,16 @@ impl FromStr for Datetime { }; if time.hour > 24 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } if time.minute > 59 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } if time.second > 59 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } if time.nanosecond > 999_999_999 { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } Some(time) @@ -288,7 +286,7 @@ impl FromStr for Datetime { // Return an error if we didn't hit eof, otherwise return our parsed // date if chars.next().is_some() { - return Err(DatetimeParseError { _private: () }) + return Err(DatetimeParseError { _private: () }); } Ok(Datetime { @@ -308,7 +306,8 @@ fn digit(chars: &mut str::Chars) -> Result<u8, DatetimeParseError> { impl ser::Serialize for Datetime { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> - where S: ser::Serializer + where + S: ser::Serializer, { use serde::ser::SerializeStruct; @@ -320,7 +319,8 @@ impl ser::Serialize for Datetime { impl<'de> de::Deserialize<'de> for Datetime { fn deserialize<D>(deserializer: D) -> Result<Datetime, D::Error> - where D: de::Deserializer<'de> + where + D: de::Deserializer<'de>, { struct DatetimeVisitor; @@ -332,15 +332,15 @@ impl<'de> de::Deserialize<'de> for Datetime { } fn visit_map<V>(self, mut visitor: V) -> Result<Datetime, V::Error> - where V: de::MapAccess<'de> + where + V: de::MapAccess<'de>, { let value = visitor.next_key::<DatetimeKey>()?; if value.is_none() { - return Err(de::Error::custom("datetime key not found")) + return Err(de::Error::custom("datetime key not found")); } let v: DatetimeFromString = visitor.next_value()?; Ok(v.value) - } } @@ -353,7 +353,8 @@ struct DatetimeKey; impl<'de> de::Deserialize<'de> for DatetimeKey { fn deserialize<D>(deserializer: D) -> Result<DatetimeKey, D::Error> - where D: de::Deserializer<'de> + where + D: de::Deserializer<'de>, { struct FieldVisitor; @@ -365,7 +366,8 @@ impl<'de> de::Deserialize<'de> for DatetimeKey { } fn visit_str<E>(self, s: &str) -> Result<(), E> - where E: de::Error + where + E: de::Error, { if s == FIELD { Ok(()) @@ -386,7 +388,8 @@ pub struct DatetimeFromString { impl<'de> de::Deserialize<'de> for DatetimeFromString { fn deserialize<D>(deserializer: D) -> Result<DatetimeFromString, D::Error> - where D: de::Deserializer<'de> + where + D: de::Deserializer<'de>, { struct Visitor; @@ -398,7 +401,8 @@ impl<'de> de::Deserialize<'de> for DatetimeFromString { } fn visit_str<E>(self, s: &str) -> Result<DatetimeFromString, E> - where E: de::Error, + where + E: de::Error, { match s.parse() { Ok(date) => Ok(DatetimeFromString { value: date }), @@ -12,19 +12,20 @@ use std::str; use std::vec; use serde::de; -use serde::de::IntoDeserializer; use serde::de::value::BorrowedStrDeserializer; +use serde::de::IntoDeserializer; -use tokens::{Tokenizer, Token, Error as TokenError, Span}; use datetime; use spanned; +use tokens::{Error as TokenError, Span, Token, Tokenizer}; /// Deserializes a byte slice into a type. /// /// This function will attempt to interpret `bytes` as UTF-8 data and then /// deserialize `T` from the TOML document provided. pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error> - where T: de::Deserialize<'de>, +where + T: de::Deserialize<'de>, { match str::from_utf8(bytes) { Ok(s) => from_str(s), @@ -68,7 +69,8 @@ pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error> /// } /// ``` pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error> - where T: de::Deserialize<'de>, +where + T: de::Deserialize<'de>, { let mut d = Deserializer::new(s); let ret = T::deserialize(&mut d)?; @@ -203,9 +205,9 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> { type Error = Error; fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { - let mut tables = self.tables()?; visitor.visit_map(MapVisitor { @@ -226,9 +228,10 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> { self, _name: &'static str, _variants: &'static [&'static str], - visitor: V + visitor: V, ) -> Result<V::Value, Error> - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { let (value, name) = self.string_or_table()?; match value.e { @@ -292,10 +295,11 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> { type Error = Error; fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> - where K: de::DeserializeSeed<'de>, + where + K: de::DeserializeSeed<'de>, { if self.cur_parent == self.max || self.cur == self.max { - return Ok(None) + return Ok(None); } loop { @@ -303,20 +307,24 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> { if let Some((key, value)) = self.values.next() { let ret = seed.deserialize(StrDeserializer::new(key.clone()))?; self.next_value = Some((key, value)); - return Ok(Some(ret)) + return Ok(Some(ret)); } let next_table = { let prefix = &self.tables[self.cur_parent].header[..self.depth]; - self.tables[self.cur..self.max].iter().enumerate().find(|&(_, t)| { - if t.values.is_none() { - return false - } - match t.header.get(..self.depth) { - Some(header) => header == prefix, - None => false, - } - }).map(|(i, _)| i + self.cur) + self.tables[self.cur..self.max] + .iter() + .enumerate() + .find(|&(_, t)| { + if t.values.is_none() { + return false; + } + match t.header.get(..self.depth) { + Some(header) => header == prefix, + None => false, + } + }) + .map(|(i, _)| i + self.cur) }; let pos = match next_table { @@ -327,11 +335,12 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> { // Test to see if we're duplicating our parent's table, and if so // then this is an error in the toml format - if self.cur_parent != pos && - self.tables[self.cur_parent].header == self.tables[pos].header { + if self.cur_parent != pos + && self.tables[self.cur_parent].header == self.tables[pos].header + { let at = self.tables[pos].at; let name = self.tables[pos].header.join("."); - return Err(self.de.error(at, ErrorKind::DuplicateTable(name))) + return Err(self.de.error(at, ErrorKind::DuplicateTable(name))); } let table = &mut self.tables[pos]; @@ -342,42 +351,47 @@ impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> { if self.depth != table.header.len() { let key = &table.header[self.depth]; let key = seed.deserialize(StrDeserializer::new(key.clone()))?; - return Ok(Some(key)) + return Ok(Some(key)); } // Rule out cases like: // // [[foo.bar]] // [[foo]] - if table.array { + if table.array { let kind = ErrorKind::RedefineAsArray; - return Err(self.de.error(table.at, kind)) + return Err(self.de.error(table.at, kind)); } - self.values = table.values.take().expect("Unable to read table values").into_iter(); + self.values = table + .values + .take() + .expect("Unable to read table values") + .into_iter(); } } fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { if let Some((k, v)) = self.next_value.take() { match seed.deserialize(ValueDeserializer::new(v)) { Ok(v) => return Ok(v), Err(mut e) => { e.add_key_context(&k); - return Err(e) + return Err(e); } } } - let array = self.tables[self.cur].array && - self.depth == self.tables[self.cur].header.len() - 1; + let array = + self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1; self.cur += 1; let res = seed.deserialize(MapVisitor { values: Vec::new().into_iter(), next_value: None, - depth: self.depth + if array {0} else {1}, + depth: self.depth + if array { 0 } else { 1 }, cur_parent: self.cur - 1, cur: 0, max: self.max, @@ -396,26 +410,30 @@ impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> { type Error = Error; fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> - where K: de::DeserializeSeed<'de>, + where + K: de::DeserializeSeed<'de>, { assert!(self.next_value.is_none()); assert!(self.values.next().is_none()); if self.cur_parent == self.max { - return Ok(None) + return Ok(None); } let next = self.tables[..self.max] .iter() .enumerate() .skip(self.cur_parent + 1) - .find(|&(_, table)| { - table.array && table.header == self.tables[self.cur_parent].header - }).map(|p| p.0) + .find(|&(_, table)| table.array && table.header == self.tables[self.cur_parent].header) + .map(|p| p.0) .unwrap_or(self.max); let ret = seed.deserialize(MapVisitor { - values: self.tables[self.cur_parent].values.take().expect("Unable to read table values").into_iter(), + values: self.tables[self.cur_parent] + .values + .take() + .expect("Unable to read table values") + .into_iter(), next_value: None, depth: self.depth + 1, cur_parent: self.cur_parent, @@ -434,9 +452,10 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> { type Error = Error; fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { - if self.array { + if self.array { visitor.visit_seq(self) } else { visitor.visit_map(self) @@ -446,7 +465,8 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> { // `None` is interpreted as a missing field so be sure to implement `Some` // as a present field. fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_some(self) } @@ -454,9 +474,10 @@ impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> { fn deserialize_newtype_struct<V>( self, _name: &'static str, - visitor: V + visitor: V, ) -> Result<V::Value, Error> - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -474,9 +495,7 @@ struct StrDeserializer<'a> { impl<'a> StrDeserializer<'a> { fn new(key: Cow<'a, str>) -> StrDeserializer<'a> { - StrDeserializer { - key: key, - } + StrDeserializer { key: key } } } @@ -484,7 +503,8 @@ impl<'de> de::Deserializer<'de> for StrDeserializer<'de> { type Error = Error; fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match self.key { Cow::Borrowed(s) => visitor.visit_borrowed_str(s), @@ -522,7 +542,8 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { type Error = Error; fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match self.value.e { E::Integer(i) => visitor.visit_i64(i), @@ -549,25 +570,29 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { } } - fn deserialize_struct<V>(self, - name: &'static str, - fields: &'static [&'static str], - visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + fn deserialize_struct<V>( + self, + name: &'static str, + fields: &'static [&'static str], + visitor: V, + ) -> Result<V::Value, Error> + where + V: de::Visitor<'de>, { if name == datetime::NAME && fields == &[datetime::FIELD] { if let E::Datetime(s) = self.value.e { return visitor.visit_map(DatetimeDeserializer { date: s, visited: false, - }) + }); } } if self.validate_struct_keys { match &self.value.e { &E::InlineTable(ref values) | &E::DottedTable(ref values) => { - let extra_fields = values.iter() + let extra_fields = values + .iter() .filter_map(|key_value| { let (ref key, ref _val) = *key_value; if !fields.contains(&&(**key)) { @@ -580,7 +605,10 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { if !extra_fields.is_empty() { return Err(Error::from_kind(ErrorKind::UnexpectedKeys { - keys: extra_fields.iter().map(|k| k.to_string()).collect::<Vec<_>>(), + keys: extra_fields + .iter() + .map(|k| k.to_string()) + .collect::<Vec<_>>(), available: fields, })); } @@ -606,7 +634,8 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { // `None` is interpreted as a missing field so be sure to implement `Some` // as a present field. fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_some(self) } @@ -615,9 +644,10 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { self, _name: &'static str, _variants: &'static [&'static str], - visitor: V + visitor: V, ) -> Result<V::Value, Error> - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { match self.value.e { E::String(val) => visitor.visit_enum(val.into_deserializer()), @@ -648,9 +678,10 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { fn deserialize_newtype_struct<V>( self, _name: &'static str, - visitor: V + visitor: V, ) -> Result<V::Value, Error> - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -684,11 +715,14 @@ impl<'de> de::MapAccess<'de> for SpannedDeserializer<'de> { K: de::DeserializeSeed<'de>, { if self.start.is_some() { - seed.deserialize(BorrowedStrDeserializer::new(spanned::START)).map(Some) + seed.deserialize(BorrowedStrDeserializer::new(spanned::START)) + .map(Some) } else if self.end.is_some() { - seed.deserialize(BorrowedStrDeserializer::new(spanned::END)).map(Some) + seed.deserialize(BorrowedStrDeserializer::new(spanned::END)) + .map(Some) } else if self.value.is_some() { - seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE)).map(Some) + seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE)) + .map(Some) } else { Ok(None) } @@ -700,7 +734,7 @@ impl<'de> de::MapAccess<'de> for SpannedDeserializer<'de> { { if let Some(start) = self.start.take() { seed.deserialize(start.into_deserializer()) - } else if let Some(end) = self.end.take() { + } else if let Some(end) = self.end.take() { seed.deserialize(end.into_deserializer()) } else if let Some(value) = self.value.take() { seed.deserialize(value.into_deserializer()) @@ -719,17 +753,19 @@ impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> { type Error = Error; fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> - where K: de::DeserializeSeed<'de>, + where + K: de::DeserializeSeed<'de>, { if self.visited { - return Ok(None) + return Ok(None); } self.visited = true; seed.deserialize(DatetimeFieldDeserializer).map(Some) } fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { seed.deserialize(StrDeserializer::new(self.date.into())) } @@ -741,7 +777,8 @@ impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer { type Error = Error; fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_borrowed_str(datetime::FIELD) } @@ -781,7 +818,8 @@ impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> { type Error = Error; fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error> - where K: de::DeserializeSeed<'de>, + where + K: de::DeserializeSeed<'de>, { let (key, value) = match self.values.next() { Some(pair) => pair, @@ -792,7 +830,8 @@ impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> { } fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error> - where V: de::DeserializeSeed<'de>, + where + V: de::DeserializeSeed<'de>, { let value = self.next_value.take().expect("Unable to read table values"); seed.deserialize(ValueDeserializer::new(value)) @@ -998,12 +1037,12 @@ impl<'a> Deserializer<'a> { loop { self.eat_whitespace()?; if self.eat_comment()? { - continue + continue; } if self.eat(Token::Newline)? { - continue + continue; } - break + break; } match self.peek()? { @@ -1017,9 +1056,7 @@ impl<'a> Deserializer<'a> { let start = self.tokens.current(); self.expect(Token::LeftBracket)?; let array = self.eat(Token::LeftBracket)?; - let ret = Header::new(self.tokens.clone(), - array, - self.require_newline_after_table); + let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table); if self.require_newline_after_table { self.tokens.skip_to_newline(); } else { @@ -1029,16 +1066,19 @@ impl<'a> Deserializer<'a> { if array { self.eat(Token::RightBracket)?; } - break + break; } - Some((_, Token::Newline)) | - None => break, + Some((_, Token::Newline)) | None => break, _ => {} } } self.eat_whitespace()?; } - Ok(Line::Table { at: start, header: ret, array: array }) + Ok(Line::Table { + at: start, + header: ret, + array: array, + }) } fn key_value(&mut self) -> Result<Line<'a>, Error> { @@ -1059,58 +1099,66 @@ impl<'a> Deserializer<'a> { fn value(&mut self) -> Result<Value<'a>, Error> { let at = self.tokens.current(); let value = match self.next()? { - Some((Span { start, end }, Token::String { val, .. })) => { - Value { e: E::String(val), start: start, end: end } - } - Some((Span { start, end }, Token::Keylike("true"))) => { - Value { e: E::Boolean(true), start: start, end: end } - } - Some((Span { start, end }, Token::Keylike("false"))) => { - Value { e: E::Boolean(false), start: start, end: end } - } + Some((Span { start, end }, Token::String { val, .. })) => Value { + e: E::String(val), + start: start, + end: end, + }, + Some((Span { start, end }, Token::Keylike("true"))) => Value { + e: E::Boolean(true), + start: start, + end: end, + }, + Some((Span { start, end }, Token::Keylike("false"))) => Value { + e: E::Boolean(false), + start: start, + end: end, + }, Some((span, Token::Keylike(key))) => self.number_or_date(span, key)?, Some((span, Token::Plus)) => self.number_leading_plus(span)?, Some((Span { start, .. }, Token::LeftBrace)) => { self.inline_table().map(|(Span { end, .. }, table)| Value { e: E::InlineTable(table), start: start, - end: end + end: end, })? } Some((Span { start, .. }, Token::LeftBracket)) => { self.array().map(|(Span { end, .. }, array)| Value { e: E::Array(array), start: start, - end: end + end: end, })? } Some(token) => { - return Err(self.error(at, ErrorKind::Wanted { - expected: "a value", - found: token.1.describe(), - })) + return Err(self.error( + at, + ErrorKind::Wanted { + expected: "a value", + found: token.1.describe(), + }, + )) } None => return Err(self.eof()), }; Ok(value) } - fn number_or_date(&mut self, span: Span, s: &'a str) - -> Result<Value<'a>, Error> - { - if s.contains('T') || (s.len() > 1 && s[1..].contains('-')) && - !s.contains("e-") { - self.datetime(span, s, false).map(|(Span { start, end }, d)| Value { - e: E::Datetime(d), - start: start, - end: end - }) + fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> { + if s.contains('T') || (s.len() > 1 && s[1..].contains('-')) && !s.contains("e-") { + self.datetime(span, s, false) + .map(|(Span { start, end }, d)| Value { + e: E::Datetime(d), + start: start, + end: end, + }) } else if self.eat(Token::Colon)? { - self.datetime(span, s, true).map(|(Span { start, end }, d)| Value { - e: E::Datetime(d), - start: start, - end: end - }) + self.datetime(span, s, true) + .map(|(Span { start, end }, d)| Value { + e: E::Datetime(d), + start: start, + end: end, + }) } else { self.number(span, s) } @@ -1166,7 +1214,11 @@ impl<'a> Deserializer<'a> { } fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> { - let to_integer = |f| Value { e: E::Integer(f), start: start, end: end }; + let to_integer = |f| Value { + e: E::Integer(f), + start: start, + end: end, + }; if s.starts_with("0x") { self.integer(&s[2..], 16).map(to_integer) } else if s.starts_with("0o") { @@ -1174,25 +1226,47 @@ impl<'a> Deserializer<'a> { } else if s.starts_with("0b") { self.integer(&s[2..], 2).map(to_integer) } else if s.contains('e') || s.contains('E') { - self.float(s, None).map(|f| Value { e: E::Float(f), start: start, end: end }) + self.float(s, None).map(|f| Value { + e: E::Float(f), + start: start, + end: end, + }) } else if self.eat(Token::Period)? { let at = self.tokens.current(); match self.next()? { Some((Span { start, end }, Token::Keylike(after))) => { self.float(s, Some(after)).map(|f| Value { - e: E::Float(f), start: start, end: end + e: E::Float(f), + start: start, + end: end, }) } _ => Err(self.error(at, ErrorKind::NumberInvalid)), } } else if s == "inf" { - Ok(Value { e: E::Float(f64::INFINITY), start: start, end: end }) + Ok(Value { + e: E::Float(f64::INFINITY), + start: start, + end: end, + }) } else if s == "-inf" { - Ok(Value { e: E::Float(f64::NEG_INFINITY), start: start, end: end }) + Ok(Value { + e: E::Float(f64::NEG_INFINITY), + start: start, + end: end, + }) } else if s == "nan" { - Ok(Value { e: E::Float(f64::NAN), start: start, end: end }) + Ok(Value { + e: E::Float(f64::NAN), + start: start, + end: end, + }) } else if s == "-nan" { - Ok(Value { e: E::Float(-f64::NAN), start: start, end: end }) + Ok(Value { + e: E::Float(-f64::NAN), + start: start, + end: end, + }) } else { self.integer(s, 10).map(to_integer) } @@ -1201,9 +1275,13 @@ impl<'a> Deserializer<'a> { fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> { let start_token = self.tokens.current(); match self.next()? { - Some((Span { end, .. }, Token::Keylike(s))) => { - self.number(Span { start: start, end: end }, s) - }, + Some((Span { end, .. }, Token::Keylike(s))) => self.number( + Span { + start: start, + end: end, + }, + s, + ), _ => Err(self.error(start_token, ErrorKind::NumberInvalid)), } } @@ -1214,7 +1292,7 @@ impl<'a> Deserializer<'a> { let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?; let start = self.tokens.substr_offset(s); if suffix != "" { - return Err(self.error(start, ErrorKind::NumberInvalid)) + return Err(self.error(start, ErrorKind::NumberInvalid)); } i64::from_str_radix(&prefix.replace("_", "").trim_left_matches('+'), radix) .map_err(|_e| self.error(start, ErrorKind::NumberInvalid)) @@ -1236,7 +1314,7 @@ impl<'a> Deserializer<'a> { for (i, c) in s.char_indices() { let at = i + start; if i == 0 && (c == '+' || c == '-') && allow_sign { - continue + continue; } if c == '0' && first { @@ -1257,20 +1335,19 @@ impl<'a> Deserializer<'a> { first = false; } if first || underscore { - return Err(self.error(start, ErrorKind::NumberInvalid)) + return Err(self.error(start, ErrorKind::NumberInvalid)); } Ok((&s[..end], &s[end..])) } - fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) - -> Result<f64, Error> { + fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> { let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?; let start = self.tokens.substr_offset(integral); let mut fraction = None; if let Some(after) = after_decimal { if suffix != "" { - return Err(self.error(start, ErrorKind::NumberInvalid)) + return Err(self.error(start, ErrorKind::NumberInvalid)); } let (a, b) = self.parse_integer(after, false, true, 10)?; fraction = Some(a); @@ -1282,24 +1359,23 @@ impl<'a> Deserializer<'a> { let (a, b) = if suffix.len() == 1 { self.eat(Token::Plus)?; match self.next()? { - Some((_, Token::Keylike(s))) => { - self.parse_integer(s, false, false, 10)? - } + Some((_, Token::Keylike(s))) => self.parse_integer(s, false, false, 10)?, _ => return Err(self.error(start, ErrorKind::NumberInvalid)), } } else { self.parse_integer(&suffix[1..], true, false, 10)? }; if b != "" { - return Err(self.error(start, ErrorKind::NumberInvalid)) + return Err(self.error(start, ErrorKind::NumberInvalid)); } exponent = Some(a); } - let mut number = integral.trim_left_matches('+') - .chars() - .filter(|c| *c != '_') - .collect::<String>(); + let mut number = integral + .trim_left_matches('+') + .chars() + .filter(|c| *c != '_') + .collect::<String>(); if let Some(fraction) = fraction { number.push_str("."); number.extend(fraction.chars().filter(|c| *c != '_')); @@ -1308,19 +1384,24 @@ impl<'a> Deserializer<'a> { number.push_str("E"); number.extend(exponent.chars().filter(|c| *c != '_')); } - number.parse().map_err(|_e| { - self.error(start, ErrorKind::NumberInvalid) - }).and_then(|n: f64| { - if n.is_finite() { - Ok(n) - } else { - Err(self.error(start, ErrorKind::NumberInvalid)) - } - }) + number + .parse() + .map_err(|_e| self.error(start, ErrorKind::NumberInvalid)) + .and_then(|n: f64| { + if n.is_finite() { + Ok(n) + } else { + Err(self.error(start, ErrorKind::NumberInvalid)) + } + }) } - fn datetime(&mut self, mut span: Span, date: &'a str, colon_eaten: bool) - -> Result<(Span, &'a str), Error> { + fn datetime( + &mut self, + mut span: Span, + date: &'a str, + colon_eaten: bool, + ) -> Result<(Span, &'a str), Error> { let start = self.tokens.substr_offset(date); // Check for space separated date and time. @@ -1328,8 +1409,8 @@ impl<'a> Deserializer<'a> { if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() { // Check if hour follows. if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() { - self.next()?; // skip space - self.next()?; // skip keylike hour + self.next()?; // skip space + self.next()?; // skip keylike hour } } @@ -1344,7 +1425,7 @@ impl<'a> Deserializer<'a> { match self.next()? { Some((Span { end, .. }, Token::Keylike(_))) => { span.end = end; - }, + } _ => return Err(self.error(start, ErrorKind::DateInvalid)), } // Fractional seconds @@ -1352,7 +1433,7 @@ impl<'a> Deserializer<'a> { match self.next()? { Some((Span { end, .. }, Token::Keylike(_))) => { span.end = end; - }, + } _ => return Err(self.error(start, ErrorKind::DateInvalid)), } } @@ -1362,7 +1443,7 @@ impl<'a> Deserializer<'a> { match self.next()? { Some((Span { end, .. }, Token::Keylike(_))) => { span.end = end; - }, + } _ => return Err(self.error(start, ErrorKind::DateInvalid)), } } @@ -1370,7 +1451,7 @@ impl<'a> Deserializer<'a> { match self.next()? { Some((Span { end, .. }, Token::Keylike(_))) => { span.end = end; - }, + } _ => return Err(self.error(start, ErrorKind::DateInvalid)), } } @@ -1386,7 +1467,7 @@ impl<'a> Deserializer<'a> { let mut ret = Vec::new(); self.eat_whitespace()?; if let Some(span) = self.eat_spanned(Token::RightBrace)? { - return Ok((span, ret)) + return Ok((span, ret)); } loop { let key = self.dotted_key()?; @@ -1398,7 +1479,7 @@ impl<'a> Deserializer<'a> { self.eat_whitespace()?; if let Some(span) = self.eat_spanned(Token::RightBrace)? { - return Ok((span, ret)) + return Ok((span, ret)); } self.expect(Token::Comma)?; self.eat_whitespace()?; @@ -1414,7 +1495,7 @@ impl<'a> Deserializer<'a> { loop { me.eat_whitespace()?; if !me.eat(Token::Newline)? && !me.eat_comment()? { - break + break; } } Ok(()) @@ -1423,19 +1504,19 @@ impl<'a> Deserializer<'a> { loop { intermediate(self)?; if let Some(span) = self.eat_spanned(Token::RightBracket)? { - return Ok((span, ret)) + return Ok((span, ret)); } let at = self.tokens.current(); let value = self.value()?; if let Some(last) = ret.last() { if !value.same_type(last) { - return Err(self.error(at, ErrorKind::MixedArrayType)) + return Err(self.error(at, ErrorKind::MixedArrayType)); } } ret.push(value); intermediate(self)?; if !self.eat(Token::Comma)? { - break + break; } } intermediate(self)?; @@ -1444,7 +1525,10 @@ impl<'a> Deserializer<'a> { } fn table_key(&mut self) -> Result<Cow<'a, str>, Error> { - self.tokens.table_key().map(|t| t.1).map_err(|e| self.token_error(e)) + self.tokens + .table_key() + .map(|t| t.1) + .map_err(|e| self.token_error(e)) } fn dotted_key(&mut self) -> Result<Vec<Cow<'a, str>>, Error> { @@ -1483,7 +1567,13 @@ impl<'a> Deserializer<'a> { return Ok(()); } match values.iter_mut().find(|&&mut (ref k, _)| *k == key) { - Some(&mut (_, Value { e: E::DottedTable(ref mut v), .. })) => { + Some(&mut ( + _, + Value { + e: E::DottedTable(ref mut v), + .. + }, + )) => { return self.add_dotted_key(key_parts, value, v); } Some(&mut (_, Value { start, .. })) => { @@ -1499,14 +1589,23 @@ impl<'a> Deserializer<'a> { }; values.push((key, table_values)); let last_i = values.len() - 1; - if let (_, Value { e: E::DottedTable(ref mut v), .. }) = values[last_i] { + if let ( + _, + Value { + e: E::DottedTable(ref mut v), + .. + }, + ) = values[last_i] + { self.add_dotted_key(key_parts, value, v)?; } Ok(()) } fn eat_whitespace(&mut self) -> Result<(), Error> { - self.tokens.eat_whitespace().map_err(|e| self.token_error(e)) + self.tokens + .eat_whitespace() + .map_err(|e| self.token_error(e)) } fn eat_comment(&mut self) -> Result<bool, Error> { @@ -1514,7 +1613,9 @@ impl<'a> Deserializer<'a> { } fn eat_newline_or_eof(&mut self) -> Result<(), Error> { - self.tokens.eat_newline_or_eof().map_err(|e| self.token_error(e)) + self.tokens + .eat_newline_or_eof() + .map_err(|e| self.token_error(e)) } fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> { @@ -1522,15 +1623,21 @@ impl<'a> Deserializer<'a> { } fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> { - self.tokens.eat_spanned(expected).map_err(|e| self.token_error(e)) + self.tokens + .eat_spanned(expected) + .map_err(|e| self.token_error(e)) } fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> { - self.tokens.expect(expected).map_err(|e| self.token_error(e)) + self.tokens + .expect(expected) + .map_err(|e| self.token_error(e)) } fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> { - self.tokens.expect_spanned(expected).map_err(|e| self.token_error(e)) + self.tokens + .expect_spanned(expected) + .map_err(|e| self.token_error(e)) } fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> { @@ -1550,36 +1657,28 @@ impl<'a> Deserializer<'a> { TokenError::InvalidCharInString(at, ch) => { self.error(at, ErrorKind::InvalidCharInString(ch)) } - TokenError::InvalidEscape(at, ch) => { - self.error(at, ErrorKind::InvalidEscape(ch)) - } + TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)), TokenError::InvalidEscapeValue(at, v) => { self.error(at, ErrorKind::InvalidEscapeValue(v)) } - TokenError::InvalidHexEscape(at, ch) => { - self.error(at, ErrorKind::InvalidHexEscape(ch)) - } - TokenError::NewlineInString(at) => { - self.error(at, ErrorKind::NewlineInString) - } - TokenError::Unexpected(at, ch) => { - self.error(at, ErrorKind::Unexpected(ch)) - } - TokenError::UnterminatedString(at) => { - self.error(at, ErrorKind::UnterminatedString) - } - TokenError::NewlineInTableKey(at) => { - self.error(at, ErrorKind::NewlineInTableKey) - } - TokenError::Wanted { at, expected, found } => { - self.error(at, ErrorKind::Wanted { expected: expected, found: found }) - } - TokenError::EmptyTableKey(at) => { - self.error(at, ErrorKind::EmptyTableKey) - } - TokenError::MultilineStringKey(at) => { - self.error(at, ErrorKind::MultilineStringKey) - } + TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)), + TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString), + TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)), + TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString), + TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey), + TokenError::Wanted { + at, + expected, + found, + } => self.error( + at, + ErrorKind::Wanted { + expected: expected, + found: found, + }, + ), + TokenError::EmptyTableKey(at) => self.error(at, ErrorKind::EmptyTableKey), + TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey), } } @@ -1598,7 +1697,7 @@ impl<'a> Deserializer<'a> { let mut cur = 0; for (i, line) in self.input.lines().enumerate() { if cur + line.len() + 1 > offset { - return (i, offset - cur) + return (i, offset - cur); } cur += line.len() + 1; } @@ -1650,26 +1749,28 @@ impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.inner.kind { ErrorKind::UnexpectedEof => "unexpected eof encountered".fmt(f)?, - ErrorKind::InvalidCharInString(c) => { - write!(f, "invalid character in string: `{}`", - c.escape_default().collect::<String>())? - } - ErrorKind::InvalidEscape(c) => { - write!(f, "invalid escape character in string: `{}`", - c.escape_default().collect::<String>())? - } - ErrorKind::InvalidHexEscape(c) => { - write!(f, "invalid hex escape character in string: `{}`", - c.escape_default().collect::<String>())? - } - ErrorKind::InvalidEscapeValue(c) => { - write!(f, "invalid escape value: `{}`", c)? - } + ErrorKind::InvalidCharInString(c) => write!( + f, + "invalid character in string: `{}`", + c.escape_default().collect::<String>() + )?, + ErrorKind::InvalidEscape(c) => write!( + f, + "invalid escape character in string: `{}`", + c.escape_default().collect::<String>() + )?, + ErrorKind::InvalidHexEscape(c) => write!( + f, + "invalid hex escape character in string: `{}`", + c.escape_default().collect::<String>() + )?, + ErrorKind::InvalidEscapeValue(c) => write!(f, "invalid escape value: `{}`", c)?, ErrorKind::NewlineInString => "newline in string found".fmt(f)?, - ErrorKind::Unexpected(ch) => { - write!(f, "unexpected character found: `{}`", - ch.escape_default().collect::<String>())? - } + ErrorKind::Unexpected(ch) => write!( + f, + "unexpected character found: `{}`", + ch.escape_default().collect::<String>() + )?, ErrorKind::UnterminatedString => "unterminated string".fmt(f)?, ErrorKind::NewlineInTableKey => "found newline in table key".fmt(f)?, ErrorKind::Wanted { expected, found } => { @@ -1694,14 +1795,14 @@ impl fmt::Display for Error { ErrorKind::DottedKeyInvalidType => { "dotted key attempted to extend non-table type".fmt(f)? } - ErrorKind::UnexpectedKeys { ref keys, available } => { - write!( - f, - "unexpected keys in table: `{:?}`, available keys: `{:?}`", - keys, - available - )? - } + ErrorKind::UnexpectedKeys { + ref keys, + available, + } => write!( + f, + "unexpected keys in table: `{:?}`, available keys: `{:?}`", + keys, available + )?, ErrorKind::__Nonexhaustive => panic!(), } @@ -1762,7 +1863,11 @@ impl de::Error for Error { } enum Line<'a> { - Table { at: usize, header: Header<'a>, array: bool }, + Table { + at: usize, + header: Header<'a>, + array: bool, + }, KeyValue(Vec<Cow<'a, str>>, Value<'a>), } @@ -1774,9 +1879,7 @@ struct Header<'a> { } impl<'a> Header<'a> { - fn new(tokens: Tokenizer<'a>, - array: bool, - require_newline_after_table: bool) -> Header<'a> { + fn new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a> { Header { first: true, array: array, @@ -1846,13 +1949,13 @@ impl<'a> E<'a> { impl<'a> Value<'a> { fn same_type(&self, other: &Value<'a>) -> bool { match (&self.e, &other.e) { - (&E::String(..), &E::String(..)) | - (&E::Integer(..), &E::Integer(..)) | - (&E::Float(..), &E::Float(..)) | - (&E::Boolean(..), &E::Boolean(..)) | - (&E::Datetime(..), &E::Datetime(..)) | - (&E::Array(..), &E::Array(..)) | - (&E::InlineTable(..), &E::InlineTable(..)) => true, + (&E::String(..), &E::String(..)) + | (&E::Integer(..), &E::Integer(..)) + | (&E::Float(..), &E::Float(..)) + | (&E::Boolean(..), &E::Boolean(..)) + | (&E::Datetime(..), &E::Datetime(..)) + | (&E::Array(..), &E::Array(..)) + | (&E::InlineTable(..), &E::InlineTable(..)) => true, (&E::DottedTable(..), &E::DottedTable(..)) => true, _ => false, diff --git a/src/macros.rs b/src/macros.rs index b4c7b22..8b76591 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -1,6 +1,6 @@ pub use serde::de::{Deserialize, IntoDeserializer}; -use value::{Value, Table, Array}; +use value::{Array, Table, Value}; /// Construct a [`toml::Value`] from TOML syntax. /// @@ -424,7 +424,10 @@ pub fn push_toml(root: &mut Value, path: &[&str]) { if !target.is_array() { *target = Value::Array(Array::new()); } - target.as_array_mut().unwrap().push(Value::Table(Table::new())); + target + .as_array_mut() + .unwrap() + .push(Value::Table(Table::new())); } fn traverse<'a>(root: &'a mut Value, path: &[&str]) -> &'a mut Value { @@ -32,8 +32,8 @@ use std::fmt::{self, Write}; use std::marker; use std::rc::Rc; -use serde::ser; use datetime; +use serde::ser; /// Serialize the given data structure as a TOML byte vector. /// @@ -41,7 +41,8 @@ use datetime; /// fail, if `T` contains a map with non-string keys, or if `T` attempts to /// serialize an unsupported datatype such as an enum, tuple, or tuple struct. pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Error> - where T: ser::Serialize, +where + T: ser::Serialize, { to_string(value).map(|e| e.into_bytes()) } @@ -87,7 +88,8 @@ pub fn to_vec<T: ?Sized>(value: &T) -> Result<Vec<u8>, Error> /// } /// ``` pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error> - where T: ser::Serialize, +where + T: ser::Serialize, { let mut dst = String::with_capacity(128); value.serialize(&mut Serializer::new(&mut dst))?; @@ -99,7 +101,8 @@ pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error> /// This is identical to `to_string` except the output string has a more /// "pretty" output. See `Serializer::pretty` for more details. pub fn to_string_pretty<T: ?Sized>(value: &T) -> Result<String, Error> - where T: ser::Serialize, +where + T: ser::Serialize, { let mut dst = String::with_capacity(128); value.serialize(&mut Serializer::pretty(&mut dst))?; @@ -177,9 +180,7 @@ struct StringSettings { impl StringSettings { fn pretty() -> StringSettings { - StringSettings { - literal: true, - } + StringSettings { literal: true } } } @@ -239,7 +240,7 @@ pub enum SerializeTable<'a: 'b, 'b> { key: String, first: Cell<bool>, table_emitted: Cell<bool>, - } + }, } impl<'a> Serializer<'a> { @@ -333,13 +334,13 @@ impl<'a> Serializer<'a> { /// """ /// ``` pub fn pretty_string_literal(&mut self, value: bool) -> &mut Self { - let use_default = if let &mut Some(ref mut s) = &mut Rc::get_mut(&mut self.settings) - .unwrap().string { - s.literal = value; - false - } else { - true - }; + let use_default = + if let &mut Some(ref mut s) = &mut Rc::get_mut(&mut self.settings).unwrap().string { + s.literal = value; + false + } else { + true + }; if use_default { let mut string = StringSettings::pretty(); @@ -389,13 +390,13 @@ impl<'a> Serializer<'a> { /// /// See `Serializer::pretty_array` for more details. pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self { - let use_default = if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings) - .unwrap().array { - a.indent = value; - false - } else { - true - }; + let use_default = + if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings).unwrap().array { + a.indent = value; + false + } else { + true + }; if use_default { let mut array = ArraySettings::pretty(); @@ -409,13 +410,13 @@ impl<'a> Serializer<'a> { /// /// See `Serializer::pretty_array` for more details. pub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self { - let use_default = if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings) - .unwrap().array { - a.trailing_comma = value; - false - } else { - true - }; + let use_default = + if let &mut Some(ref mut a) = &mut Rc::get_mut(&mut self.settings).unwrap().array { + a.trailing_comma = value; + false + } else { + true + }; if use_default { let mut array = ArraySettings::pretty(); @@ -425,9 +426,7 @@ impl<'a> Serializer<'a> { self } - fn display<T: fmt::Display>(&mut self, - t: T, - type_: &'static str) -> Result<(), Error> { + fn display<T: fmt::Display>(&mut self, t: T, type_: &'static str) -> Result<(), Error> { self.emit_key(type_)?; drop(write!(self.dst, "{}", t)); if let State::Table { .. } = self.state { @@ -446,16 +445,26 @@ impl<'a> Serializer<'a> { fn _emit_key(&mut self, state: &State) -> Result<(), Error> { match *state { State::End => Ok(()), - State::Array { parent, first, type_, len } => { + State::Array { + parent, + first, + type_, + len, + } => { assert!(type_.get().is_some()); if first.get() { self._emit_key(parent)?; } self.emit_array(first, len) } - State::Table { parent, first, table_emitted, key } => { + State::Table { + parent, + first, + table_emitted, + key, + } => { if table_emitted.get() { - return Err(Error::ValueAfterTable) + return Err(Error::ValueAfterTable); } if first.get() { self.emit_table_header(parent)?; @@ -476,7 +485,7 @@ impl<'a> Serializer<'a> { } else { self.dst.push_str(", ") } - }, + } (_, &Some(ref a)) => { if first.get() { self.dst.push_str("[\n") @@ -486,7 +495,7 @@ impl<'a> Serializer<'a> { for _ in 0..a.indent { self.dst.push_str(" "); } - }, + } } Ok(()) } @@ -498,7 +507,7 @@ impl<'a> Serializer<'a> { }; if let Some(prev) = prev.get() { if prev != type_ { - return Err(Error::ArrayMixedType) + return Err(Error::ArrayMixedType); } } else { prev.set(Some(type_)); @@ -507,14 +516,9 @@ impl<'a> Serializer<'a> { } fn escape_key(&mut self, key: &str) -> Result<(), Error> { - let ok = key.chars().all(|c| { - match c { - 'a' ... 'z' | - 'A' ... 'Z' | - '0' ... '9' | - '-' | '_' => true, - _ => false, - } + let ok = key.chars().all(|c| match c { + 'a'...'z' | 'A'...'Z' | '0'...'9' | '-' | '_' => true, + _ => false, }); if ok { drop(write!(self.dst, "{}", key)); @@ -570,7 +574,7 @@ impl<'a> Serializer<'a> { found_singles = 0 } match ch { - '\t' => {}, + '\t' => {} '\n' => ty = Type::NewlineTripple, // note that the following are invalid: \b \f \r c if c < '\u{1f}' => can_be_pretty = false, // Invalid control character @@ -606,8 +610,9 @@ impl<'a> Serializer<'a> { let repr = if !is_key && self.settings.string.is_some() { match (&self.settings.string, do_pretty(value)) { - (&Some(StringSettings { literal: false, .. }), Repr::Literal(_, ty)) => - Repr::Std(ty), + (&Some(StringSettings { literal: false, .. }), Repr::Literal(_, ty)) => { + Repr::Std(ty) + } (_, r @ _) => r, } } else { @@ -626,26 +631,23 @@ impl<'a> Serializer<'a> { Type::OnelineSingle => self.dst.push('\''), _ => self.dst.push_str("'''"), } - }, + } Repr::Std(ty) => { match ty { - Type::NewlineTripple => self.dst.push_str("\"\"\"\n"), + Type::NewlineTripple => self.dst.push_str("\"\"\"\n"), // note: OnelineTripple can happen if do_pretty wants to do // '''it's one line''' // but settings.string.literal == false - Type::OnelineSingle | - Type::OnelineTripple => self.dst.push('"'), + Type::OnelineSingle | Type::OnelineTripple => self.dst.push('"'), } for ch in value.chars() { match ch { '\u{8}' => self.dst.push_str("\\b"), '\u{9}' => self.dst.push_str("\\t"), - '\u{a}' => { - match ty { - Type::NewlineTripple => self.dst.push('\n'), - Type::OnelineSingle => self.dst.push_str("\\n"), - _ => unreachable!(), - } + '\u{a}' => match ty { + Type::NewlineTripple => self.dst.push('\n'), + Type::OnelineSingle => self.dst.push_str("\\n"), + _ => unreachable!(), }, '\u{c}' => self.dst.push_str("\\f"), '\u{d}' => self.dst.push_str("\\r"), @@ -656,10 +658,10 @@ impl<'a> Serializer<'a> { } } match ty { - Type::NewlineTripple => self.dst.push_str("\"\"\""), + Type::NewlineTripple => self.dst.push_str("\"\"\""), Type::OnelineSingle | Type::OnelineTripple => self.dst.push('"'), } - }, + } } Ok(()) } @@ -684,7 +686,11 @@ impl<'a> Serializer<'a> { if !first.get() { break; } - if let State::Array { parent: &State::Table {..}, ..} = *parent { + if let State::Array { + parent: &State::Table { .. }, + .. + } = *parent + { self.emit_table_header(parent)?; break; } @@ -697,7 +703,7 @@ impl<'a> Serializer<'a> { // table in the document. self.dst.push('\n'); } - }, + } State::Array { parent, first, .. } => { if !first.get() { // Always newline if we are not the first item in the @@ -709,7 +715,7 @@ impl<'a> Serializer<'a> { self.dst.push('\n'); } } - }, + } _ => {} } self.dst.push_str("["); @@ -728,9 +734,14 @@ impl<'a> Serializer<'a> { match *key { State::Array { parent, .. } => self.emit_key_part(parent), State::End => Ok(true), - State::Table { key, parent, table_emitted, .. } => { + State::Table { + key, + parent, + table_emitted, + .. + } => { table_emitted.set(true); - let first = self.emit_key_part(parent)?; + let first = self.emit_key_part(parent)?; if !first { self.dst.push_str("."); } @@ -841,7 +852,8 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> { } fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Self::Error> - where T: ser::Serialize + where + T: ser::Serialize, { value.serialize(self) } @@ -850,40 +862,44 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> { Err(Error::UnsupportedType) } - fn serialize_unit_struct(self, - _name: &'static str) - -> Result<(), Self::Error> { + fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> { Err(Error::UnsupportedType) } - fn serialize_unit_variant(self, - _name: &'static str, - _variant_index: u32, - variant: &'static str) - -> Result<(), Self::Error> { + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + ) -> Result<(), Self::Error> { self.serialize_str(variant) } - fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) - -> Result<(), Self::Error> - where T: ser::Serialize, + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + value: &T, + ) -> Result<(), Self::Error> + where + T: ser::Serialize, { value.serialize(self) } - fn serialize_newtype_variant<T: ?Sized>(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T) - -> Result<(), Self::Error> - where T: ser::Serialize, + fn serialize_newtype_variant<T: ?Sized>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> Result<(), Self::Error> + where + T: ser::Serialize, { Err(Error::UnsupportedType) } - fn serialize_seq(self, len: Option<usize>) - -> Result<Self::SerializeSeq, Self::Error> { + fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { self.array_type("array")?; Ok(SerializeSeq { ser: self, @@ -893,27 +909,29 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> { }) } - fn serialize_tuple(self, len: usize) - -> Result<Self::SerializeTuple, Self::Error> { + fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> { self.serialize_seq(Some(len)) } - fn serialize_tuple_struct(self, _name: &'static str, len: usize) - -> Result<Self::SerializeTupleStruct, Self::Error> { + fn serialize_tuple_struct( + self, + _name: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { self.serialize_seq(Some(len)) } - fn serialize_tuple_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - len: usize) - -> Result<Self::SerializeTupleVariant, Self::Error> { + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { self.serialize_seq(Some(len)) } - fn serialize_map(self, _len: Option<usize>) - -> Result<Self::SerializeMap, Self::Error> { + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { self.array_type("table")?; Ok(SerializeTable::Table { ser: self, @@ -923,8 +941,11 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> { }) } - fn serialize_struct(self, name: &'static str, _len: usize) - -> Result<Self::SerializeStruct, Self::Error> { + fn serialize_struct( + self, + name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { if name == datetime::NAME { self.array_type("datetime")?; Ok(SerializeTable::Datetime(self)) @@ -939,12 +960,13 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> { } } - fn serialize_struct_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result<Self::SerializeStructVariant, Self::Error> { + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { Err(Error::UnsupportedType) } } @@ -954,7 +976,8 @@ impl<'a, 'b> ser::SerializeSeq for SerializeSeq<'a, 'b> { type Error = Error; fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize, + where + T: ser::Serialize, { value.serialize(&mut Serializer { dst: &mut *self.ser.dst, @@ -973,19 +996,17 @@ impl<'a, 'b> ser::SerializeSeq for SerializeSeq<'a, 'b> { fn end(self) -> Result<(), Error> { match self.type_.get() { Some("table") => return Ok(()), - Some(_) => { - match (self.len, &self.ser.settings.array) { - (Some(0...1), _) | (_, &None) => { - self.ser.dst.push_str("]"); - }, - (_, &Some(ref a)) => { - if a.trailing_comma { - self.ser.dst.push_str(","); - } - self.ser.dst.push_str("\n]"); - }, + Some(_) => match (self.len, &self.ser.settings.array) { + (Some(0...1), _) | (_, &None) => { + self.ser.dst.push_str("]"); } - } + (_, &Some(ref a)) => { + if a.trailing_comma { + self.ser.dst.push_str(","); + } + self.ser.dst.push_str("\n]"); + } + }, None => { assert!(self.first.get()); self.ser.emit_key("array")?; @@ -1004,7 +1025,8 @@ impl<'a, 'b> ser::SerializeTuple for SerializeSeq<'a, 'b> { type Error = Error; fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize, + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -1019,7 +1041,8 @@ impl<'a, 'b> ser::SerializeTupleVariant for SerializeSeq<'a, 'b> { type Error = Error; fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize, + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -1034,7 +1057,8 @@ impl<'a, 'b> ser::SerializeTupleStruct for SerializeSeq<'a, 'b> { type Error = Error; fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize, + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -1049,7 +1073,8 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> { type Error = Error; fn serialize_key<T: ?Sized>(&mut self, input: &T) -> Result<(), Error> - where T: ser::Serialize, + where + T: ser::Serialize, { match *self { SerializeTable::Datetime(_) => panic!(), // shouldn't be possible @@ -1062,7 +1087,8 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> { } fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> - where T: ser::Serialize, + where + T: ser::Serialize, { match *self { SerializeTable::Datetime(_) => panic!(), // shouldn't be possible @@ -1085,7 +1111,7 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> { }); match res { Ok(()) => first.set(false), - Err(Error::UnsupportedNone) => {}, + Err(Error::UnsupportedNone) => {} Err(e) => return Err(e), } } @@ -1096,7 +1122,7 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> { fn end(self) -> Result<(), Error> { match self { SerializeTable::Datetime(_) => panic!(), // shouldn't be possible - SerializeTable::Table { ser, first, .. } => { + SerializeTable::Table { ser, first, .. } => { if first.get() { let state = ser.state.clone(); ser.emit_table_header(&state)?; @@ -1111,16 +1137,16 @@ impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> { type Ok = (); type Error = Error; - fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) - -> Result<(), Error> - where T: ser::Serialize, + fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error> + where + T: ser::Serialize, { match *self { SerializeTable::Datetime(ref mut ser) => { if key == datetime::FIELD { value.serialize(DateStrEmitter(&mut *ser))?; } else { - return Err(Error::DateInvalid) + return Err(Error::DateInvalid); } } SerializeTable::Table { @@ -1141,7 +1167,7 @@ impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> { }); match res { Ok(()) => first.set(false), - Err(Error::UnsupportedNone) => {}, + Err(Error::UnsupportedNone) => {} Err(e) => return Err(e), } } @@ -1151,8 +1177,8 @@ impl<'a, 'b> ser::SerializeStruct for SerializeTable<'a, 'b> { fn end(self) -> Result<(), Error> { match self { - SerializeTable::Datetime(_) => {}, - SerializeTable::Table { ser, first, .. } => { + SerializeTable::Datetime(_) => {} + SerializeTable::Table { ser, first, .. } => { if first.get() { let state = ser.state.clone(); ser.emit_table_header(&state)?; @@ -1238,7 +1264,8 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> { } fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<(), Self::Error> - where T: ser::Serialize + where + T: ser::Serialize, { Err(Error::KeyNotString) } @@ -1247,78 +1274,88 @@ impl<'a, 'b> ser::Serializer for DateStrEmitter<'a, 'b> { Err(Error::KeyNotString) } - fn serialize_unit_struct(self, - _name: &'static str) - -> Result<(), Self::Error> { + fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error> { Err(Error::DateInvalid) } - fn serialize_unit_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str) - -> Result<(), Self::Error> { + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> Result<(), Self::Error> { Err(Error::DateInvalid) } - fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, _value: &T) - -> Result<(), Self::Error> - where T: ser::Serialize, + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + _value: &T, + ) -> Result<(), Self::Error> + where + T: ser::Serialize, { Err(Error::DateInvalid) } - fn serialize_newtype_variant<T: ?Sized>(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T) - -> Result<(), Self::Error> - where T: ser::Serialize, + fn serialize_newtype_variant<T: ?Sized>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> Result<(), Self::Error> + where + T: ser::Serialize, { Err(Error::DateInvalid) } - fn serialize_seq(self, _len: Option<usize>) - -> Result<Self::SerializeSeq, Self::Error> { + fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { Err(Error::DateInvalid) } - fn serialize_tuple(self, _len: usize) - -> Result<Self::SerializeTuple, Self::Error> { + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { Err(Error::DateInvalid) } - fn serialize_tuple_struct(self, _name: &'static str, _len: usize) - -> Result<Self::SerializeTupleStruct, Self::Error> { + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { Err(Error::DateInvalid) } - fn serialize_tuple_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result<Self::SerializeTupleVariant, Self::Error> { + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { Err(Error::DateInvalid) } - fn serialize_map(self, _len: Option<usize>) - -> Result<Self::SerializeMap, Self::Error> { + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { Err(Error::DateInvalid) } - fn serialize_struct(self, _name: &'static str, _len: usize) - -> Result<Self::SerializeStruct, Self::Error> { + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { Err(Error::DateInvalid) } - fn serialize_struct_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result<Self::SerializeStructVariant, Self::Error> { + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { Err(Error::DateInvalid) } } @@ -1397,7 +1434,8 @@ impl ser::Serializer for StringExtractor { } fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<String, Self::Error> - where T: ser::Serialize + where + T: ser::Serialize, { Err(Error::KeyNotString) } @@ -1406,78 +1444,88 @@ impl ser::Serializer for StringExtractor { Err(Error::KeyNotString) } - fn serialize_unit_struct(self, - _name: &'static str) - -> Result<String, Self::Error> { + fn serialize_unit_struct(self, _name: &'static str) -> Result<String, Self::Error> { Err(Error::KeyNotString) } - fn serialize_unit_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str) - -> Result<String, Self::Error> { + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> Result<String, Self::Error> { Err(Error::KeyNotString) } - fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) - -> Result<String, Self::Error> - where T: ser::Serialize, + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + value: &T, + ) -> Result<String, Self::Error> + where + T: ser::Serialize, { value.serialize(self) } - fn serialize_newtype_variant<T: ?Sized>(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T) - -> Result<String, Self::Error> - where T: ser::Serialize, + fn serialize_newtype_variant<T: ?Sized>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> Result<String, Self::Error> + where + T: ser::Serialize, { Err(Error::KeyNotString) } - fn serialize_seq(self, _len: Option<usize>) - -> Result<Self::SerializeSeq, Self::Error> { + fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { Err(Error::KeyNotString) } - fn serialize_tuple(self, _len: usize) - -> Result<Self::SerializeTuple, Self::Error> { + fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { Err(Error::KeyNotString) } - fn serialize_tuple_struct(self, _name: &'static str, _len: usize) - -> Result<Self::SerializeTupleStruct, Self::Error> { + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { Err(Error::KeyNotString) } - fn serialize_tuple_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result<Self::SerializeTupleVariant, Self::Error> { + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { Err(Error::KeyNotString) } - fn serialize_map(self, _len: Option<usize>) - -> Result<Self::SerializeMap, Self::Error> { + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { Err(Error::KeyNotString) } - fn serialize_struct(self, _name: &'static str, _len: usize) - -> Result<Self::SerializeStruct, Self::Error> { + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result<Self::SerializeStruct, Self::Error> { Err(Error::KeyNotString) } - fn serialize_struct_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result<Self::SerializeStructVariant, Self::Error> { + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { Err(Error::KeyNotString) } } @@ -1549,12 +1597,12 @@ enum Category { /// # type Dependency = String; /// # fn main() {} /// ``` -pub fn tables_last<'a, I, K, V, S>(data: &'a I, serializer: S) - -> Result<S::Ok, S::Error> - where &'a I: IntoIterator<Item = (K, V)>, - K: ser::Serialize, - V: ser::Serialize, - S: ser::Serializer +pub fn tables_last<'a, I, K, V, S>(data: &'a I, serializer: S) -> Result<S::Ok, S::Error> +where + &'a I: IntoIterator<Item = (K, V)>, + K: ser::Serialize, + V: ser::Serialize, + S: ser::Serializer, { use serde::ser::SerializeMap; @@ -1668,15 +1716,30 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> { Err(ser::Error::custom("unsupported")) } - fn serialize_unit_variant(self, _: &'static str, _: u32, _: &'static str) -> Result<Self::Ok, Self::Error> { + fn serialize_unit_variant( + self, + _: &'static str, + _: u32, + _: &'static str, + ) -> Result<Self::Ok, Self::Error> { Err(ser::Error::custom("unsupported")) } - fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(self, _: &'static str, v: &T) -> Result<Self::Ok, Self::Error> { + fn serialize_newtype_struct<T: ?Sized + ser::Serialize>( + self, + _: &'static str, + v: &T, + ) -> Result<Self::Ok, Self::Error> { v.serialize(self) } - fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self, _: &'static str, _: u32, _: &'static str, _: &T) -> Result<Self::Ok, Self::Error> { + fn serialize_newtype_variant<T: ?Sized + ser::Serialize>( + self, + _: &'static str, + _: u32, + _: &'static str, + _: &T, + ) -> Result<Self::Ok, Self::Error> { Err(ser::Error::custom("unsupported")) } @@ -1688,11 +1751,21 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> { Ok(self) } - fn serialize_tuple_struct(self, _: &'static str, _: usize) -> Result<Self::SerializeTupleStruct, Self::Error> { + fn serialize_tuple_struct( + self, + _: &'static str, + _: usize, + ) -> Result<Self::SerializeTupleStruct, Self::Error> { Ok(self) } - fn serialize_tuple_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeTupleVariant, Self::Error> { + fn serialize_tuple_variant( + self, + _: &'static str, + _: u32, + _: &'static str, + _: usize, + ) -> Result<Self::SerializeTupleVariant, Self::Error> { Ok(self) } @@ -1704,7 +1777,13 @@ impl<E: ser::Error> ser::Serializer for Categorize<E> { Ok(self) } - fn serialize_struct_variant(self, _: &'static str, _: u32, _: &'static str, _: usize) -> Result<Self::SerializeStructVariant, Self::Error> { + fn serialize_struct_variant( + self, + _: &'static str, + _: u32, + _: &'static str, + _: usize, + ) -> Result<Self::SerializeStructVariant, Self::Error> { Err(ser::Error::custom("unsupported")) } } @@ -1713,8 +1792,7 @@ impl<E: ser::Error> ser::SerializeSeq for Categorize<E> { type Ok = Category; type Error = E; - fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) - -> Result<(), Self::Error> { + fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> { Ok(()) } @@ -1727,8 +1805,7 @@ impl<E: ser::Error> ser::SerializeTuple for Categorize<E> { type Ok = Category; type Error = E; - fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) - -> Result<(), Self::Error> { + fn serialize_element<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> { Ok(()) } @@ -1741,8 +1818,7 @@ impl<E: ser::Error> ser::SerializeTupleVariant for Categorize<E> { type Ok = Category; type Error = E; - fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) - -> Result<(), Self::Error> { + fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> { Ok(()) } @@ -1755,8 +1831,7 @@ impl<E: ser::Error> ser::SerializeTupleStruct for Categorize<E> { type Ok = Category; type Error = E; - fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) - -> Result<(), Self::Error> { + fn serialize_field<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> { Ok(()) } @@ -1769,13 +1844,11 @@ impl<E: ser::Error> ser::SerializeMap for Categorize<E> { type Ok = Category; type Error = E; - fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, _: &T) - -> Result<(), Self::Error> { + fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> { Ok(()) } - fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, _: &T) - -> Result<(), Self::Error> { + fn serialize_value<T: ?Sized + ser::Serialize>(&mut self, _: &T) -> Result<(), Self::Error> { Ok(()) } @@ -1788,10 +1861,9 @@ impl<E: ser::Error> ser::SerializeStruct for Categorize<E> { type Ok = Category; type Error = E; - fn serialize_field<T: ?Sized>(&mut self, - _: &'static str, - _: &T) -> Result<(), Self::Error> - where T: ser::Serialize, + fn serialize_field<T: ?Sized>(&mut self, _: &'static str, _: &T) -> Result<(), Self::Error> + where + T: ser::Serialize, { Ok(()) } diff --git a/src/spanned.rs b/src/spanned.rs index abbbd49..fb476ee 100644 --- a/src/spanned.rs +++ b/src/spanned.rs @@ -78,15 +78,18 @@ impl<T> Spanned<T> { } impl<'de, T> de::Deserialize<'de> for Spanned<T> - where T: de::Deserialize<'de> +where + T: de::Deserialize<'de>, { fn deserialize<D>(deserializer: D) -> Result<Spanned<T>, D::Error> - where D: de::Deserializer<'de> + where + D: de::Deserializer<'de>, { struct SpannedVisitor<T>(::std::marker::PhantomData<T>); impl<'de, T> de::Visitor<'de> for SpannedVisitor<T> - where T: de::Deserialize<'de> + where + T: de::Deserialize<'de>, { type Value = Spanned<T>; @@ -95,22 +98,23 @@ impl<'de, T> de::Deserialize<'de> for Spanned<T> } fn visit_map<V>(self, mut visitor: V) -> Result<Spanned<T>, V::Error> - where V: de::MapAccess<'de> + where + V: de::MapAccess<'de>, { if visitor.next_key()? != Some(START) { - return Err(de::Error::custom("spanned start key not found")) + return Err(de::Error::custom("spanned start key not found")); } let start: usize = visitor.next_value()?; if visitor.next_key()? != Some(END) { - return Err(de::Error::custom("spanned end key not found")) + return Err(de::Error::custom("spanned end key not found")); } let end: usize = visitor.next_value()?; if visitor.next_key()? != Some(VALUE) { - return Err(de::Error::custom("spanned value key not found")) + return Err(de::Error::custom("spanned value key not found")); } let value: T = visitor.next_value()?; @@ -118,7 +122,7 @@ impl<'de, T> de::Deserialize<'de> for Spanned<T> Ok(Spanned { start: start, end: end, - value: value + value: value, }) } } diff --git a/src/tokens.rs b/src/tokens.rs index 382c1ec..064c804 100644 --- a/src/tokens.rs +++ b/src/tokens.rs @@ -38,7 +38,11 @@ pub enum Token<'a> { RightBracket, Keylike(&'a str), - String { src: &'a str, val: Cow<'a, str>, multiline: bool }, + String { + src: &'a str, + val: Cow<'a, str>, + multiline: bool, + }, } #[derive(Eq, PartialEq, Debug)] @@ -53,7 +57,11 @@ pub enum Error { NewlineInTableKey(usize), MultilineStringKey(usize), EmptyTableKey(usize), - Wanted { at: usize, expected: &'static str, found: &'static str }, + Wanted { + at: usize, + expected: &'static str, + found: &'static str, + }, } #[derive(Clone)] @@ -101,10 +109,16 @@ impl<'a> Tokenizer<'a> { Some((start, '}')) => (start, RightBrace), Some((start, '[')) => (start, LeftBracket), Some((start, ']')) => (start, RightBracket), - Some((start, '\'')) => return self.literal_string(start) - .map(|t| Some((self.step_span(start), t))), - Some((start, '"')) => return self.basic_string(start) - .map(|t| Some((self.step_span(start), t))), + Some((start, '\'')) => { + return self + .literal_string(start) + .map(|t| Some((self.step_span(start), t))) + } + Some((start, '"')) => { + return self + .basic_string(start) + .map(|t| Some((self.step_span(start), t))) + } Some((start, ch)) if is_keylike(ch) => (start, self.keylike(start)), Some((start, ch)) => return Err(Error::Unexpected(start, ch)), @@ -156,13 +170,11 @@ impl<'a> Tokenizer<'a> { }) } } - None => { - Err(Error::Wanted { - at: self.input.len(), - expected: expected.describe(), - found: "eof", - }) - } + None => Err(Error::Wanted { + at: self.input.len(), + expected: expected.describe(), + found: "eof", + }), } } @@ -170,33 +182,36 @@ impl<'a> Tokenizer<'a> { let current = self.current(); match self.next()? { Some((span, Token::Keylike(k))) => Ok((span, k.into())), - Some((span, Token::String { src, val, multiline })) => { + Some(( + span, + Token::String { + src, + val, + multiline, + }, + )) => { let offset = self.substr_offset(src); if multiline { - return Err(Error::MultilineStringKey(offset)) + return Err(Error::MultilineStringKey(offset)); } if val == "" { - return Err(Error::EmptyTableKey(offset)) + return Err(Error::EmptyTableKey(offset)); } match src.find('\n') { None => Ok((span, val)), Some(i) => Err(Error::NewlineInTableKey(offset + i)), } } - Some((_, other)) => { - Err(Error::Wanted { - at: current, - expected: "a table key", - found: other.describe(), - }) - } - None => { - Err(Error::Wanted { - at: self.input.len(), - expected: "a table key", - found: "eof", - }) - } + Some((_, other)) => Err(Error::Wanted { + at: current, + expected: "a table key", + found: other.describe(), + }), + None => Err(Error::Wanted { + at: self.input.len(), + expected: "a table key", + found: "eof", + }), } } @@ -209,7 +224,7 @@ impl<'a> Tokenizer<'a> { pub fn eat_comment(&mut self) -> Result<bool, Error> { if !self.eatc('#') { - return Ok(false) + return Ok(false); } drop(self.comment_token(0)); self.eat_newline_or_eof().map(|()| true) @@ -218,23 +233,19 @@ impl<'a> Tokenizer<'a> { pub fn eat_newline_or_eof(&mut self) -> Result<(), Error> { let current = self.current(); match self.next()? { - None | - Some((_, Token::Newline)) => Ok(()), - Some((_, other)) => { - Err(Error::Wanted { - at: current, - expected: "newline", - found: other.describe(), - }) - } + None | Some((_, Token::Newline)) => Ok(()), + Some((_, other)) => Err(Error::Wanted { + at: current, + expected: "newline", + found: other.describe(), + }), } } pub fn skip_to_newline(&mut self) { loop { match self.one() { - Some((_, '\n')) | - None => break, + Some((_, '\n')) | None => break, _ => {} } } @@ -251,7 +262,11 @@ impl<'a> Tokenizer<'a> { } pub fn current(&mut self) -> usize { - self.chars.clone().next().map(|i| i.0).unwrap_or(self.input.len()) + self.chars + .clone() + .next() + .map(|i| i.0) + .unwrap_or(self.input.len()) } pub fn input(&self) -> &'a str { @@ -268,30 +283,35 @@ impl<'a> Tokenizer<'a> { fn comment_token(&mut self, start: usize) -> Token<'a> { while let Some((_, ch)) = self.chars.clone().next() { if ch != '\t' && (ch < '\u{20}' || ch > '\u{10ffff}') { - break + break; } self.one(); } Comment(&self.input[start..self.current()]) } - fn read_string(&mut self, - delim: char, - start: usize, - new_ch: &mut FnMut(&mut Tokenizer, &mut MaybeString, - bool, usize, char) - -> Result<(), Error>) - -> Result<Token<'a>, Error> { + fn read_string( + &mut self, + delim: char, + start: usize, + new_ch: &mut FnMut( + &mut Tokenizer, + &mut MaybeString, + bool, + usize, + char, + ) -> Result<(), Error>, + ) -> Result<Token<'a>, Error> { let mut multiline = false; if self.eatc(delim) { if self.eatc(delim) { multiline = true; } else { return Ok(String { - src: &self.input[start..start+2], + src: &self.input[start..start + 2], val: Cow::Borrowed(""), multiline: false, - }) + }); } } let mut val = MaybeString::NotEscaped(self.current()); @@ -309,9 +329,9 @@ impl<'a> Tokenizer<'a> { } else { val.push('\n'); } - continue + continue; } else { - return Err(Error::NewlineInString(i)) + return Err(Error::NewlineInString(i)); } } Some((i, ch)) if ch == delim => { @@ -319,7 +339,7 @@ impl<'a> Tokenizer<'a> { for _ in 0..2 { if !self.eatc(delim) { val.push(delim); - continue 'outer + continue 'outer; } } } @@ -327,10 +347,10 @@ impl<'a> Tokenizer<'a> { src: &self.input[start..self.current()], val: val.into_cow(&self.input[..i]), multiline: multiline, - }) + }); } Some((i, c)) => new_ch(self, &mut val, multiline, i, c)?, - None => return Err(Error::UnterminatedString(start)) + None => return Err(Error::UnterminatedString(start)), } } } @@ -347,61 +367,56 @@ impl<'a> Tokenizer<'a> { } fn basic_string(&mut self, start: usize) -> Result<Token<'a>, Error> { - self.read_string('"', start, &mut |me, val, multi, i, ch| { - match ch { - '\\' => { - val.to_owned(&me.input[..i]); - match me.chars.next() { - Some((_, '"')) => val.push('"'), - Some((_, '\\')) => val.push('\\'), - Some((_, 'b')) => val.push('\u{8}'), - Some((_, 'f')) => val.push('\u{c}'), - Some((_, 'n')) => val.push('\n'), - Some((_, 'r')) => val.push('\r'), - Some((_, 't')) => val.push('\t'), - Some((i, c @ 'u')) | - Some((i, c @ 'U')) => { - let len = if c == 'u' {4} else {8}; - val.push(me.hex(start, i, len)?); - } - Some((i, c @ ' ')) | - Some((i, c @ '\t')) | - Some((i, c @ '\n')) if multi => { - if c != '\n' { - while let Some((_, ch)) = me.chars.clone().next() { - match ch { - ' ' | '\t' => { - me.chars.next(); - continue - }, - '\n' => { - me.chars.next(); - break - }, - _ => return Err(Error::InvalidEscape(i, c)), - } - } - } + self.read_string('"', start, &mut |me, val, multi, i, ch| match ch { + '\\' => { + val.to_owned(&me.input[..i]); + match me.chars.next() { + Some((_, '"')) => val.push('"'), + Some((_, '\\')) => val.push('\\'), + Some((_, 'b')) => val.push('\u{8}'), + Some((_, 'f')) => val.push('\u{c}'), + Some((_, 'n')) => val.push('\n'), + Some((_, 'r')) => val.push('\r'), + Some((_, 't')) => val.push('\t'), + Some((i, c @ 'u')) | Some((i, c @ 'U')) => { + let len = if c == 'u' { 4 } else { 8 }; + val.push(me.hex(start, i, len)?); + } + Some((i, c @ ' ')) | Some((i, c @ '\t')) | Some((i, c @ '\n')) if multi => { + if c != '\n' { while let Some((_, ch)) = me.chars.clone().next() { match ch { - ' ' | '\t' | '\n' => { + ' ' | '\t' => { + me.chars.next(); + continue; + } + '\n' => { me.chars.next(); + break; } - _ => break, + _ => return Err(Error::InvalidEscape(i, c)), } } } - Some((i, c)) => return Err(Error::InvalidEscape(i, c)), - None => return Err(Error::UnterminatedString(start)), + while let Some((_, ch)) = me.chars.clone().next() { + match ch { + ' ' | '\t' | '\n' => { + me.chars.next(); + } + _ => break, + } + } } - Ok(()) - } - ch if '\u{20}' <= ch && ch <= '\u{10ffff}' && ch != '\u{7f}' => { - val.push(ch); - Ok(()) + Some((i, c)) => return Err(Error::InvalidEscape(i, c)), + None => return Err(Error::UnterminatedString(start)), } - _ => Err(Error::InvalidCharInString(i, ch)) + Ok(()) + } + ch if '\u{20}' <= ch && ch <= '\u{10ffff}' && ch != '\u{7f}' => { + val.push(ch); + Ok(()) } + _ => Err(Error::InvalidCharInString(i, ch)), }) } @@ -424,7 +439,7 @@ impl<'a> Tokenizer<'a> { fn keylike(&mut self, start: usize) -> Token<'a> { while let Some((_, ch)) = self.peek_one() { if !is_keylike(ch) { - break + break; } self.one(); } @@ -441,8 +456,14 @@ impl<'a> Tokenizer<'a> { /// Calculate the span of a single character. fn step_span(&mut self, start: usize) -> Span { - let end = self.peek_one().map(|t| t.0).unwrap_or_else(|| self.input.len()); - Span { start: start, end: end } + let end = self + .peek_one() + .map(|t| t.0) + .unwrap_or_else(|| self.input.len()); + Span { + start: start, + end: end, + } } /// Peek one char without consuming it. @@ -465,7 +486,7 @@ impl<'a> Iterator for CrlfFold<'a> { let mut attempt = self.chars.clone(); if let Some((_, '\n')) = attempt.next() { self.chars = attempt; - return (i, '\n') + return (i, '\n'); } } (i, c) @@ -499,11 +520,11 @@ impl MaybeString { } fn is_keylike(ch: char) -> bool { - ('A' <= ch && ch <= 'Z') || - ('a' <= ch && ch <= 'z') || - ('0' <= ch && ch <= '9') || - ch == '-' || - ch == '_' + ('A' <= ch && ch <= 'Z') + || ('a' <= ch && ch <= 'z') + || ('0' <= ch && ch <= '9') + || ch == '-' + || ch == '_' } impl<'a> Token<'a> { @@ -520,7 +541,13 @@ impl<'a> Token<'a> { Token::LeftBrace => "a left brace", Token::RightBracket => "a right bracket", Token::LeftBracket => "a left bracket", - Token::String { multiline, .. } => if multiline { "a multiline string" } else { "a string" }, + Token::String { multiline, .. } => { + if multiline { + "a multiline string" + } else { + "a string" + } + } Token::Colon => "a colon", Token::Plus => "a plus", } @@ -529,8 +556,8 @@ impl<'a> Token<'a> { #[cfg(test)] mod tests { + use super::{Error, Token, Tokenizer}; use std::borrow::Cow; - use super::{Tokenizer, Token, Error}; fn err(input: &str, err: Error) { let mut t = Tokenizer::new(input); @@ -544,11 +571,14 @@ mod tests { fn t(input: &str, val: &str, multiline: bool) { let mut t = Tokenizer::new(input); let (_, token) = t.next().unwrap().unwrap(); - assert_eq!(token, Token::String { - src: input, - val: Cow::Borrowed(val), - multiline: multiline, - }); + assert_eq!( + token, + Token::String { + src: input, + val: Cow::Borrowed(val), + multiline: multiline, + } + ); assert!(t.next().unwrap().is_none()); } @@ -567,11 +597,14 @@ mod tests { fn t(input: &str, val: &str, multiline: bool) { let mut t = Tokenizer::new(input); let (_, token) = t.next().unwrap().unwrap(); - assert_eq!(token, Token::String { - src: input, - val: Cow::Borrowed(val), - multiline: multiline, - }); + assert_eq!( + token, + Token::String { + src: input, + val: Cow::Borrowed(val), + multiline: multiline, + } + ); assert!(t.next().unwrap().is_none()); } @@ -585,7 +618,11 @@ mod tests { t(r#""\U000A0000""#, "\u{A0000}", false); t(r#""\\t""#, "\\t", false); t("\"\"\"\\\n\"\"\"", "", true); - t("\"\"\"\\\n \t \t \\\r\n \t \n \t \r\n\"\"\"", "", true); + t( + "\"\"\"\\\n \t \t \\\r\n \t \n \t \r\n\"\"\"", + "", + true, + ); t(r#""\r""#, "\r", false); t(r#""\n""#, "\n", false); t(r#""\b""#, "\u{8}", false); @@ -636,39 +673,45 @@ mod tests { assert_eq!(actual.len(), expected.len()); } - t(" a ", &[ - ((0, 1), Token::Whitespace(" "), " "), - ((1, 2), Token::Keylike("a"), "a"), - ((2, 3), Token::Whitespace(" "), " "), - ]); - - t(" a\t [[]] \t [] {} , . =\n# foo \r\n#foo \n ", &[ - ((0, 1), Token::Whitespace(" "), " "), - ((1, 2), Token::Keylike("a"), "a"), - ((2, 4), Token::Whitespace("\t "), "\t "), - ((4, 5), Token::LeftBracket, "["), - ((5, 6), Token::LeftBracket, "["), - ((6, 7), Token::RightBracket, "]"), - ((7, 8), Token::RightBracket, "]"), - ((8, 11), Token::Whitespace(" \t "), " \t "), - ((11, 12), Token::LeftBracket, "["), - ((12, 13), Token::RightBracket, "]"), - ((13, 14), Token::Whitespace(" "), " "), - ((14, 15), Token::LeftBrace, "{"), - ((15, 16), Token::RightBrace, "}"), - ((16, 17), Token::Whitespace(" "), " "), - ((17, 18), Token::Comma, ","), - ((18, 19), Token::Whitespace(" "), " "), - ((19, 20), Token::Period, "."), - ((20, 21), Token::Whitespace(" "), " "), - ((21, 22), Token::Equals, "="), - ((22, 23), Token::Newline, "\n"), - ((23, 29), Token::Comment("# foo "), "# foo "), - ((29, 31), Token::Newline, "\r\n"), - ((31, 36), Token::Comment("#foo "), "#foo "), - ((36, 37), Token::Newline, "\n"), - ((37, 38), Token::Whitespace(" "), " "), - ]); + t( + " a ", + &[ + ((0, 1), Token::Whitespace(" "), " "), + ((1, 2), Token::Keylike("a"), "a"), + ((2, 3), Token::Whitespace(" "), " "), + ], + ); + + t( + " a\t [[]] \t [] {} , . =\n# foo \r\n#foo \n ", + &[ + ((0, 1), Token::Whitespace(" "), " "), + ((1, 2), Token::Keylike("a"), "a"), + ((2, 4), Token::Whitespace("\t "), "\t "), + ((4, 5), Token::LeftBracket, "["), + ((5, 6), Token::LeftBracket, "["), + ((6, 7), Token::RightBracket, "]"), + ((7, 8), Token::RightBracket, "]"), + ((8, 11), Token::Whitespace(" \t "), " \t "), + ((11, 12), Token::LeftBracket, "["), + ((12, 13), Token::RightBracket, "]"), + ((13, 14), Token::Whitespace(" "), " "), + ((14, 15), Token::LeftBrace, "{"), + ((15, 16), Token::RightBrace, "}"), + ((16, 17), Token::Whitespace(" "), " "), + ((17, 18), Token::Comma, ","), + ((18, 19), Token::Whitespace(" "), " "), + ((19, 20), Token::Period, "."), + ((20, 21), Token::Whitespace(" "), " "), + ((21, 22), Token::Equals, "="), + ((22, 23), Token::Newline, "\n"), + ((23, 29), Token::Comment("# foo "), "# foo "), + ((29, 31), Token::Newline, "\r\n"), + ((31, 36), Token::Comment("#foo "), "#foo "), + ((36, 37), Token::Newline, "\n"), + ((37, 38), Token::Whitespace(" "), " "), + ], + ); } #[test] diff --git a/src/value.rs b/src/value.rs index 2e42dc3..ee952b6 100644 --- a/src/value.rs +++ b/src/value.rs @@ -1,18 +1,18 @@ //! Definition of a TOML value use std::collections::{BTreeMap, HashMap}; -use std::hash::Hash; use std::fmt; +use std::hash::Hash; use std::ops; use std::str::FromStr; use std::vec; -use serde::ser; use serde::de; use serde::de::IntoDeserializer; +use serde::ser; -pub use datetime::{Datetime, DatetimeParseError}; use datetime::{self, DatetimeFromString}; +pub use datetime::{Datetime, DatetimeParseError}; /// Representation of a TOML value. #[derive(PartialEq, Clone, Debug)] @@ -46,7 +46,8 @@ impl Value { /// This conversion can fail if `T`'s implementation of `Serialize` decides to /// fail, or if `T` contains a map with non-string keys. pub fn try_from<T>(value: T) -> Result<Value, ::ser::Error> - where T: ser::Serialize, + where + T: ser::Serialize, { value.serialize(Serializer) } @@ -61,7 +62,8 @@ impl Value { /// missing from the TOML map or some number is too big to fit in the expected /// primitive type. pub fn try_into<'de, T>(self) -> Result<T, ::de::Error> - where T: de::Deserialize<'de>, + where + T: de::Deserialize<'de>, { de::Deserialize::deserialize(self) } @@ -92,7 +94,10 @@ impl Value { /// Extracts the integer value if it is an integer. pub fn as_integer(&self) -> Option<i64> { - match *self { Value::Integer(i) => Some(i), _ => None } + match *self { + Value::Integer(i) => Some(i), + _ => None, + } } /// Tests whether this value is an integer. @@ -102,7 +107,10 @@ impl Value { /// Extracts the float value if it is a float. pub fn as_float(&self) -> Option<f64> { - match *self { Value::Float(f) => Some(f), _ => None } + match *self { + Value::Float(f) => Some(f), + _ => None, + } } /// Tests whether this value is a float. @@ -112,7 +120,10 @@ impl Value { /// Extracts the boolean value if it is a boolean. pub fn as_bool(&self) -> Option<bool> { - match *self { Value::Boolean(b) => Some(b), _ => None } + match *self { + Value::Boolean(b) => Some(b), + _ => None, + } } /// Tests whether this value is a boolean. @@ -122,7 +133,10 @@ impl Value { /// Extracts the string of this value if it is a string. pub fn as_str(&self) -> Option<&str> { - match *self { Value::String(ref s) => Some(&**s), _ => None } + match *self { + Value::String(ref s) => Some(&**s), + _ => None, + } } /// Tests if this value is a string. @@ -139,7 +153,10 @@ impl Value { /// 1979-05-27T07:32:00Z /// ``` pub fn as_datetime(&self) -> Option<&Datetime> { - match *self { Value::Datetime(ref s) => Some(s), _ => None } + match *self { + Value::Datetime(ref s) => Some(s), + _ => None, + } } /// Tests whether this value is a datetime. @@ -149,12 +166,18 @@ impl Value { /// Extracts the array value if it is an array. pub fn as_array(&self) -> Option<&Vec<Value>> { - match *self { Value::Array(ref s) => Some(s), _ => None } + match *self { + Value::Array(ref s) => Some(s), + _ => None, + } } /// Extracts the array value if it is an array. pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> { - match *self { Value::Array(ref mut s) => Some(s), _ => None } + match *self { + Value::Array(ref mut s) => Some(s), + _ => None, + } } /// Tests whether this value is an array. @@ -164,12 +187,18 @@ impl Value { /// Extracts the table value if it is a table. pub fn as_table(&self) -> Option<&Table> { - match *self { Value::Table(ref s) => Some(s), _ => None } + match *self { + Value::Table(ref s) => Some(s), + _ => None, + } } /// Extracts the table value if it is a table. pub fn as_table_mut(&mut self) -> Option<&mut Table> { - match *self { Value::Table(ref mut s) => Some(s), _ => None } + match *self { + Value::Table(ref mut s) => Some(s), + _ => None, + } } /// Tests whether this value is a table. @@ -180,13 +209,13 @@ impl Value { /// Tests whether this and another value have the same type. pub fn same_type(&self, other: &Value) -> bool { match (self, other) { - (&Value::String(..), &Value::String(..)) | - (&Value::Integer(..), &Value::Integer(..)) | - (&Value::Float(..), &Value::Float(..)) | - (&Value::Boolean(..), &Value::Boolean(..)) | - (&Value::Datetime(..), &Value::Datetime(..)) | - (&Value::Array(..), &Value::Array(..)) | - (&Value::Table(..), &Value::Table(..)) => true, + (&Value::String(..), &Value::String(..)) + | (&Value::Integer(..), &Value::Integer(..)) + | (&Value::Float(..), &Value::Float(..)) + | (&Value::Boolean(..), &Value::Boolean(..)) + | (&Value::Datetime(..), &Value::Datetime(..)) + | (&Value::Array(..), &Value::Array(..)) + | (&Value::Table(..), &Value::Table(..)) => true, _ => false, } @@ -206,7 +235,10 @@ impl Value { } } -impl<I> ops::Index<I> for Value where I: Index { +impl<I> ops::Index<I> for Value +where + I: Index, +{ type Output = Value; fn index(&self, index: I) -> &Value { @@ -214,7 +246,10 @@ impl<I> ops::Index<I> for Value where I: Index { } } -impl<I> ops::IndexMut<I> for Value where I: Index { +impl<I> ops::IndexMut<I> for Value +where + I: Index, +{ fn index_mut(&mut self, index: I) -> &mut Value { self.get_mut(index).expect("index not found") } @@ -235,9 +270,7 @@ impl<V: Into<Value>> From<Vec<V>> for Value { impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value { fn from(val: BTreeMap<S, V>) -> Value { - let table = val.into_iter() - .map(|(s, v)| (s.into(), v.into())) - .collect(); + let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect(); Value::Table(table) } @@ -245,9 +278,7 @@ impl<S: Into<String>, V: Into<Value>> From<BTreeMap<S, V>> for Value { impl<S: Into<String> + Hash + Eq, V: Into<Value>> From<HashMap<S, V>> for Value { fn from(val: HashMap<S, V>) -> Value { - let table = val.into_iter() - .map(|(s, v)| (s.into(), v.into())) - .collect(); + let table = val.into_iter().map(|(s, v)| (s.into(), v.into())).collect(); Value::Table(table) } @@ -261,7 +292,7 @@ macro_rules! impl_into_value { Value::$variant(val.into()) } } - } + }; } impl_into_value!(String: String); @@ -340,7 +371,10 @@ impl Index for String { } } -impl<'s, T: ?Sized> Index for &'s T where T: Index { +impl<'s, T: ?Sized> Index for &'s T +where + T: Index, +{ fn index<'a>(&self, val: &'a Value) -> Option<&'a Value> { (**self).index(val) } @@ -352,7 +386,9 @@ impl<'s, T: ?Sized> Index for &'s T where T: Index { impl fmt::Display for Value { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - ::ser::to_string(self).expect("Unable to represent value as string").fmt(f) + ::ser::to_string(self) + .expect("Unable to represent value as string") + .fmt(f) } } @@ -365,7 +401,8 @@ impl FromStr for Value { impl ser::Serialize for Value { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> - where S: ser::Serializer + where + S: ser::Serializer, { use serde::ser::SerializeMap; @@ -381,13 +418,20 @@ impl ser::Serialize for Value { // Be sure to visit non-tables first (and also non // array-of-tables) as all keys must be emitted first. for (k, v) in t { - if !v.is_table() && !v.is_array() || - (v.as_array().map(|a| !a.iter().any(|v| v.is_table())).unwrap_or(false)) { + if !v.is_table() && !v.is_array() + || (v + .as_array() + .map(|a| !a.iter().any(|v| v.is_table())) + .unwrap_or(false)) + { map.serialize_entry(k, v)?; } } for (k, v) in t { - if v.as_array().map(|a| a.iter().any(|v| v.is_table())).unwrap_or(false) { + if v.as_array() + .map(|a| a.iter().any(|v| v.is_table())) + .unwrap_or(false) + { map.serialize_entry(k, v)?; } } @@ -404,7 +448,8 @@ impl ser::Serialize for Value { impl<'de> de::Deserialize<'de> for Value { fn deserialize<D>(deserializer: D) -> Result<Value, D::Error> - where D: de::Deserializer<'de>, + where + D: de::Deserializer<'de>, { struct ValueVisitor; @@ -452,13 +497,15 @@ impl<'de> de::Deserialize<'de> for Value { } fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error> - where D: de::Deserializer<'de>, + where + D: de::Deserializer<'de>, { de::Deserialize::deserialize(deserializer) } fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error> - where V: de::SeqAccess<'de>, + where + V: de::SeqAccess<'de>, { let mut vec = Vec::new(); while let Some(elem) = visitor.next_element()? { @@ -468,16 +515,15 @@ impl<'de> de::Deserialize<'de> for Value { } fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error> - where V: de::MapAccess<'de>, + where + V: de::MapAccess<'de>, { let mut key = String::new(); - let datetime = visitor.next_key_seed(DatetimeOrTable { - key: &mut key, - })?; + let datetime = visitor.next_key_seed(DatetimeOrTable { key: &mut key })?; match datetime { Some(true) => { let date: DatetimeFromString = visitor.next_value()?; - return Ok(Value::Datetime(date.value)) + return Ok(Value::Datetime(date.value)); } None => return Ok(Value::Table(BTreeMap::new())), Some(false) => {} @@ -487,7 +533,7 @@ impl<'de> de::Deserialize<'de> for Value { while let Some(key) = visitor.next_key()? { if map.contains_key(&key) { let msg = format!("duplicate key: `{}`", key); - return Err(de::Error::custom(msg)) + return Err(de::Error::custom(msg)); } map.insert(key, visitor.next_value()?); } @@ -503,7 +549,8 @@ impl<'de> de::Deserializer<'de> for Value { type Error = ::de::Error; fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, ::de::Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { match self { Value::Boolean(v) => visitor.visit_bool(v), @@ -548,14 +595,18 @@ impl<'de> de::Deserializer<'de> for Value { { match self { Value::String(variant) => visitor.visit_enum(variant.into_deserializer()), - _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"string only")), + _ => Err(de::Error::invalid_type( + de::Unexpected::UnitVariant, + &"string only", + )), } } // `None` is interpreted as a missing field so be sure to implement `Some` // as a present field. fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, ::de::Error> - where V: de::Visitor<'de>, + where + V: de::Visitor<'de>, { visitor.visit_some(self) } @@ -563,9 +614,10 @@ impl<'de> de::Deserializer<'de> for Value { fn deserialize_newtype_struct<V>( self, _name: &'static str, - visitor: V + visitor: V, ) -> Result<V::Value, ::de::Error> - where V: de::Visitor<'de> + where + V: de::Visitor<'de>, { visitor.visit_newtype_struct(self) } @@ -592,9 +644,9 @@ impl SeqDeserializer { impl<'de> de::SeqAccess<'de> for SeqDeserializer { type Error = ::de::Error; - fn next_element_seed<T>(&mut self, seed: T) - -> Result<Option<T::Value>, ::de::Error> - where T: de::DeserializeSeed<'de>, + fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error> + where + T: de::DeserializeSeed<'de>, { match self.iter.next() { Some(value) => seed.deserialize(value).map(Some), @@ -628,7 +680,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer { type Error = ::de::Error; fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ::de::Error> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { match self.iter.next() { Some((key, value)) => { @@ -640,7 +693,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer { } fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, ::de::Error> - where T: de::DeserializeSeed<'de>, + where + T: de::DeserializeSeed<'de>, { let (key, res) = match self.value.take() { Some((key, value)) => (key, seed.deserialize(value)), @@ -749,35 +803,39 @@ impl ser::Serializer for Serializer { Err(::ser::Error::UnsupportedType) } - fn serialize_unit_struct(self, _name: &'static str) - -> Result<Value, ::ser::Error> { + fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, ::ser::Error> { Err(::ser::Error::UnsupportedType) } - fn serialize_unit_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str) - -> Result<Value, ::ser::Error> { + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> Result<Value, ::ser::Error> { self.serialize_str(_variant) } - fn serialize_newtype_struct<T: ?Sized>(self, - _name: &'static str, - value: &T) - -> Result<Value, ::ser::Error> - where T: ser::Serialize, + fn serialize_newtype_struct<T: ?Sized>( + self, + _name: &'static str, + value: &T, + ) -> Result<Value, ::ser::Error> + where + T: ser::Serialize, { value.serialize(self) } - fn serialize_newtype_variant<T: ?Sized>(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _value: &T) - -> Result<Value, ::ser::Error> - where T: ser::Serialize, + fn serialize_newtype_variant<T: ?Sized>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> Result<Value, ::ser::Error> + where + T: ser::Serialize, { Err(::ser::Error::UnsupportedType) } @@ -787,16 +845,15 @@ impl ser::Serializer for Serializer { } fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, ::ser::Error> - where T: ser::Serialize, + where + T: ser::Serialize, { value.serialize(self) } - fn serialize_seq(self, len: Option<usize>) - -> Result<Self::SerializeSeq, ::ser::Error> - { + fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, ::ser::Error> { Ok(SerializeVec { - vec: Vec::with_capacity(len.unwrap_or(0)) + vec: Vec::with_capacity(len.unwrap_or(0)), }) } @@ -804,42 +861,46 @@ impl ser::Serializer for Serializer { self.serialize_seq(Some(len)) } - fn serialize_tuple_struct(self, _name: &'static str, len: usize) - -> Result<Self::SerializeTupleStruct, ::ser::Error> { + fn serialize_tuple_struct( + self, + _name: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleStruct, ::ser::Error> { self.serialize_seq(Some(len)) } - fn serialize_tuple_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - len: usize) - -> Result<Self::SerializeTupleVariant, ::ser::Error> - { + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + len: usize, + ) -> Result<Self::SerializeTupleVariant, ::ser::Error> { self.serialize_seq(Some(len)) } - fn serialize_map(self, _len: Option<usize>) - -> Result<Self::SerializeMap, ::ser::Error> - { + fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, ::ser::Error> { Ok(SerializeMap { map: BTreeMap::new(), next_key: None, }) } - fn serialize_struct(self, _name: &'static str, len: usize) - -> Result<Self::SerializeStruct, ::ser::Error> { + fn serialize_struct( + self, + _name: &'static str, + len: usize, + ) -> Result<Self::SerializeStruct, ::ser::Error> { self.serialize_map(Some(len)) } - fn serialize_struct_variant(self, - _name: &'static str, - _variant_index: u32, - _variant: &'static str, - _len: usize) - -> Result<Self::SerializeStructVariant, ::ser::Error> - { + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result<Self::SerializeStructVariant, ::ser::Error> { Err(::ser::Error::UnsupportedType) } } @@ -858,7 +919,8 @@ impl ser::SerializeSeq for SerializeVec { type Error = ::ser::Error; fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + where + T: ser::Serialize, { self.vec.push(Value::try_from(value)?); Ok(()) @@ -874,7 +936,8 @@ impl ser::SerializeTuple for SerializeVec { type Error = ::ser::Error; fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -889,7 +952,8 @@ impl ser::SerializeTupleStruct for SerializeVec { type Error = ::ser::Error; fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -904,7 +968,8 @@ impl ser::SerializeTupleVariant for SerializeVec { type Error = ::ser::Error; fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + where + T: ser::Serialize, { ser::SerializeSeq::serialize_element(self, value) } @@ -919,7 +984,8 @@ impl ser::SerializeMap for SerializeMap { type Error = ::ser::Error; fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + where + T: ser::Serialize, { match Value::try_from(key)? { Value::String(s) => self.next_key = Some(s), @@ -929,12 +995,15 @@ impl ser::SerializeMap for SerializeMap { } fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + where + T: ser::Serialize, { let key = self.next_key.take(); let key = key.expect("serialize_value called before serialize_key"); match Value::try_from(value) { - Ok(value) => { self.map.insert(key, value); } + Ok(value) => { + self.map.insert(key, value); + } Err(::ser::Error::UnsupportedNone) => {} Err(e) => return Err(e), } @@ -950,8 +1019,13 @@ impl ser::SerializeStruct for SerializeMap { type Ok = Value; type Error = ::ser::Error; - fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), ::ser::Error> - where T: ser::Serialize + fn serialize_field<T: ?Sized>( + &mut self, + key: &'static str, + value: &T, + ) -> Result<(), ::ser::Error> + where + T: ser::Serialize, { ser::SerializeMap::serialize_key(self, key)?; ser::SerializeMap::serialize_value(self, value) @@ -970,7 +1044,8 @@ impl<'a, 'de> de::DeserializeSeed<'de> for DatetimeOrTable<'a> { type Value = bool; fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> - where D: de::Deserializer<'de> + where + D: de::Deserializer<'de>, { deserializer.deserialize_any(self) } @@ -984,7 +1059,8 @@ impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> { } fn visit_str<E>(self, s: &str) -> Result<bool, E> - where E: de::Error, + where + E: de::Error, { if s == datetime::FIELD { Ok(true) @@ -995,7 +1071,8 @@ impl<'a, 'de> de::Visitor<'de> for DatetimeOrTable<'a> { } fn visit_string<E>(self, s: String) -> Result<bool, E> - where E: de::Error, + where + E: de::Error, { if s == datetime::FIELD { Ok(true) |