wreq 1.2.5 → 1.2.7

data/src/serde/error.rs

@@ -0,0 +1,146 @@
+use std::fmt;
+
+use magnus::error::ErrorType;
+use serde_path_to_error::Path;
+
+use crate::error::contextualize_magnus_error;
+
+/// Error produced by the local Ruby and Serde bridge.
+#[derive(Debug)]
+pub(crate) enum Error {
+    Runtime(String),
+    Type(String),
+    DuplicateField(&'static str),
+    Ruby(magnus::Error),
+}
+
+impl Error {
+    /// Create a bridge error from a human-readable message.
+    pub(super) fn message(message: impl Into<String>) -> Self {
+        Self::Runtime(message.into())
+    }
+
+    /// Create a type mismatch error.
+    pub(super) fn type_error(message: impl Into<String>) -> Self {
+        Self::Type(message.into())
+    }
+
+    /// Convert this bridge error into the matching Ruby exception.
+    pub(super) fn into_magnus(self, ruby: &magnus::Ruby) -> magnus::Error {
+        match self {
+            Self::Runtime(message) => magnus::Error::new(ruby.exception_runtime_error(), message),
+            Self::Type(message) => magnus::Error::new(ruby.exception_type_error(), message),
+            Self::DuplicateField(field) => magnus::Error::new(
+                ruby.exception_runtime_error(),
+                format!("duplicate field `{field}`"),
+            ),
+            Self::Ruby(error) => error,
+        }
+    }
+
+    /// Convert an option value error into Ruby's normal argument categories.
+    pub(super) fn into_option_magnus(
+        self,
+        ruby: &magnus::Ruby,
+        path: Option<&Path>,
+    ) -> magnus::Error {
+        match self {
+            Self::Runtime(message) => magnus::Error::new(
+                ruby.exception_arg_error(),
+                contextualize_message(path, message),
+            ),
+            Self::Type(message) => magnus::Error::new(
+                ruby.exception_type_error(),
+                contextualize_message(path, message),
+            ),
+            Self::DuplicateField(field) => magnus::Error::new(
+                ruby.exception_arg_error(),
+                format!("duplicate option: :{field}"),
+            ),
+            Self::Ruby(error) if error.is_kind_of(ruby.exception_range_error()) => {
+                magnus::Error::new(
+                    ruby.exception_arg_error(),
+                    magnus_error_message(&error, path),
+                )
+            }
+            Self::Ruby(error) => match path {
+                Some(path) => {
+                    contextualize_magnus_error(error, format_args!("invalid value for :{path}"))
+                }
+                None => error,
+            },
+        }
+    }
+}
+
+/// Prefix an error message when Serde identified the failing option path.
+fn contextualize_message(path: Option<&Path>, message: String) -> String {
+    match path {
+        Some(path) => format!("invalid value for :{path}: {message}"),
+        None => message,
+    }
+}
+
+/// Build the final Ruby error message without an intermediate context String.
+fn magnus_error_message(error: &magnus::Error, path: Option<&Path>) -> String {
+    match (path, error.error_type()) {
+        (Some(path), ErrorType::Error(_, message)) => {
+            format!("invalid value for :{path}: {message}")
+        }
+        (Some(path), ErrorType::Exception(exception)) => {
+            format!("invalid value for :{path}: {exception}")
+        }
+        (Some(path), ErrorType::Jump(_)) => format!("invalid value for :{path}: {error}"),
+        (None, ErrorType::Error(_, message)) => message.as_ref().to_owned(),
+        (None, _) => error.to_string(),
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Runtime(message) | Self::Type(message) => formatter.write_str(message),
+            Self::DuplicateField(field) => write!(formatter, "duplicate field `{field}`"),
+            Self::Ruby(error) => error.fmt(formatter),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl ::serde::ser::Error for Error {
+    fn custom<T>(message: T) -> Self
+    where
+        T: fmt::Display,
+    {
+        Self::message(message.to_string())
+    }
+}
+
+impl ::serde::de::Error for Error {
+    fn custom<T>(message: T) -> Self
+    where
+        T: fmt::Display,
+    {
+        Self::message(message.to_string())
+    }
+
+    fn invalid_type(
+        unexpected: ::serde::de::Unexpected<'_>,
+        expected: &dyn ::serde::de::Expected,
+    ) -> Self {
+        Self::type_error(format!(
+            "invalid type: expected {expected}, got {unexpected}"
+        ))
+    }
+
+    fn duplicate_field(field: &'static str) -> Self {
+        Self::DuplicateField(field)
+    }
+}
+
+impl From<magnus::Error> for Error {
+    fn from(error: magnus::Error) -> Self {
+        Self::Ruby(error)
+    }
+}

data/src/serde/ser/enums.rs

@@ -0,0 +1,14 @@
+use magnus::{IntoValue, Ruby, Value};
+
+use crate::serde::Error;
+
+/// Wrap serialized enum data in the one-entry hash used by `serde_magnus`.
+pub(super) fn nest(
+    ruby: &Ruby,
+    variant: &'static str,
+    data: impl IntoValue,
+) -> Result<Value, Error> {
+    let hash = ruby.hash_new();
+    hash.aset(variant, data)?;
+    Ok(hash.into_value_with(ruby))
+}

data/src/serde/ser/map_serializer.rs

@@ -0,0 +1,56 @@
+use ::serde::{Serialize, ser::SerializeMap};
+use magnus::{IntoValue, RHash, Ruby, Value};
+
+use super::Serializer;
+use crate::serde::Error;
+
+/// Serde map serializer backed by a Ruby hash.
+pub(super) struct MapSerializer<'ruby> {
+    ruby: &'ruby Ruby,
+    hash: RHash,
+    key: Option<Value>,
+}
+
+impl<'ruby> MapSerializer<'ruby> {
+    /// Create a map serializer for an allocated Ruby hash.
+    pub(super) fn new(ruby: &'ruby Ruby, hash: RHash) -> Self {
+        Self {
+            ruby,
+            hash,
+            key: None,
+        }
+    }
+}
+
+impl SerializeMap for MapSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        self.key = Some(key.serialize(Serializer::new(self.ruby))?);
+        Ok(())
+    }
+
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        let key = self
+            .key
+            .take()
+            .ok_or_else(|| Error::message("map value has no matching key"))?;
+        self.hash
+            .aset(key, value.serialize(Serializer::new(self.ruby))?)
+            .map_err(Into::into)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        if self.key.is_some() {
+            return Err(Error::message("map key has no matching value"));
+        }
+        Ok(self.hash.into_value_with(self.ruby))
+    }
+}

