wreq 1.2.5 → 1.2.7

data/src/client/body/stream.rs

@@ -1,34 +1,58 @@
+//! Streaming request and response body support.
+
 use std::{
+    cell::{Ref, RefCell, RefMut},
+    panic::catch_unwind,
     pin::Pin,
-    sync::RwLock,
     task::{Context, Poll},
 };
 
 use bytes::Bytes;
 use futures_util::{Stream, StreamExt};
-use magnus::{Error, RString, TryConvert, Value};
-use tokio::sync::{
-    Mutex,
-    mpsc::{self},
-};
+use magnus::{Error, Integer, RString, Ruby, Value, scan_args::scan_args};
+use tokio::sync::{Mutex, Semaphore, mpsc};
 
 use crate::{
-    error::{memory_error, mpsc_send_error_to_magnus, wreq_error_to_magnus},
+    error::{
+        argument_error, body_sender_borrow_error, body_sender_borrow_mut_error,
+        body_sender_send_error, closed_body_sender_error, memory_error, type_error, wreq_error,
+    },
     rt,
 };
 
+/// Number of chunks buffered when Ruby omits the channel capacity.
+const DEFAULT_CHANNEL_CAPACITY: usize = 8;
+
 /// A receiver for streaming HTTP response bodies.
 pub struct BodyReceiver(Mutex<Pin<Box<dyn Stream<Item = wreq::Result<Bytes>> + Send>>>);
 
-/// A sender for streaming HTTP request bodies.
+/// A bounded producer for a single streaming HTTP request body.
+///
+/// The receiving side may be attached to one request. The producer remains
+/// writable until [`BodySender::close`] is called or the request drops its
+/// receiver. Ruby's GVL protects state access; no [`RefCell`] borrow is kept
+/// while request backpressure waits without the GVL.
 #[magnus::wrap(class = "Wreq::BodySender", free_immediately, size)]
-pub struct BodySender(RwLock<InnerBodySender>);
+pub struct BodySender(RefCell<InnerBodySender>);
 
+/// Mutable ownership state for both halves of the body channel.
 struct InnerBodySender {
+    /// Producing side, removed by [`BodySender::close`].
     tx: Option<mpsc::Sender<Bytes>>,
+    /// Receiving side, removed when the sender is attached to a request.
     rx: Option<mpsc::Receiver<Bytes>>,
 }
 
