tesaguri/twitter-client-rs - Change T7BC3YULOWGSGASSCX3Y6DXLCGX5NV5I6SHG2HIG36ABAXDQW3YAC

Add `RawRequest`/`RawResponse`

Created by tesaguri on January 19, 2021

T7BC3YULOWGSGASSCX3Y6DXLCGX5NV5I6SHG2HIG36ABAXDQW3YAC

Dependencies

In channels

main

Change contents

Replacement in src/response.rs at line 28 [3.14]
B:BD[3.666] → [4.1369:1408]
```
        inner: ResponseFutureInner<F>,
```
[3.666]
[3.708]
```
        raw: RawResponseFuture<F>,
```

Insertion in src/response.rs at line 30 [3.14]

[3.748]

    }
}
pin_project! {
    pub struct RawResponseFuture<F: HttpTryFuture> {
        #[pin]
        inner: ResponseFutureInner<F>,

Replacement in src/response.rs at line 42 [3.14]

B:BD[3.813] → [4.1409:1469]

    pub(crate) enum ResponseFutureInner<F: HttpTryFuture> {

[3.813]

[3.866]

    pub enum ResponseFutureInner<F: HttpTryFuture> {

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

B:BD[3.1262] → [4.1536:1735]

impl<T: de::DeserializeOwned, F: HttpTryFuture> ResponseFuture<T, F> {
    pub(crate) fn new<S, B>(req: http::Request<B>, http: &mut S) -> Self
    where
        S: HttpService<B, Future = F>,
    {

[3.1262]

[3.1417]

impl<T, F: HttpTryFuture> From<RawResponseFuture<F>> for ResponseFuture<T, F> {
    fn from(raw: RawResponseFuture<F>) -> Self {

Replacement in src/response.rs at line 67 [3.14]

B:BD[3.1442] → [5.84:140]

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

[3.1442]

[3.1569]

            raw,

Replacement in src/response.rs at line 78 [3.14]

B:BD[5.222] → [5.222:280]

        let res = ready!(self.project().inner.poll(cx)?);

[5.222]

[5.280]

        let res = ready!(self.project().raw.poll(cx)?);

Replacement in src/response.rs at line 87 [3.14]

B:BD[5.478] → [4.1902:1950]

impl<F: HttpTryFuture> ResponseFutureInner<F> {

[5.478]

[4.1950]

impl<F: HttpTryFuture> RawResponseFuture<F> {

Replacement in src/response.rs at line 92 [3.14]

∅:D[4.2078] → [5.610:646]

B:BD[5.610] → [5.610:646]

B:BD[5.646] → [4.2079:2124]

        ResponseFutureInner::Resp {
            response: http._call(req, Seal),

[4.2078]

[5.707]

        RawResponseFuture {
            inner: ResponseFutureInner::Resp {
                response: http._call(req, Seal),
            },

Replacement in src/response.rs at line 100 [3.14]

B:BD[5.726] → [4.2125:2184]

impl<F: HttpTryFuture> Future for ResponseFutureInner<F> {

[5.726]

[5.805]

impl<T, F: HttpTryFuture> From<ResponseFuture<T, F>> for RawResponseFuture<F> {
    fn from(future: ResponseFuture<T, F>) -> Self {
        future.raw
    }
}
impl<F: HttpTryFuture> Future for RawResponseFuture<F> {

Replacement in src/response.rs at line 111 [3.14]

B:BD[3.1936] → [5.938:1024]

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

[3.1936]

[4.2272]

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

Replacement in src/response.rs at line 115 [3.14]

B:BD[3.2121] → [5.1025:1261]

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

[3.2121]

[3.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()),
                });

Replacement in src/response.rs at line 129 [3.14]
B:BD[3.2560] → [5.1262:1289]
```
        } = self.project()
```
[3.2560]
[3.2603]
```
        } = self.project().inner.project()
```

File addition: request.rs (-rw-r--r--)

[6.6]

use http::header::{HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use http::{Method, Uri};
use oauth_credentials::Token;
use serde::de;
use crate::response::{RawResponseFuture, ResponseFuture};
use crate::traits::HttpService;
pub trait RawRequest: oauth::Request {
    const METHOD: Method;
    const URI: &'static str;
    fn send_raw<C, T, S, B>(
        &self,
        token: &Token<C, T>,
        http: &mut S,
    ) -> RawResponseFuture<S::Future>
    where
        C: AsRef<str>,
        T: AsRef<str>,
        S: HttpService<B>,
        B: From<Vec<u8>>,
    {
        let req = prepare_request(&Self::METHOD, Self::URI, self, token.as_ref());
        RawResponseFuture::new(req.map(Into::into), http)
    }
}
pub trait Request: RawRequest {
    type Data: de::DeserializeOwned;
    fn send<C, T, S, B>(
        &self,
        token: &Token<C, T>,
        http: &mut S,
    ) -> ResponseFuture<Self::Data, S::Future>
    where
        C: AsRef<str>,
        T: AsRef<str>,
        S: HttpService<B>,
        B: From<Vec<u8>>,
    {
        self.send_raw(token, http).into()
    }
}
fn prepare_request<R>(
    method: &Method,
    uri: &'static str,
    req: &R,
    token: Token<&str, &str>,
) -> http::Request<Vec<u8>>
where
    R: oauth::Request + ?Sized,
{
    let form = method == Method::POST;
    let mut oauth = oauth::Builder::new(token.client(), oauth::HmacSha1);
    oauth.token(token.token());
    let authorization = oauth.build(method.as_str(), uri, req);
    let http = http::Request::builder()
        .method(method)
        .header(AUTHORIZATION, authorization);
    if form {
        let data = oauth::to_form_urlencoded(req).into_bytes();
        http.uri(Uri::from_static(uri))
            .header(
                CONTENT_TYPE,
                HeaderValue::from_static("application/x-www-form-urlencoded"),
            )
            .body(data)
            .unwrap()
    } else {
        let uri = oauth::to_uri_query(uri.to_owned(), req);
        http.uri(uri).body(Vec::default()).unwrap()
    }
}

Insertion in src/lib.rs at line 3 [6.4397]
[3.3711]
[3.3711]
```
pub mod request;
```
Insertion in src/lib.rs at line 9 [6.4397]
[6.4427]
[3.3730]
```
pub use crate::request::Request;
```

Deletion in src/lib.rs at line 36 [6.4397]

∅:D[3.4560] → [6.9282:9290]

B:BD[6.9282] → [6.9282:9290]

B:BD[6.9290] → [6.9290:9291]

B:BD[6.13770] → [6.13770:13850]

B:BD[6.13850] → [2.145:175]

∅:D[2.175] → [6.13911:14019]

B:BD[6.13911] → [6.13911:14019]

B:BD[6.14019] → [2.176:282]

∅:D[2.282] → [6.14109:14719]

B:BD[6.14109] → [6.14109:14719]

    }
}
fn prepare_request<R>(
    method: &Method,
    uri: &'static str,
    req: &R,
    token: Token<&str, &str>,
) -> http::Request<Vec<u8>>
where
    R: oauth::Request + ?Sized,
{
    let form = method == Method::POST;
    let mut oauth = oauth::Builder::new(token.client(), oauth::HmacSha1);
    oauth.token(token.token());
    let authorization = oauth.build(method.as_str(), uri, req);
    let http = http::Request::builder()
        .method(method)
        .header(AUTHORIZATION, authorization);
    if form {
        let data = oauth::to_form_urlencoded(req).into_bytes();
        http.uri(Uri::from_static(uri))
            .header(
                CONTENT_TYPE,
                HeaderValue::from_static("application/x-www-form-urlencoded"),
            )
            .body(data)
            .unwrap()
    } else {
        let uri = oauth::to_uri_query(uri.to_owned(), req);
        http.uri(uri).body(Vec::default()).unwrap()

Replacement in src/auth.rs at line 15 [3.7044]

B:BD[3.7229] → [5.2329:2383]

use crate::response::{Response, ResponseFutureInner};

[3.7229]

[4.2478]

use crate::response::{RawResponseFuture, Response};

Replacement in src/auth.rs at line 26 [3.7044]
B:BD[5.2467] → [4.2578:2617]
```
        inner: ResponseFutureInner<F>,
```
[5.2467]
[5.2509]
```
        inner: RawResponseFuture<F>,
```

Replacement in src/auth.rs at line 37 [3.7044]

B:BD[5.2730] → [5.2730:2786]

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

[5.2730]

[5.2786]

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