Merge pull request #264 from azriel91/feature/225/externally-tagged-enums

Issue 255: Externally tagged enum deserialization
This commit is contained in:
Alex Crichton 2018-11-28 09:50:38 -06:00 committed by GitHub
commit 7845df9ff9
3 changed files with 675 additions and 57 deletions

46
examples/enum_external.rs Normal file
View file

@ -0,0 +1,46 @@
//! An example showing off the usage of `Deserialize` to automatically decode
//! TOML into a Rust `struct`, with enums.
#![deny(warnings)]
extern crate toml;
#[macro_use]
extern crate serde_derive;
/// This is what we're going to decode into.
#[derive(Debug, Deserialize)]
struct Config {
plain: MyEnum,
plain_table: MyEnum,
tuple: MyEnum,
#[serde(rename = "struct")]
structv: MyEnum,
newtype: MyEnum,
my_enum: Vec<MyEnum>,
}
#[derive(Debug, Deserialize)]
enum MyEnum {
Plain,
Tuple(i64, bool),
NewType(String),
Struct { value: i64 },
}
fn main() {
let toml_str = r#"
plain = "Plain"
plain_table = { Plain = {} }
tuple = { Tuple = { 0 = 123, 1 = true } }
struct = { Struct = { value = 123 } }
newtype = { NewType = "value" }
my_enum = [
{ Plain = {} },
{ Tuple = { 0 = 123, 1 = true } },
{ NewType = "value" },
{ Struct = { value = 123 } }
]"#;
let decoded: Config = toml::from_str(toml_str).unwrap();
println!("{:#?}", decoded);
}

446
src/de.rs
View file

