wreq-rb 0.6.0 → 0.6.1

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

@@ -2,7 +2,10 @@
 
 use std::task::{Context, Poll};
 
-use http::{Request, Response};
+use http::{
+    HeaderValue, Request, Response,
+    header::{ACCEPT_ENCODING, RANGE},
+};
 use http_body::Body;
 use tower::{Layer, Service};
 use tower_http::decompression::{self, DecompressionBody, ResponseFuture};
@@ -26,15 +29,26 @@ pub(crate) struct AcceptEncoding {
     pub(crate) deflate: bool,
 }
 
-/// Layer that adds response body decompression to a service.
+/// Builds response decompression middleware for a client service.
+///
+/// `DecompressionLayer` stores the client's default [`AcceptEncoding`] configuration
+/// and applies it when constructing a [`Decompression`] service.
 #[derive(Clone)]
 pub struct DecompressionLayer {
     accept: AcceptEncoding,
 }
 
-/// Service that decompresses response bodies based on the [`AcceptEncoding`] configuration.
+/// Negotiates response encodings and transparently decodes response bodies.
+///
+/// Before forwarding a request, `Decompression` applies request-specific
+/// [`AcceptEncoding`] settings and keeps range requests on the identity representation.
+/// The wrapped `tower-http` service then advertises enabled encodings and decodes matching
+/// responses.
 #[derive(Clone)]
-pub struct Decompression<S>(Option<decompression::Decompression<S>>);
+pub struct Decompression<S> {
+    decoder: Option<decompression::Decompression<S>>,
+    enabled: bool,
+}
 
 // ===== AcceptEncoding =====
 
@@ -53,6 +67,32 @@ impl Default for AcceptEncoding {
     }
 }
 
+impl AcceptEncoding {
+    fn is_enabled(&self) -> bool {
+        #[cfg(feature = "gzip")]
+        if self.gzip {
+            return true;
+        }
+
+        #[cfg(feature = "deflate")]
+        if self.deflate {
+            return true;
+        }
+
+        #[cfg(feature = "brotli")]
+        if self.brotli {
+            return true;
+        }
+
+        #[cfg(feature = "zstd")]
+        if self.zstd {
+            return true;
+        }
+
+        false
+    }
+}
+
 impl_request_config_value!(AcceptEncoding);
 
 // ===== impl DecompressionLayer =====
@@ -75,10 +115,10 @@ impl<S> Layer<S> for DecompressionLayer {
             .no_deflate()
             .no_gzip()
             .no_zstd();
-        Decompression(Some(Decompression::<S>::accept_in_place(
-            decoder,
-            &self.accept,
-        )))
+        Decompression {
+            decoder: Some(Decompression::<S>::accept_in_place(decoder, &self.accept)),
+            enabled: self.accept.is_enabled(),
+        }
     }
 }
 
@@ -127,18 +167,32 @@ where
 
     #[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)
+        self.decoder.as_mut().expect(Self::BUG_MSG).poll_ready(cx)
     }
 
-    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
-        if let Some(accept_encoding) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
-            if let Some(decoder) = self.0.take() {
-                self.0
-                    .replace(Decompression::accept_in_place(decoder, accept_encoding));
-            }
-            debug_assert!(self.0.is_some());
+    fn call(&mut self, mut req: Request<ReqBody>) -> Self::Future {
+        let enabled =
+            if let Some(accept_encoding) = RequestConfig::<AcceptEncoding>::get(req.extensions()) {
+                if let Some(decoder) = self.decoder.take() {
+                    self.decoder
+                        .replace(Decompression::accept_in_place(decoder, accept_encoding));
+                }
+                debug_assert!(self.decoder.is_some());
+                accept_encoding.is_enabled()
+            } else {
+                self.enabled
+            };
+
+        if enabled && req.headers().contains_key(RANGE) {
+            // tower-http does not account for Range when adding Accept-Encoding, so correct it
+            // before delegating. RFC 9110 section 14.1.2 applies byte ranges to the encoded
+            // representation, and Fetch avoids partial codings by requesting identity:
+            // https://www.rfc-editor.org/rfc/rfc9110.html#section-14.1.2
+            // https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
+            req.headers_mut()
+                .insert(ACCEPT_ENCODING, HeaderValue::from_static("identity"));
         }
 
-        self.0.as_mut().expect(Self::BUG_MSG).call(req)
+        self.decoder.as_mut().expect(Self::BUG_MSG).call(req)
     }
 }

data/vendor/wreq/src/client/layer/redirect/future.rs