data/src/serde/ser/seq_serializer.rs

@@ -0,0 +1,71 @@
+use ::serde::{
+    Serialize,
+    ser::{SerializeSeq, SerializeTuple, SerializeTupleStruct},
+};
+use magnus::{IntoValue, RArray, Ruby, Value};
+
+use super::Serializer;
+use crate::serde::Error;
+
+/// Serde sequence serializer backed by a Ruby array.
+pub(super) struct SeqSerializer<'ruby> {
+    ruby: &'ruby Ruby,
+    array: RArray,
+}
+
+impl<'ruby> SeqSerializer<'ruby> {
+    /// Create a sequence serializer for an allocated Ruby array.
+    pub(super) fn new(ruby: &'ruby Ruby, array: RArray) -> Self {
+        Self { ruby, array }
+    }
+}
+
+impl SerializeSeq for SeqSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, element: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        self.array
+            .push(element.serialize(Serializer::new(self.ruby))?)
+            .map_err(Into::into)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(self.array.into_value_with(self.ruby))
+    }
+}
+
+impl SerializeTuple for SeqSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, element: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        SerializeSeq::serialize_element(self, element)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        SerializeSeq::end(self)
+    }
+}
+
+impl SerializeTupleStruct for SeqSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_field<T>(&mut self, field: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        SerializeSeq::serialize_element(self, field)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        SerializeSeq::end(self)
+    }
+}

data/src/serde/ser/serializer.rs

