wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/error.rs

@@ -1,8 +1,9 @@
 use std::{error::Error as StdError, fmt, io};
 
 use http::Uri;
+use wreq_proto::ext::ReasonPhrase;
 
-use crate::{StatusCode, client::ext::ReasonPhrase, util::Escape};
+use crate::{StatusCode, util::Escape};
 
 /// A `Result` alias where the `Err` case is `wreq::Error`.
 pub type Result<T> = std::result::Result<T, Error>;
@@ -25,8 +26,22 @@ struct Inner {
     uri: Option<Uri>,
 }
 
+#[derive(Debug)]
+enum Kind {
+    Builder,
+    Request,
+    Tls,
+    Redirect,
+    Status(StatusCode, Option<ReasonPhrase>),
+    Body,
+    Decode,
+    Upgrade,
+    #[cfg(feature = "ws")]
+    WebSocket,
+}
+
 impl Error {
-    pub(crate) fn new<E>(kind: Kind, source: Option<E>) -> Error
+    fn new<E>(kind: Kind, source: Option<E>) -> Error
     where
         E: Into<BoxError>,
     {
@@ -39,43 +54,53 @@ impl Error {
         }
     }
 
+    #[inline]
     pub(crate) fn builder<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::Builder, Some(e))
     }
 
+    #[inline]
     pub(crate) fn body<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::Body, Some(e))
     }
 
+    #[inline]
     pub(crate) fn tls<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::Tls, Some(e))
     }
 
+    #[inline]
     pub(crate) fn decode<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::Decode, Some(e))
     }
 
+    #[inline]
     pub(crate) fn request<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::Request, Some(e))
     }
 
+    #[inline]
     pub(crate) fn redirect<E: Into<BoxError>>(e: E, uri: Uri) -> Error {
         Error::new(Kind::Redirect, Some(e)).with_uri(uri)
     }
 
+    #[inline]
     pub(crate) fn upgrade<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::Upgrade, Some(e))
     }
 
+    #[inline]
     #[cfg(feature = "ws")]
     pub(crate) fn websocket<E: Into<BoxError>>(e: E) -> Error {
         Error::new(Kind::WebSocket, Some(e))
     }
 
+    #[inline]
     pub(crate) fn status_code(uri: Uri, status: StatusCode, reason: Option<ReasonPhrase>) -> Error {
         Error::new(Kind::Status(status, reason), None::<Error>).with_uri(uri)
     }
 
+    #[inline]
     pub(crate) fn uri_bad_scheme(uri: Uri) -> Error {
         Error::new(Kind::Builder, Some(BadScheme)).with_uri(uri)
     }
