style: Reformat

src/admin/debug/commands.rs

@@ -6,24 +6,24 @@ use std::{
 };
 
 use conduwuit::{
-	debug_error, err, info, matrix::{
+	Err, Result, debug_error, err, info,
-		pdu::{PduEvent, PduId, RawPduId},
+	matrix::{
 		Event,
-	}, trace,
+		pdu::{PduEvent, PduId, RawPduId},
-	utils,
+	},
+	trace, utils,
 	utils::{
 		stream::{IterStream, ReadyExt},
 		string::EMPTY,
-	}, warn,
+	},
-	Err,
+	warn,
-	Result,
 };
 use futures::{FutureExt, StreamExt, TryStreamExt};
 use lettre::message::Mailbox;
 use ruma::{
-	api::federation::event::get_room_state, events::AnyStateEvent, serde::Raw, CanonicalJsonObject, CanonicalJsonValue,
+	CanonicalJsonObject, CanonicalJsonValue, EventId, OwnedEventId, OwnedRoomId,
-	EventId, OwnedEventId, OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName,
+	OwnedRoomOrAliasId, OwnedServerName, RoomId, RoomVersionId, UInt,
-	RoomId, RoomVersionId, UInt,
+	api::federation::event::get_room_state, events::AnyStateEvent, serde::Raw,
 };
 use service::rooms::{
 	short::{ShortEventId, ShortRoomId},
@@ -813,7 +813,10 @@ pub(super) async fn force_set_room_state_from_server(
 				.await;
 
 			state.insert(shortstatekey, pdu.event_id.clone());
-			self.services.rooms.pdu_metadata.clear_pdu_markers(pdu.event_id());
+			self.services
+				.rooms
+				.pdu_metadata
+				.clear_pdu_markers(pdu.event_id());
 		}
 	}
 
@@ -831,7 +834,10 @@ pub(super) async fn force_set_room_state_from_server(
 			.rooms
 			.outlier
 			.add_pdu_outlier(&event_id, &value);
-		self.services.rooms.pdu_metadata.clear_pdu_markers(&event_id);
+		self.services
+			.rooms
+			.pdu_metadata
+			.clear_pdu_markers(&event_id);
 	}
 
 	info!("Resolving new room state");

src/service/rooms/event_handler/handle_outlier_pdu.rs

@@ -1,13 +1,13 @@
-use std::collections::{hash_map, BTreeMap, HashMap};
+use std::collections::{BTreeMap, HashMap, hash_map};
 
 use conduwuit::{
-	debug, debug_info, debug_warn, err, implement, state_res, trace, warn, Err, Event,
+	Err, Event, PduEvent, Result, debug, debug_info, debug_warn, err, implement, state_res,
-	PduEvent, Result,
+	trace, warn,
 };
 use futures::future::ready;
 use ruma::{
-	events::StateEventType, CanonicalJsonObject, CanonicalJsonValue, EventId, OwnedEventId, RoomId,
+	CanonicalJsonObject, CanonicalJsonValue, EventId, OwnedEventId, RoomId, ServerName,
-	ServerName,
+	events::StateEventType,
 };
 
 use super::{check_room_id, get_room_version_rules};

src/service/rooms/membership/mod.rs

@@ -1,46 +1,46 @@
 use std::{collections::HashMap, sync::Arc};
 
 use conduwuit::{
-	debug, debug_info, debug_warn, err, error, info, is_true, matrix::{
+	Err, Pdu, Result, Server, debug, debug_info, debug_warn, err, error, info, is_true,
-		event::{gen_event_id, gen_event_id_canonical_json},
+	matrix::{
 		StateKey,
-	}, pdu::PartialPdu, state_res, trace,
+		event::{gen_event_id, gen_event_id_canonical_json},
-	utils::{self, to_canonical_object, IterStream, ReadyExt},
+	},
+	pdu::PartialPdu,
+	state_res, trace,
+	utils::{self, IterStream, ReadyExt, to_canonical_object},
 	warn,
-	Err, Pdu,
-	Result,
-	Server,
 };
 use database::Database;
-use futures::{join, FutureExt, StreamExt, TryFutureExt};
+use futures::{FutureExt, StreamExt, TryFutureExt, join};
 use ruma::{
+	CanonicalJsonObject, CanonicalJsonValue, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId,
+	RoomVersionId, UserId,
 	api::{
 		error::{ErrorKind, IncompatibleRoomVersionErrorData},
 		federation,
-	}, canonical_json::to_canonical_value, events::{
+	},
+	canonical_json::to_canonical_value,
+	events::{
+		StateEventType, StaticEventContent,
 		room::{
 			join_rules::RoomJoinRulesEventContent,
 			member::{MembershipState, RoomMemberEventContent},
-		}, StateEventType,
+		},
-		StaticEventContent,
+	},
-	}, room::{AllowRule, JoinRule}, CanonicalJsonObject, CanonicalJsonValue,
+	room::{AllowRule, JoinRule},
-	OwnedRoomId, OwnedServerName,
-	OwnedUserId,
-	RoomId,
-	RoomVersionId,
-	UserId,
 };
 
 use crate::{
-	antispam, globals, rooms::{
+	Dep, antispam, globals,
+	rooms::{
 		metadata, outlier, pdu_metadata, short,
 		state::{self, RoomMutexGuard},
 		state_accessor, state_cache,
 		state_compressor::{self, CompressedState, HashSetCompressStateEvent},
 		timeline::{self, pdu_fits},
 	},
-	sending,
+	sending, server_keys, users,
-	server_keys, users, Dep,
 };
 
 pub struct Service {

src/service/rooms/pdu_metadata/data.rs

@@ -4,22 +4,22 @@ use conduwuit::{
 	arrayvec::ArrayVec,
 	matrix::{Event, PduCount},
 	utils::{
+		ReadyExt,
 		stream::{TryIgnore, WidebandExt},
 		u64_from_u8,
-		ReadyExt,
 	},
 };
 use database::Map;
 use futures::{Stream, StreamExt};
-use ruma::{api::Direction, EventId, RoomId, UserId};
+use ruma::{EventId, RoomId, UserId, api::Direction};
 
 use crate::{
+	Dep,
 	rooms::{
 		self,
 		short::{ShortEventId, ShortRoomId},
 		timeline::{PduId, PdusIterItem, RawPduId},
 	},
-	Dep,
 };
 
 pub(super) struct Data {

src/service/rooms/pdu_metadata/mod.rs

@@ -2,14 +2,14 @@ mod bundled_aggregations;
 mod data;
 use std::sync::Arc;
 
-use conduwuit::{matrix::PduCount, Result};
+use conduwuit::{Result, matrix::PduCount};
-use futures::{future::try_join, StreamExt};
+use futures::{StreamExt, future::try_join};
-use ruma::{api::Direction, EventId, RoomId, UserId};
+use ruma::{EventId, RoomId, UserId, api::Direction};
 
 use self::data::Data;
 use crate::{
-	rooms::{self, timeline::PdusIterItem},
 	Dep,
+	rooms::{self, timeline::PdusIterItem},
 };
 
 pub struct Service {