Move upgrade methods from Request to Response

Author: yoshuawuyts

src/request.rs

@@ -16,39 +16,6 @@ use crate::mime::Mime;
 use crate::trailers::{self, Trailers};
 use crate::{Body, Extensions, Method, StatusCode, Url, Version};
 
-cfg_unstable! {
-    use crate::upgrade;
-}
-
-#[cfg(not(feature = "unstable"))]
-pin_project_lite::pin_project! {
-    /// An HTTP request.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use http_types::{Url, Method, Request};
-    ///
-    /// let mut req = Request::new(Method::Get, Url::parse("https://example.com").unwrap());
-    /// req.set_body("Hello, Nori!");
-    /// ```
-    #[derive(Debug)]
-    pub struct Request {
-        method: Method,
-        url: Url,
-        headers: Headers,
-        version: Option<Version>,
-        #[pin]
-        body: Body,
-        local_addr: Option<String>,
-        peer_addr: Option<String>,
-        ext: Extensions,
-        trailers_sender: Option<sync::Sender<Trailers>>,
-        trailers_receiver: Option<sync::Receiver<Trailers>>,
-    }
-}
-
-#[cfg(feature = "unstable")]
 pin_project_lite::pin_project! {
     /// An HTTP request.
     ///
@@ -73,40 +40,11 @@ pin_project_lite::pin_project! {
         ext: Extensions,
         trailers_sender: Option<sync::Sender<Trailers>>,
         trailers_receiver: Option<sync::Receiver<Trailers>>,
-        upgrade_sender: Option<sync::Sender<upgrade::Connection>>,
-        upgrade_receiver: Option<sync::Receiver<upgrade::Connection>>,
     }
 }
 
 impl Request {
     /// Create a new request.
-    #[cfg(feature = "unstable")]
-    pub fn new<U>(method: Method, url: U) -> Self
-    where
-        U: TryInto<Url>,
-        U::Error: std::fmt::Debug,
-    {
-        let url = url.try_into().expect("Could not convert into a valid url");
-        let (trailers_sender, trailers_receiver) = sync::channel(1);
-        let (upgrade_sender, upgrade_receiver) = sync::channel(1);
-        Self {
-            method,
-            url,
-            headers: Headers::new(),
-            version: None,
-            body: Body::empty(),
-            ext: Extensions::new(),
-            peer_addr: None,
-            local_addr: None,
-            trailers_receiver: Some(trailers_receiver),
-            trailers_sender: Some(trailers_sender),
-            upgrade_sender: Some(upgrade_sender),
-            upgrade_receiver: Some(upgrade_receiver),
-        }
-    }
-
-    /// Create a new request.
-    #[cfg(not(feature = "unstable"))]
     pub fn new<U>(method: Method, url: U) -> Self
     where
         U: TryInto<Url>,
@@ -620,28 +558,6 @@ impl Request {
         trailers::Receiver::new(receiver)
     }
 
-    /// Sends an upgrade connection to the a receiver.
-    #[cfg(feature = "unstable")]
-    #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
-    pub fn send_upgrade(&mut self) -> upgrade::Sender {
-        let sender = self
-            .upgrade_sender
-            .take()
-            .expect("Upgrade sender can only be constructed once");
-        upgrade::Sender::new(sender)
-    }
-
-    /// Receive an upgraded connection from a sender.
-    #[cfg(feature = "unstable")]
-    #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
-    pub async fn recv_upgrade(&mut self) -> upgrade::Receiver {
-        let receiver = self
-            .upgrade_receiver
-            .take()
-            .expect("Upgrade receiver can only be constructed once");
-        upgrade::Receiver::new(receiver)
-    }
-
     /// An iterator visiting all header pairs in arbitrary order.
     pub fn iter(&self) -> headers::Iter<'_> {
         self.headers.iter()
@@ -953,10 +869,6 @@ impl Clone for Request {
             version: self.version.clone(),
             trailers_sender: None,
             trailers_receiver: None,
-            #[cfg(feature = "unstable")]
-            upgrade_sender: None,
-            #[cfg(feature = "unstable")]
-            upgrade_receiver: None,
             body: Body::empty(),
             ext: Extensions::new(),
             peer_addr: self.peer_addr.clone(),

src/response.rs

@@ -17,6 +17,42 @@ use crate::mime::Mime;
 use crate::trailers::{self, Trailers};
 use crate::{Body, Extensions, StatusCode, Version};
 
+cfg_unstable! {
+    use crate::upgrade;
+}
+
+#[cfg(not(feature = "unstable"))]
+pin_project_lite::pin_project! {
+    /// An HTTP response.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn main() -> Result<(), http_types::Error> {
+    /// #
+    /// use http_types::{Response, StatusCode};
+    ///
+    /// let mut res = Response::new(StatusCode::Ok);
+    /// res.set_body("Hello, Nori!");
+    /// #
+    /// # Ok(()) }
+    /// ```
+    #[derive(Debug)]
+    pub struct Response {
+        status: StatusCode,
+        headers: Headers,
+        version: Option<Version>,
+        trailers_sender: Option<sync::Sender<Trailers>>,
+        trailers_receiver: Option<sync::Receiver<Trailers>>,
+        #[pin]
+        body: Body,
+        ext: Extensions,
+        local_addr: Option<String>,
+        peer_addr: Option<String>,
+    }
+}
+
+#[cfg(feature = "unstable")]
 pin_project_lite::pin_project! {
     /// An HTTP response.
     ///
@@ -37,8 +73,10 @@ pin_project_lite::pin_project! {
         status: StatusCode,
         headers: Headers,
         version: Option<Version>,
-        sender: Option<sync::Sender<Trailers>>,
-        receiver: Option<sync::Receiver<Trailers>>,
+        trailers_sender: Option<sync::Sender<Trailers>>,
+        trailers_receiver: Option<sync::Receiver<Trailers>>,
+        upgrade_sender: Option<sync::Sender<upgrade::Connection>>,
+        upgrade_receiver: Option<sync::Receiver<upgrade::Connection>>,
         #[pin]
         body: Body,
         ext: Extensions,
@@ -49,6 +87,7 @@ pin_project_lite::pin_project! {
 
 impl Response {
     /// Create a new response.
+    #[cfg(not(feature = "unstable"))]
     pub fn new<S>(status: S) -> Self
     where
         S: TryInto<StatusCode>,
@@ -57,14 +96,41 @@ impl Response {
         let status = status
             .try_into()
             .expect("Could not convert into a valid `StatusCode`");
-        let (sender, receiver) = sync::channel(1);
+        let (trailers_sender, trailers_receiver) = sync::channel(1);
         Self {
             status,
             headers: Headers::new(),
             version: None,
             body: Body::empty(),
-            sender: Some(sender),
-            receiver: Some(receiver),
+            trailers_sender: Some(trailers_sender),
+            trailers_receiver: Some(trailers_receiver),
+            ext: Extensions::new(),
+            peer_addr: None,
+            local_addr: None,
+        }
+    }
+
+    /// Create a new response.
+    #[cfg(feature = "unstable")]
+    pub fn new<S>(status: S) -> Self
+    where
+        S: TryInto<StatusCode>,
+        S::Error: Debug,
+    {
+        let status = status
+            .try_into()
+            .expect("Could not convert into a valid `StatusCode`");
+        let (trailers_sender, trailers_receiver) = sync::channel(1);
+        let (upgrade_sender, upgrade_receiver) = sync::channel(1);
+        Self {
+            status,
+            headers: Headers::new(),
+            version: None,
+            body: Body::empty(),
+            trailers_sender: Some(trailers_sender),
+            trailers_receiver: Some(trailers_receiver),
+            upgrade_sender: Some(upgrade_sender),
+            upgrade_receiver: Some(upgrade_receiver),
             ext: Extensions::new(),
             peer_addr: None,
             local_addr: None,
@@ -457,7 +523,7 @@ impl Response {
     /// Sends trailers to the a receiver.
     pub fn send_trailers(&mut self) -> trailers::Sender {
         let sender = self
-            .sender
+            .trailers_sender
             .take()
             .expect("Trailers sender can only be constructed once");
         trailers::Sender::new(sender)
@@ -466,12 +532,34 @@ impl Response {
     /// Receive trailers from a sender.
     pub async fn recv_trailers(&mut self) -> trailers::Receiver {
         let receiver = self
-            .receiver
+            .trailers_receiver
             .take()
             .expect("Trailers receiver can only be constructed once");
         trailers::Receiver::new(receiver)
     }
 
+    /// Sends an upgrade connection to the a receiver.
+    #[cfg(feature = "unstable")]
+    #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
+    pub fn send_upgrade(&mut self) -> upgrade::Sender {
+        let sender = self
+            .upgrade_sender
+            .take()
+            .expect("Upgrade sender can only be constructed once");
+        upgrade::Sender::new(sender)
+    }
+
+    /// Receive an upgraded connection from a sender.
+    #[cfg(feature = "unstable")]
+    #[cfg_attr(feature = "docs", doc(cfg(unstable)))]
+    pub async fn recv_upgrade(&mut self) -> upgrade::Receiver {
+        let receiver = self
+            .upgrade_receiver
+            .take()
+            .expect("Upgrade receiver can only be constructed once");
+        upgrade::Receiver::new(receiver)
+    }
+
     /// An iterator visiting all header pairs in arbitrary order.
     pub fn iter(&self) -> headers::Iter<'_> {
         self.headers.iter()
@@ -526,8 +614,12 @@ impl Clone for Response {
             status: self.status.clone(),
             headers: self.headers.clone(),
             version: self.version.clone(),
-            sender: self.sender.clone(),
-            receiver: self.receiver.clone(),
+            trailers_sender: self.trailers_sender.clone(),
+            trailers_receiver: self.trailers_receiver.clone(),
+            #[cfg(feature = "unstable")]
+            upgrade_sender: self.upgrade_sender.clone(),
+            #[cfg(feature = "unstable")]
+            upgrade_receiver: self.upgrade_receiver.clone(),
             body: Body::empty(),
             ext: Extensions::new(),
             peer_addr: self.peer_addr.clone(),