@@ -9,42 +9,40 @@ use futures_util::future::Either;
 use http::{
     HeaderMap, Method, Request, Response, StatusCode, Uri,
     header::{CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_TYPE, LOCATION, TRANSFER_ENCODING},
-    request::Parts,
 };
-use http_body::Body;
 use pin_project_lite::pin_project;
 use tower::{BoxError, Service, util::Oneshot};
 use url::Url;
 
 use super::{
     BodyRepr,
-    policy::{Action, Attempt, Policy},
+    policy::{Action, Attempt},
 };
-use crate::{Error, ext::RequestUri, into_uri::IntoUriSealed};
+use crate::{Body, ext::RequestUri, into_uri::IntoUriSealed, redirect::FollowRedirectPolicy};
 
 /// Pending future state for handling redirects.
-pub struct Pending<ReqBody, Response> {
+pub struct Pending<Response> {
     future: Pin<Box<dyn Future<Output = Action> + Send>>,
     location: Uri,
-    body: ReqBody,
+    body: Body,
     res: Response,
 }
 
 pin_project! {
     /// Response future for [`FollowRedirect`].
     #[project = ResponseFutureProj]
-    pub enum ResponseFuture<S, B, P>
+    pub enum ResponseFuture<S>
     where
-        S: Service<Request<B>>,
+        S: Service<Request<Body>>,
     {
         Redirect {
             #[pin]
-            future: Either<S::Future, Oneshot<S, Request<B>>>,
-            pending_future: Option<Pending<B, S::Response>>,
+            future: Either<S::Future, Oneshot<S, Request<Body>>>,
+            pending_future: Option<Pending<S::Response>>,
             service: S,
-            policy: P,
-            parts: Parts,
-            body_repr: BodyRepr<B>,
+            policy: FollowRedirectPolicy,
+            request: Request<()>,
+            body_repr: BodyRepr<Body>,
         },
 
         Direct {
@@ -54,14 +52,12 @@ pin_project! {
     }
 }
 
-impl<S, ReqBody, ResBody, P> Future for ResponseFuture<S, ReqBody, P>
+impl<S, B> Future for ResponseFuture<S>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S: Service<Request<Body>, Response = Response<B>> + Clone,
     S::Error: From<BoxError>,
-    P: Policy<ReqBody, S::Error>,
-    ReqBody: Body + Default,
 {
-    type Output = Result<Response<ResBody>, S::Error>;
+    type Output = Result<Response<B>, S::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.project() {
@@ -71,7 +67,7 @@ where
                 pending_future,
                 service,
                 policy,
-                parts,
+                request,
                 body_repr,
             } => {
                 // Check if we have a pending action to resolve
@@ -91,7 +87,7 @@ where
                             future: &mut future,
                             service,
                             policy,
-                            parts,
+                            request,
                             body: state.body,
                             body_repr,
                             res: state.res,
@@ -103,7 +99,8 @@ where
                 // Poll the current future to get the response
                 let mut res = {
                     let mut res = ready!(future.as_mut().poll(cx)?);
-                    res.extensions_mut().insert(RequestUri(parts.uri.clone()));
+                    res.extensions_mut()
+                        .insert(RequestUri(request.uri().clone()));
                     res
                 };
 
@@ -112,19 +109,19 @@ where
                     StatusCode::MOVED_PERMANENTLY | StatusCode::FOUND => {
                         // User agents MAY change the request method from POST to GET
                         // (RFC 7231 section 6.4.2. and 6.4.3.).
-                        if parts.method == Method::POST {
-                            parts.method = Method::GET;
+                        if request.method() == Method::POST {
+                            *request.method_mut() = Method::GET;
                             *body_repr = BodyRepr::Empty;
-                            drop_payload_headers(&mut parts.headers);
+                            drop_payload_headers(request.headers_mut());
                         }
                     }
                     StatusCode::SEE_OTHER => {
                         // A user agent can perform a GET or HEAD request (RFC 7231 section 6.4.4.).
-                        if parts.method != Method::HEAD {
-                            parts.method = Method::GET;
+                        if request.method() != Method::HEAD {
+                            *request.method_mut() = Method::GET;
                         }
                         *body_repr = BodyRepr::Empty;
-                        drop_payload_headers(&mut parts.headers);
+                        drop_payload_headers(request.headers_mut());
                     }
                     StatusCode::TEMPORARY_REDIRECT | StatusCode::PERMANENT_REDIRECT => {}
                     _ => {
@@ -144,7 +141,7 @@ where
                     .headers()
                     .get(LOCATION)
                     .and_then(|loc| loc.to_str().ok())
-                    .and_then(|loc| resolve_uri(loc, &parts.uri))
+                    .and_then(|loc| resolve_uri(loc, request.uri()))
                 else {
                     return Poll::Ready(Ok(res));
                 };
@@ -154,7 +151,7 @@ where
                     status: res.status(),
                     headers: res.headers(),
                     location: &location,
-                    previous: &parts.uri,
+                    previous: request.uri(),
                 };
 
                 // Resolve the action, awaiting if it's pending
@@ -180,7 +177,7 @@ where
                         future: &mut future,
                         service,
                         policy,
-                        parts,
+                        request,
                         body,
                         body_repr,
                         res,
@@ -215,59 +212,48 @@ fn drop_payload_headers(headers: &mut HeaderMap) {
     }
 }
 
-type RedirectFuturePin<'a, S, ReqBody> =
-    Pin<&'a mut Either<<S as Service<Request<ReqBody>>>::Future, Oneshot<S, Request<ReqBody>>>>;
+type RedirectFuturePin<'a, S> =
+    Pin<&'a mut Either<<S as Service<Request<Body>>>::Future, Oneshot<S, Request<Body>>>>;
 
-struct RedirectAction<'a, S, ReqBody, ResBody, P>
+struct RedirectAction<'a, S, B>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
-    P: Policy<ReqBody, S::Error>,
+    S: Service<Request<Body>, Response = Response<B>> + Clone,
 {
     action: Action,
-    future: &'a mut RedirectFuturePin<'a, S, ReqBody>,
+    future: &'a mut RedirectFuturePin<'a, S>,
     service: &'a S,
-    policy: &'a mut P,
-    parts: &'a mut Parts,
-    body: ReqBody,
-    body_repr: &'a mut BodyRepr<ReqBody>,
-    res: Response<ResBody>,
+    policy: &'a mut FollowRedirectPolicy,
+    request: &'a mut Request<()>,
+    body: Body,
+    body_repr: &'a mut BodyRepr<Body>,
+    res: Response<B>,
     location: Uri,
 }
 
-fn handle_action<S, ReqBody, ResBody, P>(
+fn handle_action<S, B>(
     cx: &mut Context<'_>,
-    redirect: RedirectAction<'_, S, ReqBody, ResBody, P>,
-) -> Poll<Result<Response<ResBody>, S::Error>>
+    redirect: RedirectAction<'_, S, B>,
+) -> Poll<Result<Response<B>, S::Error>>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S: Service<Request<Body>, Response = Response<B>> + Clone,
     S::Error: From<BoxError>,
-    P: Policy<ReqBody, S::Error>,
-    ReqBody: Body + Default,
 {
     match redirect.action {
         Action::Follow => {
-            redirect.parts.uri = redirect.location;
-            redirect
-                .body_repr
-                .try_clone_from(&redirect.body, redirect.policy);
+            *redirect.request.uri_mut() = redirect.location;
+            redirect.body_repr.try_clone_from(&redirect.body);
+            redirect.policy.on_request(redirect.request);
 
-            let mut req = Request::from_parts(redirect.parts.clone(), redirect.body);
-            redirect.policy.on_request(&mut req);
-            redirect
-                .future
-                .set(Either::Right(Oneshot::new(redirect.service.clone(), req)));
+            redirect.future.set(Either::Right(Oneshot::new(
+                redirect.service.clone(),
+                redirect.request.clone().map(|_| redirect.body),
+            )));
 
             cx.waker().wake_by_ref();
             Poll::Pending
         }
         Action::Stop => Poll::Ready(Ok(redirect.res)),
-        Action::Pending(_) => Poll::Ready(Err(S::Error::from(
-            Error::redirect(
-                "Nested pending Action is not supported in redirect policy",
-                redirect.parts.uri.clone(),
-            )
-            .into(),
-        ))),
         Action::Error(err) => Poll::Ready(Err(err.into())),
+        Action::Pending(_) => unreachable!(),
     }
 }

data/vendor/wreq/src/client/layer/redirect/policy.rs

@@ -2,34 +2,10 @@
 
 use std::{fmt, pin::Pin};
 
-use http::{HeaderMap, Request, Response, StatusCode, Uri};
+use http::{HeaderMap, StatusCode, Uri};
 
 use crate::error::BoxError;
 
-/// Trait for the policy on handling redirection responses.
-pub trait Policy<B, E> {
-    /// Invoked when the service received a response with a redirection status code (`3xx`).
-    ///
-    /// This method returns an [`Action`] which indicates whether the service should follow
-    /// the redirection.
-    fn redirect(&mut self, attempt: Attempt<'_>) -> Result<Action, E>;
-
-    /// Returns whether redirection is currently permitted by this policy.
-    ///
-    /// This method is called to determine whether the client should follow redirects at all.
-    /// It allows policies to enable or disable redirection behavior based on the [`Request`].
-    fn follow_redirects(&mut self, _request: &mut Request<B>) -> bool;
-
-    /// Invoked right before the service makes a [`Request`].
-    fn on_request(&mut self, _request: &mut Request<B>);
-
-    /// Invoked right after the service received a [`Response`].
-    fn on_response<Body>(&mut self, _response: &mut Response<Body>);
-
-    /// Try to clone a request body before the service makes a redirected request.
-    fn clone_body(&self, _body: &B) -> Option<B>;
-}
-
 /// A type that holds information on a redirection attempt.
 pub struct Attempt<'a> {
     pub(crate) status: StatusCode,
@@ -38,7 +14,7 @@ pub struct Attempt<'a> {
     pub(crate) previous: &'a Uri,
 }
 
-/// A value returned by [`Policy::redirect`] which indicates the action
+/// A value which indicates the action
 /// [`FollowRedirect`][super::FollowRedirect] should take for a redirection response.
 pub enum Action {
     /// Follow the redirection.

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

@@ -10,11 +10,12 @@ use std::{
 
 use futures_util::future::Either;
 use http::{Request, Response};
-use http_body::Body;
+use http_body::Body as HttpBody;
 use tower::{BoxError, Layer, Service};
 
 use self::future::ResponseFuture;
-pub use self::policy::{Action, Attempt, Policy};
+pub use self::policy::{Action, Attempt};
+use crate::{client::body::Body, redirect::FollowRedirectPolicy};
 
 enum BodyRepr<B> {
     Some(B),
@@ -22,31 +23,25 @@ enum BodyRepr<B> {
     None,
 }
 
-impl<B> BodyRepr<B>
-where
-    B: Body + Default,
-{
-    fn take(&mut self) -> Option<B> {
+impl BodyRepr<Body> {
+    fn take(&mut self) -> Option<Body> {
         match mem::replace(self, BodyRepr::None) {
             BodyRepr::Some(body) => Some(body),
             BodyRepr::Empty => {
                 *self = BodyRepr::Empty;
-                Some(B::default())
+                Some(Body::default())
             }
             BodyRepr::None => None,
         }
     }
 
-    fn try_clone_from<P, E>(&mut self, body: &B, policy: &P)
-    where
-        P: Policy<B, E>,
-    {
+    fn try_clone_from(&mut self, body: &Body) {
         match self {
             BodyRepr::Some(_) | BodyRepr::Empty => {}
             BodyRepr::None => {
                 if body.size_hint().exact() == Some(0) {
-                    *self = BodyRepr::Some(B::default());
-                } else if let Some(cloned) = policy.clone_body(body) {
+                    *self = BodyRepr::Some(Body::default());
+                } else if let Some(cloned) = body.try_clone() {
                     *self = BodyRepr::Some(cloned);
                 }
             }
@@ -55,25 +50,24 @@ where
 }
 
 /// [`Layer`] for retrying requests with a [`Service`] to follow redirection responses.
-#[derive(Clone, Copy, Default)]
-pub struct FollowRedirectLayer<P> {
-    policy: P,
+#[derive(Clone)]
+pub struct FollowRedirectLayer {
+    policy: FollowRedirectPolicy,
 }
 
-impl<P> FollowRedirectLayer<P> {
-    /// Create a new [`FollowRedirectLayer`] with the given redirection [`Policy`].
+impl FollowRedirectLayer {
+    /// Create a new [`FollowRedirectLayer`] with the given redirection policy.
     #[inline(always)]
-    pub fn with_policy(policy: P) -> Self {
+    pub(crate) fn with_policy(policy: FollowRedirectPolicy) -> Self {
         FollowRedirectLayer { policy }
     }
 }
 
-impl<S, P> Layer<S> for FollowRedirectLayer<P>
+impl<S> Layer<S> for FollowRedirectLayer
 where
     S: Clone,
-    P: Clone,
 {
-    type Service = FollowRedirect<S, P>;
+    type Service = FollowRedirect<S>;
 
     #[inline(always)]
     fn layer(&self, inner: S) -> Self::Service {
@@ -82,63 +76,57 @@ where
 }
 
 /// Middleware that retries requests with a [`Service`] to follow redirection responses.
-#[derive(Clone, Copy)]
-pub struct FollowRedirect<S, P> {
+#[derive(Clone)]
+pub struct FollowRedirect<S> {
     inner: S,
-    policy: P,
+    policy: FollowRedirectPolicy,
 }
 
-impl<S, P> FollowRedirect<S, P>
-where
-    P: Clone,
-{
-    /// Create a new [`FollowRedirect`] with the given redirection [`Policy`].
+impl<S> FollowRedirect<S> {
+    /// Create a new [`FollowRedirect`] with the given redirection policy.
     #[inline(always)]
-    pub fn with_policy(inner: S, policy: P) -> Self {
+    fn with_policy(inner: S, policy: FollowRedirectPolicy) -> Self {
         FollowRedirect { inner, policy }
     }
 }
 
-impl<ReqBody, ResBody, S, P> Service<Request<ReqBody>> for FollowRedirect<S, P>
+impl<ResBody, S> Service<Request<Body>> for FollowRedirect<S>
 where
-    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Clone,
+    S: Service<Request<Body>, Response = Response<ResBody>> + Clone,
     S::Error: From<BoxError>,
-    P: Policy<ReqBody, S::Error> + Clone,
-    ReqBody: Body + Default,
 {
     type Response = Response<ResBody>;
     type Error = S::Error;
-    type Future = ResponseFuture<S, ReqBody, P>;
+    type Future = ResponseFuture<S>;
 
     #[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 {
-        if self.policy.follow_redirects(&mut req) {
-            let service = self.inner.clone();
-            let mut service = mem::replace(&mut self.inner, service);
-            let mut policy = self.policy.clone();
-
-            let mut body_repr = BodyRepr::None;
-            body_repr.try_clone_from(req.body(), &policy);
-            policy.on_request(&mut req);
-
-            let (parts, body) = req.into_parts();
-            let req = Request::from_parts(parts.clone(), body);
-            ResponseFuture::Redirect {
-                future: Either::Left(service.call(req)),
-                pending_future: None,
-                service,
-                policy,
-                parts,
-                body_repr,
-            }
-        } else {
-            ResponseFuture::Direct {
+    fn call(&mut self, mut req: Request<Body>) -> Self::Future {
+        let Some(mut policy) = self.policy.for_request(&mut req) else {
+            return ResponseFuture::Direct {
                 future: self.inner.call(req),
-            }
+            };
+        };
+
+        let service = self.inner.clone();
+        let mut service = mem::replace(&mut self.inner, service);
+
+        let mut body_repr = BodyRepr::None;
+        body_repr.try_clone_from(req.body());
+
+        policy.on_request(&mut req);
+        let (parts, body) = req.into_parts();
+        let request = Request::from_parts(parts, ());
+        ResponseFuture::Redirect {
+            future: Either::Left(service.call(request.clone().map(|_| body))),
+            pending_future: None,
+            service,
+            policy,
+            request,
+            body_repr,
         }
     }
 }

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

@@ -132,22 +132,19 @@ fn is_retryable_error(err: &(dyn StdError + 'static)) -> bool {
         return false;
     };
 
-    if let Some(cause) = err.source() {
-        if let Some(err) = cause.downcast_ref::<http2::Error>() {
-            // They sent us a graceful shutdown, try with a new connection!
-            if err.is_go_away() && err.is_remote() && err.reason() == Some(http2::Reason::NO_ERROR)
-            {
-                return true;
-            }
+    if let Some(cause) = err.source()
+        && let Some(err) = cause.downcast_ref::<http2::Error>()
+    {
+        // They sent us a graceful shutdown, try with a new connection!
+        if err.is_go_away() && err.is_remote() && err.reason() == Some(http2::Reason::NO_ERROR) {
+            return true;
+        }
 
-            // REFUSED_STREAM was sent from the server, which is safe to retry.
-            // https://www.rfc-editor.org/rfc/rfc9113.html#section-8.7-3.2
-            if err.is_reset()
-                && err.is_remote()
-                && err.reason() == Some(http2::Reason::REFUSED_STREAM)
-            {
-                return true;
-            }
+        // REFUSED_STREAM was sent from the server, which is safe to retry.
+        // https://www.rfc-editor.org/rfc/rfc9113.html#section-8.7-3.2
+        if err.is_reset() && err.is_remote() && err.reason() == Some(http2::Reason::REFUSED_STREAM)
+        {
+            return true;
         }
     }
     false