crates/ruma-appservice-api/src/lib.rs

@@ -103,7 +103,11 @@ pub struct Registration {
     /// Whether the application service wants to receive ephemeral data.
     ///
     /// Defaults to `false`.
-    #[serde(default, skip_serializing_if = "ruma_common::serde::is_default")]
+    #[serde(
+        default,
+        skip_serializing_if = "ruma_common::serde::is_default",
+        alias = "de.sorunome.msc2409.push_ephemeral"
+    )]
     pub receive_ephemeral: bool,
 }
 

crates/ruma-common/src/push.rs

@@ -1286,9 +1286,6 @@ mod tests {
                         "enabled": true
                     }
                 ],
-                "room": [],
-                "sender": [],
-                "underride": [],
             })
         );
     }

crates/ruma-macros/src/events/event_type.rs

@@ -48,31 +48,31 @@ pub fn expand_event_type_enum(
     let mut res = TokenStream::new();
 
     res.extend(
-        generate_enum("TimelineEventType", &timeline, &ruma_events, Some(&state))
+        generate_enum("TimelineEventType", &timeline, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("StateEventType", &state, &ruma_events, None)
+        generate_enum("StateEventType", &state, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("MessageLikeEventType", &message, &ruma_events, None)
+        generate_enum("MessageLikeEventType", &message, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("EphemeralRoomEventType", &ephemeral, &ruma_events, None)
+        generate_enum("EphemeralRoomEventType", &ephemeral, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("RoomAccountDataEventType", &room_account, &ruma_events, None)
+        generate_enum("RoomAccountDataEventType", &room_account, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("GlobalAccountDataEventType", &global_account, &ruma_events, None)
+        generate_enum("GlobalAccountDataEventType", &global_account, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("ToDeviceEventType", &to_device, &ruma_events, None)
+        generate_enum("ToDeviceEventType", &to_device, &ruma_events)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
 
@@ -83,7 +83,6 @@ fn generate_enum(
     ident: &str,
     input: &[&Vec<EventEnumEntry>],
     ruma_common: &TokenStream,
-    other: Option<&[&Vec<EventEnumEntry>]>,
 ) -> syn::Result<TokenStream> {
     let serde = quote! { #ruma_common::exports::serde };
     let enum_doc = format!("The type of `{}` this is.", ident.strip_suffix("Type").unwrap());
@@ -102,18 +101,6 @@ fn generate_enum(
         }
     }
 
-    let mut other_deduped: Vec<&EventEnumEntry> = vec![];
-    for item in other.iter().flat_map(|o| o.iter()).copied().flatten() {
-        if let Some(idx) = other_deduped.iter().position(|e| e.ev_type == item.ev_type) {
-            // If there is a variant without config attributes use that
-            if other_deduped[idx].attrs != item.attrs && item.attrs.is_empty() {
-                other_deduped[idx] = item;
-            }
-        } else {
-            other_deduped.push(item);
-        }
-    }
-
     let event_types = deduped.iter().map(|e| &e.ev_type);
 
     let variants: Vec<_> = deduped
@@ -202,38 +189,6 @@ fn generate_enum(
         None
     };
 
-    let from_ident_for_state = if ident == "TimelineEventType" {
-        let match_arms: Vec<_> = other_deduped
-            .iter()
-            .map(|e| {
-                let v = e.to_variant()?;
-                let ident_var = v.match_arm(quote! { #ident });
-                let state_var = v.ctor(quote! { Self });
-
-                Ok(if e.has_type_fragment() {
-                    quote! { #ident_var (_s) => #state_var (_s) }
-                } else {
-                    quote! { #ident_var => #state_var }
-                })
-            })
-            .collect::<syn::Result<_>>()?;
-
-        Some(quote! {
-            #[allow(deprecated)]
-            impl ::std::convert::From<#ident> for StateEventType {
-                fn from(s: #ident) -> Self {
-                    match s {
-                        #(#match_arms,)*
-                        _ => panic!("EventType is not a StateEventType"),
-                        //_ => compile_error!("EventType is not a StateEventType"),
-                    }
-                }
-            }
-        })
-    } else {
-        None
-    };
-
     Ok(quote! {
         #[doc = #enum_doc]
         ///
@@ -314,6 +269,5 @@ fn generate_enum(
         }
 
         #from_ident_for_timeline
-        #from_ident_for_state
     })
 }

crates/ruma-push-gateway-api/src/send_event_notification.rs

@@ -48,7 +48,6 @@ pub mod v1 {
         /// pushkeys and remove the associated pushers. It may not necessarily be the notification
         /// in the request that failed: it could be that a previous notification to the same
         /// pushkey failed. May be empty.
-        #[serde(default)]
         pub rejected: Vec<String>,
     }
 

crates/ruma-server-util/Cargo.toml

@@ -18,7 +18,7 @@ all-features = true
 headers = "0.4.0"
 http = { workspace = true }
 http-auth = { version = "0.1.9", default-features = false }
-ruma-common = { workspace = true, features = ["api"] }
+ruma-common = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 

crates/ruma-signatures/src/functions.rs

@@ -151,7 +151,7 @@ where
 /// }"#;
 ///
 /// let object = serde_json::from_str(input).unwrap();
-/// let canonical = ruma_signatures::canonical_json(object).unwrap();
+/// let canonical = ruma_signatures::canonical_json(&object).unwrap();
 ///
 /// assert_eq!(canonical, r#"{"日":1,"本":2}"#);
 /// ```
@@ -204,7 +204,7 @@ pub fn canonical_json(object: CanonicalJsonObject) -> Result<String, Error> {
 /// public_key_map.insert("domain".into(), public_key_set);
 ///
 /// // Verify at least one signature for each entity in `public_key_map`.
-/// assert!(ruma_signatures::verify_json(&public_key_map, object).is_ok());
+/// assert!(ruma_signatures::verify_json(&public_key_map, &object).is_ok());
 /// ```
 pub fn verify_json(
     public_key_map: &PublicKeyMap,

crates/ruma-state-res/src/event_auth.rs

@@ -323,7 +323,6 @@ where
             .map(|mem| mem.membership)
             .unwrap_or(MembershipState::Leave);
 
-            println!("===========incoming event: {:?}  target_user:{target_user:?}  sender:{sender:?}", incoming_event.content());
         if !valid_membership_change(
             room_version,
             target_user,
@@ -672,7 +671,6 @@ fn valid_membership_change(
             }
         }
         MembershipState::Leave => {
-            println!("==============sender: {}  target_user:{target_user} target_user_current_membership:{:?}", sender, target_user_current_membership);
             if sender == target_user {
                 let allow = target_user_current_membership == MembershipState::Join
                     || target_user_current_membership == MembershipState::Invite

crates/ruma-state-res/src/lib.rs

@@ -1223,7 +1223,7 @@ mod tests {
         let exists = |id: <PduEvent as Event>::Id| ready(ev_map.get(&*id).is_some());
 
         let state_sets = [state_at_bob, state_at_charlie];
-        let auth_chain: Vec<_> = state_sets
+        let auth_chain = state_sets
             .iter()
             .map(|map| store.auth_event_ids(room_id(), map.values().cloned().collect()).unwrap())
             .collect();
@@ -1330,7 +1330,7 @@ mod tests {
 
         let ev_map = &store.0;
         let state_sets = [state_set_a, state_set_b];
-        let auth_chain: Vec<_> = state_sets
+        let auth_chain = state_sets
             .iter()
             .map(|map| store.auth_event_ids(room_id(), map.values().cloned().collect()).unwrap())
             .collect();

crates/ruma-state-res/src/test_utils.rs

@@ -112,7 +112,7 @@ pub(crate) async fn do_check(
                     .collect::<Vec<_>>()
             );
 
-            let auth_chain_sets: Vec<_> = state_sets
+            let auth_chain_sets = state_sets
                 .iter()
                 .map(|map| {
                     store.auth_event_ids(room_id(), map.values().cloned().collect()).unwrap()
@@ -626,7 +626,6 @@ pub(crate) mod event {
             }
         }
 
-        #[allow(refining_impl_trait)]
         fn prev_events(&self) -> Box<dyn DoubleEndedIterator<Item = &Self::Id> + Send + '_> {
             match &self.rest {
                 Pdu::RoomV1Pdu(ev) => Box::new(ev.prev_events.iter().map(|(id, _)| id)),
@@ -636,7 +635,6 @@ pub(crate) mod event {
             }
         }
 
-        #[allow(refining_impl_trait)]
         fn auth_events(&self) -> Box<dyn DoubleEndedIterator<Item = &Self::Id> + Send + '_> {
             match &self.rest {
                 Pdu::RoomV1Pdu(ev) => Box::new(ev.auth_events.iter().map(|(id, _)| id)),