summaryrefslogtreecommitdiffstats
path: root/vendor/toml_edit/src/de
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/toml_edit/src/de')
-rw-r--r--vendor/toml_edit/src/de/array.rs97
-rw-r--r--vendor/toml_edit/src/de/datetime.rs43
-rw-r--r--vendor/toml_edit/src/de/key.rs140
-rw-r--r--vendor/toml_edit/src/de/mod.rs289
-rw-r--r--vendor/toml_edit/src/de/spanned.rs70
-rw-r--r--vendor/toml_edit/src/de/table.rs213
-rw-r--r--vendor/toml_edit/src/de/table_enum.rs160
-rw-r--r--vendor/toml_edit/src/de/value.rs252
8 files changed, 1264 insertions, 0 deletions
diff --git a/vendor/toml_edit/src/de/array.rs b/vendor/toml_edit/src/de/array.rs
new file mode 100644
index 0000000..adc5401
--- /dev/null
+++ b/vendor/toml_edit/src/de/array.rs
@@ -0,0 +1,97 @@
+use crate::de::Error;
+
+pub(crate) struct ArrayDeserializer {
+ input: Vec<crate::Item>,
+ span: Option<std::ops::Range<usize>>,
+}
+
+impl ArrayDeserializer {
+ pub(crate) fn new(input: Vec<crate::Item>, span: Option<std::ops::Range<usize>>) -> Self {
+ Self { input, span }
+ }
+}
+
+// Note: this is wrapped by `ValueDeserializer` and any trait methods
+// implemented here need to be wrapped there
+impl<'de> serde::Deserializer<'de> for ArrayDeserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ visitor.visit_seq(ArraySeqAccess::new(self.input))
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ name: &'static str,
+ fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ if serde_spanned::__unstable::is_spanned(name, fields) {
+ if let Some(span) = self.span.clone() {
+ return visitor.visit_map(super::SpannedDeserializer::new(self, span));
+ }
+ }
+
+ self.deserialize_any(visitor)
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+ bytes byte_buf map option unit newtype_struct
+ ignored_any unit_struct tuple_struct tuple enum identifier
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, crate::de::Error> for ArrayDeserializer {
+ type Deserializer = Self;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ self
+ }
+}
+
+impl crate::Array {
+ pub(crate) fn into_deserializer(self) -> ArrayDeserializer {
+ ArrayDeserializer::new(self.values, self.span)
+ }
+}
+
+impl crate::ArrayOfTables {
+ pub(crate) fn into_deserializer(self) -> ArrayDeserializer {
+ ArrayDeserializer::new(self.values, self.span)
+ }
+}
+
+pub(crate) struct ArraySeqAccess {
+ iter: std::vec::IntoIter<crate::Item>,
+}
+
+impl ArraySeqAccess {
+ pub(crate) fn new(input: Vec<crate::Item>) -> Self {
+ Self {
+ iter: input.into_iter(),
+ }
+ }
+}
+
+impl<'de> serde::de::SeqAccess<'de> for ArraySeqAccess {
+ type Error = Error;
+
+ fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+ where
+ T: serde::de::DeserializeSeed<'de>,
+ {
+ match self.iter.next() {
+ Some(v) => seed
+ .deserialize(crate::de::ValueDeserializer::new(v))
+ .map(Some),
+ None => Ok(None),
+ }
+ }
+}
diff --git a/vendor/toml_edit/src/de/datetime.rs b/vendor/toml_edit/src/de/datetime.rs
new file mode 100644
index 0000000..14de28b
--- /dev/null
+++ b/vendor/toml_edit/src/de/datetime.rs
@@ -0,0 +1,43 @@
+use serde::de::value::BorrowedStrDeserializer;
+use serde::de::IntoDeserializer;
+
+use crate::de::Error;
+
+pub(crate) struct DatetimeDeserializer {
+ date: Option<crate::Datetime>,
+}
+
+impl DatetimeDeserializer {
+ pub(crate) fn new(date: crate::Datetime) -> Self {
+ Self { date: Some(date) }
+ }
+}
+
+impl<'de> serde::de::MapAccess<'de> for DatetimeDeserializer {
+ type Error = Error;
+
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+ where
+ K: serde::de::DeserializeSeed<'de>,
+ {
+ if self.date.is_some() {
+ seed.deserialize(BorrowedStrDeserializer::new(
+ toml_datetime::__unstable::FIELD,
+ ))
+ .map(Some)
+ } else {
+ Ok(None)
+ }
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+ where
+ V: serde::de::DeserializeSeed<'de>,
+ {
+ if let Some(date) = self.date.take() {
+ seed.deserialize(date.to_string().into_deserializer())
+ } else {
+ panic!("next_value_seed called before next_key_seed")
+ }
+ }
+}
diff --git a/vendor/toml_edit/src/de/key.rs b/vendor/toml_edit/src/de/key.rs
new file mode 100644
index 0000000..3da41df
--- /dev/null
+++ b/vendor/toml_edit/src/de/key.rs
@@ -0,0 +1,140 @@
+use serde::de::IntoDeserializer;
+
+use super::Error;
+
+pub(crate) struct KeyDeserializer {
+ span: Option<std::ops::Range<usize>>,
+ key: crate::InternalString,
+}
+
+impl KeyDeserializer {
+ pub(crate) fn new(key: crate::InternalString, span: Option<std::ops::Range<usize>>) -> Self {
+ KeyDeserializer { span, key }
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, Error> for KeyDeserializer {
+ type Deserializer = Self;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ self
+ }
+}
+
+impl<'de> serde::de::Deserializer<'de> for KeyDeserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ self.key.into_deserializer().deserialize_any(visitor)
+ }
+
+ fn deserialize_enum<V>(
+ self,
+ name: &str,
+ variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let _ = name;
+ let _ = variants;
+ visitor.visit_enum(self)
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ name: &'static str,
+ fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ if serde_spanned::__unstable::is_spanned(name, fields) {
+ if let Some(span) = self.span.clone() {
+ return visitor.visit_map(super::SpannedDeserializer::new(self.key.as_str(), span));
+ }
+ }
+ self.deserialize_any(visitor)
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+ bytes byte_buf map option unit newtype_struct
+ ignored_any unit_struct tuple_struct tuple identifier
+ }
+}
+
+impl<'de> serde::de::EnumAccess<'de> for KeyDeserializer {
+ type Error = super::Error;
+ type Variant = UnitOnly<Self::Error>;
+
+ fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
+ where
+ T: serde::de::DeserializeSeed<'de>,
+ {
+ seed.deserialize(self).map(unit_only)
+ }
+}
+
+pub(crate) struct UnitOnly<E> {
+ marker: std::marker::PhantomData<E>,
+}
+
+fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
+ (
+ t,
+ UnitOnly {
+ marker: std::marker::PhantomData,
+ },
+ )
+}
+
+impl<'de, E> serde::de::VariantAccess<'de> for UnitOnly<E>
+where
+ E: serde::de::Error,
+{
+ type Error = E;
+
+ fn unit_variant(self) -> Result<(), Self::Error> {
+ Ok(())
+ }
+
+ fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
+ where
+ T: serde::de::DeserializeSeed<'de>,
+ {
+ Err(serde::de::Error::invalid_type(
+ serde::de::Unexpected::UnitVariant,
+ &"newtype variant",
+ ))
+ }
+
+ fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ Err(serde::de::Error::invalid_type(
+ serde::de::Unexpected::UnitVariant,
+ &"tuple variant",
+ ))
+ }
+
+ fn struct_variant<V>(
+ self,
+ _fields: &'static [&'static str],
+ _visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ Err(serde::de::Error::invalid_type(
+ serde::de::Unexpected::UnitVariant,
+ &"struct variant",
+ ))
+ }
+}
diff --git a/vendor/toml_edit/src/de/mod.rs b/vendor/toml_edit/src/de/mod.rs
new file mode 100644
index 0000000..09ea120
--- /dev/null
+++ b/vendor/toml_edit/src/de/mod.rs
@@ -0,0 +1,289 @@
+//! Deserializing TOML into Rust structures.
+//!
+//! This module contains all the Serde support for deserializing TOML documents into Rust structures.
+
+use serde::de::DeserializeOwned;
+
+mod array;
+mod datetime;
+mod key;
+mod spanned;
+mod table;
+mod table_enum;
+mod value;
+
+use array::ArrayDeserializer;
+use datetime::DatetimeDeserializer;
+use key::KeyDeserializer;
+use spanned::SpannedDeserializer;
+use table::TableMapAccess;
+use table_enum::TableEnumDeserializer;
+
+pub use value::ValueDeserializer;
+
+/// Errors that can occur when deserializing a type.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Error {
+ inner: crate::TomlError,
+}
+
+impl Error {
+ pub(crate) fn custom<T>(msg: T, span: Option<std::ops::Range<usize>>) -> Self
+ where
+ T: std::fmt::Display,
+ {
+ Error {
+ inner: crate::TomlError::custom(msg.to_string(), span),
+ }
+ }
+
+ /// Add key while unwinding
+ pub fn add_key(&mut self, key: String) {
+ self.inner.add_key(key)
+ }
+
+ /// What went wrong
+ pub fn message(&self) -> &str {
+ self.inner.message()
+ }
+
+ /// The start/end index into the original document where the error occurred
+ pub fn span(&self) -> Option<std::ops::Range<usize>> {
+ self.inner.span()
+ }
+
+ pub(crate) fn set_span(&mut self, span: Option<std::ops::Range<usize>>) {
+ self.inner.set_span(span);
+ }
+}
+
+impl serde::de::Error for Error {
+ fn custom<T>(msg: T) -> Self
+ where
+ T: std::fmt::Display,
+ {
+ Error::custom(msg, None)
+ }
+}
+
+impl std::fmt::Display for Error {
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+ self.inner.fmt(f)
+ }
+}
+
+impl From<crate::TomlError> for Error {
+ fn from(e: crate::TomlError) -> Error {
+ Self { inner: e }
+ }
+}
+
+impl From<Error> for crate::TomlError {
+ fn from(e: Error) -> crate::TomlError {
+ e.inner
+ }
+}
+
+impl std::error::Error for Error {}
+
+/// Convert a value into `T`.
+pub fn from_str<T>(s: &'_ str) -> Result<T, Error>
+where
+ T: DeserializeOwned,
+{
+ let de = s.parse::<Deserializer>()?;
+ T::deserialize(de)
+}
+
+/// Convert a value into `T`.
+pub fn from_slice<T>(s: &'_ [u8]) -> Result<T, Error>
+where
+ T: DeserializeOwned,
+{
+ let s = std::str::from_utf8(s).map_err(|e| Error::custom(e, None))?;
+ from_str(s)
+}
+
+/// Convert a document into `T`.
+pub fn from_document<T>(d: crate::Document) -> Result<T, Error>
+where
+ T: DeserializeOwned,
+{
+ let deserializer = Deserializer::new(d);
+ T::deserialize(deserializer)
+}
+
+/// Deserialization for TOML [documents][crate::Document].
+pub struct Deserializer {
+ input: crate::Document,
+}
+
+impl Deserializer {
+ /// Deserialization implementation for TOML.
+ pub fn new(input: crate::Document) -> Self {
+ Self { input }
+ }
+}
+
+impl std::str::FromStr for Deserializer {
+ type Err = Error;
+
+ /// Parses a document from a &str
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ let d = crate::parser::parse_document(s).map_err(Error::from)?;
+ Ok(Self::new(d))
+ }
+}
+
+// Note: this is wrapped by `toml::de::Deserializer` and any trait methods
+// implemented here need to be wrapped there
+impl<'de> serde::Deserializer<'de> for Deserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let original = self.input.original;
+ self.input
+ .root
+ .into_deserializer()
+ .deserialize_any(visitor)
+ .map_err(|mut e: Self::Error| {
+ e.inner.set_original(original);
+ e
+ })
+ }
+
+ // `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: serde::de::Visitor<'de>,
+ {
+ let original = self.input.original;
+ self.input
+ .root
+ .into_deserializer()
+ .deserialize_option(visitor)
+ .map_err(|mut e: Self::Error| {
+ e.inner.set_original(original);
+ e
+ })
+ }
+
+ fn deserialize_newtype_struct<V>(
+ self,
+ name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let original = self.input.original;
+ self.input
+ .root
+ .into_deserializer()
+ .deserialize_newtype_struct(name, visitor)
+ .map_err(|mut e: Self::Error| {
+ e.inner.set_original(original);
+ e
+ })
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ name: &'static str,
+ fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let original = self.input.original;
+ self.input
+ .root
+ .into_deserializer()
+ .deserialize_struct(name, fields, visitor)
+ .map_err(|mut e: Self::Error| {
+ e.inner.set_original(original);
+ e
+ })
+ }
+
+ // 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,
+ variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let original = self.input.original;
+ self.input
+ .root
+ .into_deserializer()
+ .deserialize_enum(name, variants, visitor)
+ .map_err(|mut e: Self::Error| {
+ e.inner.set_original(original);
+ e
+ })
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+ bytes byte_buf map unit
+ ignored_any unit_struct tuple_struct tuple identifier
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, crate::de::Error> for Deserializer {
+ type Deserializer = Deserializer;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ self
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, crate::de::Error> for crate::Document {
+ type Deserializer = Deserializer;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ Deserializer::new(self)
+ }
+}
+
+pub(crate) fn validate_struct_keys(
+ table: &crate::table::KeyValuePairs,
+ fields: &'static [&'static str],
+) -> Result<(), Error> {
+ let extra_fields = table
+ .iter()
+ .filter_map(|(key, val)| {
+ if !fields.contains(&key.as_str()) {
+ Some(val.clone())
+ } else {
+ None
+ }
+ })
+ .collect::<Vec<_>>();
+
+ if extra_fields.is_empty() {
+ Ok(())
+ } else {
+ Err(Error::custom(
+ format!(
+ "unexpected keys in table: {}, available keys: {}",
+ extra_fields
+ .iter()
+ .map(|k| k.key.get())
+ .collect::<Vec<_>>()
+ .join(", "),
+ fields.join(", "),
+ ),
+ extra_fields[0].key.span(),
+ ))
+ }
+}
diff --git a/vendor/toml_edit/src/de/spanned.rs b/vendor/toml_edit/src/de/spanned.rs
new file mode 100644
index 0000000..7ce5864
--- /dev/null
+++ b/vendor/toml_edit/src/de/spanned.rs
@@ -0,0 +1,70 @@
+use serde::de::value::BorrowedStrDeserializer;
+use serde::de::IntoDeserializer as _;
+
+use super::Error;
+
+pub(crate) struct SpannedDeserializer<'de, T: serde::de::IntoDeserializer<'de, Error>> {
+ phantom_data: std::marker::PhantomData<&'de ()>,
+ start: Option<usize>,
+ end: Option<usize>,
+ value: Option<T>,
+}
+
+impl<'de, T> SpannedDeserializer<'de, T>
+where
+ T: serde::de::IntoDeserializer<'de, Error>,
+{
+ pub(crate) fn new(value: T, span: std::ops::Range<usize>) -> Self {
+ Self {
+ phantom_data: Default::default(),
+ start: Some(span.start),
+ end: Some(span.end),
+ value: Some(value),
+ }
+ }
+}
+
+impl<'de, T> serde::de::MapAccess<'de> for SpannedDeserializer<'de, T>
+where
+ T: serde::de::IntoDeserializer<'de, Error>,
+{
+ type Error = Error;
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+ where
+ K: serde::de::DeserializeSeed<'de>,
+ {
+ if self.start.is_some() {
+ seed.deserialize(BorrowedStrDeserializer::new(
+ serde_spanned::__unstable::START_FIELD,
+ ))
+ .map(Some)
+ } else if self.end.is_some() {
+ seed.deserialize(BorrowedStrDeserializer::new(
+ serde_spanned::__unstable::END_FIELD,
+ ))
+ .map(Some)
+ } else if self.value.is_some() {
+ seed.deserialize(BorrowedStrDeserializer::new(
+ serde_spanned::__unstable::VALUE_FIELD,
+ ))
+ .map(Some)
+ } else {
+ Ok(None)
+ }
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+ where
+ V: serde::de::DeserializeSeed<'de>,
+ {
+ if let Some(start) = self.start.take() {
+ seed.deserialize(start.into_deserializer())
+ } 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())
+ } else {
+ panic!("next_value_seed called before next_key_seed")
+ }
+ }
+}
diff --git a/vendor/toml_edit/src/de/table.rs b/vendor/toml_edit/src/de/table.rs
new file mode 100644
index 0000000..0b6183e
--- /dev/null
+++ b/vendor/toml_edit/src/de/table.rs
@@ -0,0 +1,213 @@
+use serde::de::IntoDeserializer;
+
+use crate::de::Error;
+
+pub(crate) struct TableDeserializer {
+ span: Option<std::ops::Range<usize>>,
+ items: crate::table::KeyValuePairs,
+}
+
+// Note: this is wrapped by `Deserializer` and `ValueDeserializer` and any trait methods
+// implemented here need to be wrapped there
+impl<'de> serde::Deserializer<'de> for TableDeserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ visitor.visit_map(crate::de::TableMapAccess::new(self))
+ }
+
+ // `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: serde::de::Visitor<'de>,
+ {
+ visitor.visit_some(self)
+ }
+
+ fn deserialize_newtype_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ visitor.visit_newtype_struct(self)
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ name: &'static str,
+ fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ if serde_spanned::__unstable::is_spanned(name, fields) {
+ if let Some(span) = self.span.clone() {
+ return visitor.visit_map(super::SpannedDeserializer::new(self, span));
+ }
+ }
+
+ self.deserialize_any(visitor)
+ }
+
+ // 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,
+ _variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ if self.items.is_empty() {
+ Err(crate::de::Error::custom(
+ "wanted exactly 1 element, found 0 elements",
+ self.span,
+ ))
+ } else if self.items.len() != 1 {
+ Err(crate::de::Error::custom(
+ "wanted exactly 1 element, more than 1 element",
+ self.span,
+ ))
+ } else {
+ visitor.visit_enum(crate::de::TableMapAccess::new(self))
+ }
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+ bytes byte_buf map unit
+ ignored_any unit_struct tuple_struct tuple identifier
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, crate::de::Error> for TableDeserializer {
+ type Deserializer = TableDeserializer;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ self
+ }
+}
+
+impl crate::Table {
+ pub(crate) fn into_deserializer(self) -> TableDeserializer {
+ TableDeserializer {
+ span: self.span(),
+ items: self.items,
+ }
+ }
+}
+
+impl crate::InlineTable {
+ pub(crate) fn into_deserializer(self) -> TableDeserializer {
+ TableDeserializer {
+ span: self.span(),
+ items: self.items,
+ }
+ }
+}
+
+pub(crate) struct TableMapAccess {
+ iter: indexmap::map::IntoIter<crate::InternalString, crate::table::TableKeyValue>,
+ span: Option<std::ops::Range<usize>>,
+ value: Option<(crate::InternalString, crate::Item)>,
+}
+
+impl TableMapAccess {
+ pub(crate) fn new(input: TableDeserializer) -> Self {
+ Self {
+ iter: input.items.into_iter(),
+ span: input.span,
+ value: None,
+ }
+ }
+}
+
+impl<'de> serde::de::MapAccess<'de> for TableMapAccess {
+ type Error = Error;
+
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+ where
+ K: serde::de::DeserializeSeed<'de>,
+ {
+ match self.iter.next() {
+ Some((k, v)) => {
+ let ret = seed
+ .deserialize(super::KeyDeserializer::new(k, v.key.span()))
+ .map(Some)
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(v.key.span());
+ }
+ e
+ });
+ self.value = Some((v.key.into(), v.value));
+ ret
+ }
+ None => Ok(None),
+ }
+ }
+
+ fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::DeserializeSeed<'de>,
+ {
+ match self.value.take() {
+ Some((k, v)) => {
+ let span = v.span();
+ seed.deserialize(crate::de::ValueDeserializer::new(v))
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e.add_key(k.as_str().to_owned());
+ e
+ })
+ }
+ None => {
+ panic!("no more values in next_value_seed, internal error in ValueDeserializer")
+ }
+ }
+ }
+}
+
+impl<'de> serde::de::EnumAccess<'de> for TableMapAccess {
+ type Error = Error;
+ type Variant = super::TableEnumDeserializer;
+
+ fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+ where
+ V: serde::de::DeserializeSeed<'de>,
+ {
+ let (key, value) = match self.iter.next() {
+ Some(pair) => pair,
+ None => {
+ return Err(Error::custom(
+ "expected table with exactly 1 entry, found empty table",
+ self.span,
+ ));
+ }
+ };
+
+ let val = seed
+ .deserialize(key.into_deserializer())
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(value.key.span());
+ }
+ e
+ })?;
+
+ let variant = super::TableEnumDeserializer::new(value.value);
+
+ Ok((val, variant))
+ }
+}
diff --git a/vendor/toml_edit/src/de/table_enum.rs b/vendor/toml_edit/src/de/table_enum.rs
new file mode 100644
index 0000000..197ad6e
--- /dev/null
+++ b/vendor/toml_edit/src/de/table_enum.rs
@@ -0,0 +1,160 @@
+use crate::de::Error;
+
+/// Deserializes table values into enum variants.
+pub(crate) struct TableEnumDeserializer {
+ value: crate::Item,
+}
+
+impl TableEnumDeserializer {
+ pub(crate) fn new(value: crate::Item) -> Self {
+ TableEnumDeserializer { value }
+ }
+}
+
+impl<'de> serde::de::VariantAccess<'de> for TableEnumDeserializer {
+ type Error = Error;
+
+ fn unit_variant(self) -> Result<(), Self::Error> {
+ match self.value {
+ crate::Item::Table(values) => {
+ if values.is_empty() {
+ Ok(())
+ } else {
+ Err(Error::custom("expected empty table", values.span()))
+ }
+ }
+ crate::Item::Value(crate::Value::InlineTable(values)) => {
+ if values.is_empty() {
+ Ok(())
+ } else {
+ Err(Error::custom("expected empty table", values.span()))
+ }
+ }
+ e => Err(Error::custom(
+ format!("expected table, found {}", e.type_name()),
+ e.span(),
+ )),
+ }
+ }
+
+ fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+ where
+ T: serde::de::DeserializeSeed<'de>,
+ {
+ seed.deserialize(super::ValueDeserializer::new(self.value))
+ }
+
+ fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ match self.value {
+ crate::Item::Table(values) => {
+ let values_span = values.span();
+ let tuple_values = values
+ .items
+ .into_iter()
+ .enumerate()
+ .map(
+ |(index, (_, value))| match value.key.get().parse::<usize>() {
+ Ok(key_index) if key_index == index => Ok(value.value),
+ Ok(_) | Err(_) => Err(Error::custom(
+ format!(
+ "expected table key `{}`, but was `{}`",
+ index,
+ value.key.get()
+ ),
+ value.key.span(),
+ )),
+ },
+ )
+ // 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 {
+ serde::de::Deserializer::deserialize_seq(
+ super::ArrayDeserializer::new(tuple_values, values_span),
+ visitor,
+ )
+ } else {
+ Err(Error::custom(
+ format!("expected tuple with length {}", len),
+ values_span,
+ ))
+ }
+ }
+ crate::Item::Value(crate::Value::InlineTable(values)) => {
+ let values_span = values.span();
+ let tuple_values = values
+ .items
+ .into_iter()
+ .enumerate()
+ .map(
+ |(index, (_, value))| match value.key.get().parse::<usize>() {
+ Ok(key_index) if key_index == index => Ok(value.value),
+ Ok(_) | Err(_) => Err(Error::custom(
+ format!(
+ "expected table key `{}`, but was `{}`",
+ index,
+ value.key.get()
+ ),
+ value.key.span(),
+ )),
+ },
+ )
+ // 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 {
+ serde::de::Deserializer::deserialize_seq(
+ super::ArrayDeserializer::new(tuple_values, values_span),
+ visitor,
+ )
+ } else {
+ Err(Error::custom(
+ format!("expected tuple with length {}", len),
+ values_span,
+ ))
+ }
+ }
+ e => Err(Error::custom(
+ format!("expected table, found {}", e.type_name()),
+ e.span(),
+ )),
+ }
+ }
+
+ fn struct_variant<V>(
+ self,
+ fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ serde::de::Deserializer::deserialize_struct(
+ super::ValueDeserializer::new(self.value).with_struct_key_validation(),
+ "", // TODO: this should be the variant name
+ fields,
+ visitor,
+ )
+ }
+}
diff --git a/vendor/toml_edit/src/de/value.rs b/vendor/toml_edit/src/de/value.rs
new file mode 100644
index 0000000..d3cf87f
--- /dev/null
+++ b/vendor/toml_edit/src/de/value.rs
@@ -0,0 +1,252 @@
+use serde::de::IntoDeserializer as _;
+
+use crate::de::DatetimeDeserializer;
+use crate::de::Error;
+
+/// Deserialization implementation for TOML [values][crate::Value].
+///
+/// Can be created either directly from TOML strings, using [`std::str::FromStr`],
+/// or from parsed [values][crate::Value] using [`serde::de::IntoDeserializer::into_deserializer`].
+///
+/// # Example
+///
+/// ```
+/// use serde::Deserialize;
+///
+/// #[derive(Deserialize)]
+/// struct Config {
+/// title: String,
+/// owner: Owner,
+/// }
+///
+/// #[derive(Deserialize)]
+/// struct Owner {
+/// name: String,
+/// }
+///
+/// let value = r#"{ title = 'TOML Example', owner = { name = 'Lisa' } }"#;
+/// let deserializer = value.parse::<toml_edit::de::ValueDeserializer>().unwrap();
+/// let config = Config::deserialize(deserializer).unwrap();
+/// assert_eq!(config.title, "TOML Example");
+/// assert_eq!(config.owner.name, "Lisa");
+/// ```
+pub struct ValueDeserializer {
+ input: crate::Item,
+ validate_struct_keys: bool,
+}
+
+impl ValueDeserializer {
+ pub(crate) fn new(input: crate::Item) -> Self {
+ Self {
+ input,
+ validate_struct_keys: false,
+ }
+ }
+
+ pub(crate) fn with_struct_key_validation(mut self) -> Self {
+ self.validate_struct_keys = true;
+ self
+ }
+}
+
+// Note: this is wrapped by `toml::de::ValueDeserializer` and any trait methods
+// implemented here need to be wrapped there
+impl<'de> serde::Deserializer<'de> for ValueDeserializer {
+ type Error = Error;
+
+ fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let span = self.input.span();
+ match self.input {
+ crate::Item::None => visitor.visit_none(),
+ crate::Item::Value(crate::Value::String(v)) => visitor.visit_string(v.into_value()),
+ crate::Item::Value(crate::Value::Integer(v)) => visitor.visit_i64(v.into_value()),
+ crate::Item::Value(crate::Value::Float(v)) => visitor.visit_f64(v.into_value()),
+ crate::Item::Value(crate::Value::Boolean(v)) => visitor.visit_bool(v.into_value()),
+ crate::Item::Value(crate::Value::Datetime(v)) => {
+ visitor.visit_map(DatetimeDeserializer::new(v.into_value()))
+ }
+ crate::Item::Value(crate::Value::Array(v)) => {
+ v.into_deserializer().deserialize_any(visitor)
+ }
+ crate::Item::Value(crate::Value::InlineTable(v)) => {
+ v.into_deserializer().deserialize_any(visitor)
+ }
+ crate::Item::Table(v) => v.into_deserializer().deserialize_any(visitor),
+ crate::Item::ArrayOfTables(v) => v.into_deserializer().deserialize_any(visitor),
+ }
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e
+ })
+ }
+
+ // `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: serde::de::Visitor<'de>,
+ {
+ let span = self.input.span();
+ visitor.visit_some(self).map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e
+ })
+ }
+
+ fn deserialize_newtype_struct<V>(
+ self,
+ _name: &'static str,
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let span = self.input.span();
+ visitor
+ .visit_newtype_struct(self)
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e
+ })
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ name: &'static str,
+ fields: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ if serde_spanned::__unstable::is_spanned(name, fields) {
+ if let Some(span) = self.input.span() {
+ return visitor.visit_map(super::SpannedDeserializer::new(self, span));
+ }
+ }
+
+ if name == toml_datetime::__unstable::NAME && fields == [toml_datetime::__unstable::FIELD] {
+ let span = self.input.span();
+ if let crate::Item::Value(crate::Value::Datetime(d)) = self.input {
+ return visitor
+ .visit_map(DatetimeDeserializer::new(d.into_value()))
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e
+ });
+ }
+ }
+
+ if self.validate_struct_keys {
+ let span = self.input.span();
+ match &self.input {
+ crate::Item::Table(values) => super::validate_struct_keys(&values.items, fields),
+ crate::Item::Value(crate::Value::InlineTable(values)) => {
+ super::validate_struct_keys(&values.items, fields)
+ }
+ _ => Ok(()),
+ }
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e
+ })?
+ }
+
+ self.deserialize_any(visitor)
+ }
+
+ // 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,
+ variants: &'static [&'static str],
+ visitor: V,
+ ) -> Result<V::Value, Error>
+ where
+ V: serde::de::Visitor<'de>,
+ {
+ let span = self.input.span();
+ match self.input {
+ crate::Item::Value(crate::Value::String(v)) => {
+ visitor.visit_enum(v.into_value().into_deserializer())
+ }
+ crate::Item::Value(crate::Value::InlineTable(v)) => {
+ if v.is_empty() {
+ Err(crate::de::Error::custom(
+ "wanted exactly 1 element, found 0 elements",
+ v.span(),
+ ))
+ } else if v.len() != 1 {
+ Err(crate::de::Error::custom(
+ "wanted exactly 1 element, more than 1 element",
+ v.span(),
+ ))
+ } else {
+ v.into_deserializer()
+ .deserialize_enum(name, variants, visitor)
+ }
+ }
+ crate::Item::Table(v) => v
+ .into_deserializer()
+ .deserialize_enum(name, variants, visitor),
+ e => Err(crate::de::Error::custom("wanted string or table", e.span())),
+ }
+ .map_err(|mut e: Self::Error| {
+ if e.span().is_none() {
+ e.set_span(span);
+ }
+ e
+ })
+ }
+
+ serde::forward_to_deserialize_any! {
+ bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+ bytes byte_buf map unit
+ ignored_any unit_struct tuple_struct tuple identifier
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, crate::de::Error> for ValueDeserializer {
+ type Deserializer = Self;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ self
+ }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, crate::de::Error> for crate::Value {
+ type Deserializer = ValueDeserializer;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ ValueDeserializer::new(crate::Item::Value(self))
+ }
+}
+
+impl crate::Item {
+ pub(crate) fn into_deserializer(self) -> ValueDeserializer {
+ ValueDeserializer::new(self)
+ }
+}
+
+impl std::str::FromStr for ValueDeserializer {
+ type Err = Error;
+
+ /// Parses a value from a &str
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ let v = crate::parser::parse_value(s).map_err(Error::from)?;
+ Ok(v.into_deserializer())
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-18 06:57:43 +0000