Status should take TryInto<StatusCode>

src/response.rs

@@ -98,7 +98,7 @@ impl Response {
  /// ```
  /// # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
  /// #
- /// use http_types::{Url, Method, Response, StatusCode};
+ /// use http_types::{Method, Response, StatusCode, Url};
  ///
  /// let mut req = Response::new(StatusCode::Ok);
  /// req.insert_header("Content-Type", "text/plain");
@@ -115,8 +115,9 @@ impl Response {
 
  /// Append a header to the headers.
  ///
- /// Unlike `insert` this function will not override the contents of a header, but insert a
- /// header if there aren't any. Or else append to the existing list of headers.
+ /// Unlike `insert` this function will not override the contents of a
+ /// header, but insert a header if there aren't any. Or else append to
+ /// the existing list of headers.
  ///
  /// # Examples
  ///
@@ -161,7 +162,7 @@ impl Response {
  /// # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
  /// # async_std::task::block_on(async {
  /// #
- /// use http_types::{Body, Url, Method, Response, StatusCode};
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
  /// let mut req = Response::new(StatusCode::Ok);
  /// req.set_body("Hello, Nori!");
@@ -190,7 +191,7 @@ impl Response {
  /// # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
  /// # async_std::task::block_on(async {
  /// #
- /// use http_types::{Body, Url, Method, Response, StatusCode};
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
  /// let mut req = Response::new(StatusCode::Ok);
  /// req.set_body("Hello, Nori!");
@@ -218,7 +219,7 @@ impl Response {
  /// # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
  /// # async_std::task::block_on(async {
  /// #
- /// use http_types::{Body, Url, Method, Response, StatusCode};
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
  /// let mut req = Response::new(StatusCode::Ok);
  /// req.set_body("Hello, Nori!");
@@ -251,10 +252,10 @@ impl Response {
  /// # use std::io::prelude::*;
  /// # fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
  /// # async_std::task::block_on(async {
- /// use http_types::{Body, Url, Method, Response, StatusCode}; 
  /// use async_std::io::Cursor;
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
- /// let mut res = Response::new(StatusCode::Ok); 
+ /// let mut res = Response::new(StatusCode::Ok);
  /// let cursor = Cursor::new("Hello Nori");
  /// let body = Body::from_reader(cursor, None);
  /// res.set_body(body);
@@ -277,7 +278,7 @@ impl Response {
  ///
  /// ```
  /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
- /// use http_types::{Body, Url, Method, Response, StatusCode};
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
  /// let bytes = vec![1, 2, 3];
  /// let mut res = Response::new(StatusCode::Ok);
@@ -303,14 +304,18 @@ impl Response {
  ///
  /// ```
  /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
- /// use http_types::{Body, Url, Method, Response, StatusCode}; 
- /// use http_types::convert::{Serialize, Deserialize};
+ /// use http_types::convert::{Deserialize, Serialize};
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
  /// #[derive(Debug, Serialize, Deserialize)]
- /// struct Cat { name: String }
+ /// struct Cat {
+ /// name: String,
+ /// }
  ///
- /// let cat = Cat { name: String::from("chashu") };
- /// let mut res = Response::new(StatusCode::Ok); 
+ /// let cat = Cat {
+ /// name: String::from("chashu"),
+ /// };
+ /// let mut res = Response::new(StatusCode::Ok);
  /// res.set_body(Body::from_json(&cat)?);
  ///
  /// let cat: Cat = res.body_json().await?;
@@ -333,14 +338,18 @@ impl Response {
  ///
  /// ```
  /// # fn main() -> Result<(), http_types::Error> { async_std::task::block_on(async {
- /// use http_types::{Body, Url, Method, Response, StatusCode}; 
- /// use http_types::convert::{Serialize, Deserialize};
+ /// use http_types::convert::{Deserialize, Serialize};
+ /// use http_types::{Body, Method, Response, StatusCode, Url};
  ///
  /// #[derive(Debug, Serialize, Deserialize)]
- /// struct Cat { name: String }
+ /// struct Cat {
+ /// name: String,
+ /// }
  ///
- /// let cat = Cat { name: String::from("chashu") };
- /// let mut res = Response::new(StatusCode::Ok); 
+ /// let cat = Cat {
+ /// name: String::from("chashu"),
+ /// };
+ /// let mut res = Response::new(StatusCode::Ok);
  /// res.set_body(Body::from_form(&cat)?);
  ///
  /// let cat: Cat = res.body_form().await?;
@@ -374,14 +383,16 @@ impl Response {
 
  /// Get the length of the body stream, if it has been set.
  ///
- /// This value is set when passing a fixed-size object into as the body. E.g. a string, or a
- /// buffer. Consumers of this API should check this value to decide whether to use `Chunked`
- /// encoding, or set the response length.
+ /// This value is set when passing a fixed-size object into as the body.
+ /// E.g. a string, or a buffer. Consumers of this API should check this
+ /// value to decide whether to use `Chunked` encoding, or set the
+ /// response length.
  pub fn len(&self) -> Option<usize> {
  self.body.len()
  }
 
- /// Returns `true` if the set length of the body stream is zero, `false` otherwise.
+ /// Returns `true` if the set length of the body stream is zero, `false`
+ /// otherwise.
  pub fn is_empty(&self) -> Option<bool> {
  self.body.is_empty()
  }
@@ -426,7 +437,8 @@ impl Response {
  self.peer_addr.as_deref()
  }
 
- /// Get the local socket address for the underlying transport, if appropriate
+ /// Get the local socket address for the underlying transport, if
+ /// appropriate
  pub fn local_addr(&self) -> Option<&str> {
  self.local_addr.as_deref()
  }
@@ -477,8 +489,8 @@ impl Response {
  self.headers.iter()
  }
 
- /// An iterator visiting all header pairs in arbitrary order, with mutable references to the
- /// values.
+ /// An iterator visiting all header pairs in arbitrary order, with mutable
+ /// references to the values.
  pub fn iter_mut(&mut self) -> headers::IterMut<'_> {
  self.headers.iter_mut()
  }
@@ -506,7 +518,7 @@ impl Response {
  /// ```
  /// # fn main() -> Result<(), http_types::Error> {
  /// #
- /// use http_types::{StatusCode, Response, Version};
+ /// use http_types::{Response, StatusCode, Version};
  ///
  /// let mut res = Response::new(StatusCode::Ok);
  /// res.ext_mut().insert("hello from the extension");
@@ -520,7 +532,8 @@ impl Response {
 }
 
 impl Clone for Response {
- /// Clone the response, resolving the body to `Body::empty()` and removing extensions.
+ /// Clone the response, resolving the body to `Body::empty()` and removing
+ /// extensions.
  fn clone(&self) -> Self {
  Self {
  status: self.status.clone(),
@@ -656,8 +669,15 @@ impl<'a> IntoIterator for &'a mut Response {
 #[cfg(test)]
 mod test {
  use super::Response;
+
  #[test]
- fn construct_shorthand() {
+ fn construct_shorthand_with_valid_status_code() {
  let _res = Response::new(200);
  }
+
+ #[test]
+ #[should_panic(expected = "Could not convert into a valid `StatusCode`")]
+ fn construct_shorthand_with_invalid_status_code() {
+ let _res = Response::new(600);
+ }
 }

src/status.rs

@@ -1,6 +1,7 @@
 use crate::{Error, StatusCode};
-use core::convert::{Infallible, Into};
+use core::convert::{Infallible, TryInto};
 use std::error::Error as StdError;
+use std::fmt::Debug;
 
 /// Provides the `status` method for `Result` and `Option`.
 ///
@@ -9,60 +10,108 @@ pub trait Status<T, E>: private::Sealed {
  /// Wrap the error value with an additional status code.
  fn status<S>(self, status: S) -> Result<T, Error>
  where
- S: Into<StatusCode>;
+ S: TryInto<StatusCode>,
+ S::Error: Debug;
 
  /// Wrap the error value with an additional status code that is evaluated
  /// lazily only once an error does occur.
  fn with_status<S, F>(self, f: F) -> Result<T, Error>
  where
- S: Into<StatusCode>,
+ S: TryInto<StatusCode>,
+ S::Error: Debug,
  F: FnOnce() -> S;
 }
 
 impl<T, E> Status<T, E> for Result<T, E>
 where
  E: StdError + Send + Sync + 'static,
 {
+ /// Wrap the error value with an additional status code.
+ ///
+ /// # Panics
+ ///
+ /// Panics if [`Status`][status] is not a valid [`StatusCode`][statuscode].
+ ///
+ /// [status]: crate::Status
+ /// [statuscode]: crate::StatusCode
  fn status<S>(self, status: S) -> Result<T, Error>
  where
- S: Into<StatusCode>,
+ S: TryInto<StatusCode>,
+ S::Error: Debug,
  {
  self.map_err(|error| {
- let status = status.into();
+ let status = status
+ .try_into()
+ .expect("Could not convert into a valid `StatusCode`");
  Error::new(status, error)
  })
  }
 
+ /// Wrap the error value with an additional status code that is evaluated
+ /// lazily only once an error does occur.
+ ///
+ /// # Panics
+ ///
+ /// Panics if [`Status`][status] is not a valid [`StatusCode`][statuscode].
+ ///
+ /// [status]: crate::Status
+ /// [statuscode]: crate::StatusCode
  fn with_status<S, F>(self, f: F) -> Result<T, Error>
  where
- S: Into<StatusCode>,
+ S: TryInto<StatusCode>,
+ S::Error: Debug,
  F: FnOnce() -> S,
  {
  self.map_err(|error| {
- let status = f().into();
+ let status = f()
+ .try_into()
+ .expect("Could not convert into a valid `StatusCode`");
  Error::new(status, error)
  })
  }
 }
 
 impl<T> Status<T, Infallible> for Option<T> {
+ /// Wrap the error value with an additional status code.
+ ///
+ /// # Panics
+ ///
+ /// Panics if [`Status`][status] is not a valid [`StatusCode`][statuscode].
+ ///
+ /// [status]: crate::Status
+ /// [statuscode]: crate::StatusCode
  fn status<S>(self, status: S) -> Result<T, Error>
  where
- S: Into<StatusCode>,
+ S: TryInto<StatusCode>,
+ S::Error: Debug,
  {
  self.ok_or_else(|| {
- let status = status.into();
+ let status = status
+ .try_into()
+ .expect("Could not convert into a valid `StatusCode`");
  Error::from_str(status, "NoneError")
  })
  }
 
+ /// Wrap the error value with an additional status code that is evaluated
+ /// lazily only once an error does occur.
+ ///
+ /// # Panics
+ ///
+ /// Panics if [`Status`][status] is not a valid [`StatusCode`][statuscode].
+ ///
+ /// [status]: crate::Status
+ /// [statuscode]: crate::StatusCode
  fn with_status<S, F>(self, f: F) -> Result<T, Error>
  where
- S: Into<StatusCode>,
+ S: TryInto<StatusCode>,
+ S::Error: Debug,
  F: FnOnce() -> S,
  {
  self.ok_or_else(|| {
- let status = f().into();
+ let status = f()
+ .try_into()
+ .expect("Could not convert into a valid `StatusCode`");
  Error::from_str(status, "NoneError")
  })
  }
@@ -74,3 +123,21 @@ pub(crate) mod private {
  impl<T, E> Sealed for Result<T, E> {}
  impl<T> Sealed for Option<T> {}
 }
+
+#[cfg(test)]
+mod test {
+ use super::Status;
+
+ #[test]
+ fn construct_shorthand_with_valid_status_code() {
+ let _res = Some(()).status(200).unwrap();
+ }
+
+ #[test]
+ #[should_panic(expected = "Could not convert into a valid `StatusCode`")]
+ fn construct_shorthand_with_invalid_status_code() {
+ let res: Result<(), std::io::Error> =
+ Err(std::io::Error::new(std::io::ErrorKind::Other, "oh no!"));
+ let _res = res.status(600).unwrap();
+ }
+}