wreq 1.2.3-x64-mingw-ucrt

data/src/error.rs

@@ -0,0 +1,163 @@
+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")
+}
+
+/// LocalJumpError for methods that require a Ruby block.
+pub fn no_block_given_error() -> MagnusError {
+    MagnusError::new(
+        ruby!().exception_local_jump_error(),
+        "no block given (yield)",
+    )
+}
+
+/// 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 type/value errors to corresponding [`magnus::Error`]
+pub fn type_value_error_to_magnus(err: &str) -> MagnusError {
+    MagnusError::new(
+        ruby!().get_inner(&BUILDER_ERROR),
+        format!("type error: {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,117 @@
+use magnus::{RArray, RHash, RString, Ruby, TryConvert, r_hash::ForEach};
+use wreq::{
+    Proxy,
+    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<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 {
+    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 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);
+        }
+
+        Ok(Extractor(None))
+    }
+}

data/src/gvl.rs

@@ -0,0 +1,154 @@
+//! Allow usage of unsafe code for FFI with Ruby's GVL functions.
+#![allow(unsafe_code)]
+
+use std::{ffi::c_void, mem::MaybeUninit, ptr::null_mut};
+
+use rb_sys::rb_thread_call_without_gvl;
+use tokio::sync::watch;
+
+/// Container for safely passing closure and result through C callback.
+struct Args<F, R> {
+    func: Option<F>,
+    result: MaybeUninit<R>,
+}
+
+/// Cancellation flag for thread interruption support.
+#[derive(Clone)]
+pub struct CancelFlag {
+    rx: watch::Receiver<bool>,
+}
+
+struct CancelSender {
+    tx: watch::Sender<bool>,
+}
+
+impl CancelSender {
+    fn new() -> (Self, CancelFlag) {
+        let (tx, rx) = watch::channel(false);
+        (Self { tx }, CancelFlag { rx })
+    }
+
+    fn cancel(&self) {
+        let _ = self.tx.send(true);
+    }
+}
+
+impl CancelFlag {
+    /// Wait until cancellation is signaled (zero-latency, no polling).
+    pub async fn cancelled(&self) {
+        let mut rx = self.rx.clone();
+        if *rx.borrow_and_update() {
+            return;
+        }
+        loop {
+            if rx.changed().await.is_err() {
+                return;
+            }
+            if *rx.borrow() {
+                return;
+            }
+        }
+    }
+}
+
+struct UnblockData {
+    sender: CancelSender,
+}
+
+unsafe extern "C" fn call_without_gvl<F, R>(arg: *mut c_void) -> *mut c_void
+where
+    F: FnOnce() -> R,
+    R: Sized,
+{
+    let args = unsafe { &mut *(arg as *mut Args<F, R>) };
+
+    // Take closure from Option to transfer ownership.
+    if let Some(func) = args.func.take() {
+        args.result.write(func());
+    }
+
+    null_mut()
+}
+
+unsafe extern "C" fn unblock_func(arg: *mut c_void) {
+    if !arg.is_null() {
+        let data = unsafe { &*(arg as *const UnblockData) };
+        data.sender.cancel();
+    }
+}
+
+/// Executes the given closure without holding the Ruby GVL (Global VM Lock).
+///
+/// WARNING: Do NOT nest calls to [`nogvl`] or [`nogvl_cancellable`] inside each other.
+/// Nesting these functions will cause Ruby thread deadlock, because the inner call
+/// will block waiting for the GVL while the outer call has already released it.
+/// This results in all Ruby threads being suspended indefinitely.
+pub fn nogvl<F, R>(func: F) -> R
+where
+    F: FnOnce() -> R,
+    R: Sized,
+{
+    // Create stable wrapper to keep data valid during callback.
+    let mut args = Args {
+        func: Some(func),
+        result: MaybeUninit::uninit(),
+    };
+
+    let arg_ptr = &mut args as *mut _ as *mut c_void;
+
+    unsafe {
+        rb_thread_call_without_gvl(Some(call_without_gvl::<F, R>), arg_ptr, None, null_mut());
+        args.result.assume_init()
+    }
+}
+
+/// Executes the given closure without GVL, supporting cancellation via thread interrupt.
+///
+/// WARNING: Do NOT nest calls to [`nogvl`] or [`nogvl_cancellable`] inside each other.
+/// Nesting these functions will cause Ruby thread deadlock, because the inner call
+/// will block waiting for the GVL while the outer call has already released it.
+/// This results in all Ruby threads being suspended indefinitely.
+pub fn nogvl_cancellable<F, R>(func: F) -> R
+where
+    F: FnOnce(CancelFlag) -> R,
+    R: Sized,
+{
+    let (sender, flag) = CancelSender::new();
+    let unblock_data = UnblockData { sender };
+
+    struct Wrapper<F, R> {
+        func: Option<F>,
+        flag: CancelFlag,
+        result: MaybeUninit<R>,
+    }
+
+    let mut wrapper = Wrapper {
+        func: Some(func),
+        flag,
+        result: MaybeUninit::uninit(),
+    };
+
+    unsafe extern "C" fn call_with_flag<F, R>(arg: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce(CancelFlag) -> R,
+    {
+        let wrapper = unsafe { &mut *(arg as *mut Wrapper<F, R>) };
+        if let Some(func) = wrapper.func.take() {
+            wrapper.result.write(func(wrapper.flag.clone()));
+        }
+        null_mut()
+    }
+
+    let wrapper_ptr = &mut wrapper as *mut _ as *mut c_void;
+    let unblock_data_ptr = &unblock_data as *const _ as *mut c_void;
+
+    unsafe {
+        rb_thread_call_without_gvl(
+            Some(call_with_flag::<F, R>),
+            wrapper_ptr,
+            Some(unblock_func),
+            unblock_data_ptr,
+        );
+        wrapper.result.assume_init()
+    }
+}

data/src/header.rs

@@ -0,0 +1,245 @@
+use std::cell::RefCell;
+
+use bytes::Bytes;
+use http::{HeaderMap, HeaderName, HeaderValue};
+use magnus::{
+    Error, Module, Object, RArray, RHash, RModule, RString, Ruby, TryConvert, Value,
+    block::Yield,
+    function, method,
+    r_hash::ForEach,
+    typed_data::{Inspect, Obj},
+};
+use wreq::header::OrigHeaderMap;
+
+use crate::error::{
+    header_name_error_to_magnus, header_value_error_to_magnus, type_value_error_to_magnus,
+};
+
+/// A wrapper for the User-Agent header value.
+pub struct UserAgent(pub HeaderValue);
+
+/// HTTP headers collection with read and write operations.
+///
+/// This class wraps HTTP headers and provides convenient methods for
+/// accessing, modifying, and iterating over header name-value pairs.
+#[derive(Clone, Default)]
+#[magnus::wrap(class = "Wreq::Headers", free_immediately, size)]
+pub struct Headers(pub RefCell<HeaderMap>);
+
+/// A map from header names to their original casing as received in an HTTP message.
+pub struct OrigHeaders(pub OrigHeaderMap);
+
+struct HeaderIter {
+    inner: http::header::IntoIter<HeaderValue>,
+    next_name: Option<HeaderName>,
+}
+
+// ===== impl UserAgent =====
+
+impl TryConvert for UserAgent {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        let s = RString::try_convert(value)?;
+        let header_value =
+            HeaderValue::from_maybe_shared(s.to_bytes()).map_err(header_value_error_to_magnus)?;
+        Ok(Self(header_value))
+    }
+}
+
+// ===== impl Headers =====
+
+impl Headers {
+    /// Create a new empty Headers instance.
+    #[inline]
+    pub fn new() -> Self {
+        Self::from(HeaderMap::new())
+    }
+
+    /// Get a header value by name (case-insensitive).
+    #[inline]
+    pub fn get(&self, name: String) -> Option<Bytes> {
+        self.0.borrow().get(&name).cloned().map(Bytes::from_owner)
+    }
+
+    /// Get all values for a header name (case-insensitive).
+    #[inline]
+    pub fn get_all(ruby: &Ruby, rb_self: &Self, name: String) -> RArray {
+        ruby.ary_from_iter(
+            rb_self
+                .0
+                .borrow()
+                .get_all(&name)
+                .iter()
+                .cloned()
+                .map(Bytes::from_owner),
+        )
+    }
+
+    /// Set a header, replacing any existing values.
+    pub fn set(&self, name: String, value: String) -> Result<(), Error> {
+        let header_name = name
+            .parse::<HeaderName>()
+            .map_err(header_name_error_to_magnus)?;
+        let header_value = HeaderValue::from_maybe_shared(Bytes::from(value))
+            .map_err(header_value_error_to_magnus)?;
+
+        self.0.borrow_mut().insert(header_name, header_value);
+        Ok(())
+    }
+
+    /// Append a header value without replacing existing values.
+    pub fn append(&self, name: String, value: String) -> Result<(), Error> {
+        let header_name = name
+            .parse::<http::header::HeaderName>()
+            .map_err(header_name_error_to_magnus)?;
+        let header_value = HeaderValue::from_maybe_shared(Bytes::from(value))
+            .map_err(header_value_error_to_magnus)?;
+
+        self.0.borrow_mut().append(header_name, header_value);
+        Ok(())
+    }
+
+    /// Remove all values for a header name.
+    #[inline]
+    pub fn remove(&self, name: String) -> Option<Bytes> {
+        self.0.borrow_mut().remove(&name).map(Bytes::from_owner)
+    }
+
+    /// Check if a header exists (case-insensitive).
+    #[inline]
+    pub fn contains(&self, name: String) -> bool {
+        self.0.borrow().contains_key(&name)
+    }
+
+    /// Get the number of headers.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.borrow().len()
+    }
+
+    /// Check if headers are empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.0.borrow().is_empty()
+    }
+
+    /// Clear all headers.
+    #[inline]
+    pub fn clear(&self) {
+        self.0.borrow_mut().clear();
+    }
+
+    /// Get all header names.
+    #[inline]
+    pub fn keys(ruby: &Ruby, rb_self: &Self) -> RArray {
+        ruby.ary_from_iter(rb_self.0.borrow().keys().cloned().map(Bytes::from_owner))
+    }
+
+    /// Get all header values.
+    #[inline]
+    pub fn values(ruby: &Ruby, rb_self: &Self) -> RArray {
+        ruby.ary_from_iter(rb_self.0.borrow().values().cloned().map(Bytes::from_owner))
+    }
+
+    /// Iterate over headers with Ruby block support.
+    #[inline]
+    pub fn each(&self) -> Yield<impl Iterator<Item = (Bytes, Bytes)>> {
+        Yield::Iter(HeaderIter {
+            inner: self.0.borrow().clone().into_iter(),
+            next_name: None,
+        })
+    }
+
+    /// Convert headers to string representation.
+    #[inline]
+    pub fn to_s(&self) -> String {
+        self.0.borrow().inspect()
+    }
+}
+
+impl From<HeaderMap> for Headers {
+    fn from(headers: HeaderMap) -> Self {
+        Self(RefCell::new(headers))
+    }
+}
+
+impl TryConvert for Headers {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        if let Some(rhash) = RHash::from_value(value) {
+            let mut headers = HeaderMap::new();
+
+            rhash.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(Self::from(headers));
+        }
+
+        Obj::<Headers>::try_convert(value)
+            .map(|headers| headers.0.clone())
+            .map(Self)
+    }
+}
+
+// ===== impl OrigHeaders =====
+
+impl TryConvert for OrigHeaders {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        let mut map = OrigHeaderMap::new();
+
+        let rarray = RArray::from_value(value)
+            .ok_or_else(|| type_value_error_to_magnus("Expected an array of strings"))?;
+
+        for value in rarray.into_iter().flat_map(RString::from_value) {
+            map.insert(value.to_bytes());
+        }
+
+        Ok(Self(map))
+    }
+}
+
+// ===== impl HeaderIter =====
+
+impl Iterator for HeaderIter {
+    type Item = (Bytes, Bytes);
+    fn next(&mut self) -> Option<Self::Item> {
+        let (name, value) = self.inner.next()?;
+        match (&self.next_name, name) {
+            (Some(next_name), None) => Some((
+                Bytes::from_owner(next_name.clone()),
+                Bytes::from_owner(value),
+            )),
+            (_, Some(name)) => {
+                self.next_name = Some(name.clone());
+                Some((Bytes::from_owner(name), Bytes::from_owner(value)))
+            }
+            (None, None) => None,
+        }
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    // Define Headers class with methods
+    let headers_class = gem_module.define_class("Headers", ruby.class_object())?;
+    headers_class.define_singleton_method("new", function!(Headers::new, 0))?;
+    headers_class.define_method("get", method!(Headers::get, 1))?;
+    headers_class.define_method("get_all", method!(Headers::get_all, 1))?;
+    headers_class.define_method("set", method!(Headers::set, 2))?;
+    headers_class.define_method("append", method!(Headers::append, 2))?;
+    headers_class.define_method("remove", method!(Headers::remove, 1))?;
+    headers_class.define_method("contains?", method!(Headers::contains, 1))?;
+    headers_class.define_method("key?", method!(Headers::contains, 1))?;
+    headers_class.define_method("length", method!(Headers::len, 0))?;
+    headers_class.define_method("empty?", method!(Headers::is_empty, 0))?;
+    headers_class.define_method("clear", method!(Headers::clear, 0))?;
+    headers_class.define_method("keys", method!(Headers::keys, 0))?;
+    headers_class.define_method("values", method!(Headers::values, 0))?;
+    headers_class.define_method("each", method!(Headers::each, 0))?;
+    headers_class.define_method("to_s", method!(Headers::to_s, 0))?;
+    Ok(())
+}