wreq-rb 0.4.0 → 0.5.1

data/ext/wreq_rb/src/client.rs

@@ -10,8 +10,10 @@ use magnus::{
 };
 use tokio::runtime::Runtime;
 use tokio_util::sync::CancellationToken;
-use wreq::header::{HeaderMap, HeaderName, HeaderValue};
-use wreq_util::{Emulation as BrowserEmulation, EmulationOS, EmulationOption};
+use std::net::IpAddr;
+use wreq::header::{HeaderMap, HeaderName, HeaderValue, OrigHeaderMap};
+use wreq::tls::TlsVersion;
+use wreq_util::{Emulation as BrowserEmulation, Platform as EmulationPlatform, Profile as BrowserProfile};
 
 use crate::error::{generic_error, to_magnus_error};
 use crate::response::Response;
@@ -139,35 +141,35 @@ async fn execute_request(req: wreq::RequestBuilder) -> Result<ResponseData, wreq
 // Emulation helpers
 // --------------------------------------------------------------------------
 
-/// The default emulation to apply when none is specified.
-const DEFAULT_EMULATION: BrowserEmulation = BrowserEmulation::Chrome145;
+/// The default browser profile to apply when none is specified.
+const DEFAULT_EMULATION: BrowserProfile = BrowserProfile::Chrome148;
 
