neodyn_xc 0.4.0

//! Deserializing from an in-memory `Value` tree.

use std::collections::{ btree_map, BTreeMap };
use serde::de::{
    Deserialize, DeserializeSeed, Deserializer, IntoDeserializer,
    Visitor,
    Expected, Unexpected, Error as DeError,
    SeqAccess, MapAccess, EnumAccess, VariantAccess,
};
use crate::error::Error;
use crate::value::Value;

/// Deserialize a strongly-typed value from a dynamically-typed `Value` tree.
pub fn from_value<T>(value: Value) -> Result<T, Error>
    where
        T: for<'a> Deserialize<'a>,
{
    <T as Deserialize>::deserialize(value)
}

/// Makes a `Result::Err` with a `serde::de::Error::invalid_type`
/// which refers to the value contained in this deserializer.
fn type_err<T>(value: &Value, expected: &dyn Expected) -> Result<T, Error> {
    Err(Error::invalid_type(Unexpected::from(value), expected))
}

/// Makes a `Result::Err` with a `serde::de::Error::invalid_length`.
fn length_err<T>(actual_len: usize, expected: &dyn Expected) -> Result<T, Error> {
    Err(Error::invalid_length(actual_len, expected))
}

/// Makes a `Result::Err` with a `serde::de::Error::invalid_type`
/// which reflects that some associated data was missing from an `enum` variant.
fn missing_enum_assoc_data_err<T>(expected: &str) -> Result<T, Error> {
    Err(Error::invalid_type(Unexpected::UnitVariant, &expected))
}

/// Deserialize a generic number.
fn deserialize_number<'de, V>(value: Value, visitor: V) -> Result<V::Value, Error>
    where
        V: Visitor<'de>,
{
    #[allow(clippy::wildcard_enum_match_arm)]
    match value {
        Value::Int(i)   => visitor.visit_i64(i),
        Value::Uint(u)  => visitor.visit_u64(u),
        Value::Float(f) => visitor.visit_f64(f.into()),
        _ => type_err(&value, &visitor),
    }
}

/// Deserialize an array.
fn deserialize_array<'de, V: Visitor<'de>>(
    array: Vec<Value>,
    visitor: V,
) -> Result<V::Value, Error> {
    visitor.visit_seq(SeqDeserializer {
        iter: array.into_iter()
    })
}

/// Deserialize a map.
fn deserialize_map<'de, V: Visitor<'de>>(
    map: BTreeMap<Value, Value>,
    visitor: V,
) -> Result<V::Value, Error> {
    visitor.visit_map(MapDeserializer {
        iter: map.into_iter(),
        next_value: None,
    })
}

/// Helper for deserializing from an array.
#[derive(Debug, Clone)]
struct SeqDeserializer {
    /// The iterator from which to read the values.
    iter: std::vec::IntoIter<Value>,
}

impl<'de> SeqAccess<'de> for SeqDeserializer {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
        where
            T: DeserializeSeed<'de>,
    {
        match self.iter.next() {
            Some(value) => seed.deserialize(value).map(Some),
            None => Ok(None),
        }
    }

    fn size_hint(&self) -> Option<usize> {
        self.iter.len().into()
    }
}

/// Helper for deserializing from a map.
#[derive(Debug)]
struct MapDeserializer {
    /// The iterator from which to read the values.
    iter: btree_map::IntoIter<Value, Value>,
    /// The next value to deserialize.
    next_value: Option<Value>,
}

