wreq 1.2.5 → 1.2.6

data/lib/wreq_ruby/emulate.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# Profile and platform constants mirror the native enum variant names.
+# standard:disable Naming/ConstantName
+
 module Wreq
   # Browser and client fingerprint profile enumeration backed by Rust.
   #
@@ -164,6 +167,29 @@ module Wreq
       def to_s
       end
     end
+
+    unless method_defined?(:==)
+      # Value-based equality.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+      end
+    end
+
+    unless method_defined?(:eql?)
+      # Strict equality for Hash key and Set member semantics.
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+      end
+    end
+
+    unless method_defined?(:hash)
+      # Hash value consistent with {#eql?} for use as Hash keys.
+      # @return [Integer]
+      def hash
+      end
+    end
   end
 
   # Operating system platform enumeration backed by Rust.
@@ -195,6 +221,36 @@ module Wreq
       def to_s
       end
     end
+
+    unless method_defined?(:to_sym)
+      # Returns the platform as a lowercase symbol (e.g. :windows, :linux).
+      # @return [Symbol]
+      def to_sym
+      end
+    end
+
+    unless method_defined?(:==)
+      # Value-based equality.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+      end
+    end
+
+    unless method_defined?(:eql?)
+      # Strict equality for Hash key and Set member semantics.
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+      end
+    end
+
+    unless method_defined?(:hash)
+      # Hash value consistent with {#eql?} for use as Hash keys.
+      # @return [Integer]
+      def hash
+      end
+    end
   end
 
   # Emulation option wrapper.
@@ -216,19 +272,31 @@ module Wreq
   #
   # @param profile [Wreq::Profile, nil] Fingerprint profile to emulate
   # @param platform [Wreq::Platform, nil] Operating system platform to emulate
-  # @param http2 [Boolean] Whether HTTP/2 support is enabled
-  # @param headers [Boolean] Whether default emulation headers are enabled
+  # @param http2 [Boolean, nil] Whether HTTP/2 emulation is enabled; defaults
+  #   to true when omitted or nil
+  # @param headers [Boolean, nil] Whether default emulation headers are enabled;
+  #   defaults to true when omitted or nil
+  # @return [Wreq::Emulation] Configured emulation settings
+  # @raise [ArgumentError] if an option is unknown or extra arguments are given
+  # @raise [TypeError] if the option argument is not a Hash or a value has the
+  #   wrong Ruby type
   class Emulation
     # Native fields and methods are set by the extension.
     # This stub is for documentation only.
-    unless method_defined?(:new)
+    unless singleton_methods(false).include?(:new)
       # @param profile [Wreq::Profile, nil] Fingerprint profile to emulate
       # @param platform [Wreq::Platform, nil] Operating system platform to emulate
-      # @param http2 [Boolean] Whether HTTP/2 support is enabled
-      # @param headers [Boolean] Whether default emulation headers are enabled
+      # @param http2 [Boolean, nil] Whether HTTP/2 emulation is enabled; defaults
+      #   to true when omitted or nil
+      # @param headers [Boolean, nil] Whether default emulation headers are enabled;
+      #   defaults to true when omitted or nil
       # @return [Wreq::Emulation] Configured emulation settings
-      def self.new(profile: nil, platform: nil, http2: true, headers: true)
+      # @raise [ArgumentError] if an option is unknown or extra arguments are given
+      # @raise [TypeError] if an option or value has the wrong Ruby type
+      def self.new(**options)
       end
     end
   end
 end
+
+# standard:enable Naming/ConstantName

data/lib/wreq_ruby/error.rb

@@ -88,7 +88,7 @@ unless defined?(Wreq)
     #
     # @example
     #   begin
-    #     client = Wreq::Client.new(max_redirects: 3)
+    #     client = Wreq::Client.new(allow_redirects: true, max_redirects: 3)
     #     client.get("https://httpbin.io/redirect/10")
     #   rescue Wreq::RedirectError => e
     #     puts "Too many redirects: #{e.message}"
