refactor: Batch of unrelated changes

Signed-off-by: Kévin Commaille <zecakeh@tedomum.fr>

Author: zecakeh

bindings/matrix-sdk-ffi/src/client.rs

@@ -2402,9 +2402,7 @@ impl TryFrom<AllowRule> for RumaAllowRule {
         match value {
             AllowRule::RoomMembership { room_id } => {
                 let room_id = RoomId::parse(room_id)?;
-                Ok(Self::RoomMembership(ruma::events::room::join_rules::RoomMembership::new(
-                    room_id,
-                )))
+                Ok(Self::RoomMembership(ruma::room::RoomMembership::new(room_id)))
             }
             AllowRule::Custom { json } => Ok(Self::_Custom(Box::new(serde_json::from_str(&json)?))),
         }

bindings/matrix-sdk-ffi/src/room/mod.rs

@@ -484,7 +484,7 @@ impl Room {
     /// # Errors
     ///
     /// Returns an error if the room is not found or on rate limit
-    pub async fn report_room(&self, reason: Option<String>) -> Result<(), ClientError> {
+    pub async fn report_room(&self, reason: String) -> Result<(), ClientError> {
         self.inner.report_room(reason).await?;
 
         Ok(())

crates/matrix-sdk-crypto/src/file_encryption/attachments.rs

@@ -136,20 +136,19 @@ impl<'a, R: Read + 'a> AttachmentDecryptor<'a, R> {
 
         let hash =
             info.hashes.get("sha256").ok_or(DecryptorError::MissingHash)?.as_bytes().to_owned();
-        let mut key = info.key.k.into_inner();
+        let key = info.key.k.as_bytes();
         let iv = info.iv.into_inner();
 
         if key.len() != KEY_SIZE {
             return Err(DecryptorError::KeyNonceLength);
         }
 
-        let key_array = GenericArray::from_slice(&key);
+        let key_array = GenericArray::from_slice(key);
         let iv = GenericArray::from_exact_iter(iv).ok_or(DecryptorError::KeyNonceLength)?;
 
         let sha = Sha256::default();
 
         let aes = Aes256Ctr::new(key_array, &iv);
-        key.zeroize();
 
         Ok(AttachmentDecryptor { inner: input, expected_hash: hash, sha, aes })
     }

crates/matrix-sdk-crypto/src/machine/test_helpers.rs

@@ -334,7 +334,7 @@ pub fn bootstrap_requests_to_keys_query_response(
 /// Helper for [`create_signed_device_of_unverified_user`] and
 /// [`create_unsigned_device`].
 fn dummy_verification_machine() -> VerificationMachine {
-    let account = Account::new(user_id!("@TEST_USER:example.com"));
+    let account = Account::new(user_id!("@test_user:example.com"));
     VerificationMachine::new(
         account.deref().clone(),
         Arc::new(Mutex::new(PrivateCrossSigningIdentity::new(account.user_id().to_owned()))),

crates/matrix-sdk-crypto/src/machine/tests/mod.rs

@@ -36,8 +36,8 @@ use ruma::{
         room::message::{
             AddMentions, MessageType, Relation, ReplyWithinThread, RoomMessageEventContent,
         },
-        AnyMessageLikeEvent, AnyMessageLikeEventContent, AnyToDeviceEvent, MessageLikeEvent,
-        OriginalMessageLikeEvent, ToDeviceEventType,
+        AnyMessageLikeEvent, AnyMessageLikeEventContent, AnySyncMessageLikeEvent, AnyToDeviceEvent,
+        MessageLikeEvent, OriginalMessageLikeEvent, ToDeviceEventType,
     },
     room_id,
     serde::Raw,
@@ -1442,8 +1442,8 @@ async fn test_unsigned_decryption() {
 
     // Encrypt a second message, an edit.
     let second_message_text = "This is the ~~original~~ edited message";
-    let second_message_content = RoomMessageEventContent::text_plain(second_message_text)
-        .make_replacement(first_message, None);
+    let second_message_content =
+        RoomMessageEventContent::text_plain(second_message_text).make_replacement(first_message);
     let second_message_encrypted_content =
         alice.encrypt_room_event(room_id, second_message_content).await.unwrap();
 
@@ -1579,7 +1579,10 @@ async fn test_unsigned_decryption() {
     assert!(first_message.unsigned.relations.replace.is_some());
     // Deserialization of the thread event succeeded, but it is still encrypted.
     let thread = first_message.unsigned.relations.thread.as_ref().unwrap();
-    assert_matches!(thread.latest_event.deserialize(), Ok(AnyMessageLikeEvent::RoomEncrypted(_)));
+    assert_matches!(
+        thread.latest_event.deserialize(),
+        Ok(AnySyncMessageLikeEvent::RoomEncrypted(_))
+    );
 
     let unsigned_encryption_info = raw_decrypted_event.unsigned_encryption_info.unwrap();
     assert_eq!(unsigned_encryption_info.len(), 2);
@@ -1625,7 +1628,7 @@ async fn test_unsigned_decryption() {
     let thread = &first_message.unsigned.relations.thread.as_ref().unwrap();
     assert_matches!(
         thread.latest_event.deserialize(),
-        Ok(AnyMessageLikeEvent::RoomMessage(third_message))
+        Ok(AnySyncMessageLikeEvent::RoomMessage(third_message))
     );
     let third_message = third_message.as_original().unwrap();
     assert_eq!(third_message.content.body(), third_message_text);

crates/matrix-sdk/src/client/mod.rs

@@ -48,9 +48,8 @@ use ruma::{
             device::{delete_devices, get_devices, update_device},
             directory::{get_public_rooms, get_public_rooms_filtered},
             discovery::{
-                discover_homeserver,
-                discover_homeserver::RtcFocusInfo,
-                get_capabilities::{self, Capabilities},
+                discover_homeserver::{self, RtcFocusInfo},
+                get_capabilities::{self, v3::Capabilities},
                 get_supported_versions,
             },
             error::ErrorKind,

crates/matrix-sdk/src/encryption/mod.rs

@@ -348,8 +348,9 @@ pub struct OAuthCrossSigningResetInfo {
 
 impl OAuthCrossSigningResetInfo {
     fn from_auth_info(auth_info: &UiaaInfo) -> Result<Self> {
-        let parameters =
-            serde_json::from_str::<OAuthCrossSigningResetUiaaParameters>(auth_info.params.get())?;
+        let parameters = serde_json::from_str::<OAuthCrossSigningResetUiaaParameters>(
+            auth_info.params.as_ref().map(|value| value.get()).unwrap_or_default(),
+        )?;
 
         Ok(OAuthCrossSigningResetInfo { approval_url: parameters.reset.url })
     }

crates/matrix-sdk/src/event_handler/static_events.rs

@@ -16,11 +16,9 @@
 
 use ruma::{
     events::{
-        self,
-        presence::{PresenceEvent, PresenceEventContent},
-        AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent, AnyStrippedStateEvent,
-        AnySyncEphemeralRoomEvent, AnySyncMessageLikeEvent, AnySyncStateEvent,
-        AnySyncTimelineEvent, AnyToDeviceEvent, EphemeralRoomEventContent,
+        self, presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent,
+        AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncMessageLikeEvent,
+        AnySyncStateEvent, AnySyncTimelineEvent, AnyToDeviceEvent, EphemeralRoomEventContent,
         GlobalAccountDataEventContent, MessageLikeEventContent, PossiblyRedactedStateEventContent,
         RedactContent, RedactedMessageLikeEventContent, RedactedStateEventContent,
         RoomAccountDataEventContent, StaticEventContent, StaticStateEventContent,
@@ -141,7 +139,7 @@ where
 
 impl SyncEvent for PresenceEvent {
     const KIND: HandlerKind = HandlerKind::Presence;
-    const TYPE: Option<&'static str> = Some(PresenceEventContent::TYPE);
+    const TYPE: Option<&'static str> = None;
 }
 
 impl SyncEvent for AnyGlobalAccountDataEvent {

crates/matrix-sdk/src/http_client/mod.rs

@@ -171,6 +171,7 @@ impl HttpClient {
                 AuthScheme::AccessToken
                 | AuthScheme::AccessTokenOptional
                 | AuthScheme::AppserviceToken
+                | AuthScheme::AppserviceTokenOptional
                 | AuthScheme::None => {}
                 AuthScheme::ServerSignatures => {
                     return Err(HttpError::NotClientRequest);

crates/matrix-sdk/src/room/mod.rs

@@ -3159,9 +3159,8 @@ impl Room {
     /// # Errors
     ///
     /// Returns an error if the room is not found or on rate limit
-    pub async fn report_room(&self, reason: Option<String>) -> Result<report_room::v3::Response> {
-        let mut request = report_room::v3::Request::new(self.inner.room_id().to_owned());
-        request.reason = reason;
+    pub async fn report_room(&self, reason: String) -> Result<report_room::v3::Response> {
+        let request = report_room::v3::Request::new(self.inner.room_id().to_owned(), reason);
 
         Ok(self.client.send(request).await?)
     }