wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/header.rs

@@ -1,13 +1,14 @@
 //! HTTP header types
 //!
-//! This module provides [`HeaderName`], [`HeaderMap`], [`OrigHeaderMap`], [`OrigHeaderName`], and a
+//! This module provides [`HeaderName`], [`HeaderMap`], [`OrigHeaderMap`], [`HeaderCaseName`], and a
 //! number of types used for interacting with `HeaderMap`. These types allow representing both
 //! HTTP/1 and HTTP/2 headers.
 
+use bytes::Bytes;
 pub use http::header::*;
-pub use name::OrigHeaderName;
+use wreq_proto::ext::OnPreserveHeaderCallback;
 
-/// Trait for types that can be converted into an [`OrigHeaderName`] (case-preserved header).
+/// Trait for types that can be converted into an [`HeaderCaseName`] (case-preserved header).
 ///
 /// This trait is sealed, so only known types can implement it.
 /// Supported types:
@@ -16,11 +17,11 @@ pub use name::OrigHeaderName;
 /// - `Bytes`
 /// - `HeaderName`
 /// - `&HeaderName`
-/// - `OrigHeaderName`
-/// - `&OrigHeaderName`
-pub trait IntoOrigHeaderName: sealed::Sealed {
-    /// Converts the type into an [`OrigHeaderName`].
-    fn into_orig_header_name(self) -> OrigHeaderName;
+/// - `HeaderCaseName`
+/// - `&HeaderCaseName`
+pub trait IntoHeaderCaseName: sealed::Sealed {
+    /// Converts the type into an [`HeaderCaseName`].
+    fn into_header_case_name(self) -> HeaderCaseName;
 }
 
 /// A map from header names to their original casing as received in an HTTP message.
@@ -29,8 +30,8 @@ pub trait IntoOrigHeaderName: sealed::Sealed {
 /// in the request or response, but also maintains the insertion order of headers. This makes
 /// it suitable for use cases where the order of headers matters, such as HTTP/1.x message
 /// serialization, proxying, or reproducing requests/responses exactly as received.
-#[derive(Debug, Clone, Default)]
-pub struct OrigHeaderMap(HeaderMap<OrigHeaderName>);
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct OrigHeaderMap(HeaderMap<HeaderCaseName>);
 
 // ===== impl OrigHeaderMap =====
 
@@ -59,16 +60,14 @@ impl OrigHeaderMap {
     #[inline]
     pub fn insert<N>(&mut self, orig: N) -> bool
     where
-        N: IntoOrigHeaderName,
+        N: IntoHeaderCaseName,
     {
-        let orig_header_name = orig.into_orig_header_name();
-        match &orig_header_name.kind {
-            name::Kind::Cased(bytes) => HeaderName::from_bytes(bytes)
-                .map(|name| self.0.append(name, orig_header_name))
+        let header_case_name = orig.into_header_case_name();
+        match &header_case_name.inner {
+            Repr::Cased(bytes) => HeaderName::from_bytes(bytes)
+                .map(|header_name| self.0.append(header_name, header_case_name))
                 .unwrap_or(false),
-            name::Kind::Standard(header_name) => {
-                self.0.append(header_name.clone(), orig_header_name)
-            }
+            Repr::Standard(header_name) => self.0.append(header_name.clone(), header_case_name),
         }
     }
 
@@ -96,15 +95,13 @@ impl OrigHeaderMap {
 
     /// Returns an iterator over all header names and their original spellings, in insertion order.
     #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = (&HeaderName, &OrigHeaderName)> {
+    pub fn iter(&self) -> impl Iterator<Item = (&HeaderName, &HeaderCaseName)> {
         self.0.iter()
     }
 }
 
-impl OrigHeaderMap {
-    /// Sorts headers by this map, preserving original casing.
-    /// Headers in the map come first, others follow.
-    pub(crate) fn sort_headers(&self, headers: &mut HeaderMap) {
+impl OnPreserveHeaderCallback for OrigHeaderMap {
+    fn call(&self, headers: &mut HeaderMap) {
         if headers.len() <= 1 || self.0.is_empty() {
             return;
         }
@@ -138,31 +135,30 @@ impl OrigHeaderMap {
         std::mem::swap(headers, &mut sorted_headers);
     }
 
-    /// Calls the given function for each header in this map's order, preserving original casing.
-    /// Headers in the map are processed first, others follow.
-    pub(crate) fn sort_headers_for_each<F>(&self, headers: &mut HeaderMap, mut dst: F)
-    where
-        F: FnMut(&[u8], &HeaderValue),
-    {
+    fn call_visit(
+        &self,
+        headers: &mut HeaderMap,
+        dst: &mut dyn FnMut(&dyn AsRef<[u8]>, &http::HeaderValue),
+    ) {
         // First, sort headers according to the order defined in this map
-        for (name, orig_name) in self.iter() {
+        for (name, case_name) in self.iter() {
             for value in headers.get_all(name) {
-                dst(orig_name.as_ref(), value);
+                dst(case_name, value);
             }
 
             headers.remove(name);
         }
 
         // After processing all ordered headers, append any remaining headers
-        let mut prev_name: Option<OrigHeaderName> = None;
+        let mut prev_name: Option<HeaderCaseName> = None;
         for (name, value) in headers.drain() {
             match (name, &prev_name) {
                 (Some(name), _) => {
-                    dst(name.as_ref(), &value);
-                    prev_name.replace(name.into_orig_header_name());
+                    dst(&name, &value);
+                    prev_name.replace(name.into_header_case_name());
                 }
                 (None, Some(prev_name)) => {
-                    dst(prev_name.as_ref(), &value);
+                    dst(prev_name, &value);
                 }
                 _ => (),
             };
@@ -171,8 +167,8 @@ impl OrigHeaderMap {
 }
 
 impl<'a> IntoIterator for &'a OrigHeaderMap {
-    type Item = (&'a HeaderName, &'a OrigHeaderName);
-    type IntoIter = <&'a HeaderMap<OrigHeaderName> as IntoIterator>::IntoIter;
+    type Item = (&'a HeaderName, &'a HeaderCaseName);
+    type IntoIter = <&'a HeaderMap<HeaderCaseName> as IntoIterator>::IntoIter;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
@@ -181,8 +177,8 @@ impl<'a> IntoIterator for &'a OrigHeaderMap {
 }
 
 impl IntoIterator for OrigHeaderMap {
-    type Item = (Option<HeaderName>, OrigHeaderName);
-    type IntoIter = <HeaderMap<OrigHeaderName> as IntoIterator>::IntoIter;
+    type Item = (Option<HeaderName>, HeaderCaseName);
+    type IntoIter = <HeaderMap<HeaderCaseName> as IntoIterator>::IntoIter;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
@@ -192,94 +188,85 @@ impl IntoIterator for OrigHeaderMap {
 
 impl_request_config_value!(OrigHeaderMap);
 
-mod name {
-    use bytes::Bytes;
-    use http::HeaderName;
-
-    use super::IntoOrigHeaderName;
-
-    /// An HTTP header name with both normalized and original casing.
-    ///
-    /// While HTTP headers are case-insensitive, this type stores both
-    /// the canonical `HeaderName` and the original casing as received,
-    /// useful for preserving header order and formatting in proxies,
-    /// debugging, or exact HTTP message reproduction.
-    #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct OrigHeaderName {
-        pub(super) kind: Kind,
-    }
+/// An HTTP header name with both normalized and original casing.
+///
+/// While HTTP headers are case-insensitive, this type stores both
+/// the canonical [`HeaderName`] and the original casing as received,
+/// useful for preserving header order and formatting in proxies,
+/// debugging, or exact HTTP message reproduction.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct HeaderCaseName {
+    inner: Repr,
+}
 
-    #[derive(Debug, Clone, PartialEq, Eq)]
-    pub(super) enum Kind {
-        /// The original casing of the header name as received.
-        Cased(Bytes),
-        /// The canonical (normalized, lowercased) header name.
-        Standard(HeaderName),
-    }
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+enum Repr {
+    Cased(Bytes),
+    Standard(HeaderName),
+}
 
-    impl AsRef<[u8]> for OrigHeaderName {
-        #[inline]
-        fn as_ref(&self) -> &[u8] {
-            match &self.kind {
-                Kind::Standard(name) => name.as_ref(),
-                Kind::Cased(orig) => orig.as_ref(),
-            }
+impl AsRef<[u8]> for HeaderCaseName {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        match &self.inner {
+            Repr::Standard(name) => name.as_ref(),
+            Repr::Cased(orig) => orig.as_ref(),
         }
     }
+}
 
-    impl IntoOrigHeaderName for &'static str {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            Bytes::from_static(self.as_bytes()).into_orig_header_name()
-        }
+impl IntoHeaderCaseName for &'static str {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        Bytes::from_static(self.as_bytes()).into_header_case_name()
     }
+}
 
-    impl IntoOrigHeaderName for String {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            Bytes::from(self).into_orig_header_name()
-        }
+impl IntoHeaderCaseName for String {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        Bytes::from(self).into_header_case_name()
     }
+}
 
-    impl IntoOrigHeaderName for Bytes {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            OrigHeaderName {
-                kind: Kind::Cased(self),
-            }
+impl IntoHeaderCaseName for Bytes {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        HeaderCaseName {
+            inner: Repr::Cased(self),
         }
     }
+}
 
-    impl IntoOrigHeaderName for &HeaderName {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            OrigHeaderName {
-                kind: Kind::Standard(self.clone()),
-            }
+impl IntoHeaderCaseName for &HeaderName {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        HeaderCaseName {
+            inner: Repr::Standard(self.clone()),
         }
     }
+}
 
-    impl IntoOrigHeaderName for HeaderName {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            OrigHeaderName {
-                kind: Kind::Standard(self),
-            }
+impl IntoHeaderCaseName for HeaderName {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        HeaderCaseName {
+            inner: Repr::Standard(self),
         }
     }
+}
 
-    impl IntoOrigHeaderName for OrigHeaderName {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            self
-        }
+impl IntoHeaderCaseName for HeaderCaseName {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        self
     }
+}
 
-    impl IntoOrigHeaderName for &OrigHeaderName {
-        #[inline]
-        fn into_orig_header_name(self) -> OrigHeaderName {
-            self.clone()
-        }
+impl IntoHeaderCaseName for &HeaderCaseName {
+    #[inline]
+    fn into_header_case_name(self) -> HeaderCaseName {
+        self.clone()
     }
 }
 
@@ -288,7 +275,7 @@ mod sealed {
     use bytes::Bytes;
     use http::HeaderName;
 
-    use crate::header::OrigHeaderName;
+    use crate::header::HeaderCaseName;
 
     pub trait Sealed {}
 
@@ -297,13 +284,14 @@ mod sealed {
     impl Sealed for Bytes {}
     impl Sealed for &HeaderName {}
     impl Sealed for HeaderName {}
-    impl Sealed for &OrigHeaderName {}
-    impl Sealed for OrigHeaderName {}
+    impl Sealed for &HeaderCaseName {}
+    impl Sealed for HeaderCaseName {}
 }
 
 #[cfg(test)]
 mod test {
     use http::{HeaderMap, HeaderName, HeaderValue};
+    use wreq_proto::ext::OnPreserveHeaderCallback;
 
     use super::OrigHeaderMap;
 
@@ -415,7 +403,7 @@ mod test {
             .collect();
 
         // Sort headers according to orig_headers order
-        orig_headers.sort_headers(&mut headers);
+        orig_headers.call(&mut headers);
 
         // Verify all cookie values are preserved
         let sorted_cookies: Vec<_> = headers
@@ -479,7 +467,7 @@ mod test {
 
         let total_before = headers.len();
 
-        orig_headers.sort_headers(&mut headers);
+        orig_headers.call(&mut headers);
 
         // Verify all values preserved
         assert_eq!(

data/vendor/wreq/src/lib.rs

@@ -1,88 +1,30 @@
 #![deny(unused)]
 #![deny(unsafe_code)]
 #![deny(missing_docs)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(test, deny(warnings))]
-#![cfg_attr(not(test), warn(unused_crate_dependencies))]
 
 //! # wreq
 //!
-//! An ergonomic all-in-one HTTP client for browser emulation with TLS, JA3/JA4, and HTTP/2
-//! fingerprints.
+//! An ergonomic and modular Rust HTTP Client for high-fidelity protocol matching, featuring
+//! customizable TLS, JA3/JA4, and HTTP/2 signature capabilities.
 //!
 //! - Plain bodies, [JSON](#json), [urlencoded](#forms), [multipart]
-//! - Cookies Store
+//! - HTTP Trailer
+//! - Cookie Store
 //! - [Redirect Policy](#redirect-policies)
 //! - Original Header
 //! - Rotating [Proxies](#proxies)
-//! - [Certificate Store](#certificate-store)
 //! - [Tower](https://docs.rs/tower/latest/tower) Middleware
 //! - [WebSocket](#websocket) Upgrade
 //! - HTTPS via [BoringSSL](#tls)
-//! - HTTP/2 over TLS [Emulation](#emulation)
+//! - HTTP/2 over TLS Parity
+//! - [Certificate Store (CAs & mTLS)](#certificate-store)
 //!
 //! Additional learning resources include:
 //!
 //! - [The Rust Cookbook](https://doc.rust-lang.org/stable/book/ch00-00-introduction.html)
 //! - [Repository Examples](https://github.com/0x676e67/wreq/tree/main/examples)
 //!
-//! ## Emulation
-//!
-//! The `emulation` module provides a way to simulate various browser TLS/HTTP2 fingerprints.
-//!
-//! ```rust,no_run
-//! use wreq_util::Emulation;
-//!
-//! #[tokio::main]
-//! async fn main() -> wreq::Result<()> {
-//!     // Use the API you're already familiar with
-//!     let resp = wreq::get("https://tls.peet.ws/api/all")
-//!         .emulation(Emulation::Firefox136)
-//!         .send().await?;
-//!     println!("{}", resp.text().await?);
-//!
-//!     Ok(())
-//! }
-//! ```
-//!
-//! ## Websocket
-//!
-//! The `websocket` module provides a way to upgrade a connection to a websocket.
-//!
-//! ```rust,no_run
-//! use futures_util::{SinkExt, StreamExt, TryStreamExt};
-//! use wreq::{header, ws::message::Message};
-//!
-//! #[tokio::main]
-//! async fn main() -> wreq::Result<()> {
-//!     // Use the API you're already familiar with
-//!     let websocket = wreq::websocket("wss://echo.websocket.org")
-//!         .header(header::USER_AGENT, env!("CARGO_PKG_NAME"))
-//!         .send()
-//!         .await?;
-//!
-//!     assert_eq!(websocket.version(), http::Version::HTTP_11);
-//!
-//!     let (mut tx, mut rx) = websocket.into_websocket().await?.split();
-//!
-//!     tokio::spawn(async move {
-//!         for i in 1..11 {
-//!             if let Err(err) = tx.send(Message::text(format!("Hello, World! {i}"))).await {
-//!                 eprintln!("failed to send message: {err}");
-//!             }
-//!         }
-//!     });
-//!
-//!     while let Some(message) = rx.try_next().await? {
-//!         if let Message::Text(text) = message {
-//!             println!("received: {text}");
-//!         }
-//!     }
-//!
-//!     Ok(())
-//! }
-//! ```
-//!
 //! ## Making a GET request
 //!
 //! Making a GET request is simple.
@@ -179,6 +121,44 @@
 //! # }
 //! ```
 //!
+//! ## Websocket
+//!
+//! The `websocket` module provides a way to upgrade a connection to a websocket.
+//!
+//! ```rust,no_run
+//! use futures_util::{SinkExt, StreamExt, TryStreamExt};
+//! use wreq::{header, ws::message::Message};
+//!
+//! #[tokio::main]
+//! async fn main() -> wreq::Result<()> {
+//!     // Use the API you're already familiar with
+//!     let websocket = wreq::websocket("wss://echo.websocket.org")
+//!         .header(header::USER_AGENT, env!("CARGO_PKG_NAME"))
+//!         .send()
+//!         .await?;
+//!
+//!     assert_eq!(websocket.version(), http::Version::HTTP_11);
+//!
+//!     let (mut tx, mut rx) = websocket.into_websocket().await?.split();
+//!
+//!     tokio::spawn(async move {
+//!         for i in 1..11 {
+//!             if let Err(err) = tx.send(Message::text(format!("Hello, World! {i}"))).await {
+//!                 eprintln!("failed to send message: {err}");
+//!             }
+//!         }
+//!     });
+//!
+//!     while let Some(message) = rx.try_next().await? {
+//!         if let Message::Text(text) = message {
+//!             println!("received: {text}");
+//!         }
+//!     }
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
 //! ## Redirect Policies
 //!
 //! By default, the client does not handle HTTP redirects.
@@ -258,7 +238,7 @@
 //! - **webpki-roots** *(enabled by default)*: Use the webpki-roots crate for root certificates.
 //! - **system-proxy**: Enable system proxy support.
 //! - **tracing**: Enable tracing logging support.
-//! - **prefix-symbols**: Prefix BoringSSL symbols to avoid linker conflicts.
+//! - **prefix-symbols**: Prefix BoringSSL symbols to avoid OpenSSL conflicts.
 //!
 //! [client]: ./struct.Client.html
 //! [response]: ./struct.Response.html
@@ -269,16 +249,66 @@
 //! [Proxy]: ./struct.Proxy.html
 //! [cargo-features]: https://doc.rust-lang.org/stable/cargo/reference/manifest.html#the-features-section
 
+macro_rules! if_tokio_rt {
+    (block: { $($tt:tt)* }) => {
+        #[cfg(all(feature = "tokio-rt", not(feature = "compio-rt")))]
+        $($tt)*
+    };
+    ($($item:item)*) => {$(
+        #[cfg(all(feature = "tokio-rt", not(feature = "compio-rt")))]
+        $item
+    )*};
+}
+
+macro_rules! if_compio_rt {
+    (block: { $($tt:tt)* }) => {
+        #[cfg(all(feature = "compio-rt", not(feature = "tokio-rt")))]
+        $($tt)*
+    };
+    ($($item:item)*) => {$(
+        #[cfg(all(feature = "compio-rt", not(feature = "tokio-rt")))]
+        $item
+    )*};
+}
+
+macro_rules! if_all_rt {
+    (block: { $($tt:tt)* }) => {
+        #[cfg(all(feature = "tokio-rt", feature = "compio-rt"))]
+        $($tt)*
+    };
+    ($($item:item)*) => {$(
+        #[cfg(all(feature = "tokio-rt", feature = "compio-rt"))]
+        $item
+    )*};
+}
+
+macro_rules! if_any_rt {
+    ($($item:item)*) => {$(
+        #[cfg(any(feature = "tokio-rt", feature = "compio-rt"))]
+        $item
+    )*};
+}
+
+macro_rules! if_no_rt {
+    (block: { $($tt:tt)* }) => {
+        #[cfg(not(any(feature = "tokio-rt", feature = "compio-rt")))]
+        $($tt)*
+    };
+}
+
 #[macro_use]
 mod trace;
 #[macro_use]
+mod ext;
+#[macro_use]
 mod config;
 mod client;
+mod conn;
 mod error;
-mod ext;
-mod hash;
+mod group;
 mod into_uri;
 mod proxy;
+mod rt;
 mod sync;
 mod util;
 
@@ -290,25 +320,46 @@ pub mod redirect;
 pub mod retry;
 pub mod tls;
 
-pub use http::{Method, StatusCode, Uri, Version};
-#[cfg(unix)]
-use libc as _;
-
 #[cfg(feature = "multipart")]
 pub use self::client::multipart;
 #[cfg(feature = "ws")]
 pub use self::client::ws;
 pub use self::{
     client::{
-        Body, Client, ClientBuilder, Emulation, EmulationBuilder, EmulationFactory, Request,
-        RequestBuilder, Response, Upgraded, http1, http2,
+        Client, ClientBuilder,
+        body::Body,
+        emulate::{Emulation, EmulationBuilder, IntoEmulation},
+        request::{Request, RequestBuilder},
+        response::Response,
+        upgrade::Upgraded,
     },
     error::{Error, Result},
     ext::{ResponseBuilderExt, ResponseExt},
+    group::Group,
     into_uri::IntoUri,
     proxy::{NoProxy, Proxy},
 };
 
+pub mod http1 {
+    //! HTTP/1 protocol implementation and utilities.
+
+    pub use wreq_proto::http1::{Http1Options, Http1OptionsBuilder};
+}
+
+pub mod http2 {
+    //! HTTP/2 protocol implementation and utilities.
+
+    pub use http2::frame::{
+        Priorities, PrioritiesBuilder, Priority, PseudoId, PseudoOrder, Setting, SettingId,
+        SettingsOrder, SettingsOrderBuilder, StreamDependency, StreamId,
+    };
+    pub use wreq_proto::http2::{Http2Options, Http2OptionsBuilder};
+}
+
+pub use http::{Method, StatusCode, Uri, Version};
+#[cfg(unix)]
+use libc as _;
+
 fn _assert_impls() {
     fn assert_send<T: Send>() {}
     fn assert_sync<T: Sync>() {}

data/vendor/wreq/src/proxy.rs

@@ -511,32 +511,18 @@ mod tests {
             .custom_http_headers(headers.clone())
             .into_matcher();
 
-        match m.intercept(&uri).unwrap() {
-            Intercepted::Proxy(proxy) => {
-                let got_headers = proxy.custom_headers().unwrap();
-                assert_eq!(got_headers, &headers, "https forwards");
-            }
-            #[cfg(unix)]
-            _ => {
-                unreachable!("Expected a Proxy Intercepted");
-            }
-        }
+        let proxy = intercept(&m, &uri);
+        let got_headers = proxy.custom_headers().unwrap();
+        assert_eq!(got_headers, &headers, "https forwards");
 
         let m = Proxy::all("http://yo.local")
             .unwrap()
             .custom_http_headers(headers.clone())
             .into_matcher();
 
-        match m.intercept(&uri).unwrap() {
-            Intercepted::Proxy(proxy) => {
-                let got_headers = proxy.custom_headers().unwrap();
-                assert_eq!(got_headers, &headers, "http forwards");
-            }
-            #[cfg(unix)]
-            _ => {
-                unreachable!("Expected a Proxy Intercepted");
-            }
-        }
+        let proxy = intercept(&m, &uri);
+        let got_headers = proxy.custom_headers().unwrap();
+        assert_eq!(got_headers, &headers, "http forwards");
     }
 
     fn test_socks_proxy_default_port(uri: &str, url2: &str, port: u16) {

data/vendor/wreq/src/redirect.rs

@@ -11,7 +11,7 @@ use futures_util::FutureExt;
 use http::{HeaderMap, HeaderName, HeaderValue, StatusCode, Uri};
 
 use crate::{
-    client::{Body, layer::redirect},
+    client::{body::Body, layer::redirect},
     config::RequestConfig,
     error::{BoxError, Error},
     ext::UriExt,