wreq 1.0.0

data/src/emulation.rs

@@ -0,0 +1,317 @@
+use magnus::{
+    Error, Module, Object, RHash, RModule, Ruby, TryConvert, Value, function, method,
+    typed_data::{Inspect, Obj},
+};
+
+define_ruby_enum!(
+    /// An emulation.
+    const,
+    EmulationDevice,
+    "Wreq::EmulationDevice",
+    wreq_util::Emulation,
+    Chrome100,
+    Chrome101,
+    Chrome104,
+    Chrome105,
+    Chrome106,
+    Chrome107,
+    Chrome108,
+    Chrome109,
+    Chrome110,
+    Chrome114,
+    Chrome116,
+    Chrome117,
+    Chrome118,
+    Chrome119,
+    Chrome120,
+    Chrome123,
+    Chrome124,
+    Chrome126,
+    Chrome127,
+    Chrome128,
+    Chrome129,
+    Chrome130,
+    Chrome131,
+    Chrome132,
+    Chrome133,
+    Chrome134,
+    Chrome135,
+    Chrome136,
+    Chrome137,
+    Chrome138,
+    Chrome139,
+    Chrome140,
+    Chrome141,
+    Chrome142,
+    Chrome143,
+    Chrome144,
+    Chrome145,
+    Edge101,
+    Edge122,
+    Edge127,
+    Edge131,
+    Edge134,
+    Edge135,
+    Edge136,
+    Edge137,
+    Edge138,
+    Edge139,
+    Edge140,
+    Edge141,
+    Edge142,
+    Edge143,
+    Edge144,
+    Edge145,
+    Firefox109,
+    Firefox117,
+    Firefox128,
+    Firefox133,
+    Firefox135,
+    FirefoxPrivate135,
+    FirefoxAndroid135,
+    Firefox136,
+    FirefoxPrivate136,
+    Firefox139,
+    Firefox142,
+    Firefox143,
+    Firefox144,
+    Firefox145,
+    Firefox146,
+    Firefox147,
+    SafariIos17_2,
+    SafariIos17_4_1,
+    SafariIos16_5,
+    Safari15_3,
+    Safari15_5,
+    Safari15_6_1,
+    Safari16,
+    Safari16_5,
+    Safari17_0,
+    Safari17_2_1,
+    Safari17_4_1,
+    Safari17_5,
+    Safari17_6,
+    Safari18,
+    SafariIPad18,
+    Safari18_2,
+    Safari18_3,
+    Safari18_3_1,
+    SafariIos18_1_1,
+    Safari18_5,
+    Safari26,
+    Safari26_1,
+    Safari26_2,
+    SafariIos26,
+    SafariIos26_2,
+    SafariIPad26,
+    SafariIpad26_2,
+    OkHttp3_9,
+    OkHttp3_11,
+    OkHttp3_13,
+    OkHttp3_14,
+    OkHttp4_9,
+    OkHttp4_10,
+    OkHttp4_12,
+    OkHttp5,
+    Opera116,
+    Opera117,
+    Opera118,
+    Opera119
+);
+
+define_ruby_enum!(
+    /// An emulation operating system.
+    const,
+    EmulationOS,
+    "Wreq::EmulationOS",
+    wreq_util::EmulationOS,
+    Windows,
+    MacOS,
+    Linux,
+    Android,
+    IOS,
+);
+
+/// A struct to represent the `EmulationOption` class.
+#[derive(Clone)]
+#[magnus::wrap(class = "Wreq::Emulation", free_immediately, size)]
+pub struct Emulation(pub wreq_util::EmulationOption);
+
+// ===== impl EmulationDevice =====
+
+impl EmulationDevice {
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+}
+
+// ===== impl EmulationOS =====
+
+impl EmulationOS {
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+}
+
+// ===== impl Emulation =====
+
+impl Emulation {
+    fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        let mut device = None;
+        let mut os = None;
+        let mut skip_http2 = None;
+        let mut skip_headers = None;
+
+        if let Some(hash) = args.first().and_then(|v| RHash::from_value(*v)) {
+            if let Some(v) = hash.get(ruby.to_symbol("device")) {
+                device = Some(Obj::<EmulationDevice>::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol("os")) {
+                os = Some(Obj::<EmulationOS>::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol("skip_http2")) {
+                skip_http2 = Some(bool::try_convert(v)?);
+            }
+            if let Some(v) = hash.get(ruby.to_symbol("skip_headers")) {
+                skip_headers = Some(bool::try_convert(v)?);
+            }
+        }
+
+        let emulation = wreq_util::EmulationOption::builder()
+            .emulation(device.map(|obj| obj.into_ffi()).unwrap_or_default())
+            .emulation_os(os.map(|os| os.into_ffi()).unwrap_or_default())
+            .skip_http2(skip_http2.unwrap_or(false))
+            .skip_headers(skip_headers.unwrap_or(false))
+            .build();
+
+        Ok(Self(emulation))
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    // EmulationDevice enum binding
+    let emulation_class = gem_module.define_class("EmulationDevice", ruby.class_object())?;
+    emulation_class.define_method("to_s", method!(EmulationDevice::to_s, 0))?;
+    emulation_class.const_set("Chrome100", EmulationDevice::Chrome100)?;
+    emulation_class.const_set("Chrome101", EmulationDevice::Chrome101)?;
+    emulation_class.const_set("Chrome104", EmulationDevice::Chrome104)?;
+    emulation_class.const_set("Chrome105", EmulationDevice::Chrome105)?;
+    emulation_class.const_set("Chrome106", EmulationDevice::Chrome106)?;
+    emulation_class.const_set("Chrome107", EmulationDevice::Chrome107)?;
+    emulation_class.const_set("Chrome108", EmulationDevice::Chrome108)?;
+    emulation_class.const_set("Chrome109", EmulationDevice::Chrome109)?;
+    emulation_class.const_set("Chrome110", EmulationDevice::Chrome110)?;
+    emulation_class.const_set("Chrome114", EmulationDevice::Chrome114)?;
+    emulation_class.const_set("Chrome116", EmulationDevice::Chrome116)?;
+    emulation_class.const_set("Chrome117", EmulationDevice::Chrome117)?;
+    emulation_class.const_set("Chrome118", EmulationDevice::Chrome118)?;
+    emulation_class.const_set("Chrome119", EmulationDevice::Chrome119)?;
+    emulation_class.const_set("Chrome120", EmulationDevice::Chrome120)?;
+    emulation_class.const_set("Chrome123", EmulationDevice::Chrome123)?;
+    emulation_class.const_set("Chrome124", EmulationDevice::Chrome124)?;
+    emulation_class.const_set("Chrome126", EmulationDevice::Chrome126)?;
+    emulation_class.const_set("Chrome127", EmulationDevice::Chrome127)?;
+    emulation_class.const_set("Chrome128", EmulationDevice::Chrome128)?;
+    emulation_class.const_set("Chrome129", EmulationDevice::Chrome129)?;
+    emulation_class.const_set("Chrome130", EmulationDevice::Chrome130)?;
+    emulation_class.const_set("Chrome131", EmulationDevice::Chrome131)?;
+    emulation_class.const_set("Chrome132", EmulationDevice::Chrome132)?;
+    emulation_class.const_set("Chrome133", EmulationDevice::Chrome133)?;
+    emulation_class.const_set("Chrome134", EmulationDevice::Chrome134)?;
+    emulation_class.const_set("Chrome135", EmulationDevice::Chrome135)?;
+    emulation_class.const_set("Chrome136", EmulationDevice::Chrome136)?;
+    emulation_class.const_set("Chrome137", EmulationDevice::Chrome137)?;
+    emulation_class.const_set("Chrome138", EmulationDevice::Chrome138)?;
+    emulation_class.const_set("Chrome139", EmulationDevice::Chrome139)?;
+    emulation_class.const_set("Chrome140", EmulationDevice::Chrome140)?;
+    emulation_class.const_set("Chrome141", EmulationDevice::Chrome141)?;
+    emulation_class.const_set("Chrome142", EmulationDevice::Chrome142)?;
+    emulation_class.const_set("Chrome143", EmulationDevice::Chrome143)?;
+    emulation_class.const_set("Chrome144", EmulationDevice::Chrome144)?;
+    emulation_class.const_set("Chrome145", EmulationDevice::Chrome145)?;
+    emulation_class.const_set("Edge101", EmulationDevice::Edge101)?;
+    emulation_class.const_set("Edge122", EmulationDevice::Edge122)?;
+    emulation_class.const_set("Edge127", EmulationDevice::Edge127)?;
+    emulation_class.const_set("Edge131", EmulationDevice::Edge131)?;
+    emulation_class.const_set("Edge134", EmulationDevice::Edge134)?;
+    emulation_class.const_set("Edge135", EmulationDevice::Edge135)?;
+    emulation_class.const_set("Edge136", EmulationDevice::Edge136)?;
+    emulation_class.const_set("Edge137", EmulationDevice::Edge137)?;
+    emulation_class.const_set("Edge138", EmulationDevice::Edge138)?;
+    emulation_class.const_set("Edge139", EmulationDevice::Edge139)?;
+    emulation_class.const_set("Edge140", EmulationDevice::Edge140)?;
+    emulation_class.const_set("Edge141", EmulationDevice::Edge141)?;
+    emulation_class.const_set("Edge142", EmulationDevice::Edge142)?;
+    emulation_class.const_set("Edge143", EmulationDevice::Edge143)?;
+    emulation_class.const_set("Edge144", EmulationDevice::Edge144)?;
+    emulation_class.const_set("Edge145", EmulationDevice::Edge145)?;
+    emulation_class.const_set("Firefox109", EmulationDevice::Firefox109)?;
+    emulation_class.const_set("Firefox117", EmulationDevice::Firefox117)?;
+    emulation_class.const_set("Firefox128", EmulationDevice::Firefox128)?;
+    emulation_class.const_set("Firefox133", EmulationDevice::Firefox133)?;
+    emulation_class.const_set("Firefox135", EmulationDevice::Firefox135)?;
+    emulation_class.const_set("FirefoxPrivate135", EmulationDevice::FirefoxPrivate135)?;
+    emulation_class.const_set("FirefoxAndroid135", EmulationDevice::FirefoxAndroid135)?;
+    emulation_class.const_set("Firefox136", EmulationDevice::Firefox136)?;
+    emulation_class.const_set("FirefoxPrivate136", EmulationDevice::FirefoxPrivate136)?;
+    emulation_class.const_set("Firefox139", EmulationDevice::Firefox139)?;
+    emulation_class.const_set("Firefox142", EmulationDevice::Firefox142)?;
+    emulation_class.const_set("Firefox143", EmulationDevice::Firefox143)?;
+    emulation_class.const_set("Firefox144", EmulationDevice::Firefox144)?;
+    emulation_class.const_set("Firefox145", EmulationDevice::Firefox145)?;
+    emulation_class.const_set("Firefox146", EmulationDevice::Firefox146)?;
+    emulation_class.const_set("Firefox147", EmulationDevice::Firefox147)?;
+    emulation_class.const_set("SafariIos17_2", EmulationDevice::SafariIos17_2)?;
+    emulation_class.const_set("SafariIos17_4_1", EmulationDevice::SafariIos17_4_1)?;
+    emulation_class.const_set("SafariIos16_5", EmulationDevice::SafariIos16_5)?;
+    emulation_class.const_set("Safari15_3", EmulationDevice::Safari15_3)?;
+    emulation_class.const_set("Safari15_5", EmulationDevice::Safari15_5)?;
+    emulation_class.const_set("Safari15_6_1", EmulationDevice::Safari15_6_1)?;
+    emulation_class.const_set("Safari16", EmulationDevice::Safari16)?;
+    emulation_class.const_set("Safari16_5", EmulationDevice::Safari16_5)?;
+    emulation_class.const_set("Safari17_0", EmulationDevice::Safari17_0)?;
+    emulation_class.const_set("Safari17_2_1", EmulationDevice::Safari17_2_1)?;
+    emulation_class.const_set("Safari17_4_1", EmulationDevice::Safari17_4_1)?;
+    emulation_class.const_set("Safari17_5", EmulationDevice::Safari17_5)?;
+    emulation_class.const_set("Safari17_6", EmulationDevice::Safari17_6)?;
+    emulation_class.const_set("Safari18", EmulationDevice::Safari18)?;
+    emulation_class.const_set("SafariIPad18", EmulationDevice::SafariIPad18)?;
+    emulation_class.const_set("Safari18_2", EmulationDevice::Safari18_2)?;
+    emulation_class.const_set("Safari18_3", EmulationDevice::Safari18_3)?;
+    emulation_class.const_set("Safari18_3_1", EmulationDevice::Safari18_3_1)?;
+    emulation_class.const_set("SafariIos18_1_1", EmulationDevice::SafariIos18_1_1)?;
+    emulation_class.const_set("Safari18_5", EmulationDevice::Safari18_5)?;
+    emulation_class.const_set("Safari26", EmulationDevice::Safari26)?;
+    emulation_class.const_set("Safari26_1", EmulationDevice::Safari26_1)?;
+    emulation_class.const_set("Safari26_2", EmulationDevice::Safari26_2)?;
+    emulation_class.const_set("SafariIos26", EmulationDevice::SafariIos26)?;
+    emulation_class.const_set("SafariIos26_2", EmulationDevice::SafariIos26_2)?;
+    emulation_class.const_set("SafariIPad26", EmulationDevice::SafariIPad26)?;
+    emulation_class.const_set("SafariIpad26_2", EmulationDevice::SafariIpad26_2)?;
+    emulation_class.const_set("OkHttp3_9", EmulationDevice::OkHttp3_9)?;
+    emulation_class.const_set("OkHttp3_11", EmulationDevice::OkHttp3_11)?;
+    emulation_class.const_set("OkHttp3_13", EmulationDevice::OkHttp3_13)?;
+    emulation_class.const_set("OkHttp3_14", EmulationDevice::OkHttp3_14)?;
+    emulation_class.const_set("OkHttp4_9", EmulationDevice::OkHttp4_9)?;
+    emulation_class.const_set("OkHttp4_10", EmulationDevice::OkHttp4_10)?;
+    emulation_class.const_set("OkHttp4_12", EmulationDevice::OkHttp4_12)?;
+    emulation_class.const_set("OkHttp5", EmulationDevice::OkHttp5)?;
+    emulation_class.const_set("Opera116", EmulationDevice::Opera116)?;
+    emulation_class.const_set("Opera117", EmulationDevice::Opera117)?;
+    emulation_class.const_set("Opera118", EmulationDevice::Opera118)?;
+    emulation_class.const_set("Opera119", EmulationDevice::Opera119)?;
+
+    // EmulationOS enum binding
+    let emulation_os_class = gem_module.define_class("EmulationOS", ruby.class_object())?;
+    emulation_os_class.define_method("to_s", method!(EmulationOS::to_s, 0))?;
+    emulation_os_class.const_set("Windows", EmulationOS::Windows)?;
+    emulation_os_class.const_set("MacOS", EmulationOS::MacOS)?;
+    emulation_os_class.const_set("Linux", EmulationOS::Linux)?;
+    emulation_os_class.const_set("Android", EmulationOS::Android)?;
+    emulation_os_class.const_set("IOS", EmulationOS::IOS)?;
+
+    // Emulation class binding
+    let emulation_option_class = gem_module.define_class("Emulation", ruby.class_object())?;
+    emulation_option_class.define_singleton_method("new", function!(Emulation::new, -1))?;
+    Ok(())
+}

data/src/error.rs

@@ -0,0 +1,147 @@
+use magnus::{
+    Error as MagnusError, RModule, Ruby, exception::ExceptionClass, prelude::*, value::Lazy,
+};
+use tokio::sync::mpsc::error::SendError;
+
+const RACE_CONDITION_ERROR_MSG: &str = r#"Due to Rust's memory management with borrowing,
+you cannot use certain instances multiple times as they may be consumed.
+
+This error can occur in the following cases:
+1) You passed a non-clonable instance to a function that requires ownership.
+2) You attempted to use a method that consumes ownership more than once (e.g., reading a response body twice).
+3) You tried to reference an instance after it was borrowed.
+
+Potential solutions:
+1) Avoid sharing instances; create a new instance each time you use it.
+2) Refrain from performing actions that consume ownership multiple times.
+3) Change the order of operations to reference the instance before borrowing it.
+"#;
+
+static WREQ: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module(crate::RUBY_MODULE_NAME).unwrap());
+
+macro_rules! define_exception {
+    ($name:ident, $ruby_name:literal, $parent_method:ident) => {
+        static $name: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+            ruby.get_inner(&WREQ)
+                .define_error($ruby_name, ruby.$parent_method())
+                .unwrap()
+        });
+    };
+}
+
+macro_rules! map_wreq_error {
+    ($ruby:expr, $err:expr, $msg:expr, $($check_method:ident => $exception:ident),* $(,)?) => {
+        {
+            $(
+                if $err.$check_method() {
+                    return MagnusError::new($ruby.get_inner(&$exception), $msg);
+                }
+            )*
+            MagnusError::new($ruby.exception_runtime_error(), $msg)
+        }
+    };
+}
+
+// System-level and runtime errors
+define_exception!(MEMORY, "MemoryError", exception_runtime_error);
+
+// Network connection errors
+define_exception!(CONNECTION_ERROR, "ConnectionError", exception_runtime_error);
+define_exception!(
+    PROXY_CONNECTION_ERROR,
+    "ProxyConnectionError",
+    exception_runtime_error
+);
+define_exception!(
+    CONNECTION_RESET_ERROR,
+    "ConnectionResetError",
+    exception_runtime_error
+);
+define_exception!(TLS_ERROR, "TlsError", exception_runtime_error);
+
+// HTTP protocol and request/response errors
+define_exception!(REQUEST_ERROR, "RequestError", exception_runtime_error);
+define_exception!(STATUS_ERROR, "StatusError", exception_runtime_error);
+define_exception!(REDIRECT_ERROR, "RedirectError", exception_runtime_error);
+define_exception!(TIMEOUT_ERROR, "TimeoutError", exception_runtime_error);
+
+// Data processing and encoding errors
+define_exception!(BODY_ERROR, "BodyError", exception_runtime_error);
+define_exception!(DECODING_ERROR, "DecodingError", exception_runtime_error);
+
+// Configuration and builder errors
+define_exception!(BUILDER_ERROR, "BuilderError", exception_runtime_error);
+
+// Thread interruption error
+define_exception!(INTERRUPT_ERROR, "InterruptError", exception_interrupt);
+
+/// Memory error constant
+pub fn memory_error() -> MagnusError {
+    MagnusError::new(ruby!().get_inner(&MEMORY), RACE_CONDITION_ERROR_MSG)
+}
+
+/// Thread interruption error (raised when Thread.kill cancels a request)
+pub fn interrupt_error() -> MagnusError {
+    MagnusError::new(ruby!().get_inner(&INTERRUPT_ERROR), "request interrupted")
+}
+
+/// Map [`tokio::sync::mpsc::error::SendError`] to corresponding [`magnus::Error`]
+pub fn mpsc_send_error_to_magnus<T>(err: SendError<T>) -> MagnusError {
+    MagnusError::new(
+        ruby!().get_inner(&BODY_ERROR),
+        format!("failed to send body chunk: {}", err),
+    )
+}
+
+/// Map [`wreq::header::InvalidHeaderName`] to corresponding [`magnus::Error`]
+pub fn header_name_error_to_magnus(err: wreq::header::InvalidHeaderName) -> MagnusError {
+    MagnusError::new(
+        ruby!().get_inner(&BUILDER_ERROR),
+        format!("invalid header name: {err}"),
+    )
+}
+
+/// Map [`wreq::header::InvalidHeaderValue`] to corresponding [`magnus::Error`]
+pub fn header_value_error_to_magnus(err: wreq::header::InvalidHeaderValue) -> MagnusError {
+    MagnusError::new(
+        ruby!().get_inner(&BUILDER_ERROR),
+        format!("invalid header value: {err}"),
+    )
+}
+
+/// Map [`wreq::Error`] to corresponding [`magnus::Error`]
+pub fn wreq_error_to_magnus(err: wreq::Error) -> MagnusError {
+    let error_msg = err.to_string();
+    map_wreq_error!(
+        ruby!(),
+        err,
+        error_msg,
+        is_builder => BUILDER_ERROR,
+        is_body => BODY_ERROR,
+        is_tls => TLS_ERROR,
+        is_connection_reset => CONNECTION_RESET_ERROR,
+        is_connect => CONNECTION_ERROR,
+        is_proxy_connect => PROXY_CONNECTION_ERROR,
+        is_decode => DECODING_ERROR,
+        is_redirect => REDIRECT_ERROR,
+        is_timeout => TIMEOUT_ERROR,
+        is_status => STATUS_ERROR,
+        is_request => REQUEST_ERROR,
+    )
+}
+
+pub fn include(ruby: &Ruby) {
+    Lazy::force(&MEMORY, ruby);
+    Lazy::force(&CONNECTION_ERROR, ruby);
+    Lazy::force(&PROXY_CONNECTION_ERROR, ruby);
+    Lazy::force(&CONNECTION_RESET_ERROR, ruby);
+    Lazy::force(&TLS_ERROR, ruby);
+    Lazy::force(&REQUEST_ERROR, ruby);
+    Lazy::force(&STATUS_ERROR, ruby);
+    Lazy::force(&REDIRECT_ERROR, ruby);
+    Lazy::force(&TIMEOUT_ERROR, ruby);
+    Lazy::force(&BODY_ERROR, ruby);
+    Lazy::force(&DECODING_ERROR, ruby);
+    Lazy::force(&BUILDER_ERROR, ruby);
+    Lazy::force(&INTERRUPT_ERROR, ruby);
+}

