run cargo fix for rust 2024 changes and rustfmt

Signed-off-by: June Clementine Strawberry <strawberry@puppygock.gay>

src/service/rooms/state_accessor/mod.rs

@@ -9,14 +9,16 @@ use std::{
 };
 
 use conduwuit::{
-	err, utils,
-	utils::math::{usize_from_f64, Expected},
-	Result,
+	Result, err, utils,
+	utils::math::{Expected, usize_from_f64},
 };
 use database::Map;
 use lru_cache::LruCache;
 use ruma::{
+	EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, OwnedRoomId, OwnedServerName,
+	OwnedUserId, RoomId, UserId,
 	events::{
+		StateEventType,
 		room::{
 			avatar::RoomAvatarEventContent,
 			canonical_alias::RoomCanonicalAliasEventContent,
@@ -29,15 +31,12 @@ use ruma::{
 			name::RoomNameEventContent,
 			topic::RoomTopicEventContent,
 		},
-		StateEventType,
 	},
 	room::RoomType,
 	space::SpaceRoomJoinRule,
-	EventEncryptionAlgorithm, JsOption, OwnedRoomAliasId, OwnedRoomId, OwnedServerName,
-	OwnedUserId, RoomId, UserId,
 };
 
-use crate::{rooms, rooms::short::ShortStateHash, Dep};
+use crate::{Dep, rooms, rooms::short::ShortStateHash};
 
 pub struct Service {
 	pub server_visibility_cache: Mutex<LruCache<(OwnedServerName, ShortStateHash), bool>>,

src/service/rooms/state_accessor/room_state.rs

@@ -1,8 +1,8 @@
 use std::borrow::Borrow;
 
-use conduwuit::{err, implement, PduEvent, Result, StateKey};
+use conduwuit::{PduEvent, Result, StateKey, err, implement};
 use futures::{Stream, StreamExt, TryFutureExt};
-use ruma::{events::StateEventType, EventId, RoomId};
+use ruma::{EventId, RoomId, events::StateEventType};
 use serde::Deserialize;
 
 /// Returns a single PDU from `room_id` with key (`event_type`,`state_key`).

src/service/rooms/state_accessor/server_can.rs

@@ -1,11 +1,11 @@
 use conduwuit::{error, implement, utils::stream::ReadyExt};
 use futures::StreamExt;
 use ruma::{
-	events::{
-		room::history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
-		StateEventType,
-	},
 	EventId, RoomId, ServerName,
+	events::{
+		StateEventType,
+		room::history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
+	},
 };
 
 /// Whether a server is allowed to see an event through federation, based on

src/service/rooms/state_accessor/state.rs

@@ -1,27 +1,26 @@
 use std::{borrow::Borrow, ops::Deref, sync::Arc};
 
 use conduwuit::{
-	at, err, implement, pair_of,
+	PduEvent, Result, StateKey, at, err, implement, pair_of,
 	utils::{
 		result::FlatOk,
 		stream::{BroadbandExt, IterStream, ReadyExt, TryExpect},
 	},
-	PduEvent, Result, StateKey,
 };
 use database::Deserialized;
-use futures::{future::try_join, pin_mut, FutureExt, Stream, StreamExt, TryFutureExt};
+use futures::{FutureExt, Stream, StreamExt, TryFutureExt, future::try_join, pin_mut};
 use ruma::{
-	events::{
-		room::member::{MembershipState, RoomMemberEventContent},
-		StateEventType,
-	},
 	EventId, OwnedEventId, UserId,
+	events::{
+		StateEventType,
+		room::member::{MembershipState, RoomMemberEventContent},
+	},
 };
 use serde::Deserialize;
 
 use crate::rooms::{
 	short::{ShortEventId, ShortStateHash, ShortStateKey},
-	state_compressor::{compress_state_event, parse_compressed_state_event, CompressedState},
+	state_compressor::{CompressedState, compress_state_event, parse_compressed_state_event},
 };
 
 /// The user was a joined member at this state (potentially in the past)

src/service/rooms/state_accessor/user_can.rs

@@ -1,14 +1,14 @@
-use conduwuit::{error, implement, pdu::PduBuilder, Err, Error, Result};
+use conduwuit::{Err, Error, Result, error, implement, pdu::PduBuilder};
 use ruma::{
+	EventId, RoomId, UserId,
 	events::{
+		StateEventType, TimelineEventType,
 		room::{
 			history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
 			member::{MembershipState, RoomMemberEventContent},
 			power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
 		},
-		StateEventType, TimelineEventType,
 	},
-	EventId, RoomId, UserId,
 };
 
 use crate::rooms::state::RoomMutexGuard;
@@ -44,7 +44,7 @@ pub async fn user_can_redact(
 		)));
 	}
 
-	if let Ok(pl_event_content) = self
+	match self
 		.room_state_get_content::<RoomPowerLevelsEventContent>(
 			room_id,
 			&StateEventType::RoomPowerLevels,
@@ -52,33 +52,35 @@ pub async fn user_can_redact(
 		)
 		.await
 	{
-		let pl_event: RoomPowerLevels = pl_event_content.into();
-		Ok(pl_event.user_can_redact_event_of_other(sender)
-			|| pl_event.user_can_redact_own_event(sender)
-				&& if let Ok(redacting_event) = redacting_event {
-					if federation {
-						redacting_event.sender.server_name() == sender.server_name()
-					} else {
-						redacting_event.sender == sender
-					}
-				} else {
-					false
-				})
-	} else {
-		// Falling back on m.room.create to judge power level
-		if let Ok(room_create) = self
-			.room_state_get(room_id, &StateEventType::RoomCreate, "")
-			.await
-		{
-			Ok(room_create.sender == sender
-				|| redacting_event
-					.as_ref()
-					.is_ok_and(|redacting_event| redacting_event.sender == sender))
-		} else {
-			Err(Error::bad_database(
-				"No m.room.power_levels or m.room.create events in database for room",
-			))
-		}
+		| Ok(pl_event_content) => {
+			let pl_event: RoomPowerLevels = pl_event_content.into();
+			Ok(pl_event.user_can_redact_event_of_other(sender)
+				|| pl_event.user_can_redact_own_event(sender)
+					&& match redacting_event {
+						| Ok(redacting_event) =>
+							if federation {
+								redacting_event.sender.server_name() == sender.server_name()
+							} else {
+								redacting_event.sender == sender
+							},
+						| _ => false,
+					})
+		},
+		| _ => {
+			// Falling back on m.room.create to judge power level
+			match self
+				.room_state_get(room_id, &StateEventType::RoomCreate, "")
+				.await
+			{
+				| Ok(room_create) => Ok(room_create.sender == sender
+					|| redacting_event
+						.as_ref()
+						.is_ok_and(|redacting_event| redacting_event.sender == sender)),
+				| _ => Err(Error::bad_database(
+					"No m.room.power_levels or m.room.create events in database for room",
+				)),
+			}
+		},
 	}
 }