wreq-rb 0.5.0 → 0.5.1

data/vendor/wreq/src/client/layer/config/options.rs

@@ -1,156 +0,0 @@
-use http::Version;
-
-use crate::{
-    client::{
-        conn::TcpConnectOptions,
-        core::{http1::Http1Options, http2::Http2Options},
-    },
-    proxy::Matcher,
-    tls::TlsOptions,
-};
-
-/// Per-request configuration for proxy, protocol, and transport options.
-/// Overrides client defaults for a single request.
-#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
-#[non_exhaustive]
-pub struct RequestOptions {
-    proxy_matcher: Option<Matcher>,
-    enforced_version: Option<Version>,
-    tcp_connect_opts: TcpConnectOptions,
-    transport_opts: TransportOptions,
-}
-
-/// Transport options for HTTP/1, HTTP/2, and TLS layers.
-///
-/// This struct allows you to customize protocol-specific and TLS settings
-/// for network connections made by the client.
-#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
-#[non_exhaustive]
-pub struct TransportOptions {
-    tls_options: Option<TlsOptions>,
-    http1_options: Option<Http1Options>,
-    http2_options: Option<Http2Options>,
-}
-
-// ===== impl RequestOptions =====
-
-impl_request_config_value!(RequestOptions);
-
-// ===== impl TransportOptions =====
-
-impl TransportOptions {
-    /// Get the reference to the TLS options.
-    #[inline]
-    pub fn tls_options(&self) -> Option<&TlsOptions> {
-        self.tls_options.as_ref()
-    }
-
-    /// Get a mutable reference to the TLS options.
-    #[inline]
-    pub fn tls_options_mut(&mut self) -> &mut Option<TlsOptions> {
-        &mut self.tls_options
-    }
-
-    /// Get the reference to the HTTP/1 options.
-    #[inline]
-    pub fn http1_options(&self) -> Option<&Http1Options> {
-        self.http1_options.as_ref()
-    }
-
-    /// Get a mutable reference to the HTTP/1 options.
-    #[inline]
-    pub fn http1_options_mut(&mut self) -> &mut Option<Http1Options> {
-        &mut self.http1_options
-    }
-
-    /// Get the reference to the HTTP/2 options.
-    #[inline]
-    pub fn http2_options(&self) -> Option<&Http2Options> {
-        self.http2_options.as_ref()
-    }
-
-    /// Get a mutable reference to the HTTP/2 options.
-    #[inline]
-    pub fn http2_options_mut(&mut self) -> &mut Option<Http2Options> {
-        &mut self.http2_options
-    }
-
-    /// Apply the transport options for HTTP/1, HTTP/2, and TLS.
-    pub(crate) fn apply_transport_options(&mut self, opts: TransportOptions) -> &mut Self {
-        if let Some(tls) = opts.tls_options {
-            *self.tls_options_mut() = Some(tls);
-        }
-        if let Some(http1) = opts.http1_options {
-            *self.http1_options_mut() = Some(http1);
-        }
-        if let Some(http2) = opts.http2_options {
-            *self.http2_options_mut() = Some(http2);
-        }
-        self
-    }
-}
-
-impl From<TransportOptions>
-    for (
-        Option<TlsOptions>,
-        Option<Http1Options>,
-        Option<Http2Options>,
-    )
-{
-    #[inline]
-    fn from(value: TransportOptions) -> Self {
-        (value.tls_options, value.http1_options, value.http2_options)
-    }
-}
-
-// ===== impl RequestOptions =====
-
-impl RequestOptions {
-    /// Get a reference to the proxy matcher.
-    #[inline]
-    pub fn proxy_matcher(&self) -> Option<&Matcher> {
-        self.proxy_matcher.as_ref()
-    }
-
-    /// Get a mutable reference to the proxy matcher.
-    #[inline]
-    pub fn proxy_matcher_mut(&mut self) -> &mut Option<Matcher> {
-        &mut self.proxy_matcher
-    }
-
-    /// Get the enforced HTTP version.
-    #[inline]
-    pub fn enforced_version(&self) -> Option<Version> {
-        self.enforced_version
-    }
-
-    /// Get a mutable reference to the enforced HTTP version.
-    #[inline]
-    pub fn enforced_version_mut(&mut self) -> &mut Option<Version> {
-        &mut self.enforced_version
-    }
-
-    /// Get a reference to the TCP connection options.
-    #[inline]
-    pub fn tcp_connect_opts(&self) -> &TcpConnectOptions {
-        &self.tcp_connect_opts
-    }
-
-    /// Get a mutable reference to the TCP connection options.
-    #[inline]
-    pub fn tcp_connect_opts_mut(&mut self) -> &mut TcpConnectOptions {
-        &mut self.tcp_connect_opts
-    }
-
-    /// Get a reference to the transport options.
-    #[inline]
-    pub fn transport_opts(&self) -> &TransportOptions {
-        &self.transport_opts
-    }
-
-    /// Get a mutable reference to the transport options.
-    #[inline]
-    pub fn transport_opts_mut(&mut self) -> &mut TransportOptions {
-        &mut self.transport_opts
-    }
-}

