From a6f22570ae78017ad98bc6e944602abd39170a27 Mon Sep 17 00:00:00 2001 From: Vincent Prouillet Date: Fri, 28 Apr 2017 13:00:37 +0900 Subject: [PATCH] Address comment and make test pass --- src/de.rs | 36 ++++++++++++++---------- src/ser.rs | 4 +-- src/value.rs | 78 ++++------------------------------------------------ 3 files changed, 28 insertions(+), 90 deletions(-) diff --git a/src/de.rs b/src/de.rs index abb7cda..223d492 100644 --- a/src/de.rs +++ b/src/de.rs @@ -122,8 +122,7 @@ enum ErrorKind { /// type. Custom, - /// TODO - ExpectedEnum, + /// A struct was expected but something else was found ExpectedString, #[doc(hidden)] @@ -206,16 +205,15 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> { ) -> Result where V: de::Visitor<'de> { - if self.peek_char()? == '"' { - // Visit a unit variant. - match self.next()?.unwrap() { - Token::String { ref val, .. } => { - visitor.visit_enum(val.clone().into_deserializer()) + if let Some(next) = self.next()? { + match next { + Token::String { val, .. } => { + visitor.visit_enum(val.into_deserializer()) }, _ => Err(Error::from_kind(ErrorKind::ExpectedString)) } } else { - Err(Error::from_kind(ErrorKind::ExpectedEnum)) + Err(Error::from_kind(ErrorKind::UnexpectedEof)) } } @@ -517,10 +515,24 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> { visitor.visit_some(self) } + fn deserialize_enum( + self, + _name: &'static str, + _variants: &'static [&'static str], + visitor: V + ) -> Result + where V: de::Visitor<'de> + { + match self.value { + Value::String(val) => visitor.visit_enum(val.into_deserializer()), + _ => Err(Error::from_kind(ErrorKind::ExpectedString)) + } + } + forward_to_deserialize_any! { bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq bytes byte_buf map unit newtype_struct identifier - ignored_any unit_struct tuple_struct tuple enum + ignored_any unit_struct tuple_struct tuple } } @@ -988,10 +1000,6 @@ impl<'a> Deserializer<'a> { self.tokens.peek().map_err(|e| self.token_error(e)) } - fn peek_char(&mut self) -> Result { - self.input.chars().next().ok_or(Error::from_kind(ErrorKind::UnexpectedEof)) - } - fn eof(&self) -> Error { self.error(self.input.len(), ErrorKind::UnexpectedEof) } @@ -1125,7 +1133,6 @@ impl fmt::Display for Error { ErrorKind::RedefineAsArray => "table redefined as array".fmt(f)?, ErrorKind::EmptyTableKey => "empty table key found".fmt(f)?, ErrorKind::Custom => self.inner.message.fmt(f)?, - ErrorKind::ExpectedEnum => "expected enum".fmt(f)?, ErrorKind::ExpectedString => "expected string".fmt(f)?, ErrorKind::__Nonexhaustive => panic!(), } @@ -1169,7 +1176,6 @@ impl error::Error for Error { ErrorKind::RedefineAsArray => "table redefined as array", ErrorKind::EmptyTableKey => "empty table key found", ErrorKind::Custom => "a custom error", - ErrorKind::ExpectedEnum => "expected enum", ErrorKind::ExpectedString => "expected string", ErrorKind::__Nonexhaustive => panic!(), } diff --git a/src/ser.rs b/src/ser.rs index 2365b38..4896f8a 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -421,9 +421,9 @@ impl<'a, 'b> ser::Serializer for &'b mut Serializer<'a> { fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, - _variant: &'static str) + variant: &'static str) -> Result<(), Self::Error> { - self.serialize_str(_variant) + self.serialize_str(variant) } fn serialize_newtype_struct(self, _name: &'static str, value: &T) diff --git a/src/value.rs b/src/value.rs index ebb14fc..dcc3567 100644 --- a/src/value.rs +++ b/src/value.rs @@ -516,20 +516,11 @@ impl<'de> de::Deserializer<'de> for Value { where V: de::Visitor<'de>, { - let (variant, value) = match self { - Value::String(variant) => (variant, None), - _ => { - return Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"string only"),); - } - }; - - visitor.visit_enum( - EnumDeserializer { - variant: variant, - value: value, - }, - ) -} + match self { + Value::String(variant) => visitor.visit_enum(variant.into_deserializer()), + _ => 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. @@ -545,65 +536,6 @@ impl<'de> de::Deserializer<'de> for Value { tuple ignored_any newtype_struct identifier } } -struct EnumDeserializer { - variant: String, - value: Option, -} - -impl<'de> de::EnumAccess<'de> for EnumDeserializer { - type Error = ::de::Error; - type Variant = VariantDeserializer; - - fn variant_seed(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error> - where - V: de::DeserializeSeed<'de>, - { - let variant = self.variant.into_deserializer(); - let visitor = VariantDeserializer { value: self.value }; - seed.deserialize(variant).map(|v| (v, visitor)) - } -} - -struct VariantDeserializer { - value: Option, -} - -impl<'de> de::VariantAccess<'de> for VariantDeserializer { - type Error = ::de::Error; - - fn unit_variant(self) -> Result<(), Self::Error> { - match self.value { - Some(value) => de::Deserialize::deserialize(value), - None => Ok(()), - } - } - - fn newtype_variant_seed(self, _: T) -> Result - where - T: de::DeserializeSeed<'de>, - { - Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant")) - } - - fn tuple_variant(self, _len: usize, _: V) -> Result - where - V: de::Visitor<'de>, - { - Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")) - } - - fn struct_variant( - self, - _fields: &'static [&'static str], - _: V, - ) -> Result - where - V: de::Visitor<'de>, - { - Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")) - } -} - struct SeqDeserializer { iter: vec::IntoIter,