wreq 1.2.4 → 1.2.6

data/src/emulate.rs

@@ -1,11 +1,47 @@
-use magnus::{
-    Error, Module, Object, RHash, RModule, Ruby, TryConvert, Value, function, method,
-    typed_data::{Inspect, Obj},
-};
+use ::serde::Deserialize;
+use magnus::{Error, Module, Object, RModule, Ruby, Value, function, method, typed_data::Obj};
 
+use crate::options::{NativeOption, Options};
+
+/// Keyword arguments accepted by `Wreq::Emulation.new`.
+#[derive(Default, Deserialize)]
+struct Builder {
+    /// The browser profile to emulate.
+    #[serde(default)]
+    profile: NativeOption<Obj<Profile>>,
+
+    /// The operating-system profile to emulate.
+    #[serde(default)]
+    platform: NativeOption<Obj<Platform>>,
+
+    /// Whether HTTP/2 settings are emulated.
+    http2: Option<bool>,
+
+    /// Whether browser headers are emulated.
+    headers: Option<bool>,
+}
+
+// ===== impl Builder =====
+
+impl Builder {
+    /// Deserialize and convert one validated emulation options Hash.
+    ///
+    /// # Errors
+    ///
+    /// Returns `ArgumentError` for unknown or duplicate options and `TypeError`
+    /// for invalid option values.
+    fn from_options(options: Options<'_>) -> Result<Self, Error> {
+        let mut builder = options.validate_keys::<Self>()?.deserialize::<Self>()?;
+        extract_native_option!(options, builder, profile);
+        extract_native_option!(options, builder, platform);
+        Ok(builder)
+    }
+}
+
+// Defines constant registration, `into_ffi`/`from_ffi`, and handlers for
+// Ruby's `to_s`, `==`, `eql?`, and `hash` methods.
 define_ruby_enum!(
     /// An emulation profile.
-    const,
     Profile,
     "Wreq::Profile",
     wreq_util::Profile,
@@ -50,6 +86,7 @@ define_ruby_enum!(
     Chrome147,
     Chrome148,
     Chrome149,
+    Chrome150,
 
     Edge101,
     Edge122,
@@ -149,17 +186,19 @@ define_ruby_enum!(
     Opera131,
 );
 
+// Defines constant registration, `into_ffi`/`from_ffi`, and handlers for
+// Ruby's `to_s`, `to_sym`, `==`, `eql?`, and `hash` methods.
 define_ruby_enum!(
     /// An emulation profile for OS.
-    const,
     Platform,
     "Wreq::Platform",
     wreq_util::Platform,
-    Windows,
-    MacOS,
-    Linux,
-    Android,
-    IOS,
+    symbols:
+    Windows => "windows",
+    MacOS => "macos",
+    Linux => "linux",
+    Android => "android",
+    IOS => "ios",
 );
 
 /// A struct to represent the `EmulationOption` class.
@@ -167,51 +206,41 @@ define_ruby_enum!(
 #[magnus::wrap(class = "Wreq::Emulation", free_immediately, size)]
 pub struct Emulation(pub wreq_util::Emulation);
 
-// ===== impl Profile =====
-
-impl Profile {
-    pub fn to_s(&self) -> String {
-        self.into_ffi().inspect()
-    }
-}
-
-// ===== impl Platform =====
-
-impl Platform {
-    pub fn to_s(&self) -> String {
-        self.into_ffi().inspect()
-    }
-}
-
 // ===== impl Emulation =====
 
 impl Emulation {
+    /// Create emulation settings from one optional Hash.
+    ///
+    /// Unknown keys, non-Hash arguments, and extra positional arguments are
+    /// rejected before the native emulation value is built.
+    ///
+    /// # Errors
+    ///
+    /// Returns `ArgumentError` for unknown keys or argument count and
+    /// `TypeError` for invalid option values.
     fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
-        let mut profile = None;
-        let mut platform = None;
-        let mut http2 = None;
-        let mut headers = None;
-
-        if let Some(hash) = args.first().and_then(|v| RHash::from_value(*v)) {
-            if let Some(v) = hash.get(ruby.to_symbol(stringify!(profile))) {
-                profile = Some(Obj::<Profile>::try_convert(v)?);
-            }
-            if let Some(v) = hash.get(ruby.to_symbol(stringify!(platform))) {
-                platform = Some(Obj::<Platform>::try_convert(v)?);
-            }
-            if let Some(v) = hash.get(ruby.to_symbol(stringify!(http2))) {
-                http2 = Some(bool::try_convert(v)?);
-            }
-            if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
-                headers = Some(bool::try_convert(v)?);
-            }
-        }
+        let mut params = Options::from_args(ruby, args, "emulation")?
+            .map(Builder::from_options)
+            .transpose()?
+            .unwrap_or_default();
 
         let emulation = wreq_util::Emulation::builder()
-            .profile(profile.map(|obj| obj.into_ffi()).unwrap_or_default())
-            .platform(platform.map(|os| os.into_ffi()).unwrap_or_default())
-            .http2(http2.unwrap_or(true))
-            .headers(headers.unwrap_or(true))
+            .profile(
+                params
+                    .profile
+                    .take()
+                    .map(|obj| obj.into_ffi())
+                    .unwrap_or_default(),
+            )
+            .platform(
+                params
+                    .platform
+                    .take()
+                    .map(|os| os.into_ffi())
+                    .unwrap_or_default(),
+            )
+            .http2(params.http2.unwrap_or(true))
+            .headers(params.headers.unwrap_or(true))
             .build();
 
         Ok(Self(emulation))
@@ -222,11 +251,18 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     // Profile enum binding
     let profile = gem_module.define_class("Profile", ruby.class_object())?;
     profile.define_method("to_s", method!(Profile::to_s, 0))?;
+    profile.define_method("==", method!(Profile::equals, 1))?;
+    profile.define_method("eql?", method!(Profile::is_eql, 1))?;
+    profile.define_method("hash", method!(Profile::hash_value, 0))?;
     Profile::define_constants(profile)?;
 
     // Platform enum binding
     let platform = gem_module.define_class("Platform", ruby.class_object())?;
     platform.define_method("to_s", method!(Platform::to_s, 0))?;
+    platform.define_method("to_sym", method!(Platform::to_sym, 0))?;
+    platform.define_method("==", method!(Platform::equals, 1))?;
+    platform.define_method("eql?", method!(Platform::is_eql, 1))?;
+    platform.define_method("hash", method!(Platform::hash_value, 0))?;
     Platform::define_constants(platform)?;
 
     // Emulation class binding

data/src/error.rs

@@ -1,5 +1,11 @@
+use std::{
+    cell::{BorrowError, BorrowMutError},
+    fmt,
+};
+
 use magnus::{
-    Error as MagnusError, RModule, Ruby, exception::ExceptionClass, prelude::*, value::Lazy,
+    Error as MagnusError, RModule, Ruby, error::ErrorType, exception::ExceptionClass, prelude::*,
+    value::Lazy,
 };
 use tokio::sync::mpsc::error::SendError;
 
@@ -17,18 +23,24 @@ Potential solutions:
 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()
+            ruby.class_object()
+                .const_get::<_, RModule>(crate::RUBY_MODULE_NAME)
+                .and_then(|module| module.const_get::<_, ExceptionClass>($ruby_name))
+                .unwrap_or_else(|_| ruby.$parent_method())
         });
     };
 }
 
