chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename *EventStub -> Sync*Event

Browse Source
This commit is contained in:
Devin R 2020-07-14 13:44:39 -04:00
parent 7b909efccc
commit 204a90ac43
12 changed files with 123 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ruma-client-api/src/r0/sync/sync_events.rs
View File

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

56
ruma-events-macros/src/event_enum.rs
View File

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

30
ruma-events/src/enums.rs
View File

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

14
ruma-events/src/event_kinds.rs
View File

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

16
ruma-events/src/lib.rs
View File

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

6
ruma-events/src/room/member.rs
View File

@ -7,7 +7,7 @@ use ruma_identifiers::UserId;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use strum::{Display, EnumString}; use strum::{Display, EnumString};
use crate::{StateEvent, StateEventStub, StrippedStateEventStub}; use crate::{StateEvent, StrippedStateEvent, SyncStateEvent};
/// The current membership state of a user in the room. /// The current membership state of a user in the room.
/// ///
@ -222,7 +222,7 @@ impl MemberEvent {
} }
} }
impl StateEventStub<MemberEventContent> { impl SyncStateEvent<MemberEventContent> {
/// Helper function for membership change. Check [the specification][spec] for details. /// Helper function for membership change. Check [the specification][spec] for details.
/// ///
/// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member /// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
@ -231,7 +231,7 @@ impl StateEventStub<MemberEventContent> {
} }
} }
impl StrippedStateEventStub<MemberEventContent> { impl StrippedStateEvent<MemberEventContent> {
/// Helper function for membership change. Check [the specification][spec] for details. /// Helper function for membership change. Check [the specification][spec] for details.
/// ///
/// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member /// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member

2
ruma-events/src/room/redaction.rs
View File

@ -38,7 +38,7 @@ pub struct RedactionEvent {
/// Redaction event without a `room_id`. /// Redaction event without a `room_id`.
#[derive(Clone, Debug, Event)] #[derive(Clone, Debug, Event)]
pub struct RedactionEventStub { pub struct SyncRedactionEvent {
/// Data specific to the event type. /// Data specific to the event type.
pub content: RedactionEventContent, pub content: RedactionEventContent,

18
ruma-events/tests/custom.rs
View File

@ -5,9 +5,9 @@ use std::{
use matches::assert_matches; use matches::assert_matches;
use ruma_events::{ use ruma_events::{
custom::CustomEventContent, AnyMessageEvent, AnyMessageEventStub, AnyRoomEventStub, custom::CustomEventContent, AnyMessageEvent, AnyStateEvent, AnyStateEventContent,
AnyStateEvent, AnyStateEventContent, EventJson, MessageEvent, MessageEventStub, StateEvent, AnySyncMessageEvent, AnySyncRoomEvent, EventJson, MessageEvent, StateEvent, SyncMessageEvent,
StateEventStub, UnsignedData, SyncStateEvent, UnsignedData,
}; };
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
use serde_json::{ use serde_json::{
@ -157,7 +157,7 @@ fn deserialize_custom_state_event() {
} }
#[test] #[test]
fn deserialize_custom_state_stub_event() { fn deserialize_custom_state_sync_event() {
let json_data = custom_state_event(); let json_data = custom_state_event();
let expected_content = json!({ let expected_content = json!({
@ -169,9 +169,9 @@ fn deserialize_custom_state_stub_event() {
}); });
assert_matches!( assert_matches!(
from_json_value::<StateEventStub<AnyStateEventContent>>(json_data) from_json_value::<SyncStateEvent<AnyStateEventContent>>(json_data)
.unwrap(), .unwrap(),
StateEventStub { SyncStateEvent {
content: AnyStateEventContent::Custom(CustomEventContent { content: AnyStateEventContent::Custom(CustomEventContent {
json, event_type, json, event_type,
}), }),
@ -191,7 +191,7 @@ fn deserialize_custom_state_stub_event() {
} }
#[test] #[test]
fn deserialize_custom_message_stub_event() { fn deserialize_custom_message_sync_event() {
let json_data = json!({ let json_data = json!({
"content": { "content": {
"m.relates_to": { "m.relates_to": {
@ -219,9 +219,9 @@ fn deserialize_custom_message_stub_event() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data) from_json_value::<AnySyncRoomEvent>(json_data)
.unwrap(), .unwrap(),
AnyRoomEventStub::Message(AnyMessageEventStub::Custom(MessageEventStub { AnySyncRoomEvent::Message(AnySyncMessageEvent::Custom(SyncMessageEvent {
content: CustomEventContent { content: CustomEventContent {
json, event_type, json, event_type,
}, },

38
ruma-events/tests/enums.rs
View File

@ -10,9 +10,9 @@ use ruma_events::{
message::{MessageEventContent, TextMessageEventContent}, message::{MessageEventContent, TextMessageEventContent},
power_levels::PowerLevelsEventContent, power_levels::PowerLevelsEventContent,
}, },
AnyEvent, AnyMessageEvent, AnyMessageEventStub, AnyRoomEvent, AnyRoomEventStub, AnyStateEvent, AnyEvent, AnyMessageEvent, AnyRoomEvent, AnyStateEvent, AnyStateEventContent,
AnyStateEventContent, AnyStateEventStub, MessageEvent, MessageEventStub, StateEvent, AnySyncMessageEvent, AnySyncRoomEvent, AnySyncStateEvent, MessageEvent, StateEvent,
StateEventStub, SyncMessageEvent, SyncStateEvent,
}; };
fn message_event() -> JsonValue { fn message_event() -> JsonValue {
@ -34,7 +34,7 @@ fn message_event() -> JsonValue {
}) })
} }
fn message_event_stub() -> JsonValue { fn message_event_sync() -> JsonValue {
json!({ json!({
"content": { "content": {
"body": "baba", "body": "baba",
@ -69,7 +69,7 @@ fn aliases_event() -> JsonValue {
}) })
} }
fn aliases_event_stub() -> JsonValue { fn aliases_event_sync() -> JsonValue {
json!({ json!({
"content": { "content": {
"aliases": ["#somewhere:localhost"] "aliases": ["#somewhere:localhost"]
@ -86,7 +86,7 @@ fn aliases_event_stub() -> JsonValue {
} }
#[test] #[test]
fn power_event_stub_deserialization() { fn power_event_sync_deserialization() {
let json_data = json!({ let json_data = json!({
"content": { "content": {
"ban": 50, "ban": 50,
@ -118,9 +118,9 @@ fn power_event_stub_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data), from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnyRoomEventStub::State( Ok(AnySyncRoomEvent::State(
AnyStateEventStub::RoomPowerLevels(StateEventStub { AnySyncStateEvent::RoomPowerLevels(SyncStateEvent {
content: PowerLevelsEventContent { content: PowerLevelsEventContent {
ban, .. ban, ..
}, },
@ -132,13 +132,13 @@ fn power_event_stub_deserialization() {
} }
#[test] #[test]
fn message_event_stub_deserialization() { fn message_event_sync_deserialization() {
let json_data = message_event_stub(); let json_data = message_event_sync();
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data), from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnyRoomEventStub::Message( Ok(AnySyncRoomEvent::Message(
AnyMessageEventStub::RoomMessage(MessageEventStub { AnySyncMessageEvent::RoomMessage(SyncMessageEvent {
content: MessageEventContent::Text(TextMessageEventContent { content: MessageEventContent::Text(TextMessageEventContent {
body, body,
formatted: Some(formatted), formatted: Some(formatted),
@ -152,13 +152,13 @@ fn message_event_stub_deserialization() {
} }
#[test] #[test]
fn aliases_event_stub_deserialization() { fn aliases_event_sync_deserialization() {
let json_data = aliases_event_stub(); let json_data = aliases_event_sync();
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEventStub>(json_data), from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnyRoomEventStub::State( Ok(AnySyncRoomEvent::State(
AnyStateEventStub::RoomAliases(StateEventStub { AnySyncStateEvent::RoomAliases(SyncStateEvent {
content: AliasesEventContent { content: AliasesEventContent {
aliases, aliases,
}, },

30
ruma-events/tests/redacted.rs
View File

@ -12,9 +12,9 @@ use ruma_events::{
message::RedactedMessageEventContent, message::RedactedMessageEventContent,
redaction::{RedactionEvent, RedactionEventContent}, redaction::{RedactionEvent, RedactionEventContent},
}, },
AnyRedactedMessageEvent, AnyRedactedMessageEventStub, AnyRedactedStateEventStub, AnyRoomEvent, AnyRedactedMessageEvent, AnyRedactedSyncMessageEvent, AnyRedactedSyncStateEvent, AnyRoomEvent,
AnyRoomEventStub, EventJson, RedactedMessageEvent, RedactedMessageEventStub, AnySyncRoomEvent, EventJson, RedactedMessageEvent, RedactedSyncMessageEvent,
RedactedStateEventStub, UnsignedData, RedactedSyncStateEvent, UnsignedData,
}; };
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
use serde_json::{from_value as from_json_value, json, to_value as to_json_value}; use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
@ -25,7 +25,7 @@ fn is_zst<T>(_: &T) -> bool {
#[test] #[test]
fn redacted_message_event_serialize() { fn redacted_message_event_serialize() {
let redacted = RedactedMessageEventStub { let redacted = RedactedSyncMessageEvent {
content: RedactedMessageEventContent, content: RedactedMessageEventContent,
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(), event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UNIX_EPOCH + Duration::from_millis(1), origin_server_ts: UNIX_EPOCH + Duration::from_millis(1),
@ -46,7 +46,7 @@ fn redacted_message_event_serialize() {
#[test] #[test]
fn redacted_aliases_event_serialize() { fn redacted_aliases_event_serialize() {
let redacted = RedactedStateEventStub { let redacted = RedactedSyncStateEvent {
content: RedactedAliasesEventContent { aliases: None }, content: RedactedAliasesEventContent { aliases: None },
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(), event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
state_key: "".to_string(), state_key: "".to_string(),
@ -108,9 +108,9 @@ fn redacted_deserialize_any_room() {
} }
#[test] #[test]
fn redacted_deserialize_any_room_stub() { fn redacted_deserialize_any_room_sync() {
let mut unsigned = UnsignedData::default(); let mut unsigned = UnsignedData::default();
// The presence of `redacted_because` triggers the event enum (AnyRoomEventStub in this case) // The presence of `redacted_because` triggers the event enum (AnySyncRoomEvent in this case)
// to return early with `RedactedContent` instead of failing to deserialize according // to return early with `RedactedContent` instead of failing to deserialize according
// to the event type string. // to the event type string.
unsigned.redacted_because = Some(EventJson::from(RedactionEvent { unsigned.redacted_because = Some(EventJson::from(RedactionEvent {
@ -134,11 +134,11 @@ fn redacted_deserialize_any_room_stub() {
let actual = to_json_value(&redacted).unwrap(); let actual = to_json_value(&redacted).unwrap();
assert_matches!( assert_matches!(
from_json_value::<EventJson<AnyRoomEventStub>>(actual) from_json_value::<EventJson<AnySyncRoomEvent>>(actual)
.unwrap() .unwrap()
.deserialize() .deserialize()
.unwrap(), .unwrap(),
AnyRoomEventStub::RedactedMessage(AnyRedactedMessageEventStub::RoomMessage(RedactedMessageEventStub { AnySyncRoomEvent::RedactedMessage(AnyRedactedSyncMessageEvent::RoomMessage(RedactedSyncMessageEvent {
event_id, content, .. event_id, content, ..
})) if event_id == EventId::try_from("$h29iv0s8:example.com").unwrap() })) if event_id == EventId::try_from("$h29iv0s8:example.com").unwrap()
&& is_zst(&content) && is_zst(&content)
@ -171,11 +171,11 @@ fn redacted_state_event_deserialize() {
}); });
assert_matches!( assert_matches!(
from_json_value::<EventJson<AnyRoomEventStub>>(redacted) from_json_value::<EventJson<AnySyncRoomEvent>>(redacted)
.unwrap() .unwrap()
.deserialize() .deserialize()
.unwrap(), .unwrap(),
AnyRoomEventStub::RedactedState(AnyRedactedStateEventStub::RoomCreate(RedactedStateEventStub { AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomCreate(RedactedSyncStateEvent {
content: RedactedCreateEventContent { content: RedactedCreateEventContent {
creator, creator,
}, },
@ -210,11 +210,11 @@ fn redacted_custom_event_serialize() {
}); });
assert_matches!( assert_matches!(
from_json_value::<EventJson<AnyRoomEventStub>>(redacted.clone()) from_json_value::<EventJson<AnySyncRoomEvent>>(redacted.clone())
.unwrap() .unwrap()
.deserialize() .deserialize()
.unwrap(), .unwrap(),
AnyRoomEventStub::RedactedState(AnyRedactedStateEventStub::Custom(RedactedStateEventStub { AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::Custom(RedactedSyncStateEvent {
content: RedactedCustomEventContent { content: RedactedCustomEventContent {
event_type, event_type,
}, },
@ -225,7 +225,7 @@ fn redacted_custom_event_serialize() {
&& event_type == "m.made.up" && event_type == "m.made.up"
); );
let x = from_json_value::<EventJson<crate::AnyRedactedStateEventStub>>(redacted) let x = from_json_value::<EventJson<crate::AnyRedactedSyncStateEvent>>(redacted)
.unwrap() .unwrap()
.deserialize() .deserialize()
.unwrap(); .unwrap();
@ -245,7 +245,7 @@ fn redacted_custom_event_deserialize() {
unsigned: UnsignedData::default(), unsigned: UnsignedData::default(),
})); }));
let redacted = RedactedStateEventStub { let redacted = RedactedSyncStateEvent {
content: RedactedCustomEventContent { event_type: "m.made.up".to_string() }, content: RedactedCustomEventContent { event_type: "m.made.up".to_string() },
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(), event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
sender: UserId::try_from("@carl:example.com").unwrap(), sender: UserId::try_from("@carl:example.com").unwrap(),

8
ruma-events/tests/state_event.rs
View File

@ -7,7 +7,7 @@ use js_int::UInt;
use matches::assert_matches; use matches::assert_matches;
use ruma_events::{ use ruma_events::{
room::{aliases::AliasesEventContent, avatar::AvatarEventContent, ImageInfo, ThumbnailInfo}, room::{aliases::AliasesEventContent, avatar::AvatarEventContent, ImageInfo, ThumbnailInfo},
AnyRoomEvent, AnyStateEvent, AnyStateEventContent, EventJson, StateEvent, StateEventStub, AnyRoomEvent, AnyStateEvent, AnyStateEventContent, EventJson, StateEvent, SyncStateEvent,
UnsignedData, UnsignedData,
}; };
use ruma_identifiers::{EventId, RoomAliasId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomAliasId, RoomId, UserId};
@ -132,13 +132,13 @@ fn deserialize_aliases_with_prev_content() {
} }
#[test] #[test]
fn deserialize_aliases_stub_with_room_id() { fn deserialize_aliases_sync_with_room_id() {
let json_data = aliases_event_with_prev_content(); let json_data = aliases_event_with_prev_content();
assert_matches!( assert_matches!(
from_json_value::<StateEventStub<AnyStateEventContent>>(json_data) from_json_value::<SyncStateEvent<AnyStateEventContent>>(json_data)
.unwrap(), .unwrap(),
StateEventStub { SyncStateEvent {
content: AnyStateEventContent::RoomAliases(content), content: AnyStateEventContent::RoomAliases(content),
event_id, event_id,
origin_server_ts, origin_server_ts,

18
ruma-events/tests/stripped.rs
View File

@ -3,14 +3,14 @@ use std::convert::TryFrom;
use js_int::uint; use js_int::uint;
use ruma_events::{ use ruma_events::{
room::{join_rules::JoinRule, topic::TopicEventContent}, room::{join_rules::JoinRule, topic::TopicEventContent},
AnyStateEventContent, AnyStrippedStateEventStub, StrippedStateEventStub, AnyStateEventContent, AnyStrippedStateEvent, StrippedStateEvent,
}; };
use ruma_identifiers::UserId; use ruma_identifiers::UserId;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value}; use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
#[test] #[test]
fn serialize_stripped_state_event_any_content() { fn serialize_stripped_state_event_any_content() {
let event = StrippedStateEventStub { let event = StrippedStateEvent {
content: AnyStateEventContent::RoomTopic(TopicEventContent { content: AnyStateEventContent::RoomTopic(TopicEventContent {
topic: "Testing room".to_string(), topic: "Testing room".to_string(),
}), }),
@ -32,7 +32,7 @@ fn serialize_stripped_state_event_any_content() {
#[test] #[test]
fn serialize_stripped_state_event_any_event() { fn serialize_stripped_state_event_any_event() {
let event = AnyStrippedStateEventStub::RoomTopic(StrippedStateEventStub { let event = AnyStrippedStateEvent::RoomTopic(StrippedStateEvent {
content: TopicEventContent { topic: "Testing room".to_string() }, content: TopicEventContent { topic: "Testing room".to_string() },
state_key: "".to_string(), state_key: "".to_string(),
sender: UserId::try_from("@example:localhost").unwrap(), sender: UserId::try_from("@example:localhost").unwrap(),
@ -95,9 +95,9 @@ fn deserialize_stripped_state_events() {
} }
}); });
let event = from_json_value::<AnyStrippedStateEventStub>(name_event).unwrap(); let event = from_json_value::<AnyStrippedStateEvent>(name_event).unwrap();
match event { match event {
AnyStrippedStateEventStub::RoomName(event) => { AnyStrippedStateEvent::RoomName(event) => {
assert_eq!(event.content.name(), Some("Ruma")); assert_eq!(event.content.name(), Some("Ruma"));
assert_eq!(event.state_key, ""); assert_eq!(event.state_key, "");
assert_eq!(event.sender.to_string(), "@example:localhost"); assert_eq!(event.sender.to_string(), "@example:localhost");
@ -105,9 +105,9 @@ fn deserialize_stripped_state_events() {
_ => unreachable!(), _ => unreachable!(),
} }
let event = from_json_value::<AnyStrippedStateEventStub>(join_rules_event).unwrap(); let event = from_json_value::<AnyStrippedStateEvent>(join_rules_event).unwrap();
match event { match event {
AnyStrippedStateEventStub::RoomJoinRules(event) => { AnyStrippedStateEvent::RoomJoinRules(event) => {
assert_eq!(event.content.join_rule, JoinRule::Public); assert_eq!(event.content.join_rule, JoinRule::Public);
assert_eq!(event.state_key, ""); assert_eq!(event.state_key, "");
assert_eq!(event.sender.to_string(), "@example:localhost"); assert_eq!(event.sender.to_string(), "@example:localhost");
@ -115,9 +115,9 @@ fn deserialize_stripped_state_events() {
_ => unreachable!(), _ => unreachable!(),
} }
let event = from_json_value::<AnyStrippedStateEventStub>(avatar_event).unwrap(); let event = from_json_value::<AnyStrippedStateEvent>(avatar_event).unwrap();
match event { match event {
AnyStrippedStateEventStub::RoomAvatar(event) => { AnyStrippedStateEvent::RoomAvatar(event) => {
let image_info = event.content.info.unwrap(); let image_info = event.content.info.unwrap();
assert_eq!(image_info.height.unwrap(), uint!(128)); assert_eq!(image_info.height.unwrap(), uint!(128));