From 7cb77bae0fd978cd5b9de3e2936de4b8e2cb849b Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Tue, 25 Apr 2023 17:41:14 +0200 Subject: [PATCH] Improve readability --- src/api/auth/login.rs | 4 +- src/api/auth/register.rs | 4 +- src/api/policies/instance/instance.rs | 4 +- src/api/policies/instance/limits.rs | 62 +++++++++++++-------------- src/api/schemas.rs | 26 +++++------ src/api/types.rs | 10 ++--- src/instance.rs | 2 +- src/lib.rs | 4 +- src/limit.rs | 22 +++++----- 9 files changed, 67 insertions(+), 71 deletions(-) diff --git a/src/api/auth/login.rs b/src/api/auth/login.rs index bc37b25..f7c4fe6 100644 --- a/src/api/auth/login.rs +++ b/src/api/auth/login.rs @@ -30,7 +30,7 @@ pub mod login { &mut cloned_limits, ) .await; - if !response.is_ok() { + if response.is_err() { return Err(InstanceServerError::NoResponse); } @@ -51,7 +51,7 @@ pub mod login { let login_result: LoginResult = from_str(&response_text_string).unwrap(); - return Ok(login_result); + Ok(login_result) } } } diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs index d0d6cf8..b932b9f 100644 --- a/src/api/auth/register.rs +++ b/src/api/auth/register.rs @@ -76,7 +76,7 @@ mod test { "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) .await .unwrap(); @@ -109,7 +109,7 @@ mod test { "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) .await .unwrap(); diff --git a/src/api/policies/instance/instance.rs b/src/api/policies/instance/instance.rs index 7f69670..f96325f 100644 --- a/src/api/policies/instance/instance.rs +++ b/src/api/policies/instance/instance.rs @@ -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 { 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(), ); - 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) .await .unwrap(); diff --git a/src/api/policies/instance/limits.rs b/src/api/policies/instance/limits.rs index c3c76a3..7c4b624 100644 --- a/src/api/policies/instance/limits.rs +++ b/src/api/policies/instance/limits.rs @@ -155,14 +155,14 @@ pub mod limits { impl Limit { pub fn add_remaining(&mut self, remaining: i64) { if remaining < 0 { - if ((self.remaining as i64 + remaining) as i64) <= 0 { + if (self.remaining as i64 + remaining) <= 0 { self.remaining = 0; return; } - self.remaining -= remaining.abs() as u64; + self.remaining -= remaining.unsigned_abs(); 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, user_rate_limits: &'a mut Limits, ) -> LimitsMutRef<'a> { - return LimitsMutRef { + LimitsMutRef { limit_absolute_messages: &mut instance_rate_limits.limit_absolute_messages, limit_absolute_register: &mut instance_rate_limits.limit_absolute_register, 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_ip: &mut instance_rate_limits.limit_ip, limit_webhook: &mut user_rate_limits.limit_webhook, - }; + } } pub fn get_limit_ref(&self, limit_type: &LimitType) -> &Limit { match limit_type { - &LimitType::AbsoluteMessage => &self.limit_absolute_messages, - &LimitType::AbsoluteRegister => &self.limit_absolute_register, - &LimitType::AuthLogin => &self.limit_auth_login, - &LimitType::AuthRegister => &self.limit_auth_register, - &LimitType::Channel => &self.limit_channel, - &LimitType::Error => &self.limit_error, - &LimitType::Global => &self.limit_global, - &LimitType::Guild => &self.limit_guild, - &LimitType::Ip => &self.limit_ip, - &LimitType::Webhook => &self.limit_webhook, + &LimitType::AbsoluteMessage => self.limit_absolute_messages, + &LimitType::AbsoluteRegister => self.limit_absolute_register, + &LimitType::AuthLogin => self.limit_auth_login, + &LimitType::AuthRegister => self.limit_auth_register, + &LimitType::Channel => self.limit_channel, + &LimitType::Error => self.limit_error, + &LimitType::Global => self.limit_global, + &LimitType::Guild => self.limit_guild, + &LimitType::Ip => self.limit_ip, + &LimitType::Webhook => self.limit_webhook, } } pub fn get_limit_mut_ref(&mut self, limit_type: &LimitType) -> &mut Limit { match limit_type { - &LimitType::AbsoluteMessage => &mut self.limit_absolute_messages, - &LimitType::AbsoluteRegister => &mut self.limit_absolute_register, - &LimitType::AuthLogin => &mut self.limit_auth_login, - &LimitType::AuthRegister => &mut self.limit_auth_register, - &LimitType::Channel => &mut self.limit_channel, - &LimitType::Error => &mut self.limit_error, - &LimitType::Global => &mut self.limit_global, - &LimitType::Guild => &mut self.limit_guild, - &LimitType::Ip => &mut self.limit_ip, - &LimitType::Webhook => &mut self.limit_webhook, + &LimitType::AbsoluteMessage => self.limit_absolute_messages, + &LimitType::AbsoluteRegister => self.limit_absolute_register, + &LimitType::AuthLogin => self.limit_auth_login, + &LimitType::AuthRegister => self.limit_auth_register, + &LimitType::Channel => self.limit_channel, + &LimitType::Error => self.limit_error, + &LimitType::Global => self.limit_global, + &LimitType::Guild => self.limit_guild, + &LimitType::Ip => self.limit_ip, + &LimitType::Webhook => self.limit_webhook, } } } @@ -245,7 +245,7 @@ pub mod limits { impl 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_register: instance_rate_limits.limit_absolute_register, limit_auth_login: instance_rate_limits.limit_auth_login, @@ -256,7 +256,7 @@ pub mod limits { limit_guild: user_rate_limits.limit_guild, limit_ip: instance_rate_limits.limit_ip, limit_webhook: user_rate_limits.limit_webhook, - }; + } } pub fn get_limit_ref(&self, limit_type: &LimitType) -> &Limit { @@ -329,7 +329,7 @@ pub mod limits { 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 let mut limits: Limits; - if config.rate.enabled == false { + if !config.rate.enabled { limits = Limits { limit_absolute_messages: Limit { bucket: LimitType::AbsoluteMessage, @@ -475,7 +475,7 @@ pub mod limits { }; } - return limits; + limits } } } @@ -493,8 +493,8 @@ mod instance_limits { reset: 0, }; limit.add_remaining(-2); - assert_eq!(0 as u64, limit.remaining); + assert_eq!(0_u64, limit.remaining); limit.add_remaining(-2123123); - assert_eq!(0 as u64, limit.remaining); + assert_eq!(0_u64, limit.remaining); } } diff --git a/src/api/schemas.rs b/src/api/schemas.rs index 33091a6..08425a3 100644 --- a/src/api/schemas.rs +++ b/src/api/schemas.rs @@ -23,10 +23,10 @@ impl AuthEmail { */ pub fn new(email: String) -> Result { 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 Ok(AuthEmail { email }); + Ok(AuthEmail { email }) } } @@ -54,9 +54,9 @@ impl AuthUsername { */ pub fn new(username: String) -> Result { if username.len() < 2 || username.len() > 32 { - return Err(FieldFormatError::UsernameError); + Err(FieldFormatError::UsernameError) } else { - return Ok(AuthUsername { username }); + Ok(AuthUsername { username }) } } } @@ -84,10 +84,10 @@ impl AuthPassword { - The password is not between 1 and 72 characters. */ pub fn new(password: String) -> Result { - if password.len() < 1 || password.len() > 72 { - return Err(FieldFormatError::PasswordError); + if password.is_empty() || password.len() > 72 { + Err(FieldFormatError::PasswordError) } else { - return Ok(AuthPassword { password }); + Ok(AuthPassword { password }) } } } @@ -162,7 +162,7 @@ impl RegisterSchema { return Err(FieldFormatError::ConsentError); } - return Ok(RegisterSchema { + Ok(RegisterSchema { username, password: has_password, consent, @@ -173,7 +173,7 @@ impl RegisterSchema { gift_code_sku_id, captcha_key, promotional_email_opt_in, - }); + }) } } @@ -220,14 +220,14 @@ impl LoginSchema { gift_code_sku_id: Option, ) -> Result { let login = login.username; - return Ok(LoginSchema { + Ok(LoginSchema { login, password, undelete, captcha_key, login_source, gift_code_sku_id, - }); + }) } } @@ -259,7 +259,7 @@ mod schemas_tests { fn password_too_long() { let mut long_pw = String::new(); for _ in 0..73 { - long_pw = long_pw + "a"; + long_pw += "a"; } assert_eq!( AuthPassword::new(long_pw), @@ -279,7 +279,7 @@ mod schemas_tests { fn username_too_long() { let mut long_un = String::new(); for _ in 0..33 { - long_un = long_un + "a"; + long_un += "a"; } assert_eq!( AuthUsername::new(long_un), diff --git a/src/api/types.rs b/src/api/types.rs index 1f281f0..d4c8309 100644 --- a/src/api/types.rs +++ b/src/api/types.rs @@ -174,19 +174,15 @@ pub struct User { impl User { pub fn is_logged_in(&self) -> bool { - if self.logged_in == true { - true - } else { - false - } + self.logged_in } pub fn belongs_to(&self) -> URLBundle { - return self.belongs_to.clone(); + self.belongs_to.clone() } pub fn token(&self) -> String { - return self.token.clone(); + self.token.clone() } pub fn set_logged_in(&mut self, bool: bool) { diff --git a/src/instance.rs b/src/instance.rs index 7f2bb9e..3e52e88 100644 --- a/src/instance.rs +++ b/src/instance.rs @@ -87,6 +87,6 @@ impl Username { if username.len() < 2 || username.len() > 32 { return Err(FieldFormatError::UsernameError); } - return Ok(Username { username }); + Ok(Username { username }) } } diff --git a/src/lib.rs b/src/lib.rs index ab97b74..00170d0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -49,10 +49,10 @@ impl URLBundle { }; // if the last character of the string is a slash, remove it. let mut url_string = url.to_string(); - if url_string.chars().last().unwrap() == '/' { + if url_string.ends_with('/') { url_string.pop(); } - return url_string; + url_string } pub fn get_api(&self) -> &str { diff --git a/src/limit.rs b/src/limit.rs index f7f89d5..84e6d17 100644 --- a/src/limit.rs +++ b/src/limit.rs @@ -28,7 +28,7 @@ impl LimitedRequester { /// 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. #[allow(dead_code)] - pub async fn new(api_url: String) -> Self { + pub async fn new() -> Self { LimitedRequester { http: Client::new(), requests: VecDeque::new(), @@ -86,13 +86,13 @@ impl LimitedRequester { instance_rate_limits, user_rate_limits, ); - return Ok(response); + Ok(response) } else { self.requests.push_back(TypedRequest { - request: request, - limit_type: limit_type, + request, + limit_type, }); - return Err(InstanceServerError::RateLimited); + Err(InstanceServerError::RateLimited) } } @@ -125,7 +125,7 @@ impl LimitedRequester { ] .to_vec(); for limit in constant_limits.iter() { - match rate_limits.to_hash_map().get(&limit) { + match rate_limits.to_hash_map().get(limit) { Some(limit) => { if limit.remaining == 0 { return false; @@ -155,7 +155,7 @@ impl LimitedRequester { None => return false, } } - return true; + true } fn update_limits( @@ -183,7 +183,7 @@ impl LimitedRequester { let status = response.status(); let status_str = status.as_str(); - if status_str.chars().next().unwrap() == '4' { + if status_str.starts_with('4') { rate_limits .get_limit_mut_ref(&LimitType::Error) .add_remaining(-1); @@ -266,7 +266,7 @@ mod rate_limit { String::from("wss://localhost:3001/"), String::from("http://localhost:3001/cdn"), ); - let requester = LimitedRequester::new(urls.api).await; + let _requester = LimitedRequester::new().await; } #[tokio::test] @@ -276,7 +276,7 @@ mod rate_limit { String::from("wss://localhost:3001/"), 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> = None; let mut instance_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 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_builder = requester.http.get(request_path); let request = requester