-/// Parse a Ruby string like "chrome_143" into a BrowserEmulation variant.
-fn parse_emulation(name: &str) -> Result<BrowserEmulation, magnus::Error> {
+/// Parse a Ruby string like "chrome_143" into a BrowserProfile variant.
+fn parse_emulation(name: &str) -> Result<BrowserProfile, magnus::Error> {
     let json_val = serde_json::Value::String(name.to_string());
-    serde_json::from_value::<BrowserEmulation>(json_val)
-        .map_err(|_| generic_error(format!("unknown emulation: '{}'. Use names like 'chrome_145', 'firefox_147', 'safari_18.5', etc.", name)))
+    serde_json::from_value::<BrowserProfile>(json_val)
+        .map_err(|_| generic_error(format!("unknown emulation: '{}'. Use names like 'chrome_148', 'firefox_151', 'safari_18.5', etc.", name)))
 }
 
-/// Parse a Ruby string like "windows" into an EmulationOS variant.
-fn parse_emulation_os(name: &str) -> Result<EmulationOS, magnus::Error> {
+/// Parse a Ruby string like "windows" into an EmulationPlatform variant.
+fn parse_emulation_os(name: &str) -> Result<EmulationPlatform, magnus::Error> {
     let json_val = serde_json::Value::String(name.to_string());
-    serde_json::from_value::<EmulationOS>(json_val)
+    serde_json::from_value::<EmulationPlatform>(json_val)
         .map_err(|_| generic_error("unknown emulation_os. Use: 'windows', 'macos', 'linux', 'android', 'ios'"))
 }
 
-/// Build an EmulationOption from an Emulation and an optional OS from the opts hash.
+/// Build a BrowserEmulation from a profile and an optional platform from the opts hash.
 fn build_emulation_option(
-    emu: BrowserEmulation,
+    profile: BrowserProfile,
     opts: &RHash,
-) -> Result<EmulationOption, magnus::Error> {
-    let os = match hash_get_string(opts, "emulation_os")? {
-        Some(os_name) => parse_emulation_os(&os_name)?,
-        None => EmulationOS::default(),
+) -> Result<BrowserEmulation, magnus::Error> {
+    let platform = match hash_get_string(opts, "emulation_os")? {
+        Some(platform_name) => parse_emulation_os(&platform_name)?,
+        None => EmulationPlatform::default(),
     };
-    Ok(EmulationOption::builder()
-        .emulation(emu)
-        .emulation_os(os)
+    Ok(BrowserEmulation::builder()
+        .profile(profile)
+        .platform(platform)
         .build())
 }
 
@@ -178,6 +180,7 @@ fn build_emulation_option(
 #[magnus::wrap(class = "Wreq::Client", free_immediately)]
 struct Client {
     inner: wreq::Client,
+    cancel_token: std::sync::Mutex<CancellationToken>,
 }
 
 impl Client {
@@ -189,9 +192,16 @@ impl Client {
             Some(RHash::try_convert(args[0])?)
         };
 
-        let mut builder = wreq::Client::builder();
+        let mut builder = wreq::Client::builder()
+            .retry(wreq::retry::Policy::never());
 
         if let Some(opts) = opts {
+            // Apply header_order BEFORE emulation so the user's ordering takes precedence
+            if let Some(ary) = hash_get_array(&opts, "header_order")? {
+                let orig = array_to_orig_header_map(ary)?;
+                builder = builder.orig_headers(orig);
+            }
+
             if let Some(val) = hash_get_value(&opts, "emulation")? {
                 let ruby = unsafe { Ruby::get_unchecked() };
                 if val.is_kind_of(ruby.class_false_class()) {
@@ -267,11 +277,11 @@ impl Client {
             }
 
             if let Some(v) = hash_get_bool(&opts, "verify_host")? {
-                builder = builder.verify_hostname(v);
+                builder = builder.tls_verify_hostname(v);
             }
 
             if let Some(v) = hash_get_bool(&opts, "verify_cert")? {
-                builder = builder.cert_verification(v);
+                builder = builder.tls_cert_verification(v);
             }
 
             if let Some(true) = hash_get_bool(&opts, "http1_only")? {
@@ -293,12 +303,50 @@ impl Client {
             if let Some(v) = hash_get_bool(&opts, "zstd")? {
                 builder = builder.zstd(v);
             }
+
+            if let Some(v) = hash_get_bool(&opts, "referer")? {
+                builder = builder.referer(v);
+            }
+
+            if let Some(n) = hash_get_usize(&opts, "pool_max_idle_per_host")? {
+                builder = builder.pool_max_idle_per_host(n);
+            }
+
+            if let Some(n) = hash_get_usize(&opts, "pool_max_size")? {
+                builder = builder.pool_max_size(n);
+            }
+
+            if let Some(v) = hash_get_bool(&opts, "tcp_nodelay")? {
+                builder = builder.tcp_nodelay(v);
+            }
+
+            if let Some(t) = hash_get_float(&opts, "tcp_keepalive")? {
+                builder = builder.tcp_keepalive(Duration::from_secs_f64(t));
+            }
+
+            if let Some(addr_str) = hash_get_string(&opts, "local_address")? {
+                let addr: IpAddr = addr_str.parse()
+                    .map_err(|_| generic_error(format!("invalid IP address: '{}'", addr_str)))?;
+                builder = builder.local_address(addr);
+            }
+
+            if let Some(v) = hash_get_bool(&opts, "tls_sni")? {
+                builder = builder.tls_sni(v);
+            }
+
+            if let Some(s) = hash_get_string(&opts, "min_tls_version")? {
+                builder = builder.tls_min_version(parse_tls_version(&s)?);
+            }
+
+            if let Some(s) = hash_get_string(&opts, "max_tls_version")? {
+                builder = builder.tls_max_version(parse_tls_version(&s)?);
+            }
         } else {
             builder = builder.emulation(DEFAULT_EMULATION);
         }
 
         let client = builder.build().map_err(to_magnus_error)?;
-        Ok(Client { inner: client })
+        Ok(Client { inner: client, cancel_token: std::sync::Mutex::new(CancellationToken::new()) })
     }
 
     /// client.get(url) or client.get(url, opts)
@@ -330,6 +378,18 @@ impl Client {
         self.execute_method("OPTIONS", args)
     }
 
+    fn cancel(&self) {
+        // Replace the cancel token first so new requests use a fresh token,
+        // then cancel the old one to unblock all current in-flight select!s.
+        let old_token = {
+            let mut guard = self.cancel_token.lock().unwrap_or_else(|e| e.into_inner());
+            let old = guard.clone();
+            *guard = CancellationToken::new();
+            old
+        };
+        old_token.cancel();
+    }
+
     fn execute_method(&self, method_str: &str, args: &[Value]) -> Result<Response, magnus::Error> {
         let url: String = if args.is_empty() {
             return Err(generic_error("url is required"));
@@ -353,13 +413,16 @@ impl Client {
             req = apply_request_options(req, &opts)?;
         }
 
+        let client_token = self.cancel_token.lock().unwrap_or_else(|e| e.into_inner()).clone();
+
         // Release the GVL so other Ruby threads can run during I/O.
         let outcome: RequestOutcome = unsafe {
-            without_gvl(|cancel| {
+            without_gvl(|thread_token| {
                 runtime().block_on(async {
                     tokio::select! {
                         biased;
-                        _ = cancel.cancelled() => RequestOutcome::Interrupted,
+                        _ = thread_token.cancelled() => RequestOutcome::Interrupted,
+                        _ = client_token.cancelled() => RequestOutcome::Interrupted,
                         res = execute_request(req) => match res {
                             Ok(data) => RequestOutcome::Ok(data),
                             Err(e) => RequestOutcome::Err(e),
@@ -382,6 +445,21 @@ fn apply_request_options(
     mut req: wreq::RequestBuilder,
     opts: &RHash,
 ) -> Result<wreq::RequestBuilder, magnus::Error> {
+    if let Some(val) = hash_get_value(opts, "emulation")? {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        if val.is_kind_of(ruby.class_false_class()) {
+            // emulation: false — no per-request emulation override
+        } else if val.is_kind_of(ruby.class_true_class()) {
+            let opt = build_emulation_option(DEFAULT_EMULATION, opts)?;
+            req = req.emulation(opt);
+        } else {
+            let name: String = TryConvert::try_convert(val)?;
+            let emu = parse_emulation(&name)?;
+            let opt = build_emulation_option(emu, opts)?;
+            req = req.emulation(opt);
+        }
+    }
+
     if let Some(hdr_hash) = hash_get_hash(opts, "headers")? {
         let hmap = hash_to_header_map(&hdr_hash)?;
         req = req.headers(hmap);
@@ -436,21 +514,6 @@ fn apply_request_options(
         req = req.proxy(proxy);
     }
 
-    if let Some(val) = hash_get_value(opts, "emulation")? {
-        let ruby = unsafe { Ruby::get_unchecked() };
-        if val.is_kind_of(ruby.class_false_class()) {
-            // emulation: false — no per-request emulation override
-        } else if val.is_kind_of(ruby.class_true_class()) {
-            let opt = build_emulation_option(DEFAULT_EMULATION, opts)?;
-            req = req.emulation(opt);
-        } else {
-            let name: String = TryConvert::try_convert(val)?;
-            let emu = parse_emulation(&name)?;
-            let opt = build_emulation_option(emu, opts)?;
-            req = req.emulation(opt);
-        }
-    }
-
     Ok(req)
 }
 
@@ -529,6 +592,25 @@ fn hash_get_bool(hash: &RHash, key: &str) -> Result<Option<bool>, magnus::Error>
     }
 }
 
+fn hash_get_usize(hash: &RHash, key: &str) -> Result<Option<usize>, magnus::Error> {
+    match hash_get_value(hash, key)? {
+        Some(v) => Ok(Some(TryConvert::try_convert(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn parse_tls_version(s: &str) -> Result<TlsVersion, magnus::Error> {
+    match s {
+        "tls1.0" | "tls_1_0" | "1.0" => Ok(TlsVersion::TLS_1_0),
+        "tls1.1" | "tls_1_1" | "1.1" => Ok(TlsVersion::TLS_1_1),
+        "tls1.2" | "tls_1_2" | "1.2" => Ok(TlsVersion::TLS_1_2),
+        "tls1.3" | "tls_1_3" | "1.3" => Ok(TlsVersion::TLS_1_3),
+        _ => Err(generic_error(format!(
+            "unknown TLS version '{}'. Use: 'tls1.2', 'tls1.3'", s
+        ))),
+    }
+}
+
 fn hash_get_hash(hash: &RHash, key: &str) -> Result<Option<RHash>, magnus::Error> {
     match hash_get_value(hash, key)? {
         Some(v) => Ok(Some(RHash::try_convert(v)?)),
@@ -536,6 +618,27 @@ fn hash_get_hash(hash: &RHash, key: &str) -> Result<Option<RHash>, magnus::Error
     }
 }
 
+fn hash_get_array(hash: &RHash, key: &str) -> Result<Option<RArray>, magnus::Error> {
+    match hash_get_value(hash, key)? {
+        Some(v) => Ok(Some(RArray::try_convert(v)?)),
+        None => Ok(None),
+    }
+}
+
+fn array_to_orig_header_map(ary: RArray) -> Result<OrigHeaderMap, magnus::Error> {
+    let mut orig = OrigHeaderMap::with_capacity(ary.len());
+    for elem in ary.into_iter() {
+        let ruby = unsafe { Ruby::get_unchecked() };
+        let name_str: String = if elem.is_kind_of(ruby.class_symbol()) {
+            elem.funcall("to_s", ())?  
+        } else {
+            TryConvert::try_convert(elem)?
+        };
+        orig.insert(name_str);
+    }
+    Ok(orig)
+}
+
 fn hash_to_header_map(hash: &RHash) -> Result<HeaderMap, magnus::Error> {
     let mut hmap = HeaderMap::new();
     hash.foreach(|k: Value, v: Value| {
@@ -589,6 +692,7 @@ pub fn init(_ruby: &magnus::Ruby, module: &magnus::RModule) -> Result<(), magnus
     client_class.define_method("delete", method!(Client::delete, -1))?;
     client_class.define_method("head", method!(Client::head, -1))?;
     client_class.define_method("options", method!(Client::options, -1))?;
+    client_class.define_method("cancel", method!(Client::cancel, 0))?;
 
     module.define_module_function("get", function!(wreq_get, -1))?;
     module.define_module_function("post", function!(wreq_post, -1))?;

data/lib/wreq-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wreq
-  VERSION = "0.4.0"
+  VERSION = "0.5.1"
 end

data/patches/0001-add-transfer-size-tracking.patch

@@ -1,60 +1,51 @@
-diff --git a/src/client/http.rs b/src/client/http.rs
-index 10be0c83..462c77d0 100644
---- a/src/client/http.rs
-+++ b/src/client/http.rs
-@@ -33,6 +33,7 @@ use self::future::Pending;
-     feature = "deflate",
- ))]
- use super::layer::decoder::{AcceptEncoding, DecompressionLayer};
-+use super::layer::transfer_size::{CountingBody, TransferSizeLayer, TransferSizeService};
- #[cfg(feature = "ws")]
- use super::ws::WebSocketRequestBuilder;
- use super::{
-@@ -104,7 +105,7 @@ type Decompression<T> = super::layer::decoder::Decompression<T>;
-     feature = "brotli",
-     feature = "deflate"
- ))]
--type ResponseBody = TimeoutBody<tower_http::decompression::DecompressionBody<Incoming>>;
-+type ResponseBody = TimeoutBody<tower_http::decompression::DecompressionBody<CountingBody<Incoming>>>;
+diff --git a/src/client.rs b/src/client.rs
+index 4abe25d8..76e709a8 100644
+--- a/src/client.rs
++++ b/src/client.rs
+@@ -49,6 +49,7 @@ use self::{
+         redirect::{FollowRedirect, FollowRedirectLayer},
+         retry::RetryPolicy,
+         timeout::{Timeout, TimeoutLayer, TimeoutOptions, body::TimeoutBody},
++        transfer_size::{CountingBody, TransferSizeLayer, TransferSizeService},
+     },
+     request::{Request, RequestBuilder},
+     response::Response,
+@@ -115,25 +116,30 @@ type MaybeDecompressionBody<T> = tower_http::decompression::DecompressionBody<T>
+ type ClientService = Timeout<
+     ConfigService<
+         MaybeDecompression<
+-            Retry<RetryPolicy, FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>>,
++            TransferSizeService<
++                Retry<
++                    RetryPolicy,
++                    FollowRedirect<HttpClient<Connector, Body>, FollowRedirectPolicy>,
++                >,
++            >,
+         >,
+     >,
+ >;
  
- /// Response body type with timeout only (no compression features).
- #[cfg(not(any(
-@@ -113,23 +114,25 @@ type ResponseBody = TimeoutBody<tower_http::decompression::DecompressionBody<Inc
-     feature = "brotli",
-     feature = "deflate"
- )))]
--type ResponseBody = TimeoutBody<Incoming>;
-+type ResponseBody = TimeoutBody<CountingBody<Incoming>>;
+ type BoxedClientService = BoxCloneSyncService<
+     http::Request<Body>,
+-    http::Response<TimeoutBody<MaybeDecompressionBody<Incoming>>>,
++    http::Response<TimeoutBody<MaybeDecompressionBody<CountingBody<Incoming>>>>,
+     BoxError,
+ >;
  
- /// The complete HTTP client service stack with all middleware layers.
- type ClientService = Timeout<
-     ResponseBodyTimeout<
-         ConfigService<
-             Decompression<
--                Retry<
--                    RetryPolicy,
--                    FollowRedirect<
--                        CookieService<
--                            MapErr<
--                                HttpClient<Connector, Body>,
--                                fn(client::error::Error) -> BoxError,
-+                TransferSizeService<
-+                    Retry<
-+                        RetryPolicy,
-+                        FollowRedirect<
-+                            CookieService<
-+                                MapErr<
-+                                    HttpClient<Connector, Body>,
-+                                    fn(client::error::Error) -> BoxError,
-+                                >,
-                             >,
-+                            FollowRedirectPolicy,
-                         >,
--                        FollowRedirectPolicy,
-                     >,
-                 >,
-             >,
-@@ -582,6 +585,10 @@ impl ClientBuilder {
+ type BoxedClientServiceLayer = BoxCloneSyncServiceLayer<
+     BoxCloneSyncService<
+         http::Request<Body>,
+-        http::Response<MaybeDecompressionBody<Incoming>>,
++        http::Response<MaybeDecompressionBody<CountingBody<Incoming>>>,
+         BoxError,
+     >,
+     http::Request<Body>,
+-    http::Response<MaybeDecompressionBody<Incoming>>,
++    http::Response<MaybeDecompressionBody<CountingBody<Incoming>>>,
+     BoxError,
+ >;
+ 
+@@ -593,6 +599,10 @@ impl ClientBuilder {
                  })
                  .service(service);
  
@@ -65,18 +56,36 @@ index 10be0c83..462c77d0 100644
              #[cfg(any(
                  feature = "gzip",
                  feature = "zstd",
+@@ -1585,7 +1595,7 @@ impl ClientBuilder {
+         L: Layer<
+                 BoxCloneSyncService<
+                     http::Request<Body>,
+-                    http::Response<MaybeDecompressionBody<Incoming>>,
++                    http::Response<MaybeDecompressionBody<CountingBody<Incoming>>>,
+                     BoxError,
+                 >,
+             > + Clone
+@@ -1594,7 +1604,7 @@ impl ClientBuilder {
+             + 'static,
+         L::Service: Service<
+                 http::Request<Body>,
+-                Response = http::Response<MaybeDecompressionBody<Incoming>>,
++                Response = http::Response<MaybeDecompressionBody<CountingBody<Incoming>>>,
+                 Error = BoxError,
+             > + Clone
+             + Send
 diff --git a/src/client/layer.rs b/src/client/layer.rs
-index 05bb533f..cb0b0866 100644
+index 5c03ef4d..fe37cff0 100644
 --- a/src/client/layer.rs
 +++ b/src/client/layer.rs
-@@ -13,3 +13,4 @@ pub mod decoder;
+@@ -12,3 +12,4 @@ pub mod decoder;
  pub mod redirect;
  pub mod retry;
  pub mod timeout;
 +pub mod transfer_size;
 diff --git a/src/client/layer/transfer_size.rs b/src/client/layer/transfer_size.rs
 new file mode 100644
-index 00000000..7e8a4390
+index 00000000..f155ec8d
 --- /dev/null
 +++ b/src/client/layer/transfer_size.rs
 @@ -0,0 +1,176 @@
@@ -91,8 +100,8 @@ index 00000000..7e8a4390
 +use std::{
 +    pin::Pin,
 +    sync::{
-+        atomic::{AtomicU64, Ordering},
 +        Arc,
++        atomic::{AtomicU64, Ordering},
 +    },
 +    task::{Context, Poll},
 +};
@@ -257,18 +266,18 @@ index 00000000..7e8a4390
 +    }
 +}
 diff --git a/src/client/response.rs b/src/client/response.rs
-index d98859b9..16ed35c3 100644
+index 3d3532af..ed478804 100644
 --- a/src/client/response.rs
 +++ b/src/client/response.rs
-@@ -20,6 +20,7 @@ use serde::de::DeserializeOwned;
- use super::{
-     conn::HttpInfo,
-     core::{ext::ReasonPhrase, upgrade},
-+    layer::transfer_size::TransferSizeHandle,
- };
+@@ -18,6 +18,7 @@ use mime::Mime;
+ use serde::de::DeserializeOwned;
+ use wreq_proto::ext::ReasonPhrase;
+ 
++use super::layer::transfer_size::TransferSizeHandle;
  #[cfg(feature = "cookies")]
  use crate::cookie;
-@@ -91,6 +92,21 @@ impl Response {
+ use crate::{
+@@ -97,6 +98,21 @@ impl Response {
          HttpBody::size_hint(self.res.body()).exact()
      }