wreq 1.2.5 → 1.2.6

data/src/serde/de/deserializer.rs

@@ -0,0 +1,307 @@
+use ::serde::forward_to_deserialize_any;
+use magnus::{
+    Fixnum, Float, Integer, RArray, RBignum, RHash, RString, Ruby, Symbol, Value,
+    value::{Qfalse, Qtrue, ReprValue},
+};
+
+use super::super::{Error, MAX_JSON_NESTING};
+use super::{
+    array_deserializer::ArrayDeserializer, enum_deserializer::EnumDeserializer,
+    hash_deserializer::HashDeserializer, number_deserializer::NumberDeserializer,
+};
+use crate::options::NATIVE_OPTION_TOKEN;
+
+/// Implement typed Serde integer entry points with Magnus's checked conversions.
+macro_rules! impl_deserialize_integers {
+    ($($method:ident => ($visit:ident, $convert:ident)),+ $(,)?) => {
+        $(
+            fn $method<Visitor>(self, visitor: Visitor) -> Result<Visitor::Value, Self::Error>
+            where
+                Visitor: ::serde::de::Visitor<'de>,
+            {
+                match Integer::from_value(self.value) {
+                    Some(value) => visitor.$visit(value.$convert()?),
+                    None => self.deserialize_any(visitor),
+                }
+            }
+        )+
+    };
+}
+
+/// Data model applied to a Ruby value during deserialization.
+#[derive(Clone, Copy)]
+pub(super) enum Mode {
+    /// Preserve the native Ruby-to-Serde conversion behavior.
+    Ruby,
+    /// Visit option names while skipping their values.
+    OptionKeys,
+    /// Enforce the JSON data model and preserve arbitrary-size numbers.
+    Json,
+}
+
+impl Mode {
+    /// Return whether JSON-specific validation is enabled.
+    fn is_json(self) -> bool {
+        matches!(self, Self::Json)
+    }
+}
+
+/// Serde deserializer over Ruby values.
+pub(in crate::serde) struct Deserializer<'ruby> {
+    ruby: &'ruby Ruby,
+    value: Value,
+    depth: usize,
+    mode: Mode,
+}
+
+impl<'ruby> Deserializer<'ruby> {
+    /// Create a deserializer with native `serde_magnus` Ruby behavior.
+    pub(in crate::serde) fn new_ruby(ruby: &'ruby Ruby, value: Value) -> Self {
+        Self::with_mode(ruby, value, 0, Mode::Ruby)
+    }
+
+    /// Create a deserializer that validates option keys without reading values.
+    pub(in crate::serde) fn new_option_keys(ruby: &'ruby Ruby, value: Value) -> Self {
+        Self::with_mode(ruby, value, 0, Mode::OptionKeys)
+    }
+
+    /// Create a JSON deserializer with validation and arbitrary precision.
+    pub(super) fn new_json(ruby: &'ruby Ruby, value: Value) -> Self {
+        Self::with_mode(ruby, value, 0, Mode::Json)
+    }
+
+    /// Create a nested deserializer that inherits its conversion mode.
+    pub(super) fn with_mode(ruby: &'ruby Ruby, value: Value, depth: usize, mode: Mode) -> Self {
+        Self {
+            ruby,
+            value,
+            depth,
+            mode,
+        }
+    }
+
+    /// Validate and return the depth used by a nested container.
+    pub(super) fn nested_depth(&self) -> Result<usize, Error> {
+        let depth = self
+            .depth
+            .checked_add(1)
+            .ok_or_else(|| Error::message("JSON nesting depth overflow"))?;
+        if self.mode.is_json() && depth > MAX_JSON_NESTING {
+            Err(Error::message(format!(
+                "JSON nesting exceeds {MAX_JSON_NESTING} levels"
+            )))
+        } else {
+            Ok(depth)
+        }
+    }
+}
+
+impl<'de> ::serde::Deserializer<'de> for Deserializer<'_> {
+    type Error = Error;
+
+    fn deserialize_any<Visitor>(self, visitor: Visitor) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if self.value.is_nil() {
+            return visitor.visit_unit();
+        }
+
+        if let Some(value) = Qtrue::from_value(self.value) {
+            return visitor.visit_bool(value.to_bool());
+        }
+
+        if let Some(value) = Qfalse::from_value(self.value) {
+            return visitor.visit_bool(value.to_bool());
+        }
+
+        if let Some(value) = Fixnum::from_value(self.value) {
+            return visitor.visit_i64(value.to_i64());
+        }
+
+        if let Some(value) = RBignum::from_value(self.value) {
+            if self.mode.is_json() {
+                let source: String = value.funcall_public("to_s", ())?;
+                return visitor.visit_map(NumberDeserializer::new(source));
+            }
+
+            return visitor.visit_i64(value.to_i64()?);
+        }
+
+        if let Some(value) = Float::from_value(self.value) {
+            let value = value.to_f64();
+            if self.mode.is_json() && !value.is_finite() {
+                return Err(Error::message("non-finite Float values are not valid JSON"));
+            }
+
+            return visitor.visit_f64(value);
+        }
+
+        if let Some(value) = RString::from_value(self.value) {
+            return visitor.visit_string(value.to_string()?);
+        }
+
+        if let Some(value) = Symbol::from_value(self.value) {
+            return visitor.visit_string(value.name()?.into_owned());
+        }
+
+        if let Some(value) = RArray::from_value(self.value) {
+            let depth = self.nested_depth()?;
+            return visitor.visit_seq(ArrayDeserializer::new(self.ruby, value, depth, self.mode));
+        }
+
+        if let Some(value) = RHash::from_value(self.value) {
+            let depth = self.nested_depth()?;
+            return visitor.visit_map(HashDeserializer::new(self.ruby, value, depth, self.mode)?);
+        }
+
+        Err(Error::type_error(format!(
+            "can't deserialize {}",
+            // SAFETY: conversion runs while the Ruby GVL is held.
+            unsafe { self.value.classname() }
+        )))
+    }
+
+    fn deserialize_bytes<Visitor>(self, _visitor: Visitor) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        Err(Error::type_error("can't deserialize into byte slice"))
+    }
+
+    fn deserialize_byte_buf<Visitor>(self, visitor: Visitor) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if let Some(string) = RString::from_value(self.value) {
+            // SAFETY: the bytes are copied before any further Ruby API call.
+            visitor.visit_byte_buf(unsafe { string.as_slice() }.to_owned())
+        } else {
+            Err(Error::type_error(format!(
+                "no implicit conversion of {} to String",
+                // SAFETY: conversion runs while the Ruby GVL is held.
+                unsafe { self.value.classname() }
+            )))
+        }
+    }
+
+    fn deserialize_option<Visitor>(self, visitor: Visitor) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if matches!(self.mode, Mode::OptionKeys) || self.value.is_nil() {
+            visitor.visit_none()
+        } else {
+            visitor.visit_some(self)
+        }
+    }
+
+    fn deserialize_enum<Visitor>(
+        self,
+        _name: &'static str,
+        _variants: &'static [&'static str],
+        visitor: Visitor,
+    ) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if let Some(variant) = RString::from_value(self.value) {
+            return visitor.visit_enum(EnumDeserializer::new(
+                self.ruby,
+                variant.to_string()?,
+                self.ruby.qnil().as_value(),
+                self.depth,
+                self.mode,
+            ));
+        }
+
+        if let Some(hash) = RHash::from_value(self.value) {
+            if hash.len() == 1 {
+                let keys: RArray = hash.funcall("keys", ())?;
+                let key: String = keys.entry(0)?;
+                let value = hash
+                    .get(key.as_str())
+                    .unwrap_or_else(|| self.ruby.qnil().as_value());
+                return visitor.visit_enum(EnumDeserializer::new(
+                    self.ruby, key, value, self.depth, self.mode,
+                ));
+            }
+            return Err(Error::type_error(format!(
+                "can't deserialize Hash of length {} to Enum",
+                hash.len()
+            )));
+        }
+
+        Err(Error::type_error(format!(
+            "can't deserialize {} to Enum",
+            // SAFETY: conversion runs while the Ruby GVL is held.
+            unsafe { self.value.classname() }
+        )))
+    }
+
+    fn deserialize_newtype_struct<Visitor>(
+        self,
+        name: &'static str,
+        visitor: Visitor,
+    ) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if name == NATIVE_OPTION_TOKEN {
+            visitor.visit_unit()
+        } else {
+            visitor.visit_newtype_struct(self)
+        }
+    }
+
+    fn deserialize_ignored_any<Visitor>(
+        self,
+        visitor: Visitor,
+    ) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_identifier<Visitor>(
+        self,
+        visitor: Visitor,
+    ) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if matches!(self.mode, Mode::OptionKeys) {
+            if let Some(value) = RString::from_value(self.value) {
+                return visitor.visit_string(value.to_string()?);
+            }
+            if let Some(value) = Symbol::from_value(self.value) {
+                return match value.name()? {
+                    std::borrow::Cow::Borrowed(name) => visitor.visit_borrowed_str(name),
+                    std::borrow::Cow::Owned(name) => visitor.visit_string(name),
+                };
+            }
+            return Err(Error::type_error("option keys must be Symbols or Strings"));
+        }
+
+        self.deserialize_any(visitor)
+    }
+
+    impl_deserialize_integers! {
+        deserialize_i8 => (visit_i8, to_i8),
+        deserialize_i16 => (visit_i16, to_i16),
+        deserialize_i32 => (visit_i32, to_i32),
+        deserialize_i64 => (visit_i64, to_i64),
+        deserialize_i128 => (visit_i128, to_i128),
+        deserialize_u8 => (visit_u8, to_u8),
+        deserialize_u16 => (visit_u16, to_u16),
+        deserialize_u32 => (visit_u32, to_u32),
+        deserialize_u64 => (visit_u64, to_u64),
+        deserialize_u128 => (visit_u128, to_u128),
+    }
+
+    forward_to_deserialize_any! {
+        <Visitor: Visitor<'de>>
+        bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map struct
+    }
+}

