tesaguri/twitter-client-rs - Change OX4PDDAAYMNRVC2HNEILNGDSHPQPPOMNBIBQCRW7NE6QFKFKB4XAC

Split modules

Created by tesaguri on January 17, 2021

OX4PDDAAYMNRVC2HNEILNGDSHPQPPOMNBIBQCRW7NE6QFKFKB4XAC

Dependencies

[2] FRMT7RO7G2QNNLXMR2524IU6MV42ISMNXRISWT56JSDB2WCBQN6QC

In channels

main

Change contents

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

[2.6]

use std::future::Future;
use std::marker::PhantomData;
use std::ops::Deref;
use std::pin::Pin;
use std::task::{Context, Poll};
use futures_core::ready;
use http::StatusCode;
use http_body::Body;
use pin_project_lite::pin_project;
use serde::{de, Deserialize};
use tower::util::{Oneshot, ServiceExt};
use crate::error::{Error, ErrorCode, TwitterErrors};
use crate::service::{HttpService, IntoService};
use crate::util::{ConcatBody, Seal};
use crate::RateLimit;
#[derive(Debug)]
pub struct Response<T> {
    pub data: T,
    pub rate_limit: Option<RateLimit>,
}
pin_project! {
    pub struct ResponseFuture<T, S: HttpService<B>, B> {
        #[pin]
        inner: ResponseFutureInner<S, B>,
        marker: PhantomData<fn() -> T>,
    }
}
pin_project! {
    #[project = ResponseFutureInnerProj]
    enum ResponseFutureInner<S: HttpService<B>, B> {
        Resp {
            #[pin]
            response: Oneshot<IntoService<S>, http::Request<B>>,
        },
        Body {
            status: StatusCode,
            rate_limit: Option<RateLimit>,
            #[pin]
            body: ConcatBody<S::ResponseBody>,
        },
    }
}
impl<T> Deref for Response<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.data
    }
}
impl<T: de::DeserializeOwned, S, B> ResponseFuture<T, S, B>
where
    S: HttpService<B>,
{
    pub(crate) fn new(req: http::Request<B>, http: S) -> Self {
        ResponseFuture {
            inner: ResponseFutureInner::Resp {
                response: http._into_service(Seal).oneshot(req),
            },
            marker: PhantomData,
        }
    }
}
impl<T: de::DeserializeOwned, S, B> Future for ResponseFuture<T, S, B>
where
    S: HttpService<B>,
{
    #[allow(clippy::type_complexity)]
    type Output = Result<Response<T>, Error<S::Error, <S::ResponseBody as Body>::Error>>;
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if let ResponseFutureInnerProj::Resp { response } = self.as_mut().project().inner.project()
        {
            let res = ready!(response.poll(cx).map_err(Error::Service))?;
            self.as_mut()
                .project()
                .inner
                .set(ResponseFutureInner::Body {
                    status: res.status(),
                    rate_limit: RateLimit::from_headers(res.headers()),
                    body: ConcatBody::new(res.into_body()),
                });
        }
        if let ResponseFutureInnerProj::Body {
            status,
            rate_limit,
            body,
        } = self.project().inner.project()
        {
            let body = ready!(body.poll(cx).map_err(Error::Body))?;
            Poll::Ready(make_response(*status, *rate_limit, &body, |body| {
                serde_json::from_slice(body).map_err(Error::Deserializing)
            }))
        } else {
            unreachable!();
        }
    }
}
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>,
        }
        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/lib.rs at line 1 [2.4397]
[2.4397]
[2.4398]
```
pub mod auth;
pub mod error;
pub mod response;
```

Replacement in src/lib.rs at line 8 [2.4397]

B:BD[2.4427] → [2.4427:4612]

use std::error;
use std::fmt::{self, Display, Formatter};
use std::future::Future;
use std::marker::PhantomData;
use std::ops::Deref;
use std::pin::Pin;
use std::task::{Context, Poll};

[2.4427]

[2.4612]

pub use crate::response::Response;

Deletion in src/lib.rs at line 10 [2.4397]
B:BD[2.4613] → [2.4613:4638]
```
use futures_core::ready;
```
Replacement in src/lib.rs at line 11 [2.4397]
B:BD[2.4700] → [2.4700:4758]
```
use http::{Method, StatusCode, Uri};
use http_body::Body;
```
[2.4700]
[2.4758]
```
use http::{Method, Uri};
```

