wreq 1.2.4 → 1.2.6

data/src/http.rs

@@ -1,31 +1,38 @@
-use magnus::{Error, Module, RModule, Ruby, TryConvert, Value, method, typed_data::Inspect};
+use magnus::{Error, Module, RModule, Ruby, TryConvert, Value, method};
 
+// Defines constant registration, `into_ffi`/`from_ffi`, and handlers for
+// Ruby's `to_s`, `==`, `eql?`, and `hash` methods.
+// `wreq::Version` only exposes protocol strings through `Debug`, so static
+// labels avoid allocating an intermediate `String`.
 define_ruby_enum!(
     /// An HTTP version.
-    const,
     Version,
     "Wreq::Version",
     wreq::Version,
-    HTTP_09,
-    HTTP_10,
-    HTTP_11,
-    HTTP_2,
-    HTTP_3,
+    strings:
+    HTTP_09 => "HTTP/0.9",
+    HTTP_10 => "HTTP/1.0",
+    HTTP_11 => "HTTP/1.1",
+    HTTP_2 => "HTTP/2.0",
+    HTTP_3 => "HTTP/3.0",
 );
 
+// Defines constant registration, `into_ffi`/`from_ffi`, and handlers for
+// Ruby's `to_s`, `to_sym`, `==`, `eql?`, and `hash` methods.
 define_ruby_enum!(
     /// An HTTP method.
     Method,
     "Wreq::Method",
     wreq::Method,
-    GET,
-    HEAD,
-    POST,
-    PUT,
-    DELETE,
-    OPTIONS,
-    TRACE,
-    PATCH,
+    symbols:
+    GET => "get",
+    HEAD => "head",
+    POST => "post",
+    PUT => "put",
+    DELETE => "delete",
+    OPTIONS => "options",
+    TRACE => "trace",
+    PATCH => "patch",
 );
 
 /// HTTP status code.
