wreq-rb 0.3.0

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

@@ -0,0 +1,156 @@
+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/config.rs

@@ -0,0 +1,116 @@
+mod options;
+
+use std::{
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use futures_util::future::{self, Either, Ready};
+use http::{HeaderMap, Request, Response};
+use tower::{Layer, Service};
+
+pub use self::options::{RequestOptions, TransportOptions};
+use crate::{Error, config::RequestConfig, ext::UriExt, header::OrigHeaderMap};
+
+/// A marker type for the default headers configuration value.
+#[derive(Clone, Copy)]
+pub(crate) struct DefaultHeaders;
+
+/// Configuration for the [`ConfigService`].
+struct Config {
+    https_only: bool,
+    headers: HeaderMap,
+    orig_headers: RequestConfig<OrigHeaderMap>,
+    default_headers: RequestConfig<DefaultHeaders>,
+}
+
+/// Middleware layer to use [`ConfigService`].
+pub struct ConfigServiceLayer {
+    config: Arc<Config>,
+}
+
+/// Middleware service to use [`Config`].
+#[derive(Clone)]
+pub struct ConfigService<S> {
+    inner: S,
+    config: Arc<Config>,
+}
+
+// ===== impl DefaultHeaders =====
+
+impl_request_config_value!(DefaultHeaders, bool);
+
+// ===== impl ConfigServiceLayer =====
+
+impl ConfigServiceLayer {
+    /// Creates a new [`ConfigServiceLayer`].
+    pub fn new(https_only: bool, headers: HeaderMap, orig_headers: OrigHeaderMap) -> Self {
+        let org_headers = (!orig_headers.is_empty()).then_some(orig_headers);
+        ConfigServiceLayer {
+            config: Arc::new(Config {
+                https_only,
+                headers,
+                orig_headers: RequestConfig::new(org_headers),
+                default_headers: RequestConfig::new(Some(true)),
+            }),
+        }
+    }
+}
+
+impl<S> Layer<S> for ConfigServiceLayer {
+    type Service = ConfigService<S>;
+
+    #[inline(always)]
+    fn layer(&self, inner: S) -> Self::Service {
+        ConfigService {
+            inner,
+            config: self.config.clone(),
+        }
+    }
+}
+
+// ===== impl ConfigService =====
+
+impl<ReqBody, ResBody, S> Service<Request<ReqBody>> for ConfigService<S>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
+    S::Error: From<Error>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Future = Either<S::Future, Ready<Result<Self::Response, Self::Error>>>;
+
+    #[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 {
+        let uri = req.uri().clone();
+
+        // check if the request URI scheme is valid.
+        if !(uri.is_http() || uri.is_https()) || (self.config.https_only && !uri.is_https()) {
+            return Either::Right(future::err(Error::uri_bad_scheme(uri.clone()).into()));
+        }
+
+        // check if the request ignores the default headers.
+        if self
+            .config
+            .default_headers
+            .fetch(req.extensions())
+            .copied()
+            .unwrap_or_default()
+        {
+            // insert default headers in the request headers
+            // without overwriting already appended headers.
+            let mut dest = self.config.headers.clone();
+            crate::util::replace_headers(&mut dest, std::mem::take(req.headers_mut()));
+            std::mem::swap(req.headers_mut(), &mut dest);
+        }
+
+        // store the original headers in request extensions
+        self.config.orig_headers.store(req.extensions_mut());
+
+        Either::Left(self.inner.call(req))
+    }
+}

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

@@ -0,0 +1,161 @@
+//! 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/client/layer/decoder.rs

@@ -0,0 +1,139 @@
+//! Middleware for decoding
+
+use std::task::{Context, Poll};
+
+use http::{Request, Response};
+use http_body::Body;
+use tower::{Layer, Service};
+use tower_http::decompression::{self, DecompressionBody, ResponseFuture};
+
+use crate::config::RequestConfig;
+
+/// Configuration for supported content-encoding algorithms.
+///
+/// `AcceptEncoding` controls which compression formats are enabled for decoding
+/// response bodies. Each field corresponds to a specific algorithm and is only
+/// available if the corresponding feature is enabled.
+#[derive(Clone)]
+pub(crate) struct AcceptEncoding {
+    #[cfg(feature = "gzip")]
+    pub(crate) gzip: bool,
+    #[cfg(feature = "brotli")]
+    pub(crate) brotli: bool,
+    #[cfg(feature = "zstd")]
+    pub(crate) zstd: bool,
+    #[cfg(feature = "deflate")]
+    pub(crate) deflate: bool,
+}
+
+/// Layer that adds response body decompression to a service.
+#[derive(Clone)]
+pub struct DecompressionLayer {
+    accept: AcceptEncoding,
+}
+
+/// Service that decompresses response bodies based on the [`AcceptEncoding`] configuration.
+#[derive(Clone)]
+pub struct Decompression<S>(Option<decompression::Decompression<S>>);
+
+// ===== AcceptEncoding =====
+
+impl Default for AcceptEncoding {
+    fn default() -> AcceptEncoding {
+        AcceptEncoding {
+            #[cfg(feature = "gzip")]
+            gzip: true,
+            #[cfg(feature = "brotli")]
+            brotli: true,
+            #[cfg(feature = "zstd")]
+            zstd: true,
+            #[cfg(feature = "deflate")]
+            deflate: true,
+        }
+    }
+}
+
+impl_request_config_value!(AcceptEncoding);
+
+// ===== impl DecompressionLayer =====
+
+impl DecompressionLayer {
+    /// Creates a new [`DecompressionLayer`] with the specified [`AcceptEncoding`].
+    #[inline(always)]
+    pub const fn new(accept: AcceptEncoding) -> Self {
+        Self { accept }
+    }
+}
+
+impl<S> Layer<S> for DecompressionLayer {
+    type Service = Decompression<S>;
+
+    #[inline(always)]
+    fn layer(&self, service: S) -> Self::Service {
+        Decompression(Some(Decompression::<S>::accept_in_place(
+            decompression::Decompression::new(service),
+            &self.accept,
+        )))
+    }
+}
+
+// ===== impl Decompression =====
+
+impl<S> Decompression<S> {
+    const BUG_MSG: &str = "[BUG] Decompression service not initialized; bug in setup";
+
+    fn accept_in_place(
+        mut decoder: decompression::Decompression<S>,
+        accept: &AcceptEncoding,
+    ) -> decompression::Decompression<S> {
+        #[cfg(feature = "gzip")]
+        {
+            decoder = decoder.gzip(accept.gzip);
+        }
+
+        #[cfg(feature = "deflate")]
+        {
+            decoder = decoder.deflate(accept.deflate);
+        }
+
+        #[cfg(feature = "brotli")]
+        {
+            decoder = decoder.br(accept.brotli);
+        }
+
+        #[cfg(feature = "zstd")]
+        {
+            decoder = decoder.zstd(accept.zstd);
+        }
+
+        decoder
+    }
+}
+
+impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for Decompression<S>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
+    ReqBody: Body,
+    ResBody: Body,
+{
+    type Response = Response<DecompressionBody<ResBody>>;
+    type Error = S::Error;
+    type Future = ResponseFuture<S::Future>;
+
+    #[inline(always)]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.0.as_mut().expect(Self::BUG_MSG).poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
+        if let Some(accept) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
+            if let Some(decoder) = self.0.take() {
+                self.0
+                    .replace(Decompression::accept_in_place(decoder, accept));
+            }
+            debug_assert!(self.0.is_some());
+        }
+
+        self.0.as_mut().expect(Self::BUG_MSG).call(req)
+    }
+}