Replacement in src/lib.rs at line 13 [2.4397]

B:BD[2.4794] → [2.4794:4829]

B:BD[2.4829] → [2.4829:4859]

B:BD[2.4859] → [2.4859:4899]

B:BD[2.4899] → [2.4899:4900]

B:BD[2.4900] → [2.4900:4985]

B:BD[2.4985] → [2.4985:5034]

B:BD[2.5034] → [2.5034:5056]

B:BD[2.5056] → [2.5056:5112]

B:BD[2.5112] → [2.5112:5393]

use pin_project_lite::pin_project;
use serde::{de, Deserialize};
use tower::util::{Oneshot, ServiceExt};
use crate::service::{HttpService, IntoService};
use crate::util::{ConcatBody, Seal};
#[derive(Deserialize)]
pub struct AccessToken {
    #[serde(flatten)]
    pub credentials: Credentials,
    pub user_id: i64,
}
#[derive(Debug)]
pub struct Response<T> {
    pub data: T,
    pub rate_limit: Option<RateLimit>,
}
pin_project! {
    pub struct ResponseFuture<T, S: HttpService<B>, B> {
        #[pin]
        inner: ResponseFutureInner<S, B>,
        marker: PhantomData<fn() -> T>,
    }
}

[2.4794]

[2.5393]

use serde::de;

Replacement in src/lib.rs at line 15 [2.4397]

B:BD[2.5394] → [2.5394:5786]

B:BD[2.5786] → [2.5786:5788]

pin_project! {
    #[project = ResponseFutureInnerProj]
    enum ResponseFutureInner<S: HttpService<B>, B> {
        Resp {
            #[pin]
            response: Oneshot<IntoService<S>, http::Request<B>>,
        },
        Body {
            status: StatusCode,
            rate_limit: Option<RateLimit>,
            #[pin]
            body: ConcatBody<S::ResponseBody>,
        },
    }
}

[2.5394]

[2.5788]

use crate::response::ResponseFuture;
use crate::service::HttpService;

Deletion in src/lib.rs at line 23 [2.4397]

