Rename *EventStub -> Sync*Event

ruma-client-api/src/r0/sync/sync_events.rs

@@ -6,8 +6,8 @@ use js_int::UInt;
 use ruma_api::ruma_api;
 use ruma_common::presence::PresenceState;
 use ruma_events::{
-    presence::PresenceEvent, AnyBasicEvent, AnyEphemeralRoomEventStub, AnyRoomEventStub,
-    AnyStateEventStub, AnyStrippedStateEventStub, AnyToDeviceEvent, EventJson,
+    presence::PresenceEvent, AnyBasicEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent,
+    AnySyncRoomEvent, AnySyncStateEvent, AnyToDeviceEvent, EventJson,
 };
 use ruma_identifiers::{RoomId, UserId};
 use serde::{Deserialize, Serialize};
@@ -242,7 +242,7 @@ pub struct Timeline {
     pub prev_batch: Option<String>,
 
     /// A list of events.
-    pub events: Vec<EventJson<AnyRoomEventStub>>,
+    pub events: Vec<EventJson<AnySyncRoomEvent>>,
 }
 
 impl Timeline {
@@ -256,7 +256,7 @@ impl Timeline {
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct State {
     /// A list of state events.
-    pub events: Vec<EventJson<AnyStateEventStub>>,
+    pub events: Vec<EventJson<AnySyncStateEvent>>,
 }
 
 impl State {
@@ -284,7 +284,7 @@ impl AccountData {
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct Ephemeral {
     /// A list of events.
-    pub events: Vec<EventJson<AnyEphemeralRoomEventStub>>,
+    pub events: Vec<EventJson<AnySyncEphemeralRoomEvent>>,
 }
 
 impl Ephemeral {
@@ -343,7 +343,7 @@ impl InvitedRoom {
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct InviteState {
     /// A list of state events.
-    pub events: Vec<EventJson<AnyStrippedStateEventStub>>,
+    pub events: Vec<EventJson<AnyStrippedStateEvent>>,
 }
 
 impl InviteState {

ruma-events-macros/src/event_enum.rs

@@ -15,7 +15,7 @@ fn is_non_stripped_room_event(kind: &EventKind, var: &EventKindVariation) -> boo
 
 fn has_prev_content_field(kind: &EventKind, var: &EventKindVariation) -> bool {
     matches!(kind, EventKind::State(_))
-        && matches!(var, EventKindVariation::Full | EventKindVariation::Stub)
+        && matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
 }
 
 type EventKindFn = fn(&EventKind, &EventKindVariation) -> bool;
@@ -48,8 +48,8 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
     let event_enum =
         expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Full);
 
-    let event_stub_enum =
-        expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Stub);
+    let sync_event_enum =
+        expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Sync);
 
     let event_stripped_enum =
         expand_any_with_deser(name, events, attrs, &variants, &EventKindVariation::Stripped);
@@ -61,7 +61,7 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
     Ok(quote! {
         #event_enum
 
-        #event_stub_enum
+        #sync_event_enum
 
         #event_stripped_enum
 
@@ -154,26 +154,26 @@ fn expand_any_redacted(
     use EventKindVariation::*;
 
     if kind.is_state() {
-        let state_full = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
-        let state_stub = expand_any_with_deser(kind, events, attrs, variants, &RedactedStub);
-        let state_stripped =
+        let full_state = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
+        let sync_state = expand_any_with_deser(kind, events, attrs, variants, &RedactedSync);
+        let stripped_state =
             expand_any_with_deser(kind, events, attrs, variants, &RedactedStripped);
 
         quote! {
-            #state_full
+            #full_state
 
-            #state_stub
+            #sync_state
 
-            #state_stripped
+            #stripped_state
         }
     } else if kind.is_message() {
-        let message_full = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
-        let message_stub = expand_any_with_deser(kind, events, attrs, variants, &RedactedStub);
+        let full_message = expand_any_with_deser(kind, events, attrs, variants, &Redacted);
+        let sync_message = expand_any_with_deser(kind, events, attrs, variants, &RedactedSync);
 
         quote! {
-            #message_full
+            #full_message
 
-            #message_stub
+            #sync_message
         }
     } else {
         TokenStream::new()
@@ -250,7 +250,7 @@ fn expand_custom_variant(
 ) -> (TokenStream, TokenStream) {
     use EventKindVariation::*;
 
-    if matches!(var, Redacted | RedactedStub | RedactedStripped) {
+    if matches!(var, Redacted | RedactedSync | RedactedStripped) {
         (
             quote! {
                 /// A redacted event not defined by the Matrix specification
@@ -317,7 +317,7 @@ fn accessor_methods(
     let ident = kind.to_event_enum_ident(var)?;
 
     // matching `EventKindVariation`s
-    if let Redacted | RedactedStub | RedactedStripped = var {
+    if let Redacted | RedactedSync | RedactedStripped = var {
         return redacted_accessor_methods(kind, var, variants);
     }
 
@@ -408,15 +408,15 @@ fn to_event_path(name: &LitStr, struct_name: &Ident) -> TokenStream {
     let path = path.iter().map(|s| Ident::new(s, span));
 
     match struct_name.to_string().as_str() {
-        "MessageEvent" | "MessageEventStub" if name == "m.room.redaction" => {
+        "MessageEvent" | "SyncMessageEvent" if name == "m.room.redaction" => {
             let redaction = if struct_name == "MessageEvent" {
                 quote! { RedactionEvent }
             } else {
-                quote! { RedactionEventStub }
+                quote! { SyncRedactionEvent }
             };
             quote! { ::ruma_events::room::redaction::#redaction }
         }
-        "ToDeviceEvent" | "StateEventStub" | "StrippedStateEventStub" | "MessageEventStub" => {
+        "ToDeviceEvent" | "SyncStateEvent" | "StrippedStateEvent" | "SyncMessageEvent" => {
             let content = format_ident!("{}EventContent", event);
             quote! { ::ruma_events::#struct_name<::ruma_events::#( #path )::*::#content> }
         }
@@ -523,10 +523,10 @@ mod kw {
 // If the variants of this enum change `to_event_path` needs to be updated as well.
 enum EventKindVariation {
     Full,
-    Stub,
+    Sync,
     Stripped,
     Redacted,
-    RedactedStub,
+    RedactedSync,
     RedactedStripped,
 }
 
@@ -554,19 +554,17 @@ impl EventKind {
         match (self, var) {
             // all `EventKind`s are valid event structs and event enums.
             (_, Full) => Some(format_ident!("{}Event", self.get_ident())),
-            (Self::Ephemeral(i), Stub) | (Self::Message(i), Stub) | (Self::State(i), Stub) => {
-                Some(format_ident!("{}EventStub", i))
+            (Self::Ephemeral(i), Sync) | (Self::Message(i), Sync) | (Self::State(i), Sync) => {
+                Some(format_ident!("Sync{}Event", i))
             }
-            (Self::State(i), Stripped) => Some(format_ident!("Stripped{}EventStub", i)),
+            (Self::State(i), Stripped) => Some(format_ident!("Stripped{}Event", i)),
             (Self::Message(i), Redacted) | (Self::State(i), Redacted) => {
                 Some(format_ident!("Redacted{}Event", i))
             }
-            (Self::Message(i), RedactedStub) | (Self::State(i), RedactedStub) => {
-                Some(format_ident!("Redacted{}EventStub", i))
-            }
-            (Self::State(i), RedactedStripped) => {
-                Some(format_ident!("RedactedStripped{}EventStub", i))
+            (Self::Message(i), RedactedSync) | (Self::State(i), RedactedSync) => {
+                Some(format_ident!("RedactedSync{}Event", i))
             }
+            (Self::State(i), RedactedStripped) => Some(format_ident!("RedactedStripped{}Event", i)),
             _ => None,
         }
     }

ruma-events/src/enums.rs

@@ -117,18 +117,18 @@ pub enum AnyRoomEvent {
     RedactedState(AnyRedactedStateEvent),
 }
 
-/// Any room event stub (room event without a `room_id`, as returned in `/sync` responses)
+/// Any sync room event (room event without a `room_id`, as returned in `/sync` responses)
 #[derive(Clone, Debug, Serialize)]
 #[serde(untagged)]
-pub enum AnyRoomEventStub {
-    /// Any message event stub
-    Message(AnyMessageEventStub),
-    /// Any state event stub
-    State(AnyStateEventStub),
-    /// Any message event stub that has been redacted.
-    RedactedMessage(AnyRedactedMessageEventStub),
-    /// Any state event stub that has been redacted.
-    RedactedState(AnyRedactedStateEventStub),
+pub enum AnySyncRoomEvent {
+    /// Any sync message event
+    Message(AnySyncMessageEvent),
+    /// Any sync state event
+    State(AnySyncStateEvent),
+    /// Any sync message event that has been redacted.
+    RedactedMessage(AnyRedactedSyncMessageEvent),
+    /// Any sync state event that has been redacted.
+    RedactedState(AnyRedactedSyncStateEvent),
 }
 
 // FIXME `#[serde(untagged)]` deserialization fails for these enums which
@@ -192,7 +192,7 @@ impl<'de> de::Deserialize<'de> for AnyRoomEvent {
     }
 }
 
-impl<'de> de::Deserialize<'de> for AnyRoomEventStub {
+impl<'de> de::Deserialize<'de> for AnySyncRoomEvent {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: de::Deserializer<'de>,
@@ -203,16 +203,16 @@ impl<'de> de::Deserialize<'de> for AnyRoomEventStub {
         if state_key.is_some() {
             Ok(match unsigned {
                 Some(unsigned) if unsigned.redacted_because.is_some() => {
-                    AnyRoomEventStub::RedactedState(from_raw_json_value(&json)?)
+                    AnySyncRoomEvent::RedactedState(from_raw_json_value(&json)?)
                 }
-                _ => AnyRoomEventStub::State(from_raw_json_value(&json)?),
+                _ => AnySyncRoomEvent::State(from_raw_json_value(&json)?),
             })
         } else {
             Ok(match unsigned {
                 Some(unsigned) if unsigned.redacted_because.is_some() => {
-                    AnyRoomEventStub::RedactedMessage(from_raw_json_value(&json)?)
+                    AnySyncRoomEvent::RedactedMessage(from_raw_json_value(&json)?)
                 }
-                _ => AnyRoomEventStub::Message(from_raw_json_value(&json)?),
+                _ => AnySyncRoomEvent::Message(from_raw_json_value(&json)?),
             })
         }
     }

ruma-events/src/event_kinds.rs

@@ -27,7 +27,7 @@ pub struct EphemeralRoomEvent<C: EphemeralRoomEventContent> {
 
 /// An ephemeral room event without a `room_id`.
 #[derive(Clone, Debug, Event)]
-pub struct EphemeralRoomEventStub<C: EphemeralRoomEventContent> {
+pub struct SyncEphemeralRoomEvent<C: EphemeralRoomEventContent> {
     /// Data specific to the event type.
     pub content: C,
 }
@@ -56,7 +56,7 @@ pub struct MessageEvent<C: MessageEventContent> {
 
 /// A message event without a `room_id`.
 #[derive(Clone, Debug, Event)]
-pub struct MessageEventStub<C: MessageEventContent> {
+pub struct SyncMessageEvent<C: MessageEventContent> {
     /// Data specific to the event type.
     pub content: C,
 
@@ -97,7 +97,7 @@ pub struct RedactedMessageEvent<C: RedactedMessageEventContent> {
 
 /// A redacted message event without a `room_id`.
 #[derive(Clone, Debug, Event)]
-pub struct RedactedMessageEventStub<C: RedactedMessageEventContent> {
+pub struct RedactedSyncMessageEvent<C: RedactedMessageEventContent> {
     /// Data specific to the event type.
     // #[serde(default, skip_serializing_if = "is_zst")]
     pub content: C,
@@ -148,7 +148,7 @@ pub struct StateEvent<C: StateEventContent> {
 
 /// A state event without a `room_id`.
 #[derive(Clone, Debug, Event)]
-pub struct StateEventStub<C: StateEventContent> {
+pub struct SyncStateEvent<C: StateEventContent> {
     /// Data specific to the event type.
     pub content: C,
 
@@ -177,7 +177,7 @@ pub struct StateEventStub<C: StateEventContent> {
 /// A stripped-down state event, used for previews of rooms the user has been
 /// invited to.
 #[derive(Clone, Debug, Event)]
-pub struct StrippedStateEventStub<C: StateEventContent> {
+pub struct StrippedStateEvent<C: StateEventContent> {
     /// Data specific to the event type.
     pub content: C,
 
@@ -221,7 +221,7 @@ pub struct RedactedStateEvent<C: RedactedStateEventContent> {
 
 /// A redacted state event without a `room_id`.
 #[derive(Clone, Debug, Event)]
-pub struct RedactedStateEventStub<C: RedactedStateEventContent> {
+pub struct RedactedSyncStateEvent<C: RedactedStateEventContent> {
     /// Data specific to the event type.
     // #[serde(default, skip_serializing_if = "is_zst")]
     pub content: C,
@@ -247,7 +247,7 @@ pub struct RedactedStateEventStub<C: RedactedStateEventContent> {
 
 /// A stripped-down redacted state event.
 #[derive(Clone, Debug, Event)]
-pub struct RedactedStrippedStateEventStub<C: RedactedStateEventContent> {
+pub struct RedactedStrippedStateEvent<C: RedactedStateEventContent> {
     /// Data specific to the event type.
     pub content: C,
 

ruma-events/src/lib.rs

@@ -165,17 +165,17 @@ pub use self::{
     algorithm::Algorithm,
     enums::{
         AnyBasicEvent, AnyBasicEventContent, AnyEphemeralRoomEvent, AnyEphemeralRoomEventContent,
-        AnyEphemeralRoomEventStub, AnyEvent, AnyMessageEvent, AnyMessageEventContent,
-        AnyMessageEventStub, AnyRedactedMessageEvent, AnyRedactedMessageEventStub,
-        AnyRedactedStateEvent, AnyRedactedStateEventStub, AnyRedactedStrippedStateEventStub,
-        AnyRoomEvent, AnyRoomEventStub, AnyStateEvent, AnyStateEventContent, AnyStateEventStub,
-        AnyStrippedStateEventStub, AnyToDeviceEvent, AnyToDeviceEventContent,
+        AnyEvent, AnyMessageEvent, AnyMessageEventContent, AnyRedactedMessageEvent,
+        AnyRedactedStateEvent, AnyRedactedStrippedStateEvent, AnyRedactedSyncMessageEvent,
+        AnyRedactedSyncStateEvent, AnyRoomEvent, AnyStateEvent, AnyStateEventContent,
+        AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncMessageEvent, AnySyncRoomEvent,
+        AnySyncStateEvent, AnyToDeviceEvent, AnyToDeviceEventContent,
     },
     error::{FromStrError, InvalidInput},
     event_kinds::{
-        BasicEvent, EphemeralRoomEvent, EphemeralRoomEventStub, MessageEvent, MessageEventStub,
-        RedactedMessageEvent, RedactedMessageEventStub, RedactedStateEvent, RedactedStateEventStub,
-        RedactedStrippedStateEventStub, StateEvent, StateEventStub, StrippedStateEventStub,
+        BasicEvent, EphemeralRoomEvent, MessageEvent, RedactedMessageEvent, RedactedStateEvent,
+        RedactedStrippedStateEvent, RedactedSyncMessageEvent, RedactedSyncStateEvent, StateEvent,
+        StrippedStateEvent, SyncEphemeralRoomEvent, SyncMessageEvent, SyncStateEvent,
         ToDeviceEvent,
     },
     event_type::EventType,