src/response.rs

use crate::Body;
use bytes::Bytes;
use http::{header, HeaderMap, HeaderValue, Response, StatusCode};
use serde::Serialize;
use std::{borrow::Cow, convert::Infallible};
use tower::util::Either;

pub trait IntoResponse {
    fn into_response(self) -> Response<Body>;
}

impl IntoResponse for () {
    fn into_response(self) -> Response<Body> {
        Response::new(Body::empty())
    }
}

impl IntoResponse for Infallible {
    fn into_response(self) -> Response<Body> {
        match self {}
    }
}

impl<T, K> IntoResponse for Either<T, K>
where
    T: IntoResponse,
    K: IntoResponse,
{
    fn into_response(self) -> Response<Body> {
        match self {
            Either::A(inner) => inner.into_response(),
            Either::B(inner) => inner.into_response(),
        }
    }
}

impl<T, E> IntoResponse for Result<T, E>
where
    T: IntoResponse,
    E: IntoResponse,
{
    fn into_response(self) -> Response<Body> {
        match self {
            Ok(value) => value.into_response(),
            Err(err) => err.into_response(),
        }
    }
}

impl IntoResponse for Response<Body> {
    fn into_response(self) -> Self {
        self
    }
}

impl IntoResponse for &'static str {
    #[inline]
    fn into_response(self) -> Response<Body> {
        Cow::Borrowed(self).into_response()
    }
}

impl IntoResponse for String {
    #[inline]
    fn into_response(self) -> Response<Body> {
        Cow::<'static, str>::Owned(self).into_response()
    }
}

impl IntoResponse for std::borrow::Cow<'static, str> {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut()
            .insert(header::CONTENT_TYPE, HeaderValue::from_static("text/plain"));
        res
    }
}

impl IntoResponse for Bytes {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for &'static [u8] {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for Vec<u8> {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for std::borrow::Cow<'static, [u8]> {
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(Body::from(self));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/octet-stream"),
        );
        res
    }
}

impl IntoResponse for StatusCode {
    fn into_response(self) -> Response<Body> {
        Response::builder()
            .status(self)
            .body(Body::empty())
            .unwrap()
    }
}

impl<T> IntoResponse for (StatusCode, T)
where
    T: Into<Body>,
{
    fn into_response(self) -> Response<Body> {
        Response::builder()
            .status(self.0)
            .body(self.1.into())
            .unwrap()
    }
}

impl<T> IntoResponse for (StatusCode, HeaderMap, T)
where
    T: Into<Body>,
{
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(self.2.into());
        *res.status_mut() = self.0;
        *res.headers_mut() = self.1;
        res
    }
}

pub struct Html<T>(pub T);

impl<T> IntoResponse for Html<T>
where
    T: Into<Body>,
{
    fn into_response(self) -> Response<Body> {
        let mut res = Response::new(self.0.into());
        res.headers_mut()
            .insert(header::CONTENT_TYPE, HeaderValue::from_static("text/html"));
        res
    }
}

pub struct Json<T>(pub T);

impl<T> IntoResponse for Json<T>
where
    T: Serialize,
{
    fn into_response(self) -> Response<Body> {
        let bytes = match serde_json::to_vec(&self.0) {
            Ok(res) => res,
            Err(err) => {
                return Response::builder()
                    .header(header::CONTENT_TYPE, "text/plain")
                    .body(Body::from(err.to_string()))
                    .unwrap();
            }
        };

        let mut res = Response::new(Body::from(bytes));
        res.headers_mut().insert(
            header::CONTENT_TYPE,
            HeaderValue::from_static("application/json"),
        );
        res
    }
}
This changes everything 2021-05-31 22:54:21 +02:00			`use crate::Body;`
Break things into modules 2021-05-30 13:24:03 +02:00			`use bytes::Bytes;`
Some simplifications 2021-06-01 08:32:58 +02:00			`use http::{header, HeaderMap, HeaderValue, Response, StatusCode};`
Break things into modules 2021-05-30 13:24:03 +02:00			`use serde::Serialize;`
Write some docs 2021-06-06 15:19:54 +02:00			`use std::{borrow::Cow, convert::Infallible};`
Some simplifications 2021-06-01 08:32:58 +02:00			`use tower::util::Either;`
Break things into modules 2021-05-30 13:24:03 +02:00
Remove some needless type params 2021-06-06 22:41:52 +02:00			`pub trait IntoResponse {`
			`fn into_response(self) -> Response<Body>;`