data/vendor/wreq/src/client/layer/cookie.rs

@@ -1,161 +0,0 @@
-//! Middleware to use Cookie.
-
-use std::{
-    future::Future,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll, ready},
-};
-
-use http::{Request, Response, Uri, header::COOKIE};
-use pin_project_lite::pin_project;
-use tower::{Layer, Service};
-
-use crate::{
-    config::RequestConfig,
-    cookie::{CookieStore, Cookies},
-};
-
-pin_project! {
-    /// Response future for [`CookieService`].
-    #[project = ResponseFutureProj]
-    pub enum ResponseFuture<Fut> {
-        Managed {
-            #[pin]
-            fut: Fut,
-            uri: Uri,
-            store: Arc<dyn CookieStore>,
-        },
-        Plain {
-            #[pin]
-            fut: Fut,
-        },
-    }
-}
-
-/// Layer to apply [`CookieService`] middleware.
-#[derive(Clone)]
-pub struct CookieServiceLayer {
-    store: RequestConfig<Arc<dyn CookieStore>>,
-}
-
-/// Middleware to use [`CookieStore`].
-#[derive(Clone)]
-pub struct CookieService<S> {
-    inner: S,
-    store: RequestConfig<Arc<dyn CookieStore>>,
-}
-
-// ===== impl ResponseFuture =====
-
-impl<F, ResBody, E> Future for ResponseFuture<F>
-where
-    F: Future<Output = Result<Response<ResBody>, E>>,
-{
-    type Output = F::Output;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.project() {
-            ResponseFutureProj::Managed { fut, uri, store } => {
-                let res = ready!(fut.poll(cx)?);
-                let mut cookies = res
-                    .headers()
-                    .get_all(http::header::SET_COOKIE)
-                    .iter()
-                    .peekable();
-                if cookies.peek().is_some() {
-                    store.set_cookies(&mut cookies, uri);
-                }
-
-                Poll::Ready(Ok(res))
-            }
-            ResponseFutureProj::Plain { fut: mut future } => future.as_mut().poll(cx),
-        }
-    }
-}
-
-// ===== impl CookieServiceLayer =====
-
-impl CookieServiceLayer {
-    /// Create a new [`CookieServiceLayer`].
-    #[inline(always)]
-    pub const fn new(store: Option<Arc<dyn CookieStore + 'static>>) -> Self {
-        Self {
-            store: RequestConfig::new(store),
-        }
-    }
-}
-
-impl<S> Layer<S> for CookieServiceLayer {
-    type Service = CookieService<S>;
-
-    #[inline(always)]
-    fn layer(&self, inner: S) -> Self::Service {
-        CookieService {
-            inner,
-            store: self.store.clone(),
-        }
-    }
-}
-
-// ===== impl CookieService =====
-
-impl<S> CookieService<S> {
-    fn inject_cookies<B>(
-        &self,
-        req: &mut Request<B>,
-        store: Arc<dyn CookieStore>,
-    ) -> (Arc<dyn CookieStore>, Uri) {
-        let uri = req.uri().clone();
-        let headers = req.headers_mut();
-
-        // Only inject cookies if request doesn't already have them
-        if !headers.contains_key(COOKIE) {
-            match store.cookies(&uri) {
-                Cookies::Compressed(value) => {
-                    headers.insert(COOKIE, value);
-                }
-                Cookies::Uncompressed(values) => {
-                    for value in values {
-                        headers.append(COOKIE, value);
-                    }
-                }
-                Cookies::Empty => (),
-            }
-        }
-
-        (store, uri)
-    }
-}
-
-impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for CookieService<S>
-where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
-{
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = ResponseFuture<S::Future>;
-
-    #[inline(always)]
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.inner.poll_ready(cx)
-    }
-
-    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
-        match self
-            .store
-            .fetch(req.extensions())
-            .cloned()
-            .map(|store| self.inject_cookies(&mut req, store))
-        {
-            Some((store, uri)) => ResponseFuture::Managed {
-                uri,
-                store,
-                fut: self.inner.call(req),
-            },
-            None => ResponseFuture::Plain {
-                fut: self.inner.call(req),
-            },
-        }
-    }
-}

