kozabrada123/chorus
kozabrada123
/
chorus
mirror of https://github.com/polyphony-chat/chorus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Improve readability

This commit is contained in:
bitfl0wer 2023-04-25 17:41:14 +02:00
parent 9dad307b71
commit 7cb77bae0f
No known key found for this signature in database
GPG Key ID: 84BBB60DF895ABF2
9 changed files with 67 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/api/auth/login.rs
View File

@ -30,7 +30,7 @@ pub mod login {
&mut cloned_limits, &mut cloned_limits,
) )
.await; .await;
if !response.is_ok() { if response.is_err() {
return Err(InstanceServerError::NoResponse); return Err(InstanceServerError::NoResponse);
} }
@ -51,7 +51,7 @@ pub mod login {
let login_result: LoginResult = from_str(&response_text_string).unwrap(); let login_result: LoginResult = from_str(&response_text_string).unwrap();
return Ok(login_result); Ok(login_result)
} }
} }
} }

4
src/api/auth/register.rs
View File

@ -76,7 +76,7 @@ mod test {
"http://localhost:3001".to_string(), "http://localhost:3001".to_string(),
"http://localhost:3001".to_string(), "http://localhost:3001".to_string(),
); );
let limited_requester = LimitedRequester::new(urls.get_api().to_string()).await; let limited_requester = LimitedRequester::new().await;
let mut test_instance = Instance::new(urls.clone(), limited_requester) let mut test_instance = Instance::new(urls.clone(), limited_requester)
.await .await
.unwrap(); .unwrap();
@ -109,7 +109,7 @@ mod test {
"http://localhost:3001".to_string(), "http://localhost:3001".to_string(),
"http://localhost:3001".to_string(), "http://localhost:3001".to_string(),
); );
let limited_requester = LimitedRequester::new(urls.get_api().to_string()).await; let limited_requester = LimitedRequester::new().await;
let mut test_instance = Instance::new(urls.clone(), limited_requester) let mut test_instance = Instance::new(urls.clone(), limited_requester)
.await .await
.unwrap(); .unwrap();

4
src/api/policies/instance/instance.rs
View File