@@ -139,16 +139,14 @@ unless defined?(Wreq)
 
     # Configuration and builder errors
 
-    # Client configuration is invalid.
+    # A native client or request configuration could not be built.
     #
-    # Raised when the client is configured with invalid options.
+    # Raised when validated Ruby options cannot be represented by the native
+    # builder or request body.
     #
     # @example
     #   begin
-    #     client = Wreq::Client.new(
-    #       proxy: "invalid://proxy",
-    #       timeout: -1
-    #     )
+    #     client = Wreq::Client.new(proxy: "invalid://")
     #   rescue Wreq::BuilderError => e
     #     puts "Invalid configuration: #{e.message}"
     #   end

data/lib/wreq_ruby/http.rb

@@ -25,6 +25,43 @@ module Wreq
       TRACE = nil # @return [Wreq::Method] HTTP TRACE method
       PATCH = nil # @return [Wreq::Method] HTTP PATCH method
     end
+
+    # Returns the HTTP method token (e.g. "GET", "POST").
+    # @return [String]
+    unless method_defined?(:to_s)
+      def to_s
+      end
+    end
+
+    # Returns the HTTP method as a lowercase symbol (e.g. :get, :post).
+    # @return [Symbol]
+    unless method_defined?(:to_sym)
+      def to_sym
+      end
+    end
+
+    # Value-based equality. Returns true when both represent the same HTTP method.
+    # @param other [Object]
+    # @return [Boolean]    
+    unless method_defined?(:==)
+      def ==(other)
+      end
+    end
+
+    # Strict equality for Hash key and Set member semantics.
+    # @param other [Object]
+    # @return [Boolean]
+    unless method_defined?(:eql?)
+      def eql?(other)
+      end
+    end
+
+    # Hash value consistent with {#eql?} for use as Hash keys.
+    # @return [Integer]
+    unless method_defined?(:hash)
+      def hash
+      end
+    end
   end
 
   # HTTP version enumeration backed by Rust.
@@ -63,6 +100,21 @@ module Wreq
       def ==(other)
       end
     end
+
+    # Strict equality for Hash key and Set member semantics.
+    # @param other [Object]
+    # @return [Boolean]
+    unless method_defined?(:eql?)
+      def eql?(other)
+      end
+    end
+
+    # Hash value consistent with {#eql?} for use as Hash keys.
+    # @return [Integer]
+    unless method_defined?(:hash)
+      def hash
+      end
+    end
   end
 
   # HTTP status code wrapper.
@@ -141,6 +193,28 @@ module Wreq
       # @return [String] Status code as string
       def to_s
       end
+
+      # Returns the status code as an integer.
+      # @return [Integer] the numeric HTTP status code
+      def to_i
+      end
+
+      # Value-based equality. Only compares with other StatusCode instances.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+      end
+
+      # Strict equality for Hash key and Set member semantics.
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+      end
+
+      # Hash value consistent with {#eql?} for use as Hash keys.
+      # @return [Integer]
+      def hash
+      end
     end
   end
 end

data/lib/wreq_ruby/response.rb

@@ -127,6 +127,9 @@ unless defined?(Wreq)
 
       # Parse the response body as JSON.
       #
+      # Integral JSON numbers are returned as arbitrary-precision Ruby Integer
+      # values. Fractional and exponent-form numbers are returned as Float values.
+      #
       # @return [Object] Parsed JSON (Hash, Array, String, Integer, Float, Boolean, nil)
       # @raise [Wreq::DecodingError] if body is not valid JSON
       # @example

data/script/build_windows_gnu.ps1

@@ -32,7 +32,12 @@ function Invoke-Step {
     )
 
     Write-Host "==> $Name"
+    # Native command failures do not honor ErrorActionPreference in Windows PowerShell.
+    $global:LASTEXITCODE = 0
     & $Command