data/vendor/wreq/src/hash.rs

@@ -1,143 +0,0 @@
-use std::{
-    borrow::Borrow,
-    hash::{BuildHasher, Hash, Hasher},
-    num::NonZeroU64,
-    sync::atomic::{AtomicU64, Ordering},
-};
-
-use ahash::RandomState;
-use schnellru::ByLength;
-
-/// Pre-seeded [`RandomState`] for consistent internal hashing.
-///
-/// Uses fixed seeds to ensure deterministic hashing behavior across
-/// program runs. Primarily used for connection pools and internal caches.
-///
-/// **Note**: Not cryptographically secure due to fixed seeds.
-pub const HASHER: RandomState = RandomState::with_seeds(
-    0x6b68_d618_a4b5_3c57,
-    0xadc8_c4d5_82bb_1313,
-    0x2f72_c2c1_9b04_2d4c,
-    0x94e5_8d83_a26c_3f28,
-);
-
-/// A type alias for a hash set using `ahash` with a pre-seeded `RandomState`.
-pub type HashSet<T> = std::collections::HashSet<T, RandomState>;
-
-/// A type alias for a hash map using `ahash` with a pre-seeded `RandomState`.
-pub type HashMap<K, V> = std::collections::HashMap<K, V, RandomState>;
-
-/// A specialized LRU cache using `schnellru` with a fixed capacity
-pub type LruMap<K, V> = schnellru::LruMap<K, V, ByLength, RandomState>;
-
-/// A wrapper that memoizes the hash value of its contained data.
-#[derive(Debug)]
-pub struct HashMemo<T, H: BuildHasher = RandomState>
-where
-    T: Eq + PartialEq + Hash,
-{
-    value: T,
-    hash: AtomicU64,
-    hasher: H,
-}
-
-impl<T, H> HashMemo<T, H>
-where
-    T: Eq + Hash,
-    H: BuildHasher,
-{
-    /// Creates a new `HashMemo` with a custom hasher.
-    ///
-    /// This allows you to specify a custom `BuildHasher` implementation for
-    /// controlling how hash values are computed.
-    pub const fn with_hasher(value: T, hasher: H) -> Self {
-        Self {
-            value,
-            hash: AtomicU64::new(u64::MIN),
-            hasher,
-        }
-    }
-}
-
-impl<T, H> Hash for HashMemo<T, H>
-where
-    T: Eq + Hash,
-    H: BuildHasher,
-{
-    fn hash<H2: Hasher>(&self, state: &mut H2) {
-        let hash = self.hash.load(Ordering::Relaxed);
-        if hash != 0 {
-            state.write_u64(hash);
-            return;
-        }
-
-        let computed_hash = NonZeroU64::new(self.hasher.hash_one(&self.value))
-            .map(NonZeroU64::get)
-            .unwrap_or(1);
-
-        let _ = self.hash.compare_exchange(
-            u64::MIN,
-            computed_hash,
-            Ordering::Relaxed,
-            Ordering::Relaxed,
-        );
-        state.write_u64(computed_hash);
-    }
-}
-
-impl<T, H> PartialOrd for HashMemo<T, H>
-where
-    T: Eq + Hash + PartialOrd,
-    H: BuildHasher,
-{
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.value.partial_cmp(&other.value)
-    }
-}
-
-impl<T, H> Ord for HashMemo<T, H>
-where
-    T: Eq + Hash + Ord,
-    H: BuildHasher,
-{
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.value.cmp(&other.value)
-    }
-}
-
-impl<T, H> PartialEq for HashMemo<T, H>
-where
-    T: Eq + Hash,
-    H: BuildHasher,
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.value == other.value
-    }
-}
-
-impl<T, H> Eq for HashMemo<T, H>
-where
-    T: Eq + Hash,
-    H: BuildHasher,
-{
-}
-
-impl<T, H> AsRef<T> for HashMemo<T, H>
-where
-    T: Eq + Hash,
-    H: BuildHasher,
-{
-    fn as_ref(&self) -> &T {
-        &self.value
-    }
-}
-
-impl<T, H> Borrow<T> for HashMemo<T, H>
-where
-    T: Eq + Hash,
-    H: BuildHasher,
-{
-    fn borrow(&self) -> &T {
-        &self.value
-    }
-}

