fix: store history in an ext instead of Response struct

unusual-thoughts · unusual-thoughts · commit 5159862e6afb · 2025-05-18T18:34:16.000+02:00
diff --git a/src/async_impl/client.rs b/src/async_impl/client.rs
@@ -30,6 +30,7 @@ use crate::dns::{gai::GaiResolver, DnsResolverWithOverrides, DynResolver, Resolv
 use crate::error::{self, BoxError};
 use crate::into_url::try_uri;
 use crate::redirect::{self, remove_sensitive_headers};
+use crate::response::History;
 #[cfg(feature = "__rustls")]
 use crate::tls::CertificateRevocationList;
 #[cfg(feature = "__tls")]
@@ -2851,7 +2852,7 @@ impl Future for PendingRequest {
         }
 
         loop {
-            let res = match self.as_mut().in_flight().get_mut() {
+            let mut res = match self.as_mut().in_flight().get_mut() {
                 ResponseFuture::Default(r) => match Pin::new(r).poll(cx) {
                     Poll::Ready(Err(e)) => {
                         #[cfg(feature = "http2")]
@@ -3032,10 +3033,12 @@ impl Future for PendingRequest {
                 }
             }
 
+            res.extensions_mut()
+                .insert(History(mem::take(&mut self.urls)));
+
             let res = Response::new(
                 res,
                 self.url.clone(),
-                mem::take(&mut self.urls),
                 self.client.accepts,
                 self.total_timeout.take(),
                 self.read_timeout,
diff --git a/src/async_impl/response.rs b/src/async_impl/response.rs
@@ -19,6 +19,7 @@ use super::decoder::{Accepts, Decoder};
 use crate::async_impl::body::ResponseBody;
 #[cfg(feature = "cookies")]
 use crate::cookie;
+use crate::response::History;
 
 #[cfg(feature = "charset")]
 use encoding_rs::{Encoding, UTF_8};
@@ -31,14 +32,12 @@ pub struct Response {
     // Boxed to save space (11 words to 1 word), and it's not accessed
     // frequently internally.
     url: Box<Url>,
-    history: Vec<Url>,
 }
 
 impl Response {
     pub(super) fn new(
         res: hyper::Response<ResponseBody>,
         url: Url,
-        history: Vec<Url>,
         accepts: Accepts,
         total_timeout: Option<Pin<Box<Sleep>>>,
         read_timeout: Option<Duration>,
@@ -54,7 +53,6 @@ impl Response {
         Response {
             res,
             url: Box::new(url),
-            history,
         }
     }
 
@@ -122,14 +120,18 @@ impl Response {
     /// Get all the intermediate `Url`s traversed by redirects.
     #[inline]
     pub fn history(&self) -> &[Url] {
-        &self.history
+        &self
+            .extensions()
+            .get::<History>()
+            .map(|h| &h.0)
+            .expect("history extension")
     }
 
     /// Get all the `Url`s, in sequential order, that were requested,
     /// including any redirects and the final url.
     #[inline]
     pub fn all_urls(&self) -> impl Iterator<Item = &Url> {
-        self.history
+        self.history()
             .iter()
             .chain(std::iter::once(self.url.as_ref()))
     }
@@ -488,11 +490,11 @@ impl<T: Into<Body>> From<http::Response<T>> for Response {
             .remove::<ResponseUrl>()
             .unwrap_or_else(|| ResponseUrl(Url::parse("http://no.url.provided.local").unwrap()));
         let url = url.0;
+        parts.extensions.get_or_insert_default::<History>();
         let res = hyper::Response::from_parts(parts, decoder);
         Response {
             res,
             url: Box::new(url),
-            history: vec![],
         }
     }
 }
diff --git a/src/response.rs b/src/response.rs
@@ -3,39 +3,61 @@ use url::Url;
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct ResponseUrl(pub Url);
 
+/// Response [`Extensions`][http::Extensions] value that represents intermediate `Url`s traversed by redirects
+#[derive(Debug, Clone, Default, PartialEq)]
+pub(crate) struct History(pub Vec<Url>);
+
 /// Extension trait for http::response::Builder objects
 ///
 /// Allows the user to add a `Url` to the http::Response
 pub trait ResponseBuilderExt {
     /// A builder method for the `http::response::Builder` type that allows the user to add a `Url`
     /// to the `http::Response`
     fn url(self, url: Url) -> Self;
+
+    /// A builder method for the `http::response::Builder` type that allows the user to add redirect history
+    /// to the `http::Response`
+    fn history(self, history: Vec<Url>) -> Self;
 }
 
 impl ResponseBuilderExt for http::response::Builder {
     fn url(self, url: Url) -> Self {
         self.extension(ResponseUrl(url))
     }
+
+    fn history(self, history: Vec<Url>) -> Self {
+        self.extension(History(history))
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{ResponseBuilderExt, ResponseUrl};
+    use super::{History, ResponseBuilderExt, ResponseUrl};
     use http::response::Builder;
     use url::Url;
 
     #[test]
     fn test_response_builder_ext() {
-        let url = Url::parse("http://example.com").unwrap();
+        let history = vec![
+            Url::parse("http://initial.com").unwrap(),
+            Url::parse("http://intermediate.com").unwrap(),
+        ];
+        let url = Url::parse("http://final.com").unwrap();
         let response = Builder::new()
             .status(200)
             .url(url.clone())
+            .history(history.clone())
             .body(())
             .unwrap();
 
         assert_eq!(
             response.extensions().get::<ResponseUrl>(),
             Some(&ResponseUrl(url))
         );
+
+        assert_eq!(
+            response.extensions().get::<History>(),
+            Some(&History(history))
+        );
     }
 }