B:BD[2.5906] → [2.5906:6064]

}
#[derive(Debug)]
pub enum Error<SE, BE> {
    Deserializing(serde_json::Error),
    Service(SE),
    Body(BE),
    Twitter(TwitterErrors),
    Unexpected,

Deletion in src/lib.rs at line 25 [2.4397]

B:BD[2.6067] → [2.6067:6313]

#[derive(Debug)]
pub struct TwitterErrors {
    pub status: StatusCode,
    pub errors: Vec<ErrorCode>,
    pub rate_limit: Option<RateLimit>,
}
#[derive(Debug, Deserialize)]
pub struct ErrorCode {
    pub code: u32,
    pub message: String,
}

Replacement in src/lib.rs at line 55 [2.4397]

B:BD[2.6958] → [2.6958:7137]

pub const RATE_LIMIT_LIMIT: &str = "x-rate-limit-limit";
pub const RATE_LIMIT_REMAINING: &str = "x-rate-limit-remaining";
pub const RATE_LIMIT_RESET: &str = "x-rate-limit-reset";

[2.6958]

[2.7137]

impl RateLimit {
    fn from_headers(headers: &http::HeaderMap) -> Option<Self> {
        pub const RATE_LIMIT_LIMIT: &str = "x-rate-limit-limit";
        pub const RATE_LIMIT_REMAINING: &str = "x-rate-limit-remaining";
        pub const RATE_LIMIT_RESET: &str = "x-rate-limit-reset";

Replacement in src/lib.rs at line 61 [2.4397]

B:BD[2.7138] → [2.7138:7577]

impl<T> Deref for Response<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.data
    }
}
impl<T: de::DeserializeOwned, S, B> ResponseFuture<T, S, B>
where
    S: HttpService<B>,
{
    fn new(req: http::Request<B>, http: S) -> Self {
        ResponseFuture {
            inner: ResponseFutureInner::Resp {
                response: http._into_service(Seal).oneshot(req),
            },
            marker: PhantomData,

[2.7138]

[2.7577]

        fn header(headers: &http::HeaderMap, name: &str) -> Option<u64> {
            headers
                .get(name)
                .and_then(|value| atoi::atoi(value.as_bytes()))

Deletion in src/lib.rs at line 66 [2.4397]
B:BD[2.7587] → [2.7587:7595]
```
    }
}
```

Replacement in src/lib.rs at line 67 [2.4397]

B:BD[2.7596] → [2.7596:9282]

impl<T: de::DeserializeOwned, S, B> Future for ResponseFuture<T, S, B>
where
    S: HttpService<B>,
{
    #[allow(clippy::type_complexity)]
    type Output = Result<Response<T>, Error<S::Error, <S::ResponseBody as Body>::Error>>;
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        if let ResponseFutureInnerProj::Resp { response } = self.as_mut().project().inner.project()
        {
            let res = ready!(response.poll(cx).map_err(Error::Service))?;
            self.as_mut()
                .project()
                .inner
                .set(ResponseFutureInner::Body {
                    status: res.status(),
                    rate_limit: rate_limit(&res),
                    body: ConcatBody::new(res.into_body()),
                });
        }
        if let ResponseFutureInnerProj::Body {
            status,
            rate_limit,
            body,
        } = self.project().inner.project()
        {
            let body = ready!(body.poll(cx).map_err(Error::Body))?;
            Poll::Ready(make_response(*status, *rate_limit, &body, |body| {
                serde_json::from_slice(body).map_err(Error::Deserializing)
            }))
        } else {
            unreachable!();
        }
    }
}
impl<SE: error::Error + 'static, BE: error::Error + 'static> error::Error for Error<SE, BE> {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match *self {
            Error::Deserializing(ref e) => Some(e),
            Error::Service(ref e) => Some(e),
            Error::Body(ref e) => Some(e),
            Error::Twitter(ref e) => Some(e),
            Error::Unexpected => None,
        }

[2.7596]

[2.9282]

        Some(RateLimit {
            limit: header(headers, RATE_LIMIT_LIMIT)?,
            remaining: header(headers, RATE_LIMIT_REMAINING)?,
            reset: header(headers, RATE_LIMIT_RESET)?,
        })

Deletion in src/lib.rs at line 75 [2.4397]

B:BD[2.9291] → [2.9291:9830]

B:BD[2.9830] → [2.9830:9839]

B:BD[2.9839] → [2.9839:9971]

B:BD[2.9971] → [2.9971:9972]

B:BD[2.9972] → [2.9972:10323]

B:BD[2.10323] → [2.10323:10333]

B:BD[2.10333] → [2.10333:10661]

B:BD[2.10661] → [2.10661:10662]

B:BD[2.10662] → [2.10662:10801]

B:BD[2.10801] → [2.10801:10810]

B:BD[2.10810] → [2.10810:13770]

impl<SE: Display, BE: Display> Display for Error<SE, BE> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match *self {
            Error::Deserializing(_) => f.write_str("Failed to deserialize the response body."),
            Error::Service(_) => f.write_str("HTTP error"),
            Error::Body(_) => f.write_str("Error while reading the response body"),
            Error::Twitter(_) => f.write_str("Twitter returned error(s)"),
            Error::Unexpected => f.write_str("Unexpected error occured."),
        }
    }
}
impl TwitterErrors {
    pub fn codes(&self) -> impl Iterator<Item = u32> + '_ {
        self.errors.iter().map(|e| e.code)
    }
}
impl Display for TwitterErrors {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "status: {}", self.status)?;
        let mut errors = self.errors.iter();
        if let Some(e) = errors.next() {
            write!(f, "; errors: {}", e)?;
            for e in errors {
                write!(f, ", {}", e)?;
            }
        }
        Ok(())
    }
}
impl error::Error for TwitterErrors {}
impl ErrorCode {
    pub const YOU_ARENT_ALLOWED_TO_ADD_MEMBERS_TO_THIS_LIST: u32 = 104;
    pub const CANNOT_FIND_SPECIFIED_USER: u32 = 108;
    pub const NO_STATUS_FOUND_WITH_THAT_ID: u32 = 144;
    pub const YOU_HAVE_ALREADY_RETWEETED_THIS_TWEET: u32 = 327;
}
impl Display for ErrorCode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{} {}", self.code, self.message)
    }
}
pub async fn request_token<S, B>(
    client_credentials: Credentials<&str>,
    client: S,
) -> Result<Response<Credentials<Box<str>>>, Error<S::Error, <S::ResponseBody as Body>::Error>>
where
    S: HttpService<B>,
    B: Default + From<Vec<u8>>,
{
    const URI: &str = "https://api.twitter.com/oauth/request_token";
    let authorization = oauth::Builder::<_, _>::new(client_credentials, oauth::HmacSha1)
        .callback("oob")
        .post(URI, &());
    let req = http::Request::post(Uri::from_static(URI))
        .header(AUTHORIZATION, authorization)
        .body(Default::default())
        .unwrap();
    let res = client
        ._into_service(Seal)
        .oneshot(req)
        .await
        .map_err(Error::Service)?;
    let status = res.status();
    let rate_limit = rate_limit(&res);
    let body = ConcatBody::new(res.into_body())
        .await
        .map_err(Error::Body)?;
    make_response(status, rate_limit, &body, |body| {
        serde_urlencoded::from_bytes(body).map_err(|_| Error::Unexpected)
    })
}
pub async fn access_token<'a, S, B>(
    oauth_verifier: &'a str,
    client_credentials: Credentials<&'a str>,
    temporary_credentials: Credentials<&'a str>,
    client: S,
) -> Result<Response<AccessToken>, Error<S::Error, <S::ResponseBody as Body>::Error>>
where
    S: HttpService<B>,
    B: Default + From<Vec<u8>>,
{
    const URI: &str = "https://api.twitter.com/oauth/access_token";
    let authorization = oauth::Builder::new(client_credentials, oauth::HmacSha1)
        .token(temporary_credentials)
        .verifier(oauth_verifier)
        .post(URI, &());
    let req = http::Request::post(Uri::from_static(URI))
        .header(AUTHORIZATION, authorization)
        .body(Default::default())
        .unwrap();
    let res = client
        ._into_service(Seal)
        .oneshot(req)
        .await
        .map_err(Error::Service)?;
    let status = res.status();
    let rate_limit = rate_limit(&res);
    let body = ConcatBody::new(res.into_body())
        .await
        .map_err(Error::Body)?;
    make_response(status, rate_limit, &body, |body| {
        serde_urlencoded::from_bytes(body).map_err(|_| Error::Unexpected)
    })
}
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>,
        }
        serde_json::from_slice(body)
            .or_else(|_| Ok(Errors::default()))
            .and_then(|errors| {
                Err(Error::Twitter(TwitterErrors {
                    status,
                    errors: errors.errors,
                    rate_limit,
                }))
            })
    }
}

