tesaguri/twitter-client-rs - Change MV45TA67UIMNWDVRJUENF6JRRDCXYAUP2KJRUTUMBY3V2SSY6THAC

Make `crate::auth` functions return a nameable future

Created by tesaguri on January 18, 2021

MV45TA67UIMNWDVRJUENF6JRRDCXYAUP2KJRUTUMBY3V2SSY6THAC

Dependencies

[2] OX4PDDAAYMNRVC2HNEILNGDSHPQPPOMNBIBQCRW7NE6QFKFKB4XAC

In channels

main

Change contents

Insertion in src/response.rs at line 7 [2.14]
[2.143]
[2.143]
```
use bytes::Bytes;
```

Replacement in src/response.rs at line 36 [2.14]

B:BD[2.813] → [2.813:866]

    enum ResponseFutureInner<S: HttpService<B>, B> {

[2.813]

[2.866]

    pub(crate) enum ResponseFutureInner<S: HttpService<B>, B> {

Replacement in src/response.rs at line 64 [2.14]

B:BD[2.1442] → [2.1442:1569]

            inner: ResponseFutureInner::Resp {
                response: http._into_service(Seal).oneshot(req),
            },

[2.1442]

[2.1569]

            inner: ResponseFutureInner::new(req, http),

Insertion in src/response.rs at line 76 [2.14]

[2.1851]


    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let res = ready!(self.project().inner.poll(cx)?);
        let data = serde_json::from_slice(&res.data).map_err(Error::Deserializing)?;
        Poll::Ready(Ok(Response {
            data,
            rate_limit: res.rate_limit,
        }))
    }
}
impl<S, B> ResponseFutureInner<S, B>
where
    S: HttpService<B>,
{
    pub(crate) fn new(req: http::Request<B>, http: S) -> Self {
        ResponseFutureInner::Resp {
            response: http._into_service(Seal).oneshot(req),
        }
    }
}
impl<S, B> Future for ResponseFutureInner<S, B>
where
    S: HttpService<B>,
{
    #[allow(clippy::type_complexity)]
    type Output = Result<Response<Bytes>, Error<S::Error, <S::ResponseBody as Body>::Error>>;

Replacement in src/response.rs at line 106 [2.14]

B:BD[2.1936] → [2.1936:2046]

        if let ResponseFutureInnerProj::Resp { response } = self.as_mut().project().inner.project()
        {

[2.1936]

[2.2046]

        if let ResponseFutureInnerProj::Resp { response } = self.as_mut().project() {

Replacement in src/response.rs at line 109 [2.14]

B:BD[2.2121] → [2.2121:2440]

            self.as_mut()
                .project()
                .inner
                .set(ResponseFutureInner::Body {
                    status: res.status(),
                    rate_limit: RateLimit::from_headers(res.headers()),
                    body: ConcatBody::new(res.into_body()),
                });

[2.2121]

[2.2440]

            self.as_mut().set(ResponseFutureInner::Body {
                status: res.status(),
                rate_limit: RateLimit::from_headers(res.headers()),
                body: ConcatBody::new(res.into_body()),
            });

Replacement in src/response.rs at line 120 [2.14]
B:BD[2.2560] → [2.2560:2603]
```
        } = self.project().inner.project()
```
[2.2560]
[2.2603]
```
        } = self.project()
```

Insertion in src/response.rs at line 122 [2.14]

[2.2613]

            let status = *status;
            let rate_limit = *rate_limit;

Replacement in src/response.rs at line 126 [2.14]

B:BD[2.2682] → [2.2682:2849]

            Poll::Ready(make_response(*status, *rate_limit, &body, |body| {
                serde_json::from_slice(body).map_err(Error::Deserializing)
            }))

[2.2682]

[2.2849]

            let result = if let StatusCode::OK = status {
                Ok(Response {
                    data: body,
                    rate_limit,
                })
            } else {
                #[derive(Default, Deserialize)]
                struct Errors {
                    errors: Vec<ErrorCode>,
                }
                serde_json::from_slice(&body)
                    .or_else(|_| Ok(Errors::default()))
                    .and_then(|errors| {
                        Err(Error::Twitter(TwitterErrors {
                            status,
                            errors: errors.errors,
                            rate_limit,
                        }))
                    })
            };
            Poll::Ready(result)

Deletion in src/response.rs at line 150 [2.14]

B:BD[2.2894] → [2.2894:3356]

        }
    }
}
pub(crate) fn make_response<T, F, SE, BE>(
    status: StatusCode,
    rate_limit: Option<RateLimit>,
    body: &[u8],
    parse: F,
) -> Result<Response<T>, Error<SE, BE>>
where
    F: FnOnce(&[u8]) -> Result<T, Error<SE, BE>>,
{
    if let StatusCode::OK = status {
        parse(body).map(|data| Response { data, rate_limit })
    } else {
        #[derive(Default, Deserialize)]
        struct Errors {
            errors: Vec<ErrorCode>,

Deletion in src/response.rs at line 151 [2.14]

B:BD[2.3366] → [2.3366:3673]

        serde_json::from_slice(body)
            .or_else(|_| Ok(Errors::default()))
            .and_then(|errors| {
                Err(Error::Twitter(TwitterErrors {
                    status,
                    errors: errors.errors,
                    rate_limit,
                }))
            })

Insertion in src/auth.rs at line 1 [2.7044]

[2.7044]

[2.7045]

use std::future::Future;
use std::marker::PhantomData;
use std::pin::Pin;
use std::task::{Context, Poll};
use futures_core::ready;

Replacement in src/auth.rs at line 11 [2.7044]

B:BD[2.7150] → [2.7150:7203]

use serde::Deserialize;
use tower::util::ServiceExt;

[2.7150]

[2.7203]

use pin_project_lite::pin_project;
use serde::{de, Deserialize};

Replacement in src/auth.rs at line 15 [2.7044]
B:BD[2.7229] → [2.7229:7250]
```
use crate::response;
```
[2.7229]
[2.7250]
```
use crate::response::{Response, ResponseFutureInner};
```
Deletion in src/auth.rs at line 17 [2.7044]
B:BD[2.7283] → [2.7283:7354]
```
use crate::util::{ConcatBody, Seal};
use crate::{RateLimit, Response};
```

Replacement in src/auth.rs at line 25 [2.7044]

B:BD[2.7484] → [2.7484:7518]

pub async fn request_token<S, B>(

[2.7484]

[2.7518]

pin_project! {
    pub struct AuthFuture<T, S: HttpService<B>, B> {
        #[pin]
        inner: ResponseFutureInner<S, B>,
        marker: PhantomData<fn() -> T>,
    }
}
impl<T: de::DeserializeOwned, S, B> AuthFuture<T, S, B>
where
    S: HttpService<B>,
{
    pub(crate) fn new(req: http::Request<B>, http: S) -> Self {
        AuthFuture {
            inner: ResponseFutureInner::new(req, http),
            marker: PhantomData,
        }
    }
}
impl<T: de::DeserializeOwned, S: HttpService<B>, B> Future for AuthFuture<T, S, B> {
    #[allow(clippy::type_complexity)]
    type Output = Result<Response<T>, Error<S::Error, <S::ResponseBody as Body>::Error>>;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let res = ready!(self.project().inner.poll(cx)?);
        let data = serde_urlencoded::from_bytes(&res.data).map_err(|_| Error::Unexpected)?;
        Poll::Ready(Ok(Response {
            data,
            rate_limit: res.rate_limit,
        }))
    }
}
pub fn request_token<S, B>(

Replacement in src/auth.rs at line 62 [2.7044]

B:BD[2.7576] → [2.7576:7672]

) -> Result<Response<Credentials<Box<str>>>, Error<S::Error, <S::ResponseBody as Body>::Error>>

[2.7576]

[2.7672]

) -> AuthFuture<Credentials<Box<str>>, S, B>

Replacement in src/auth.rs at line 78 [2.7044]

B:BD[2.8102] → [2.8102:8528]

    let res = client
        ._into_service(Seal)
        .oneshot(req)
        .await
        .map_err(Error::Service)?;
    let status = res.status();
    let rate_limit = RateLimit::from_headers(res.headers());
    let body = ConcatBody::new(res).await.map_err(Error::Body)?;
    response::make_response(status, rate_limit, &body, |body| {
        serde_urlencoded::from_bytes(body).map_err(|_| Error::Unexpected)
    })

[2.8102]

[2.8528]

    AuthFuture::new(req, client)

Replacement in src/auth.rs at line 81 [2.7044]
B:BD[2.8531] → [2.8531:8568]
```
pub async fn access_token<'a, S, B>(
```
[2.8531]
[2.8568]
```
pub fn access_token<'a, S, B>(
```

Replacement in src/auth.rs at line 86 [2.7044]

B:BD[2.8707] → [2.8707:8793]

) -> Result<Response<AccessToken>, Error<S::Error, <S::ResponseBody as Body>::Error>>

[2.8707]

[2.8793]

) -> AuthFuture<AccessToken, S, B>

Replacement in src/auth.rs at line 103 [2.7044]

B:BD[2.9261] → [2.9261:9687]

    let res = client
        ._into_service(Seal)
        .oneshot(req)
        .await
        .map_err(Error::Service)?;
    let status = res.status();
    let rate_limit = RateLimit::from_headers(res.headers());
    let body = ConcatBody::new(res).await.map_err(Error::Body)?;
    response::make_response(status, rate_limit, &body, |body| {
        serde_urlencoded::from_bytes(body).map_err(|_| Error::Unexpected)
    })

[2.9261]

[2.9687]

    AuthFuture::new(req, client)