+macro_rules! initialize_exception {
+    ($ruby:expr, $module:expr, $name:ident, $ruby_name:literal, $parent_method:ident) => {{
+        $module.define_error($ruby_name, $ruby.$parent_method())?;
+        Lazy::force(&$name, $ruby);
+    }};
+}
+
 macro_rules! map_wreq_error {
     ($ruby:expr, $err:expr, $msg:expr, $($check_method:ident => $exception:ident),* $(,)?) => {
         {
@@ -72,64 +84,128 @@ 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)
+pub fn memory_error(ruby: &Ruby) -> 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")
+/// Create Ruby's standard thread interruption error.
+pub fn interrupt_error(ruby: &Ruby) -> MagnusError {
+    MagnusError::new(ruby.exception_interrupt(), "request interrupted")
+}
+
+/// Map a Tokio runtime initialization failure to `Wreq::BuilderError`.
+pub fn runtime_initialization_error(ruby: &Ruby, err: &std::io::Error) -> MagnusError {
+    MagnusError::new(
+        ruby.get_inner(&BUILDER_ERROR),
+        format!("failed to initialize Tokio runtime: {err}"),
+    )
 }
 
 /// LocalJumpError for methods that require a Ruby block.
-pub fn no_block_given_error() -> MagnusError {
+pub fn no_block_given_error(ruby: &Ruby) -> MagnusError {
+    MagnusError::new(ruby.exception_local_jump_error(), "no block given (yield)")
+}
+
+/// Build an `IOError` for writes to a closed request-body sender.
+pub fn closed_body_sender_error(ruby: &Ruby) -> MagnusError {
+    MagnusError::new(ruby.exception_io_error(), "closed body sender")
+}
+
+/// Map a failed body-channel send to `IOError`.
+pub fn body_sender_send_error<T>(ruby: &Ruby, err: SendError<T>) -> MagnusError {
+    MagnusError::new(
+        ruby.exception_io_error(),
+        format!("closed body sender: {err}"),
+    )
+}
+
+/// Map an immutable sender-state borrow failure to `Wreq::BodyError`.
+pub fn body_sender_borrow_error(ruby: &Ruby, err: BorrowError) -> MagnusError {
     MagnusError::new(
-        ruby!().exception_local_jump_error(),
-        "no block given (yield)",
+        ruby.get_inner(&BODY_ERROR),
+        format!("body sender state is unavailable: {err}"),
     )
 }
 
-/// Map [`tokio::sync::mpsc::error::SendError`] to corresponding [`magnus::Error`]
-pub fn mpsc_send_error_to_magnus<T>(err: SendError<T>) -> MagnusError {
+/// Map a mutable sender-state borrow failure to `Wreq::BodyError`.
+pub fn body_sender_borrow_mut_error(ruby: &Ruby, err: BorrowMutError) -> MagnusError {
     MagnusError::new(
-        ruby!().get_inner(&BODY_ERROR),
-        format!("failed to send body chunk: {}", err),
+        ruby.get_inner(&BODY_ERROR),
+        format!("body sender state is unavailable: {err}"),
     )
 }
 
 /// Map [`wreq::header::InvalidHeaderName`] to corresponding [`magnus::Error`]
-pub fn header_name_error_to_magnus(err: wreq::header::InvalidHeaderName) -> MagnusError {
+pub fn header_name_error(ruby: &Ruby, err: wreq::header::InvalidHeaderName) -> MagnusError {
     MagnusError::new(
-        ruby!().get_inner(&BUILDER_ERROR),
+        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 {
+pub fn header_value_error(ruby: &Ruby, err: wreq::header::InvalidHeaderValue) -> MagnusError {
     MagnusError::new(
-        ruby!().get_inner(&BUILDER_ERROR),
+        ruby.get_inner(&BUILDER_ERROR),
         format!("invalid header value: {err}"),
     )
 }
 
-/// Map type/value errors to corresponding [`magnus::Error`]
-pub fn type_value_error_to_magnus(err: &str) -> MagnusError {
+/// Build a `Wreq::BuilderError` for an invalid Ruby header structure.
+pub fn header_type_error(ruby: &Ruby, err: &str) -> MagnusError {
+    MagnusError::new(ruby.get_inner(&BUILDER_ERROR), format!("type error: {err}"))
+}
+
+/// Build a `Wreq::BuilderError` for unsupported request JSON values.
+pub fn json_serialization_error(ruby: &Ruby, err: MagnusError) -> MagnusError {
     MagnusError::new(
-        ruby!().get_inner(&BUILDER_ERROR),
-        format!("type error: {err}"),
+        ruby.get_inner(&BUILDER_ERROR),
+        format!("JSON serialization error: {err}"),
     )
 }
 
+/// Prefix a Magnus error while preserving its original Ruby exception class.
+pub(crate) fn contextualize_magnus_error(
+    err: MagnusError,
+    context: fmt::Arguments<'_>,
+) -> MagnusError {
+    match err.error_type() {
+        ErrorType::Error(class, message) => {
+            MagnusError::new(*class, format!("{context}: {message}"))
+        }
+        ErrorType::Exception(exception) => MagnusError::new(
+            exception.exception_class(),
+            format!("{context}: {exception}"),
+        ),
+        ErrorType::Jump(_) => err,
+    }
+}
+
+/// Add an option name while preserving the original Ruby exception class.
+pub fn option_value_error(option: &str, err: MagnusError) -> MagnusError {
+    contextualize_magnus_error(err, format_args!("invalid value for :{option}"))
+}
+
+/// Build an `ArgumentError` from a validation message.
+pub fn argument_error(ruby: &Ruby, message: impl Into<String>) -> MagnusError {
+    MagnusError::new(ruby.exception_arg_error(), message.into())
+}
+
+/// Builds a Ruby `RangeError` from a validation message.
+pub fn range_error(ruby: &Ruby, message: impl Into<String>) -> MagnusError {
+    MagnusError::new(ruby.exception_range_error(), message.into())
+}
+
+/// Build a `TypeError` from a conversion message.
+pub fn type_error(ruby: &Ruby, message: impl Into<String>) -> MagnusError {
+    MagnusError::new(ruby.exception_type_error(), message.into())
+}
 /// Map [`wreq::Error`] to corresponding [`magnus::Error`]
-pub fn wreq_error_to_magnus(err: wreq::Error) -> MagnusError {
+pub fn wreq_error(ruby: &Ruby, err: wreq::Error) -> MagnusError {
     let error_msg = err.to_string();
     map_wreq_error!(
-        ruby!(),
+        ruby,
         err,
         error_msg,
         is_builder => BUILDER_ERROR,
@@ -146,18 +222,95 @@ pub fn wreq_error_to_magnus(err: wreq::Error) -> MagnusError {
     )
 }
 
-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);
+/// Define and retain the Ruby exception classes used by the binding.
+///
+/// # Errors
+///
+/// Returns the Ruby exception raised while defining an error class.
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), MagnusError> {
+    initialize_exception!(
+        ruby,
+        gem_module,
+        MEMORY,
+        "MemoryError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        CONNECTION_ERROR,
+        "ConnectionError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        PROXY_CONNECTION_ERROR,
+        "ProxyConnectionError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        CONNECTION_RESET_ERROR,
+        "ConnectionResetError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        TLS_ERROR,
+        "TlsError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        REQUEST_ERROR,
+        "RequestError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        STATUS_ERROR,
+        "StatusError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        REDIRECT_ERROR,
+        "RedirectError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        TIMEOUT_ERROR,
+        "TimeoutError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        BODY_ERROR,
+        "BodyError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        DECODING_ERROR,
+        "DecodingError",
+        exception_runtime_error
+    );
+    initialize_exception!(
+        ruby,
+        gem_module,
+        BUILDER_ERROR,
+        "BuilderError",
+        exception_runtime_error
+    );
+    Ok(())
 }

data/src/extractor.rs

@@ -1,12 +1,8 @@
-use magnus::{RArray, RHash, RString, Ruby, TryConvert, r_hash::ForEach};
-use wreq::{
-    Proxy,
-    header::{HeaderMap, HeaderName, HeaderValue, OrigHeaderMap},
-};
+use magnus::{RHash, RString, Ruby, TryConvert, value::ReprValue};
+use wreq::Proxy;
 
-use crate::error::{
-    header_name_error_to_magnus, header_value_error_to_magnus, wreq_error_to_magnus,
-};
+use crate::error::{option_value_error, wreq_error};
+use crate::options;
 
 /// A trait that defines the parameter name for extraction.
 pub trait ExtractorName {
@@ -32,65 +28,6 @@ where
     }
 }
 
-// ===== 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<Proxy> =====
 
 impl ExtractorName for Proxy {
@@ -102,16 +39,19 @@ impl TryConvert for Extractor<Proxy> {
         let ruby = Ruby::get_with(value);
         let rhash = RHash::try_convert(value)?;
 
-        if let Some(proxy) = rhash
-            .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);
+        let Some(value) = options::get(&ruby, rhash, Proxy::NAME) else {
+            return Ok(Extractor(None));
+        };
+        if value.is_nil() {
+            return Ok(Extractor(None));
         }
 
-        Ok(Extractor(None))
+        let proxy =
+            RString::try_convert(value).map_err(|error| option_value_error(Proxy::NAME, error))?;
+        let proxy = Proxy::all(proxy.to_bytes().as_ref())
+            .map_err(|err| wreq_error(&ruby, err))
+            .map_err(|error| option_value_error(Proxy::NAME, error))?;
+
+        Ok(Extractor(Some(proxy)))
     }
 }