Deletion in src/lib.rs at line 108 [2.4397]

B:BD[2.14725] → [2.14725:15133]

}
fn rate_limit<T>(res: &http::Response<T>) -> Option<RateLimit> {
    Some(RateLimit {
        limit: header(res, RATE_LIMIT_LIMIT)?,
        remaining: header(res, RATE_LIMIT_REMAINING)?,
        reset: header(res, RATE_LIMIT_RESET)?,
    })
}
fn header<T>(res: &http::Response<T>, name: &str) -> Option<u64> {
    res.headers()
        .get(name)
        .and_then(|value| atoi::atoi(value.as_bytes()))

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

[2.6]

use std::error;
use std::fmt::{self, Display, Formatter};
use http::StatusCode;
use serde::Deserialize;
#[derive(Debug)]
pub enum Error<SE, BE> {
    Deserializing(serde_json::Error),
    Service(SE),
    Body(BE),
    Twitter(TwitterErrors),
    Unexpected,
}
#[derive(Debug)]
pub struct TwitterErrors {
    pub status: StatusCode,
    pub errors: Vec<ErrorCode>,
    pub rate_limit: Option<crate::RateLimit>,
}
#[derive(Debug, Deserialize)]
pub struct ErrorCode {
    pub code: u32,
    pub message: String,
}
impl<SE: error::Error + 'static, BE: error::Error + 'static> error::Error for Error<SE, BE> {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match *self {
            Error::Deserializing(ref e) => Some(e),
            Error::Service(ref e) => Some(e),
            Error::Body(ref e) => Some(e),
            Error::Twitter(ref e) => Some(e),
            Error::Unexpected => None,
        }
    }
}
impl<SE: Display, BE: Display> Display for Error<SE, BE> {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match *self {
            Error::Deserializing(_) => f.write_str("Failed to deserialize the response body."),
            Error::Service(_) => f.write_str("HTTP error"),
            Error::Body(_) => f.write_str("Error while reading the response body"),
            Error::Twitter(_) => f.write_str("Twitter returned error(s)"),
            Error::Unexpected => f.write_str("Unexpected error occured."),
        }
    }
}
impl TwitterErrors {
    pub fn codes(&self) -> impl Iterator<Item = u32> + '_ {
        self.errors.iter().map(|e| e.code)
    }
}
impl Display for TwitterErrors {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "status: {}", self.status)?;
        let mut errors = self.errors.iter();
        if let Some(e) = errors.next() {
            write!(f, "; errors: {}", e)?;
            for e in errors {
                write!(f, ", {}", e)?;
            }
        }
        Ok(())
    }
}
impl error::Error for TwitterErrors {}
impl ErrorCode {
    pub const YOU_ARENT_ALLOWED_TO_ADD_MEMBERS_TO_THIS_LIST: u32 = 104;
    pub const CANNOT_FIND_SPECIFIED_USER: u32 = 108;
    pub const NO_STATUS_FOUND_WITH_THAT_ID: u32 = 144;
    pub const YOU_HAVE_ALREADY_RETWEETED_THIS_TWEET: u32 = 327;
}
impl Display for ErrorCode {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{} {}", self.code, self.message)
    }
}

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

