u

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

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

@@ -103,11 +103,7 @@ 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",
-        alias = "de.sorunome.msc2409.push_ephemeral"
-    )]
+    #[serde(default, skip_serializing_if = "ruma_common::serde::is_default")]
     pub receive_ephemeral: bool,
 }
 

crates/ruma-common/src/push.rs

@@ -1286,6 +1286,9 @@ 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)
+        generate_enum("TimelineEventType", &timeline, &ruma_events, Some(&state))
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("StateEventType", &state, &ruma_events)
+        generate_enum("StateEventType", &state, &ruma_events, None)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("MessageLikeEventType", &message, &ruma_events)
+        generate_enum("MessageLikeEventType", &message, &ruma_events, None)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("EphemeralRoomEventType", &ephemeral, &ruma_events)
+        generate_enum("EphemeralRoomEventType", &ephemeral, &ruma_events, None)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("RoomAccountDataEventType", &room_account, &ruma_events)
+        generate_enum("RoomAccountDataEventType", &room_account, &ruma_events, None)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("GlobalAccountDataEventType", &global_account, &ruma_events)
+        generate_enum("GlobalAccountDataEventType", &global_account, &ruma_events, None)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
     res.extend(
-        generate_enum("ToDeviceEventType", &to_device, &ruma_events)
+        generate_enum("ToDeviceEventType", &to_device, &ruma_events, None)
             .unwrap_or_else(syn::Error::into_compile_error),
     );
 
@@ -83,6 +83,7 @@ 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());
@@ -101,6 +102,18 @@ 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
@@ -189,6 +202,38 @@ 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]
         ///
@@ -269,5 +314,6 @@ fn generate_enum(
         }
 
         #from_ident_for_timeline
+        #from_ident_for_state
     })
 }

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

@@ -48,6 +48,7 @@ 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 }
+ruma-common = { workspace = true, features = ["api"] }
 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,6 +323,7 @@ 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,
@@ -671,6 +672,7 @@ 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 = state_sets
+        let auth_chain: Vec<_> = 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 = state_sets
+        let auth_chain: Vec<_> = 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 = state_sets
+            let auth_chain_sets: Vec<_> = state_sets
                 .iter()
                 .map(|map| {
                     store.auth_event_ids(room_id(), map.values().cloned().collect()).unwrap()
@@ -626,6 +626,7 @@ 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)),
@@ -635,6 +636,7 @@ 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)),