This changes everything 2021-05-31 22:54:21 +02:00			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for () {`
Write some docs 2021-06-06 15:19:54 +02:00			`fn into_response(self) -> Response<Body> {`
			`Response::new(Body::empty())`
This changes everything 2021-05-31 22:54:21 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Infallible {`
			`fn into_response(self) -> Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`match self {}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T, K> IntoResponse for Either<T, K>`
Don't force handlers to return `Result`s 2021-05-31 20:42:57 +02:00			`where`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`T: IntoResponse,`
			`K: IntoResponse,`
Don't force handlers to return `Result`s 2021-05-31 20:42:57 +02:00			`{`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`fn into_response(self) -> Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`match self {`
			`Either::A(inner) => inner.into_response(),`
			`Either::B(inner) => inner.into_response(),`
			`}`
			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T, E> IntoResponse for Result<T, E>`
This changes everything 2021-05-31 22:54:21 +02:00			`where`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`T: IntoResponse,`
			`E: IntoResponse,`
This changes everything 2021-05-31 22:54:21 +02:00			`{`
Remove some needless type params 2021-06-06 22:41:52 +02:00			`fn into_response(self) -> Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`match self {`
			`Ok(value) => value.into_response(),`
			`Err(err) => err.into_response(),`
			`}`
Don't force handlers to return `Result`s 2021-05-31 20:42:57 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Response<Body> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Self {`
			`self`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for &'static str {`
Write some docs 2021-06-06 15:19:54 +02:00			`#[inline]`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Write some docs 2021-06-06 15:19:54 +02:00			`Cow::Borrowed(self).into_response()`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for String {`
Write some docs 2021-06-06 15:19:54 +02:00			`#[inline]`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Write some docs 2021-06-06 15:19:54 +02:00			`Cow::<'static, str>::Owned(self).into_response()`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for std::borrow::Cow<'static, str> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Write some docs 2021-06-06 15:19:54 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut()`
			`.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/plain"));`
			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Bytes {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for &'static [u8] {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for Vec<u8> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for std::borrow::Cow<'static, [u8]> {`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Add example 2021-05-30 14:33:20 +02:00			`let mut res = Response::new(Body::from(self));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/octet-stream"),`
			`);`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Break things into modules 2021-05-30 13:24:03 +02:00			`}`
			`}`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl IntoResponse for StatusCode {`
Write some docs 2021-06-06 15:19:54 +02:00			`fn into_response(self) -> Response<Body> {`
			`Response::builder()`
			`.status(self)`
			`.body(Body::empty())`
			`.unwrap()`
Move things around a bit 2021-06-06 11:37:08 +02:00			`}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for (StatusCode, T)`
Break things into modules 2021-05-30 13:24:03 +02:00			`where`
Move things around a bit 2021-06-06 11:37:08 +02:00			`T: Into<Body>,`
Break things into modules 2021-05-30 13:24:03 +02:00			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Move things around a bit 2021-06-06 11:37:08 +02:00			`Response::builder()`
			`.status(self.0)`
			`.body(self.1.into())`
			`.unwrap()`
			`}`
			`}`
This changes everything 2021-05-31 22:54:21 +02:00
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for (StatusCode, HeaderMap, T)`
Move things around a bit 2021-06-06 11:37:08 +02:00			`where`
			`T: Into<Body>,`
			`{`
			`fn into_response(self) -> Response<Body> {`
			`let mut res = Response::new(self.2.into());`
			`*res.status_mut() = self.0;`
			`*res.headers_mut() = self.1;`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Add example 2021-05-30 14:33:20 +02:00			`}`
			`}`
Break things into modules 2021-05-30 13:24:03 +02:00
Add `Html` response type 2021-05-31 10:20:07 +02:00			`pub struct Html<T>(pub T);`

Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for Html<T>`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`where`
Move things around a bit 2021-06-06 11:37:08 +02:00			`T: Into<Body>,`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`{`
This changes everything 2021-05-31 22:54:21 +02:00			`fn into_response(self) -> Response<Body> {`
Move things around a bit 2021-06-06 11:37:08 +02:00			`let mut res = Response::new(self.0.into());`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`res.headers_mut()`
			`.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/html"));`
This changes everything 2021-05-31 22:54:21 +02:00			`res`
Add `Html` response type 2021-05-31 10:20:07 +02:00			`}`
			`}`

Move things around a bit 2021-06-06 11:37:08 +02:00			`pub struct Json<T>(pub T);`
More error handling 2021-06-01 00:34:09 +02:00
Remove some needless type params 2021-06-06 22:41:52 +02:00			`impl<T> IntoResponse for Json<T>`
More error handling 2021-06-01 00:34:09 +02:00			`where`
Move things around a bit 2021-06-06 11:37:08 +02:00			`T: Serialize,`
More error handling 2021-06-01 00:34:09 +02:00			`{`
			`fn into_response(self) -> Response<Body> {`
Move things around a bit 2021-06-06 11:37:08 +02:00			`let bytes = match serde_json::to_vec(&self.0) {`
			`Ok(res) => res,`
			`Err(err) => {`
			`return Response::builder()`
			`.header(header::CONTENT_TYPE, "text/plain")`
			`.body(Body::from(err.to_string()))`
			`.unwrap();`
			`}`
			`};`

			`let mut res = Response::new(Body::from(bytes));`
			`res.headers_mut().insert(`
			`header::CONTENT_TYPE,`
			`HeaderValue::from_static("application/json"),`
			`);`
			`res`
More error handling 2021-06-01 00:34:09 +02:00			`}`
			`}`