[2.6]

use http::header::AUTHORIZATION;
use http::Uri;
use http_body::Body;
use oauth_credentials::Credentials;
use serde::Deserialize;
use tower::util::ServiceExt;
use crate::error::Error;
use crate::response;
use crate::service::HttpService;
use crate::util::{ConcatBody, Seal};
use crate::{RateLimit, Response};
#[derive(Deserialize)]
pub struct AccessToken {
    #[serde(flatten)]
    pub credentials: Credentials,
    pub user_id: i64,
}
pub async fn request_token<S, B>(
    client_credentials: Credentials<&str>,
    client: S,
) -> Result<Response<Credentials<Box<str>>>, Error<S::Error, <S::ResponseBody as Body>::Error>>
where
    S: HttpService<B>,
    B: Default + From<Vec<u8>>,
{
    const URI: &str = "https://api.twitter.com/oauth/request_token";
    let authorization = oauth::Builder::<_, _>::new(client_credentials, oauth::HmacSha1)
        .callback("oob")
        .post(URI, &());
    let req = http::Request::post(Uri::from_static(URI))
        .header(AUTHORIZATION, authorization)
        .body(Default::default())
        .unwrap();
    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)
    })
}
pub async fn access_token<'a, S, B>(
    oauth_verifier: &'a str,
    client_credentials: Credentials<&'a str>,
    temporary_credentials: Credentials<&'a str>,
    client: S,
) -> Result<Response<AccessToken>, Error<S::Error, <S::ResponseBody as Body>::Error>>
where
    S: HttpService<B>,
    B: Default + From<Vec<u8>>,
{
    const URI: &str = "https://api.twitter.com/oauth/access_token";
    let authorization = oauth::Builder::new(client_credentials, oauth::HmacSha1)
        .token(temporary_credentials)
        .verifier(oauth_verifier)
        .post(URI, &());
    let req = http::Request::post(Uri::from_static(URI))
        .header(AUTHORIZATION, authorization)
        .body(Default::default())
        .unwrap();
    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)
    })
}

Split modules

Dependencies

In channels

Change contents

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

Insertion in src/lib.rs at line 1 [2.4397]

Replacement in src/lib.rs at line 8 [2.4397]

Deletion in src/lib.rs at line 10 [2.4397]

Replacement in src/lib.rs at line 11 [2.4397]

Replacement in src/lib.rs at line 13 [2.4397]

Replacement in src/lib.rs at line 15 [2.4397]

Deletion in src/lib.rs at line 23 [2.4397]

Deletion in src/lib.rs at line 25 [2.4397]

Replacement in src/lib.rs at line 55 [2.4397]

Replacement in src/lib.rs at line 61 [2.4397]

Deletion in src/lib.rs at line 66 [2.4397]

Replacement in src/lib.rs at line 67 [2.4397]

Deletion in src/lib.rs at line 75 [2.4397]

Deletion in src/lib.rs at line 108 [2.4397]

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

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