wreq 1.0.0

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,177 @@
+use std::cell::RefCell;
+
+use bytes::Bytes;
+use http::{HeaderMap, HeaderName, HeaderValue};
+use magnus::{
+    Error, Module, Object, RArray, RModule, Ruby, block::Yield, function, method,
+    typed_data::Inspect,
+};
+
+use crate::error::{header_name_error_to_magnus, header_value_error_to_magnus};
+
+/// 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(RefCell<HeaderMap>);
+
+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))
+    }
+}
+
+struct HeaderIter {
+    inner: http::header::IntoIter<HeaderValue>,
+    next_name: Option<HeaderName>,
+}
+
+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(())
+}

data/src/http.rs

@@ -0,0 +1,127 @@
+use magnus::{Error, Module, RModule, Ruby, method, typed_data::Inspect};
+
+define_ruby_enum!(
+    /// An HTTP version.
+    const,
+    Version,
+    "Wreq::Version",
+    wreq::Version,
+    HTTP_09,
+    HTTP_10,
+    HTTP_11,
+    HTTP_2,
+    HTTP_3,
+);
+
+define_ruby_enum!(
+    /// An HTTP method.
+    Method,
+    "Wreq::Method",
+    wreq::Method,
+    GET,
+    HEAD,
+    POST,
+    PUT,
+    DELETE,
+    OPTIONS,
+    TRACE,
+    PATCH,
+);
+
+/// HTTP status code.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[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()
+    }
+}
+
+// ===== impl StatusCode =====
+
+impl StatusCode {
+    /// Return the status code as an integer.
+    #[inline]
+    pub const fn as_int(&self) -> u16 {
+        self.0.as_u16()
+    }
+
+    /// Check if status is within 100-199.
+    #[inline]
+    pub fn is_informational(&self) -> bool {
+        self.0.is_informational()
+    }
+
+    /// Check if status is within 200-299.
+    #[inline]
+    pub fn is_success(&self) -> bool {
+        self.0.is_success()
+    }
+
+    /// Check if status is within 300-399.
+    #[inline]
+    pub fn is_redirection(&self) -> bool {
+        self.0.is_redirection()
+    }
+
+    /// Check if status is within 400-499.
+    #[inline]
+    pub fn is_client_error(&self) -> bool {
+        self.0.is_client_error()
+    }
+
+    /// Check if status is within 500-599.
+    #[inline]
+    pub fn is_server_error(&self) -> bool {
+        self.0.is_server_error()
+    }
+
+    /// Convert status code to string.
+    #[inline]
+    pub fn to_s(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl From<wreq::StatusCode> for StatusCode {
+    fn from(status: wreq::StatusCode) -> Self {
+        Self(status)
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let method_class = gem_module.define_class("Method", ruby.class_object())?;
+    method_class.const_set("GET", Method::GET)?;
+    method_class.const_set("POST", Method::POST)?;
+    method_class.const_set("PUT", Method::PUT)?;
+    method_class.const_set("DELETE", Method::DELETE)?;
+    method_class.const_set("PATCH", Method::PATCH)?;
+    method_class.const_set("HEAD", Method::HEAD)?;
+    method_class.const_set("TRACE", Method::TRACE)?;
+    method_class.const_set("OPTIONS", Method::OPTIONS)?;
+
+    let version_class = gem_module.define_class("Version", ruby.class_object())?;
+    version_class.const_set("HTTP_09", Version::HTTP_09)?;
+    version_class.const_set("HTTP_10", Version::HTTP_10)?;
+    version_class.const_set("HTTP_11", Version::HTTP_11)?;
+    version_class.const_set("HTTP_2", Version::HTTP_2)?;
+    version_class.const_set("HTTP_3", Version::HTTP_3)?;
+    version_class.define_method("to_s", method!(Version::to_s, 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))?;
+    status_code_class.define_method("informational?", method!(StatusCode::is_informational, 0))?;
+    status_code_class.define_method("success?", method!(StatusCode::is_success, 0))?;
+    status_code_class.define_method("redirection?", method!(StatusCode::is_redirection, 0))?;
+    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))?;
+
+    Ok(())
+}

data/src/lib.rs

@@ -0,0 +1,97 @@
+#![allow(clippy::wrong_self_convention)]
+
+#[macro_use]
+mod macros;
+mod client;
+mod cookie;
+mod emulation;
+mod error;
+mod extractor;
+mod gvl;
+mod header;
+mod http;
+mod rt;
+
+use magnus::{Error, Module, Ruby, Value};
+
+use crate::client::{Client, resp::Response};
+
+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)
+}
+
+/// Send a GET request.
+#[inline]
+pub fn get(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::get(&Client::default(), args)
+}
+
+/// Send a POST request.
+#[inline]
+pub fn post(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::post(&Client::default(), args)
+}
+
+/// Send a PUT request.
+#[inline]
+pub fn put(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::put(&Client::default(), args)
+}
+
+/// Send a DELETE request.
+#[inline]
+pub fn delete(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::delete(&Client::default(), args)
+}
+
+/// Send a HEAD request.
+#[inline]
+pub fn head(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::head(&Client::default(), args)
+}
+
+/// Send an OPTIONS request.
+#[inline]
+pub fn options(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::options(&Client::default(), args)
+}
+
+/// Send a TRACE request.
+#[inline]
+pub fn trace(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::trace(&Client::default(), args)
+}
+
+/// Send a PATCH request.
+#[inline]
+pub fn patch(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::patch(&Client::default(), args)
+}
+
+/// wreq ruby binding
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let gem_module = ruby.define_module(RUBY_MODULE_NAME)?;
+    gem_module.const_set("VERSION", VERSION)?;
+    gem_module.define_module_function("request", magnus::function!(request, -1))?;
+    gem_module.define_module_function("get", magnus::function!(get, -1))?;
+    gem_module.define_module_function("post", magnus::function!(post, -1))?;
+    gem_module.define_module_function("put", magnus::function!(put, -1))?;
+    gem_module.define_module_function("delete", magnus::function!(delete, -1))?;
+    gem_module.define_module_function("head", magnus::function!(head, -1))?;
+    gem_module.define_module_function("options", magnus::function!(options, -1))?;
+    gem_module.define_module_function("trace", magnus::function!(trace, -1))?;
+    gem_module.define_module_function("patch", magnus::function!(patch, -1))?;
+    http::include(ruby, &gem_module)?;
+    header::include(ruby, &gem_module)?;
+    cookie::include(ruby, &gem_module)?;
+    client::include(ruby, &gem_module)?;
+    emulation::include(ruby, &gem_module)?;
+    error::include(ruby);
+    Ok(())
+}