data/vendor/wreq/src/tls/conn/cache.rs

@@ -1,123 +0,0 @@
-use std::{
-    borrow::Borrow,
-    collections::hash_map::Entry,
-    hash::{Hash, Hasher},
-};
-
-use boring2::ssl::{SslSession, SslSessionRef, SslVersion};
-use schnellru::ByLength;
-
-use crate::hash::{HASHER, HashMap, LruMap};
-
-/// A typed key for indexing TLS sessions in the cache.
-///
-/// This wrapper provides type safety and allows different key types
-/// (e.g., hostname, connection parameters) to be used for session lookup.
-#[derive(Hash, PartialEq, Eq, Clone)]
-pub struct SessionKey<T>(pub T);
-
-/// A hashable wrapper around `SslSession` for use in hash-based collections.
-///
-/// Uses the session ID for hashing and equality, enabling efficient
-/// storage and lookup in HashMap/HashSet while maintaining session semantics.
-#[derive(Clone)]
-struct HashSession(SslSession);
-
-impl PartialEq for HashSession {
-    fn eq(&self, other: &HashSession) -> bool {
-        self.0.id() == other.0.id()
-    }
-}
-
-impl Eq for HashSession {}
-
-impl Hash for HashSession {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.0.id().hash(state);
-    }
-}
-
-impl Borrow<[u8]> for HashSession {
-    fn borrow(&self) -> &[u8] {
-        self.0.id()
-    }
-}
-
-/// A two-level cache for TLS sessions organized by host keys with LRU eviction.
-///
-/// Maintains both forward (key → sessions) and reverse (session → key) lookups
-/// for efficient session storage, retrieval, and cleanup operations.
-pub struct SessionCache<T> {
-    reverse: HashMap<HashSession, SessionKey<T>>,
-    per_host_sessions: HashMap<SessionKey<T>, LruMap<HashSession, ()>>,
-    per_host_session_capacity: usize,
-}
-
-impl<T> SessionCache<T>
-where
-    T: Hash + Eq + Clone,
-{
-    pub fn with_capacity(per_host_session_capacity: usize) -> SessionCache<T> {
-        SessionCache {
-            per_host_sessions: HashMap::with_hasher(HASHER),
-            reverse: HashMap::with_hasher(HASHER),
-            per_host_session_capacity,
-        }
-    }
-
-    pub fn insert(&mut self, key: SessionKey<T>, session: SslSession) {
-        let per_host_sessions = self
-            .per_host_sessions
-            .entry(key.clone())
-            .or_insert_with(|| {
-                LruMap::with_hasher(ByLength::new(self.per_host_session_capacity as _), HASHER)
-            });
-
-        // Enforce per-key capacity limit by evicting the least recently used session
-        if per_host_sessions.len() >= self.per_host_session_capacity {
-            if let Some((evicted_session, _)) = per_host_sessions.pop_oldest() {
-                // Remove from reverse lookup to maintain consistency
-                self.reverse.remove(&evicted_session);
-            }
-        }
-
-        let session = HashSession(session);
-        per_host_sessions.insert(session.clone(), ());
-        self.reverse.insert(session, key);
-    }
-
-    pub fn get(&mut self, key: &SessionKey<T>) -> Option<SslSession> {
-        let session = {
-            let per_host_sessions = self.per_host_sessions.get_mut(key)?;
-            per_host_sessions.peek_oldest()?.0.clone().0
-        };
-
-        // https://tools.ietf.org/html/rfc8446#appendix-C.4
-        // OpenSSL will remove the session from its cache after the handshake completes anyway, but
-        // this ensures that concurrent handshakes don't end up with the same session.
-        if session.protocol_version() == SslVersion::TLS1_3 {
-            self.remove(&session);
-        }
-
-        Some(session)
-    }
-
-    fn remove(&mut self, session: &SslSessionRef) {
-        let key = match self.reverse.remove(session.id()) {
-            Some(key) => key,
-            None => return,
-        };
-
-        if let Entry::Occupied(mut per_host_sessions) = self.per_host_sessions.entry(key) {
-            per_host_sessions
-                .get_mut()
-                .remove(&HashSession(session.to_owned()));
-            if per_host_sessions.get().is_empty() {
-                per_host_sessions.remove();
-            }
-        }
-    }
-}