+impl InnerBodySender {
+    /// Return whether the channel can no longer accept body chunks.
+    fn is_closed(&self) -> bool {
+        match &self.tx {
+            Some(tx) => tx.is_closed(),
+            None => true,
+        }
+    }
+}
+
 // ===== impl BodyReceiver =====
 
 impl BodyReceiver {
@@ -39,8 +63,9 @@ impl BodyReceiver {
     }
 
     /// Read the next body chunk, converting stream errors into Ruby errors.
-    pub fn next(&self) -> Result<Option<Bytes>, Error> {
+    pub fn next(&self, ruby: &Ruby) -> Result<Option<Bytes>, Error> {
         rt::try_block_on(
+            ruby,
             async {
                 match self.0.lock().await.as_mut().next().await {
                     Some(Ok(data)) => Ok(Some(data)),
@@ -48,7 +73,7 @@ impl BodyReceiver {
                     None => Ok(None),
                 }
             },
-            wreq_error_to_magnus,
+            wreq_error,
         )
     }
 }
@@ -56,54 +81,133 @@ impl BodyReceiver {
 // ===== impl BodySender =====
 
 impl BodySender {
-    /// Ruby: `Wreq::Sender.new(capacity = 8)`
-    pub fn new(args: &[Value]) -> Self {
-        let capacity: usize = if let Some(v) = args.first() {
-            usize::try_convert(*v).unwrap_or(8)
-        } else {
-            8
-        };
-
-        let (tx, rx) = mpsc::channel(capacity);
-        BodySender(RwLock::new(InnerBodySender {
+    /// Create a bounded request-body channel.
+    ///
+    /// Ruby: `Wreq::BodySender.new(capacity = 8)`. Capacity must be greater
+    /// than zero and no larger than [`Semaphore::MAX_PERMITS`].
+    ///
+    /// # Errors
+    ///
+    /// Returns `TypeError` for a non-Integer capacity and `ArgumentError` for
+    /// an invalid range or argument count.
+    pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        let capacity = parse_capacity(ruby, args)?;
+
+        // Create the Tokio channel without allowing an unwind to cross the Ruby FFI boundary.
+        //
+        // Known panic conditions are rejected by [`parse_capacity`]. The unwind guard
+        // remains as a defensive fallback if Tokio adds another channel invariant.
+        let (tx, rx) =
+            catch_unwind(|| mpsc::channel(capacity)).map_err(|_| invalid_capacity_error(ruby))?;
+
+        Ok(BodySender(RefCell::new(InnerBodySender {
             tx: Some(tx),
             rx: Some(rx),
-        }))
+        })))
     }
 
-    /// Ruby: `push(data)` where data is String or bytes
-    pub fn push(rb_self: &Self, data: RString) -> Result<(), Error> {
-        let bytes = data.to_bytes();
-        let inner = rb_self.0.read().unwrap();
-        if let Some(ref tx) = inner.tx {
-            rt::try_block_on(tx.send(bytes), mpsc_send_error_to_magnus)?;
-        }
-        Ok(())
+    /// Push a binary chunk, waiting for capacity when the channel is full.
+    ///
+    /// Ruby: `push(data)` where `data` is a String.
+    ///
+    /// # Errors
+    ///
+    /// Returns `IOError` after either channel side has closed. An interrupted
+    /// wait raises Ruby's standard `Interrupt` exception.
+    pub fn push(ruby: &Ruby, rb_self: &Self, data: RString) -> Result<(), Error> {
+        // Clone during the shared borrow, then release it before waiting
+        // for capacity. Request attachment needs a mutable borrow.
+        let tx = match &rb_self.read_inner(ruby)?.tx {
+            Some(tx) if !tx.is_closed() => tx.clone(),
+            _ => return Err(closed_body_sender_error(ruby)),
+        };
+
+        rt::try_block_on(ruby, tx.send(data.to_bytes()), body_sender_send_error)
     }
 
-    /// Ruby: `close` to close the sender
-    pub fn close(&self) {
-        let mut inner = self.0.write().unwrap();
+    /// Close the producing side while retaining the receiver and queued chunks.
+    ///
+    /// Calling this method more than once has no additional effect.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::BodyError` if the internal state is already borrowed.
+    pub fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let mut inner = rb_self.write_inner(ruby)?;
         inner.tx.take();
-        inner.rx.take();
+        Ok(())
     }
-}
 
-impl TryFrom<&BodySender> for ReceiverStream<Bytes> {
-    type Error = magnus::Error;
+    /// Return whether this sender can no longer accept body chunks.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::BodyError` if the internal state is already borrowed.
+    pub fn is_closed(ruby: &Ruby, rb_self: &Self) -> Result<bool, Error> {
+        rb_self.read_inner(ruby).map(|r| r.is_closed())
+    }
 
-    fn try_from(sender: &BodySender) -> Result<Self, Self::Error> {
-        sender
-            .0
-            .write()
-            .unwrap()
+    /// Borrow the channel state without panicking on accidental re-entry.
+    fn read_inner(&self, ruby: &Ruby) -> Result<Ref<'_, InnerBodySender>, Error> {
+        self.0
+            .try_borrow()
+            .map_err(|err| body_sender_borrow_error(ruby, err))
+    }
+
+    /// Mutably borrow the channel state without panicking on accidental re-entry.
+    fn write_inner(&self, ruby: &Ruby) -> Result<RefMut<'_, InnerBodySender>, Error> {
+        self.0
+            .try_borrow_mut()
+            .map_err(|err| body_sender_borrow_mut_error(ruby, err))
+    }
+
+    /// Move the receiving side into one request body.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::MemoryError` if the receiver was already consumed, or
+    /// `Wreq::BodyError` if Ruby re-enters while the state is borrowed.
+    pub(super) fn take_receiver(&self, ruby: &Ruby) -> Result<ReceiverStream<Bytes>, Error> {
+        self.write_inner(ruby)?
             .rx
             .take()
             .map(ReceiverStream::new)
-            .ok_or_else(memory_error)
+            .ok_or_else(|| memory_error(ruby))
     }
 }
 
+/// Parse and validate the optional Ruby channel capacity.
+///
+/// [`mpsc::channel`] panics for zero or values above
+/// [`Semaphore::MAX_PERMITS`], so validation must finish before channel creation.
+fn parse_capacity(ruby: &Ruby, args: &[Value]) -> Result<usize, Error> {
+    let Some(value) = scan_args::<(), (Option<Value>,), (), (), (), ()>(args)?
+        .optional
+        .0
+    else {
+        return Ok(DEFAULT_CHANNEL_CAPACITY);
+    };
+
+    let integer = Integer::from_value(value)
+        .ok_or_else(|| type_error(ruby, "capacity must be an Integer"))?;
+    let capacity = integer
+        .to_i64()
+        .ok()
+        .and_then(|capacity| usize::try_from(capacity).ok())
+        .filter(|capacity| (1..=Semaphore::MAX_PERMITS).contains(capacity))
+        .ok_or_else(|| invalid_capacity_error(ruby))?;
+
+    Ok(capacity)
+}
+
+/// Build the synchronous Ruby error used for an invalid channel capacity.
+fn invalid_capacity_error(ruby: &Ruby) -> Error {
+    argument_error(
+        ruby,
+        format!("capacity must be between 1 and {}", Semaphore::MAX_PERMITS),
+    )
+}
+
 /// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].
 pub struct ReceiverStream<T> {
     inner: mpsc::Receiver<T>,

data/src/client/body.rs

@@ -1,6 +1,6 @@
-mod form;
-mod json;
-mod stream;
+pub mod form;
+pub mod json;
+pub mod stream;
 
 use bytes::Bytes;
 use futures_util::StreamExt;
@@ -9,29 +9,24 @@ use magnus::{
     typed_data::Obj,
 };
 
-pub use self::{
-    form::Form,
-    json::Json,
-    stream::{BodyReceiver, BodySender, ReceiverStream},
-};
-
 /// Represents the body of an HTTP request.
 /// Supports text, bytes, and streaming bodies (Proc/Enumerator).
 pub enum Body {
     /// Static bytes body
     Bytes(Bytes),
     /// Streaming body
-    Stream(ReceiverStream<Bytes>),
+    Stream(stream::ReceiverStream<Bytes>),
 }
 
 impl TryConvert for Body {
     fn try_convert(val: Value) -> Result<Self, Error> {
+        let ruby = Ruby::get_with(val);
         if let Ok(s) = RString::try_convert(val) {
             return Ok(Body::Bytes(s.to_bytes()));
         }
 
-        let obj = Obj::<BodySender>::try_convert(val)?;
-        let stream = ReceiverStream::try_from(&*obj)?;
+        let obj = Obj::<stream::BodySender>::try_convert(val)?;
+        let stream = obj.take_receiver(&ruby)?;
         Ok(Body::Stream(stream))
     }
 }
@@ -50,8 +45,9 @@ impl From<Body> for wreq::Body {
 
 pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     let sender_class = gem_module.define_class("BodySender", ruby.class_object())?;
-    sender_class.define_singleton_method("new", function!(BodySender::new, -1))?;
-    sender_class.define_method("push", method!(BodySender::push, 1))?;
-    sender_class.define_method("close", magnus::method!(BodySender::close, 0))?;
+    sender_class.define_singleton_method("new", function!(stream::BodySender::new, -1))?;
+    sender_class.define_method("push", method!(stream::BodySender::push, 1))?;
+    sender_class.define_method("close", magnus::method!(stream::BodySender::close, 0))?;
+    sender_class.define_method("closed?", magnus::method!(stream::BodySender::is_closed, 0))?;
     Ok(())
 }

data/src/client/param.rs

@@ -1,19 +1,19 @@
+use ::serde::{Deserialize, Serialize};
 use indexmap::IndexMap;
-use serde::{Deserialize, Serialize};
 
-/// Represents HTTP parameters from Python as either a mapping or a sequence of key-value pairs.
+/// HTTP parameters represented as an insertion-ordered Ruby mapping.
 pub type Params = IndexMap<String, ParamValue>;
 
-/// Represents a single parameter value that can be automatically converted from Python types.
+/// A scalar Ruby value accepted in query-string and form mappings.
 #[derive(Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum ParamValue {
-    /// A boolean value from Python `bool`.
+    /// A Ruby `true` or `false` value.
     Boolean(bool),
-    /// An integer value from Python `int`.
+    /// A Ruby Integer that fits in the native pointer-sized range.
     Number(isize),
-    /// A floating-point value from Python `float`.
+    /// A Ruby Float.
     Float64(f64),
-    /// A string value from Python `str`.
+    /// A Ruby String or Symbol.
     String(String),
 }

data/src/client/req.rs

@@ -1,19 +1,21 @@
 use std::{net::IpAddr, time::Duration};
 
+use ::serde::Deserialize;
 use http::header;
 use magnus::{RHash, TryConvert, typed_data::Obj, value::ReprValue};
-use serde::Deserialize;
 use wreq::{Client, Proxy};
 
-use super::body::{Body, Form, Json};
+use super::body::{Body, form::Form, json::Json};
 use crate::{
+    arch::SUPPORTS_INTERFACE,
     client::{query::Query, resp::Response},
     cookie::Cookies,
     emulate::Emulation,
-    error::wreq_error_to_magnus,
+    error::wreq_error,
     extractor::Extractor,
     header::{Headers, OrigHeaders},
     http::{Method, Version},
+    options::{NativeOption, Options},
     rt,
 };
 
@@ -22,12 +24,12 @@ use crate::{
 #[non_exhaustive]
 pub struct Request {
     /// The emulation option for the request.
-    #[serde(skip)]
-    emulation: Option<Emulation>,
+    #[serde(default)]
+    emulation: NativeOption<Emulation>,
 
     /// The proxy to use for the request.
-    #[serde(skip)]
-    proxy: Option<Proxy>,
+    #[serde(default)]
+    proxy: NativeOption<Proxy>,
 
     /// Bind to a local IP Address.
     local_address: Option<IpAddr>,
@@ -43,23 +45,23 @@ pub struct Request {
     read_timeout: Option<u64>,
 
     /// The HTTP version to use for the request.
-    #[serde(skip)]
-    version: Option<Version>,
+    #[serde(default)]
+    version: NativeOption<Version>,
 
     /// The option enables default headers.
     default_headers: Option<bool>,
 
     /// The headers to use for the request.
-    #[serde(skip)]
-    headers: Option<Headers>,
+    #[serde(default)]
+    headers: NativeOption<Headers>,
 
     /// The original headers to use for the request.
-    #[serde(skip)]
-    orig_headers: Option<OrigHeaders>,
+    #[serde(default)]
+    orig_headers: NativeOption<OrigHeaders>,
 
     /// The cookies to use for the request.
-    #[serde(skip)]
-    cookies: Option<Cookies>,
+    #[serde(default)]
+    cookies: NativeOption<Cookies>,
 
     /// Whether to allow redirects.
     allow_redirects: Option<bool>,
@@ -95,57 +97,95 @@ pub struct Request {
     form: Option<Form>,
 
     /// The JSON body to use for the request.
-    json: Option<Json>,
+    #[serde(default)]
+    json: NativeOption<Json>,
 
     /// The body to use for the request.
-    #[serde(skip)]
-    body: Option<Body>,
+    #[serde(default)]
+    body: NativeOption<Body>,
 }
 
 impl Request {
     /// Create a new [`Request`] from Ruby keyword arguments.
+    ///
+    /// # Errors
+    ///
+    /// Returns before network I/O for unknown, duplicate, unsupported,
+    /// conflicting, ineffective, or invalid option values.
     pub fn new(ruby: &magnus::Ruby, hash: RHash) -> Result<Self, magnus::Error> {
         let keyword = hash.as_value();
-        let mut builder: Self = serde_magnus::deserialize(ruby, keyword)?;
-
-        if let Some(v) = hash.get(ruby.to_symbol(stringify!(emulation))) {
-            let obj = Obj::<Emulation>::try_convert(v)?;
-            builder.emulation = Some((*obj).clone());
-        }
-
-        if let Some(v) = hash.get(ruby.to_symbol(stringify!(version))) {
-            builder.version = Some(Version::try_convert(v)?);
-        }
-
-        if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
-            builder.headers = Some(Headers::try_convert(v)?);
-        }
-
-        if let Some(v) = hash.get(ruby.to_symbol(stringify!(orig_headers))) {
-            builder.orig_headers = Some(OrigHeaders::try_convert(v)?);
-        }
-
-        if let Some(v) = hash.get(ruby.to_symbol(stringify!(cookies))) {
-            builder.cookies = Some(Cookies::try_convert(v)?);
-        }
-
-        if let Some(v) = hash.get(ruby.to_symbol(stringify!(body))) {
-            builder.body = Some(Body::try_convert(v)?);
-        }
-
-        builder.proxy = Extractor::<Proxy>::try_convert(keyword)?.into_inner();
+        let options = Options::new(ruby, hash);
+        let mut builder = Self::deserialize_options(&options)?;
+        options
+            .validator()
+            .require_when_present(
+                stringify!(max_redirects),
+                builder.max_redirects.is_some(),
+                builder.allow_redirects == Some(true),
+                ":allow_redirects to be true",
+            )
+            .finish()?;
+
+        extract_native_option!(
+            options,
+            builder,
+            emulation,
+            Obj<Emulation> => |value| (*value).clone()
+        );
+        extract_native_option!(options, builder, version);
+        extract_native_option!(options, builder, headers);
+        extract_native_option!(options, builder, orig_headers);
+        extract_native_option!(options, builder, cookies);
+        extract_native_option!(options, builder, json, present);
+        builder
+            .proxy
+            .set(Extractor::<Proxy>::try_convert(keyword)?.into_inner());
+        extract_native_option!(options, builder, body);
 
         Ok(builder)
     }
+
+    /// Validate pre-conversion rules and deserialize the request options.
+    ///
+    /// # Errors
+    ///
+    /// Returns `ArgumentError` for failed rules or the Ruby conversion error
+    /// produced by an invalid option value.
+    fn deserialize_options(options: &Options<'_>) -> Result<Self, magnus::Error> {
+        options
+            .validate_keys::<Self>()?
+            .validator()
+            .reject_unsupported(stringify!(interface), SUPPORTS_INTERFACE)
+            .reject_conflicts([
+                (stringify!(body), options.is_non_nil(stringify!(body))),
+                (stringify!(form), options.is_non_nil(stringify!(form))),
+                (stringify!(json), options.is_present(stringify!(json))),
+            ])
+            .reject_conflicts([
+                (stringify!(auth), options.is_non_nil(stringify!(auth))),
+                (
+                    stringify!(bearer_auth),
+                    options.is_non_nil(stringify!(bearer_auth)),
+                ),
+                (
+                    stringify!(basic_auth),
+                    options.is_non_nil(stringify!(basic_auth)),
+                ),
+            ])
+            .finish()?
+            .deserialize::<Self>()
+    }
 }
 
 pub fn execute_request<U: AsRef<str>>(
+    ruby: &magnus::Ruby,
     client: Client,
     method: Method,
     url: U,
     mut request: Request,
 ) -> Result<Response, magnus::Error> {
     rt::try_block_on(
+        ruby,
         async move {
             let mut builder = client.request(method.into_ffi(), url.as_ref());
 
@@ -269,6 +309,6 @@ pub fn execute_request<U: AsRef<str>>(
             // Send request.
             builder.send().await.map(Response::new)
         },
-        wreq_error_to_magnus,
+        wreq_error,
     )
 }

data/src/client/resp.rs

@@ -9,10 +9,10 @@ use magnus::{Error, Module, RArray, RModule, Ruby, Value, scan_args::scan_args};
 use wreq::Uri;
 
 use crate::{
-    client::body::{BodyReceiver, Json},
+    client::body::{json::Json, stream::BodyReceiver},
     cookie::Cookie,
-    error::{memory_error, no_block_given_error, wreq_error_to_magnus},
-    gvl::{self, nogvl},
+    error::{memory_error, no_block_given_error, wreq_error},
+    gvl,
     header::Headers,
     http::{StatusCode, Version},
     rt,
@@ -64,7 +64,7 @@ impl Response {
     }
 
     /// Internal method to get the wreq::Response, optionally streaming the body.
-    fn response(&self, stream: bool) -> Result<wreq::Response, Error> {
+    fn response(&self, ruby: &Ruby, stream: bool) -> Result<wreq::Response, Error> {
         let build_response = |body: wreq::Body| -> wreq::Response {
             let mut response = HttpResponse::new(body);
             *response.version_mut() = self.version.into_ffi();
@@ -81,8 +81,9 @@ impl Response {
                         Ok(build_response(body))
                     } else {
                         let bytes = rt::try_block_on(
+                            ruby,
                             BodyExt::collect(body).map_ok(|buf| buf.to_bytes()),
-                            wreq_error_to_magnus,
+                            wreq_error,
                         )?;
 
                         self.body
@@ -103,7 +104,7 @@ impl Response {
             };
         }
 
-        Err(memory_error())
+        Err(memory_error(ruby))
     }
 }
 
@@ -167,44 +168,42 @@ impl Response {
     }
 
     /// Get the response body as bytes.
-    pub fn bytes(&self) -> Result<Bytes, Error> {
-        let response = self.response(false)?;
-        rt::try_block_on(response.bytes(), wreq_error_to_magnus)
+    pub fn bytes(ruby: &Ruby, rb_self: &Self) -> Result<Bytes, Error> {
+        let response = rb_self.response(ruby, false)?;
+        rt::try_block_on(ruby, response.bytes(), wreq_error)
     }
 
     ///  Get the full response text given a specific encoding.
-    pub fn text(&self, args: &[Value]) -> Result<String, Error> {
+    pub fn text(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<String, Error> {
         let args = scan_args::<(), (Option<String>,), (), (), (), ()>(args)?;
-        let response = self.response(false)?;
+        let response = rb_self.response(ruby, false)?;
         match args.optional.0 {
             Some(encoding) => {
-                rt::try_block_on(response.text_with_charset(encoding), wreq_error_to_magnus)
+                rt::try_block_on(ruby, response.text_with_charset(encoding), wreq_error)
             }
-            None => rt::try_block_on(response.text(), wreq_error_to_magnus),
+            None => rt::try_block_on(ruby, response.text(), wreq_error),
         }
     }
 
     /// Get the response body as JSON.
     pub fn json(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
-        let response = rb_self.response(false)?;
-        let json = rt::try_block_on(response.json::<Json>(), wreq_error_to_magnus)?;
-        serde_magnus::serialize(ruby, &json)
+        let response = rb_self.response(ruby, false)?;
+        let json = rt::try_block_on(ruby, response.json::<Json>(), wreq_error)?;
+        crate::serde::serialize(ruby, &json)
     }
 
     /// Yield response body chunks to the given Ruby block.
     pub fn chunks(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
         if !ruby.block_given() {
-            return Err(no_block_given_error());
+            return Err(no_block_given_error(ruby));
         }
 
-        let receiver = nogvl(|| {
-            rb_self
-                .response(true)
-                .map(wreq::Response::bytes_stream)
-                .map(BodyReceiver::new)
-        })?;
+        let receiver = rb_self
+            .response(ruby, true)
+            .map(wreq::Response::bytes_stream)
+            .map(BodyReceiver::new)?;
 
-        while let Some(chunk) = receiver.next()? {
+        while let Some(chunk) = receiver.next(ruby)? {
             let _: Value = ruby.yield_value(chunk)?;
         }