@@ -0,0 +1,194 @@
+use ::serde::Serialize;
+use magnus::{IntoValue, Ruby, Value};
+
+use super::super::Error;
+use super::{
+    enums::nest, map_serializer::MapSerializer, seq_serializer::SeqSerializer,
+    struct_serializer::StructSerializer, struct_variant_serializer::StructVariantSerializer,
+    tuple_variant_serializer::TupleVariantSerializer,
+};
+
+/// Implement primitive numeric serialization through Magnus's `IntoValue`.
+macro_rules! impl_serialize_numbers {
+    ($($method:ident => $type:ty),+ $(,)?) => {
+        $(
+            fn $method(self, value: $type) -> Result<Self::Ok, Self::Error> {
+                Ok(value.into_value_with(self.ruby))
+            }
+        )+
+    };
+}
+
+/// Serde serializer that creates Ruby values.
+pub(super) struct Serializer<'ruby> {
+    ruby: &'ruby Ruby,
+}
+
+impl<'ruby> Serializer<'ruby> {
+    /// Create a serializer with upstream `serde_magnus` behavior.
+    pub(super) fn new(ruby: &'ruby Ruby) -> Self {
+        Self { ruby }
+    }
+}
+
+impl<'ruby> ::serde::Serializer for Serializer<'ruby> {
+    type Ok = Value;
+    type Error = Error;
+
+    type SerializeSeq = SeqSerializer<'ruby>;
+    type SerializeTuple = SeqSerializer<'ruby>;
+    type SerializeTupleStruct = SeqSerializer<'ruby>;
+    type SerializeTupleVariant = TupleVariantSerializer<'ruby>;
+    type SerializeMap = MapSerializer<'ruby>;
+    type SerializeStruct = StructSerializer<'ruby>;
+    type SerializeStructVariant = StructVariantSerializer<'ruby>;
+
+    fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
+        Ok(value.into_value_with(self.ruby))
+    }
+
+    impl_serialize_numbers! {
+        serialize_i8 => i8,
+        serialize_i16 => i16,
+        serialize_i32 => i32,
+        serialize_i64 => i64,
+        serialize_i128 => i128,
+        serialize_u8 => u8,
+        serialize_u16 => u16,
+        serialize_u32 => u32,
+        serialize_u64 => u64,
+        serialize_u128 => u128,
+        serialize_f32 => f32,
+        serialize_f64 => f64,
+    }
+
+    fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
+        Ok(value.into_value_with(self.ruby))
+    }
+
+    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
+        Ok(value.into_value_with(self.ruby))
+    }
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Ok(self.ruby.str_from_slice(value).into_value_with(self.ruby))
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        self.serialize_unit()
+    }
+
+    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Ok(().into_value_with(self.ruby))
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _index: u32,
+        variant: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        self.serialize_str(variant)
+    }
+
+    fn serialize_newtype_struct<T>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &'static str,
+        _index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        nest(
+            self.ruby,
+            variant,
+            value.serialize(Serializer::new(self.ruby))?,
+        )
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Ok(SeqSerializer::new(
+            self.ruby,
+            self.ruby.ary_new_capa(len.unwrap_or(0)),
+        ))
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Ok(TupleVariantSerializer::new(
+            self.ruby,
+            variant,
+            self.ruby.ary_new_capa(len),
+        ))
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Ok(MapSerializer::new(
+            self.ruby,
+            self.ruby.hash_new_capa(len.unwrap_or(0)),
+        ))
+    }
+
+    fn serialize_struct(
+        self,
+        name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Ok(StructSerializer::new(self.ruby, name, len))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        Ok(StructVariantSerializer::new(
+            self.ruby,
+            variant,
+            self.ruby.hash_new_capa(len),
+        ))
+    }
+}

data/src/serde/ser/struct_serializer.rs

@@ -0,0 +1,106 @@
+use ::serde::{Serialize, ser::SerializeStruct};
+use magnus::{Integer, IntoValue, RHash, RString, Ruby, Value, value::ReprValue};
+
+use super::Serializer;
+use crate::serde::{Error, JSON_NUMBER_TOKEN};
+
+/// Serde struct serializer, including `serde_json` arbitrary-precision numbers.
+pub(super) enum StructSerializer<'ruby> {
+    Map {
+        ruby: &'ruby Ruby,
+        hash: RHash,
+    },
+    Number {
+        ruby: &'ruby Ruby,
+        value: Option<Value>,
+    },
+}
+
+impl<'ruby> StructSerializer<'ruby> {
+    /// Create the serializer selected by the Serde struct name.
+    pub(super) fn new(ruby: &'ruby Ruby, name: &'static str, len: usize) -> Self {
+        if name == JSON_NUMBER_TOKEN {
+            Self::Number { ruby, value: None }
+        } else {
+            Self::Map {
+                ruby,
+                hash: ruby.hash_new_capa(len),
+            }
+        }
+    }
+}
+
+impl SerializeStruct for StructSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_field<T>(&mut self, name: &'static str, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        match self {
+            Self::Map { ruby, hash } => hash
+                .aset(
+                    ruby.to_symbol(name),
+                    value.serialize(Serializer::new(ruby))?,
+                )
+                .map_err(Into::into),
+            Self::Number {
+                ruby,
+                value: output,
+            } => {
+                if name != JSON_NUMBER_TOKEN {
+                    return Err(Error::message("invalid arbitrary-precision number field"));
+                }
+
+                if output.is_some() {
+                    return Err(Error::message(
+                        "arbitrary-precision number has duplicate fields",
+                    ));
+                }
+
+                let source = value.serialize(Serializer::new(ruby))?;
+                let source = RString::from_value(source)
+                    .ok_or_else(|| Error::message("JSON number token must be a String"))?
+                    .to_string()?;
+                *output = Some(number_to_ruby(ruby, &source)?);
+                Ok(())
+            }
+        }
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        match self {
+            Self::Map { ruby, hash } => Ok(hash.into_value_with(ruby)),
+            Self::Number { value, .. } => {
+                value.ok_or_else(|| Error::message("JSON number token is missing"))
+            }
+        }
+    }
+}
+
+/// Convert a validated JSON number token into a Ruby Integer or Float.
+fn number_to_ruby(ruby: &Ruby, source: &str) -> Result<Value, Error> {
+    if is_integral_number(source) {
+        integer_to_ruby(ruby, source)
+    } else {
+        let value = source.parse::<f64>().map_err(|error| {
+            Error::message(format!("failed to convert JSON number {source}: {error}"))
+        })?;
+        Ok(ruby.float_from_f64(value).as_value())
+    }
+}
+
+/// Convert a decimal integer token into an arbitrary-precision Ruby Integer.
+fn integer_to_ruby(ruby: &Ruby, source: &str) -> Result<Value, Error> {
+    let source = ruby.str_new(source);
+    let value: Integer = ruby.module_kernel().funcall("Integer", (source, 10))?;
+    Ok(value.as_value())
+}
+
+/// Return whether a validated JSON number token is integral.
+fn is_integral_number(source: &str) -> bool {
+    !source
+        .bytes()
+        .any(|byte| matches!(byte, b'.' | b'e' | b'E'))
+}