data/src/extractor.rs

@@ -0,0 +1,199 @@
+use bytes::Bytes;
+use magnus::{RArray, RHash, RString, Ruby, TryConvert, r_hash::ForEach};
+use wreq::{
+    Proxy, Version,
+    header::{HeaderMap, HeaderName, HeaderValue, OrigHeaderMap},
+};
+
+use crate::error::{
+    header_name_error_to_magnus, header_value_error_to_magnus, wreq_error_to_magnus,
+};
+
+/// A trait that defines the parameter name for extraction.
+pub trait ExtractorName {
+    /// The name of the parameter in the Ruby hash.
+    const NAME: &str;
+}
+
+/// A generic extractor for various types.
+pub struct Extractor<T>(Option<T>)
+where
+    T: ExtractorName;
+
+impl<T> Extractor<T>
+where
+    T: ExtractorName,
+{
+    /// Consumes the extractor and returns the wrapped value.
+    ///
+    /// Returns `Some(T)` if a value was extracted, `None` otherwise.
+    #[inline]
+    pub fn into_inner(self) -> Option<T> {
+        self.0
+    }
+}
+
+// ===== impl Extractor<Version> =====
+
+impl ExtractorName for Version {
+    const NAME: &str = "version";
+}
+
+impl TryConvert for Extractor<Version> {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let keyword = RHash::try_convert(value)?;
+        if let Some(version_val) = keyword.get(Version::NAME) {
+            return <&crate::http::Version>::try_convert(version_val)
+                .cloned()
+                .map(crate::http::Version::into_ffi)
+                .map(Some)
+                .map(Extractor);
+        }
+
+        Ok(Extractor(None))
+    }
+}
+
+// ===== impl Extractor<HeaderValue> =====
+
+impl ExtractorName for HeaderValue {
+    const NAME: &str = "user_agent";
+}
+
+impl TryConvert for Extractor<HeaderValue> {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let ruby = Ruby::get_with(value);
+        let keyword = RHash::try_convert(value)?;
+
+        if let Some(ruby_value) = keyword
+            .get(ruby.to_symbol(HeaderValue::NAME))
+            .and_then(RString::from_value)
+        {
+            return HeaderValue::from_maybe_shared(ruby_value.to_bytes())
+                .map(Some)
+                .map(Extractor)
+                .map_err(header_value_error_to_magnus);
+        }
+
+        Ok(Extractor(None))
+    }
+}
+
+// ===== impl Extractor<HeaderMap> =====
+
+impl ExtractorName for HeaderMap {
+    const NAME: &str = "headers";
+}
+
+impl TryConvert for Extractor<HeaderMap> {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let ruby = Ruby::get_with(value);
+        let keyword = RHash::try_convert(value)?;
+        let mut headers = HeaderMap::new();
+
+        if let Some(hash) = keyword
+            .get(ruby.to_symbol(HeaderMap::NAME))
+            .and_then(RHash::from_value)
+        {
+            hash.foreach(|name: RString, value: RString| {
+                let name = HeaderName::from_bytes(&name.to_bytes())
+                    .map_err(header_name_error_to_magnus)?;
+                let value = HeaderValue::from_maybe_shared(value.to_bytes())
+                    .map_err(header_value_error_to_magnus)?;
+                headers.insert(name, value);
+
+                Ok(ForEach::Continue)
+            })?;
+
+            return Ok(Extractor(Some(headers)));
+        }
+
+        Ok(Extractor(None))
+    }
+}
+
+// ===== impl Extractor<OrigHeaderMap> =====
+
+impl ExtractorName for OrigHeaderMap {
+    const NAME: &str = "orig_headers";
+}
+
+impl TryConvert for Extractor<OrigHeaderMap> {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let ruby = Ruby::get_with(value);
+        let keyword = RHash::try_convert(value)?;
+
+        if let Some(orig_headers) = keyword
+            .get(ruby.to_symbol(OrigHeaderMap::NAME))
+            .and_then(RArray::from_value)
+        {
+            let mut map = OrigHeaderMap::new();
+            for value in orig_headers.into_iter().flat_map(RString::from_value) {
+                map.insert(value.to_bytes());
+            }
+            return Ok(Extractor(Some(map)));
+        }
+
+        Ok(Extractor(None))
+    }
+}
+
+// ===== impl Extractor<Vec<HeaderValue>> =====
+
+impl ExtractorName for Vec<HeaderValue> {
+    const NAME: &str = "cookies";
+}
+
+impl TryConvert for Extractor<Vec<HeaderValue>> {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        use percent_encoding::{NON_ALPHANUMERIC, percent_encode};
+
+        let ruby = Ruby::get_with(value);
+        let keyword = RHash::try_convert(value)?;
+
+        if let Some(hash) = keyword
+            .get(ruby.to_symbol(Vec::<HeaderValue>::NAME))
+            .and_then(RHash::from_value)
+        {
+            let mut cookies = Vec::new();
+            hash.foreach(|name: RString, value: RString| {
+                let value = value.to_bytes();
+                let encoded_value = percent_encode(&value, NON_ALPHANUMERIC);
+                let cookie = format!("{name}={encoded_value}");
+                let header_value = HeaderValue::from_maybe_shared(Bytes::from(cookie))
+                    .map_err(header_value_error_to_magnus)?;
+                cookies.push(header_value);
+                Ok(ForEach::Continue)
+            })?;
+
+            return Ok(Extractor(Some(cookies)));
+        }
+
+        Ok(Extractor(None))
+    }
+}
+
+// ===== impl Extractor<Proxy> =====
+
+impl ExtractorName for Proxy {
+    const NAME: &str = "proxy";
+}
+
+impl TryConvert for Extractor<Proxy> {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let ruby = Ruby::get_with(value);
+        let keyword = RHash::try_convert(value)?;
+
+        if let Some(proxy) = keyword
+            .get(ruby.to_symbol(Proxy::NAME))
+            .and_then(RString::from_value)
+        {
+            return Proxy::all(proxy.to_bytes().as_ref())
+                .map(Some)
+                .map(Extractor)
+                .map_err(wreq_error_to_magnus);
+        }
+
+        Ok(Extractor(None))
+    }
+}