chore: updated rust.toml

Author: Utilitycoder

rustfmt.toml

@@ -1 +1,22 @@
-# Run `cargo +nightly fmt` to properly group imports
+# Run `cargo +nightly fmt` to properly group imports
+
+edition = "2021"
+newline_style = "unix"
+use_field_init_shorthand = true
+use_small_heuristics = "Max"
+use_try_shorthand = true
+max_width = 100
+
+# Unstable features below
+unstable_features = true
+version = "Two"
+comment_width = 100
+format_code_in_doc_comments = true
+format_macro_bodies = true
+format_macro_matchers = true
+format_strings = true
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"
+normalize_comments = true
+normalize_doc_attributes = true
+wrap_comments = true

src/authentication/middleware.rs

@@ -1,17 +1,15 @@
-use crate::{
-    session_state::TypedSession,
-    utils::{e500, see_other},
-};
-use actix_web::{
-    body::MessageBody,
-    dev::{ServiceRequest, ServiceResponse},
-    error::InternalError,
-    {FromRequest, HttpMessage},
-};
-use actix_web_lab::middleware::Next;
 use std::ops::Deref;
+
+use actix_web::body::MessageBody;
+use actix_web::dev::{ServiceRequest, ServiceResponse};
+use actix_web::error::InternalError;
+use actix_web::{FromRequest, HttpMessage};
+use actix_web_lab::middleware::Next;
 use uuid::Uuid;
 
+use crate::session_state::TypedSession;
+use crate::utils::{e500, see_other};
+
 #[derive(Copy, Clone, Debug)]
 pub struct UserId(Uuid);
 

src/authentication/password.rs

@@ -1,8 +1,6 @@
 use anyhow::Context;
-use argon2::{
-    password_hash::SaltString, Algorithm, Argon2, Params, PasswordHash, PasswordHasher,
-    PasswordVerifier, Version,
-};
+use argon2::password_hash::SaltString;
+use argon2::{Algorithm, Argon2, Params, PasswordHash, PasswordHasher, PasswordVerifier, Version};
 use secrecy::{ExposeSecret, Secret};
 use sqlx::PgPool;
 