impl<'de> MapAccess<'de> for MapDeserializer {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
        where
            K: DeserializeSeed<'de>,
    {
        if self.next_value.is_none() {
            match self.iter.next() {
                Some((key, value)) => {
                    self.next_value = Some(value);
                    seed.deserialize(key).map(Some)
                }
                None => Ok(None)
            }
        } else {
            Err(Error::custom("attempted to deserialize two keys in a row"))
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
        where
            V: DeserializeSeed<'de>,
    {
        // This would actually be _less clear_ using a giant `map_or_else`.
        #[allow(clippy::option_if_let_else)]
        if let Some(value) = self.next_value.take() {
            seed.deserialize(value)
        } else {
            Err(Error::custom("attempted to deserialize value without a key"))
        }
    }

    // can't (and shouldn't have to) do anything with this "very complex" type,
    // since the signature is specified by the trait which I don't control.
    #[allow(clippy::type_complexity)]
    fn next_entry_seed<K, V>(
        &mut self,
        key_seed: K,
        val_seed: V
    ) -> Result<Option<(K::Value, V::Value)>, Self::Error> where
        K: DeserializeSeed<'de>,
        V: DeserializeSeed<'de>,
    {
        // If `next_value` is `None`, we just leave it as-is,
        // since we extract both the key and the value in one step.
        if self.next_value.is_none() {
            match self.iter.next() {
                Some((k, v)) => {
                    let key = key_seed.deserialize(k)?;
                    let val = val_seed.deserialize(v)?;
                    Ok(Some((key, val)))
                }
                None => Ok(None)
            }
        } else {
            Err(Error::custom("attempted to deserialize two keys in a row"))
        }
    }

    fn size_hint(&self) -> Option<usize> {
        self.iter.len().into()
    }
}

/// Helper for deserializing an `enum`.
#[derive(Debug, Clone)]
struct EnumDeserializer {
    /// The name of the variant.
    name: String,
    /// The associated value(s) of the variant, if any.
    payload: Option<Value>,
}

impl<'de> EnumAccess<'de> for EnumDeserializer {
    type Error = Error;
    type Variant = VariantDeserializer;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
        where
            V: DeserializeSeed<'de>,
    {
        use serde::de::value::StringDeserializer;

        let de: StringDeserializer<Error> = self.name.into_deserializer();
        let variant = seed.deserialize(de)?;
        let visitor = VariantDeserializer { payload: self.payload };

        Ok((variant, visitor))
    }
}

/// Helper for deserializing the associated data of an `enum` variant.
#[derive(Debug, Clone)]
struct VariantDeserializer {
    /// The associated value(s) of the variant, if any.
    payload: Option<Value>,
}

impl<'de> VariantAccess<'de> for VariantDeserializer {
    type Error = Error;

    fn unit_variant(self) -> Result<(), Self::Error> {
        match self.payload {
            Some(value) => Deserialize::deserialize(value),
            None => Ok(()),
        }
    }

    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
        where
            T: DeserializeSeed<'de>,
    {
        match self.payload {
            Some(value) => seed.deserialize(value),
            None => missing_enum_assoc_data_err(
                "newtype variant (missing associated data)"
            ),
        }
    }

    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
    {
        match self.payload {
            Some(Value::Array(array)) => deserialize_array(array, visitor),
            Some(other) => type_err(&other, &"tuple variant"),
            None => missing_enum_assoc_data_err(
                "tuple variant (missing associated data)"
            ),
        }
    }

    fn struct_variant<V>(
        self,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
        where
            V: Visitor<'de>,
    {
        match self.payload {
            Some(Value::Map(map)) => deserialize_map(map, visitor),
            Some(other) => type_err(&other, &"struct variant"),
            None => missing_enum_assoc_data_err(
                "struct variant (missing associated data)"
            ),
        }
    }
}

/// The actual `Deserializer` impl.
impl<'de> Deserializer<'de> for Value {
    type Error = Error;

    fn is_human_readable(&self) -> bool {
        true
    }

    fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        match self {
            Value::Null         => visitor.visit_unit(),
            Value::Opt(inner)   => visitor.visit_some(*inner),
            Value::Bool(b)      => visitor.visit_bool(b),
            Value::Int(i)       => visitor.visit_i64(i),
            Value::Uint(u)      => visitor.visit_u64(u),
            Value::Float(f)     => visitor.visit_f64(f.into()),
            Value::String(s)    => visitor.visit_string(s),
            Value::Blob(bytes)  => visitor.visit_byte_buf(bytes),
            Value::Array(array) => deserialize_array(array, visitor),
            Value::Map(map)     => deserialize_map(map, visitor),
        }
    }

    fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::Bool(b) => visitor.visit_bool(b),
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        deserialize_number(self, visitor)
    }

    fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        self.deserialize_string(visitor)
    }

    fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        self.deserialize_string(visitor)
    }

    fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::String(s) => visitor.visit_string(s),
            Value::Blob(bytes) => {
                let s = String::from_utf8(bytes)?;
                visitor.visit_string(s)
            },
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        self.deserialize_byte_buf(visitor)
    }

    fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::Blob(bytes)  => visitor.visit_byte_buf(bytes),
            Value::String(s)    => visitor.visit_string(s),
            Value::Array(array) => deserialize_array(array, visitor), // try it
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::Null => visitor.visit_none(),
            Value::Opt(inner) => visitor.visit_some(*inner),
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::Null => visitor.visit_unit(),
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_unit_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        self.deserialize_unit(visitor)
    }

    fn deserialize_newtype_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        visitor.visit_newtype_struct(self)
    }

    fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::Array(array) => deserialize_array(array, visitor),
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_tuple<V: Visitor<'de>>(
        self,
        _len: usize,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        self.deserialize_seq(visitor)
    }

    fn deserialize_tuple_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        len: usize,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        self.deserialize_tuple(len, visitor)
    }

    fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        match self {
            Value::Map(map) => deserialize_map(map, visitor),
            _ => type_err(&self, &visitor),
        }
    }

    fn deserialize_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        self.deserialize_map(visitor)
    }

    fn deserialize_enum<V: Visitor<'de>>(
        self,
        _type_name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        #[allow(clippy::wildcard_enum_match_arm)]
        let (name, payload) = match self {
            Value::String(s) => (s, None),
            Value::Map(map) => if map.len() == 1 {
                if let Some((key, val)) = map.into_iter().next() {
                    if let Value::String(s) = key {
                        (s, Some(val))
                    } else {
                        return type_err(&key, &"variant name as string");
                    }
                } else {
                    // this should never happen, but if it does,
                    // it's still better than crashing.
                    return length_err(0, &"map.len() == 1 but empty iterator");
                }
            } else {
                return length_err(map.len(), &"enum as single-key map");
            },
            _ => return type_err(&self, &"enum as string or single-key map"),
        };

        visitor.visit_enum(EnumDeserializer { name, payload })
    }

    fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        self.deserialize_string(visitor)
    }

    fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
        visitor.visit_unit()
    }
}

impl<'de> IntoDeserializer<'de, Error> for Value {
    type Deserializer = Self;

    fn into_deserializer(self) -> Self::Deserializer {
        self
    }
}