@@ -33,24 +40,6 @@ define_ruby_enum!(
 #[magnus::wrap(class = "Wreq::StatusCode", free_immediately, size)]
 pub struct StatusCode(pub wreq::StatusCode);
 
-// ===== impl Version =====
-
-impl Version {
-    /// Convert version to string.
-    #[inline]
-    pub fn to_s(&self) -> String {
-        self.into_ffi().inspect()
-    }
-
-    /// Value-based equality for Ruby (`==`).
-    #[inline]
-    pub fn equals(&self, other: Value) -> bool {
-        <&Version>::try_convert(other)
-            .map(|other| *self == *other)
-            .unwrap_or(false)
-    }
-}
-
 impl TryConvert for Version {
     fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
         <&Version>::try_convert(value).cloned()
@@ -101,6 +90,35 @@ impl StatusCode {
     pub fn to_s(&self) -> String {
         self.0.to_string()
     }
+
+    /// Value-based equality for Ruby (`==`).
+    #[inline]
+    pub fn equals(&self, other: Value) -> bool {
+        <&StatusCode>::try_convert(other)
+            .map(|other| *self == *other)
+            .unwrap_or(false)
+    }
+
+    /// Strict equality for Ruby (`eql?`).
+    #[inline]
+    pub fn is_eql(&self, other: Value) -> bool {
+        self.equals(other)
+    }
+
+    /// Hash value for Ruby (`hash`).
+    #[inline]
+    pub fn hash_value(&self) -> u64 {
+        use std::hash::{Hash, Hasher};
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        self.0.hash(&mut hasher);
+        hasher.finish()
+    }
+
+    /// Return the status code as an integer (Ruby `to_i`).
+    #[inline]
+    pub const fn to_i(&self) -> u16 {
+        self.0.as_u16()
+    }
 }
 
 impl From<wreq::StatusCode> for StatusCode {
@@ -112,11 +130,18 @@ impl From<wreq::StatusCode> for StatusCode {
 pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     let method_class = gem_module.define_class("Method", ruby.class_object())?;
     Method::define_constants(method_class)?;
+    method_class.define_method("to_s", method!(Method::to_s, 0))?;
+    method_class.define_method("to_sym", method!(Method::to_sym, 0))?;
+    method_class.define_method("==", method!(Method::equals, 1))?;
+    method_class.define_method("eql?", method!(Method::is_eql, 1))?;
+    method_class.define_method("hash", method!(Method::hash_value, 0))?;
 
     let version_class = gem_module.define_class("Version", ruby.class_object())?;
     Version::define_constants(version_class)?;
     version_class.define_method("to_s", method!(Version::to_s, 0))?;
     version_class.define_method("==", method!(Version::equals, 1))?;
+    version_class.define_method("eql?", method!(Version::is_eql, 1))?;
+    version_class.define_method("hash", method!(Version::hash_value, 0))?;
 
     let status_code_class = gem_module.define_class("StatusCode", ruby.class_object())?;
     status_code_class.define_method("as_int", method!(StatusCode::as_int, 0))?;
@@ -126,6 +151,10 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     status_code_class.define_method("client_error?", method!(StatusCode::is_client_error, 0))?;
     status_code_class.define_method("server_error?", method!(StatusCode::is_server_error, 0))?;
     status_code_class.define_method("to_s", method!(StatusCode::to_s, 0))?;
+    status_code_class.define_method("==", method!(StatusCode::equals, 1))?;
+    status_code_class.define_method("eql?", method!(StatusCode::is_eql, 1))?;
+    status_code_class.define_method("hash", method!(StatusCode::hash_value, 0))?;
+    status_code_class.define_method("to_i", method!(StatusCode::to_i, 0))?;
 
     Ok(())
 }

data/src/lib.rs

@@ -1,3 +1,4 @@
+#![deny(unsafe_code)]
 #![allow(clippy::wrong_self_convention)]
 
 #[macro_use]
@@ -11,67 +12,72 @@ mod extractor;
 mod gvl;
 mod header;
 mod http;
+mod options;
 mod rt;
+mod serde;
 
 use magnus::{Error, Module, Ruby, Value};
 
-use crate::client::{Client, resp::Response};
+use crate::{
+    client::{Client, resp::Response},
+    http::Method,
+};
 
 const RUBY_MODULE_NAME: &str = "Wreq";
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 /// Send a HTTP request.
 #[inline]
-pub fn request(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::request(&Client::default(), args)
+pub fn request(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::request_with_default_client(ruby, args)
 }
 
 /// Send a GET request.
 #[inline]
-pub fn get(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::get(&Client::default(), args)
+pub fn get(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::GET, args)
 }
 
 /// Send a POST request.
 #[inline]
-pub fn post(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::post(&Client::default(), args)
+pub fn post(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::POST, args)
 }
 
 /// Send a PUT request.
 #[inline]
-pub fn put(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::put(&Client::default(), args)
+pub fn put(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::PUT, args)
 }
 
 /// Send a DELETE request.
 #[inline]
-pub fn delete(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::delete(&Client::default(), args)
+pub fn delete(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::DELETE, args)
 }
 
 /// Send a HEAD request.
 #[inline]
-pub fn head(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::head(&Client::default(), args)
+pub fn head(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::HEAD, args)
 }
 
 /// Send an OPTIONS request.
 #[inline]
-pub fn options(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::options(&Client::default(), args)
+pub fn options(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::OPTIONS, args)
 }
 
 /// Send a TRACE request.
 #[inline]
-pub fn trace(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::trace(&Client::default(), args)
+pub fn trace(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::TRACE, args)
 }
 
 /// Send a PATCH request.
 #[inline]
-pub fn patch(args: &[Value]) -> Result<Response, magnus::Error> {
-    Client::patch(&Client::default(), args)
+pub fn patch(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::execute_with_default_client(ruby, Method::PATCH, args)
 }
 
 /// wreq ruby binding
@@ -93,6 +99,6 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     cookie::include(ruby, &gem_module)?;
     client::include(ruby, &gem_module)?;
     emulate::include(ruby, &gem_module)?;
-    error::include(ruby);
+    error::include(ruby, &gem_module)?;
     Ok(())
 }

data/src/macros.rs

@@ -34,92 +34,116 @@ macro_rules! apply_option {
             $builder = $builder.$method();
         }
     };
-    (set_if_true_with, $builder:expr, $option:expr, $method:ident, $default:expr, $value:expr) => {
-        if $option.unwrap_or($default) {
-            $builder = $builder.$method($value);
-        }
-    };
+}
+
+/// Convert a Ruby-native option whose field name is also its keyword name.
+macro_rules! extract_native_option {
+    ($options:expr, $target:expr, $field:ident) => {{
+        $target.$field.set($options.convert(stringify!($field))?);
+    }};
+    ($options:expr, $target:expr, $field:ident, present) => {{
+        $target
+            .$field
+            .set($options.convert_present(stringify!($field))?);
+    }};
+    ($options:expr, $target:expr, $field:ident, $source:ty => $map:expr) => {{
+        $target
+            .$field
+            .set($options.convert::<$source>(stringify!($field))?.map($map));
+    }};
 }
 
 macro_rules! define_ruby_enum {
-    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $($variant:ident),* $(,)?) => {
-        define_ruby_enum!($(#[$meta])* $enum_type, $ruby_class, $ffi_type, $( ($variant, $variant) ),*);
+    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, strings: $($variant:ident => $display:expr),* $(,)?) => {
+        define_ruby_enum!(@impl $(#[$meta])* $enum_type, $ruby_class, $ffi_type, [$(($variant, $display)),*], []);
+    };
+
+    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, symbols: $($variant:ident => $symbol:expr),* $(,)?) => {
+        define_ruby_enum!(@impl $(#[$meta])* $enum_type, $ruby_class, $ffi_type, [$(($variant, stringify!($variant))),*], [$($variant => $symbol),*]);
     };
 
-    ($(#[$meta:meta])* const, $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $($variant:ident),* $(,)?) => {
-        define_ruby_enum!($(#[$meta])* const, $enum_type, $ruby_class, $ffi_type, $( ($variant, $variant) ),*);
+    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $($variant:ident),* $(,)?) => {
+        define_ruby_enum!(@impl $(#[$meta])* $enum_type, $ruby_class, $ffi_type, [$(($variant, stringify!($variant))),*], []);
     };
 
-    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $(($rust_variant:ident, $ffi_variant:ident)),* $(,)?) => {
+    (@impl $(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, [$(($variant:ident, $display:expr)),*], [$($symbol_variant:ident => $symbol:expr),*]) => {
         $(#[$meta])*
         #[magnus::wrap(class = $ruby_class, free_immediately, size)]
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         #[allow(non_camel_case_types)]
         #[allow(clippy::upper_case_acronyms)]
         pub enum $enum_type {
-            $($rust_variant),*
+            $($variant),*
         }
 
         impl $enum_type {
+            /// Return the static text exposed through Ruby's `to_s`.
+            #[inline]
+            pub const fn to_s(&self) -> &'static str {
+                match self {
+                    $(<$enum_type>::$variant => $display,)*
+                }
+            }
+
+            define_ruby_enum!(@to_sym $enum_type, [$($symbol_variant => $symbol),*]);
+
+            /// Convert this Ruby wrapper into its native enum value.
             pub fn into_ffi(self) -> $ffi_type {
                 match self {
-                    $(<$enum_type>::$rust_variant => <$ffi_type>::$ffi_variant,)*
+                    $(<$enum_type>::$variant => <$ffi_type>::$variant,)*
                 }
             }
 
+            /// Convert a known native enum value into its Ruby wrapper.
             #[allow(dead_code)]
             pub fn from_ffi(ffi: $ffi_type) -> Self {
                 #[allow(unreachable_patterns)]
                 match ffi {
-                    $(<$ffi_type>::$ffi_variant => <$enum_type>::$rust_variant,)*
+                    $(<$ffi_type>::$variant => <$enum_type>::$variant,)*
                     _ => unreachable!(),
                 }
             }
 
+            /// Register every enum variant as a constant on the Ruby class.
             pub fn define_constants(class: magnus::RClass) -> Result<(), magnus::Error> {
-                $(class.const_set(stringify!($rust_variant), <$enum_type>::$rust_variant)?;)*
+                $(class.const_set(stringify!($variant), <$enum_type>::$variant)?;)*
                 Ok(())
             }
-        }
-    };
-
-    ($(#[$meta:meta])* const, $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $(($rust_variant:ident, $ffi_variant:ident)),* $(,)?) => {
-        $(#[$meta])*
-        #[magnus::wrap(class = $ruby_class, free_immediately, size)]
-        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-        #[allow(non_camel_case_types)]
-        #[allow(clippy::upper_case_acronyms)]
-        pub enum $enum_type {
-            $($rust_variant),*
-        }
 
-        impl $enum_type {
-            pub const fn into_ffi(self) -> $ffi_type {
-                match self {
-                    $(<$enum_type>::$rust_variant => <$ffi_type>::$ffi_variant,)*
-                }
+            /// Compare two wrapped enum values for Ruby's `==`.
+            pub fn equals(&self, other: magnus::Value) -> bool {
+                use magnus::TryConvert;
+                <&$enum_type>::try_convert(other)
+                    .map(|other| *self == *other)
+                    .unwrap_or(false)
             }
 
-            #[allow(dead_code)]
-            pub const fn from_ffi(ffi: $ffi_type) -> Self {
-                #[allow(unreachable_patterns)]
-                match ffi {
-                    $(<$ffi_type>::$ffi_variant => <$enum_type>::$rust_variant,)*
-                    _ => unreachable!(),
-                }
+            /// Compare two wrapped enum values for Ruby's `eql?`.
+            pub fn is_eql(&self, other: magnus::Value) -> bool {
+                self.equals(other)
             }
 
-            pub fn define_constants(class: magnus::RClass) -> Result<(), magnus::Error> {
-                $(class.const_set(stringify!($rust_variant), <$enum_type>::$rust_variant)?;)*
-                Ok(())
+            /// Return a hash consistent with Ruby's `eql?` contract.
+            pub fn hash_value(&self) -> u64 {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                self.hash(&mut hasher);
+                hasher.finish()
             }
         }
     };
-}
 
-macro_rules! ruby {
-    () => {
-        magnus::Ruby::get().expect("Failed to get Ruby VM instance")
+    (@to_sym $enum_type:ident, []) => {};
+
+    (@to_sym $enum_type:ident, [$($variant:ident => $symbol:expr),+]) => {
+        /// Return the configured Ruby symbol for this enum value.
+        #[inline]
+        pub fn to_sym(ruby: &magnus::Ruby, rb_self: &Self) -> magnus::Symbol {
+            let name = match *rb_self {
+                $(<$enum_type>::$variant => $symbol,)+
+            };
+            ruby.to_symbol(name)
+        }
     };
 }
 
@@ -127,7 +151,8 @@ macro_rules! extract_request {
     ($args:expr, $required:ty) => {{
         let args = magnus::scan_args::scan_args::<$required, (), (), (), magnus::RHash, ()>($args)?;
         let required = args.required;
-        let request = crate::client::req::Request::new(&ruby!(), args.keywords)?;
+        let ruby = magnus::Ruby::get_with(args.keywords);
+        let request = crate::client::req::Request::new(&ruby, args.keywords)?;
         (required, request)
     }};
 }