diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/de.rs | 13 | ||||
| -rw-r--r-- | src/lib.rs | 2 | ||||
| -rw-r--r-- | src/ser.rs | 4 | ||||
| -rw-r--r-- | src/tokens.rs | 19 | ||||
| -rw-r--r-- | src/value.rs | 63 |
5 files changed, 81 insertions, 20 deletions
@@ -1324,13 +1324,12 @@ impl<'a> Deserializer<'a> { let start = self.tokens.substr_offset(date); // Check for space separated date and time. - if let Some((_, Token::Whitespace(s))) = self.peek()? { - if s == " " { - self.next()?; - // Skip past the hour. - if let Some((_, Token::Keylike(_))) = self.peek()? { - self.next()?; - } + let mut lookahead = self.tokens.clone(); + 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 } } @@ -1,6 +1,6 @@ //! A [TOML]-parsing library //! -//! This library implements a [TOML] v0.4.0 compatible parser, +//! This library implements a [TOML] v0.5.0 compatible parser, //! primarily supporting the [`serde`] library for encoding/decoding //! various types in Rust. //! @@ -1420,11 +1420,11 @@ impl ser::Serializer for StringExtractor { Err(Error::KeyNotString) } - fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, _value: &T) + fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<String, Self::Error> where T: ser::Serialize, { - Err(Error::KeyNotString) + value.serialize(self) } fn serialize_newtype_variant<T: ?Sized>(self, diff --git a/src/tokens.rs b/src/tokens.rs index 15c3b41..382c1ec 100644 --- a/src/tokens.rs +++ b/src/tokens.rs @@ -364,7 +364,24 @@ impl<'a> Tokenizer<'a> { let len = if c == 'u' {4} else {8}; val.push(me.hex(start, i, len)?); } - Some((_, '\n')) if multi => { + 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)), + } + } + } while let Some((_, ch)) = me.chars.clone().next() { match ch { ' ' | '\t' | '\n' => { diff --git a/src/value.rs b/src/value.rs index 64f4555..2e42dc3 100644 --- a/src/value.rs +++ b/src/value.rs @@ -675,9 +675,9 @@ impl ser::Serializer for Serializer { type Error = ::ser::Error; type SerializeSeq = SerializeVec; - type SerializeTuple = ser::Impossible<Value, ::ser::Error>; - type SerializeTupleStruct = ser::Impossible<Value, ::ser::Error>; - type SerializeTupleVariant = ser::Impossible<Value, ::ser::Error>; + type SerializeTuple = SerializeVec; + type SerializeTupleStruct = SerializeVec; + type SerializeTupleVariant = SerializeVec; type SerializeMap = SerializeMap; type SerializeStruct = SerializeMap; type SerializeStructVariant = ser::Impossible<Value, ::ser::Error>; @@ -800,23 +800,23 @@ impl ser::Serializer for Serializer { }) } - fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, ::ser::Error> { - Err(::ser::Error::UnsupportedType) + fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, ::ser::Error> { + self.serialize_seq(Some(len)) } - fn serialize_tuple_struct(self, _name: &'static str, _len: usize) + fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, ::ser::Error> { - Err(::ser::Error::UnsupportedType) + self.serialize_seq(Some(len)) } fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, - _len: usize) + len: usize) -> Result<Self::SerializeTupleVariant, ::ser::Error> { - Err(::ser::Error::UnsupportedType) + self.serialize_seq(Some(len)) } fn serialize_map(self, _len: Option<usize>) @@ -869,6 +869,51 @@ impl ser::SerializeSeq for SerializeVec { } } +impl ser::SerializeTuple for SerializeVec { + type Ok = Value; + type Error = ::ser::Error; + + fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> + where T: ser::Serialize + { + ser::SerializeSeq::serialize_element(self, value) + } + + fn end(self) -> Result<Value, ::ser::Error> { + ser::SerializeSeq::end(self) + } +} + +impl ser::SerializeTupleStruct for SerializeVec { + type Ok = Value; + type Error = ::ser::Error; + + fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> + where T: ser::Serialize + { + ser::SerializeSeq::serialize_element(self, value) + } + + fn end(self) -> Result<Value, ::ser::Error> { + ser::SerializeSeq::end(self) + } +} + +impl ser::SerializeTupleVariant for SerializeVec { + type Ok = Value; + type Error = ::ser::Error; + + fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), ::ser::Error> + where T: ser::Serialize + { + ser::SerializeSeq::serialize_element(self, value) + } + + fn end(self) -> Result<Value, ::ser::Error> { + ser::SerializeSeq::end(self) + } +} + impl ser::SerializeMap for SerializeMap { type Ok = Value; type Error = ::ser::Error; |