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

events: Rework the event enum hierarchy

Browse Source
This commit is contained in:
Jonas Platte 2022-04-04 14:19:52 +02:00
parent ca7af393d6
commit 7de3b4b649
No known key found for this signature in database
GPG Key ID: BBA95679259D342F
35 changed files with 617 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/ruma-client-api/src/context/get_context.rs
View File

@ -8,7 +8,7 @@ pub mod v3 {
use js_int::{uint, UInt}; use js_int::{uint, UInt};
use ruma_common::{ use ruma_common::{
api::ruma_api, api::ruma_api,
events::{AnyOriginalStateEvent, AnyRoomEvent}, events::{AnyRoomEvent, AnyStateEvent},
serde::Raw, serde::Raw,
EventId, RoomId, EventId, RoomId,
}; };
@ -79,7 +79,7 @@ pub mod v3 {
/// The state of the room at the last event returned. /// The state of the room at the last event returned.
#[serde(default, skip_serializing_if = "Vec::is_empty")] #[serde(default, skip_serializing_if = "Vec::is_empty")]
pub state: Vec<Raw<AnyOriginalStateEvent>>, pub state: Vec<Raw<AnyStateEvent>>,
} }
error: crate::Error error: crate::Error

4
crates/ruma-client-api/src/message/get_message_events.rs
View File

@ -8,7 +8,7 @@ pub mod v3 {
use js_int::{uint, UInt}; use js_int::{uint, UInt};
use ruma_common::{ use ruma_common::{
api::ruma_api, api::ruma_api,
events::{AnyOriginalStateEvent, AnyRoomEvent}, events::{AnyRoomEvent, AnyStateEvent},
serde::Raw, serde::Raw,
RoomId, RoomId,
}; };
@ -96,7 +96,7 @@ pub mod v3 {
/// A list of state events relevant to showing the `chunk`. /// A list of state events relevant to showing the `chunk`.
#[serde(default, skip_serializing_if = "Vec::is_empty")] #[serde(default, skip_serializing_if = "Vec::is_empty")]
pub state: Vec<Raw<AnyOriginalStateEvent>>, pub state: Vec<Raw<AnyStateEvent>>,
} }
error: crate::Error error: crate::Error

4
crates/ruma-client-api/src/search/search_events.rs
View File