data/src/serde/de/enum_deserializer.rs

@@ -0,0 +1,47 @@
+use ::serde::de::{DeserializeSeed, EnumAccess, value::StringDeserializer};
+use magnus::{Ruby, Value};
+
+use super::{Mode, VariantDeserializer};
+use crate::serde::Error;
+
+/// Serde enum access over a Ruby string or one-entry hash.
+pub(super) struct EnumDeserializer<'ruby> {
+    ruby: &'ruby Ruby,
+    variant: String,
+    value: Value,
+    depth: usize,
+    mode: Mode,
+}
+
+impl<'ruby> EnumDeserializer<'ruby> {
+    /// Create enum access for a variant and its associated Ruby value.
+    pub(super) fn new(
+        ruby: &'ruby Ruby,
+        variant: String,
+        value: Value,
+        depth: usize,
+        mode: Mode,
+    ) -> Self {
+        Self {
+            ruby,
+            variant,
+            value,
+            depth,
+            mode,
+        }
+    }
+}
+
+impl<'ruby, 'de> EnumAccess<'de> for EnumDeserializer<'ruby> {
+    type Variant = VariantDeserializer<'ruby>;
+    type Error = Error;
+
+    fn variant_seed<Seed>(self, seed: Seed) -> Result<(Seed::Value, Self::Variant), Self::Error>
+    where
+        Seed: DeserializeSeed<'de>,
+    {
+        let variant = VariantDeserializer::new(self.ruby, self.value, self.depth, self.mode);
+        seed.deserialize(StringDeserializer::<Error>::new(self.variant))
+            .map(|value| (value, variant))
+    }
+}