@ -159,12 +159,35 @@ enum ErrorKind {
/// type.
Custom,
/// A struct was expected but something else was found
ExpectedString,
/// A tuple with a certain number of elements was expected but something
/// else was found.
ExpectedTuple(usize),
/// Expected table keys to be in increasing tuple index order, but something
/// else was found.
ExpectedTupleIndex {
/// Expected index.
expected: usize,
/// Key that was specified.
found: String,
},
/// An empty table was expected but entries were found
ExpectedEmptyTable,
/// Dotted key attempted to extend something that is not a table.
DottedKeyInvalidType,
/// An unexpected key was encountered.
///
/// Used when deserializing a struct with a limited set of fields.
UnexpectedKeys {
/// The unexpected keys.
keys: Vec<String>,
/// Keys that may be specified.
available: &'static [&'static str],
},
#[doc(hidden)]
__Nonexhaustive,
}
@ -182,47 +205,8 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
{
let mut tables = Vec::new();
let mut cur_table = Table {
at: 0,
header: Vec::new(),
values: None,
array: false,
};
while let Some(line) = self.line()? {
match line {
Line::Table { at, mut header, array } => {
if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table);
}
cur_table = Table {
at: at,
header: Vec::new(),
values: Some(Vec::new()),
array: array,
};
loop {
let part = header.next().map_err(|e| {
self.token_error(e)
});
match part? {
Some(part) => cur_table.header.push(part),
None => break,
}
}
}
Line::KeyValue(key, value) => {
if cur_table.values.is_none() {
cur_table.values = Some(Vec::new());
}
self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
}
}
}
if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table);
}
let mut tables = self.tables()?;
visitor.visit_map(MapVisitor {
values: Vec::new().into_iter(),
@ -237,6 +221,7 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
})
}
// Called when the type to deserialize is an enum, as opposed to a field in the type.
fn deserialize_enum<V>(
self,
_name: &'static str,
@ -245,15 +230,34 @@ impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
) -> Result<V::Value, Error>
where V: de::Visitor<'de>
{
if let Some(next) = self.next()? {
match next {
(_, Token::String { val, .. }) => {
visitor.visit_enum(val.into_deserializer())
},
_ => Err(Error::from_kind(ErrorKind::ExpectedString))
}
let (value, name) = self.string_or_table()?;
match value.e {
E::String(val) => visitor.visit_enum(val.into_deserializer()),
E::InlineTable(values) => {
if values.len() != 1 {
Err(Error::from_kind(ErrorKind::Wanted {
expected: "exactly 1 element",
found: if values.is_empty() {
"zero elements"
} else {
Err(Error::from_kind(ErrorKind::UnexpectedEof))
"more than 1 element"
},
}))
} else {
visitor.visit_enum(InlineTableDeserializer {
values: values.into_iter(),
next_value: None,
})
}
}
E::DottedTable(_) => visitor.visit_enum(DottedTableDeserializer {
name: name.expect("Expected table header to be passed."),
value: value,
}),
e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
expected: "string or table",
found: e.type_name(),
})),
}
}
@ -497,14 +501,21 @@ impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
struct ValueDeserializer<'a> {
value: Value<'a>,
validate_struct_keys: bool,
}
impl<'a> ValueDeserializer<'a> {
fn new(value: Value<'a>) -> ValueDeserializer<'a> {
ValueDeserializer {
value: value,
validate_struct_keys: false,
}
}
fn with_struct_key_validation(mut self) -> Self {
self.validate_struct_keys = true;
self
}
}
impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
@ -553,6 +564,31 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
}
}
if self.validate_struct_keys {
match &self.value.e {
&E::InlineTable(ref values) | &E::DottedTable(ref values) => {
let extra_fields = values.iter()
.filter_map(|key_value| {
let (ref key, ref _val) = *key_value;
if !fields.contains(&&(**key)) {
Some(key.clone())
} else {
None
}
})
.collect::<Vec<Cow<'de, str>>>();
if !extra_fields.is_empty() {
return Err(Error::from_kind(ErrorKind::UnexpectedKeys {
keys: extra_fields.iter().map(|k| k.to_string()).collect::<Vec<_>>(),
available: fields,
}));
}
}
_ => {}
}
}
if name == spanned::NAME && fields == &[spanned::START, spanned::END, spanned::VALUE] {
let start = self.value.start;
let end = self.value.end;
@ -585,7 +621,27 @@ impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
{
match self.value.e {
E::String(val) => visitor.visit_enum(val.into_deserializer()),
_ => Err(Error::from_kind(ErrorKind::ExpectedString))
E::InlineTable(values) => {
if values.len() != 1 {
Err(Error::from_kind(ErrorKind::Wanted {
expected: "exactly 1 element",
found: if values.is_empty() {
"zero elements"
} else {
"more than 1 element"
},
}))
} else {
visitor.visit_enum(InlineTableDeserializer {
values: values.into_iter(),
next_value: None,
})
}
}
e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
expected: "string or inline table",
found: e.type_name(),
})),
}
}
@ -697,6 +753,25 @@ impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
}
}
struct DottedTableDeserializer<'a> {
name: Cow<'a, str>,
value: Value<'a>,
}
impl<'de> de::EnumAccess<'de> for DottedTableDeserializer<'de> {
type Error = Error;
type Variant = TableEnumDeserializer<'de>;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where
V: de::DeserializeSeed<'de>,
{
let (name, value) = (self.name, self.value);
seed.deserialize(StrDeserializer::new(name))
.map(|val| (val, TableEnumDeserializer { value: value }))
}
}
struct InlineTableDeserializer<'a> {
values: vec::IntoIter<(Cow<'a, str>, Value<'a>)>,
next_value: Option<Value<'a>>,
@ -724,6 +799,124 @@ impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
}
}
impl<'de> de::EnumAccess<'de> for InlineTableDeserializer<'de> {
type Error = Error;
type Variant = TableEnumDeserializer<'de>;
fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where
V: de::DeserializeSeed<'de>,
{
let (key, value) = match self.values.next() {
Some(pair) => pair,
None => {
return Err(Error::from_kind(ErrorKind::Wanted {
expected: "table with exactly 1 entry",
found: "empty table",
}))
}
};
seed.deserialize(StrDeserializer::new(key))
.map(|val| (val, TableEnumDeserializer { value: value }))
}
}
/// Deserializes table values into enum variants.
struct TableEnumDeserializer<'a> {
value: Value<'a>,
}
impl<'de> de::VariantAccess<'de> for TableEnumDeserializer<'de> {
type Error = Error;
fn unit_variant(self) -> Result<(), Self::Error> {
match self.value.e {
E::InlineTable(values) | E::DottedTable(values) => {
if values.len() == 0 {
Ok(())
} else {
Err(Error::from_kind(ErrorKind::ExpectedEmptyTable))
}
}
e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
expected: "table",
found: e.type_name(),
})),
}
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(ValueDeserializer::new(self.value))
}
fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
match self.value.e {
E::InlineTable(values) | E::DottedTable(values) => {
let tuple_values = values
.into_iter()
.enumerate()
.map(|(index, (key, value))| match key.parse::<usize>() {
Ok(key_index) if key_index == index => Ok(value),
Ok(_) | Err(_) => Err(Error::from_kind(ErrorKind::ExpectedTupleIndex {
expected: index,
found: key.to_string(),
})),
})
// Fold all values into a `Vec`, or return the first error.
.fold(Ok(Vec::with_capacity(len)), |result, value_result| {
result.and_then(move |mut tuple_values| match value_result {
Ok(value) => {
tuple_values.push(value);
Ok(tuple_values)
}
// `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
Err(e) => Err(e),
})
})?;
if tuple_values.len() == len {
de::Deserializer::deserialize_seq(
ValueDeserializer::new(Value {
e: E::Array(tuple_values),
start: self.value.start,
end: self.value.end,
}),
visitor,
)
} else {
Err(Error::from_kind(ErrorKind::ExpectedTuple(len)))
}
}
e @ _ => Err(Error::from_kind(ErrorKind::Wanted {
expected: "table",
found: e.type_name(),
})),
}
}
fn struct_variant<V>(
self,
fields: &'static [&'static str],
visitor: V,
) -> Result<V::Value, Self::Error>
where
V: de::Visitor<'de>,
{
de::Deserializer::deserialize_struct(
ValueDeserializer::new(self.value).with_struct_key_validation(),
"", // TODO: this should be the variant name
fields,
visitor,
)
}
}
impl<'a> Deserializer<'a> {
/// Creates a new deserializer which will be deserializing the string
@ -754,6 +947,53 @@ impl<'a> Deserializer<'a> {
self.require_newline_after_table = require;
}
fn tables(&mut self) -> Result<Vec<Table<'a>>, Error> {
let mut tables = Vec::new();
let mut cur_table = Table {
at: 0,
header: Vec::new(),
values: None,
array: false,
};
while let Some(line) = self.line()? {
match line {
Line::Table {
at,
mut header,
array,
} => {
if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table);
}
cur_table = Table {
at: at,
header: Vec::new(),
values: Some(Vec::new()),
array: array,
};
loop {
let part = header.next().map_err(|e| self.token_error(e));
match part? {
Some(part) => cur_table.header.push(part),
None => break,
}
}
}
Line::KeyValue(key, value) => {
if cur_table.values.is_none() {
cur_table.values = Some(Vec::new());
}
self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
}
}
}
if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table);
}
Ok(tables)
}
fn line(&mut self) -> Result<Option<Line<'a>>, Error> {
loop {
self.eat_whitespace()?;
@ -876,6 +1116,55 @@ impl<'a> Deserializer<'a> {
}
}
/// Returns a string or table value type.
///
/// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
/// structures (tuple, newtype, struct) must be represented as a table.
fn string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error> {
match self.peek()? {
Some((_, Token::LeftBracket)) => {
let tables = self.tables()?;
if tables.len() != 1 {
return Err(Error::from_kind(ErrorKind::Wanted {
expected: "exactly 1 table",
found: if tables.is_empty() {
"zero tables"
} else {
"more than 1 table"
},
}));
}
let table = tables
.into_iter()
.next()
.expect("Expected exactly one table");
let header = table
.header
.last()
.expect("Expected at least one header value for table.");
let start = table.at;
let end = table
.values
.as_ref()
.and_then(|values| values.last())
.map(|&(_, ref val)| val.end)
.unwrap_or_else(|| header.len());
Ok((
Value {
e: E::DottedTable(table.values.unwrap_or_else(Vec::new)),
start: start,
end: end,
},
Some(header.clone()),
))
}
Some(_) => self.value().map(|val| (val, None)),
None => Err(self.eof()),
}
}
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 };
if s.starts_with("0x") {
@ -1170,6 +1459,18 @@ impl<'a> Deserializer<'a> {
Ok(result)
}
/// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
///
/// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
/// intermediate parts which are mapped to the relevant fields in the deserialized type's data
/// hierarchy.
///
/// # Parameters
///
/// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
/// `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
/// * `value`: The parsed value.
/// * `values`: The `Vec` to store the value in.
fn add_dotted_key(
&self,
mut key_parts: Vec<Cow<'a, str>>,
@ -1191,12 +1492,12 @@ impl<'a> Deserializer<'a> {
None => {}
}
// The start/end value is somewhat misleading here.
let inline_table = Value {
let table_values = Value {
e: E::DottedTable(Vec::new()),
start: value.start,
end: value.end,
};
values.push((key, inline_table));
values.push((key, table_values));
let last_i = values.len() - 1;
if let (_, Value { e: E::DottedTable(ref mut v), .. }) = values[last_i] {
self.add_dotted_key(key_parts, value, v)?;
@ -1384,8 +1685,23 @@ impl fmt::Display for Error {
ErrorKind::EmptyTableKey => "empty table key found".fmt(f)?,
ErrorKind::MultilineStringKey => "multiline strings are not allowed for key".fmt(f)?,
ErrorKind::Custom => self.inner.message.fmt(f)?,
ErrorKind::ExpectedString => "expected string".fmt(f)?,
ErrorKind::DottedKeyInvalidType => "dotted key attempted to extend non-table type".fmt(f)?,
ErrorKind::ExpectedTuple(l) => write!(f, "expected table with length {}", l)?,
ErrorKind::ExpectedTupleIndex {
expected,
ref found,
} => write!(f, "expected table key `{}`, but was `{}`", expected, found)?,
ErrorKind::ExpectedEmptyTable => "expected empty table".fmt(f)?,
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::__Nonexhaustive => panic!(),
}
@ -1429,8 +1745,11 @@ impl error::Error for Error {
ErrorKind::EmptyTableKey => "empty table key found",
ErrorKind::MultilineStringKey => "invalid multiline string for key",
ErrorKind::Custom => "a custom error",
ErrorKind::ExpectedString => "expected string",
ErrorKind::ExpectedTuple(_) => "expected table length",
ErrorKind::ExpectedTupleIndex { .. } => "expected table key",
ErrorKind::ExpectedEmptyTable => "expected empty table",
ErrorKind::DottedKeyInvalidType => "dotted key invalid type",
ErrorKind::UnexpectedKeys { .. } => "unexpected keys in table",
ErrorKind::__Nonexhaustive => panic!(),
}
}
@ -1509,6 +1828,21 @@ enum E<'a> {
DottedTable(Vec<(Cow<'a, str>, Value<'a>)>),
}
impl<'a> E<'a> {
fn type_name(&self) -> &'static str {
match *self {
E::String(..) => "string",
E::Integer(..) => "integer",
E::Float(..) => "float",
E::Boolean(..) => "boolean",
E::Datetime(..) => "datetime",
E::Array(..) => "array",
E::InlineTable(..) => "inline table",
E::DottedTable(..) => "dotted table",
}
}
}
impl<'a> Value<'a> {
fn same_type(&self, other: &Value<'a>) -> bool {
match (&self.e, &other.e) {

View file

@ -0,0 +1,238 @@
#[macro_use]
extern crate serde_derive;
extern crate toml;
#[derive(Debug, Deserialize, PartialEq)]
enum TheEnum {
Plain,
Tuple(i64, bool),
NewType(String),
Struct { value: i64 },
}
#[derive(Debug, Deserialize, PartialEq)]
struct Val {
val: TheEnum,
}
#[derive(Debug, Deserialize, PartialEq)]
struct Multi {
enums: Vec<TheEnum>,
}
#[test]
fn invalid_variant_returns_error_with_good_message_string() {
let error = toml::from_str::<TheEnum>("\"NonExistent\"").unwrap_err();
assert_eq!(
error.to_string(),
"unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`"
);
}
#[test]
fn invalid_variant_returns_error_with_good_message_inline_table() {
let error = toml::from_str::<TheEnum>("{ NonExistent = {} }").unwrap_err();
assert_eq!(
error.to_string(),
"unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`"
);
}
#[test]
fn extra_field_returns_expected_empty_table_error() {
let error = toml::from_str::<TheEnum>("{ Plain = { extra_field = 404 } }").unwrap_err();
assert_eq!(error.to_string(), "expected empty table");
}
#[test]
fn extra_field_returns_expected_empty_table_error_struct_variant() {
let error = toml::from_str::<TheEnum>("{ Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }")
.unwrap_err();
assert_eq!(
error.to_string(),
r#"unexpected keys in table: `["extra_0", "extra_1"]`, available keys: `["value"]`"#
);
}
mod enum_unit {
use super::*;
#[test]
fn from_str() {
assert_eq!(TheEnum::Plain, toml::from_str("\"Plain\"").unwrap());
}
#[test]
fn from_inline_table() {
assert_eq!(TheEnum::Plain, toml::from_str("{ Plain = {} }").unwrap());
assert_eq!(
Val {
val: TheEnum::Plain
},
toml::from_str("val = { Plain = {} }").unwrap()
);
}
#[test]
fn from_dotted_table() {
assert_eq!(TheEnum::Plain, toml::from_str("[Plain]\n").unwrap());
}
}
mod enum_tuple {
use super::*;
#[test]
fn from_inline_table() {
assert_eq!(
TheEnum::Tuple(-123, true),
toml::from_str("{ Tuple = { 0 = -123, 1 = true } }").unwrap()
);
assert_eq!(
Val {
val: TheEnum::Tuple(-123, true)
},
toml::from_str("val = { Tuple = { 0 = -123, 1 = true } }").unwrap()
);
}
#[test]
fn from_dotted_table() {
assert_eq!(
TheEnum::Tuple(-123, true),
toml::from_str(
r#"[Tuple]
0 = -123
1 = true
"#
)
.unwrap()
);
}
}
mod enum_newtype {
use super::*;
#[test]
fn from_inline_table() {
assert_eq!(
TheEnum::NewType("value".to_string()),
toml::from_str(r#"{ NewType = "value" }"#).unwrap()
);
assert_eq!(
Val {
val: TheEnum::NewType("value".to_string()),
},
toml::from_str(r#"val = { NewType = "value" }"#).unwrap()
);
}
#[test]
#[ignore = "Unimplemented: https://github.com/alexcrichton/toml-rs/pull/264#issuecomment-431707209"]
fn from_dotted_table() {
assert_eq!(
TheEnum::NewType("value".to_string()),
toml::from_str(r#"NewType = "value""#).unwrap()
);
assert_eq!(
Val {
val: TheEnum::NewType("value".to_string()),
},
toml::from_str(
r#"[val]
NewType = "value"
"#
)
.unwrap()
);
}
}
mod enum_struct {
use super::*;
#[test]
fn from_inline_table() {
assert_eq!(
TheEnum::Struct { value: -123 },
toml::from_str("{ Struct = { value = -123 } }").unwrap()
);
assert_eq!(
Val {
val: TheEnum::Struct { value: -123 }
},
toml::from_str("val = { Struct = { value = -123 } }").unwrap()
);
}
#[test]
fn from_dotted_table() {
assert_eq!(
TheEnum::Struct { value: -123 },
toml::from_str(
r#"[Struct]
value = -123
"#
)
.unwrap()
);
}
}
mod enum_array {
use super::*;
#[test]
fn from_inline_tables() {
let toml_str = r#"
enums = [
{ Plain = {} },
{ Tuple = { 0 = -123, 1 = true } },
{ NewType = "value" },
{ Struct = { value = -123 } }
]"#;
assert_eq!(
Multi {
enums: vec![
TheEnum::Plain,
TheEnum::Tuple(-123, true),
TheEnum::NewType("value".to_string()),
TheEnum::Struct { value: -123 },
]
},
toml::from_str(toml_str).unwrap()
);
}
#[test]
#[ignore = "Unimplemented: https://github.com/alexcrichton/toml-rs/pull/264#issuecomment-431707209"]
fn from_dotted_table() {
let toml_str = r#"[[enums]]
Plain = {}
[[enums]]
Tuple = { 0 = -123, 1 = true }
[[enums]]
NewType = "value"
[[enums]]
Struct = { value = -123 }
"#;
assert_eq!(
Multi {
enums: vec![
TheEnum::Plain,
TheEnum::Tuple(-123, true),
TheEnum::NewType("value".to_string()),
TheEnum::Struct { value: -123 },
]
},
toml::from_str(toml_str).unwrap()
);
}
}