cargo clippy

src/api/client_server/account.rs

@@ -333,7 +333,7 @@ pub async fn whoami_route(body: Ruma<whoami::v3::Request>) -> Result<whoami::v3:
     Ok(whoami::v3::Response {
         user_id: sender_user.clone(),
         device_id,
-        is_guest: services().users.is_deactivated(&sender_user)?,
+        is_guest: services().users.is_deactivated(sender_user)?,
     })
 }
 
@@ -383,7 +383,7 @@ pub async fn deactivate_route(
     }
 
     // Make the user leave all rooms before deactivation
-    client_server::leave_all_rooms(&sender_user).await?;
+    client_server::leave_all_rooms(sender_user).await?;
 
     // Remove devices and mark account as deactivated
     services().users.deactivate_account(sender_user)?;

src/api/client_server/keys.rs

@@ -234,7 +234,7 @@ pub async fn get_key_changes_route(
             services()
                 .users
                 .keys_changed(
-                    &room_id.to_string(),
+                    room_id.as_ref(),
                     body.from.parse().map_err(|_| {
                         Error::BadRequest(ErrorKind::InvalidParam, "Invalid `from`.")
                     })?,
@@ -264,7 +264,7 @@ pub(crate) async fn get_keys_helper<F: Fn(&UserId) -> bool>(
     let mut get_over_federation = HashMap::new();
 
     for (user_id, device_ids) in device_keys_input {
-        let user_id: &UserId = &**user_id;
+        let user_id: &UserId = user_id;
 
         if user_id.server_name() != services().globals.server_name() {
             get_over_federation

src/api/client_server/membership.rs

@@ -62,15 +62,13 @@ pub async fn join_room_by_id_route(
 
     servers.push(body.room_id.server_name().to_owned());
 
-    let ret = join_room_by_id_helper(
+    join_room_by_id_helper(
         body.sender_user.as_deref(),
         &body.room_id,
         &servers,
         body.third_party_signed.as_ref(),
     )
-    .await;
-
-    ret
+    .await
 }
 
 /// # `POST /_matrix/client/r0/join/{roomIdOrAlias}`
@@ -171,7 +169,7 @@ pub async fn kick_user_route(
             .room_state_get(
                 &body.room_id,
                 &StateEventType::RoomMember,
-                &body.user_id.to_string(),
+                body.user_id.as_ref(),
             )?
             .ok_or(Error::BadRequest(
                 ErrorKind::BadState,
@@ -230,7 +228,7 @@ pub async fn ban_user_route(
         .room_state_get(
             &body.room_id,
             &StateEventType::RoomMember,
-            &body.user_id.to_string(),
+            body.user_id.as_ref(),
         )?
         .map_or(
             Ok(RoomMemberEventContent {
@@ -297,7 +295,7 @@ pub async fn unban_user_route(
             .room_state_get(
                 &body.room_id,
                 &StateEventType::RoomMember,
-                &body.user_id.to_string(),
+                body.user_id.as_ref(),
             )?
             .ok_or(Error::BadRequest(
                 ErrorKind::BadState,
@@ -408,7 +406,7 @@ pub async fn get_member_events_route(
             .await?
             .iter()
             .filter(|(key, _)| key.0 == StateEventType::RoomMember)
-            .map(|(_, pdu)| pdu.to_member_event().into())
+            .map(|(_, pdu)| pdu.to_member_event())
             .collect(),
     })
 }
@@ -864,7 +862,7 @@ pub(crate) async fn invite_helper<'a>(
             "${}",
             ruma::signatures::reference_hash(
                 &pdu_json,
-                &services().rooms.state.get_room_version(&room_id)?
+                &services().rooms.state.get_room_version(room_id)?
             )
             .expect("ruma can calculate reference hashes")
         );
@@ -878,7 +876,7 @@ pub(crate) async fn invite_helper<'a>(
                 create_invite::v2::Request {
                     room_id,
                     event_id: expected_event_id,
-                    room_version: &services().rooms.state.get_room_version(&room_id)?,
+                    room_version: &services().rooms.state.get_room_version(room_id)?,
                     event: &PduEvent::convert_to_outgoing_federation_event(pdu_json.clone()),
                     invite_room_state: &invite_room_state,
                 },
@@ -938,7 +936,7 @@ pub(crate) async fn invite_helper<'a>(
     if !services()
         .rooms
         .state_cache
-        .is_joined(sender_user, &room_id)?
+        .is_joined(sender_user, room_id)?
     {
         return Err(Error::BadRequest(
             ErrorKind::Forbidden,

src/api/client_server/room.rs

@@ -1,8 +1,6 @@
 use crate::{
     api::client_server::invite_helper, service::pdu::PduBuilder, services, Error, Result, Ruma,
 };
-use ruma::serde::JsonObject;
-use ruma::OwnedRoomAliasId;
 use ruma::{
     api::client::{
         error::ErrorKind,
@@ -23,7 +21,9 @@ use ruma::{
         },
         RoomEventType, StateEventType,
     },
-    int, CanonicalJsonObject, RoomAliasId, RoomId,
+    int,
+    serde::JsonObject,
+    CanonicalJsonObject, OwnedRoomAliasId, RoomAliasId, RoomId,
 };
 use serde_json::{json, value::to_raw_value};
 use std::{cmp::max, collections::BTreeMap, sync::Arc};
@@ -213,14 +213,11 @@ pub async fn create_room_route(
     // 3. Power levels
 
     // Figure out preset. We need it for preset specific events
-    let preset = body
-        .preset
-        .clone()
-        .unwrap_or_else(|| match &body.visibility {
-            room::Visibility::Private => RoomPreset::PrivateChat,
-            room::Visibility::Public => RoomPreset::PublicChat,
-            _ => RoomPreset::PrivateChat, // Room visibility should not be custom
-        });
+    let preset = body.preset.clone().unwrap_or(match &body.visibility {
+        room::Visibility::Private => RoomPreset::PrivateChat,
+        room::Visibility::Public => RoomPreset::PublicChat,
+        _ => RoomPreset::PrivateChat, // Room visibility should not be custom
+    });
 
     let mut users = BTreeMap::new();
     users.insert(sender_user.clone(), int!(100));

src/api/client_server/session.rs

@@ -53,11 +53,11 @@ pub async fn login_route(body: Ruma<login::v3::IncomingRequest>) -> Result<login
             } else {
                 return Err(Error::BadRequest(ErrorKind::Forbidden, "Bad login type."));
             };
-            let user_id = UserId::parse_with_server_name(
-                username.to_owned(),
-                services().globals.server_name(),
-            )
-            .map_err(|_| Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid."))?;
+            let user_id =
+                UserId::parse_with_server_name(username, services().globals.server_name())
+                    .map_err(|_| {
+                        Error::BadRequest(ErrorKind::InvalidUsername, "Username is invalid.")
+                    })?;
             let hash = services()
                 .users
                 .password_hash(&user_id)?

src/api/client_server/sync.rs

@@ -207,7 +207,7 @@ async fn sync_helper(
     device_list_updates.extend(
         services()
             .users
-            .keys_changed(&sender_user.to_string(), since, None)
+            .keys_changed(sender_user.as_ref(), since, None)
             .filter_map(|r| r.ok()),
     );
 
@@ -673,7 +673,7 @@ async fn sync_helper(
         device_list_updates.extend(
             services()
                 .users
-                .keys_changed(&room_id.to_string(), since, None)
+                .keys_changed(room_id.as_ref(), since, None)
                 .filter_map(|r| r.ok()),
         );
 
@@ -951,8 +951,8 @@ async fn sync_helper(
         },
         presence: Presence {
             events: presence_updates
-                .into_iter()
-                .map(|(_, v)| Raw::new(&v).expect("PresenceEvent always serializes successfully"))
+                .into_values()
+                .map(|v| Raw::new(&v).expect("PresenceEvent always serializes successfully"))
                 .collect(),
         },
         account_data: GlobalAccountData {

src/api/client_server/to_device.rs

@@ -58,7 +58,7 @@ pub async fn send_event_to_device_route(
                     services().users.add_to_device_event(
                         sender_user,
                         target_user_id,
-                        &target_device_id,
+                        target_device_id,
                         &body.event_type,
                         event.deserialize_as().map_err(|_| {
                             Error::BadRequest(ErrorKind::InvalidParam, "Event is invalid")

src/api/client_server/user_directory.rs

@@ -75,7 +75,7 @@ pub async fn search_users_route(
         let user_is_in_shared_rooms = services()
             .rooms
             .user
-            .get_shared_rooms(vec![sender_user.clone(), user_id.clone()])
+            .get_shared_rooms(vec![sender_user.clone(), user_id])
             .ok()?
             .next()
             .is_some();