data/src/macros.rs

@@ -0,0 +1,118 @@
+macro_rules! apply_option {
+    (set_if_some, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(value);
+        }
+    };
+    (set_if_some_ref, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(&value);
+        }
+    };
+    (set_if_some_inner, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(value.0);
+        }
+    };
+    (set_if_some_map, $builder:expr, $option:expr, $method:ident, $transform:expr) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method($transform(value));
+        }
+    };
+    (set_if_some_map_ref, $builder:expr, $option:expr, $method:ident, $transform:expr) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method($transform(&value));
+        }
+    };
+    (set_if_true, $builder:expr, $option:expr, $method:ident, $default:expr) => {
+        if $option.unwrap_or($default) {
+            $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);
+        }
+    };
+}
+
+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])* 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, $(($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 fn into_ffi(self) -> $ffi_type {
+                match self {
+                    $(<$enum_type>::$rust_variant => <$ffi_type>::$ffi_variant,)*
+                }
+            }
+
+            #[allow(dead_code)]
+            pub fn from_ffi(ffi: $ffi_type) -> Self {
+                #[allow(unreachable_patterns)]
+                match ffi {
+                    $(<$ffi_type>::$ffi_variant => <$enum_type>::$rust_variant,)*
+                    _ => unreachable!(),
+                }
+            }
+        }
+    };
+
+    ($(#[$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,)*
+                }
+            }
+
+            #[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!(),
+                }
+            }
+        }
+    };
+}
+
+macro_rules! ruby {
+    () => {
+        magnus::Ruby::get().expect("Failed to get Ruby VM instance")
+    };
+}
+
+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)?;
+        (required, request)
+    }};
+}