+    if ($LASTEXITCODE -ne 0) {
+        throw "$Name failed with exit code $LASTEXITCODE."
+    }
 }
 
 function Get-MissingUcrtTools {
@@ -122,6 +127,7 @@ Invoke-Step "Check MSYS2 UCRT build tools" {
         $stillMissing = @(Get-MissingUcrtTools)
         if ($stillMissing.Count -eq 0) {
             Write-Warning "pacman returned exit code $LASTEXITCODE, but all required tools are present; continuing."
+            $global:LASTEXITCODE = 0
             return
         }
 

data/src/arch.rs

@@ -4,6 +4,28 @@
 //! ABI boundaries, or OS APIs used by the Rust extension. Normal HTTP client
 //! behavior should stay in the client/runtime modules so platform workarounds
 //! do not leak into the rest of the binding.
+#![allow(unsafe_code)]
+
+/// Whether the native client exposes TCP user-timeout configuration.
+pub(crate) const SUPPORTS_TCP_USER_TIMEOUT: bool = cfg!(any(
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "linux"
+));
+
+/// Whether the native client exposes network-interface binding.
+pub(crate) const SUPPORTS_INTERFACE: bool = cfg!(any(
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "solaris",
+    target_os = "tvos",
+    target_os = "visionos",
+    target_os = "watchos",
+));
 
 #[cfg(all(target_os = "windows", target_env = "gnu"))]
 mod windows_gnu {

data/src/client/body/form.rs

@@ -1,2 +1,4 @@
+//! Form request body conversion.
+
 /// Alias for form parameters.
 pub type Form = crate::client::param::Params;

data/src/client/body/json.rs

@@ -1,16 +1,49 @@
-use indexmap::IndexMap;
-use serde::{Deserialize, Serialize};
+//! JSON conversion at the Ruby request and response boundary.
+//!
+//! Request values are converted from Ruby into an owned [`Json`] tree before
+//! network I/O. Response bodies are deserialized into the same tree by wreq and
+//! then converted back into Ruby values.
+//!
+//! The underlying `serde_json` configuration preserves object insertion order
+//! and arbitrary-size integer tokens in both directions.
 
-/// Represents a JSON value for HTTP requests.
-/// Supports objects, arrays, numbers, strings, booleans, and null.
-#[derive(Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum Json {
-    Object(IndexMap<String, Json>),
-    Boolean(bool),
-    Number(isize),
-    Float(f64),
-    String(String),
-    Null(Option<isize>),
-    Array(Vec<Json>),
+use ::serde::{Deserialize, Serialize};
+use magnus::{Error, Ruby, TryConvert, Value};
+
+use crate::{error::json_serialization_error, serde::deserialize_json};
+
+/// An owned JSON tree shared by request and response conversion.
+///
+/// This wrapper keeps the configured `serde_json::Value` representation private
+/// so callers use the same precision and ordering behavior in both directions.
+#[derive(Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct Json(serde_json::Value);
+
+/// Convert supported Ruby request values into an owned JSON tree.
+///
+/// Supported values are `Hash`, `Array`, `String`, `Symbol`, `Integer`, finite
+/// `Float`, booleans, and `nil`. Hash keys must be strings or symbols. Arrays
+/// and hashes are limited to 100 nesting levels, which also bounds cyclic input.
+/// Unsupported values are reported as `Wreq::BuilderError` before network I/O.
+impl TryConvert for Json {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        let ruby = Ruby::get_with(value);
+        deserialize_json(&ruby, value)
+            .map(Self)
+            .map_err(|error| json_serialization_error(&ruby, error))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Json;
+
+    #[test]
+    fn preserves_number_precision_and_object_order() {
+        let source = br#"{"second":115792089237316195423570985008687907853269984665640564039457584007913129639936,"first":1}"#;
+        let json: Json = serde_json::from_slice(source).unwrap();
+
+        assert_eq!(source, serde_json::to_vec(&json).unwrap().as_slice());
+    }
 }

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(())
 }