@ -10,7 +10,7 @@ pub mod v3 {
use js_int::{uint, UInt}; use js_int::{uint, UInt};
use ruma_common::{ use ruma_common::{
api::ruma_api, api::ruma_api,
events::{AnyOriginalStateEvent, AnyRoomEvent}, events::{AnyRoomEvent, AnyStateEvent},
serde::{Incoming, Raw, StringEnum}, serde::{Incoming, Raw, StringEnum},
EventId, MxcUri, RoomId, UserId, EventId, MxcUri, RoomId, UserId,
}; };
@ -385,7 +385,7 @@ pub mod v3 {
/// ///
/// This is included if the request had the `include_state` key set with a value of `true`. /// This is included if the request had the `include_state` key set with a value of `true`.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")] #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub state: BTreeMap<Box<RoomId>, Vec<Raw<AnyOriginalStateEvent>>>, pub state: BTreeMap<Box<RoomId>, Vec<Raw<AnyStateEvent>>>,
/// List of words which should be highlighted, useful for stemming which may /// List of words which should be highlighted, useful for stemming which may
/// change the query terms. /// change the query terms.

6
crates/ruma-client-api/src/state/get_state_events.rs
View File

@ -5,7 +5,7 @@ pub mod v3 {
//! //!
//! [spec]: https://spec.matrix.org/v1.2/client-server-api/#get_matrixclientv3roomsroomidstate //! [spec]: https://spec.matrix.org/v1.2/client-server-api/#get_matrixclientv3roomsroomidstate
use ruma_common::{api::ruma_api, events::AnyOriginalStateEvent, serde::Raw, RoomId}; use ruma_common::{api::ruma_api, events::AnyStateEvent, serde::Raw, RoomId};
ruma_api! { ruma_api! {
metadata: { metadata: {
@ -32,7 +32,7 @@ pub mod v3 {
/// If the user has left the room then this will be the state of the room when they left as /// If the user has left the room then this will be the state of the room when they left as
/// a list of events. /// a list of events.
#[ruma_api(body)] #[ruma_api(body)]
pub room_state: Vec<Raw<AnyOriginalStateEvent>>, pub room_state: Vec<Raw<AnyStateEvent>>,
} }
error: crate::Error error: crate::Error
@ -47,7 +47,7 @@ pub mod v3 {
impl Response { impl Response {
/// Creates a new `Response` with the given room state. /// Creates a new `Response` with the given room state.
pub fn new(room_state: Vec<Raw<AnyOriginalStateEvent>>) -> Self { pub fn new(room_state: Vec<Raw<AnyStateEvent>>) -> Self {
Self { room_state } Self { room_state }
} }
} }

8
crates/ruma-client-api/src/sync/sync_events.rs
View File

@ -11,9 +11,9 @@ pub mod v3 {
use ruma_common::{ use ruma_common::{
api::ruma_api, api::ruma_api,
events::{ events::{
presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyOriginalSyncStateEvent, presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent,
AnyRoomAccountDataEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncRoomEvent, AnySyncStateEvent,
AnySyncRoomEvent, AnyToDeviceEvent, AnyToDeviceEvent,
}, },
presence::PresenceState, presence::PresenceState,
serde::{Incoming, Raw}, serde::{Incoming, Raw},
@ -384,7 +384,7 @@ pub mod v3 {
pub struct State { pub struct State {
/// A list of state events. /// A list of state events.
#[serde(default, skip_serializing_if = "Vec::is_empty")] #[serde(default, skip_serializing_if = "Vec::is_empty")]
pub events: Vec<Raw<AnyOriginalSyncStateEvent>>, pub events: Vec<Raw<AnySyncStateEvent>>,
} }
impl State { impl State {

6
crates/ruma-common/benches/event_deserialize.rs
View File

@ -11,7 +11,7 @@
use criterion::{criterion_group, criterion_main, Criterion}; use criterion::{criterion_group, criterion_main, Criterion};
use ruma_common::{ use ruma_common::{
events::{ events::{
room::power_levels::RoomPowerLevelsEventContent, AnyOriginalStateEvent, AnyRoomEvent, room::power_levels::RoomPowerLevelsEventContent, AnyRoomEvent, AnyStateEvent,
OriginalStateEvent, OriginalStateEvent,
}, },
serde::Raw, serde::Raw,
@ -66,9 +66,9 @@ fn deserialize_any_room_event(c: &mut Criterion) {
fn deserialize_any_state_event(c: &mut Criterion) { fn deserialize_any_state_event(c: &mut Criterion) {
let json_data = power_levels(); let json_data = power_levels();
c.bench_function("deserialize to `AnyOriginalStateEvent`", |b| { c.bench_function("deserialize to `AnyStateEvent`", |b| {
b.iter(|| { b.iter(|| {
let _ = serde_json::from_value::<AnyOriginalStateEvent>(json_data.clone()).unwrap(); let _ = serde_json::from_value::<AnyStateEvent>(json_data.clone()).unwrap();
}) })
}); });
} }

8
crates/ruma-common/src/events.rs
View File

@ -102,7 +102,7 @@
use serde::{de::IgnoredAny, Deserialize, Serializer}; use serde::{de::IgnoredAny, Deserialize, Serializer};
use self::room::redaction::OriginalSyncRoomRedactionEvent; use self::room::redaction::SyncRoomRedactionEvent;
use crate::{EventEncryptionAlgorithm, RoomVersionId}; use crate::{EventEncryptionAlgorithm, RoomVersionId};
// Needs to be public for trybuild tests // Needs to be public for trybuild tests
@ -180,11 +180,7 @@ pub trait Redact {
/// ///
/// A small number of events have room-version specific redaction behavior, so a version has to /// A small number of events have room-version specific redaction behavior, so a version has to
/// be specified. /// be specified.
fn redact( fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted;
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> Self::Redacted;
} }
/// Trait to define the behavior of redact an event's content object. /// Trait to define the behavior of redact an event's content object.

4
crates/ruma-common/src/events/content.rs
View File

@ -39,8 +39,8 @@ where
/// The base trait that all redacted event content types implement. /// The base trait that all redacted event content types implement.
/// ///
/// This trait's associated functions and methods should not be used to build /// This trait's associated functions and methods should not be used to build
/// redacted events, prefer the `redact` method on `AnyOriginalStateEvent` and /// redacted events, prefer the `redact` method on `AnyStateEvent` and
/// `AnyOriginalMessageLikeEvent` and their "sync" and "stripped" counterparts. /// `AnyMessageLikeEvent` and their "sync" and "stripped" counterparts.
/// The `RedactedEventContent` trait is an implementation detail, ruma makes no /// The `RedactedEventContent` trait is an implementation detail, ruma makes no
/// API guarantees. /// API guarantees.
pub trait RedactedEventContent: EventContent { pub trait RedactedEventContent: EventContent {

155
crates/ruma-common/src/events/enums.rs
View File

@ -4,8 +4,8 @@ use serde_json::value::RawValue as RawJsonValue;
use super::{ use super::{
key, key,
room::{encrypted, redaction::OriginalSyncRoomRedactionEvent}, room::{encrypted, redaction::SyncRoomRedactionEvent},
Redact, UnsignedDeHelper, Redact,
}; };
use crate::{ use crate::{
serde::from_raw_json_value, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId, serde::from_raw_json_value, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
@ -129,10 +129,8 @@ macro_rules! room_ev_accessor {
#[doc = concat!("Returns this event's `", stringify!($field), "` field.")] #[doc = concat!("Returns this event's `", stringify!($field), "` field.")]
pub fn $field(&self) -> $ty { pub fn $field(&self) -> $ty {
match self { match self {
Self::OriginalMessageLike(ev) => ev.$field(), Self::MessageLike(ev) => ev.$field(),
Self::OriginalState(ev) => ev.$field(), Self::State(ev) => ev.$field(),
Self::RedactedMessageLike(ev) => ev.$field(),
Self::RedactedState(ev) => ev.$field(),
} }
} }
} }
@ -143,17 +141,11 @@ macro_rules! room_ev_accessor {
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)] #[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)] #[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnyRoomEvent { pub enum AnyRoomEvent {
/// Any message-like event (unredacted). /// Any message-like event.
OriginalMessageLike(AnyOriginalMessageLikeEvent), MessageLike(AnyMessageLikeEvent),
/// Any state event (unredacted). /// Any state event.
OriginalState(AnyOriginalStateEvent), State(AnyStateEvent),
/// Any message-like event that has been redacted.
RedactedMessageLike(AnyRedactedMessageLikeEvent),
/// Any state event that has been redacted.
RedactedState(AnyRedactedStateEvent),
} }
impl AnyRoomEvent { impl AnyRoomEvent {
@ -169,17 +161,11 @@ impl AnyRoomEvent {
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)] #[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)] #[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnySyncRoomEvent { pub enum AnySyncRoomEvent {
/// Any sync message-like event (unredacted). /// Any sync message-like event.
OriginalMessageLike(AnyOriginalSyncMessageLikeEvent), MessageLike(AnySyncMessageLikeEvent),
/// Any sync state event (unredacted). /// Any sync state event.
OriginalState(AnyOriginalSyncStateEvent), State(AnySyncStateEvent),
/// Any sync message-like event that has been redacted.
RedactedMessageLike(AnyRedactedSyncMessageLikeEvent),
/// Any sync state event that has been redacted.
RedactedState(AnyRedactedSyncStateEvent),
} }
impl AnySyncRoomEvent { impl AnySyncRoomEvent {
@ -190,14 +176,8 @@ impl AnySyncRoomEvent {
/// Converts `self` to an `AnyRoomEvent` by adding the given a room ID. /// Converts `self` to an `AnyRoomEvent` by adding the given a room ID.
pub fn into_full_event(self, room_id: Box<RoomId>) -> AnyRoomEvent { pub fn into_full_event(self, room_id: Box<RoomId>) -> AnyRoomEvent {
match self { match self {
Self::OriginalMessageLike(ev) => { Self::MessageLike(ev) => AnyRoomEvent::MessageLike(ev.into_full_event(room_id)),
AnyRoomEvent::OriginalMessageLike(ev.into_full_event(room_id)) Self::State(ev) => AnyRoomEvent::State(ev.into_full_event(room_id)),
}
Self::OriginalState(ev) => AnyRoomEvent::OriginalState(ev.into_full_event(room_id)),
Self::RedactedMessageLike(ev) => {
AnyRoomEvent::RedactedMessageLike(ev.into_full_event(room_id))
}
Self::RedactedState(ev) => AnyRoomEvent::RedactedState(ev.into_full_event(room_id)),
} }
} }
} }
@ -206,7 +186,6 @@ impl AnySyncRoomEvent {
#[allow(clippy::exhaustive_structs)] #[allow(clippy::exhaustive_structs)]
struct EventDeHelper { struct EventDeHelper {
pub state_key: Option<de::IgnoredAny>, pub state_key: Option<de::IgnoredAny>,
pub unsigned: Option<UnsignedDeHelper>,
} }
impl<'de> Deserialize<'de> for AnyRoomEvent { impl<'de> Deserialize<'de> for AnyRoomEvent {
@ -215,22 +194,12 @@ impl<'de> Deserialize<'de> for AnyRoomEvent {
D: de::Deserializer<'de>, D: de::Deserializer<'de>,
{ {
let json = Box::<RawJsonValue>::deserialize(deserializer)?; let json = Box::<RawJsonValue>::deserialize(deserializer)?;
let EventDeHelper { state_key, unsigned } = from_raw_json_value(&json)?; let EventDeHelper { state_key } = from_raw_json_value(&json)?;
if state_key.is_some() { if state_key.is_some() {
Ok(match unsigned { Ok(AnyRoomEvent::State(from_raw_json_value(&json)?))
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnyRoomEvent::OriginalState(from_raw_json_value(&json)?),
})
} else { } else {
Ok(match unsigned { Ok(AnyRoomEvent::MessageLike(from_raw_json_value(&json)?))
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEvent::RedactedMessageLike(from_raw_json_value(&json)?)
}
_ => AnyRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
})
} }
} }
} }
@ -241,108 +210,40 @@ impl<'de> Deserialize<'de> for AnySyncRoomEvent {
D: de::Deserializer<'de>, D: de::Deserializer<'de>,
{ {
let json = Box::<RawJsonValue>::deserialize(deserializer)?; let json = Box::<RawJsonValue>::deserialize(deserializer)?;
let EventDeHelper { state_key, unsigned } = from_raw_json_value(&json)?; let EventDeHelper { state_key } = from_raw_json_value(&json)?;
if state_key.is_some() { if state_key.is_some() {
Ok(match unsigned { Ok(AnySyncRoomEvent::State(from_raw_json_value(&json)?))
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnySyncRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnySyncRoomEvent::OriginalState(from_raw_json_value(&json)?),
})
} else { } else {
Ok(match unsigned { Ok(AnySyncRoomEvent::MessageLike(from_raw_json_value(&json)?))
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnySyncRoomEvent::RedactedMessageLike(from_raw_json_value(&json)?)
}
_ => AnySyncRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
})
} }
} }
} }
/// Any redacted room event.
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnyRedactedRoomEvent {
/// Any message-like event that has been redacted.
MessageLike(AnyRedactedMessageLikeEvent),
/// Any state event that has been redacted.
State(AnyRedactedStateEvent),
}
impl Redact for AnyRoomEvent { impl Redact for AnyRoomEvent {
type Redacted = AnyRedactedRoomEvent; type Redacted = Self;
/// Redacts `self`, referencing the given event in `unsigned.redacted_because`. /// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
/// ///
/// Does nothing for events that are already redacted. /// Does nothing for events that are already redacted.
fn redact( fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self {
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> Self::Redacted {
match self { match self {
Self::OriginalMessageLike(ev) => { Self::MessageLike(ev) => Self::MessageLike(ev.redact(redaction, version)),
AnyRedactedRoomEvent::MessageLike(ev.redact(redaction, version)) Self::State(ev) => Self::State(ev.redact(redaction, version)),
}
Self::OriginalState(ev) => AnyRedactedRoomEvent::State(ev.redact(redaction, version)),
Self::RedactedMessageLike(ev) => AnyRedactedRoomEvent::MessageLike(ev),
Self::RedactedState(ev) => AnyRedactedRoomEvent::State(ev),
} }
} }
} }
impl From<AnyRedactedRoomEvent> for AnyRoomEvent {
fn from(ev: AnyRedactedRoomEvent) -> Self {
match ev {
AnyRedactedRoomEvent::MessageLike(ev) => Self::RedactedMessageLike(ev),
AnyRedactedRoomEvent::State(ev) => Self::RedactedState(ev),
}
}
}
/// Any redacted sync room event (room event without a `room_id`, as returned in `/sync` responses)
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnyRedactedSyncRoomEvent {
/// Any sync message-like event that has been redacted.
MessageLike(AnyRedactedSyncMessageLikeEvent),
/// Any sync state event that has been redacted.
State(AnyRedactedSyncStateEvent),
}
impl Redact for AnySyncRoomEvent { impl Redact for AnySyncRoomEvent {
type Redacted = AnyRedactedSyncRoomEvent; type Redacted = Self;
/// Redacts `self`, referencing the given event in `unsigned.redacted_because`. /// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
/// ///
/// Does nothing for events that are already redacted. /// Does nothing for events that are already redacted.
fn redact( fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self {
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> AnyRedactedSyncRoomEvent {
match self { match self {
Self::OriginalMessageLike(ev) => { Self::MessageLike(ev) => Self::MessageLike(ev.redact(redaction, version)),
AnyRedactedSyncRoomEvent::MessageLike(ev.redact(redaction, version)) Self::State(ev) => Self::State(ev.redact(redaction, version)),
}
Self::OriginalState(ev) => {
AnyRedactedSyncRoomEvent::State(ev.redact(redaction, version))
}
Self::RedactedMessageLike(ev) => AnyRedactedSyncRoomEvent::MessageLike(ev),
Self::RedactedState(ev) => AnyRedactedSyncRoomEvent::State(ev),
}
}
}
impl From<AnyRedactedSyncRoomEvent> for AnySyncRoomEvent {
fn from(ev: AnyRedactedSyncRoomEvent) -> Self {
match ev {
AnyRedactedSyncRoomEvent::MessageLike(ev) => Self::RedactedMessageLike(ev),
AnyRedactedSyncRoomEvent::State(ev) => Self::RedactedState(ev),
} }
} }
} }

30
crates/ruma-common/src/events/kinds.rs
View File

@ -5,13 +5,16 @@ use serde::{Deserialize, Deserializer, Serialize};
use serde_json::value::RawValue as RawJsonValue; use serde_json::value::RawValue as RawJsonValue;
use super::{ use super::{
EphemeralRoomEventContent, EventContent, GlobalAccountDataEventContent, room::redaction::SyncRoomRedactionEvent, EphemeralRoomEventContent, EventContent,
MessageLikeEventContent, MessageLikeEventType, MessageLikeUnsigned, RedactContent, GlobalAccountDataEventContent, MessageLikeEventContent, MessageLikeEventType,
RedactedEventContent, RedactedMessageLikeEventContent, RedactedStateEventContent, MessageLikeUnsigned, Redact, RedactContent, RedactedEventContent,
RedactedUnsigned, RedactionDeHelper, RoomAccountDataEventContent, StateEventContent, RedactedMessageLikeEventContent, RedactedStateEventContent, RedactedUnsigned,
StateEventType, StateUnsigned, ToDeviceEventContent, RedactionDeHelper, RoomAccountDataEventContent, StateEventContent, StateEventType,
StateUnsigned, ToDeviceEventContent,
};
use crate::{
serde::from_raw_json_value, EventId, MilliSecondsSinceUnixEpoch, RoomId, RoomVersionId, UserId,
}; };
use crate::{serde::from_raw_json_value, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
/// A global account data event. /// A global account data event.
#[derive(Clone, Debug, Event)] #[derive(Clone, Debug, Event)]
@ -449,6 +452,21 @@ macro_rules! impl_possibly_redacted_event {
$($extra)* $($extra)*
} }
impl<C> Redact for $ty<C>
where
C: $content_trait + RedactContent,
C::Redacted: $content_trait + RedactedEventContent,
{
type Redacted = Self;
fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self {
match self {
Self::Original(ev) => Self::Redacted(ev.redact(redaction, version)),
Self::Redacted(ev) => Self::Redacted(ev),
}
}
}
impl<'de, C> Deserialize<'de> for $ty<C> impl<'de, C> Deserialize<'de> for $ty<C>
where where
C: $content_trait + RedactContent, C: $content_trait + RedactContent,

6
crates/ruma-common/src/events/relation.rs
View File

@ -5,7 +5,7 @@ use std::fmt::Debug;
use js_int::UInt; use js_int::UInt;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use super::AnyOriginalSyncMessageLikeEvent; use super::AnySyncMessageLikeEvent;
use crate::{serde::Raw, EventId, MilliSecondsSinceUnixEpoch, UserId}; use crate::{serde::Raw, EventId, MilliSecondsSinceUnixEpoch, UserId};
/// Summary of all reactions with the given key to an event. /// Summary of all reactions with the given key to an event.
@ -98,7 +98,7 @@ impl BundledReplacement {
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)] #[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
pub struct BundledThread { pub struct BundledThread {
/// The latest event in the thread. /// The latest event in the thread.
pub latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>, pub latest_event: Box<Raw<AnySyncMessageLikeEvent>>,
/// The number of events in the thread. /// The number of events in the thread.
pub count: UInt, pub count: UInt,
@ -111,7 +111,7 @@ pub struct BundledThread {
impl BundledThread { impl BundledThread {
/// Creates a new `BundledThread` with the given event, count and user participated flag. /// Creates a new `BundledThread` with the given event, count and user participated flag.
pub fn new( pub fn new(
latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>, latest_event: Box<Raw<AnySyncMessageLikeEvent>>,
count: UInt, count: UInt,
current_user_participated: bool, current_user_participated: bool,
) -> Self { ) -> Self {

184
crates/ruma-common/src/events/room/redaction.rs
View File

@ -3,13 +3,42 @@
//! [`m.room.redaction`]: https://spec.matrix.org/v1.2/client-server-api/#mroomredaction //! [`m.room.redaction`]: https://spec.matrix.org/v1.2/client-server-api/#mroomredaction
use ruma_macros::{Event, EventContent}; use ruma_macros::{Event, EventContent};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Deserializer, Serialize};
use serde_json::value::RawValue as RawJsonValue;
use crate::{ use crate::{
events::{MessageLikeUnsigned, Redact, RedactContent, RedactedUnsigned}, events::{
EventContent, MessageLikeEventType, MessageLikeUnsigned, Redact, RedactContent,
RedactedUnsigned, RedactionDeHelper,
},
serde::from_raw_json_value,
EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId,
}; };
/// A possibly-redacted redaction event.
#[allow(clippy::exhaustive_enums)]
#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum RoomRedactionEvent {
/// Original, unredacted form of the event.
Original(OriginalRoomRedactionEvent),
/// Redacted form of the event with minimal fields.
Redacted(RedactedRoomRedactionEvent),
}
/// A possibly-redacted redaction event without a `room_id`.
#[allow(clippy::exhaustive_enums)]
#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum SyncRoomRedactionEvent {
/// Original, unredacted form of the event.
Original(OriginalSyncRoomRedactionEvent),
/// Redacted form of the event with minimal fields.
Redacted(RedactedSyncRoomRedactionEvent),
}
/// Redaction event. /// Redaction event.
#[derive(Clone, Debug, Event)] #[derive(Clone, Debug, Event)]
#[allow(clippy::exhaustive_structs)] #[allow(clippy::exhaustive_structs)]
@ -41,7 +70,7 @@ impl Redact for OriginalRoomRedactionEvent {
fn redact( fn redact(
self, self,
redaction: OriginalSyncRoomRedactionEvent, redaction: SyncRoomRedactionEvent,
version: &crate::RoomVersionId, version: &crate::RoomVersionId,
) -> Self::Redacted { ) -> Self::Redacted {
RedactedRoomRedactionEvent { RedactedRoomRedactionEvent {
@ -111,7 +140,7 @@ impl Redact for OriginalSyncRoomRedactionEvent {
fn redact( fn redact(
self, self,
redaction: OriginalSyncRoomRedactionEvent, redaction: SyncRoomRedactionEvent,
version: &crate::RoomVersionId, version: &crate::RoomVersionId,
) -> Self::Redacted { ) -> Self::Redacted {
RedactedSyncRoomRedactionEvent { RedactedSyncRoomRedactionEvent {
@ -170,3 +199,150 @@ impl RoomRedactionEventContent {
Self { reason: Some(reason) } Self { reason: Some(reason) }
} }
} }
impl RoomRedactionEvent {
/// Returns the `type` of this event.
pub fn event_type(&self) -> MessageLikeEventType {
match self {
Self::Original(ev) => ev.content.event_type(),
Self::Redacted(ev) => ev.content.event_type(),
}
}
/// Returns this event's `event_id` field.
pub fn event_id(&self) -> &EventId {
match self {
Self::Original(ev) => &ev.event_id,
Self::Redacted(ev) => &ev.event_id,
}
}
/// Returns this event's `sender` field.
pub fn sender(&self) -> &UserId {
match self {
Self::Original(ev) => &ev.sender,
Self::Redacted(ev) => &ev.sender,
}
}
/// Returns this event's `origin_server_ts` field.
pub fn origin_server_ts(&self) -> &MilliSecondsSinceUnixEpoch {
match self {
Self::Original(ev) => &ev.origin_server_ts,
Self::Redacted(ev) => &ev.origin_server_ts,
}
}
/// Returns this event's `room_id` field.
pub fn room_id(&self) -> &RoomId {
match self {
Self::Original(ev) => &ev.room_id,
Self::Redacted(ev) => &ev.room_id,
}
}
}
impl Redact for RoomRedactionEvent {
type Redacted = Self;
fn redact(self, redaction: SyncRoomRedactionEvent, version: &crate::RoomVersionId) -> Self {
match self {
Self::Original(ev) => Self::Redacted(ev.redact(redaction, version)),
Self::Redacted(ev) => Self::Redacted(ev),
}
}
}
impl<'de> Deserialize<'de> for RoomRedactionEvent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let json = Box::<RawJsonValue>::deserialize(deserializer)?;
let RedactionDeHelper { unsigned } = from_raw_json_value(&json)?;
if unsigned.and_then(|u| u.redacted_because).is_some() {
Ok(Self::Redacted(from_raw_json_value(&json)?))
} else {
Ok(Self::Original(from_raw_json_value(&json)?))
}
}
}
impl SyncRoomRedactionEvent {
/// Returns the `type` of this event.
pub fn event_type(&self) -> MessageLikeEventType {
match self {
Self::Original(ev) => ev.content.event_type(),
Self::Redacted(ev) => ev.content.event_type(),
}
}
/// Returns this event's `event_id` field.
pub fn event_id(&self) -> &EventId {
match self {
Self::Original(ev) => &ev.event_id,
Self::Redacted(ev) => &ev.event_id,
}
}
/// Returns this event's `sender` field.
pub fn sender(&self) -> &UserId {
match self {
Self::Original(ev) => &ev.sender,
Self::Redacted(ev) => &ev.sender,
}
}
/// Returns this event's `origin_server_ts` field.
pub fn origin_server_ts(&self) -> &MilliSecondsSinceUnixEpoch {
match self {
Self::Original(ev) => &ev.origin_server_ts,
Self::Redacted(ev) => &ev.origin_server_ts,
}
}
/// Convert this sync event into a full event (one with a `room_id` field).
pub fn into_full_event(self, room_id: Box<RoomId>) -> RoomRedactionEvent {
match self {
Self::Original(ev) => RoomRedactionEvent::Original(ev.into_full_event(room_id)),
Self::Redacted(ev) => RoomRedactionEvent::Redacted(ev.into_full_event(room_id)),
}
}
}
impl From<RoomRedactionEvent> for SyncRoomRedactionEvent {
fn from(full: RoomRedactionEvent) -> Self {
match full {
RoomRedactionEvent::Original(ev) => Self::Original(ev.into()),
RoomRedactionEvent::Redacted(ev) => Self::Redacted(ev.into()),
}
}
}
impl Redact for SyncRoomRedactionEvent {
type Redacted = Self;
fn redact(self, redaction: SyncRoomRedactionEvent, version: &crate::RoomVersionId) -> Self {
match self {
Self::Original(ev) => Self::Redacted(ev.redact(redaction, version)),
Self::Redacted(ev) => Self::Redacted(ev),
}
}
}
impl<'de> Deserialize<'de> for SyncRoomRedactionEvent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let json = Box::<RawJsonValue>::deserialize(deserializer)?;
let RedactionDeHelper { unsigned } = from_raw_json_value(&json)?;
if unsigned.and_then(|u| u.redacted_because).is_some() {
Ok(Self::Redacted(from_raw_json_value(&json)?))
} else {
Ok(Self::Original(from_raw_json_value(&json)?))
}
}
}

6
crates/ruma-common/src/events/unsigned.rs
View File

@ -4,7 +4,7 @@ use serde_json::{from_str as from_json_str, value::RawValue as RawJsonValue};
#[cfg(feature = "unstable-msc2675")] #[cfg(feature = "unstable-msc2675")]
use super::relation::Relations; use super::relation::Relations;
use super::{room::redaction::OriginalSyncRoomRedactionEvent, StateEventContent}; use super::{room::redaction::SyncRoomRedactionEvent, StateEventContent};
use crate::{serde::Raw, TransactionId}; use crate::{serde::Raw, TransactionId};
/// Extra information about a message event that is not incorporated into the event's hash. /// Extra information about a message event that is not incorporated into the event's hash.
@ -172,7 +172,7 @@ impl<C: StateEventContent> Default for StateUnsigned<C> {
pub struct RedactedUnsigned { pub struct RedactedUnsigned {
/// The event that redacted this event, if any. /// The event that redacted this event, if any.
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
pub redacted_because: Option<Box<OriginalSyncRoomRedactionEvent>>, pub redacted_because: Option<Box<SyncRoomRedactionEvent>>,
} }
impl RedactedUnsigned { impl RedactedUnsigned {
@ -182,7 +182,7 @@ impl RedactedUnsigned {
} }
/// Create a new `RedactedUnsigned` with the given redacted because. /// Create a new `RedactedUnsigned` with the given redacted because.
pub fn new_because(redacted_because: Box<OriginalSyncRoomRedactionEvent>) -> Self { pub fn new_because(redacted_because: Box<SyncRoomRedactionEvent>) -> Self {
Self { redacted_because: Some(redacted_because) } Self { redacted_because: Some(redacted_because) }
} }

8
crates/ruma-common/tests/events/audio.rs
View File

@ -17,7 +17,7 @@ use ruma_common::{
}, },
JsonWebKeyInit, MediaSource, JsonWebKeyInit, MediaSource,
}, },
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
mxc_uri, room_id, mxc_uri, room_id,
serde::Base64, serde::Base64,
@ -349,8 +349,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Audio(OriginalMessageLikeEvent { AnyMessageLikeEvent::Audio(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: AudioEventContent { content: AudioEventContent {
message, message,
file: FileContent { file: FileContent {
@ -366,7 +366,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Upload: airplane_sound.opus") && message.find_plain() == Some("Upload: airplane_sound.opus")
&& message.find_html().is_none() && message.find_html().is_none()
&& url == "mxc://notareal.hs/abcdef" && url == "mxc://notareal.hs/abcdef"

111
crates/ruma-common/tests/events/enums.rs
View File

@ -1,6 +1,12 @@
use js_int::uint; use js_int::uint;
use matches::assert_matches; use matches::assert_matches;
use ruma_common::{event_id, room_alias_id, room_id, serde::test::serde_json_eq, user_id}; use ruma_common::{
event_id,
events::{MessageLikeEvent, StateEvent, SyncMessageLikeEvent, SyncStateEvent},
room_alias_id, room_id,
serde::test::serde_json_eq,
user_id,
};
use serde_json::{from_value as from_json_value, json, Value as JsonValue}; use serde_json::{from_value as from_json_value, json, Value as JsonValue};
use ruma_common::{ use ruma_common::{
@ -10,12 +16,11 @@ use ruma_common::{
message::{MessageType, RoomMessageEventContent, TextMessageEventContent}, message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
power_levels::RoomPowerLevelsEventContent, power_levels::RoomPowerLevelsEventContent,
}, },
AnyEphemeralRoomEvent, AnyOriginalMessageLikeEvent, AnyOriginalStateEvent, AnyEphemeralRoomEvent, AnyMessageLikeEvent, AnyRoomEvent, AnyStateEvent,
AnyOriginalSyncMessageLikeEvent, AnyOriginalSyncStateEvent, AnyRoomEvent, AnySyncRoomEvent, AnySyncMessageLikeEvent, AnySyncRoomEvent, AnySyncStateEvent, EphemeralRoomEventType,
EphemeralRoomEventType, GlobalAccountDataEventType, MessageLikeEventType, GlobalAccountDataEventType, MessageLikeEventType, MessageLikeUnsigned,
MessageLikeUnsigned, OriginalMessageLikeEvent, OriginalStateEvent, OriginalMessageLikeEvent, OriginalStateEvent, OriginalSyncMessageLikeEvent,
OriginalSyncMessageLikeEvent, OriginalSyncStateEvent, RoomAccountDataEventType, OriginalSyncStateEvent, RoomAccountDataEventType, StateEventType, ToDeviceEventType,
StateEventType, ToDeviceEventType,
}, },
MilliSecondsSinceUnixEpoch, MilliSecondsSinceUnixEpoch,
}; };
@ -124,13 +129,15 @@ fn power_event_sync_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data), from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::OriginalState( Ok(AnySyncRoomEvent::State(
AnyOriginalSyncStateEvent::RoomPowerLevels(OriginalSyncStateEvent { AnySyncStateEvent::RoomPowerLevels(SyncStateEvent::Original(
content: RoomPowerLevelsEventContent { OriginalSyncStateEvent {
ban, .. content: RoomPowerLevelsEventContent {
ban, ..
},
..
}, },
.. )),
})
)) ))
if ban == js_int::Int::new(50).unwrap() if ban == js_int::Int::new(50).unwrap()
); );
@ -142,18 +149,20 @@ fn message_event_sync_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data), from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::OriginalMessageLike( Ok(AnySyncRoomEvent::MessageLike(
AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent { AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent::Original(
content: RoomMessageEventContent { OriginalSyncMessageLikeEvent {
msgtype: MessageType::Text(TextMessageEventContent { content: RoomMessageEventContent {
body, msgtype: MessageType::Text(TextMessageEventContent {
formatted: Some(formatted), body,
formatted: Some(formatted),
..
}),
.. ..
}), },
.. ..
}, },
.. ))
})
)) ))
if body == "baba" && formatted.body == "<strong>baba</strong>" if body == "baba" && formatted.body == "<strong>baba</strong>"
); );
@ -165,14 +174,16 @@ fn aliases_event_sync_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data), from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::OriginalState( Ok(AnySyncRoomEvent::State(
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent { AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(
content: RoomAliasesEventContent { OriginalSyncStateEvent {
aliases, content: RoomAliasesEventContent {
aliases,
..
},
.. ..
}, },
.. ))
})
)) ))
if aliases == vec![ room_alias_id!("#somewhere:localhost") ] if aliases == vec![ room_alias_id!("#somewhere:localhost") ]
); );
@ -184,18 +195,20 @@ fn message_room_event_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(json_data), from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalMessageLike( Ok(AnyRoomEvent::MessageLike(
AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent { AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Original(
content: RoomMessageEventContent { OriginalMessageLikeEvent {
msgtype: MessageType::Text(TextMessageEventContent { content: RoomMessageEventContent {
body, msgtype: MessageType::Text(TextMessageEventContent {
formatted: Some(formatted), body,
formatted: Some(formatted),
..
}),
.. ..
}), },
.. ..
}, },
.. ))
})
)) ))
if body == "baba" && formatted.body == "<strong>baba</strong>" if body == "baba" && formatted.body == "<strong>baba</strong>"
); );
@ -231,14 +244,14 @@ fn alias_room_event_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(json_data), from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalState( Ok(AnyRoomEvent::State(
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent { AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
content: RoomAliasesEventContent { content: RoomAliasesEventContent {
aliases, aliases,
.. ..
}, },
.. ..
}) }))
)) ))
if aliases == vec![ room_alias_id!("#somewhere:localhost") ] if aliases == vec![ room_alias_id!("#somewhere:localhost") ]
); );
@ -250,8 +263,8 @@ fn message_event_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(json_data), from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalMessageLike( Ok(AnyRoomEvent::MessageLike(
AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent { AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: RoomMessageEventContent { content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent { msgtype: MessageType::Text(TextMessageEventContent {
body, body,
@ -261,7 +274,7 @@ fn message_event_deserialization() {
.. ..
}, },
.. ..
}) }))
)) ))
if body == "baba" && formatted.body == "<strong>baba</strong>" if body == "baba" && formatted.body == "<strong>baba</strong>"
); );
@ -273,14 +286,14 @@ fn alias_event_deserialization() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(json_data), from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalState( Ok(AnyRoomEvent::State(
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent { AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
content: RoomAliasesEventContent { content: RoomAliasesEventContent {
aliases, aliases,
.. ..
}, },
.. ..
}) }))
)) ))
if aliases == vec![ room_alias_id!("#somewhere:localhost") ] if aliases == vec![ room_alias_id!("#somewhere:localhost") ]
); );
@ -292,15 +305,15 @@ fn alias_event_field_access() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(json_data.clone()), from_json_value::<AnyRoomEvent>(json_data.clone()),
Ok(AnyRoomEvent::OriginalState(state_event)) Ok(AnyRoomEvent::State(state_event))
if state_event.state_key() == "" if state_event.state_key() == ""
&& state_event.room_id() == room_id!("!room:room.com") && state_event.room_id() == room_id!("!room:room.com")
&& state_event.event_id() == event_id!("$152037280074GZeOm:localhost") && state_event.event_id() == event_id!("$152037280074GZeOm:localhost")
&& state_event.sender() == user_id!("@example:localhost") && state_event.sender() == user_id!("@example:localhost")
); );
let deser = from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(); let deser = from_json_value::<AnyStateEvent>(json_data).unwrap();
if let AnyOriginalStateEvent::RoomAliases(ev) = &deser { if let AnyStateEvent::RoomAliases(StateEvent::Original(ev)) = &deser {
assert_eq!(ev.content.aliases, vec![room_alias_id!("#somewhere:localhost")]) assert_eq!(ev.content.aliases, vec![room_alias_id!("#somewhere:localhost")])
} else { } else {
panic!("the `Any*Event` enum's accessor methods may have been altered") panic!("the `Any*Event` enum's accessor methods may have been altered")

12
crates/ruma-common/tests/events/event_enums.rs
View File

@ -1,11 +1,13 @@
use js_int::{uint, UInt}; use js_int::{uint, UInt};
use matches::assert_matches; use matches::assert_matches;
use ruma_common::{event_id, room_id, user_id, MilliSecondsSinceUnixEpoch}; use ruma_common::{
event_id, events::MessageLikeEvent, room_id, user_id, MilliSecondsSinceUnixEpoch,
};
use serde_json::{from_value as from_json_value, json}; use serde_json::{from_value as from_json_value, json};
use ruma_common::events::{ use ruma_common::events::{
call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType}, call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
AnyOriginalMessageLikeEvent, OriginalMessageLikeEvent, AnyMessageLikeEvent, OriginalMessageLikeEvent,
}; };
#[test] #[test]
@ -35,9 +37,9 @@ fn deserialize_message_event() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data) from_json_value::<AnyMessageLikeEvent>(json_data)
.unwrap(), .unwrap(),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent { AnyMessageLikeEvent::CallAnswer(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: CallAnswerEventContent { content: CallAnswerEventContent {
answer: SessionDescription { answer: SessionDescription {
session_type: SessionDescriptionType::Answer, session_type: SessionDescriptionType::Answer,
@ -53,7 +55,7 @@ fn deserialize_message_event() {
room_id, room_id,
sender, sender,
unsigned, unsigned,
}) if sdp == "Hello" && call_id == "foofoo" && version == UInt::new(1).unwrap() })) if sdp == "Hello" && call_id == "foofoo" && version == UInt::new(1).unwrap()
&& event_id == event_id!("$h29iv0s8:example.com") && event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com") && room_id == room_id!("!roomid:room.com")

8
crates/ruma-common/tests/events/file.rs
View File

@ -14,7 +14,7 @@ use ruma_common::{
}, },
EncryptedFileInit, JsonWebKeyInit, MediaSource, EncryptedFileInit, JsonWebKeyInit, MediaSource,
}, },
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
mxc_uri, room_id, mxc_uri, room_id,
serde::Base64, serde::Base64,
@ -225,8 +225,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::File(OriginalMessageLikeEvent { AnyMessageLikeEvent::File(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: FileEventContent { content: FileEventContent {
message, message,
file: FileContent { file: FileContent {
@ -241,7 +241,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Upload: my_file.txt") && message.find_plain() == Some("Upload: my_file.txt")
&& message.find_html() == Some("Upload: <strong>my_file.txt</strong>") && message.find_html() == Some("Upload: <strong>my_file.txt</strong>")
&& url.as_str() == "mxc://notareal.hs/abcdef" && url.as_str() == "mxc://notareal.hs/abcdef"

8
crates/ruma-common/tests/events/image.rs
View File

@ -18,7 +18,7 @@ use ruma_common::{
}, },
JsonWebKeyInit, MediaSource, JsonWebKeyInit, MediaSource,
}, },
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
mxc_uri, room_id, mxc_uri, room_id,
serde::Base64, serde::Base64,
@ -285,8 +285,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Image(OriginalMessageLikeEvent { AnyMessageLikeEvent::Image(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: ImageEventContent { content: ImageEventContent {
message, message,
file: FileContent { file: FileContent {
@ -304,7 +304,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Upload: my_gnome.webp") && message.find_plain() == Some("Upload: my_gnome.webp")
&& message.find_html().is_none() && message.find_html().is_none()
&& url == "mxc://notareal.hs/abcdef" && url == "mxc://notareal.hs/abcdef"

8
crates/ruma-common/tests/events/location.rs
View File

@ -14,7 +14,7 @@ use ruma_common::{
room::message::{ room::message::{
InReplyTo, LocationMessageEventContent, MessageType, Relation, RoomMessageEventContent, InReplyTo, LocationMessageEventContent, MessageType, Relation, RoomMessageEventContent,
}, },
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
room_id, user_id, MilliSecondsSinceUnixEpoch, room_id, user_id, MilliSecondsSinceUnixEpoch,
}; };
@ -195,8 +195,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Location(OriginalMessageLikeEvent { AnyMessageLikeEvent::Location(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: LocationEventContent { content: LocationEventContent {
message, message,
location: LocationContent { location: LocationContent {
@ -217,7 +217,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Alice was at geo:51.5008,0.1247;u=35 as of Sat Nov 13 18:50:58 2021") && message.find_plain() == Some("Alice was at geo:51.5008,0.1247;u=35 as of Sat Nov 13 18:50:58 2021")
&& message.find_html().is_none() && message.find_html().is_none()
&& uri == "geo:51.5008,0.1247;u=35" && uri == "geo:51.5008,0.1247;u=35"

32
crates/ruma-common/tests/events/message.rs
View File

@ -15,7 +15,7 @@ use ruma_common::{
EmoteMessageEventContent, InReplyTo, MessageType, NoticeMessageEventContent, Relation, EmoteMessageEventContent, InReplyTo, MessageType, NoticeMessageEventContent, Relation,
RoomMessageEventContent, TextMessageEventContent, RoomMessageEventContent, TextMessageEventContent,
}, },
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
room_id, user_id, MilliSecondsSinceUnixEpoch, room_id, user_id, MilliSecondsSinceUnixEpoch,
}; };
@ -255,8 +255,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Message(OriginalMessageLikeEvent { AnyMessageLikeEvent::Message(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: MessageEventContent { content: MessageEventContent {
message, message,
.. ..
@ -266,7 +266,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Hello, World!") && message.find_plain() == Some("Hello, World!")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
&& room_id == room_id!("!roomid:notareal.hs") && room_id == room_id!("!roomid:notareal.hs")
@ -447,8 +447,8 @@ fn notice_event_stable_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent { AnyMessageLikeEvent::Notice(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: NoticeEventContent { content: NoticeEventContent {
message, message,
.. ..
@ -458,7 +458,7 @@ fn notice_event_stable_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Hello, I'm a robot!") && message.find_plain() == Some("Hello, I'm a robot!")
&& message.find_html() == Some("Hello, I'm a <em>robot</em>!") && message.find_html() == Some("Hello, I'm a <em>robot</em>!")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
@ -485,8 +485,8 @@ fn notice_event_unstable_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent { AnyMessageLikeEvent::Notice(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: NoticeEventContent { content: NoticeEventContent {
message, message,
.. ..
@ -496,7 +496,7 @@ fn notice_event_unstable_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Hello, I'm a robot!") && message.find_plain() == Some("Hello, I'm a robot!")
&& message.find_html() == Some("Hello, I'm a <em>robot</em>!") && message.find_html() == Some("Hello, I'm a <em>robot</em>!")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
@ -618,8 +618,8 @@ fn emote_event_stable_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent { AnyMessageLikeEvent::Emote(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: EmoteEventContent { content: EmoteEventContent {
message, message,
.. ..
@ -629,7 +629,7 @@ fn emote_event_stable_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("is testing some code…") && message.find_plain() == Some("is testing some code…")
&& message.find_html().is_none() && message.find_html().is_none()
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
@ -653,8 +653,8 @@ fn emote_event_unstable_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent { AnyMessageLikeEvent::Emote(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: EmoteEventContent { content: EmoteEventContent {
message, message,
.. ..
@ -664,7 +664,7 @@ fn emote_event_unstable_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("is testing some code…") && message.find_plain() == Some("is testing some code…")
&& message.find_html().is_none() && message.find_html().is_none()
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))

20
crates/ruma-common/tests/events/message_event.rs
View File

@ -7,7 +7,7 @@ use ruma_common::{
call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType}, call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
room::{ImageInfo, MediaSource, ThumbnailInfo}, room::{ImageInfo, MediaSource, ThumbnailInfo},
sticker::StickerEventContent, sticker::StickerEventContent,
AnyMessageLikeEventContent, AnyOriginalMessageLikeEvent, AnyOriginalSyncMessageLikeEvent, AnyMessageLikeEvent, AnyMessageLikeEventContent, AnySyncMessageLikeEvent, MessageLikeEvent,
MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent, MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
mxc_uri, room_id, mxc_uri, room_id,
@ -167,8 +167,8 @@ fn deserialize_message_call_answer() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent { AnyMessageLikeEvent::CallAnswer(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: CallAnswerEventContent { content: CallAnswerEventContent {
answer: SessionDescription { answer: SessionDescription {
session_type: SessionDescriptionType::Answer, session_type: SessionDescriptionType::Answer,
@ -184,7 +184,7 @@ fn deserialize_message_call_answer() {
room_id, room_id,
sender, sender,
unsigned, unsigned,
}) if sdp == "Hello" && call_id == "foofoo" && version == UInt::new(1).unwrap() })) if sdp == "Hello" && call_id == "foofoo" && version == UInt::new(1).unwrap()
&& event_id == event_id!("$h29iv0s8:example.com") && event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com") && room_id == room_id!("!roomid:room.com")
@ -221,8 +221,8 @@ fn deserialize_message_sticker() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Sticker(OriginalMessageLikeEvent { AnyMessageLikeEvent::Sticker(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: StickerEventContent { content: StickerEventContent {
body, body,
info: ImageInfo { info: ImageInfo {
@ -244,7 +244,7 @@ fn deserialize_message_sticker() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$h29iv0s8:example.com") })) if event_id == event_id!("$h29iv0s8:example.com")
&& body == "Hello" && body == "Hello"
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com") && room_id == room_id!("!roomid:room.com")
@ -290,11 +290,11 @@ fn deserialize_message_then_convert_to_full() {
"type": "m.call.answer" "type": "m.call.answer"
}); });
let sync_ev: AnyOriginalSyncMessageLikeEvent = from_json_value(json_data).unwrap(); let sync_ev: AnySyncMessageLikeEvent = from_json_value(json_data).unwrap();
assert_matches!( assert_matches!(
sync_ev.into_full_event(rid.to_owned()), sync_ev.into_full_event(rid.to_owned()),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent { AnyMessageLikeEvent::CallAnswer(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: CallAnswerEventContent { content: CallAnswerEventContent {
answer: SessionDescription { answer: SessionDescription {
session_type: SessionDescriptionType::Answer, session_type: SessionDescriptionType::Answer,
@ -310,7 +310,7 @@ fn deserialize_message_then_convert_to_full() {
room_id, room_id,
sender, sender,
unsigned, unsigned,
}) if sdp == "Hello" })) if sdp == "Hello"
&& call_id == "foofoo" && call_id == "foofoo"
&& version == uint!(1) && version == uint!(1)
&& event_id == "$h29iv0s8:example.com" && event_id == "$h29iv0s8:example.com"

88
crates/ruma-common/tests/events/redacted.rs
View File

@ -7,12 +7,14 @@ use ruma_common::{
aliases::RedactedRoomAliasesEventContent, aliases::RedactedRoomAliasesEventContent,
create::{RedactedRoomCreateEventContent, RoomCreateEventContent}, create::{RedactedRoomCreateEventContent, RoomCreateEventContent},
message::{RedactedRoomMessageEventContent, RoomMessageEventContent}, message::{RedactedRoomMessageEventContent, RoomMessageEventContent},
redaction::{OriginalSyncRoomRedactionEvent, RoomRedactionEventContent}, redaction::{
OriginalSyncRoomRedactionEvent, RoomRedactionEventContent, SyncRoomRedactionEvent,
},
}, },
AnyOriginalMessageLikeEvent, AnyRedactedMessageLikeEvent, AnyRedactedSyncMessageLikeEvent, AnyMessageLikeEvent, AnyRoomEvent, AnySyncMessageLikeEvent, AnySyncRoomEvent,
AnyRedactedSyncStateEvent, AnyRoomEvent, AnySyncRoomEvent, EventContent, AnySyncStateEvent, EventContent, MessageLikeEvent, MessageLikeUnsigned, RedactContent,
MessageLikeUnsigned, Redact, RedactContent, RedactedMessageLikeEvent, RedactedMessageLikeEvent, RedactedSyncMessageLikeEvent, RedactedSyncStateEvent,
RedactedSyncMessageLikeEvent, RedactedSyncStateEvent, RedactedUnsigned, RedactedUnsigned, SyncMessageLikeEvent, SyncStateEvent,
}, },
room_id, user_id, MilliSecondsSinceUnixEpoch, RoomVersionId, room_id, user_id, MilliSecondsSinceUnixEpoch, RoomVersionId,
}; };
@ -23,14 +25,15 @@ use serde_json::{
fn unsigned() -> RedactedUnsigned { fn unsigned() -> RedactedUnsigned {
let mut unsigned = RedactedUnsigned::default(); let mut unsigned = RedactedUnsigned::default();
unsigned.redacted_because = Some(Box::new(OriginalSyncRoomRedactionEvent { unsigned.redacted_because =
content: RoomRedactionEventContent::with_reason("redacted because".into()), Some(Box::new(SyncRoomRedactionEvent::Original(OriginalSyncRoomRedactionEvent {
redacts: event_id!("$h29iv0s8:example.com").to_owned(), content: RoomRedactionEventContent::with_reason("redacted because".into()),
event_id: event_id!("$h29iv0s8:example.com").to_owned(), redacts: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)), event_id: event_id!("$h29iv0s8:example.com").to_owned(),
sender: user_id!("@carl:example.com").to_owned(), origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
unsigned: MessageLikeUnsigned::default(), sender: user_id!("@carl:example.com").to_owned(),
})); unsigned: MessageLikeUnsigned::default(),
})));
unsigned unsigned
} }
@ -120,12 +123,12 @@ fn redacted_aliases_deserialize() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(actual).unwrap(), from_json_value::<AnySyncRoomEvent>(actual).unwrap(),
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomAliases( AnySyncRoomEvent::State(AnySyncStateEvent::RoomAliases(
RedactedSyncStateEvent { SyncStateEvent::Redacted(RedactedSyncStateEvent {
content: RedactedRoomAliasesEventContent { aliases, .. }, content: RedactedRoomAliasesEventContent { aliases, .. },
event_id, event_id,
.. ..
}, }),
)) if event_id == event_id!("$h29iv0s8:example.com") )) if event_id == event_id!("$h29iv0s8:example.com")
&& aliases.is_none() && aliases.is_none()
) )
@ -146,10 +149,12 @@ fn redacted_deserialize_any_room() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(actual).unwrap(), from_json_value::<AnyRoomEvent>(actual).unwrap(),
AnyRoomEvent::RedactedMessageLike(AnyRedactedMessageLikeEvent::RoomMessage(RedactedMessageLikeEvent { AnyRoomEvent::MessageLike(AnyMessageLikeEvent::RoomMessage(
content: RedactedRoomMessageEventContent { .. }, MessageLikeEvent::Redacted(RedactedMessageLikeEvent {
event_id, room_id, .. content: RedactedRoomMessageEventContent { .. },
})) if event_id == event_id!("$h29iv0s8:example.com") event_id, room_id, ..
}),
)) if event_id == event_id!("$h29iv0s8:example.com")
&& room_id == room_id!("!roomid:room.com") && room_id == room_id!("!roomid:room.com")
) )
} }
@ -160,14 +165,15 @@ fn redacted_deserialize_any_room_sync() {
// The presence of `redacted_because` triggers the event enum (AnySyncRoomEvent 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(Box::new(OriginalSyncRoomRedactionEvent { unsigned.redacted_because =
content: RoomRedactionEventContent::with_reason("redacted because".into()), Some(Box::new(SyncRoomRedactionEvent::Original(OriginalSyncRoomRedactionEvent {
redacts: event_id!("$h29iv0s8:example.com").to_owned(), content: RoomRedactionEventContent::with_reason("redacted because".into()),
event_id: event_id!("$h29iv0s8:example.com").to_owned(), redacts: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)), event_id: event_id!("$h29iv0s8:example.com").to_owned(),
sender: user_id!("@carl:example.com").to_owned(), origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
unsigned: MessageLikeUnsigned::default(), sender: user_id!("@carl:example.com").to_owned(),
})); unsigned: MessageLikeUnsigned::default(),
})));
let redacted = json!({ let redacted = json!({
"event_id": "$h29iv0s8:example.com", "event_id": "$h29iv0s8:example.com",
@ -181,12 +187,12 @@ fn redacted_deserialize_any_room_sync() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(actual).unwrap(), from_json_value::<AnySyncRoomEvent>(actual).unwrap(),
AnySyncRoomEvent::RedactedMessageLike(AnyRedactedSyncMessageLikeEvent::RoomMessage( AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
RedactedSyncMessageLikeEvent { SyncMessageLikeEvent::Redacted(RedactedSyncMessageLikeEvent {
content: RedactedRoomMessageEventContent { .. }, content: RedactedRoomMessageEventContent { .. },
event_id, event_id,
.. ..
} }),
)) if event_id == event_id!("$h29iv0s8:example.com") )) if event_id == event_id!("$h29iv0s8:example.com")
) )
} }
@ -208,8 +214,8 @@ fn redacted_state_event_deserialize() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(redacted) from_json_value::<AnySyncRoomEvent>(redacted)
.unwrap(), .unwrap(),
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomCreate( AnySyncRoomEvent::State(AnySyncStateEvent::RoomCreate(
RedactedSyncStateEvent { SyncStateEvent::Redacted(RedactedSyncStateEvent {
content: RedactedRoomCreateEventContent { content: RedactedRoomCreateEventContent {
creator, .. creator, ..
}, },
@ -217,7 +223,7 @@ fn redacted_state_event_deserialize() {
state_key, state_key,
unsigned, unsigned,
.. ..
} }),
)) if event_id == event_id!("$h29iv0s8:example.com") )) if event_id == event_id!("$h29iv0s8:example.com")
&& unsigned.redacted_because.is_some() && unsigned.redacted_because.is_some()
&& state_key == "hello there" && state_key == "hello there"
@ -238,14 +244,14 @@ fn redacted_custom_event_serialize() {
assert_matches!( assert_matches!(
from_json_value::<AnySyncRoomEvent>(redacted.clone()), from_json_value::<AnySyncRoomEvent>(redacted.clone()),
Ok(AnySyncRoomEvent::RedactedState(_)) Ok(AnySyncRoomEvent::State(_))
); );
let x = from_json_value::<AnyRedactedSyncStateEvent>(redacted).unwrap(); let x = from_json_value::<AnySyncStateEvent>(redacted).unwrap();
assert_eq!(x.event_id(), event_id!("$h29iv0s8:example.com")) assert_eq!(x.event_id(), event_id!("$h29iv0s8:example.com"))
} }
#[test] /* #[test]
fn redact_method_properly_redacts() { fn redact_method_properly_redacts() {
let ev = json!({ let ev = json!({
"type": "m.room.message", "type": "m.room.message",
@ -269,24 +275,24 @@ fn redact_method_properly_redacts() {
unsigned: MessageLikeUnsigned::default(), unsigned: MessageLikeUnsigned::default(),
}; };
let event: AnyOriginalMessageLikeEvent = from_json_value(ev).unwrap(); let event: AnyMessageLikeEvent = from_json_value(ev).unwrap();
assert_matches!( assert_matches!(
event.redact(redaction, &RoomVersionId::V6), event.redact(redaction, &RoomVersionId::V6),
AnyRedactedMessageLikeEvent::RoomMessage(RedactedMessageLikeEvent { AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Redacted(RedactedMessageLikeEvent {
content: RedactedRoomMessageEventContent { .. }, content: RedactedRoomMessageEventContent { .. },
event_id, event_id,
room_id, room_id,
sender, sender,
origin_server_ts, origin_server_ts,
unsigned, unsigned,
}) if event_id == event_id!("$143273582443PhrSn:example.com") })) if event_id == event_id!("$143273582443PhrSn:example.com")
&& unsigned.redacted_because.is_some() && unsigned.redacted_because.is_some()
&& room_id == room_id!("!roomid:room.com") && room_id == room_id!("!roomid:room.com")
&& sender == user_id!("@user:example.com") && sender == user_id!("@user:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
); );
} } */
#[test] #[test]
fn redact_message_content() { fn redact_message_content() {

12
crates/ruma-common/tests/events/redaction.rs
View File

@ -3,8 +3,10 @@ use matches::assert_matches;
use ruma_common::{ use ruma_common::{
event_id, event_id,
events::{ events::{
room::redaction::{OriginalRoomRedactionEvent, RoomRedactionEventContent}, room::redaction::{
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalRoomRedactionEvent, RoomRedactionEvent, RoomRedactionEventContent,
},
AnyMessageLikeEvent, MessageLikeUnsigned,
}, },
room_id, user_id, MilliSecondsSinceUnixEpoch, room_id, user_id, MilliSecondsSinceUnixEpoch,
}; };
@ -49,8 +51,8 @@ fn deserialize_redaction() {
let json_data = redaction(); let json_data = redaction();
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::RoomRedaction(OriginalRoomRedactionEvent { AnyMessageLikeEvent::RoomRedaction(RoomRedactionEvent::Original(OriginalRoomRedactionEvent {
content: RoomRedactionEventContent { reason: Some(reas), .. }, content: RoomRedactionEventContent { reason: Some(reas), .. },
redacts, redacts,
event_id, event_id,
@ -58,7 +60,7 @@ fn deserialize_redaction() {
room_id, room_id,
sender, sender,
unsigned, unsigned,
}) if reas == "being a turd" })) if reas == "being a turd"
&& event_id == event_id!("$h29iv0s8:example.com") && event_id == event_id!("$h29iv0s8:example.com")
&& redacts == event_id!("$nomore:example.com") && redacts == event_id!("$nomore:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))

36
crates/ruma-common/tests/events/state_event.rs
View File

@ -9,8 +9,8 @@ use ruma_common::{
avatar::{ImageInfo, RoomAvatarEventContent}, avatar::{ImageInfo, RoomAvatarEventContent},
ThumbnailInfo, ThumbnailInfo,
}, },
AnyOriginalStateEvent, AnyOriginalSyncStateEvent, AnyRoomEvent, AnyStateEventContent, AnyRoomEvent, AnyStateEvent, AnyStateEventContent, AnySyncStateEvent, OriginalStateEvent,
OriginalStateEvent, OriginalSyncStateEvent, StateEventType, StateUnsigned, OriginalSyncStateEvent, StateEvent, StateEventType, StateUnsigned, SyncStateEvent,
}, },
mxc_uri, room_alias_id, room_id, mxc_uri, room_alias_id, room_id,
serde::Raw, serde::Raw,
@ -115,8 +115,8 @@ fn deserialize_aliases_with_prev_content() {
let json_data = aliases_event_with_prev_content(); let json_data = aliases_event_with_prev_content();
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(), from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent { AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
content, content,
event_id, event_id,
origin_server_ts, origin_server_ts,
@ -127,7 +127,7 @@ fn deserialize_aliases_with_prev_content() {
prev_content: Some(prev_content), prev_content: Some(prev_content),
.. ..
}, },
}) if content.aliases == vec![room_alias_id!("#somewhere:localhost")] })) if content.aliases == vec![room_alias_id!("#somewhere:localhost")]
&& event_id == event_id!("$h29iv0s8:example.com") && event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& prev_content.aliases == vec![room_alias_id!("#inner:localhost")] && prev_content.aliases == vec![room_alias_id!("#inner:localhost")]
@ -143,9 +143,9 @@ 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::<AnyOriginalSyncStateEvent>(json_data) from_json_value::<AnySyncStateEvent>(json_data)
.unwrap(), .unwrap(),
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent { AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(OriginalSyncStateEvent {
content, content,
event_id, event_id,
origin_server_ts, origin_server_ts,
@ -155,7 +155,7 @@ fn deserialize_aliases_sync_with_room_id() {
prev_content: Some(prev_content), prev_content: Some(prev_content),
.. ..
}, },
}) if content.aliases == vec![room_alias_id!("#somewhere:localhost")] })) if content.aliases == vec![room_alias_id!("#somewhere:localhost")]
&& event_id == event_id!("$h29iv0s8:example.com") && event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& prev_content.aliases == vec![room_alias_id!("#inner:localhost")] && prev_content.aliases == vec![room_alias_id!("#inner:localhost")]
@ -193,8 +193,8 @@ fn deserialize_avatar_without_prev_content() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(), from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyOriginalStateEvent::RoomAvatar(OriginalStateEvent { AnyStateEvent::RoomAvatar(StateEvent::Original(OriginalStateEvent {
content: RoomAvatarEventContent { content: RoomAvatarEventContent {
info: Some(info), info: Some(info),
url: Some(url), url: Some(url),
@ -206,7 +206,7 @@ fn deserialize_avatar_without_prev_content() {
sender, sender,
state_key, state_key,
unsigned, unsigned,
}) if event_id == event_id!("$h29iv0s8:example.com") })) if event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com") && room_id == room_id!("!roomid:room.com")
&& sender == user_id!("@carl:example.com") && sender == user_id!("@carl:example.com")
@ -268,15 +268,15 @@ fn deserialize_member_event_with_top_level_membership_field() {
assert_matches!( assert_matches!(
from_json_value::<AnyRoomEvent>(json_data) from_json_value::<AnyRoomEvent>(json_data)
.unwrap(), .unwrap(),
AnyRoomEvent::OriginalState( AnyRoomEvent::State(AnyStateEvent::RoomMember(StateEvent::Original(
AnyOriginalStateEvent::RoomMember(OriginalStateEvent { OriginalStateEvent {
content, content,
event_id, event_id,
origin_server_ts, origin_server_ts,
sender, sender,
.. ..
} }
)) if event_id == event_id!("$h29iv0s8:example.com") ))) if event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& sender == user_id!("@example:localhost") && sender == user_id!("@example:localhost")
&& content.displayname == Some("example".into()) && content.displayname == Some("example".into())
@ -287,11 +287,11 @@ fn deserialize_member_event_with_top_level_membership_field() {
fn deserialize_full_event_convert_to_sync() { fn deserialize_full_event_convert_to_sync() {
let json_data = aliases_event_with_prev_content(); let json_data = aliases_event_with_prev_content();
let full_ev: AnyOriginalStateEvent = from_json_value(json_data).unwrap(); let full_ev: AnyStateEvent = from_json_value(json_data).unwrap();
assert_matches!( assert_matches!(
AnyOriginalSyncStateEvent::from(full_ev), AnySyncStateEvent::from(full_ev),
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent { AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(OriginalSyncStateEvent {
content, content,
event_id, event_id,
origin_server_ts, origin_server_ts,
@ -301,7 +301,7 @@ fn deserialize_full_event_convert_to_sync() {
prev_content: Some(prev_content), prev_content: Some(prev_content),
.. ..
} }
}) if content.aliases == vec![room_alias_id!("#somewhere:localhost")] })) if content.aliases == vec![room_alias_id!("#somewhere:localhost")]
&& event_id == "$h29iv0s8:example.com" && event_id == "$h29iv0s8:example.com"
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1)) && origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& prev_content.aliases == vec![room_alias_id!("#inner:localhost")] && prev_content.aliases == vec![room_alias_id!("#inner:localhost")]

8
crates/ruma-common/tests/events/video.rs
View File

@ -18,7 +18,7 @@ use ruma_common::{
JsonWebKeyInit, MediaSource, JsonWebKeyInit, MediaSource,
}, },
video::{VideoContent, VideoEventContent}, video::{VideoContent, VideoEventContent},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
mxc_uri, room_id, mxc_uri, room_id,
serde::Base64, serde::Base64,
@ -295,8 +295,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Video(OriginalMessageLikeEvent { AnyMessageLikeEvent::Video(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: VideoEventContent { content: VideoEventContent {
message, message,
file: FileContent { file: FileContent {
@ -314,7 +314,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Upload: my_gnome.webm") && message.find_plain() == Some("Upload: my_gnome.webm")
&& message.find_html().is_none() && message.find_html().is_none()
&& url == "mxc://notareal.hs/abcdef" && url == "mxc://notareal.hs/abcdef"

8
crates/ruma-common/tests/events/voice.rs
View File

@ -17,7 +17,7 @@ use ruma_common::{
MediaSource, MediaSource,
}, },
voice::{VoiceContent, VoiceEventContent}, voice::{VoiceContent, VoiceEventContent},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent, AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
}, },
mxc_uri, room_id, user_id, MilliSecondsSinceUnixEpoch, mxc_uri, room_id, user_id, MilliSecondsSinceUnixEpoch,
}; };
@ -114,8 +114,8 @@ fn message_event_deserialization() {
}); });
assert_matches!( assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(), from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Voice(OriginalMessageLikeEvent { AnyMessageLikeEvent::Voice(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: VoiceEventContent { content: VoiceEventContent {
message, message,
file: FileContent { file: FileContent {
@ -131,7 +131,7 @@ fn message_event_deserialization() {
room_id, room_id,
sender, sender,
unsigned unsigned
}) if event_id == event_id!("$event:notareal.hs") })) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Voice message") && message.find_plain() == Some("Voice message")
&& message.find_html().is_none() && message.find_html().is_none()
&& url == "mxc://notareal.hs/abcdef" && url == "mxc://notareal.hs/abcdef"

2
crates/ruma-macros/src/events/event.rs
View File

@ -422,7 +422,7 @@ fn expand_redact_event(
fn redact( fn redact(
self, self,
redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent, redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
version: &#ruma_common::RoomVersionId, version: &#ruma_common::RoomVersionId,
) -> Self::Redacted { ) -> Self::Redacted {
let content = #ruma_common::events::RedactContent::redact(self.content, version); let content = #ruma_common::events::RedactContent::redact(self.content, version);

216
crates/ruma-macros/src/events/event_enum.rs
View File

@ -1,16 +1,26 @@
//! Implementation of event enum and event content enum macros. //! Implementation of event enum and event content enum macros.
use std::fmt;
use proc_macro2::{Span, TokenStream}; use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote, ToTokens}; use quote::{format_ident, quote, IdentFragment, ToTokens};
use syn::{Attribute, Data, DataEnum, DeriveInput, Ident, LitStr}; use syn::{Attribute, Data, DataEnum, DeriveInput, Ident, LitStr};
use super::{ use super::event_parse::{EventEnumDecl, EventEnumEntry, EventKind};
event_parse::{EventEnumDecl, EventEnumEntry, EventKind, EventKindVariation},
util::is_non_stripped_room_event,
};
use crate::util::m_prefix_name_to_type_name; use crate::util::m_prefix_name_to_type_name;
type EventKindFn = fn(EventKind, EventKindVariation) -> bool; /// Custom keywords for the `event_enum!` macro
mod kw {
syn::custom_keyword!(kind);
syn::custom_keyword!(events);
}
pub(crate) fn is_non_stripped_room_event(kind: EventKind, var: EventEnumVariation) -> bool {
matches!(kind, EventKind::MessageLike | EventKind::State)
&& matches!(var, EventEnumVariation::None | EventEnumVariation::Sync)
}
type EventKindFn = fn(EventKind, EventEnumVariation) -> bool;
/// This const is used to generate the accessor methods for the `Any*Event` enums. /// This const is used to generate the accessor methods for the `Any*Event` enums.
/// ///
@ -20,24 +30,19 @@ const EVENT_FIELDS: &[(&str, EventKindFn)] = &[
("origin_server_ts", is_non_stripped_room_event), ("origin_server_ts", is_non_stripped_room_event),
("room_id", |kind, var| { ("room_id", |kind, var| {
matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::Ephemeral) matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::Ephemeral)
&& matches!( && matches!(var, EventEnumVariation::None)
var,
EventKindVariation::None
| EventKindVariation::Original
| EventKindVariation::Redacted
)
}), }),
("event_id", is_non_stripped_room_event), ("event_id", is_non_stripped_room_event),
("sender", |kind, var| { ("sender", |kind, var| {
matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::ToDevice) matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::ToDevice)
&& var != EventKindVariation::Initial && var != EventEnumVariation::Initial
}), }),
("state_key", |kind, _| matches!(kind, EventKind::State)), ("state_key", |kind, _| matches!(kind, EventKind::State)),
]; ];
/// Create a content enum from `EventEnumInput`. /// Create a content enum from `EventEnumInput`.
pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> { pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
use EventKindVariation as V; use EventEnumVariation as V;
let ruma_common = crate::import_ruma_common(); let ruma_common = crate::import_ruma_common();
@ -54,51 +59,30 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
let ruma_common = &ruma_common; let ruma_common = &ruma_common;
res.extend(expand_content_enum(kind, events, attrs, variants, ruma_common)); res.extend(expand_content_enum(kind, events, attrs, variants, ruma_common));
res.extend(
expand_event_enum(kind, V::None, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
if matches!(kind, EventKind::MessageLike | EventKind::State) { if matches!(kind, EventKind::MessageLike | EventKind::State) {
res.extend( res.extend(
expand_event_enum(kind, V::Original, events, attrs, variants, ruma_common) expand_event_enum(kind, V::Sync, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error), .unwrap_or_else(syn::Error::into_compile_error),
); );
res.extend( res.extend(
expand_event_enum(kind, V::OriginalSync, events, attrs, variants, ruma_common) expand_redact(kind, V::None, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error), .unwrap_or_else(syn::Error::into_compile_error),
); );
res.extend( res.extend(
expand_event_enum(kind, V::Redacted, events, attrs, variants, ruma_common) expand_redact(kind, V::Sync, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error), .unwrap_or_else(syn::Error::into_compile_error),
); );
res.extend( res.extend(
expand_event_enum(kind, V::RedactedSync, events, attrs, variants, ruma_common) expand_from_full_event(kind, V::None, variants)
.unwrap_or_else(syn::Error::into_compile_error), .unwrap_or_else(syn::Error::into_compile_error),
); );
res.extend( res.extend(
expand_redact(kind, V::Original, variants, ruma_common) expand_into_full_event(kind, V::Sync, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_redact(kind, V::OriginalSync, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_from_full_event(kind, V::Original, variants)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_into_full_event(kind, V::OriginalSync, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_from_full_event(kind, V::Redacted, variants)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_into_full_event(kind, V::RedactedSync, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
} else {
res.extend(
expand_event_enum(kind, V::None, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error), .unwrap_or_else(syn::Error::into_compile_error),
); );
} }
@ -126,14 +110,14 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
fn expand_event_enum( fn expand_event_enum(
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
events: &[LitStr], events: &[LitStr],
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_common: &TokenStream, ruma_common: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let event_struct = kind.to_event_ident(var)?; let event_struct = kind.to_event_ident(var.into())?;
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var.into())?;
let variant_decls = variants.iter().map(|v| v.decl()); let variant_decls = variants.iter().map(|v| v.decl());
let content: Vec<_> = let content: Vec<_> =
@ -170,7 +154,7 @@ fn expand_event_enum(
fn expand_deserialize_impl( fn expand_deserialize_impl(
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
events: &[LitStr], events: &[LitStr],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_common: &TokenStream, ruma_common: &TokenStream,
@ -178,7 +162,7 @@ fn expand_deserialize_impl(
let serde = quote! { #ruma_common::exports::serde }; let serde = quote! { #ruma_common::exports::serde };
let serde_json = quote! { #ruma_common::exports::serde_json }; let serde_json = quote! { #ruma_common::exports::serde_json };
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var.into())?;
let variant_attrs = variants.iter().map(|v| { let variant_attrs = variants.iter().map(|v| {
let attrs = &v.attrs; let attrs = &v.attrs;
@ -242,11 +226,11 @@ fn expand_from_impl(
fn expand_from_full_event( fn expand_from_full_event(
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var.into())?;
let sync = kind.to_event_enum_ident(var.to_sync())?; let sync = kind.to_event_enum_ident(var.to_sync().into())?;
let ident_variants = variants.iter().map(|v| v.match_arm(&ident)); let ident_variants = variants.iter().map(|v| v.match_arm(&ident));
let self_variants = variants.iter().map(|v| v.ctor(quote! { Self })); let self_variants = variants.iter().map(|v| v.ctor(quote! { Self }));
@ -272,12 +256,12 @@ fn expand_from_full_event(
fn expand_into_full_event( fn expand_into_full_event(
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_common: &TokenStream, ruma_common: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var.into())?;
let full = kind.to_event_enum_ident(var.to_full())?; let full = kind.to_event_enum_ident(var.to_full().into())?;
let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self })); let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self }));
let full_variants = variants.iter().map(|v| v.ctor(&full)); let full_variants = variants.iter().map(|v| v.ctor(&full));
@ -398,33 +382,32 @@ fn expand_content_enum(
fn expand_redact( fn expand_redact(
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_common: &TokenStream, ruma_common: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var.into())?;
let redacted_enum = kind.to_event_enum_ident(var.to_redacted())?;
let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self })); let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self }));
let redacted_variants = variants.iter().map(|v| v.ctor(&redacted_enum)); let redacted_variants = variants.iter().map(|v| v.ctor(&ident));
Ok(quote! { Ok(quote! {
#[automatically_derived] #[automatically_derived]
impl #ruma_common::events::Redact for #ident { impl #ruma_common::events::Redact for #ident {
type Redacted = #redacted_enum; type Redacted = Self;
fn redact( fn redact(
self, self,
redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent, redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
version: &#ruma_common::RoomVersionId, version: &#ruma_common::RoomVersionId,
) -> #redacted_enum { ) -> Self {
match self { match self {
#( #(
#self_variants(event) => #redacted_variants( #self_variants(event) => #redacted_variants(
#ruma_common::events::Redact::redact(event, redaction, version), #ruma_common::events::Redact::redact(event, redaction, version),
), ),
)* )*
Self::_Custom(event) => #redacted_enum::_Custom( Self::_Custom(event) => Self::_Custom(
#ruma_common::events::Redact::redact(event, redaction, version), #ruma_common::events::Redact::redact(event, redaction, version),
) )
} }
@ -435,15 +418,33 @@ fn expand_redact(
fn expand_accessor_methods( fn expand_accessor_methods(
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
ruma_common: &TokenStream, ruma_common: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var.into())?;
let event_type_enum = format_ident!("{}Type", kind); let event_type_enum = format_ident!("{}Type", kind);
let self_variants: Vec<_> = variants.iter().map(|v| v.match_arm(quote! { Self })).collect(); let self_variants: Vec<_> = variants.iter().map(|v| v.match_arm(quote! { Self })).collect();
let content_accessors = (!kind.is_room()).then(|| { let maybe_redacted =
kind.is_room() && matches!(var, EventEnumVariation::None | EventEnumVariation::Sync);
let event_type_match_arms = if maybe_redacted {
quote! {
#( #self_variants(event) => event.event_type(), )*
Self::_Custom(event) => event.event_type(),
}
} else {
quote! {
#( #self_variants(event) =>
#ruma_common::events::EventContent::event_type(&event.content), )*
Self::_Custom(event) => ::std::convert::From::from(
#ruma_common::events::EventContent::event_type(&event.content),
),
}
};
let content_accessors = (!maybe_redacted).then(|| {
let content_enum = kind.to_content_enum(); let content_enum = kind.to_content_enum();
let content_variants: Vec<_> = variants.iter().map(|v| v.ctor(&content_enum)).collect(); let content_variants: Vec<_> = variants.iter().map(|v| v.ctor(&content_enum)).collect();
@ -468,17 +469,18 @@ fn expand_accessor_methods(
let methods = EVENT_FIELDS.iter().map(|(name, has_field)| { let methods = EVENT_FIELDS.iter().map(|(name, has_field)| {
has_field(kind, var).then(|| { has_field(kind, var).then(|| {
let docs = format!("Returns this event's {} field.", name); let docs = format!("Returns this event's `{}` field.", name);
let ident = Ident::new(name, Span::call_site()); let ident = Ident::new(name, Span::call_site());
let field_type = field_return_type(name, var, ruma_common); let field_type = field_return_type(name, ruma_common);
let variants = variants.iter().map(|v| v.match_arm(quote! { Self })); let variants = variants.iter().map(|v| v.match_arm(quote! { Self }));
let call_parens = maybe_redacted.then(|| quote! { () });
quote! { quote! {
#[doc = #docs] #[doc = #docs]
pub fn #ident(&self) -> &#field_type { pub fn #ident(&self) -> &#field_type {
match self { match self {
#( #variants(event) => &event.#ident, )* #( #variants(event) => &event.#ident #call_parens, )*
Self::_Custom(event) => &event.#ident, Self::_Custom(event) => &event.#ident #call_parens,
} }
} }
} }
@ -490,17 +492,10 @@ fn expand_accessor_methods(
impl #ident { impl #ident {
/// Returns the `type` of this event. /// Returns the `type` of this event.
pub fn event_type(&self) -> #ruma_common::events::#event_type_enum { pub fn event_type(&self) -> #ruma_common::events::#event_type_enum {
match self { match self { #event_type_match_arms }
#( #self_variants(event) =>
#ruma_common::events::EventContent::event_type(&event.content), )*
Self::_Custom(event) => ::std::convert::From::from(
#ruma_common::events::EventContent::event_type(&event.content),
),
}
} }
#content_accessors #content_accessors
#( #methods )* #( #methods )*
} }
}) })
@ -509,13 +504,13 @@ fn expand_accessor_methods(
fn to_event_path( fn to_event_path(
name: &LitStr, name: &LitStr,
kind: EventKind, kind: EventKind,
var: EventKindVariation, var: EventEnumVariation,
ruma_common: &TokenStream, ruma_common: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let path = event_module_path(name); let path = event_module_path(name);
let event = m_prefix_name_to_type_name(name).unwrap(); let event = m_prefix_name_to_type_name(name).unwrap();
let event_name = if kind == EventKind::ToDevice { let event_name = if kind == EventKind::ToDevice {
assert_eq!(var, EventKindVariation::None); assert_eq!(var, EventEnumVariation::None);
format_ident!("ToDevice{}Event", event) format_ident!("ToDevice{}Event", event)
} else { } else {
format_ident!("{}{}Event", var, event) format_ident!("{}{}Event", var, event)
@ -554,24 +549,13 @@ fn event_module_path(name: &LitStr) -> Vec<Ident> {
.collect() .collect()
} }
fn field_return_type( fn field_return_type(name: &str, ruma_common: &TokenStream) -> TokenStream {
name: &str,
var: EventKindVariation,
ruma_common: &TokenStream,
) -> TokenStream {
match name { match name {
"origin_server_ts" => quote! { #ruma_common::MilliSecondsSinceUnixEpoch }, "origin_server_ts" => quote! { #ruma_common::MilliSecondsSinceUnixEpoch },
"room_id" => quote! { #ruma_common::RoomId }, "room_id" => quote! { #ruma_common::RoomId },
"event_id" => quote! { #ruma_common::EventId }, "event_id" => quote! { #ruma_common::EventId },
"sender" => quote! { #ruma_common::UserId }, "sender" => quote! { #ruma_common::UserId },
"state_key" => quote! { ::std::primitive::str }, "state_key" => quote! { ::std::primitive::str },
"unsigned" => {
if var.is_redacted() {
quote! { #ruma_common::events::RedactedUnsigned }
} else {
quote! { #ruma_common::events::MessageLikeUnsigned }
}
}
_ => panic!("the `ruma_macros::event_enum::EVENT_FIELD` const was changed"), _ => panic!("the `ruma_macros::event_enum::EVENT_FIELD` const was changed"),
} }
} }
@ -655,3 +639,51 @@ pub(crate) fn expand_from_impls_derived(input: DeriveInput) -> TokenStream {
#( #from_impls )* #( #from_impls )*
} }
} }
// If the variants of this enum change `to_event_path` needs to be updated as well.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EventEnumVariation {
None,
Sync,
Stripped,
Initial,
}
impl From<EventEnumVariation> for crate::events::event_parse::EventKindVariation {
fn from(v: EventEnumVariation) -> Self {
match v {
EventEnumVariation::None => Self::None,
EventEnumVariation::Sync => Self::Sync,
EventEnumVariation::Stripped => Self::Stripped,
EventEnumVariation::Initial => Self::Initial,
}
}
}
// FIXME: Duplicated with the other EventKindVariation type
impl EventEnumVariation {
pub fn to_sync(self) -> Self {
match self {
EventEnumVariation::None => EventEnumVariation::Sync,
_ => panic!("No sync form of {:?}", self),
}
}
pub fn to_full(self) -> Self {
match self {
EventEnumVariation::Sync => EventEnumVariation::None,
_ => panic!("No full form of {:?}", self),
}
}
}
impl IdentFragment for EventEnumVariation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
EventEnumVariation::None => write!(f, ""),
EventEnumVariation::Sync => write!(f, "Sync"),
EventEnumVariation::Stripped => write!(f, "Stripped"),
EventEnumVariation::Initial => write!(f, "Initial"),
}
}
}

21
crates/ruma-macros/src/events/event_parse.rs
View File

@ -61,14 +61,6 @@ impl EventKindVariation {
} }
} }
pub fn to_sync(self) -> Self {
match self {
EventKindVariation::Original => EventKindVariation::OriginalSync,
EventKindVariation::Redacted => EventKindVariation::RedactedSync,
_ => panic!("No sync form of {:?}", self),
}
}
pub fn to_full(self) -> Self { pub fn to_full(self) -> Self {
match self { match self {
EventKindVariation::OriginalSync => EventKindVariation::Original, EventKindVariation::OriginalSync => EventKindVariation::Original,
@ -135,17 +127,8 @@ impl EventKind {
use EventKindVariation as V; use EventKindVariation as V;
match (self, var) { match (self, var) {
( (_, V::None)
Self::GlobalAccountData | (Self::Ephemeral | Self::MessageLike | Self::State, V::Sync)
| Self::RoomAccountData
| Self::Ephemeral
| Self::ToDevice
| Self::Presence
| Self::HierarchySpaceChild
| Self::Decrypted,
V::None,
)
| (Self::Ephemeral, V::Sync)
| ( | (
Self::MessageLike | Self::RoomRedaction | Self::State, Self::MessageLike | Self::RoomRedaction | Self::State,
V::Original | V::OriginalSync | V::Redacted | V::RedactedSync, V::Original | V::OriginalSync | V::Redacted | V::RedactedSync,

16
crates/ruma-state-res/benches/state_res_bench.rs
View File

@ -18,7 +18,7 @@ use std::{
}; };
use criterion::{criterion_group, criterion_main, Criterion}; use criterion::{criterion_group, criterion_main, Criterion};
use event::OriginalStateEvent; use event::PduEvent;
use js_int::{int, uint}; use js_int::{int, uint};
use maplit::{btreemap, hashmap, hashset}; use maplit::{btreemap, hashmap, hashset};
use ruma_common::{ use ruma_common::{
@ -232,7 +232,7 @@ impl<E: Event> TestStore<E> {
} }
} }
impl TestStore<OriginalStateEvent> { impl TestStore<PduEvent> {
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
fn set_up( fn set_up(
&mut self, &mut self,
@ -372,7 +372,7 @@ fn to_pdu_event<S>(
content: Box<RawJsonValue>, content: Box<RawJsonValue>,
auth_events: &[S], auth_events: &[S],
prev_events: &[S], prev_events: &[S],
) -> Arc<OriginalStateEvent> ) -> Arc<PduEvent>
where where
S: AsRef<str>, S: AsRef<str>,
{ {
@ -384,7 +384,7 @@ where
let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>(); let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
let state_key = state_key.map(ToOwned::to_owned); let state_key = state_key.map(ToOwned::to_owned);
Arc::new(OriginalStateEvent { Arc::new(PduEvent {
event_id: id.try_into().unwrap(), event_id: id.try_into().unwrap(),
rest: Pdu::RoomV3Pdu(RoomV3Pdu { rest: Pdu::RoomV3Pdu(RoomV3Pdu {
room_id: room_id().to_owned(), room_id: room_id().to_owned(),
@ -406,7 +406,7 @@ where
// all graphs start with these input events // all graphs start with these input events
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> { fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![ vec![
to_pdu_event::<&EventId>( to_pdu_event::<&EventId>(
"CREATE", "CREATE",
@ -488,7 +488,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
// all graphs start with these input events // all graphs start with these input events
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> { fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![ vec![
to_pdu_event( to_pdu_event(
"PA", "PA",
@ -541,7 +541,7 @@ mod event {
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use serde_json::value::RawValue as RawJsonValue; use serde_json::value::RawValue as RawJsonValue;
impl Event for OriginalStateEvent { impl Event for PduEvent {
type Id = Box<EventId>; type Id = Box<EventId>;
fn event_id(&self) -> &Self::Id { fn event_id(&self) -> &Self::Id {
@ -631,7 +631,7 @@ mod event {
} }
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub struct OriginalStateEvent { pub struct PduEvent {
pub event_id: Box<EventId>, pub event_id: Box<EventId>,
#[serde(flatten)] #[serde(flatten)]
pub rest: Pdu, pub rest: Pdu,

16
crates/ruma-state-res/src/event_auth.rs
View File

@ -982,7 +982,7 @@ mod tests {
event_auth::valid_membership_change, event_auth::valid_membership_change,
test_utils::{ test_utils::{
alice, charlie, ella, event_id, member_content_ban, member_content_join, room_id, alice, charlie, ella, event_id, member_content_ban, member_content_join, room_id,
to_pdu_event, OriginalStateEvent, INITIAL_EVENTS, INITIAL_EVENTS_CREATE_ROOM, to_pdu_event, PduEvent, INITIAL_EVENTS, INITIAL_EVENTS_CREATE_ROOM,
}, },
Event, RoomVersion, StateMap, Event, RoomVersion, StateMap,
}; };
@ -1021,7 +1021,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
@ -1065,7 +1065,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
@ -1109,7 +1109,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
@ -1153,7 +1153,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,
@ -1214,7 +1214,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&alice()), Some(&alice()),
@ -1230,7 +1230,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&ella()), Some(&ella()),
@ -1283,7 +1283,7 @@ mod tests {
&sender, &sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()), fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester, &requester,
None::<OriginalStateEvent>, None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()), fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()), fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None, None,

9
crates/ruma-state-res/src/lib.rs
View File

@ -657,8 +657,7 @@ mod tests {
room_version::RoomVersion, room_version::RoomVersion,
test_utils::{ test_utils::{
alice, bob, charlie, do_check, ella, event_id, member_content_ban, member_content_join, alice, bob, charlie, do_check, ella, event_id, member_content_ban, member_content_join,
room_id, to_init_pdu_event, to_pdu_event, zara, OriginalStateEvent, TestStore, room_id, to_init_pdu_event, to_pdu_event, zara, PduEvent, TestStore, INITIAL_EVENTS,
INITIAL_EVENTS,
}, },
Event, StateMap, Event, StateMap,
}; };
@ -1043,7 +1042,7 @@ mod tests {
let _ = let _ =
tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish()); tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
let mut store = TestStore::<OriginalStateEvent>(hashmap! {}); let mut store = TestStore::<PduEvent>(hashmap! {});
// build up the DAG // build up the DAG
let (state_at_bob, state_at_charlie, expected) = store.set_up(); let (state_at_bob, state_at_charlie, expected) = store.set_up();
@ -1209,7 +1208,7 @@ mod tests {
} }
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> { fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![ vec![
to_pdu_event( to_pdu_event(
"PA", "PA",
@ -1254,7 +1253,7 @@ mod tests {
} }
#[allow(non_snake_case)] #[allow(non_snake_case)]
fn JOIN_RULE() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> { fn JOIN_RULE() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![ vec![
to_pdu_event( to_pdu_event(
"JR", "JR",

35
crates/ruma-state-res/src/test_utils.rs
View File

@ -29,12 +29,12 @@ use tracing::info;
use crate::{auth_types_for_event, Error, Event, Result, StateMap}; use crate::{auth_types_for_event, Error, Event, Result, StateMap};
pub use event::OriginalStateEvent; pub use event::PduEvent;
static SERVER_TIMESTAMP: AtomicU64 = AtomicU64::new(0); static SERVER_TIMESTAMP: AtomicU64 = AtomicU64::new(0);
pub fn do_check( pub fn do_check(
events: &[Arc<OriginalStateEvent>], events: &[Arc<PduEvent>],
edges: Vec<Vec<Box<EventId>>>, edges: Vec<Vec<Box<EventId>>>,
expected_state_ids: Vec<Box<EventId>>, expected_state_ids: Vec<Box<EventId>>,
) { ) {
@ -77,7 +77,7 @@ pub fn do_check(
} }
// event_id -> OriginalStateEvent // event_id -> OriginalStateEvent
let mut event_map: HashMap<Box<EventId>, Arc<OriginalStateEvent>> = HashMap::new(); let mut event_map: HashMap<Box<EventId>, Arc<PduEvent>> = HashMap::new();
// event_id -> StateMap<Box<EventId>> // event_id -> StateMap<Box<EventId>>
let mut state_at_event: HashMap<Box<EventId>, StateMap<Box<EventId>>> = HashMap::new(); let mut state_at_event: HashMap<Box<EventId>, StateMap<Box<EventId>>> = HashMap::new();
@ -245,7 +245,7 @@ impl<E: Event> TestStore<E> {
// A StateStore implementation for testing // A StateStore implementation for testing
#[allow(clippy::type_complexity)] #[allow(clippy::type_complexity)]
impl TestStore<OriginalStateEvent> { impl TestStore<PduEvent> {
pub fn set_up( pub fn set_up(
&mut self, &mut self,
) -> (StateMap<Box<EventId>>, StateMap<Box<EventId>>, StateMap<Box<EventId>>) { ) -> (StateMap<Box<EventId>>, StateMap<Box<EventId>>, StateMap<Box<EventId>>) {
@ -387,12 +387,12 @@ pub fn to_init_pdu_event(
ev_type: RoomEventType, ev_type: RoomEventType,
state_key: Option<&str>, state_key: Option<&str>,
content: Box<RawJsonValue>, content: Box<RawJsonValue>,
) -> Arc<OriginalStateEvent> { ) -> Arc<PduEvent> {
let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst); let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) }; let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
let state_key = state_key.map(ToOwned::to_owned); let state_key = state_key.map(ToOwned::to_owned);
Arc::new(OriginalStateEvent { Arc::new(PduEvent {
event_id: id.try_into().unwrap(), event_id: id.try_into().unwrap(),
rest: Pdu::RoomV3Pdu(RoomV3Pdu { rest: Pdu::RoomV3Pdu(RoomV3Pdu {
room_id: room_id().to_owned(), room_id: room_id().to_owned(),
@ -420,7 +420,7 @@ pub fn to_pdu_event<S>(
content: Box<RawJsonValue>, content: Box<RawJsonValue>,
auth_events: &[S], auth_events: &[S],
prev_events: &[S], prev_events: &[S],
) -> Arc<OriginalStateEvent> ) -> Arc<PduEvent>
where where
S: AsRef<str>, S: AsRef<str>,
{ {
@ -430,7 +430,7 @@ where
let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>(); let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
let state_key = state_key.map(ToOwned::to_owned); let state_key = state_key.map(ToOwned::to_owned);
Arc::new(OriginalStateEvent { Arc::new(PduEvent {
event_id: id.try_into().unwrap(), event_id: id.try_into().unwrap(),
rest: Pdu::RoomV3Pdu(RoomV3Pdu { rest: Pdu::RoomV3Pdu(RoomV3Pdu {
room_id: room_id().to_owned(), room_id: room_id().to_owned(),
@ -452,7 +452,7 @@ where
// all graphs start with these input events // all graphs start with these input events
#[allow(non_snake_case)] #[allow(non_snake_case)]
pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> { pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![ vec![
to_pdu_event::<&EventId>( to_pdu_event::<&EventId>(
"CREATE", "CREATE",
@ -534,7 +534,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
// all graphs start with these input events // all graphs start with these input events
#[allow(non_snake_case)] #[allow(non_snake_case)]
pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> { pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![to_pdu_event::<&EventId>( vec![to_pdu_event::<&EventId>(
"CREATE", "CREATE",
alice(), alice(),
@ -567,7 +567,7 @@ pub mod event {
use crate::Event; use crate::Event;
impl Event for OriginalStateEvent { impl Event for PduEvent {
type Id = Box<EventId>; type Id = Box<EventId>;
fn event_id(&self) -> &Self::Id { fn event_id(&self) -> &Self::Id {
@ -658,20 +658,9 @@ pub mod event {
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
#[allow(clippy::exhaustive_structs)] #[allow(clippy::exhaustive_structs)]
pub struct OriginalStateEvent { pub struct PduEvent {
pub event_id: Box<EventId>, pub event_id: Box<EventId>,
#[serde(flatten)] #[serde(flatten)]
pub rest: Pdu, pub rest: Pdu,
} }
//impl OriginalStateEvent {
// pub fn state_key(&self) -> &str {
// match &self.rest {
// Pdu::RoomV1Pdu(ev) => ev.state_key.as_ref().unwrap(),
// Pdu::RoomV3Pdu(ev) => ev.state_key.as_ref().unwrap(),
// #[cfg(not(feature = "unstable-exhaustive-types"))]
// _ => unreachable!("new PDU version"),
// }
// }
//}
} }

8
examples/joke_bot/src/main.rs
View File

@ -9,7 +9,7 @@ use ruma::{
assign, client, assign, client,
events::{ events::{
room::message::{MessageType, RoomMessageEventContent}, room::message::{MessageType, RoomMessageEventContent},
AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent, AnySyncMessageLikeEvent, AnySyncRoomEvent, SyncMessageLikeEvent,
}, },
presence::PresenceState, presence::PresenceState,
serde::Raw, serde::Raw,
@ -146,9 +146,9 @@ async fn handle_message(
room_id: &RoomId, room_id: &RoomId,
bot_user_id: &UserId, bot_user_id: &UserId,
) -> Result<(), Box<dyn Error>> { ) -> Result<(), Box<dyn Error>> {
if let Ok(AnySyncRoomEvent::OriginalMessageLike( if let Ok(AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
AnyOriginalSyncMessageLikeEvent::RoomMessage(m), SyncMessageLikeEvent::Original(m),
)) = e.deserialize() ))) = e.deserialize()
{ {
// workaround because Conduit does not implement filtering. // workaround because Conduit does not implement filtering.
if m.sender == bot_user_id { if m.sender == bot_user_id {

9
examples/message_log/src/main.rs
View File

@ -5,7 +5,8 @@ use ruma::{
api::client::{filter::FilterDefinition, sync::sync_events}, api::client::{filter::FilterDefinition, sync::sync_events},
events::{ events::{
room::message::{MessageType, RoomMessageEventContent, TextMessageEventContent}, room::message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent, OriginalSyncMessageLikeEvent, AnySyncMessageLikeEvent, AnySyncRoomEvent, OriginalSyncMessageLikeEvent,
SyncMessageLikeEvent,
}, },
presence::PresenceState, presence::PresenceState,
}; };
@ -42,8 +43,8 @@ async fn log_messages(
for (room_id, room) in res.rooms.join { for (room_id, room) in res.rooms.join {
for event in room.timeline.events.into_iter().flat_map(|r| r.deserialize()) { for event in room.timeline.events.into_iter().flat_map(|r| r.deserialize()) {
// Filter out the text messages // Filter out the text messages
if let AnySyncRoomEvent::OriginalMessageLike( if let AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent { SyncMessageLikeEvent::Original(OriginalSyncMessageLikeEvent {
content: content:
RoomMessageEventContent { RoomMessageEventContent {
msgtype: msgtype:
@ -55,7 +56,7 @@ async fn log_messages(
sender, sender,
.. ..
}), }),
) = event )) = event
{ {
println!("{:?} in {:?}: {}", sender, room_id, msg_body); println!("{:?} in {:?}: {}", sender, room_id, msg_body);
} }