pyrite/torn-api.rs
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

revert part of the typings for single requests

Browse source
This commit is contained in:
TotallyNot 2022-09-19 00:42:34 +02:00
parent 102d02d390
commit 77c50fac64
7 changed files with 97 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
torn-api/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "torn-api"
version = "0.5.1"
version = "0.5.2"
edition = "2021"
authors = ["Pyrit [2111649]"]
license = "MIT"

2
torn-api/src/faction.rs
View file

@ -47,7 +47,7 @@ mod tests {
let response = Client::default()
.torn_api(key)
.faction(None, |b| b.selections(&[Selection::Basic]))
.faction(|b| b.selections(&[Selection::Basic]))
.await
.unwrap();

34
torn-api/src/lib.rs
View file

@ -180,18 +180,25 @@ where
A: ApiCategoryResponse,
{
request: ApiRequest<A>,
id: Option<i64>,
}
impl<A> Default for ApiRequestBuilder<A>
where
A: ApiCategoryResponse,
{
fn default() -> Self {
Self {
request: Default::default(),
id: None,
}
}
}
impl<A> ApiRequestBuilder<A>
where
A: ApiCategoryResponse,
{
pub(crate) fn new() -> Self {
Self {
request: ApiRequest::default(),
}
}
#[must_use]
pub fn selections(mut self, selections: &[A::Selection]) -> Self {
self.request
@ -217,6 +224,15 @@ where
self.request.comment = Some(comment);
self
}
#[must_use]
pub fn id<I>(mut self, id: I) -> Self
where
I: num_traits::AsPrimitive<i64>,
{
self.id = Some(id.as_());
self
}
}
#[cfg(test)]
@ -259,11 +275,7 @@ pub(crate) mod tests {
async fn reqwest() {
let key = setup();
Client::default()
.torn_api(key)
.user(None, |b| b)
.await
.unwrap();
Client::default().torn_api(key).user(|b| b).await.unwrap();
}
#[cfg(feature = "awc")]

52
torn-api/src/local.rs
View file

@ -7,54 +7,48 @@ use crate::{
ApiResponse, DirectExecutor,
};
pub struct ApiProvider<'a, C, E, I = i32>
pub struct ApiProvider<'a, C, E>
where
C: ApiClient,
E: RequestExecutor<C>,
I: num_traits::AsPrimitive<i64>,
{
client: &'a C,
executor: E,
_marker: std::marker::PhantomData<I>,
}
impl<'a, C, E, I> ApiProvider<'a, C, E, I>
impl<'a, C, E> ApiProvider<'a, C, E>
where
C: ApiClient,
E: RequestExecutor<C>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
{
pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E, I> {
Self {
client,
executor,
_marker: Default::default(),
}
pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E> {
Self { client, executor }
}
pub async fn user<F>(&self, id: Option<I>, build: F) -> Result<user::Response, E::Error>
pub async fn user<F>(&self, build: F) -> Result<user::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
.execute(self.client, builder.request, id.map(|i| i.as_()))
.execute(self.client, builder.request, builder.id)
.await
}
pub async fn users<F, L>(
pub async fn users<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<user::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -69,28 +63,30 @@ where
.collect()
}
pub async fn faction<F>(&self, id: Option<I>, build: F) -> Result<faction::Response, E::Error>
pub async fn faction<F>(&self, build: F) -> Result<faction::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
.execute(self.client, builder.request, id.map(|i| i.as_()))
.execute(self.client, builder.request, builder.id)
.await
}
pub async fn factions<F, L>(
pub async fn factions<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<faction::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -105,28 +101,30 @@ where
.collect()
}
pub async fn torn<F>(&self, id: Option<I>, build: F) -> Result<torn::Response, E::Error>
pub async fn torn<F>(&self, build: F) -> Result<torn::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
.execute(self.client, builder.request, id.map(|i| i.as_()))
.execute(self.client, builder.request, builder.id)
.await
}
pub async fn torns<F, L>(
pub async fn torns<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<torn::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor

52
torn-api/src/send.rs
View file

@ -7,54 +7,48 @@ use crate::{
ApiResponse, DirectExecutor,
};
pub struct ApiProvider<'a, C, E, I = i32>
pub struct ApiProvider<'a, C, E>
where
C: ApiClient,
E: RequestExecutor<C>,
I: num_traits::AsPrimitive<i64>,
{
client: &'a C,
executor: E,
_marker: std::marker::PhantomData<I>,
}
impl<'a, C, E, I> ApiProvider<'a, C, E, I>
impl<'a, C, E> ApiProvider<'a, C, E>
where
C: ApiClient,
E: RequestExecutor<C>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
{
pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E, I> {
Self {
client,
executor,
_marker: Default::default(),
}
pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E> {
Self { client, executor }
}
pub async fn user<F>(&self, id: Option<I>, build: F) -> Result<user::Response, E::Error>
pub async fn user<F>(&self, build: F) -> Result<user::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
.execute(self.client, builder.request, id.map(|i| i.as_()))
.execute(self.client, builder.request, builder.id)
.await
}
pub async fn users<F, L>(
pub async fn users<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<user::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -69,28 +63,30 @@ where
.collect()
}
pub async fn faction<F>(&self, id: Option<I>, build: F) -> Result<faction::Response, E::Error>
pub async fn faction<F>(&self, build: F) -> Result<faction::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
.execute(self.client, builder.request, id.map(|i| i.as_()))
.execute(self.client, builder.request, builder.id)
.await
}
pub async fn factions<F, L>(
pub async fn factions<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<faction::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
@ -105,28 +101,30 @@ where
.collect()
}
pub async fn torn<F>(&self, id: Option<I>, build: F) -> Result<torn::Response, E::Error>
pub async fn torn<F>(&self, build: F) -> Result<torn::Response, E::Error>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor
.execute(self.client, builder.request, id.map(|i| i.as_()))
.execute(self.client, builder.request, builder.id)
.await
}
pub async fn torns<F, L>(
pub async fn torns<F, L, I>(
&self,
ids: L,
build: F,
) -> HashMap<I, Result<torn::Response, E::Error>>
where
F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
i64: num_traits::AsPrimitive<I>,
L: IntoIterator<Item = I>,
{
let mut builder = ApiRequestBuilder::new();
let mut builder = ApiRequestBuilder::default();
builder = build(builder);
self.executor

2
torn-api/src/torn.rs
View file

@ -91,7 +91,7 @@ mod tests {
let response = Client::default()
.torn_api(key)
.torn(None, |b| b.selections(&[Selection::Competition]))
.torn(|b| b.selections(&[Selection::Competition]))
.await
.unwrap();

25
torn-api/src/user.rs
View file

@ -399,7 +399,7 @@ mod tests {
let response = Client::default()
.torn_api(key)
.user(None, |b| {
.user(|b| {
b.selections(&[
Selection::Basic,
Selection::Discord,
@ -424,7 +424,7 @@ mod tests {
let response = Client::default()
.torn_api(key)
.user(Some(28), |b| b.selections(&[Selection::Profile]))
.user(|b| b.id(28).selections(&[Selection::Profile]))
.await
.unwrap();
@ -439,7 +439,7 @@ mod tests {
let response = Client::default()
.torn_api(key)
.user(None, |b| b.selections(&[Selection::Profile]))
.user(|b| b.selections(&[Selection::Profile]))
.await
.unwrap();
@ -453,10 +453,27 @@ mod tests {
let response = Client::default()
.torn_api(key)
.users([1, 2111649], |b| b.selections(&[Selection::Basic]))
.users([1, 2111649, 374272176892674048i64], |b| {
b.selections(&[Selection::Basic])
})
.await;
response.get(&1).as_ref().unwrap().as_ref().unwrap();
response.get(&2111649).as_ref().unwrap().as_ref().unwrap();
}
#[async_test]
async fn discord() {
let key = setup();
let basic = Client::default()
.torn_api(key)
.user(|b| b.id(374272176892674048i64).selections(&[Selection::Basic]))
.await
.unwrap()
.basic()
.unwrap();
assert_eq!(basic.player_id, 2111649);
}
}