@ -26,7 +26,7 @@ pub mod instance {
} }
}; };
if request.status().as_str().chars().next().unwrap() != '2' { if !request.status().as_str().starts_with('2') {
return Err(InstanceServerError::ReceivedErrorCodeError { return Err(InstanceServerError::ReceivedErrorCodeError {
error_code: request.status().to_string(), error_code: request.status().to_string(),
}); });
@ -50,7 +50,7 @@ mod instance_policies_schema_test {
"http://localhost:3001".to_string(), "http://localhost:3001".to_string(),
"http://localhost:3001".to_string(), "http://localhost:3001".to_string(),
); );
let limited_requester = LimitedRequester::new(urls.get_api().to_string()).await; let limited_requester = LimitedRequester::new().await;
let test_instance = Instance::new(urls.clone(), limited_requester) let test_instance = Instance::new(urls.clone(), limited_requester)
.await .await
.unwrap(); .unwrap();

62
src/api/policies/instance/limits.rs
View File

@ -155,14 +155,14 @@ pub mod limits {
impl Limit { impl Limit {
pub fn add_remaining(&mut self, remaining: i64) { pub fn add_remaining(&mut self, remaining: i64) {
if remaining < 0 { if remaining < 0 {
if ((self.remaining as i64 + remaining) as i64) <= 0 { if (self.remaining as i64 + remaining) <= 0 {
self.remaining = 0; self.remaining = 0;
return; return;
} }
self.remaining -= remaining.abs() as u64; self.remaining -= remaining.unsigned_abs();
return; return;
} }
self.remaining += remaining.abs() as u64; self.remaining += remaining.unsigned_abs();
} }
} }
@ -184,7 +184,7 @@ pub mod limits {
instance_rate_limits: &'a mut Limits, instance_rate_limits: &'a mut Limits,
user_rate_limits: &'a mut Limits, user_rate_limits: &'a mut Limits,
) -> LimitsMutRef<'a> { ) -> LimitsMutRef<'a> {
return LimitsMutRef { LimitsMutRef {
limit_absolute_messages: &mut instance_rate_limits.limit_absolute_messages, limit_absolute_messages: &mut instance_rate_limits.limit_absolute_messages,
limit_absolute_register: &mut instance_rate_limits.limit_absolute_register, limit_absolute_register: &mut instance_rate_limits.limit_absolute_register,
limit_auth_login: &mut instance_rate_limits.limit_auth_login, limit_auth_login: &mut instance_rate_limits.limit_auth_login,
@ -195,36 +195,36 @@ pub mod limits {
limit_guild: &mut user_rate_limits.limit_guild, limit_guild: &mut user_rate_limits.limit_guild,
limit_ip: &mut instance_rate_limits.limit_ip, limit_ip: &mut instance_rate_limits.limit_ip,
limit_webhook: &mut user_rate_limits.limit_webhook, limit_webhook: &mut user_rate_limits.limit_webhook,
}; }
} }
pub fn get_limit_ref(&self, limit_type: &LimitType) -> &Limit { pub fn get_limit_ref(&self, limit_type: &LimitType) -> &Limit {
match limit_type { match limit_type {
&LimitType::AbsoluteMessage => &self.limit_absolute_messages, &LimitType::AbsoluteMessage => self.limit_absolute_messages,
&LimitType::AbsoluteRegister => &self.limit_absolute_register, &LimitType::AbsoluteRegister => self.limit_absolute_register,
&LimitType::AuthLogin => &self.limit_auth_login, &LimitType::AuthLogin => self.limit_auth_login,
&LimitType::AuthRegister => &self.limit_auth_register, &LimitType::AuthRegister => self.limit_auth_register,
&LimitType::Channel => &self.limit_channel, &LimitType::Channel => self.limit_channel,
&LimitType::Error => &self.limit_error, &LimitType::Error => self.limit_error,
&LimitType::Global => &self.limit_global, &LimitType::Global => self.limit_global,
&LimitType::Guild => &self.limit_guild, &LimitType::Guild => self.limit_guild,
&LimitType::Ip => &self.limit_ip, &LimitType::Ip => self.limit_ip,
&LimitType::Webhook => &self.limit_webhook, &LimitType::Webhook => self.limit_webhook,
} }
} }
pub fn get_limit_mut_ref(&mut self, limit_type: &LimitType) -> &mut Limit { pub fn get_limit_mut_ref(&mut self, limit_type: &LimitType) -> &mut Limit {
match limit_type { match limit_type {
&LimitType::AbsoluteMessage => &mut self.limit_absolute_messages, &LimitType::AbsoluteMessage => self.limit_absolute_messages,
&LimitType::AbsoluteRegister => &mut self.limit_absolute_register, &LimitType::AbsoluteRegister => self.limit_absolute_register,
&LimitType::AuthLogin => &mut self.limit_auth_login, &LimitType::AuthLogin => self.limit_auth_login,
&LimitType::AuthRegister => &mut self.limit_auth_register, &LimitType::AuthRegister => self.limit_auth_register,
&LimitType::Channel => &mut self.limit_channel, &LimitType::Channel => self.limit_channel,
&LimitType::Error => &mut self.limit_error, &LimitType::Error => self.limit_error,
&LimitType::Global => &mut self.limit_global, &LimitType::Global => self.limit_global,
&LimitType::Guild => &mut self.limit_guild, &LimitType::Guild => self.limit_guild,
&LimitType::Ip => &mut self.limit_ip, &LimitType::Ip => self.limit_ip,
&LimitType::Webhook => &mut self.limit_webhook, &LimitType::Webhook => self.limit_webhook,
} }
} }
} }
@ -245,7 +245,7 @@ pub mod limits {
impl Limits { impl Limits {
pub fn combine(instance_rate_limits: &Limits, user_rate_limits: &Limits) -> Limits { pub fn combine(instance_rate_limits: &Limits, user_rate_limits: &Limits) -> Limits {
return Limits { Limits {
limit_absolute_messages: instance_rate_limits.limit_absolute_messages, limit_absolute_messages: instance_rate_limits.limit_absolute_messages,
limit_absolute_register: instance_rate_limits.limit_absolute_register, limit_absolute_register: instance_rate_limits.limit_absolute_register,
limit_auth_login: instance_rate_limits.limit_auth_login, limit_auth_login: instance_rate_limits.limit_auth_login,
@ -256,7 +256,7 @@ pub mod limits {
limit_guild: user_rate_limits.limit_guild, limit_guild: user_rate_limits.limit_guild,
limit_ip: instance_rate_limits.limit_ip, limit_ip: instance_rate_limits.limit_ip,
limit_webhook: user_rate_limits.limit_webhook, limit_webhook: user_rate_limits.limit_webhook,
}; }
} }
pub fn get_limit_ref(&self, limit_type: &LimitType) -> &Limit { pub fn get_limit_ref(&self, limit_type: &LimitType) -> &Limit {
@ -329,7 +329,7 @@ pub mod limits {
let config: Config = from_str(&result).unwrap(); let config: Config = from_str(&result).unwrap();
// If config.rate.enabled is false, then add return a Limits struct with all limits set to u64::MAX // If config.rate.enabled is false, then add return a Limits struct with all limits set to u64::MAX
let mut limits: Limits; let mut limits: Limits;
if config.rate.enabled == false { if !config.rate.enabled {
limits = Limits { limits = Limits {
limit_absolute_messages: Limit { limit_absolute_messages: Limit {
bucket: LimitType::AbsoluteMessage, bucket: LimitType::AbsoluteMessage,
@ -475,7 +475,7 @@ pub mod limits {
}; };
} }
return limits; limits
} }
} }
} }
@ -493,8 +493,8 @@ mod instance_limits {
reset: 0, reset: 0,
}; };
limit.add_remaining(-2); limit.add_remaining(-2);
assert_eq!(0 as u64, limit.remaining); assert_eq!(0_u64, limit.remaining);
limit.add_remaining(-2123123); limit.add_remaining(-2123123);
assert_eq!(0 as u64, limit.remaining); assert_eq!(0_u64, limit.remaining);
} }
} }

