wreq 1.2.5 → 1.2.7

data/src/header.rs

@@ -8,8 +8,6 @@
 //!
 //! [RFC 9110 section 5.1]: https://www.rfc-editor.org/rfc/rfc9110.html#section-5.1
 
-mod helper;
-
 use std::cell::RefCell;
 
 use bytes::Bytes;
@@ -17,11 +15,12 @@ use http::{HeaderMap, HeaderValue};
 use magnus::{
     Error, RArray, RModule, RString, Ruby, TryConvert, Value, function, method,
     prelude::*,
+    scan_args::scan_args,
     typed_data::{Inspect, Obj},
 };
 use wreq::header::OrigHeaderMap;
 
-use crate::error::{header_value_error_to_magnus, type_value_error_to_magnus};
+use crate::error::{header_type_error, header_value_error};
 
 use self::helper::{
     ensure_header_count, from_source, header_count_error, parse_header_name, parse_header_values,
@@ -45,10 +44,11 @@ pub struct OrigHeaders(pub OrigHeaderMap);
 
 impl TryConvert for UserAgent {
     fn try_convert(value: Value) -> Result<Self, Error> {
+        let ruby = Ruby::get_with(value);
         let s = RString::try_convert(value)?;
         HeaderValue::from_maybe_shared(s.to_bytes())
             .map(Self)
-            .map_err(header_value_error_to_magnus)
+            .map_err(|err| header_value_error(&ruby, err))
     }
 }
 
@@ -78,11 +78,12 @@ impl Headers {
     /// A String stores one occurrence, while an Array stores each String as a
     /// separate occurrence. An empty Array removes the header.
     pub fn set(&self, name: Value, value: Value) -> Result<(), Error> {
+        let ruby = Ruby::get_with(name);
         let name = parse_header_name(name)?;
         let values = parse_header_values(value)?;
         let mut headers = self.0.borrow_mut();
         let replaced = headers.get_all(&name).iter().count();
-        ensure_header_count(headers.len(), replaced, values.len())?;
+        ensure_header_count(&ruby, headers.len(), replaced, values.len())?;
 
         let mut values = values.into_iter();
         let Some(first) = values.next() else {
@@ -92,11 +93,11 @@ impl Headers {
 
         headers
             .try_insert(name.clone(), first)
-            .map_err(|_| header_count_error())?;
+            .map_err(|_| header_count_error(&ruby))?;
         for value in values {
             headers
                 .try_append(name.clone(), value)
-                .map_err(|_| header_count_error())?;
+                .map_err(|_| header_count_error(&ruby))?;
         }
         Ok(())
     }
@@ -105,15 +106,16 @@ impl Headers {
     ///
     /// Array elements are appended separately and are never comma-folded.
     pub fn append(&self, name: Value, value: Value) -> Result<(), Error> {
+        let ruby = Ruby::get_with(name);
         let name = parse_header_name(name)?;
         let values = parse_header_values(value)?;
         let mut headers = self.0.borrow_mut();
-        ensure_header_count(headers.len(), 0, values.len())?;
+        ensure_header_count(&ruby, headers.len(), 0, values.len())?;
 
         for value in values {
             headers
                 .try_append(name.clone(), value)
-                .map_err(|_| header_count_error())?;
+                .map_err(|_| header_count_error(&ruby))?;
         }
         Ok(())
     }
@@ -170,18 +172,13 @@ impl Headers {
     ///
     /// The optional source may be a Hash, another `Wreq::Headers`, or an
     /// Enumerable whose elements are name-value pairs.
-    pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
-        match args {
-            [] => Ok(Self::default()),
-            [source] => from_source(*source),
-            _ => Err(Error::new(
-                ruby.exception_arg_error(),
-                format!(
-                    "wrong number of arguments (given {}, expected 0..1)",
-                    args.len()
-                ),
-            )),
-        }
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        scan_args::<(), (Option<Value>,), (), (), (), ()>(args)?
+            .optional
+            .0
+            .map(from_source)
+            .transpose()
+            .map(Option::unwrap_or_default)
     }
 
     /// Return a value using Ruby collection semantics.
@@ -268,12 +265,15 @@ impl TryConvert for Headers {
 
 impl TryConvert for OrigHeaders {
     fn try_convert(value: Value) -> Result<Self, Error> {
+        let ruby = Ruby::get_with(value);
         let mut map = OrigHeaderMap::new();
 
         let rarray = RArray::from_value(value)
-            .ok_or_else(|| type_value_error_to_magnus("Expected an array of strings"))?;
+            .ok_or_else(|| header_type_error(&ruby, "Expected an array of strings"))?;
 
-        for value in rarray.into_iter().flat_map(RString::from_value) {
+        for value in rarray {
+            let value = RString::try_convert(value)
+                .map_err(|_| header_type_error(&ruby, "Expected an array of strings"))?;
             map.insert(value.to_bytes());
         }
 
@@ -281,6 +281,129 @@ impl TryConvert for OrigHeaders {
     }
 }
 
+mod helper {
+    //! Ruby value conversion helpers for `Wreq::Headers`.
+
+    use bytes::Bytes;
+    use http::{HeaderName, HeaderValue};
+    use magnus::{
+        Error, RArray, RString, Ruby, Symbol, TryConvert, Value, prelude::*, typed_data::Obj,
+    };
+
+    use crate::error::{header_name_error, header_type_error, header_value_error};
+
+    use super::Headers;
+
+    /// Maximum number of field-value occurrences supported by `HeaderMap`.
+    const MAX_HEADER_ENTRIES: usize = 1 << 15;
+
+    /// Build a header collection from a Ruby source object.
+    ///
+    /// Accepts another `Wreq::Headers`, a Hash, or any object whose `to_a` result
+    /// contains two-element name-value pairs. Array values are delegated to
+    /// [`Headers::append`] so each value remains a separate occurrence.
+    pub(super) fn from_source(source: Value) -> Result<Headers, Error> {
+        let ruby = Ruby::get_with(source);
+        if let Ok(headers) = Obj::<Headers>::try_convert(source) {
+            return Ok((*headers).clone());
+        }
+        if !source.respond_to("to_a", false)? {
+            return Err(header_type_error(
+                &ruby,
+                "Expected Headers, a Hash, or an enumerable of pairs",
+            ));
+        }
+
+        let pairs: RArray = source.funcall_public("to_a", ())?;
+        let headers = Headers::default();
+        for pair in pairs {
+            let pair = RArray::try_convert(pair)
+                .map_err(|_| header_type_error(&ruby, "Expected each header entry to be a pair"))?;
+            if pair.len() != 2 {
+                return Err(header_type_error(
+                    &ruby,
+                    "Expected each header entry to contain a name and value",
+                ));
+            }
+
+            headers.append(pair.entry(0)?, pair.entry(1)?)?;
+        }
+        Ok(headers)
+    }
+
+    /// Convert a Ruby String or Symbol into a normalized HTTP header name.
+    ///
+    /// Symbol underscores are changed to hyphens before [`HeaderName`] validates
+    /// and normalizes the name. Other Ruby types produce `Wreq::BuilderError`.
+    pub(super) fn parse_header_name(value: Value) -> Result<HeaderName, Error> {
+        let ruby = Ruby::get_with(value);
+        let name = match (RString::from_value(value), Symbol::from_value(value)) {
+            (Some(name), _) => name.to_bytes(),
+            (None, Some(name)) => Bytes::from(name.name()?.replace('_', "-")),
+            (None, None) => {
+                return Err(header_type_error(
+                    &ruby,
+                    "Expected a String or Symbol header name",
+                ));
+            }
+        };
+        HeaderName::from_bytes(name.as_ref()).map_err(|err| header_name_error(&ruby, err))
+    }
+
+    /// Convert a Ruby String or Array of Strings into validated header values.
+    ///
+    /// Each Array element becomes one [`HeaderValue`]. An empty Array therefore
+    /// produces no values, allowing `set` to remove a header and `append` to do
+    /// nothing.
+    pub(super) fn parse_header_values(value: Value) -> Result<Vec<HeaderValue>, Error> {
+        if let Some(values) = RArray::from_value(value) {
+            values.into_iter().map(parse_header_value).collect()
+        } else {
+            Ok(vec![parse_header_value(value)?])
+        }
+    }
+
+    /// Convert one Ruby String into a validated HTTP header value.
+    ///
+    /// Invalid Ruby types and bytes rejected by [`HeaderValue`] are mapped to
+    /// `Wreq::BuilderError`.
+    fn parse_header_value(value: Value) -> Result<HeaderValue, Error> {
+        let ruby = Ruby::get_with(value);
+        let value = RString::try_convert(value)
+            .map_err(|_| header_type_error(&ruby, "Expected a String header value"))?;
+        HeaderValue::from_maybe_shared(value.to_bytes())
+            .map_err(|err| header_value_error(&ruby, err))
+    }
+
+    /// Validate the resulting number of header occurrences before a mutation.
+    ///
+    /// `current` is the collection length, `replaced` is the number of existing
+    /// occurrences removed by `set`, and `added` is the incoming value count.
+    /// Checked arithmetic prevents overflow; an invalid calculation or a result
+    /// above the native [`HeaderMap`](http::HeaderMap) limit returns
+    /// `Wreq::BuilderError` without mutating the collection.
+    pub(super) fn ensure_header_count(
+        ruby: &Ruby,
+        current: usize,
+        replaced: usize,
+        added: usize,
+    ) -> Result<(), Error> {
+        let count = current
+            .checked_sub(replaced)
+            .and_then(|count| count.checked_add(added));
+        if count.is_some_and(|count| count <= MAX_HEADER_ENTRIES) {
+            Ok(())
+        } else {
+            Err(header_count_error(ruby))
+        }
+    }
+
+    /// Build the error returned when the native header map reaches its entry limit.
+    pub(super) fn header_count_error(ruby: &Ruby) -> Error {
+        header_type_error(ruby, "Header collection exceeds 32,768 entries")
+    }
+}
+
 /// Register `Wreq::Headers` and its native methods with Ruby.
 pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     let headers_class = gem_module.define_class("Headers", ruby.class_object())?;

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)
     }};
 }