data/src/serde/de/hash_deserializer.rs

@@ -0,0 +1,89 @@
+use std::iter::Peekable;
+
+use ::serde::de::{DeserializeSeed, MapAccess};
+use magnus::{RHash, RString, Ruby, Symbol, Value, r_hash::ForEach};
+
+use super::{Deserializer, Mode, array_enumerator::ArrayEnumerator};
+use crate::serde::Error;
+
+/// Serde map access over a Ruby hash.
+pub(super) struct HashDeserializer<'ruby> {
+    ruby: &'ruby Ruby,
+    hash: RHash,
+    keys: Peekable<ArrayEnumerator<'ruby>>,
+    depth: usize,
+    mode: Mode,
+}
+
+impl<'ruby> HashDeserializer<'ruby> {
+    /// Create map access while preserving Ruby hash insertion order.
+    pub(super) fn new(
+        ruby: &'ruby Ruby,
+        hash: RHash,
+        depth: usize,
+        mode: Mode,
+    ) -> Result<Self, Error> {
+        let keys = ruby.ary_new_capa(hash.len());
+        hash.foreach(|key: Value, _value: Value| {
+            keys.push(key)?;
+            Ok(ForEach::Continue)
+        })?;
+        Ok(Self {
+            ruby,
+            hash,
+            keys: ArrayEnumerator::new(ruby, keys).peekable(),
+            depth,
+            mode,
+        })
+    }
+
+    /// Reject object keys that JSON cannot represent.
+    fn validate_key(key: Value) -> Result<(), Error> {
+        if RString::from_value(key).is_some() || Symbol::from_value(key).is_some() {
+            Ok(())
+        } else {
+            Err(Error::message(
+                "JSON object keys must be String or Symbol values",
+            ))
+        }
+    }
+}
+
+impl<'de> MapAccess<'de> for HashDeserializer<'_> {
+    type Error = Error;
+
+    fn next_key_seed<Seed>(&mut self, seed: Seed) -> Result<Option<Seed::Value>, Self::Error>
+    where
+        Seed: DeserializeSeed<'de>,
+    {
+        match self.keys.peek() {
+            Some(Ok(key)) => {
+                if matches!(self.mode, Mode::Json) {
+                    Self::validate_key(*key)?;
+                }
+                seed.deserialize(Deserializer::with_mode(
+                    self.ruby, *key, self.depth, self.mode,
+                ))
+                .map(Some)
+            }
+            Some(Err(error)) => Err(Error::message(format!("failed to read map key: {error}"))),
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<Seed>(&mut self, seed: Seed) -> Result<Seed::Value, Self::Error>
+    where
+        Seed: DeserializeSeed<'de>,
+    {
+        match self.keys.next() {
+            Some(Ok(key)) => seed.deserialize(Deserializer::with_mode(
+                self.ruby,
+                self.hash.aref(key)?,
+                self.depth,
+                self.mode,
+            )),
+            Some(Err(error)) => Err(error),
+            None => Err(Error::message("map value has no matching key")),
+        }
+    }
+}

data/src/serde/de/number_deserializer.rs

@@ -0,0 +1,51 @@
+use ::serde::de::{
+    DeserializeSeed, MapAccess,
+    value::{BorrowedStrDeserializer, StringDeserializer},
+};
+
+use super::super::{Error, JSON_NUMBER_TOKEN};
+
+/// Serde map representation used by `serde_json` for arbitrary-precision numbers.
+pub(super) struct NumberDeserializer {
+    source: Option<String>,
+}
+
+impl NumberDeserializer {
+    /// Create a one-entry number map from a Ruby Integer decimal string.
+    pub(super) fn new(source: String) -> Self {
+        Self {
+            source: Some(source),
+        }
+    }
+}
+
+impl<'de> MapAccess<'de> for NumberDeserializer {
+    type Error = Error;
+
+    fn next_key_seed<Seed>(&mut self, seed: Seed) -> Result<Option<Seed::Value>, Self::Error>
+    where
+        Seed: DeserializeSeed<'de>,
+    {
+        if self.source.is_none() {
+            return Ok(None);
+        }
+
+        seed.deserialize(BorrowedStrDeserializer::<Error>::new(JSON_NUMBER_TOKEN))
+            .map(Some)
+    }
+
+    fn next_value_seed<Seed>(&mut self, seed: Seed) -> Result<Seed::Value, Self::Error>
+    where
+        Seed: DeserializeSeed<'de>,
+    {
+        let source = self
+            .source
+            .take()
+            .ok_or_else(|| Error::message("JSON number value is missing"))?;
+        seed.deserialize(StringDeserializer::<Error>::new(source))
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(usize::from(self.source.is_some()))
+    }
+}

data/src/serde/de/variant_deserializer.rs

@@ -0,0 +1,101 @@
+use ::serde::de::{DeserializeSeed, Unexpected, VariantAccess};
+use magnus::{RArray, RHash, Ruby, Value, value::ReprValue};
+
+use super::{ArrayDeserializer, Deserializer, HashDeserializer, Mode};
+use crate::serde::Error;
+
+/// Serde access to the payload of a Ruby enum representation.
+pub(super) struct VariantDeserializer<'ruby> {
+    ruby: &'ruby Ruby,
+    value: Value,
+    depth: usize,
+    mode: Mode,
+}
+
+impl<'ruby> VariantDeserializer<'ruby> {
+    /// Create variant access for a Ruby payload.
+    pub(super) fn new(ruby: &'ruby Ruby, value: Value, depth: usize, mode: Mode) -> Self {
+        Self {
+            ruby,
+            value,
+            depth,
+            mode,
+        }
+    }
+
+    /// Return the depth assigned to a container payload.
+    fn nested_depth(&self) -> Result<usize, Error> {
+        Deserializer::with_mode(self.ruby, self.value, self.depth, self.mode).nested_depth()
+    }
+}
+
+impl<'de> VariantAccess<'de> for VariantDeserializer<'_> {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        if self.value.is_nil() {
+            Ok(())
+        } else {
+            Err(::serde::de::Error::invalid_type(
+                Unexpected::Other(
+                    // SAFETY: conversion runs while the Ruby GVL is held.
+                    &unsafe { self.value.classname() },
+                ),
+                &"unit variant",
+            ))
+        }
+    }
+
+    fn newtype_variant_seed<Seed>(self, seed: Seed) -> Result<Seed::Value, Self::Error>
+    where
+        Seed: DeserializeSeed<'de>,
+    {
+        seed.deserialize(Deserializer::with_mode(
+            self.ruby, self.value, self.depth, self.mode,
+        ))
+    }
+
+    fn tuple_variant<Visitor>(
+        self,
+        _len: usize,
+        visitor: Visitor,
+    ) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if let Some(array) = RArray::from_value(self.value) {
+            let depth = self.nested_depth()?;
+            visitor.visit_seq(ArrayDeserializer::new(self.ruby, array, depth, self.mode))
+        } else {
+            Err(::serde::de::Error::invalid_type(
+                Unexpected::Other(
+                    // SAFETY: conversion runs while the Ruby GVL is held.
+                    &unsafe { self.value.classname() },
+                ),
+                &"tuple variant",
+            ))
+        }
+    }
+
+    fn struct_variant<Visitor>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: Visitor,
+    ) -> Result<Visitor::Value, Self::Error>
+    where
+        Visitor: ::serde::de::Visitor<'de>,
+    {
+        if let Some(hash) = RHash::from_value(self.value) {
+            let depth = self.nested_depth()?;
+            visitor.visit_map(HashDeserializer::new(self.ruby, hash, depth, self.mode)?)
+        } else {
+            Err(::serde::de::Error::invalid_type(
+                Unexpected::Other(
+                    // SAFETY: conversion runs while the Ruby GVL is held.
+                    &unsafe { self.value.classname() },
+                ),
+                &"struct variant",
+            ))
+        }
+    }
+}

data/src/serde/de.rs

@@ -0,0 +1,33 @@
+mod array_deserializer;
+mod array_enumerator;
+mod deserializer;
+mod enum_deserializer;
+mod hash_deserializer;
+mod number_deserializer;
+mod variant_deserializer;
+
+use ::serde::Deserialize;
+use magnus::{Ruby, Value};
+
+use super::Error;
+use array_deserializer::ArrayDeserializer;
+pub(super) use deserializer::Deserializer;
+use deserializer::Mode;
+use hash_deserializer::HashDeserializer;
+use variant_deserializer::VariantDeserializer;
+
+/// Deserialize one Ruby value using native Ruby data model semantics.
+pub(super) fn deserialize_ruby<'de, Output>(ruby: &Ruby, value: Value) -> Result<Output, Error>
+where
+    Output: Deserialize<'de>,
+{
+    Output::deserialize(Deserializer::new_ruby(ruby, value))
+}
+
+/// Deserialize one Ruby value using JSON-specific conversion rules.
+pub(super) fn deserialize_json<'de, Output>(ruby: &Ruby, value: Value) -> Result<Output, Error>
+where
+    Output: Deserialize<'de>,
+{
+    Output::deserialize(Deserializer::new_json(ruby, value))
+}