@@ -49,9 +47,8 @@ pub async fn validate_credentials(
 ) -> Result<uuid::Uuid, AuthError> {
     let mut user_id = None;
     let mut expected_password_hash = Secret::new(
-        "$argon2id$v=19$m=15000,t=2,p=1$\
-        gZiV/M1gPc22ElAH/Jh1Hw$\
-        CWOrkoo7oJBQ/iyh7uJ0LO2aLEfrHwTWllSAxT0zRno"
+        "$argon2id$v=19$m=15000,t=2,p=1$gZiV/M1gPc22ElAH/Jh1Hw$CWOrkoo7oJBQ/\
+         iyh7uJ0LO2aLEfrHwTWllSAxT0zRno"
             .to_string(),
     );
 
@@ -86,10 +83,7 @@ fn verify_password_hash(
         .context("Failed to parse hash in PHC string format.")?;
 
     Argon2::default()
-        .verify_password(
-            password_candidate.expose_secret().as_bytes(),
-            &expected_password_hash,
-        )
+        .verify_password(password_candidate.expose_secret().as_bytes(), &expected_password_hash)
         .context("Invalid password.")
         .map_err(AuthError::InvalidCredentials)
 }
@@ -120,12 +114,9 @@ pub async fn change_password(
 
 fn compute_password_hash(password: Secret<String>) -> Result<Secret<String>, anyhow::Error> {
     let salt = SaltString::generate(&mut rand::thread_rng());
-    let password_hash = Argon2::new(
-        Algorithm::Argon2id,
-        Version::V0x13,
-        Params::new(15000, 2, 1, None).unwrap(),
-    )
-    .hash_password(password.expose_secret().as_bytes(), &salt)?
-    .to_string();
+    let password_hash =
+        Argon2::new(Algorithm::Argon2id, Version::V0x13, Params::new(15000, 2, 1, None).unwrap())
+            .hash_password(password.expose_secret().as_bytes(), &salt)?
+            .to_string();
     Ok(Secret::new(password_hash))
 }

src/configuration.rs

@@ -1,11 +1,14 @@
-use crate::{domain::SubscriberEmail, email_client::EmailClient};
+use std::convert::{TryFrom, TryInto};
+
 use secrecy::{ExposeSecret, Secret};
 use serde_aux::field_attributes::deserialize_number_from_string;
 use sqlx::postgres::{PgConnectOptions, PgSslMode};
 use sqlx::ConnectOptions;
-use std::convert::{TryFrom, TryInto};
 use tracing_log::log;
 
+use crate::domain::SubscriberEmail;
+use crate::email_client::EmailClient;
+
 #[derive(serde::Deserialize, Clone)]
 pub struct Settings {
     pub database: DatabaseSettings,
@@ -35,12 +38,7 @@ impl EmailClientSettings {
     pub fn client(self) -> EmailClient {
         let sender_email = self.sender().expect("Invalid sender email address");
         let timeout = std::time::Duration::from_millis(self.timeout_ms);
-        EmailClient::new(
-            self.base_url,
-            sender_email,
-            self.authorization_token,
-            timeout,
-        )
+        EmailClient::new(self.base_url, sender_email, self.authorization_token, timeout)
     }
 
     pub fn sender(&self) -> Result<SubscriberEmail, String> {
@@ -65,11 +63,7 @@ pub struct DatabaseSettings {
 
 impl DatabaseSettings {
     pub fn without_db(&self) -> PgConnectOptions {
-        let ssl_mode = if self.require_ssl {
-            PgSslMode::Require
-        } else {
-            PgSslMode::Prefer
-        };
+        let ssl_mode = if self.require_ssl { PgSslMode::Require } else { PgSslMode::Prefer };
         PgConnectOptions::new()
             .host(&self.host)
             .username(&self.username)
@@ -102,14 +96,8 @@ pub fn get_configuration() -> Result<Settings, config::ConfigError> {
 
     let settings = config::Config::builder()
         .add_source(config::File::from(configuration_directory.join("base")))
-        .add_source(config::File::from(
-            configuration_directory.join(environment_filename),
-        ))
-        .add_source(
-            config::Environment::with_prefix("app")
-                .prefix_separator("_")
-                .separator("__"),
-        )
+        .add_source(config::File::from(configuration_directory.join(environment_filename)))
+        .add_source(config::Environment::with_prefix("app").prefix_separator("_").separator("__"))
         .build()?;
 
     settings.try_deserialize::<Settings>()

src/domain/new_subscriber.rs

@@ -1,4 +1,5 @@
-use crate::domain::{subscriber_email::SubscriberEmail, subscriber_name::SubscriberName};
+use crate::domain::subscriber_email::SubscriberEmail;
+use crate::domain::subscriber_name::SubscriberName;
 
 pub struct NewSubscriber {
     pub email: SubscriberEmail,

src/domain/subscriber_email.rs

@@ -29,12 +29,14 @@ impl std::fmt::Display for SubscriberEmail {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use claim::{assert_err, assert_ok};
     use fake::faker::internet::en::SafeEmail;
     use fake::Fake;
     use quickcheck::Gen;
-    use rand::{rngs::StdRng, SeedableRng};
+    use rand::rngs::StdRng;
+    use rand::SeedableRng;
+
+    use super::*;
 
     #[test]
     fn empty_string_is_rejected() {

src/domain/subscriber_name.rs

@@ -14,15 +14,14 @@ impl SubscriberName {
         let is_too_long = name.len() > 256;
         let forbidden_characters = ['/', '(', ')', '"', '<', '>', '\\', '{', '}'];
         // Check if the name contains any of the forbidden characters.
-        let contains_forbidden_characters = name
-            .chars()
-            .any(|char| forbidden_characters.contains(&char));
+        let contains_forbidden_characters =
+            name.chars().any(|char| forbidden_characters.contains(&char));
         // If any of the above checks returns true, return an error.
         if is_empty_or_whitespace || is_too_long || contains_forbidden_characters {
             Err(format!(
-                "`{}` is not a valid subscriber name. Subscriber name cannot be empty, more than 256 characters long, or contain the following characters: {:?}",
-                name,
-                forbidden_characters,
+                "`{}` is not a valid subscriber name. Subscriber name cannot be empty, more than \
+                 256 characters long, or contain the following characters: {:?}",
+                name, forbidden_characters,
             ))
         } else {
             Ok(Self(name))
@@ -32,9 +31,10 @@ impl SubscriberName {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use claim::{assert_err, assert_ok};
 
+    use super::*;
+
     #[test]
     fn a_256_graheme_long_name_is_valid() {
         let name = "a".repeat(256);

src/email_client.rs

@@ -1,7 +1,8 @@
-use crate::domain::SubscriberEmail;
 use reqwest::Client;
 use secrecy::{ExposeSecret, Secret};
 
+use crate::domain::SubscriberEmail;
+
 #[derive(Clone)]
 pub struct EmailClient {
     http_client: Client,
@@ -18,12 +19,7 @@ impl EmailClient {
         timeout: std::time::Duration,
     ) -> Self {
         let http_client = Client::builder().timeout(timeout).build().unwrap();
-        Self {
-            http_client,
-            base_url,
-            sender,
-            authorization_token,
-        }
+        Self { http_client, base_url, sender, authorization_token }
     }
 }
 
@@ -46,10 +42,7 @@ impl EmailClient {
 
         self.http_client
             .post(&url)
-            .header(
-                "X-Postmark-Server-Token",
-                self.authorization_token.expose_secret(),
-            )
+            .header("X-Postmark-Server-Token", self.authorization_token.expose_secret())
             .json(&request_body)
             .send()
             .await?
@@ -70,18 +63,16 @@ pub struct SendEmailRequest<'a> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{domain::SubscriberEmail, email_client::EmailClient};
     use claim::{assert_err, assert_ok};
-    use fake::{
-        faker::internet::en::SafeEmail,
-        faker::lorem::en::{Paragraph, Sentence},
-        Fake, Faker,
-    };
+    use fake::faker::internet::en::SafeEmail;
+    use fake::faker::lorem::en::{Paragraph, Sentence};
+    use fake::{Fake, Faker};
     use secrecy::Secret;
-    use wiremock::{
-        matchers::{any, header, header_exists, method, path},
-        Mock, MockServer, Request, ResponseTemplate,
-    };
+    use wiremock::matchers::{any, header, header_exists, method, path};
+    use wiremock::{Mock, MockServer, Request, ResponseTemplate};
+
+    use crate::domain::SubscriberEmail;
+    use crate::email_client::EmailClient;
 
     struct SendEmailBodyMatcher;
 
@@ -140,12 +131,7 @@ mod tests {
         let recipient = get_email();
 
         let _ = email_client
-            .send_email(
-                &recipient,
-                &generate_subject(),
-                &generate_content(),
-                &generate_content(),
-            )
+            .send_email(&recipient, &generate_subject(), &generate_content(), &generate_content())
             .await;
     }
 
@@ -208,11 +194,7 @@ mod tests {
 
         let response = ResponseTemplate::new(200).set_delay(std::time::Duration::from_secs(180));
 
-        Mock::given(any())
-            .respond_with(response)
-            .expect(1)
-            .mount(&mock_server)
-            .await;
+        Mock::given(any()).respond_with(response).expect(1).mount(&mock_server).await;
 
         let outcome = email_client
             .send_email(

src/idempotency/persistence.rs

@@ -1,8 +1,12 @@
-use super::IdempotencyKey;
-use actix_web::{body::to_bytes, http::StatusCode, HttpResponse};
-use sqlx::{postgres::PgHasArrayType, PgPool, Postgres, Transaction};
+use actix_web::body::to_bytes;
+use actix_web::http::StatusCode;
+use actix_web::HttpResponse;
+use sqlx::postgres::PgHasArrayType;
+use sqlx::{PgPool, Postgres, Transaction};
 use uuid::Uuid;
 
+use super::IdempotencyKey;
+
 #[derive(Debug, sqlx::Type)]
 #[sqlx(type_name = "header_pair")]
 struct HeaderPairRecord {

src/issue_delivery_worker.rs

@@ -1,12 +1,15 @@
-use crate::{
-    configuration::Settings, domain::SubscriberEmail, email_client::EmailClient,
-    startup::get_connection_pool,
-};
-use sqlx::{PgPool, Postgres, Transaction};
 use std::time::Duration;
-use tracing::{field::display, Span};
+
+use sqlx::{PgPool, Postgres, Transaction};
+use tracing::field::display;
+use tracing::Span;
 use uuid::Uuid;
 
+use crate::configuration::Settings;
+use crate::domain::SubscriberEmail;
+use crate::email_client::EmailClient;
+use crate::startup::get_connection_pool;
+
 pub enum ExecutionOutcome {
     TaskCompleted,
     EmptyQueue,
@@ -38,12 +41,7 @@ pub async fn try_execute_task(
         Ok(email) => {
             let issue = get_issue(pool, issue_id).await?;
             if let Err(e) = email_client
-                .send_email(
-                    &email,
-                    &issue.title,
-                    &issue.html_content,
-                    &issue.text_content,
-                )
+                .send_email(&email, &issue.title, &issue.html_content, &issue.text_content)
                 .await
             {
                 tracing::error!(
@@ -88,11 +86,7 @@ async fn dequeue_task(
     .fetch_optional(&mut *transaction)
     .await?;
     if let Some(r) = r {
-        Ok(Some((
-            transaction,
-            r.newsletter_issue_id,
-            r.subscriber_email,
-        )))
+        Ok(Some((transaction, r.newsletter_issue_id, r.subscriber_email)))
     } else {
         Ok(None)
     }

src/main.rs

@@ -1,8 +1,9 @@
-use robust_rust::{
-    configuration::get_configuration, issue_delivery_worker::run_worker_until_stopped,
-    startup::Application, telemetry::get_subscriber, telemetry::init_subscriber,
-};
 use std::fmt::{Debug, Display};
+
+use robust_rust::configuration::get_configuration;
+use robust_rust::issue_delivery_worker::run_worker_until_stopped;
+use robust_rust::startup::Application;
+use robust_rust::telemetry::{get_subscriber, init_subscriber};
 use tokio::task::JoinError;
 
 #[tokio::main]