change rustfmt configuration

This change is fully automated, except the `rustfmt.toml` changes and
a few clippy directives to allow specific functions with too many lines
because they are longer now.

src/api/client_server/state.rs

@@ -1,25 +1,30 @@
 use std::sync::Arc;
 
-use crate::{service::pdu::PduBuilder, services, Error, Result, Ruma, RumaResponse};
 use ruma::{
     api::client::{
         error::ErrorKind,
         state::{get_state_events, get_state_events_for_key, send_state_event},
     },
     events::{
-        room::canonical_alias::RoomCanonicalAliasEventContent, AnyStateEventContent, StateEventType,
+        room::canonical_alias::RoomCanonicalAliasEventContent,
+        AnyStateEventContent, StateEventType,
     },
     serde::Raw,
     EventId, RoomId, UserId,
 };
 use tracing::log::warn;
 
+use crate::{
+    service::pdu::PduBuilder, services, Error, Result, Ruma, RumaResponse,
+};
+
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/state/{eventType}/{stateKey}`
 ///
 /// Sends a state event into the room.
 ///
 /// - The only requirement for the content is that it has to be valid json
-/// - Tries to send the event into the room, auth rules will determine if it is allowed
+/// - Tries to send the event into the room, auth rules will determine if it is
+///   allowed
 /// - If event is new `canonical_alias`: Rejects if alias is incorrect
 pub(crate) async fn send_state_event_for_key_route(
     body: Ruma<send_state_event::v3::Request>,
@@ -37,7 +42,9 @@ pub(crate) async fn send_state_event_for_key_route(
     .await?;
 
     let event_id = (*event_id).to_owned();
-    Ok(send_state_event::v3::Response { event_id })
+    Ok(send_state_event::v3::Response {
+        event_id,
+    })
 }
 
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/state/{eventType}`
@@ -45,7 +52,8 @@ pub(crate) async fn send_state_event_for_key_route(
 /// Sends a state event into the room.
 ///
 /// - The only requirement for the content is that it has to be valid json
-/// - Tries to send the event into the room, auth rules will determine if it is allowed
+/// - Tries to send the event into the room, auth rules will determine if it is
+///   allowed
 /// - If event is new `canonical_alias`: Rejects if alias is incorrect
 pub(crate) async fn send_state_event_for_empty_key_route(
     body: Ruma<send_state_event::v3::Request>,
@@ -53,7 +61,9 @@ pub(crate) async fn send_state_event_for_empty_key_route(
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
     // Forbid m.room.encryption if encryption is disabled
-    if body.event_type == StateEventType::RoomEncryption && !services().globals.allow_encryption() {
+    if body.event_type == StateEventType::RoomEncryption
+        && !services().globals.allow_encryption()
+    {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,
             "Encryption has been disabled",
@@ -70,14 +80,18 @@ pub(crate) async fn send_state_event_for_empty_key_route(
     .await?;
 
     let event_id = (*event_id).to_owned();
-    Ok(send_state_event::v3::Response { event_id }.into())
+    Ok(send_state_event::v3::Response {
+        event_id,
+    }
+    .into())
 }
 
 /// # `GET /_matrix/client/r0/rooms/{roomid}/state`
 ///
 /// Get all state events for a room.
 ///
-/// - If not joined: Only works if current room history visibility is world readable
+/// - If not joined: Only works if current room history visibility is world
+///   readable
 pub(crate) async fn get_state_events_route(
     body: Ruma<get_state_events::v3::Request>,
 ) -> Result<get_state_events::v3::Response> {
@@ -110,7 +124,8 @@ pub(crate) async fn get_state_events_route(
 ///
 /// Get single state event of a room.
 ///
-/// - If not joined: Only works if current room history visibility is world readable
+/// - If not joined: Only works if current room history visibility is world
+///   readable
 pub(crate) async fn get_state_events_for_key_route(
     body: Ruma<get_state_events_for_key::v3::Request>,
 ) -> Result<get_state_events_for_key::v3::Response> {
@@ -140,8 +155,9 @@ pub(crate) async fn get_state_events_for_key_route(
         })?;
 
     Ok(get_state_events_for_key::v3::Response {
-        content: serde_json::from_str(event.content.get())
-            .map_err(|_| Error::bad_database("Invalid event content in database"))?,
+        content: serde_json::from_str(event.content.get()).map_err(|_| {
+            Error::bad_database("Invalid event content in database")
+        })?,
     })
 }
 
@@ -149,7 +165,8 @@ pub(crate) async fn get_state_events_for_key_route(
 ///
 /// Get single state event of a room.
 ///
-/// - If not joined: Only works if current room history visibility is world readable
+/// - If not joined: Only works if current room history visibility is world
+///   readable
 pub(crate) async fn get_state_events_for_empty_key_route(
     body: Ruma<get_state_events_for_key::v3::Request>,
 ) -> Result<RumaResponse<get_state_events_for_key::v3::Response>> {
@@ -179,8 +196,9 @@ pub(crate) async fn get_state_events_for_empty_key_route(
         })?;
 
     Ok(get_state_events_for_key::v3::Response {
-        content: serde_json::from_str(event.content.get())
-            .map_err(|_| Error::bad_database("Invalid event content in database"))?,
+        content: serde_json::from_str(event.content.get()).map_err(|_| {
+            Error::bad_database("Invalid event content in database")
+        })?,
     }
     .into())
 }
@@ -194,10 +212,11 @@ async fn send_state_event_for_key_helper(
 ) -> Result<Arc<EventId>> {
     let sender_user = sender;
 
-    // TODO: Review this check, error if event is unparsable, use event type, allow alias if it
-    // previously existed
-    if let Ok(canonical_alias) =
-        serde_json::from_str::<RoomCanonicalAliasEventContent>(json.json().get())
+    // TODO: Review this check, error if event is unparsable, use event type,
+    // allow alias if it previously existed
+    if let Ok(canonical_alias) = serde_json::from_str::<
+        RoomCanonicalAliasEventContent,
+    >(json.json().get())
     {
         let mut aliases = canonical_alias.alt_aliases.clone();
 
@@ -216,8 +235,8 @@ async fn send_state_event_for_key_helper(
             {
                 return Err(Error::BadRequest(
                     ErrorKind::Forbidden,
-                    "You are only allowed to send canonical_alias \
-                    events when it's aliases already exists",
+                    "You are only allowed to send canonical_alias events when \
+                     it's aliases already exists",
                 ));
             }
         }
@@ -240,7 +259,8 @@ async fn send_state_event_for_key_helper(
         .build_and_append_pdu(
             PduBuilder {
                 event_type: event_type.to_string().into(),
-                content: serde_json::from_str(json.json().get()).expect("content is valid json"),
+                content: serde_json::from_str(json.json().get())
+                    .expect("content is valid json"),
                 unsigned: None,
                 state_key: Some(state_key),
                 redacts: None,