26
src/api/schemas.rs
View File

@ -23,10 +23,10 @@ impl AuthEmail {
*/ */
pub fn new(email: String) -> Result<AuthEmail, FieldFormatError> { pub fn new(email: String) -> Result<AuthEmail, FieldFormatError> {
let regex = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap(); let regex = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
if !regex.is_match(email.clone().as_str()) { if !regex.is_match(email.as_str()) {
return Err(FieldFormatError::EmailError); return Err(FieldFormatError::EmailError);
} }
return Ok(AuthEmail { email }); Ok(AuthEmail { email })
} }
} }
@ -54,9 +54,9 @@ impl AuthUsername {
*/ */
pub fn new(username: String) -> Result<AuthUsername, FieldFormatError> { pub fn new(username: String) -> Result<AuthUsername, FieldFormatError> {
if username.len() < 2 || username.len() > 32 { if username.len() < 2 || username.len() > 32 {
return Err(FieldFormatError::UsernameError); Err(FieldFormatError::UsernameError)
} else { } else {
return Ok(AuthUsername { username }); Ok(AuthUsername { username })
} }
} }
} }
@ -84,10 +84,10 @@ impl AuthPassword {
- The password is not between 1 and 72 characters. - The password is not between 1 and 72 characters.
*/ */
pub fn new(password: String) -> Result<AuthPassword, FieldFormatError> { pub fn new(password: String) -> Result<AuthPassword, FieldFormatError> {
if password.len() < 1 || password.len() > 72 { if password.is_empty() || password.len() > 72 {
return Err(FieldFormatError::PasswordError); Err(FieldFormatError::PasswordError)
} else { } else {
return Ok(AuthPassword { password }); Ok(AuthPassword { password })
} }
} }
} }
@ -162,7 +162,7 @@ impl RegisterSchema {
return Err(FieldFormatError::ConsentError); return Err(FieldFormatError::ConsentError);
} }
return Ok(RegisterSchema { Ok(RegisterSchema {
username, username,
password: has_password, password: has_password,
consent, consent,
@ -173,7 +173,7 @@ impl RegisterSchema {
gift_code_sku_id, gift_code_sku_id,
captcha_key, captcha_key,
promotional_email_opt_in, promotional_email_opt_in,
}); })
} }
} }
@ -220,14 +220,14 @@ impl LoginSchema {
gift_code_sku_id: Option<String>, gift_code_sku_id: Option<String>,
) -> Result<LoginSchema, FieldFormatError> { ) -> Result<LoginSchema, FieldFormatError> {
let login = login.username; let login = login.username;
return Ok(LoginSchema { Ok(LoginSchema {
login, login,
password, password,
undelete, undelete,
captcha_key, captcha_key,
login_source, login_source,
gift_code_sku_id, gift_code_sku_id,
}); })
} }
} }
@ -259,7 +259,7 @@ mod schemas_tests {
fn password_too_long() { fn password_too_long() {
let mut long_pw = String::new(); let mut long_pw = String::new();
for _ in 0..73 { for _ in 0..73 {
long_pw = long_pw + "a"; long_pw += "a";
} }
assert_eq!( assert_eq!(
AuthPassword::new(long_pw), AuthPassword::new(long_pw),
@ -279,7 +279,7 @@ mod schemas_tests {
fn username_too_long() { fn username_too_long() {
let mut long_un = String::new(); let mut long_un = String::new();
for _ in 0..33 { for _ in 0..33 {
long_un = long_un + "a"; long_un += "a";
} }
assert_eq!( assert_eq!(
AuthUsername::new(long_un), AuthUsername::new(long_un),

10
src/api/types.rs
View File

@ -174,19 +174,15 @@ pub struct User {
impl User { impl User {
pub fn is_logged_in(&self) -> bool { pub fn is_logged_in(&self) -> bool {
if self.logged_in == true { self.logged_in
true
} else {
false
}
} }
pub fn belongs_to(&self) -> URLBundle { pub fn belongs_to(&self) -> URLBundle {
return self.belongs_to.clone(); self.belongs_to.clone()
} }
pub fn token(&self) -> String { pub fn token(&self) -> String {
return self.token.clone(); self.token.clone()
} }
pub fn set_logged_in(&mut self, bool: bool) { pub fn set_logged_in(&mut self, bool: bool) {

2
src/instance.rs
View File

@ -87,6 +87,6 @@ impl Username {
if username.len() < 2 || username.len() > 32 { if username.len() < 2 || username.len() > 32 {
return Err(FieldFormatError::UsernameError); return Err(FieldFormatError::UsernameError);
} }
return Ok(Username { username }); Ok(Username { username })
} }
} }

4
src/lib.rs
View File

@ -49,10 +49,10 @@ impl URLBundle {
}; };
// if the last character of the string is a slash, remove it. // if the last character of the string is a slash, remove it.
let mut url_string = url.to_string(); let mut url_string = url.to_string();
if url_string.chars().last().unwrap() == '/' { if url_string.ends_with('/') {
url_string.pop(); url_string.pop();
} }
return url_string; url_string
} }
pub fn get_api(&self) -> &str { pub fn get_api(&self) -> &str {

22
src/limit.rs
View File

@ -28,7 +28,7 @@ impl LimitedRequester {
/// be send within the `Limit` of an external API Ratelimiter, and looks at the returned request /// be send within the `Limit` of an external API Ratelimiter, and looks at the returned request
/// headers to see if it can find Ratelimit info to update itself. /// headers to see if it can find Ratelimit info to update itself.
#[allow(dead_code)] #[allow(dead_code)]
pub async fn new(api_url: String) -> Self { pub async fn new() -> Self {
LimitedRequester { LimitedRequester {
http: Client::new(), http: Client::new(),
requests: VecDeque::new(), requests: VecDeque::new(),
@ -86,13 +86,13 @@ impl LimitedRequester {
instance_rate_limits, instance_rate_limits,
user_rate_limits, user_rate_limits,
); );
return Ok(response); Ok(response)
} else { } else {
self.requests.push_back(TypedRequest { self.requests.push_back(TypedRequest {
request: request, request,
limit_type: limit_type, limit_type,
}); });
return Err(InstanceServerError::RateLimited); Err(InstanceServerError::RateLimited)
} }
} }
@ -125,7 +125,7 @@ impl LimitedRequester {
] ]
.to_vec(); .to_vec();
for limit in constant_limits.iter() { for limit in constant_limits.iter() {
match rate_limits.to_hash_map().get(&limit) { match rate_limits.to_hash_map().get(limit) {
Some(limit) => { Some(limit) => {
if limit.remaining == 0 { if limit.remaining == 0 {
return false; return false;
@ -155,7 +155,7 @@ impl LimitedRequester {
None => return false, None => return false,
} }
} }
return true; true
} }
fn update_limits( fn update_limits(
@ -183,7 +183,7 @@ impl LimitedRequester {
let status = response.status(); let status = response.status();
let status_str = status.as_str(); let status_str = status.as_str();
if status_str.chars().next().unwrap() == '4' { if status_str.starts_with('4') {
rate_limits rate_limits
.get_limit_mut_ref(&LimitType::Error) .get_limit_mut_ref(&LimitType::Error)
.add_remaining(-1); .add_remaining(-1);
@ -266,7 +266,7 @@ mod rate_limit {
String::from("wss://localhost:3001/"), String::from("wss://localhost:3001/"),
String::from("http://localhost:3001/cdn"), String::from("http://localhost:3001/cdn"),
); );
let requester = LimitedRequester::new(urls.api).await; let _requester = LimitedRequester::new().await;
} }
#[tokio::test] #[tokio::test]
@ -276,7 +276,7 @@ mod rate_limit {
String::from("wss://localhost:3001/"), String::from("wss://localhost:3001/"),
String::from("http://localhost:3001/cdn"), String::from("http://localhost:3001/cdn"),
); );
let mut requester = LimitedRequester::new(urls.api.clone()).await; let mut requester = LimitedRequester::new().await;
let mut request: Option<Result<Response, InstanceServerError>> = None; let mut request: Option<Result<Response, InstanceServerError>> = None;
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
@ -314,7 +314,7 @@ mod rate_limit {
); );
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
let mut requester = LimitedRequester::new(urls.api.clone()).await; let mut requester = LimitedRequester::new().await;
let request_path = urls.api.clone() + "/policies/instance/limits"; let request_path = urls.api.clone() + "/policies/instance/limits";
let request_builder = requester.http.get(request_path); let request_builder = requester.http.get(request_path);
let request = requester let request = requester