chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions 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 ruma_common::{
api::ruma_api,
events::{AnyOriginalStateEvent, AnyRoomEvent},
events::{AnyRoomEvent, AnyStateEvent},
serde::Raw,
EventId, RoomId,
};
@ -79,7 +79,7 @@ pub mod v3 {
/// The state of the room at the last event returned.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub state: Vec<Raw<AnyOriginalStateEvent>>,
pub state: Vec<Raw<AnyStateEvent>>,
}
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 ruma_common::{
api::ruma_api,
events::{AnyOriginalStateEvent, AnyRoomEvent},
events::{AnyRoomEvent, AnyStateEvent},
serde::Raw,
RoomId,
};
@ -96,7 +96,7 @@ pub mod v3 {
/// A list of state events relevant to showing the `chunk`.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub state: Vec<Raw<AnyOriginalStateEvent>>,
pub state: Vec<Raw<AnyStateEvent>>,
}
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 ruma_common::{
api::ruma_api,
events::{AnyOriginalStateEvent, AnyRoomEvent},
events::{AnyRoomEvent, AnyStateEvent},
serde::{Incoming, Raw, StringEnum},
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`.
#[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
/// 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
use ruma_common::{api::ruma_api, events::AnyOriginalStateEvent, serde::Raw, RoomId};
use ruma_common::{api::ruma_api, events::AnyStateEvent, serde::Raw, RoomId};
ruma_api! {
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
/// a list of events.
#[ruma_api(body)]
pub room_state: Vec<Raw<AnyOriginalStateEvent>>,
pub room_state: Vec<Raw<AnyStateEvent>>,
}
error: crate::Error
@ -47,7 +47,7 @@ pub mod v3 {
impl Response {
/// 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 }
}
}

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

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

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

@ -11,7 +11,7 @@
use criterion::{criterion_group, criterion_main, Criterion};
use ruma_common::{
events::{
room::power_levels::RoomPowerLevelsEventContent, AnyOriginalStateEvent, AnyRoomEvent,
room::power_levels::RoomPowerLevelsEventContent, AnyRoomEvent, AnyStateEvent,
OriginalStateEvent,
},
serde::Raw,
@ -66,9 +66,9 @@ fn deserialize_any_room_event(c: &mut Criterion) {
fn deserialize_any_state_event(c: &mut Criterion) {
let json_data = power_levels();
c.bench_function("deserialize to `AnyOriginalStateEvent`", |b| {
c.bench_function("deserialize to `AnyStateEvent`", |b| {
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 self::room::redaction::OriginalSyncRoomRedactionEvent;
use self::room::redaction::SyncRoomRedactionEvent;
use crate::{EventEncryptionAlgorithm, RoomVersionId};
// 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
/// be specified.
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> Self::Redacted;
fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted;
}
/// 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.
///
/// This trait's associated functions and methods should not be used to build
/// redacted events, prefer the `redact` method on `AnyOriginalStateEvent` and
/// `AnyOriginalMessageLikeEvent` and their "sync" and "stripped" counterparts.
/// redacted events, prefer the `redact` method on `AnyStateEvent` and
/// `AnyMessageLikeEvent` and their "sync" and "stripped" counterparts.
/// The `RedactedEventContent` trait is an implementation detail, ruma makes no
/// API guarantees.
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::{
key,
room::{encrypted, redaction::OriginalSyncRoomRedactionEvent},
Redact, UnsignedDeHelper,
room::{encrypted, redaction::SyncRoomRedactionEvent},
Redact,
};
use crate::{
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.")]
pub fn $field(&self) -> $ty {
match self {
Self::OriginalMessageLike(ev) => ev.$field(),
Self::OriginalState(ev) => ev.$field(),
Self::RedactedMessageLike(ev) => ev.$field(),
Self::RedactedState(ev) => ev.$field(),
Self::MessageLike(ev) => ev.$field(),
Self::State(ev) => ev.$field(),
}
}
}
@ -143,17 +141,11 @@ macro_rules! room_ev_accessor {
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnyRoomEvent {
/// Any message-like event (unredacted).
OriginalMessageLike(AnyOriginalMessageLikeEvent),
/// Any message-like event.
MessageLike(AnyMessageLikeEvent),
/// Any state event (unredacted).
OriginalState(AnyOriginalStateEvent),
/// Any message-like event that has been redacted.
RedactedMessageLike(AnyRedactedMessageLikeEvent),
/// Any state event that has been redacted.
RedactedState(AnyRedactedStateEvent),
/// Any state event.
State(AnyStateEvent),
}
impl AnyRoomEvent {
@ -169,17 +161,11 @@ impl AnyRoomEvent {
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnySyncRoomEvent {
/// Any sync message-like event (unredacted).
OriginalMessageLike(AnyOriginalSyncMessageLikeEvent),
/// Any sync message-like event.
MessageLike(AnySyncMessageLikeEvent),
/// Any sync state event (unredacted).
OriginalState(AnyOriginalSyncStateEvent),
/// Any sync message-like event that has been redacted.
RedactedMessageLike(AnyRedactedSyncMessageLikeEvent),
/// Any sync state event that has been redacted.
RedactedState(AnyRedactedSyncStateEvent),
/// Any sync state event.
State(AnySyncStateEvent),
}
impl AnySyncRoomEvent {
@ -190,14 +176,8 @@ impl AnySyncRoomEvent {
/// Converts `self` to an `AnyRoomEvent` by adding the given a room ID.
pub fn into_full_event(self, room_id: Box<RoomId>) -> AnyRoomEvent {
match self {
Self::OriginalMessageLike(ev) => {
AnyRoomEvent::OriginalMessageLike(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)),
Self::MessageLike(ev) => AnyRoomEvent::MessageLike(ev.into_full_event(room_id)),
Self::State(ev) => AnyRoomEvent::State(ev.into_full_event(room_id)),
}
}
}
@ -206,7 +186,6 @@ impl AnySyncRoomEvent {
#[allow(clippy::exhaustive_structs)]
struct EventDeHelper {
pub state_key: Option<de::IgnoredAny>,
pub unsigned: Option<UnsignedDeHelper>,
}
impl<'de> Deserialize<'de> for AnyRoomEvent {
@ -215,22 +194,12 @@ impl<'de> Deserialize<'de> for AnyRoomEvent {
D: de::Deserializer<'de>,
{
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() {
Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnyRoomEvent::OriginalState(from_raw_json_value(&json)?),
})
Ok(AnyRoomEvent::State(from_raw_json_value(&json)?))
} else {
Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEvent::RedactedMessageLike(from_raw_json_value(&json)?)
}
_ => AnyRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
})
Ok(AnyRoomEvent::MessageLike(from_raw_json_value(&json)?))
}
}
}
@ -241,108 +210,40 @@ impl<'de> Deserialize<'de> for AnySyncRoomEvent {
D: de::Deserializer<'de>,
{
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() {
Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnySyncRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnySyncRoomEvent::OriginalState(from_raw_json_value(&json)?),
})
Ok(AnySyncRoomEvent::State(from_raw_json_value(&json)?))
} else {
Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnySyncRoomEvent::RedactedMessageLike(from_raw_json_value(&json)?)
}
_ => AnySyncRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
})
Ok(AnySyncRoomEvent::MessageLike(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 {
type Redacted = AnyRedactedRoomEvent;
type Redacted = Self;
/// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
///
/// Does nothing for events that are already redacted.
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> Self::Redacted {
fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self {
match self {
Self::OriginalMessageLike(ev) => {
AnyRedactedRoomEvent::MessageLike(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),
Self::MessageLike(ev) => Self::MessageLike(ev.redact(redaction, version)),
Self::State(ev) => Self::State(ev.redact(redaction, version)),
}
}
}
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 {
type Redacted = AnyRedactedSyncRoomEvent;
type Redacted = Self;
/// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
///
/// Does nothing for events that are already redacted.
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> AnyRedactedSyncRoomEvent {
fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self {
match self {
Self::OriginalMessageLike(ev) => {
AnyRedactedSyncRoomEvent::MessageLike(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),
Self::MessageLike(ev) => Self::MessageLike(ev.redact(redaction, version)),
Self::State(ev) => Self::State(ev.redact(redaction, version)),
}
}
}

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 super::{
EphemeralRoomEventContent, EventContent, GlobalAccountDataEventContent,
MessageLikeEventContent, MessageLikeEventType, MessageLikeUnsigned, RedactContent,
RedactedEventContent, RedactedMessageLikeEventContent, RedactedStateEventContent,
RedactedUnsigned, RedactionDeHelper, RoomAccountDataEventContent, StateEventContent,
StateEventType, StateUnsigned, ToDeviceEventContent,
room::redaction::SyncRoomRedactionEvent, EphemeralRoomEventContent, EventContent,
GlobalAccountDataEventContent, MessageLikeEventContent, MessageLikeEventType,
MessageLikeUnsigned, Redact, RedactContent, RedactedEventContent,
RedactedMessageLikeEventContent, RedactedStateEventContent, RedactedUnsigned,
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.
#[derive(Clone, Debug, Event)]
@ -449,6 +452,21 @@ macro_rules! impl_possibly_redacted_event {
$($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>
where
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 serde::{Deserialize, Serialize};
use super::AnyOriginalSyncMessageLikeEvent;
use super::AnySyncMessageLikeEvent;
use crate::{serde::Raw, EventId, MilliSecondsSinceUnixEpoch, UserId};
/// 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)]
pub struct BundledThread {
/// 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.
pub count: UInt,
@ -111,7 +111,7 @@ pub struct BundledThread {
impl BundledThread {
/// Creates a new `BundledThread` with the given event, count and user participated flag.
pub fn new(
latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>,
latest_event: Box<Raw<AnySyncMessageLikeEvent>>,
count: UInt,
current_user_participated: bool,
) -> 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
use ruma_macros::{Event, EventContent};
use serde::{Deserialize, Serialize};
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::value::RawValue as RawJsonValue;
use crate::{
events::{MessageLikeUnsigned, Redact, RedactContent, RedactedUnsigned},
events::{
EventContent, MessageLikeEventType, MessageLikeUnsigned, Redact, RedactContent,
RedactedUnsigned, RedactionDeHelper,
},
serde::from_raw_json_value,
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.
#[derive(Clone, Debug, Event)]
#[allow(clippy::exhaustive_structs)]
@ -41,7 +70,7 @@ impl Redact for OriginalRoomRedactionEvent {
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
redaction: SyncRoomRedactionEvent,
version: &crate::RoomVersionId,
) -> Self::Redacted {
RedactedRoomRedactionEvent {
@ -111,7 +140,7 @@ impl Redact for OriginalSyncRoomRedactionEvent {
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
redaction: SyncRoomRedactionEvent,
version: &crate::RoomVersionId,
) -> Self::Redacted {
RedactedSyncRoomRedactionEvent {
@ -170,3 +199,150 @@ impl RoomRedactionEventContent {
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")]
use super::relation::Relations;
use super::{room::redaction::OriginalSyncRoomRedactionEvent, StateEventContent};
use super::{room::redaction::SyncRoomRedactionEvent, StateEventContent};
use crate::{serde::Raw, TransactionId};
/// 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 {
/// The event that redacted this event, if any.
#[serde(skip_serializing_if = "Option::is_none")]
pub redacted_because: Option<Box<OriginalSyncRoomRedactionEvent>>,
pub redacted_because: Option<Box<SyncRoomRedactionEvent>>,
}
impl RedactedUnsigned {
@ -182,7 +182,7 @@ impl RedactedUnsigned {
}
/// 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) }
}

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

@ -17,7 +17,7 @@ use ruma_common::{
},
JsonWebKeyInit, MediaSource,
},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -349,8 +349,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Audio(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Audio(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: AudioEventContent {
message,
file: FileContent {
@ -366,7 +366,7 @@ fn message_event_deserialization() {
room_id,
sender,
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_html().is_none()
&& url == "mxc://notareal.hs/abcdef"

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

@ -1,6 +1,12 @@
use js_int::uint;
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 ruma_common::{
@ -10,12 +16,11 @@ use ruma_common::{
message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
power_levels::RoomPowerLevelsEventContent,
},
AnyEphemeralRoomEvent, AnyOriginalMessageLikeEvent, AnyOriginalStateEvent,
AnyOriginalSyncMessageLikeEvent, AnyOriginalSyncStateEvent, AnyRoomEvent, AnySyncRoomEvent,
EphemeralRoomEventType, GlobalAccountDataEventType, MessageLikeEventType,
MessageLikeUnsigned, OriginalMessageLikeEvent, OriginalStateEvent,
OriginalSyncMessageLikeEvent, OriginalSyncStateEvent, RoomAccountDataEventType,
StateEventType, ToDeviceEventType,
AnyEphemeralRoomEvent, AnyMessageLikeEvent, AnyRoomEvent, AnyStateEvent,
AnySyncMessageLikeEvent, AnySyncRoomEvent, AnySyncStateEvent, EphemeralRoomEventType,
GlobalAccountDataEventType, MessageLikeEventType, MessageLikeUnsigned,
OriginalMessageLikeEvent, OriginalStateEvent, OriginalSyncMessageLikeEvent,
OriginalSyncStateEvent, RoomAccountDataEventType, StateEventType, ToDeviceEventType,
},
MilliSecondsSinceUnixEpoch,
};
@ -124,13 +129,15 @@ fn power_event_sync_deserialization() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::OriginalState(
AnyOriginalSyncStateEvent::RoomPowerLevels(OriginalSyncStateEvent {
content: RoomPowerLevelsEventContent {
ban, ..
Ok(AnySyncRoomEvent::State(
AnySyncStateEvent::RoomPowerLevels(SyncStateEvent::Original(
OriginalSyncStateEvent {
content: RoomPowerLevelsEventContent {
ban, ..
},
..
},
..
})
)),
))
if ban == js_int::Int::new(50).unwrap()
);
@ -142,18 +149,20 @@ fn message_event_sync_deserialization() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::OriginalMessageLike(
AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
formatted: Some(formatted),
Ok(AnySyncRoomEvent::MessageLike(
AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent::Original(
OriginalSyncMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
formatted: Some(formatted),
..
}),
..
}),
},
..
},
..
})
))
))
if body == "baba" && formatted.body == "<strong>baba</strong>"
);
@ -165,14 +174,16 @@ fn aliases_event_sync_deserialization() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::OriginalState(
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
content: RoomAliasesEventContent {
aliases,
Ok(AnySyncRoomEvent::State(
AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(
OriginalSyncStateEvent {
content: RoomAliasesEventContent {
aliases,
..
},
..
},
..
})
))
))
if aliases == vec![ room_alias_id!("#somewhere:localhost") ]
);
@ -184,18 +195,20 @@ fn message_room_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalMessageLike(
AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
formatted: Some(formatted),
Ok(AnyRoomEvent::MessageLike(
AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Original(
OriginalMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
formatted: Some(formatted),
..
}),
..
}),
},
..
},
..
})
))
))
if body == "baba" && formatted.body == "<strong>baba</strong>"
);
@ -231,14 +244,14 @@ fn alias_room_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalState(
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
Ok(AnyRoomEvent::State(
AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
content: RoomAliasesEventContent {
aliases,
..
},
..
})
}))
))
if aliases == vec![ room_alias_id!("#somewhere:localhost") ]
);
@ -250,8 +263,8 @@ fn message_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalMessageLike(
AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent {
Ok(AnyRoomEvent::MessageLike(
AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
@ -261,7 +274,7 @@ fn message_event_deserialization() {
..
},
..
})
}))
))
if body == "baba" && formatted.body == "<strong>baba</strong>"
);
@ -273,14 +286,14 @@ fn alias_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::OriginalState(
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
Ok(AnyRoomEvent::State(
AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
content: RoomAliasesEventContent {
aliases,
..
},
..
})
}))
))
if aliases == vec![ room_alias_id!("#somewhere:localhost") ]
);
@ -292,15 +305,15 @@ fn alias_event_field_access() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data.clone()),
Ok(AnyRoomEvent::OriginalState(state_event))
Ok(AnyRoomEvent::State(state_event))
if state_event.state_key() == ""
&& state_event.room_id() == room_id!("!room:room.com")
&& state_event.event_id() == event_id!("$152037280074GZeOm:localhost")
&& state_event.sender() == user_id!("@example:localhost")
);
let deser = from_json_value::<AnyOriginalStateEvent>(json_data).unwrap();
if let AnyOriginalStateEvent::RoomAliases(ev) = &deser {
let deser = from_json_value::<AnyStateEvent>(json_data).unwrap();
if let AnyStateEvent::RoomAliases(StateEvent::Original(ev)) = &deser {
assert_eq!(ev.content.aliases, vec![room_alias_id!("#somewhere:localhost")])
} else {
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 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 ruma_common::events::{
call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
AnyOriginalMessageLikeEvent, OriginalMessageLikeEvent,
AnyMessageLikeEvent, OriginalMessageLikeEvent,
};
#[test]
@ -35,9 +37,9 @@ fn deserialize_message_event() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data)
from_json_value::<AnyMessageLikeEvent>(json_data)
.unwrap(),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
AnyMessageLikeEvent::CallAnswer(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: CallAnswerEventContent {
answer: SessionDescription {
session_type: SessionDescriptionType::Answer,
@ -53,7 +55,7 @@ fn deserialize_message_event() {
room_id,
sender,
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")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& 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,
},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -225,8 +225,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::File(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::File(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: FileEventContent {
message,
file: FileContent {
@ -241,7 +241,7 @@ fn message_event_deserialization() {
room_id,
sender,
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_html() == Some("Upload: <strong>my_file.txt</strong>")
&& 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,
},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -285,8 +285,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Image(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Image(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: ImageEventContent {
message,
file: FileContent {
@ -304,7 +304,7 @@ fn message_event_deserialization() {
room_id,
sender,
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_html().is_none()
&& url == "mxc://notareal.hs/abcdef"

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

@ -14,7 +14,7 @@ use ruma_common::{
room::message::{
InReplyTo, LocationMessageEventContent, MessageType, Relation, RoomMessageEventContent,
},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -195,8 +195,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Location(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Location(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: LocationEventContent {
message,
location: LocationContent {
@ -217,7 +217,7 @@ fn message_event_deserialization() {
room_id,
sender,
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_html().is_none()
&& 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,
RoomMessageEventContent, TextMessageEventContent,
},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -255,8 +255,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Message(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Message(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: MessageEventContent {
message,
..
@ -266,7 +266,7 @@ fn message_event_deserialization() {
room_id,
sender,
unsigned
}) if event_id == event_id!("$event:notareal.hs")
})) if event_id == event_id!("$event:notareal.hs")
&& message.find_plain() == Some("Hello, World!")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
&& room_id == room_id!("!roomid:notareal.hs")
@ -447,8 +447,8 @@ fn notice_event_stable_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Notice(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: NoticeEventContent {
message,
..
@ -458,7 +458,7 @@ fn notice_event_stable_deserialization() {
room_id,
sender,
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_html() == Some("Hello, I'm a <em>robot</em>!")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
@ -485,8 +485,8 @@ fn notice_event_unstable_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Notice(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: NoticeEventContent {
message,
..
@ -496,7 +496,7 @@ fn notice_event_unstable_deserialization() {
room_id,
sender,
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_html() == Some("Hello, I'm a <em>robot</em>!")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
@ -618,8 +618,8 @@ fn emote_event_stable_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Emote(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: EmoteEventContent {
message,
..
@ -629,7 +629,7 @@ fn emote_event_stable_deserialization() {
room_id,
sender,
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_html().is_none()
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(134_829_848))
@ -653,8 +653,8 @@ fn emote_event_unstable_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Emote(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: EmoteEventContent {
message,
..
@ -664,7 +664,7 @@ fn emote_event_unstable_deserialization() {
room_id,
sender,
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_html().is_none()
&& 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},
room::{ImageInfo, MediaSource, ThumbnailInfo},
sticker::StickerEventContent,
AnyMessageLikeEventContent, AnyOriginalMessageLikeEvent, AnyOriginalSyncMessageLikeEvent,
AnyMessageLikeEvent, AnyMessageLikeEventContent, AnySyncMessageLikeEvent, MessageLikeEvent,
MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
@ -167,8 +167,8 @@ fn deserialize_message_call_answer() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::CallAnswer(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: CallAnswerEventContent {
answer: SessionDescription {
session_type: SessionDescriptionType::Answer,
@ -184,7 +184,7 @@ fn deserialize_message_call_answer() {
room_id,
sender,
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")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com")
@ -221,8 +221,8 @@ fn deserialize_message_sticker() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Sticker(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Sticker(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: StickerEventContent {
body,
info: ImageInfo {
@ -244,7 +244,7 @@ fn deserialize_message_sticker() {
room_id,
sender,
unsigned
}) if event_id == event_id!("$h29iv0s8:example.com")
})) if event_id == event_id!("$h29iv0s8:example.com")
&& body == "Hello"
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com")
@ -290,11 +290,11 @@ fn deserialize_message_then_convert_to_full() {
"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!(
sync_ev.into_full_event(rid.to_owned()),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
AnyMessageLikeEvent::CallAnswer(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: CallAnswerEventContent {
answer: SessionDescription {
session_type: SessionDescriptionType::Answer,
@ -310,7 +310,7 @@ fn deserialize_message_then_convert_to_full() {
room_id,
sender,
unsigned,
}) if sdp == "Hello"
})) if sdp == "Hello"
&& call_id == "foofoo"
&& version == uint!(1)
&& event_id == "$h29iv0s8:example.com"

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

@ -7,12 +7,14 @@ use ruma_common::{
aliases::RedactedRoomAliasesEventContent,
create::{RedactedRoomCreateEventContent, RoomCreateEventContent},
message::{RedactedRoomMessageEventContent, RoomMessageEventContent},
redaction::{OriginalSyncRoomRedactionEvent, RoomRedactionEventContent},
redaction::{
OriginalSyncRoomRedactionEvent, RoomRedactionEventContent, SyncRoomRedactionEvent,
},
},
AnyOriginalMessageLikeEvent, AnyRedactedMessageLikeEvent, AnyRedactedSyncMessageLikeEvent,
AnyRedactedSyncStateEvent, AnyRoomEvent, AnySyncRoomEvent, EventContent,
MessageLikeUnsigned, Redact, RedactContent, RedactedMessageLikeEvent,
RedactedSyncMessageLikeEvent, RedactedSyncStateEvent, RedactedUnsigned,
AnyMessageLikeEvent, AnyRoomEvent, AnySyncMessageLikeEvent, AnySyncRoomEvent,
AnySyncStateEvent, EventContent, MessageLikeEvent, MessageLikeUnsigned, RedactContent,
RedactedMessageLikeEvent, RedactedSyncMessageLikeEvent, RedactedSyncStateEvent,
RedactedUnsigned, SyncMessageLikeEvent, SyncStateEvent,
},
room_id, user_id, MilliSecondsSinceUnixEpoch, RoomVersionId,
};
@ -23,14 +25,15 @@ use serde_json::{
fn unsigned() -> RedactedUnsigned {
let mut unsigned = RedactedUnsigned::default();
unsigned.redacted_because = Some(Box::new(OriginalSyncRoomRedactionEvent {
content: RoomRedactionEventContent::with_reason("redacted because".into()),
redacts: event_id!("$h29iv0s8:example.com").to_owned(),
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
sender: user_id!("@carl:example.com").to_owned(),
unsigned: MessageLikeUnsigned::default(),
}));
unsigned.redacted_because =
Some(Box::new(SyncRoomRedactionEvent::Original(OriginalSyncRoomRedactionEvent {
content: RoomRedactionEventContent::with_reason("redacted because".into()),
redacts: event_id!("$h29iv0s8:example.com").to_owned(),
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
sender: user_id!("@carl:example.com").to_owned(),
unsigned: MessageLikeUnsigned::default(),
})));
unsigned
}
@ -120,12 +123,12 @@ fn redacted_aliases_deserialize() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(actual).unwrap(),
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomAliases(
RedactedSyncStateEvent {
AnySyncRoomEvent::State(AnySyncStateEvent::RoomAliases(
SyncStateEvent::Redacted(RedactedSyncStateEvent {
content: RedactedRoomAliasesEventContent { aliases, .. },
event_id,
..
},
}),
)) if event_id == event_id!("$h29iv0s8:example.com")
&& aliases.is_none()
)
@ -146,10 +149,12 @@ fn redacted_deserialize_any_room() {
assert_matches!(
from_json_value::<AnyRoomEvent>(actual).unwrap(),
AnyRoomEvent::RedactedMessageLike(AnyRedactedMessageLikeEvent::RoomMessage(RedactedMessageLikeEvent {
content: RedactedRoomMessageEventContent { .. },
event_id, room_id, ..
})) if event_id == event_id!("$h29iv0s8:example.com")
AnyRoomEvent::MessageLike(AnyMessageLikeEvent::RoomMessage(
MessageLikeEvent::Redacted(RedactedMessageLikeEvent {
content: RedactedRoomMessageEventContent { .. },
event_id, room_id, ..
}),
)) if event_id == event_id!("$h29iv0s8:example.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)
// to return early with `RedactedContent` instead of failing to deserialize according
// to the event type string.
unsigned.redacted_because = Some(Box::new(OriginalSyncRoomRedactionEvent {
content: RoomRedactionEventContent::with_reason("redacted because".into()),
redacts: event_id!("$h29iv0s8:example.com").to_owned(),
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
sender: user_id!("@carl:example.com").to_owned(),
unsigned: MessageLikeUnsigned::default(),
}));
unsigned.redacted_because =
Some(Box::new(SyncRoomRedactionEvent::Original(OriginalSyncRoomRedactionEvent {
content: RoomRedactionEventContent::with_reason("redacted because".into()),
redacts: event_id!("$h29iv0s8:example.com").to_owned(),
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
sender: user_id!("@carl:example.com").to_owned(),
unsigned: MessageLikeUnsigned::default(),
})));
let redacted = json!({
"event_id": "$h29iv0s8:example.com",
@ -181,12 +187,12 @@ fn redacted_deserialize_any_room_sync() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(actual).unwrap(),
AnySyncRoomEvent::RedactedMessageLike(AnyRedactedSyncMessageLikeEvent::RoomMessage(
RedactedSyncMessageLikeEvent {
AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
SyncMessageLikeEvent::Redacted(RedactedSyncMessageLikeEvent {
content: RedactedRoomMessageEventContent { .. },
event_id,
..
}
}),
)) if event_id == event_id!("$h29iv0s8:example.com")
)
}
@ -208,8 +214,8 @@ fn redacted_state_event_deserialize() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(redacted)
.unwrap(),
AnySyncRoomEvent::RedactedState(AnyRedactedSyncStateEvent::RoomCreate(
RedactedSyncStateEvent {
AnySyncRoomEvent::State(AnySyncStateEvent::RoomCreate(
SyncStateEvent::Redacted(RedactedSyncStateEvent {
content: RedactedRoomCreateEventContent {
creator, ..
},
@ -217,7 +223,7 @@ fn redacted_state_event_deserialize() {
state_key,
unsigned,
..
}
}),
)) if event_id == event_id!("$h29iv0s8:example.com")
&& unsigned.redacted_because.is_some()
&& state_key == "hello there"
@ -238,14 +244,14 @@ fn redacted_custom_event_serialize() {
assert_matches!(
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"))
}
#[test]
/* #[test]
fn redact_method_properly_redacts() {
let ev = json!({
"type": "m.room.message",
@ -269,24 +275,24 @@ fn redact_method_properly_redacts() {
unsigned: MessageLikeUnsigned::default(),
};
let event: AnyOriginalMessageLikeEvent = from_json_value(ev).unwrap();
let event: AnyMessageLikeEvent = from_json_value(ev).unwrap();
assert_matches!(
event.redact(redaction, &RoomVersionId::V6),
AnyRedactedMessageLikeEvent::RoomMessage(RedactedMessageLikeEvent {
AnyMessageLikeEvent::RoomMessage(MessageLikeEvent::Redacted(RedactedMessageLikeEvent {
content: RedactedRoomMessageEventContent { .. },
event_id,
room_id,
sender,
origin_server_ts,
unsigned,
}) if event_id == event_id!("$143273582443PhrSn:example.com")
})) if event_id == event_id!("$143273582443PhrSn:example.com")
&& unsigned.redacted_because.is_some()
&& room_id == room_id!("!roomid:room.com")
&& sender == user_id!("@user:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
);
}
} */
#[test]
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::{
event_id,
events::{
room::redaction::{OriginalRoomRedactionEvent, RoomRedactionEventContent},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned,
room::redaction::{
OriginalRoomRedactionEvent, RoomRedactionEvent, RoomRedactionEventContent,
},
AnyMessageLikeEvent, MessageLikeUnsigned,
},
room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -49,8 +51,8 @@ fn deserialize_redaction() {
let json_data = redaction();
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::RoomRedaction(OriginalRoomRedactionEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::RoomRedaction(RoomRedactionEvent::Original(OriginalRoomRedactionEvent {
content: RoomRedactionEventContent { reason: Some(reas), .. },
redacts,
event_id,
@ -58,7 +60,7 @@ fn deserialize_redaction() {
room_id,
sender,
unsigned,
}) if reas == "being a turd"
})) if reas == "being a turd"
&& event_id == event_id!("$h29iv0s8:example.com")
&& redacts == event_id!("$nomore:example.com")
&& 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},
ThumbnailInfo,
},
AnyOriginalStateEvent, AnyOriginalSyncStateEvent, AnyRoomEvent, AnyStateEventContent,
OriginalStateEvent, OriginalSyncStateEvent, StateEventType, StateUnsigned,
AnyRoomEvent, AnyStateEvent, AnyStateEventContent, AnySyncStateEvent, OriginalStateEvent,
OriginalSyncStateEvent, StateEvent, StateEventType, StateUnsigned, SyncStateEvent,
},
mxc_uri, room_alias_id, room_id,
serde::Raw,
@ -115,8 +115,8 @@ fn deserialize_aliases_with_prev_content() {
let json_data = aliases_event_with_prev_content();
assert_matches!(
from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(),
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyStateEvent::RoomAliases(StateEvent::Original(OriginalStateEvent {
content,
event_id,
origin_server_ts,
@ -127,7 +127,7 @@ fn deserialize_aliases_with_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")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& 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();
assert_matches!(
from_json_value::<AnyOriginalSyncStateEvent>(json_data)
from_json_value::<AnySyncStateEvent>(json_data)
.unwrap(),
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(OriginalSyncStateEvent {
content,
event_id,
origin_server_ts,
@ -155,7 +155,7 @@ fn deserialize_aliases_sync_with_room_id() {
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")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& prev_content.aliases == vec![room_alias_id!("#inner:localhost")]
@ -193,8 +193,8 @@ fn deserialize_avatar_without_prev_content() {
});
assert_matches!(
from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(),
AnyOriginalStateEvent::RoomAvatar(OriginalStateEvent {
from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyStateEvent::RoomAvatar(StateEvent::Original(OriginalStateEvent {
content: RoomAvatarEventContent {
info: Some(info),
url: Some(url),
@ -206,7 +206,7 @@ fn deserialize_avatar_without_prev_content() {
sender,
state_key,
unsigned,
}) if event_id == event_id!("$h29iv0s8:example.com")
})) if event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& room_id == room_id!("!roomid:room.com")
&& sender == user_id!("@carl:example.com")
@ -268,15 +268,15 @@ fn deserialize_member_event_with_top_level_membership_field() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data)
.unwrap(),
AnyRoomEvent::OriginalState(
AnyOriginalStateEvent::RoomMember(OriginalStateEvent {
AnyRoomEvent::State(AnyStateEvent::RoomMember(StateEvent::Original(
OriginalStateEvent {
content,
event_id,
origin_server_ts,
sender,
..
}
)) if event_id == event_id!("$h29iv0s8:example.com")
))) if event_id == event_id!("$h29iv0s8:example.com")
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& sender == user_id!("@example:localhost")
&& 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() {
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!(
AnyOriginalSyncStateEvent::from(full_ev),
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
AnySyncStateEvent::from(full_ev),
AnySyncStateEvent::RoomAliases(SyncStateEvent::Original(OriginalSyncStateEvent {
content,
event_id,
origin_server_ts,
@ -301,7 +301,7 @@ fn deserialize_full_event_convert_to_sync() {
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"
&& origin_server_ts == MilliSecondsSinceUnixEpoch(uint!(1))
&& 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,
},
video::{VideoContent, VideoEventContent},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -295,8 +295,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Video(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Video(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: VideoEventContent {
message,
file: FileContent {
@ -314,7 +314,7 @@ fn message_event_deserialization() {
room_id,
sender,
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_html().is_none()
&& url == "mxc://notareal.hs/abcdef"

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

@ -17,7 +17,7 @@ use ruma_common::{
MediaSource,
},
voice::{VoiceContent, VoiceEventContent},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -114,8 +114,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Voice(OriginalMessageLikeEvent {
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Voice(MessageLikeEvent::Original(OriginalMessageLikeEvent {
content: VoiceEventContent {
message,
file: FileContent {
@ -131,7 +131,7 @@ fn message_event_deserialization() {
room_id,
sender,
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_html().is_none()
&& 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(
self,
redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent,
redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
version: &#ruma_common::RoomVersionId,
) -> Self::Redacted {
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.
use std::fmt;
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 super::{
event_parse::{EventEnumDecl, EventEnumEntry, EventKind, EventKindVariation},
util::is_non_stripped_room_event,
};
use super::event_parse::{EventEnumDecl, EventEnumEntry, EventKind};
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.
///
@ -20,24 +30,19 @@ const EVENT_FIELDS: &[(&str, EventKindFn)] = &[
("origin_server_ts", is_non_stripped_room_event),
("room_id", |kind, var| {
matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::Ephemeral)
&& matches!(
var,
EventKindVariation::None
| EventKindVariation::Original
| EventKindVariation::Redacted
)
&& matches!(var, EventEnumVariation::None)
}),
("event_id", is_non_stripped_room_event),
("sender", |kind, var| {
matches!(kind, EventKind::MessageLike | EventKind::State | EventKind::ToDevice)
&& var != EventKindVariation::Initial
&& var != EventEnumVariation::Initial
}),
("state_key", |kind, _| matches!(kind, EventKind::State)),
];
/// Create a content enum from `EventEnumInput`.
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();
@ -54,51 +59,30 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
let ruma_common = &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) {
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),
);
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),
);
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),
);
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),
);
res.extend(
expand_redact(kind, V::Original, 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)
expand_into_full_event(kind, V::Sync, variants, ruma_common)
.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(
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
events: &[LitStr],
attrs: &[Attribute],
variants: &[EventEnumVariant],
ruma_common: &TokenStream,
) -> syn::Result<TokenStream> {
let event_struct = kind.to_event_ident(var)?;
let ident = kind.to_event_enum_ident(var)?;
let event_struct = kind.to_event_ident(var.into())?;
let ident = kind.to_event_enum_ident(var.into())?;
let variant_decls = variants.iter().map(|v| v.decl());
let content: Vec<_> =
@ -170,7 +154,7 @@ fn expand_event_enum(
fn expand_deserialize_impl(
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
events: &[LitStr],
variants: &[EventEnumVariant],
ruma_common: &TokenStream,
@ -178,7 +162,7 @@ fn expand_deserialize_impl(
let serde = quote! { #ruma_common::exports::serde };
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 attrs = &v.attrs;
@ -242,11 +226,11 @@ fn expand_from_impl(
fn expand_from_full_event(
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
variants: &[EventEnumVariant],
) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?;
let sync = kind.to_event_enum_ident(var.to_sync())?;
let ident = kind.to_event_enum_ident(var.into())?;
let sync = kind.to_event_enum_ident(var.to_sync().into())?;
let ident_variants = variants.iter().map(|v| v.match_arm(&ident));
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(
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
variants: &[EventEnumVariant],
ruma_common: &TokenStream,
) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?;
let full = kind.to_event_enum_ident(var.to_full())?;
let ident = kind.to_event_enum_ident(var.into())?;
let full = kind.to_event_enum_ident(var.to_full().into())?;
let self_variants = variants.iter().map(|v| v.match_arm(quote! { Self }));
let full_variants = variants.iter().map(|v| v.ctor(&full));
@ -398,33 +382,32 @@ fn expand_content_enum(
fn expand_redact(
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
variants: &[EventEnumVariant],
ruma_common: &TokenStream,
) -> syn::Result<TokenStream> {
let ident = kind.to_event_enum_ident(var)?;
let redacted_enum = kind.to_event_enum_ident(var.to_redacted())?;
let ident = kind.to_event_enum_ident(var.into())?;
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! {
#[automatically_derived]
impl #ruma_common::events::Redact for #ident {
type Redacted = #redacted_enum;
type Redacted = Self;
fn redact(
self,
redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent,
redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
version: &#ruma_common::RoomVersionId,
) -> #redacted_enum {
) -> Self {
match self {
#(
#self_variants(event) => #redacted_variants(
#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),
)
}
@ -435,15 +418,33 @@ fn expand_redact(
fn expand_accessor_methods(
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
variants: &[EventEnumVariant],
ruma_common: &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 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_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)| {
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 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 call_parens = maybe_redacted.then(|| quote! { () });
quote! {
#[doc = #docs]
pub fn #ident(&self) -> &#field_type {
match self {
#( #variants(event) => &event.#ident, )*
Self::_Custom(event) => &event.#ident,
#( #variants(event) => &event.#ident #call_parens, )*
Self::_Custom(event) => &event.#ident #call_parens,
}
}
}
@ -490,17 +492,10 @@ fn expand_accessor_methods(
impl #ident {
/// Returns the `type` of this event.
pub fn event_type(&self) -> #ruma_common::events::#event_type_enum {
match self {
#( #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),
),
}
match self { #event_type_match_arms }
}
#content_accessors
#( #methods )*
}
})
@ -509,13 +504,13 @@ fn expand_accessor_methods(
fn to_event_path(
name: &LitStr,
kind: EventKind,
var: EventKindVariation,
var: EventEnumVariation,
ruma_common: &TokenStream,
) -> TokenStream {
let path = event_module_path(name);
let event = m_prefix_name_to_type_name(name).unwrap();
let event_name = if kind == EventKind::ToDevice {
assert_eq!(var, EventKindVariation::None);
assert_eq!(var, EventEnumVariation::None);
format_ident!("ToDevice{}Event", event)
} else {
format_ident!("{}{}Event", var, event)
@ -554,24 +549,13 @@ fn event_module_path(name: &LitStr) -> Vec<Ident> {
.collect()
}
fn field_return_type(
name: &str,
var: EventKindVariation,
ruma_common: &TokenStream,
) -> TokenStream {
fn field_return_type(name: &str, ruma_common: &TokenStream) -> TokenStream {
match name {
"origin_server_ts" => quote! { #ruma_common::MilliSecondsSinceUnixEpoch },
"room_id" => quote! { #ruma_common::RoomId },
"event_id" => quote! { #ruma_common::EventId },
"sender" => quote! { #ruma_common::UserId },
"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"),
}
}
@ -655,3 +639,51 @@ pub(crate) fn expand_from_impls_derived(input: DeriveInput) -> TokenStream {
#( #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 {
match self {
EventKindVariation::OriginalSync => EventKindVariation::Original,
@ -135,17 +127,8 @@ impl EventKind {
use EventKindVariation as V;
match (self, var) {
(
Self::GlobalAccountData
| Self::RoomAccountData
| Self::Ephemeral
| Self::ToDevice
| Self::Presence
| Self::HierarchySpaceChild
| Self::Decrypted,
V::None,
)
| (Self::Ephemeral, V::Sync)
(_, V::None)
| (Self::Ephemeral | Self::MessageLike | Self::State, V::Sync)
| (
Self::MessageLike | Self::RoomRedaction | Self::State,
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 event::OriginalStateEvent;
use event::PduEvent;
use js_int::{int, uint};
use maplit::{btreemap, hashmap, hashset};
use ruma_common::{
@ -232,7 +232,7 @@ impl<E: Event> TestStore<E> {
}
}
impl TestStore<OriginalStateEvent> {
impl TestStore<PduEvent> {
#[allow(clippy::type_complexity)]
fn set_up(
&mut self,
@ -372,7 +372,7 @@ fn to_pdu_event<S>(
content: Box<RawJsonValue>,
auth_events: &[S],
prev_events: &[S],
) -> Arc<OriginalStateEvent>
) -> Arc<PduEvent>
where
S: AsRef<str>,
{
@ -384,7 +384,7 @@ where
let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
let state_key = state_key.map(ToOwned::to_owned);
Arc::new(OriginalStateEvent {
Arc::new(PduEvent {
event_id: id.try_into().unwrap(),
rest: Pdu::RoomV3Pdu(RoomV3Pdu {
room_id: room_id().to_owned(),
@ -406,7 +406,7 @@ where
// all graphs start with these input events
#[allow(non_snake_case)]
fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![
to_pdu_event::<&EventId>(
"CREATE",
@ -488,7 +488,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
// all graphs start with these input events
#[allow(non_snake_case)]
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![
to_pdu_event(
"PA",
@ -541,7 +541,7 @@ mod event {
use serde::{Deserialize, Serialize};
use serde_json::value::RawValue as RawJsonValue;
impl Event for OriginalStateEvent {
impl Event for PduEvent {
type Id = Box<EventId>;
fn event_id(&self) -> &Self::Id {
@ -631,7 +631,7 @@ mod event {
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct OriginalStateEvent {
pub struct PduEvent {
pub event_id: Box<EventId>,
#[serde(flatten)]
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,
test_utils::{
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,
};
@ -1021,7 +1021,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
@ -1065,7 +1065,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
@ -1109,7 +1109,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
@ -1153,7 +1153,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,
@ -1214,7 +1214,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&alice()),
@ -1230,7 +1230,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
Some(&ella()),
@ -1283,7 +1283,7 @@ mod tests {
&sender,
fetch_state(RoomEventType::RoomMember, sender.to_string()),
&requester,
None::<OriginalStateEvent>,
None::<PduEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,

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

@ -657,8 +657,7 @@ mod tests {
room_version::RoomVersion,
test_utils::{
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,
INITIAL_EVENTS,
room_id, to_init_pdu_event, to_pdu_event, zara, PduEvent, TestStore, INITIAL_EVENTS,
},
Event, StateMap,
};
@ -1043,7 +1042,7 @@ mod tests {
let _ =
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
let (state_at_bob, state_at_charlie, expected) = store.set_up();
@ -1209,7 +1208,7 @@ mod tests {
}
#[allow(non_snake_case)]
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![
to_pdu_event(
"PA",
@ -1254,7 +1253,7 @@ mod tests {
}
#[allow(non_snake_case)]
fn JOIN_RULE() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
fn JOIN_RULE() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![
to_pdu_event(
"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};
pub use event::OriginalStateEvent;
pub use event::PduEvent;
static SERVER_TIMESTAMP: AtomicU64 = AtomicU64::new(0);
pub fn do_check(
events: &[Arc<OriginalStateEvent>],
events: &[Arc<PduEvent>],
edges: Vec<Vec<Box<EventId>>>,
expected_state_ids: Vec<Box<EventId>>,
) {
@ -77,7 +77,7 @@ pub fn do_check(
}
// 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>>
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
#[allow(clippy::type_complexity)]
impl TestStore<OriginalStateEvent> {
impl TestStore<PduEvent> {
pub fn set_up(
&mut self,
) -> (StateMap<Box<EventId>>, StateMap<Box<EventId>>, StateMap<Box<EventId>>) {
@ -387,12 +387,12 @@ pub fn to_init_pdu_event(
ev_type: RoomEventType,
state_key: Option<&str>,
content: Box<RawJsonValue>,
) -> Arc<OriginalStateEvent> {
) -> Arc<PduEvent> {
let ts = SERVER_TIMESTAMP.fetch_add(1, SeqCst);
let id = if id.contains('$') { id.to_owned() } else { format!("${}:foo", id) };
let state_key = state_key.map(ToOwned::to_owned);
Arc::new(OriginalStateEvent {
Arc::new(PduEvent {
event_id: id.try_into().unwrap(),
rest: Pdu::RoomV3Pdu(RoomV3Pdu {
room_id: room_id().to_owned(),
@ -420,7 +420,7 @@ pub fn to_pdu_event<S>(
content: Box<RawJsonValue>,
auth_events: &[S],
prev_events: &[S],
) -> Arc<OriginalStateEvent>
) -> Arc<PduEvent>
where
S: AsRef<str>,
{
@ -430,7 +430,7 @@ where
let prev_events = prev_events.iter().map(AsRef::as_ref).map(event_id).collect::<Vec<_>>();
let state_key = state_key.map(ToOwned::to_owned);
Arc::new(OriginalStateEvent {
Arc::new(PduEvent {
event_id: id.try_into().unwrap(),
rest: Pdu::RoomV3Pdu(RoomV3Pdu {
room_id: room_id().to_owned(),
@ -452,7 +452,7 @@ where
// all graphs start with these input events
#[allow(non_snake_case)]
pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<PduEvent>> {
vec![
to_pdu_event::<&EventId>(
"CREATE",
@ -534,7 +534,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
// all graphs start with these input events
#[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>(
"CREATE",
alice(),
@ -567,7 +567,7 @@ pub mod event {
use crate::Event;
impl Event for OriginalStateEvent {
impl Event for PduEvent {
type Id = Box<EventId>;
fn event_id(&self) -> &Self::Id {
@ -658,20 +658,9 @@ pub mod event {
#[derive(Clone, Debug, Deserialize, Serialize)]
#[allow(clippy::exhaustive_structs)]
pub struct OriginalStateEvent {
pub struct PduEvent {
pub event_id: Box<EventId>,
#[serde(flatten)]
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,
events::{
room::message::{MessageType, RoomMessageEventContent},
AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent,
AnySyncMessageLikeEvent, AnySyncRoomEvent, SyncMessageLikeEvent,
},
presence::PresenceState,
serde::Raw,
@ -146,9 +146,9 @@ async fn handle_message(
room_id: &RoomId,
bot_user_id: &UserId,
) -> Result<(), Box<dyn Error>> {
if let Ok(AnySyncRoomEvent::OriginalMessageLike(
AnyOriginalSyncMessageLikeEvent::RoomMessage(m),
)) = e.deserialize()
if let Ok(AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
SyncMessageLikeEvent::Original(m),
))) = e.deserialize()
{
// workaround because Conduit does not implement filtering.
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},
events::{
room::message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent, OriginalSyncMessageLikeEvent,
AnySyncMessageLikeEvent, AnySyncRoomEvent, OriginalSyncMessageLikeEvent,
SyncMessageLikeEvent,
},
presence::PresenceState,
};
@ -42,8 +43,8 @@ async fn log_messages(
for (room_id, room) in res.rooms.join {
for event in room.timeline.events.into_iter().flat_map(|r| r.deserialize()) {
// Filter out the text messages
if let AnySyncRoomEvent::OriginalMessageLike(
AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent {
if let AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
SyncMessageLikeEvent::Original(OriginalSyncMessageLikeEvent {
content:
RoomMessageEventContent {
msgtype:
@ -55,7 +56,7 @@ async fn log_messages(
sender,
..
}),
) = event
)) = event
{
println!("{:?} in {:?}: {}", sender, room_id, msg_body);
}