data/vendor/wreq/src/tls/conn/cert_compression.rs

@@ -1,125 +0,0 @@
-use std::io::{self, Read, Result, Write};
-
-use boring2::ssl::{CertificateCompressionAlgorithm, CertificateCompressor};
-use brotli::{CompressorWriter, Decompressor};
-use flate2::{Compression, read::ZlibDecoder, write::ZlibEncoder};
-use zstd::stream::{Decoder as ZstdDecoder, Encoder as ZstdEncoder};
-
-#[derive(Debug, Clone, Default)]
-#[non_exhaustive]
-pub struct BrotliCertificateCompressor;
-
-impl CertificateCompressor for BrotliCertificateCompressor {
-    const ALGORITHM: CertificateCompressionAlgorithm = CertificateCompressionAlgorithm::BROTLI;
-    const CAN_COMPRESS: bool = true;
-    const CAN_DECOMPRESS: bool = true;
-
-    fn compress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
-    where
-        W: Write,
-    {
-        let mut writer = CompressorWriter::new(output, input.len(), 11, 22);
-        writer.write_all(input)?;
-        writer.flush()?;
-        Ok(())
-    }
-
-    fn decompress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
-    where
-        W: Write,
-    {
-        let mut reader = Decompressor::new(input, 4096);
-        let mut buf = [0u8; 4096];
-        loop {
-            match reader.read(&mut buf[..]) {
-                Err(e) => {
-                    if let io::ErrorKind::Interrupted = e.kind() {
-                        continue;
-                    }
-                    return Err(e);
-                }
-                Ok(size) => {
-                    if size == 0 {
-                        break;
-                    }
-                    output.write_all(&buf[..size])?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-#[non_exhaustive]
-pub struct ZlibCertificateCompressor;
-
-impl CertificateCompressor for ZlibCertificateCompressor {
-    const ALGORITHM: CertificateCompressionAlgorithm = CertificateCompressionAlgorithm::ZLIB;
-    const CAN_COMPRESS: bool = true;
-    const CAN_DECOMPRESS: bool = true;
-
-    fn compress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
-    where
-        W: Write,
-    {
-        let mut encoder = ZlibEncoder::new(output, Compression::default());
-        encoder.write_all(input)?;
-        encoder.finish()?;
-        Ok(())
-    }
-
-    fn decompress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
-    where
-        W: Write,
-    {
-        let mut decoder = ZlibDecoder::new(input);
-        io::copy(&mut decoder, output)?;
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-#[non_exhaustive]
-pub struct ZstdCertificateCompressor;
-
-impl CertificateCompressor for ZstdCertificateCompressor {
-    const ALGORITHM: CertificateCompressionAlgorithm = CertificateCompressionAlgorithm::ZSTD;
-    const CAN_COMPRESS: bool = true;
-    const CAN_DECOMPRESS: bool = true;
-
-    fn compress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
-    where
-        W: Write,
-    {
-        let mut writer = ZstdEncoder::new(output, 0)?;
-        writer.write_all(input)?;
-        writer.flush()?;
-        Ok(())
-    }
-
-    fn decompress<W>(&self, input: &[u8], output: &mut W) -> Result<()>
-    where
-        W: Write,
-    {
-        let mut reader = ZstdDecoder::new(input)?;
-        let mut buf = [0u8; 4096];
-        loop {
-            match reader.read(&mut buf[..]) {
-                Err(e) => {
-                    if let io::ErrorKind::Interrupted = e.kind() {
-                        continue;
-                    }
-                    return Err(e);
-                }
-                Ok(size) => {
-                    if size == 0 {
-                        break;
-                    }
-                    output.write_all(&buf[..size])?;
-                }
-            }
-        }
-        Ok(())
-    }
-}