data/src/serde/ser/struct_variant_serializer.rs

@@ -0,0 +1,44 @@
+use ::serde::{Serialize, ser::SerializeStructVariant};
+use magnus::{RHash, Ruby, Value};
+
+use super::{Serializer, enums::nest};
+use crate::serde::Error;
+
+/// Serde struct-variant serializer backed by a Ruby hash.
+pub(super) struct StructVariantSerializer<'ruby> {
+    ruby: &'ruby Ruby,
+    variant: &'static str,
+    hash: RHash,
+}
+
+impl<'ruby> StructVariantSerializer<'ruby> {
+    /// Create a struct-variant serializer for an allocated Ruby hash.
+    pub(super) fn new(ruby: &'ruby Ruby, variant: &'static str, hash: RHash) -> Self {
+        Self {
+            ruby,
+            variant,
+            hash,
+        }
+    }
+}
+
+impl SerializeStructVariant for StructVariantSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_field<T>(&mut self, name: &'static str, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        self.hash
+            .aset(
+                self.ruby.to_symbol(name),
+                value.serialize(Serializer::new(self.ruby))?,
+            )
+            .map_err(Into::into)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        nest(self.ruby, self.variant, self.hash)
+    }
+}

data/src/serde/ser/tuple_variant_serializer.rs

@@ -0,0 +1,41 @@
+use ::serde::{Serialize, ser::SerializeTupleVariant};
+use magnus::{RArray, Ruby, Value};
+
+use super::{Serializer, enums::nest};
+use crate::serde::Error;
+
+/// Serde tuple-variant serializer backed by a Ruby array.
+pub(super) struct TupleVariantSerializer<'ruby> {
+    ruby: &'ruby Ruby,
+    variant: &'static str,
+    array: RArray,
+}
+
+impl<'ruby> TupleVariantSerializer<'ruby> {
+    /// Create a tuple-variant serializer for an allocated Ruby array.
+    pub(super) fn new(ruby: &'ruby Ruby, variant: &'static str, array: RArray) -> Self {
+        Self {
+            ruby,
+            variant,
+            array,
+        }
+    }
+}
+
+impl SerializeTupleVariant for TupleVariantSerializer<'_> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_field<T>(&mut self, field: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize + ?Sized,
+    {
+        self.array
+            .push(field.serialize(Serializer::new(self.ruby))?)
+            .map_err(Into::into)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        nest(self.ruby, self.variant, self.array)
+    }
+}

data/src/serde/ser.rs

@@ -0,0 +1,18 @@
+mod enums;
+mod map_serializer;
+mod seq_serializer;
+mod serializer;
+mod struct_serializer;
+mod struct_variant_serializer;
+mod tuple_variant_serializer;
+
+use ::serde::Serialize;
+use magnus::{Ruby, Value};
+
+use super::Error;
+use serializer::Serializer;
+
+/// Serialize any Serde value into Ruby values.
+pub(super) fn serialize(ruby: &Ruby, value: &(impl Serialize + ?Sized)) -> Result<Value, Error> {
+    value.serialize(Serializer::new(ruby))
+}