@@ -101,6 +126,7 @@ impl Error {
     /// }
     /// # }
     /// ```
+    #[inline]
     pub fn uri(&self) -> Option<&Uri> {
         self.inner.uri.as_ref()
     }
@@ -110,11 +136,13 @@ impl Error {
     /// This is useful if you need to remove sensitive information from the URI
     /// (e.g. an API key in the query), but do not want to remove the URI
     /// entirely.
+    #[inline]
     pub fn uri_mut(&mut self) -> Option<&mut Uri> {
         self.inner.uri.as_mut()
     }
 
     /// Add a uri related to this error (overwriting any existing)
+    #[inline]
     pub fn with_uri(mut self, uri: Uri) -> Self {
         self.inner.uri = Some(uri);
         self
@@ -122,22 +150,26 @@ impl Error {
 
     /// Strip the related uri from this error (if, for example, it contains
     /// sensitive information)
+    #[inline]
     pub fn without_uri(mut self) -> Self {
         self.inner.uri = None;
         self
     }
 
     /// Returns true if the error is from a type Builder.
+    #[inline]
     pub fn is_builder(&self) -> bool {
         matches!(self.inner.kind, Kind::Builder)
     }
 
     /// Returns true if the error is from a `RedirectPolicy`.
+    #[inline]
     pub fn is_redirect(&self) -> bool {
         matches!(self.inner.kind, Kind::Redirect)
     }
 
     /// Returns true if the error is from `Response::error_for_status`.
+    #[inline]
     pub fn is_status(&self) -> bool {
         matches!(self.inner.kind, Kind::Status(_, _))
     }
@@ -151,7 +183,7 @@ impl Error {
                 return true;
             }
 
-            if let Some(core_err) = err.downcast_ref::<crate::client::CoreError>() {
+            if let Some(core_err) = err.downcast_ref::<wreq_proto::Error>() {
                 if core_err.is_timeout() {
                     return true;
                 }
@@ -170,13 +202,14 @@ impl Error {
     }
 
     /// Returns true if the error is related to the request
+    #[inline]
     pub fn is_request(&self) -> bool {
         matches!(self.inner.kind, Kind::Request)
     }
 
     /// Returns true if the error is related to connect
     pub fn is_connect(&self) -> bool {
-        use crate::client::Error;
+        use crate::client::layer::client::Error;
 
         let mut source = self.source();
 
@@ -195,7 +228,7 @@ impl Error {
 
     /// Returns true if the error is related to proxy connect
     pub fn is_proxy_connect(&self) -> bool {
-        use crate::client::Error;
+        use crate::client::layer::client::Error;
 
         let mut source = self.source();
 
@@ -229,27 +262,32 @@ impl Error {
     }
 
     /// Returns true if the error is related to the request or response body
+    #[inline]
     pub fn is_body(&self) -> bool {
         matches!(self.inner.kind, Kind::Body)
     }
 
     /// Returns true if the error is related to TLS
+    #[inline]
     pub fn is_tls(&self) -> bool {
         matches!(self.inner.kind, Kind::Tls)
     }
 
     /// Returns true if the error is related to decoding the response's body
+    #[inline]
     pub fn is_decode(&self) -> bool {
         matches!(self.inner.kind, Kind::Decode)
     }
 
     /// Returns true if the error is related to upgrading the connection
+    #[inline]
     pub fn is_upgrade(&self) -> bool {
         matches!(self.inner.kind, Kind::Upgrade)
     }
 
-    #[cfg(feature = "ws")]
     /// Returns true if the error is related to WebSocket operations
+    #[inline]
+    #[cfg(feature = "ws")]
     pub fn is_websocket(&self) -> bool {
         matches!(self.inner.kind, Kind::WebSocket)
     }
@@ -329,7 +367,7 @@ impl fmt::Display for Error {
                         f,
                         "{prefix} ({} {})",
                         code.as_str(),
-                        Escape::new(reason.as_bytes())
+                        Escape::new(reason.as_ref())
                     )?;
                 } else {
                     write!(f, "{prefix} ({code})")?;
@@ -350,25 +388,12 @@ impl fmt::Display for Error {
 }
 
 impl StdError for Error {
+    #[inline]
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
         self.inner.source.as_ref().map(|e| &**e as _)
     }
 }
 
-#[derive(Debug)]
-pub(crate) enum Kind {
-    Builder,
-    Request,
-    Tls,
-    Redirect,
-    Status(StatusCode, Option<ReasonPhrase>),
-    Body,
-    Decode,
-    Upgrade,
-    #[cfg(feature = "ws")]
-    WebSocket,
-}
-
 #[derive(Debug)]
 pub(crate) struct TimedOut;
 
@@ -380,38 +405,39 @@ pub(crate) struct ProxyConnect(pub(crate) BoxError);
 
 // ==== impl TimedOut ====
 
+impl StdError for TimedOut {}
+
 impl fmt::Display for TimedOut {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("operation timed out")
     }
 }
 
-impl StdError for TimedOut {}
-
 // ==== impl BadScheme ====
 
+impl StdError for BadScheme {}
+
 impl fmt::Display for BadScheme {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("URI scheme is not allowed")
     }
 }
 
-impl StdError for BadScheme {}
-
 // ==== impl ProxyConnect ====
 
-impl fmt::Display for ProxyConnect {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "proxy connect error: {}", self.0)
-    }
-}
-
 impl StdError for ProxyConnect {
+    #[inline]
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
         Some(&*self.0)
     }
 }
 
+impl fmt::Display for ProxyConnect {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "proxy connect error: {}", self.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/vendor/wreq/src/ext.rs

@@ -25,6 +25,31 @@ const USERINFO: &AsciiSet = &PATH
     .add(b'^')
     .add(b'|');
 
+macro_rules! impl_into_shared {
+    ($(#[$meta:meta])* $vis:vis trait $name:ident => $target:path) => {
+        $(#[$meta])*
+        $vis trait $name {
+            #[doc = concat!("Converts this type into a shared [`", stringify!($target), "`].")]
+            fn into_shared(self) -> Arc<dyn $target>;
+        }
+
+        impl $name for Arc<dyn $target> {
+            #[inline]
+            fn into_shared(self) -> Arc<dyn $target> { self }
+        }
+
+        impl<R: $target + 'static> $name for Arc<R> {
+            #[inline]
+            fn into_shared(self) -> Arc<dyn $target> { self }
+        }
+
+        impl<R: $target + 'static> $name for R {
+            #[inline]
+            fn into_shared(self) -> Arc<dyn $target> { Arc::new(self) }
+        }
+    };
+}
+
 /// Extension trait for http::Response objects
 ///
 /// Provides methods to extract URI information from HTTP responses

data/vendor/wreq/src/group.rs

@@ -0,0 +1,211 @@
+//! # Request Grouping Mechanism
+//!
+//! This module provides the [`Group`] structure, which defines the logical boundaries
+//! for categorizing and segregating outbound requests.
+//!
+//! ## Concept
+//! A `Group` acts as a multi-dimensional identity for a request. In complex networking
+//! stack environments, two requests targeting the same destination may belong to
+//! distinct logical groups due to different metadata, security contexts, or
+//! routing requirements.
+//!
+//! ## Logical Segregation
+//! By assigning requests to different groups, the system ensures:
+//! 1. **Contextual Isolation**: Requests are processed and dispatched within their defined logical
+//!    partitions.
+//! 2. **Deterministic Identity**: The internal `BTreeMap` ensures that the identity of a group is
+//!    stable and invariant to the order in which grouping criteria are applied.
+//! 3. **Resource Affinity**: Resource management (such as connection pooling) respects these
+//!    boundaries, ensuring that resources are never leaked across different request groups.
+
+use std::collections::BTreeMap;
+
+use http::{Uri, Version};
+use name::GroupId;
+
+use crate::{conn::net::SocketBindOptions, proxy::Matcher};
+
+macro_rules! impl_group_variants {
+    ($($name:ident $(($ty:ty))?,)*) => {
+        #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+        enum GroupKey {
+            $($name,)*
+        }
+
+        #[derive(Debug, Clone, Hash, PartialEq, Eq)]
+        enum GroupVariant {
+            $($name $(($ty))?,)*
+        }
+    }
+}
+
+impl_group_variants! {
+    Request(Group),
+    Emulate(Group),
+    Named(GroupId),
+    Uri(Uri),
+    Version(Version),
+    Proxy(Matcher),
+    SocketBind(Option<SocketBindOptions>),
+}
+
+/// A logical identifier for request grouping.
+///
+/// `Group` encapsulates the criteria that define a request's execution context.
+/// Requests with non-identical `Group` states are treated as belonging to
+/// different logical partitions, preventing unintended interaction or
+/// resource sharing between them.
+#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
+pub struct Group(BTreeMap<GroupKey, GroupVariant>);
+
+impl Group {
+    /// Creates a new [`Group`] with a custom string or numeric identifier.
+    #[inline]
+    pub fn new<N: Into<GroupId>>(name: N) -> Self {
+        Group(BTreeMap::from([(
+            GroupKey::Named,
+            GroupVariant::Named(name.into()),
+        )]))
+    }
+
+    /// Groups the request by a specific target [`Uri`].
+    #[inline]
+    pub(crate) fn uri(&mut self, uri: Uri) -> &mut Self {
+        self.extend(GroupKey::Uri, GroupVariant::Uri(uri))
+    }
+
+    /// Groups the request by its required HTTP [`Version`].
+    #[inline]
+    pub(crate) fn version(&mut self, version: Option<Version>) -> &mut Self {
+        self.extend(GroupKey::Version, version.map(GroupVariant::Version))
+    }
+
+    /// Groups the request based on its proxy [`Matcher`] criteria.
+    #[inline]
+    pub(crate) fn proxy(&mut self, proxy: Option<Matcher>) -> &mut Self {
+        self.extend(GroupKey::Proxy, proxy.map(GroupVariant::Proxy))
+    }
+
+    /// Groups the request by its resolved socket bind options.
+    #[inline]
+    pub(crate) fn socket_bind(&mut self, opts: Option<SocketBindOptions>) -> &mut Self {
+        self.extend(GroupKey::SocketBind, GroupVariant::SocketBind(opts))
+    }
+
+    /// Creates a nested request group.
+    #[inline]
+    pub(crate) fn request(&mut self, group: Group) -> &mut Self {
+        self.extend(GroupKey::Request, GroupVariant::Request(group))
+    }
+
+    /// Groups the request by its emulation-layer characteristics.
+    #[inline]
+    pub(crate) fn emulate(&mut self, group: Group) -> &mut Self {
+        self.extend(GroupKey::Emulate, GroupVariant::Emulate(group))
+    }
+
+    #[inline]
+    fn extend<T: Into<Option<GroupVariant>>>(&mut self, id: GroupKey, entry: T) -> &mut Self {
+        if let Some(entry) = entry.into() {
+            self.0.insert(id, entry);
+        }
+        self
+    }
+}
+
+impl From<u64> for Group {
+    #[inline]
+    fn from(value: u64) -> Self {
+        Group::new(value)
+    }
+}
+
+impl From<&'static str> for Group {
+    #[inline]
+    fn from(value: &'static str) -> Self {
+        Group::new(value)
+    }
+}
+
+impl From<String> for Group {
+    #[inline]
+    fn from(value: String) -> Self {
+        Group::new(value)
+    }
+}
+
+impl From<Box<str>> for Group {
+    #[inline]
+    fn from(value: Box<str>) -> Self {
+        Group::new(value)
+    }
+}
+
+mod name {
+
+    /// A group identifier that can be a string or a numeric tag.
+    #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+    pub enum GroupId {
+        Borrowed(&'static str),
+        Owned(Box<str>),
+        Number(u64),
+    }
+
+    impl From<&'static str> for GroupId {
+        #[inline]
+        fn from(value: &'static str) -> Self {
+            Self::Borrowed(value)
+        }
+    }
+
+    impl From<String> for GroupId {
+        #[inline]
+        fn from(value: String) -> Self {
+            Self::Owned(value.into_boxed_str())
+        }
+    }
+
+    impl From<Box<str>> for GroupId {
+        #[inline]
+        fn from(value: Box<str>) -> Self {
+            Self::Owned(value)
+        }
+    }
+
+    impl From<u64> for GroupId {
+        #[inline]
+        fn from(value: u64) -> Self {
+            Self::Number(value)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::hash::{DefaultHasher, Hash, Hasher};
+
+    use super::*;
+
+    #[test]
+    fn test_group_identity_invariance() {
+        let mut g1 = Group::default();
+        g1.extend(GroupKey::Named, GroupVariant::Named("worker".into()));
+        g1.extend(GroupKey::Version, GroupVariant::Version(Version::HTTP_2));
+
+        let mut g2 = Group::default();
+        g2.extend(GroupKey::Version, GroupVariant::Version(Version::HTTP_2));
+        g2.extend(GroupKey::Named, GroupVariant::Named("worker".into()));
+
+        let mut h1 = DefaultHasher::new();
+        g1.hash(&mut h1);
+
+        let mut h2 = DefaultHasher::new();
+        g2.hash(&mut h2);
+
+        assert_eq!(
+            h1.finish(),
+            h2.finish(),
+            "Request groups must maintain identical hashes regardless of criteria insertion order"
+        );
+    }
+}