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

events: Add 'Original' prefix to unredacted types with a redacted form

Browse Source
This commit is contained in:
Jonas Platte 2022-03-29 16:23:45 +02:00
parent d614ad1422
commit d87874314b
No known key found for this signature in database
GPG Key ID: BBA95679259D342F
54 changed files with 429 additions and 354 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::{AnyRoomEvent, AnyStateEvent},
events::{AnyOriginalStateEvent, AnyRoomEvent},
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<AnyStateEvent>>,
pub state: Vec<Raw<AnyOriginalStateEvent>>,
}
error: crate::Error

6
crates/ruma-client-api/src/membership/get_member_events.rs
View File

@ -7,7 +7,7 @@ pub mod v3 {
use ruma_common::{
api::ruma_api,
events::room::member::RoomMemberEvent,
events::room::member::OriginalRoomMemberEvent,
serde::{Raw, StringEnum},
RoomId,
};
@ -58,7 +58,7 @@ pub mod v3 {
response: {
/// A list of member events.
pub chunk: Vec<Raw<RoomMemberEvent>>,
pub chunk: Vec<Raw<OriginalRoomMemberEvent>>,
}
error: crate::Error
@ -73,7 +73,7 @@ pub mod v3 {
impl Response {
/// Creates a new `Response` with the given member event chunk.
pub fn new(chunk: Vec<Raw<RoomMemberEvent>>) -> Self {
pub fn new(chunk: Vec<Raw<OriginalRoomMemberEvent>>) -> Self {
Self { chunk }
}
}

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::{AnyRoomEvent, AnyStateEvent},
events::{AnyOriginalStateEvent, AnyRoomEvent},
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<AnyStateEvent>>,
pub state: Vec<Raw<AnyOriginalStateEvent>>,
}
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::{AnyRoomEvent, AnyStateEvent},
events::{AnyOriginalStateEvent, AnyRoomEvent},
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<AnyStateEvent>>>,
pub state: BTreeMap<Box<RoomId>, Vec<Raw<AnyOriginalStateEvent>>>,
/// 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::AnyStateEvent, serde::Raw, RoomId};
use ruma_common::{api::ruma_api, events::AnyOriginalStateEvent, 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<AnyStateEvent>>,
pub room_state: Vec<Raw<AnyOriginalStateEvent>>,
}
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<AnyStateEvent>>) -> Self {
pub fn new(room_state: Vec<Raw<AnyOriginalStateEvent>>) -> 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, AnyRoomAccountDataEvent,
AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncRoomEvent, AnySyncStateEvent,
AnyToDeviceEvent,
presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyOriginalSyncStateEvent,
AnyRoomAccountDataEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent,
AnySyncRoomEvent, 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<AnySyncStateEvent>>,
pub events: Vec<Raw<AnyOriginalSyncStateEvent>>,
}
impl State {

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

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

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

@ -38,10 +38,10 @@
//! `ruma::api::client::state::send_state_event`'s `Request`.
//!
//! As a more advanced example we create a reaction message event. For this event we will use a
//! [`SyncMessageLikeEvent`] struct but any [`MessageLikeEvent`] struct would work.
//! [`OriginalSyncMessageLikeEvent`] struct but any [`OriginalMessageLikeEvent`] struct would work.
//!
//! ```rust
//! use ruma_common::events::{macros::EventContent, SyncMessageLikeEvent};
//! use ruma_common::events::{macros::EventContent, OriginalSyncMessageLikeEvent};
//! use ruma_common::EventId;
//! use serde::{Deserialize, Serialize};
//!
@ -90,8 +90,8 @@
//! // The downside of this event is we cannot use it with event enums,
//! // but could be deserialized from a `Raw<_>` that has failed to deserialize.
//! matches::assert_matches!(
//! serde_json::from_value::<SyncMessageLikeEvent<ReactionEventContent>>(json),
//! Ok(SyncMessageLikeEvent {
//! serde_json::from_value::<OriginalSyncMessageLikeEvent<ReactionEventContent>>(json),
//! Ok(OriginalSyncMessageLikeEvent {
//! content: ReactionEventContent {
//! relates_to: RelatesTo::Annotation { key, .. },
//! },
@ -102,7 +102,7 @@
use serde::{de::IgnoredAny, Deserialize, Serializer};
use self::room::redaction::SyncRoomRedactionEvent;
use self::room::redaction::OriginalSyncRoomRedactionEvent;
use crate::{EventEncryptionAlgorithm, RoomVersionId};
// Needs to be public for trybuild tests
@ -180,7 +180,11 @@ 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: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted;
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> Self::Redacted;
}
/// Trait to define the behavior of redact an event's content object.

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

@ -39,9 +39,9 @@ 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 `AnyStateEvent` and
/// `AnyMessageLikeEvent` and their "sync" and "stripped" counterparts. The
/// `RedactedEventContent` trait is an implementation detail, ruma makes no
/// redacted events, prefer the `redact` method on `AnyOriginalStateEvent` and
/// `AnyOriginalMessageLikeEvent` and their "sync" and "stripped" counterparts.
/// The `RedactedEventContent` trait is an implementation detail, ruma makes no
/// API guarantees.
pub trait RedactedEventContent: EventContent {
/// Constructs the redacted event content.

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

@ -4,7 +4,7 @@ use serde_json::value::RawValue as RawJsonValue;
use super::{
key,
room::{encrypted, redaction::SyncRoomRedactionEvent},
room::{encrypted, redaction::OriginalSyncRoomRedactionEvent},
Redact, UnsignedDeHelper,
};
use crate::{
@ -129,8 +129,8 @@ macro_rules! room_ev_accessor {
#[doc = concat!("Returns this event's `", stringify!($field), "` field.")]
pub fn $field(&self) -> $ty {
match self {
Self::MessageLike(ev) => ev.$field(),
Self::State(ev) => ev.$field(),
Self::OriginalMessageLike(ev) => ev.$field(),
Self::OriginalState(ev) => ev.$field(),
Self::RedactedMessageLike(ev) => ev.$field(),
Self::RedactedState(ev) => ev.$field(),
}
@ -143,11 +143,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.
MessageLike(AnyMessageLikeEvent),
/// Any message-like event (unredacted).
OriginalMessageLike(AnyOriginalMessageLikeEvent),
/// Any state event.
State(AnyStateEvent),
/// Any state event (unredacted).
OriginalState(AnyOriginalStateEvent),
/// Any message-like event that has been redacted.
RedactedMessageLike(AnyRedactedMessageLikeEvent),
@ -169,11 +169,11 @@ impl AnyRoomEvent {
#[allow(clippy::large_enum_variant, clippy::exhaustive_enums)]
#[derive(Clone, Debug, EventEnumFromEvent)]
pub enum AnySyncRoomEvent {
/// Any sync message-like event.
MessageLike(AnySyncMessageLikeEvent),
/// Any sync message-like event (unredacted).
OriginalMessageLike(AnyOriginalSyncMessageLikeEvent),
/// Any sync state event.
State(AnySyncStateEvent),
/// Any sync state event (unredacted).
OriginalState(AnyOriginalSyncStateEvent),
/// Any sync message-like event that has been redacted.
RedactedMessageLike(AnyRedactedSyncMessageLikeEvent),
@ -190,8 +190,10 @@ 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::MessageLike(ev) => AnyRoomEvent::MessageLike(ev.into_full_event(room_id)),
Self::State(ev) => AnyRoomEvent::State(ev.into_full_event(room_id)),
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))
}
@ -220,14 +222,14 @@ impl<'de> Deserialize<'de> for AnyRoomEvent {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnyRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnyRoomEvent::State(from_raw_json_value(&json)?),
_ => AnyRoomEvent::OriginalState(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::MessageLike(from_raw_json_value(&json)?),
_ => AnyRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
})
}
}
@ -246,14 +248,14 @@ impl<'de> Deserialize<'de> for AnySyncRoomEvent {
Some(unsigned) if unsigned.redacted_because.is_some() => {
AnySyncRoomEvent::RedactedState(from_raw_json_value(&json)?)
}
_ => AnySyncRoomEvent::State(from_raw_json_value(&json)?),
_ => AnySyncRoomEvent::OriginalState(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::MessageLike(from_raw_json_value(&json)?),
_ => AnySyncRoomEvent::OriginalMessageLike(from_raw_json_value(&json)?),
})
}
}
@ -276,12 +278,18 @@ impl Redact for AnyRoomEvent {
/// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
///
/// Does nothing for events that are already redacted.
fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted {
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> Self::Redacted {
match self {
Self::MessageLike(ev) => Self::Redacted::MessageLike(ev.redact(redaction, version)),
Self::State(ev) => Self::Redacted::State(ev.redact(redaction, version)),
Self::RedactedMessageLike(ev) => Self::Redacted::MessageLike(ev),
Self::RedactedState(ev) => Self::Redacted::State(ev),
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),
}
}
}
@ -312,12 +320,20 @@ impl Redact for AnySyncRoomEvent {
/// Redacts `self`, referencing the given event in `unsigned.redacted_because`.
///
/// Does nothing for events that are already redacted.
fn redact(self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) -> Self::Redacted {
fn redact(
self,
redaction: OriginalSyncRoomRedactionEvent,
version: &RoomVersionId,
) -> AnyRedactedSyncRoomEvent {
match self {
Self::MessageLike(ev) => Self::Redacted::MessageLike(ev.redact(redaction, version)),
Self::State(ev) => Self::Redacted::State(ev.redact(redaction, version)),
Self::RedactedMessageLike(ev) => Self::Redacted::MessageLike(ev),
Self::RedactedState(ev) => Self::Redacted::State(ev),
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),
}
}
}

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

@ -44,10 +44,10 @@ pub struct SyncEphemeralRoomEvent<C: EphemeralRoomEventContent> {
/// A message-like event.
///
/// `MessageLikeEvent` implements the comparison traits using only the `event_id` field, a sorted
/// list would be sorted lexicographically based on the event's `EventId`.
/// `OriginalMessageLikeEvent` implements the comparison traits using only the `event_id` field, a
/// sorted list would be sorted lexicographically based on the event's `EventId`.
#[derive(Clone, Debug, Event)]
pub struct MessageLikeEvent<C: MessageLikeEventContent> {
pub struct OriginalMessageLikeEvent<C: MessageLikeEventContent> {
/// Data specific to the event type.
pub content: C,
@ -69,10 +69,10 @@ pub struct MessageLikeEvent<C: MessageLikeEventContent> {
/// A message-like event without a `room_id`.
///
/// `SyncMessageLikeEvent` implements the comparison traits using only the `event_id` field, a
/// sorted list would be sorted lexicographically based on the event's `EventId`.
/// `OriginalSyncMessageLikeEvent` implements the comparison traits using only the `event_id` field,
/// a sorted list would be sorted lexicographically based on the event's `EventId`.
#[derive(Clone, Debug, Event)]
pub struct SyncMessageLikeEvent<C: MessageLikeEventContent> {
pub struct OriginalSyncMessageLikeEvent<C: MessageLikeEventContent> {
/// Data specific to the event type.
pub content: C,
@ -138,10 +138,10 @@ pub struct RedactedSyncMessageLikeEvent<C: RedactedMessageLikeEventContent> {
/// A state event.
///
/// `StateEvent` implements the comparison traits using only the `event_id` field, a sorted list
/// would be sorted lexicographically based on the event's `EventId`.
/// `OriginalStateEvent` implements the comparison traits using only the `event_id` field, a sorted
/// list would be sorted lexicographically based on the event's `EventId`.
#[derive(Clone, Debug, Event)]
pub struct StateEvent<C: StateEventContent> {
pub struct OriginalStateEvent<C: StateEventContent> {
/// Data specific to the event type.
pub content: C,
@ -169,10 +169,10 @@ pub struct StateEvent<C: StateEventContent> {
/// A state event without a `room_id`.
///
/// `SyncStateEvent` implements the comparison traits using only the `event_id` field, a sorted list
/// would be sorted lexicographically based on the event's `EventId`.
/// `OriginalSyncStateEvent` implements the comparison traits using only the `event_id` field, a
/// sorted list would be sorted lexicographically based on the event's `EventId`.
#[derive(Clone, Debug, Event)]
pub struct SyncStateEvent<C: StateEventContent> {
pub struct OriginalSyncStateEvent<C: StateEventContent> {
/// Data specific to the event type.
pub content: C,

9
crates/ruma-common/src/events/policy/rule/room.rs
View File

@ -22,7 +22,7 @@ mod tests {
use js_int::int;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{PolicyRuleRoomEvent, PolicyRuleRoomEventContent};
use super::{OriginalPolicyRuleRoomEvent, PolicyRuleRoomEventContent};
use crate::{
event_id,
events::{
@ -36,7 +36,7 @@ mod tests {
#[test]
fn serialization() {
let room_event = PolicyRuleRoomEvent {
let room_event = OriginalPolicyRuleRoomEvent {
event_id: event_id!("$143273582443PhrSn:example.org").to_owned(),
sender: user_id!("@example:example.org").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_432_735_824_653_u64.try_into().unwrap()),
@ -89,6 +89,9 @@ mod tests {
}
});
assert!(from_json_value::<Raw<PolicyRuleRoomEvent>>(json).unwrap().deserialize().is_ok());
assert!(from_json_value::<Raw<OriginalPolicyRuleRoomEvent>>(json)
.unwrap()
.deserialize()
.is_ok());
}
}

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::AnySyncMessageLikeEvent;
use super::AnyOriginalSyncMessageLikeEvent;
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<AnySyncMessageLikeEvent>>,
pub latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>,
/// 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<AnySyncMessageLikeEvent>>,
latest_event: Box<Raw<AnyOriginalSyncMessageLikeEvent>>,
count: UInt,
current_user_participated: bool,
) -> Self {

12
crates/ruma-common/src/events/room/canonical_alias.rs
View File

@ -44,11 +44,11 @@ mod tests {
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::RoomCanonicalAliasEventContent;
use crate::events::{StateEvent, StateUnsigned};
use crate::events::{OriginalStateEvent, StateUnsigned};
#[test]
fn serialization_with_optional_fields_as_none() {
let canonical_alias_event = StateEvent {
let canonical_alias_event = OriginalStateEvent {
content: RoomCanonicalAliasEventContent {
alias: Some(room_alias_id!("#somewhere:localhost").to_owned()),
alt_aliases: Vec::new(),
@ -90,7 +90,7 @@ mod tests {
});
assert_eq!(
from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,
@ -112,7 +112,7 @@ mod tests {
"type": "m.room.canonical_alias"
});
assert_eq!(
from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,
@ -134,7 +134,7 @@ mod tests {
"type": "m.room.canonical_alias"
});
assert_eq!(
from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,
@ -157,7 +157,7 @@ mod tests {
"type": "m.room.canonical_alias"
});
assert_eq!(
from_json_value::<StateEvent<RoomCanonicalAliasEventContent>>(json_data)
from_json_value::<OriginalStateEvent<RoomCanonicalAliasEventContent>>(json_data)
.unwrap()
.content
.alias,

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

@ -221,7 +221,7 @@ mod tests {
use crate::room_id;
use matches::assert_matches;
use super::{AllowRule, JoinRule, RoomJoinRulesEventContent, SyncRoomJoinRulesEvent};
use super::{AllowRule, JoinRule, OriginalSyncRoomJoinRulesEvent, RoomJoinRulesEventContent};
#[test]
fn deserialize() {
@ -277,6 +277,6 @@ mod tests {
"event_id": "$0ACb9KSPlT3al3kikyRYvFhMqXPP9ZcQOBrsdIuh58U"
}"#;
assert_matches!(serde_json::from_str::<SyncRoomJoinRulesEvent>(json), Ok(_));
assert_matches!(serde_json::from_str::<OriginalSyncRoomJoinRulesEvent>(json), Ok(_));
}
}

28
crates/ruma-common/src/events/room/member.rs
View File

@ -10,8 +10,8 @@ use serde_json::value::RawValue as RawJsonValue;
use crate::{
events::{
EventContent, HasDeserializeFields, RedactContent, RedactedEventContent, StateEventType,
StrippedStateEvent, SyncStateEvent,
EventContent, HasDeserializeFields, OriginalSyncStateEvent, RedactContent,
RedactedEventContent, StateEventType, StrippedStateEvent,
},
serde::StringEnum,
MxcUri, PrivOwnedStr, RoomVersionId, ServerName, ServerSigningKeyId, UserId,
@ -377,7 +377,7 @@ fn membership_change(
}
}
impl RoomMemberEvent {
impl OriginalRoomMemberEvent {
/// Helper function for membership change.
///
/// Check [the specification][spec] for details.
@ -393,7 +393,7 @@ impl RoomMemberEvent {
}
}
impl SyncStateEvent<RoomMemberEventContent> {
impl OriginalSyncStateEvent<RoomMemberEventContent> {
/// Helper function for membership change.
///
/// Check [the specification][spec] for details.
@ -429,7 +429,7 @@ mod tests {
use serde_json::{from_value as from_json_value, json};
use super::{MembershipState, RoomMemberEventContent, SignedContent, ThirdPartyInvite};
use crate::events::{StateEvent, StateUnsigned};
use crate::events::{OriginalStateEvent, StateUnsigned};
#[test]
fn serde_with_no_prev_content() {
@ -446,8 +446,8 @@ mod tests {
});
assert_matches!(
from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
StateEvent {
from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
OriginalStateEvent {
content: RoomMemberEventContent {
avatar_url: None,
displayname: None,
@ -490,7 +490,7 @@ mod tests {
},
});
let ev = from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap();
let ev = from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap();
assert_matches!(
ev.content,
@ -556,8 +556,8 @@ mod tests {
});
assert_matches!(
from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
StateEvent {
from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
OriginalStateEvent {
content: RoomMemberEventContent {
avatar_url: Some(avatar_url),
displayname: Some(displayname),
@ -629,8 +629,8 @@ mod tests {
});
assert_matches!(
from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
StateEvent {
from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
OriginalStateEvent {
content: RoomMemberEventContent {
avatar_url: None,
displayname: None,
@ -692,8 +692,8 @@ mod tests {
});
assert_matches!(
from_json_value::<StateEvent<RoomMemberEventContent>>(json).unwrap(),
StateEvent {
from_json_value::<OriginalStateEvent<RoomMemberEventContent>>(json).unwrap(),
OriginalStateEvent {
content: RoomMemberEventContent {
avatar_url: None,
displayname: None,

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

@ -127,11 +127,11 @@ impl RoomMessageEventContent {
/// [`RoomMessageEvent`] since it creates a permalink to the previous message, for which the
/// room ID is required. If you want to reply to a [`SyncRoomMessageEvent`], you have to convert
/// it first by calling
/// [`.into_full_event()`][crate::events::SyncMessageLikeEvent::into_full_event].
/// [`.into_full_event()`][crate::events::OriginalSyncMessageLikeEvent::into_full_event].
pub fn text_reply_html(
reply: impl fmt::Display,
html_reply: impl fmt::Display,
original_message: &RoomMessageEvent,
original_message: &OriginalRoomMessageEvent,
) -> Self {
let quoted = reply::get_plain_quote_fallback(original_message);
let quoted_html = reply::get_html_quote_fallback(original_message);
@ -169,11 +169,11 @@ impl RoomMessageEventContent {
/// [`RoomMessageEvent`] since it creates a permalink to the previous message, for which the
/// room ID is required. If you want to reply to a [`SyncRoomMessageEvent`], you have to convert
/// it first by calling
/// [`.into_full_event()`][crate::events::SyncMessageLikeEvent::into_full_event].
/// [`.into_full_event()`][crate::events::OriginalSyncMessageLikeEvent::into_full_event].
pub fn notice_reply_html(
reply: impl fmt::Display,
html_reply: impl fmt::Display,
original_message: &RoomMessageEvent,
original_message: &OriginalRoomMessageEvent,
) -> Self {
let quoted = reply::get_plain_quote_fallback(original_message);
let quoted_html = reply::get_html_quote_fallback(original_message);

13
crates/ruma-common/src/events/room/message/reply.rs
View File

@ -1,7 +1,8 @@
use indoc::formatdoc;
use super::{
FormattedBody, MessageType, RoomMessageEvent, RoomMessageEventContent, SyncRoomMessageEvent,
FormattedBody, MessageType, OriginalRoomMessageEvent, OriginalSyncRoomMessageEvent,
RoomMessageEventContent,
};
use crate::{EventId, UserId};
@ -21,7 +22,7 @@ pub trait ReplyBaseEvent {
fn content(&self) -> &RoomMessageEventContent;
}
impl ReplyBaseEvent for RoomMessageEvent {
impl ReplyBaseEvent for OriginalRoomMessageEvent {
fn event_id(&self) -> &EventId {
&self.event_id
}
@ -35,7 +36,7 @@ impl ReplyBaseEvent for RoomMessageEvent {
}
}
impl ReplyBaseEvent for SyncRoomMessageEvent {
impl ReplyBaseEvent for OriginalSyncRoomMessageEvent {
fn event_id(&self) -> &EventId {
&self.event_id
}
@ -91,7 +92,7 @@ pub fn get_plain_quote_fallback(original_message: &impl ReplyBaseEvent) -> Strin
}
#[allow(clippy::nonstandard_macro_braces)]
pub fn get_html_quote_fallback(original_message: &RoomMessageEvent) -> String {
pub fn get_html_quote_fallback(original_message: &OriginalRoomMessageEvent) -> String {
match &original_message.content.msgtype {
MessageType::Audio(_) => {
formatdoc!(
@ -303,12 +304,12 @@ mod tests {
event_id, events::MessageLikeUnsigned, room_id, user_id, MilliSecondsSinceUnixEpoch,
};
use super::{RoomMessageEvent, RoomMessageEventContent};
use super::{OriginalRoomMessageEvent, RoomMessageEventContent};
#[test]
fn plain_quote_fallback_multiline() {
assert_eq!(
super::get_plain_quote_fallback(&RoomMessageEvent {
super::get_plain_quote_fallback(&OriginalRoomMessageEvent {
content: RoomMessageEventContent::text_plain("multi\nline"),
event_id: event_id!("$1598361704261elfgc:localhost").to_owned(),
sender: user_id!("@alice:example.com").to_owned(),

26
crates/ruma-common/src/events/room/name.rs
View File

@ -36,11 +36,11 @@ mod tests {
use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::RoomNameEventContent;
use crate::events::{StateEvent, StateUnsigned};
use crate::events::{OriginalStateEvent, StateUnsigned};
#[test]
fn serialization_with_optional_fields_as_none() {
let name_event = StateEvent {
let name_event = OriginalStateEvent {
content: RoomNameEventContent { name: "The room name".try_into().ok() },
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
@ -68,7 +68,7 @@ mod tests {
#[test]
fn serialization_with_all_fields() {
let name_event = StateEvent {
let name_event = OriginalStateEvent {
content: RoomNameEventContent { name: "The room name".try_into().ok() },
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(1)),
@ -114,7 +114,10 @@ mod tests {
"type": "m.room.name"
});
assert_eq!(
from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
.unwrap()
.content
.name,
None
);
}
@ -161,7 +164,10 @@ mod tests {
"type": "m.room.name"
});
assert_eq!(
from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
.unwrap()
.content
.name,
None
);
}
@ -180,7 +186,10 @@ mod tests {
"type": "m.room.name"
});
assert_eq!(
from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
.unwrap()
.content
.name,
None
);
}
@ -201,7 +210,10 @@ mod tests {
});
assert_eq!(
from_json_value::<StateEvent<RoomNameEventContent>>(json_data).unwrap().content.name,
from_json_value::<OriginalStateEvent<RoomNameEventContent>>(json_data)
.unwrap()
.content
.name,
name
);
}

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

@ -32,7 +32,7 @@ mod tests {
use crate::{server_name, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId};
use super::RoomPinnedEventsEventContent;
use crate::events::{StateEvent, StateUnsigned};
use crate::events::{OriginalStateEvent, StateUnsigned};
#[test]
fn serialization_deserialization() {
@ -43,7 +43,7 @@ mod tests {
content.pinned.push(EventId::new(server_name));
content.pinned.push(EventId::new(server_name));
let event = StateEvent {
let event = OriginalStateEvent {
content: content.clone(),
event_id: EventId::new(server_name),
origin_server_ts: MilliSecondsSinceUnixEpoch(1_432_804_485_886_u64.try_into().unwrap()),
@ -54,7 +54,7 @@ mod tests {
};
let serialized_event = serde_json::to_string(&event).unwrap();
let parsed_event: StateEvent<RoomPinnedEventsEventContent> =
let parsed_event: OriginalStateEvent<RoomPinnedEventsEventContent> =
serde_json::from_str(&serialized_event).unwrap();
assert_eq!(parsed_event.event_id, event.event_id);

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

@ -182,13 +182,13 @@ mod tests {
use serde_json::{json, to_value as to_json_value};
use super::{default_power_level, NotificationPowerLevels, RoomPowerLevelsEventContent};
use crate::events::{StateEvent, StateUnsigned};
use crate::events::{OriginalStateEvent, StateUnsigned};
#[test]
fn serialization_with_optional_fields_as_none() {
let default = default_power_level();
let power_levels_event = StateEvent {
let power_levels_event = OriginalStateEvent {
content: RoomPowerLevelsEventContent {
ban: default,
events: BTreeMap::new(),
@ -226,7 +226,7 @@ mod tests {
#[test]
fn serialization_with_all_fields() {
let user = user_id!("@carl:example.com");
let power_levels_event = StateEvent {
let power_levels_event = OriginalStateEvent {
content: RoomPowerLevelsEventContent {
ban: int!(23),
events: btreemap! {

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

@ -13,7 +13,7 @@ use crate::{
/// Redaction event.
#[derive(Clone, Debug, Event)]
#[allow(clippy::exhaustive_structs)]
pub struct RoomRedactionEvent {
pub struct OriginalRoomRedactionEvent {
/// Data specific to the event type.
pub content: RoomRedactionEventContent,
@ -36,12 +36,12 @@ pub struct RoomRedactionEvent {
pub unsigned: MessageLikeUnsigned,
}
impl Redact for RoomRedactionEvent {
impl Redact for OriginalRoomRedactionEvent {
type Redacted = RedactedRoomRedactionEvent;
fn redact(
self,
redaction: SyncRoomRedactionEvent,
redaction: OriginalSyncRoomRedactionEvent,
version: &crate::RoomVersionId,
) -> Self::Redacted {
RedactedRoomRedactionEvent {
@ -86,7 +86,7 @@ pub struct RedactedRoomRedactionEvent {
/// Redaction event without a `room_id`.
#[derive(Clone, Debug, Event)]
#[allow(clippy::exhaustive_structs)]
pub struct SyncRoomRedactionEvent {
pub struct OriginalSyncRoomRedactionEvent {
/// Data specific to the event type.
pub content: RoomRedactionEventContent,
@ -106,12 +106,12 @@ pub struct SyncRoomRedactionEvent {
pub unsigned: MessageLikeUnsigned,
}
impl Redact for SyncRoomRedactionEvent {
impl Redact for OriginalSyncRoomRedactionEvent {
type Redacted = RedactedSyncRoomRedactionEvent;
fn redact(
self,
redaction: SyncRoomRedactionEvent,
redaction: OriginalSyncRoomRedactionEvent,
version: &crate::RoomVersionId,
) -> Self::Redacted {
RedactedSyncRoomRedactionEvent {

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

@ -68,7 +68,7 @@ mod tests {
use serde_json::{from_value as from_json_value, json};
use super::RoomServerAclEventContent;
use crate::events::StateEvent;
use crate::events::OriginalStateEvent;
#[test]
fn default_values() {
@ -82,7 +82,7 @@ mod tests {
"type": "m.room.server_acl"
});
let server_acl_event: StateEvent<RoomServerAclEventContent> =
let server_acl_event: OriginalStateEvent<RoomServerAclEventContent> =
from_json_value(json_data).unwrap();
assert!(server_acl_event.content.allow_ip_literals);

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::SyncRoomRedactionEvent, StateEventContent};
use super::{room::redaction::OriginalSyncRoomRedactionEvent, 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<SyncRoomRedactionEvent>>,
pub redacted_because: Option<Box<OriginalSyncRoomRedactionEvent>>,
}
impl RedactedUnsigned {
@ -182,7 +182,7 @@ impl RedactedUnsigned {
}
/// Create a new `RedactedUnsigned` with the given redacted because.
pub fn new_because(redacted_because: Box<SyncRoomRedactionEvent>) -> Self {
pub fn new_because(redacted_because: Box<OriginalSyncRoomRedactionEvent>) -> 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,
},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -137,7 +137,7 @@ fn encrypted_content_serialization() {
#[test]
fn event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: assign!(
AudioEventContent::with_message(
MessageContent::html(
@ -349,8 +349,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Audio(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Audio(OriginalMessageLikeEvent {
content: AudioEventContent {
message,
file: FileContent {

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

@ -10,11 +10,12 @@ use ruma_common::{
message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
power_levels::RoomPowerLevelsEventContent,
},
AnyEphemeralRoomEvent, AnyMessageLikeEvent, AnyRoomEvent, AnyStateEvent,
AnyStateEventContent, AnySyncMessageLikeEvent, AnySyncRoomEvent, AnySyncStateEvent,
EphemeralRoomEventType, GlobalAccountDataEventType, MessageLikeEvent, MessageLikeEventType,
MessageLikeUnsigned, RoomAccountDataEventType, StateEvent, StateEventType,
SyncMessageLikeEvent, SyncStateEvent, ToDeviceEventType,
AnyEphemeralRoomEvent, AnyOriginalMessageLikeEvent, AnyOriginalStateEvent,
AnyOriginalSyncMessageLikeEvent, AnyOriginalSyncStateEvent, AnyRoomEvent,
AnyStateEventContent, AnySyncRoomEvent, EphemeralRoomEventType, GlobalAccountDataEventType,
MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent, OriginalStateEvent,
OriginalSyncMessageLikeEvent, OriginalSyncStateEvent, RoomAccountDataEventType,
StateEventType, ToDeviceEventType,
},
MilliSecondsSinceUnixEpoch,
};
@ -123,8 +124,8 @@ fn power_event_sync_deserialization() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::State(
AnySyncStateEvent::RoomPowerLevels(SyncStateEvent {
Ok(AnySyncRoomEvent::OriginalState(
AnyOriginalSyncStateEvent::RoomPowerLevels(OriginalSyncStateEvent {
content: RoomPowerLevelsEventContent {
ban, ..
},
@ -141,8 +142,8 @@ fn message_event_sync_deserialization() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::MessageLike(
AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent {
Ok(AnySyncRoomEvent::OriginalMessageLike(
AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
@ -164,8 +165,8 @@ fn aliases_event_sync_deserialization() {
assert_matches!(
from_json_value::<AnySyncRoomEvent>(json_data),
Ok(AnySyncRoomEvent::State(
AnySyncStateEvent::RoomAliases(SyncStateEvent {
Ok(AnySyncRoomEvent::OriginalState(
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
content: RoomAliasesEventContent {
aliases,
..
@ -183,8 +184,8 @@ fn message_room_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::MessageLike(
AnyMessageLikeEvent::RoomMessage(MessageLikeEvent {
Ok(AnyRoomEvent::OriginalMessageLike(
AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
@ -202,7 +203,7 @@ fn message_room_event_deserialization() {
#[test]
fn message_event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: RoomMessageEventContent::text_plain("test"),
event_id: event_id!("$1234:example.com").to_owned(),
origin_server_ts: MilliSecondsSinceUnixEpoch(uint!(0)),
@ -230,8 +231,8 @@ fn alias_room_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::State(
AnyStateEvent::RoomAliases(StateEvent {
Ok(AnyRoomEvent::OriginalState(
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
content: RoomAliasesEventContent {
aliases,
..
@ -249,8 +250,8 @@ fn message_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::MessageLike(
AnyMessageLikeEvent::RoomMessage(MessageLikeEvent {
Ok(AnyRoomEvent::OriginalMessageLike(
AnyOriginalMessageLikeEvent::RoomMessage(OriginalMessageLikeEvent {
content: RoomMessageEventContent {
msgtype: MessageType::Text(TextMessageEventContent {
body,
@ -272,8 +273,8 @@ fn alias_event_deserialization() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data),
Ok(AnyRoomEvent::State(
AnyStateEvent::RoomAliases(StateEvent {
Ok(AnyRoomEvent::OriginalState(
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
content: RoomAliasesEventContent {
aliases,
..
@ -291,14 +292,14 @@ fn alias_event_field_access() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data.clone()),
Ok(AnyRoomEvent::State(state_event))
Ok(AnyRoomEvent::OriginalState(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::<AnyStateEvent>(json_data).unwrap();
let deser = from_json_value::<AnyOriginalStateEvent>(json_data).unwrap();
if let AnyStateEventContent::RoomAliases(RoomAliasesEventContent { aliases, .. }) =
deser.content()
{

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

@ -5,7 +5,7 @@ use serde_json::{from_value as from_json_value, json};
use ruma_common::events::{
call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
AnyMessageLikeEvent, MessageLikeEvent,
AnyOriginalMessageLikeEvent, OriginalMessageLikeEvent,
};
#[test]
@ -35,9 +35,9 @@ fn deserialize_message_event() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data)
from_json_value::<AnyOriginalMessageLikeEvent>(json_data)
.unwrap(),
AnyMessageLikeEvent::CallAnswer(MessageLikeEvent {
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
content: CallAnswerEventContent {
answer: SessionDescription {
session_type: SessionDescriptionType::Answer,

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

@ -14,7 +14,7 @@ use ruma_common::{
},
EncryptedFileInit, JsonWebKeyInit, MediaSource,
},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -92,7 +92,7 @@ fn encrypted_content_serialization() {
#[test]
fn file_event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: assign!(
FileEventContent::plain_message(
MessageContent::html(
@ -225,8 +225,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::File(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::File(OriginalMessageLikeEvent {
content: FileEventContent {
message,
file: FileContent {

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

@ -18,7 +18,7 @@ use ruma_common::{
},
JsonWebKeyInit, MediaSource,
},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -99,7 +99,7 @@ fn encrypted_content_serialization() {
#[test]
fn image_event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: assign!(
ImageEventContent::with_message(
MessageContent::html(
@ -285,8 +285,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Image(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Image(OriginalMessageLikeEvent {
content: ImageEventContent {
message,
file: FileContent {

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

@ -14,7 +14,7 @@ use ruma_common::{
room::message::{
InReplyTo, LocationMessageEventContent, MessageType, Relation, RoomMessageEventContent,
},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -40,7 +40,7 @@ fn plain_content_serialization() {
#[test]
fn event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: assign!(
LocationEventContent::with_message(
MessageContent::html(
@ -195,8 +195,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Location(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Location(OriginalMessageLikeEvent {
content: LocationEventContent {
message,
location: LocationContent {

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

@ -15,7 +15,7 @@ use ruma_common::{
EmoteMessageEventContent, InReplyTo, MessageType, NoticeMessageEventContent, Relation,
RoomMessageEventContent, TextMessageEventContent,
},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -126,7 +126,7 @@ fn relates_to_content_serialization() {
#[test]
fn message_event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: MessageEventContent::plain("Hello, World!"),
event_id: event_id!("$event:notareal.hs").to_owned(),
sender: user_id!("@user:notareal.hs").to_owned(),
@ -255,8 +255,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Message(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Message(OriginalMessageLikeEvent {
content: MessageEventContent {
message,
..
@ -391,7 +391,7 @@ fn room_message_html_text_unstable_deserialization() {
#[test]
fn notice_event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: NoticeEventContent::plain("Hello, I'm a robot!"),
event_id: event_id!("$event:notareal.hs").to_owned(),
sender: user_id!("@user:notareal.hs").to_owned(),
@ -447,8 +447,8 @@ fn notice_event_stable_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Notice(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent {
content: NoticeEventContent {
message,
..
@ -485,8 +485,8 @@ fn notice_event_unstable_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Notice(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Notice(OriginalMessageLikeEvent {
content: NoticeEventContent {
message,
..
@ -558,7 +558,7 @@ fn room_message_notice_unstable_deserialization() {
#[test]
fn emote_event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: EmoteEventContent::html(
"is testing some code…",
"is testing some <code>code</code>…",
@ -618,8 +618,8 @@ fn emote_event_stable_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Emote(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent {
content: EmoteEventContent {
message,
..
@ -653,8 +653,8 @@ fn emote_event_unstable_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Emote(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Emote(OriginalMessageLikeEvent {
content: EmoteEventContent {
message,
..

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

@ -7,8 +7,8 @@ use ruma_common::{
call::{answer::CallAnswerEventContent, SessionDescription, SessionDescriptionType},
room::{ImageInfo, MediaSource, ThumbnailInfo},
sticker::StickerEventContent,
AnyMessageLikeEvent, AnyMessageLikeEventContent, AnySyncMessageLikeEvent, MessageLikeEvent,
MessageLikeEventType, MessageLikeUnsigned,
AnyMessageLikeEventContent, AnyOriginalMessageLikeEvent, AnyOriginalSyncMessageLikeEvent,
MessageLikeEventType, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Raw,
@ -18,7 +18,7 @@ use serde_json::{from_value as from_json_value, json, to_value as to_json_value}
#[test]
fn message_serialize_sticker() {
let aliases_event = MessageLikeEvent {
let aliases_event = OriginalMessageLikeEvent {
content: StickerEventContent::new(
"Hello".into(),
assign!(ImageInfo::new(), {
@ -167,8 +167,8 @@ fn deserialize_message_call_answer() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::CallAnswer(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
content: CallAnswerEventContent {
answer: SessionDescription {
session_type: SessionDescriptionType::Answer,
@ -221,8 +221,8 @@ fn deserialize_message_sticker() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Sticker(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Sticker(OriginalMessageLikeEvent {
content: StickerEventContent {
body,
info: ImageInfo {
@ -290,11 +290,11 @@ fn deserialize_message_then_convert_to_full() {
"type": "m.call.answer"
});
let sync_ev: AnySyncMessageLikeEvent = from_json_value(json_data).unwrap();
let sync_ev: AnyOriginalSyncMessageLikeEvent = from_json_value(json_data).unwrap();
assert_matches!(
sync_ev.into_full_event(rid.to_owned()),
AnyMessageLikeEvent::CallAnswer(MessageLikeEvent {
AnyOriginalMessageLikeEvent::CallAnswer(OriginalMessageLikeEvent {
content: CallAnswerEventContent {
answer: SessionDescription {
session_type: SessionDescriptionType::Answer,

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

@ -7,9 +7,9 @@ use ruma_common::{
aliases::RedactedRoomAliasesEventContent,
create::{RedactedRoomCreateEventContent, RoomCreateEventContent},
message::{RedactedRoomMessageEventContent, RoomMessageEventContent},
redaction::{RoomRedactionEventContent, SyncRoomRedactionEvent},
redaction::{OriginalSyncRoomRedactionEvent, RoomRedactionEventContent},
},
AnyMessageLikeEvent, AnyRedactedMessageLikeEvent, AnyRedactedSyncMessageLikeEvent,
AnyOriginalMessageLikeEvent, AnyRedactedMessageLikeEvent, AnyRedactedSyncMessageLikeEvent,
AnyRedactedSyncStateEvent, AnyRoomEvent, AnySyncRoomEvent, EventContent,
MessageLikeUnsigned, Redact, RedactContent, RedactedMessageLikeEvent,
RedactedSyncMessageLikeEvent, RedactedSyncStateEvent, RedactedUnsigned,
@ -23,7 +23,7 @@ use serde_json::{
fn unsigned() -> RedactedUnsigned {
let mut unsigned = RedactedUnsigned::default();
unsigned.redacted_because = Some(Box::new(SyncRoomRedactionEvent {
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(),
@ -160,7 +160,7 @@ 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(SyncRoomRedactionEvent {
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(),
@ -260,7 +260,7 @@ fn redact_method_properly_redacts() {
},
});
let redaction = SyncRoomRedactionEvent {
let redaction = OriginalSyncRoomRedactionEvent {
content: RoomRedactionEventContent::with_reason("redacted because".into()),
redacts: event_id!("$143273582443PhrSn:example.com").to_owned(),
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
@ -269,7 +269,7 @@ fn redact_method_properly_redacts() {
unsigned: MessageLikeUnsigned::default(),
};
let event: AnyMessageLikeEvent = from_json_value(ev).unwrap();
let event: AnyOriginalMessageLikeEvent = from_json_value(ev).unwrap();
assert_matches!(
event.redact(redaction, &RoomVersionId::V6),

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

@ -3,8 +3,8 @@ use matches::assert_matches;
use ruma_common::{
event_id,
events::{
room::redaction::{RoomRedactionEvent, RoomRedactionEventContent},
AnyMessageLikeEvent, MessageLikeUnsigned,
room::redaction::{OriginalRoomRedactionEvent, RoomRedactionEventContent},
AnyOriginalMessageLikeEvent, MessageLikeUnsigned,
},
room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -28,7 +28,7 @@ fn redaction() -> JsonValue {
#[test]
fn serialize_redaction() {
let aliases_event = RoomRedactionEvent {
let aliases_event = OriginalRoomRedactionEvent {
content: RoomRedactionEventContent::with_reason("being a turd".into()),
redacts: event_id!("$nomore:example.com").to_owned(),
event_id: event_id!("$h29iv0s8:example.com").to_owned(),
@ -49,8 +49,8 @@ fn deserialize_redaction() {
let json_data = redaction();
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::RoomRedaction(RoomRedactionEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::RoomRedaction(OriginalRoomRedactionEvent {
content: RoomRedactionEventContent { reason: Some(reas), .. },
redacts,
event_id,

4
crates/ruma-common/tests/events/room_message.rs
View File

@ -15,7 +15,7 @@ use ruma_common::{
room::{
message::{
AudioMessageEventContent, KeyVerificationRequestEventContent, MessageType,
RoomMessageEvent, RoomMessageEventContent, TextMessageEventContent,
OriginalRoomMessageEvent, RoomMessageEventContent, TextMessageEventContent,
},
MediaSource,
},
@ -39,7 +39,7 @@ macro_rules! json_object {
#[test]
fn serialization() {
let ev = RoomMessageEvent {
let ev = OriginalRoomMessageEvent {
content: RoomMessageEventContent::new(MessageType::Audio(AudioMessageEventContent::plain(
"test".into(),
mxc_uri!("mxc://example.org/ffed755USFFxlgbQYZGtryd").to_owned(),

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

@ -9,8 +9,8 @@ use ruma_common::{
avatar::{ImageInfo, RoomAvatarEventContent},
ThumbnailInfo,
},
AnyRoomEvent, AnyStateEvent, AnyStateEventContent, AnySyncStateEvent, StateEvent,
StateEventType, StateUnsigned, SyncStateEvent,
AnyOriginalStateEvent, AnyOriginalSyncStateEvent, AnyRoomEvent, AnyStateEventContent,
OriginalStateEvent, OriginalSyncStateEvent, StateEventType, StateUnsigned,
},
mxc_uri, room_alias_id, room_id,
serde::Raw,
@ -41,7 +41,7 @@ fn aliases_event_with_prev_content() -> JsonValue {
#[test]
fn serialize_aliases_with_prev_content() {
let aliases_event = StateEvent {
let aliases_event = OriginalStateEvent {
content: RoomAliasesEventContent::new(vec![
room_alias_id!("#somewhere:localhost").to_owned()
]),
@ -66,7 +66,7 @@ fn serialize_aliases_with_prev_content() {
#[test]
fn serialize_aliases_without_prev_content() {
let aliases_event = StateEvent {
let aliases_event = OriginalStateEvent {
content: RoomAliasesEventContent::new(vec![
room_alias_id!("#somewhere:localhost").to_owned()
]),
@ -115,8 +115,8 @@ fn deserialize_aliases_with_prev_content() {
let json_data = aliases_event_with_prev_content();
assert_matches!(
from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyStateEvent::RoomAliases(StateEvent {
from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(),
AnyOriginalStateEvent::RoomAliases(OriginalStateEvent {
content,
event_id,
origin_server_ts,
@ -143,9 +143,9 @@ fn deserialize_aliases_sync_with_room_id() {
let json_data = aliases_event_with_prev_content();
assert_matches!(
from_json_value::<AnySyncStateEvent>(json_data)
from_json_value::<AnyOriginalSyncStateEvent>(json_data)
.unwrap(),
AnySyncStateEvent::RoomAliases(SyncStateEvent {
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
content,
event_id,
origin_server_ts,
@ -193,8 +193,8 @@ fn deserialize_avatar_without_prev_content() {
});
assert_matches!(
from_json_value::<AnyStateEvent>(json_data).unwrap(),
AnyStateEvent::RoomAvatar(StateEvent {
from_json_value::<AnyOriginalStateEvent>(json_data).unwrap(),
AnyOriginalStateEvent::RoomAvatar(OriginalStateEvent {
content: RoomAvatarEventContent {
info: Some(info),
url: Some(url),
@ -268,8 +268,8 @@ fn deserialize_member_event_with_top_level_membership_field() {
assert_matches!(
from_json_value::<AnyRoomEvent>(json_data)
.unwrap(),
AnyRoomEvent::State(
AnyStateEvent::RoomMember(StateEvent {
AnyRoomEvent::OriginalState(
AnyOriginalStateEvent::RoomMember(OriginalStateEvent {
content,
event_id,
origin_server_ts,
@ -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: AnyStateEvent = from_json_value(json_data).unwrap();
let full_ev: AnyOriginalStateEvent = from_json_value(json_data).unwrap();
assert_matches!(
AnySyncStateEvent::from(full_ev),
AnySyncStateEvent::RoomAliases(SyncStateEvent {
AnyOriginalSyncStateEvent::from(full_ev),
AnyOriginalSyncStateEvent::RoomAliases(OriginalSyncStateEvent {
content,
event_id,
origin_server_ts,

2
crates/ruma-common/tests/events/ui/04-event-sanity-check.rs
View File

@ -11,7 +11,7 @@ use ruma_macros::Event;
/// State event.
#[derive(Clone, Debug, Event)]
pub struct StateEvent<C: StateEventContent> {
pub struct OriginalStateEvent<C: StateEventContent> {
pub content: C,
pub event_id: Box<EventId>,
pub sender: Box<UserId>,

2
crates/ruma-common/tests/events/ui/05-named-fields.rs
View File

@ -3,6 +3,6 @@ use ruma_macros::Event;
/// State event.
#[derive(Clone, Debug, Event)]
pub struct StateEvent<C: StateEventContent>(C);
pub struct OriginalStateEvent<C: StateEventContent>(C);
fn main() {}

4
crates/ruma-common/tests/events/ui/05-named-fields.stderr
View File

@ -1,5 +1,5 @@
error: the `Event` derive only supports structs with named fields
--> tests/events/ui/05-named-fields.rs:6:12
|
6 | pub struct StateEvent<C: StateEventContent>(C);
| ^^^^^^^^^^
6 | pub struct OriginalStateEvent<C: StateEventContent>(C);
| ^^^^^^^^^^^^^^^^^^

2
crates/ruma-common/tests/events/ui/06-no-content-field.rs
View File

@ -3,7 +3,7 @@ use ruma_macros::Event;
/// State event.
#[derive(Clone, Debug, Event)]
pub struct StateEvent<C: StateEventContent> {
pub struct OriginalStateEvent<C: StateEventContent> {
pub not_content: C,
}

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

@ -18,7 +18,7 @@ use ruma_common::{
JsonWebKeyInit, MediaSource,
},
video::{VideoContent, VideoEventContent},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id,
serde::Base64,
@ -99,7 +99,7 @@ fn encrypted_content_serialization() {
#[test]
fn event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: assign!(
VideoEventContent::with_message(
MessageContent::html(
@ -295,8 +295,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Video(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Video(OriginalMessageLikeEvent {
content: VideoEventContent {
message,
file: FileContent {

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

@ -17,7 +17,7 @@ use ruma_common::{
MediaSource,
},
voice::{VoiceContent, VoiceEventContent},
AnyMessageLikeEvent, MessageLikeEvent, MessageLikeUnsigned,
AnyOriginalMessageLikeEvent, MessageLikeUnsigned, OriginalMessageLikeEvent,
},
mxc_uri, room_id, user_id, MilliSecondsSinceUnixEpoch,
};
@ -25,7 +25,7 @@ use serde_json::{from_value as from_json_value, json, to_value as to_json_value}
#[test]
fn event_serialization() {
let event = MessageLikeEvent {
let event = OriginalMessageLikeEvent {
content: assign!(
VoiceEventContent::plain(
"Voice message",
@ -114,8 +114,8 @@ fn message_event_deserialization() {
});
assert_matches!(
from_json_value::<AnyMessageLikeEvent>(json_data).unwrap(),
AnyMessageLikeEvent::Voice(MessageLikeEvent {
from_json_value::<AnyOriginalMessageLikeEvent>(json_data).unwrap(),
AnyOriginalMessageLikeEvent::Voice(OriginalMessageLikeEvent {
content: VoiceEventContent {
message,
file: FileContent {

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

@ -55,7 +55,7 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
}
if matches!(kind, EventKind::MessageLike | EventKind::State)
&& matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
&& matches!(var, EventKindVariation::Original | EventKindVariation::OriginalSync)
{
res.extend(expand_redact_event(&input, kind, var, &fields, &ruma_common));
}
@ -422,7 +422,7 @@ fn expand_redact_event(
fn redact(
self,
redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent,
version: &#ruma_common::RoomVersionId,
) -> Self::Redacted {
let content = #ruma_common::events::RedactContent::redact(self.content, version);

10
crates/ruma-macros/src/events/event_content.rs
View File

@ -367,8 +367,10 @@ fn generate_event_type_aliases(
})?;
let type_aliases = [
EventKindVariation::Full,
EventKindVariation::None,
EventKindVariation::Sync,
EventKindVariation::Original,
EventKindVariation::OriginalSync,
EventKindVariation::Stripped,
EventKindVariation::Initial,
EventKindVariation::Redacted,
@ -380,8 +382,10 @@ fn generate_event_type_aliases(
let ev_type = format_ident!("{}{}", var, ev_type_s);
let doc_text = match var {
EventKindVariation::Full => "",
EventKindVariation::Sync => " from a `sync_events` response",
EventKindVariation::None | EventKindVariation::Original => "",
EventKindVariation::Sync | EventKindVariation::OriginalSync => {
" from a `sync_events` response"
}
EventKindVariation::Stripped => " from an invited room preview",
EventKindVariation::Redacted => " that has been redacted",
EventKindVariation::RedactedSync => {

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

@ -20,7 +20,12 @@ 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::Full | EventKindVariation::Redacted)
&& matches!(
var,
EventKindVariation::None
| EventKindVariation::Original
| EventKindVariation::Redacted
)
}),
("event_id", is_non_stripped_room_event),
("sender", |kind, var| {
@ -48,25 +53,61 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
let variants = &variants;
let ruma_common = &ruma_common;
res.extend(
expand_event_enum(kind, V::Full, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(expand_content_enum(kind, events, attrs, variants, ruma_common));
if matches!(kind, EventKind::Ephemeral | EventKind::MessageLike | EventKind::State) {
if matches!(kind, EventKind::MessageLike | EventKind::State) {
res.extend(
expand_event_enum(kind, V::Original, 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)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_event_enum(kind, V::Redacted, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_event_enum(kind, V::RedactedSync, events, attrs, variants, ruma_common)
.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)
.unwrap_or_else(syn::Error::into_compile_error),
);
}
if matches!(kind, EventKind::Ephemeral) {
res.extend(
expand_event_enum(kind, V::Sync, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_from_full_event(kind, V::Full, variants)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_into_full_event(kind, V::Sync, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
}
if matches!(kind, EventKind::State) {
@ -80,33 +121,6 @@ pub fn expand_event_enums(input: &EventEnumDecl) -> syn::Result<TokenStream> {
);
}
if matches!(kind, EventKind::MessageLike | EventKind::State) {
res.extend(
expand_event_enum(kind, V::Redacted, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_event_enum(kind, V::RedactedSync, events, attrs, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_redact(kind, V::Full, variants, ruma_common)
.unwrap_or_else(syn::Error::into_compile_error),
);
res.extend(
expand_redact(kind, V::Sync, 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),
);
}
Ok(res)
}
@ -401,7 +415,7 @@ fn expand_redact(
fn redact(
self,
redaction: #ruma_common::events::room::redaction::SyncRoomRedactionEvent,
redaction: #ruma_common::events::room::redaction::OriginalSyncRoomRedactionEvent,
version: &#ruma_common::RoomVersionId,
) -> #redacted_enum {
match self {
@ -546,7 +560,7 @@ fn to_event_path(
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::Full);
assert_eq!(var, EventKindVariation::None);
format_ident!("ToDevice{}Event", event)
} else {
format_ident!("{}{}Event", var, event)

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

@ -19,8 +19,10 @@ mod kw {
// If the variants of this enum change `to_event_path` needs to be updated as well.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EventKindVariation {
Full,
None,
Sync,
Original,
OriginalSync,
Stripped,
Initial,
Redacted,
@ -30,8 +32,10 @@ pub enum EventKindVariation {
impl fmt::Display for EventKindVariation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
EventKindVariation::Full => write!(f, ""),
EventKindVariation::None => write!(f, ""),
EventKindVariation::Sync => write!(f, "Sync"),
EventKindVariation::Original => write!(f, "Original"),
EventKindVariation::OriginalSync => write!(f, "OriginalSync"),
EventKindVariation::Stripped => write!(f, "Stripped"),
EventKindVariation::Initial => write!(f, "Initial"),
EventKindVariation::Redacted => write!(f, "Redacted"),
@ -46,20 +50,20 @@ impl EventKindVariation {
}
pub fn is_sync(self) -> bool {
matches!(self, Self::Sync | Self::RedactedSync)
matches!(self, Self::OriginalSync | Self::RedactedSync)
}
pub fn to_redacted(self) -> Self {
match self {
EventKindVariation::Full => EventKindVariation::Redacted,
EventKindVariation::Sync => EventKindVariation::RedactedSync,
EventKindVariation::Original => EventKindVariation::Redacted,
EventKindVariation::OriginalSync => EventKindVariation::RedactedSync,
_ => panic!("No redacted form of {:?}", self),
}
}
pub fn to_sync(self) -> Self {
match self {
EventKindVariation::Full => EventKindVariation::Sync,
EventKindVariation::Original => EventKindVariation::OriginalSync,
EventKindVariation::Redacted => EventKindVariation::RedactedSync,
_ => panic!("No sync form of {:?}", self),
}
@ -67,9 +71,9 @@ impl EventKindVariation {
pub fn to_full(self) -> Self {
match self {
EventKindVariation::Sync => EventKindVariation::Full,
EventKindVariation::OriginalSync => EventKindVariation::Original,
EventKindVariation::RedactedSync => EventKindVariation::Redacted,
_ => panic!("No full form of {:?}", self),
_ => panic!("No original (unredacted) form of {:?}", self),
}
}
}
@ -127,11 +131,20 @@ impl EventKind {
use EventKindVariation as V;
match (self, var) {
(_, V::Full)
| (Self::MessageLike | Self::RoomRedaction | Self::State | Self::Ephemeral, V::Sync)
(
Self::GlobalAccountData
| Self::RoomAccountData
| Self::Ephemeral
| Self::ToDevice
| Self::Presence
| Self::HierarchySpaceChild
| Self::Decrypted,
V::None,
)
| (Self::Ephemeral, V::Sync)
| (
Self::MessageLike | Self::RoomRedaction | Self::State,
V::Redacted | V::RedactedSync,
V::Original | V::OriginalSync | V::Redacted | V::RedactedSync,
)
| (Self::State, V::Stripped | V::Initial) => Ok(format_ident!("{}{}", var, self)),
_ => Err(syn::Error::new(
@ -188,29 +201,33 @@ impl Parse for EventKind {
pub fn to_kind_variation(ident: &Ident) -> Option<(EventKind, EventKindVariation)> {
let ident_str = ident.to_string();
match ident_str.as_str() {
"GlobalAccountDataEvent" => Some((EventKind::GlobalAccountData, EventKindVariation::Full)),
"RoomAccountDataEvent" => Some((EventKind::RoomAccountData, EventKindVariation::Full)),
"EphemeralRoomEvent" => Some((EventKind::Ephemeral, EventKindVariation::Full)),
"GlobalAccountDataEvent" => Some((EventKind::GlobalAccountData, EventKindVariation::None)),
"RoomAccountDataEvent" => Some((EventKind::RoomAccountData, EventKindVariation::None)),
"EphemeralRoomEvent" => Some((EventKind::Ephemeral, EventKindVariation::None)),
"SyncEphemeralRoomEvent" => Some((EventKind::Ephemeral, EventKindVariation::Sync)),
"MessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Full)),
"SyncMessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Sync)),
"OriginalMessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Original)),
"OriginalSyncMessageLikeEvent" => {
Some((EventKind::MessageLike, EventKindVariation::OriginalSync))
}
"RedactedMessageLikeEvent" => Some((EventKind::MessageLike, EventKindVariation::Redacted)),
"RedactedSyncMessageLikeEvent" => {
Some((EventKind::MessageLike, EventKindVariation::RedactedSync))
}
"StateEvent" => Some((EventKind::State, EventKindVariation::Full)),
"SyncStateEvent" => Some((EventKind::State, EventKindVariation::Sync)),
"OriginalStateEvent" => Some((EventKind::State, EventKindVariation::Original)),
"OriginalSyncStateEvent" => Some((EventKind::State, EventKindVariation::OriginalSync)),
"StrippedStateEvent" => Some((EventKind::State, EventKindVariation::Stripped)),
"InitialStateEvent" => Some((EventKind::State, EventKindVariation::Initial)),
"RedactedStateEvent" => Some((EventKind::State, EventKindVariation::Redacted)),
"RedactedSyncStateEvent" => Some((EventKind::State, EventKindVariation::RedactedSync)),
"ToDeviceEvent" => Some((EventKind::ToDevice, EventKindVariation::Full)),
"PresenceEvent" => Some((EventKind::Presence, EventKindVariation::Full)),
"ToDeviceEvent" => Some((EventKind::ToDevice, EventKindVariation::None)),
"PresenceEvent" => Some((EventKind::Presence, EventKindVariation::None)),
"HierarchySpaceChildEvent" => {
Some((EventKind::HierarchySpaceChild, EventKindVariation::Stripped))
}
"RoomRedactionEvent" => Some((EventKind::RoomRedaction, EventKindVariation::Full)),
"SyncRoomRedactionEvent" => Some((EventKind::RoomRedaction, EventKindVariation::Sync)),
"OriginalRoomRedactionEvent" => Some((EventKind::RoomRedaction, EventKindVariation::None)),
"OriginalSyncRoomRedactionEvent" => {
Some((EventKind::RoomRedaction, EventKindVariation::OriginalSync))
}
"RedactedRoomRedactionEvent" => {
Some((EventKind::RoomRedaction, EventKindVariation::Redacted))
}
@ -218,7 +235,7 @@ pub fn to_kind_variation(ident: &Ident) -> Option<(EventKind, EventKindVariation
Some((EventKind::RoomRedaction, EventKindVariation::RedactedSync))
}
"DecryptedOlmV1Event" | "DecryptedMegolmV1Event" => {
Some((EventKind::Decrypted, EventKindVariation::Full))
Some((EventKind::Decrypted, EventKindVariation::None))
}
_ => None,
}

6
crates/ruma-macros/src/events/util.rs
View File

@ -4,8 +4,8 @@ pub(crate) fn is_non_stripped_room_event(kind: EventKind, var: EventKindVariatio
matches!(kind, EventKind::MessageLike | EventKind::State)
&& matches!(
var,
EventKindVariation::Full
| EventKindVariation::Sync
EventKindVariation::Original
| EventKindVariation::OriginalSync
| EventKindVariation::Redacted
| EventKindVariation::RedactedSync
)
@ -13,5 +13,5 @@ pub(crate) fn is_non_stripped_room_event(kind: EventKind, var: EventKindVariatio
pub(crate) fn has_prev_content(kind: EventKind, var: EventKindVariation) -> bool {
matches!(kind, EventKind::State)
&& matches!(var, EventKindVariation::Full | EventKindVariation::Sync)
&& matches!(var, EventKindVariation::Original | EventKindVariation::OriginalSync)
}

2
crates/ruma-state-res/README.md
View File

@ -15,7 +15,7 @@ pub trait Event {
/// A mapping of event type and state_key to some value `T`, usually an `EventId`.
pub type StateMap<T> = BTreeMap<(EventType, Option<String>), T>;
/// A mapping of `EventId` to `T`, usually a `StateEvent`.
/// A mapping of `EventId` to `T`, usually a `OriginalStateEvent`.
pub type EventMap<T> = BTreeMap<Box<EventId>, T>;
struct StateResolution {

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::StateEvent;
use event::OriginalStateEvent;
use js_int::{int, uint};
use maplit::{btreemap, hashmap, hashset};
use ruma_common::{
@ -232,7 +232,7 @@ impl<E: Event> TestStore<E> {
}
}
impl TestStore<StateEvent> {
impl TestStore<OriginalStateEvent> {
#[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<StateEvent>
) -> Arc<OriginalStateEvent>
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(StateEvent {
Arc::new(OriginalStateEvent {
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<StateEvent>> {
fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
vec![
to_pdu_event::<&EventId>(
"CREATE",
@ -488,7 +488,7 @@ fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
// all graphs start with these input events
#[allow(non_snake_case)]
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<StateEvent>> {
fn BAN_STATE_SET() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
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 StateEvent {
impl Event for OriginalStateEvent {
type Id = Box<EventId>;
fn event_id(&self) -> &Self::Id {
@ -631,7 +631,7 @@ mod event {
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct StateEvent {
pub struct OriginalStateEvent {
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, StateEvent, INITIAL_EVENTS, INITIAL_EVENTS_CREATE_ROOM,
to_pdu_event, OriginalStateEvent, 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::<StateEvent>,
None::<OriginalStateEvent>,
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::<StateEvent>,
None::<OriginalStateEvent>,
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::<StateEvent>,
None::<OriginalStateEvent>,
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::<StateEvent>,
None::<OriginalStateEvent>,
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::<StateEvent>,
None::<OriginalStateEvent>,
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::<StateEvent>,
None::<OriginalStateEvent>,
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::<StateEvent>,
None::<OriginalStateEvent>,
fetch_state(RoomEventType::RoomPowerLevels, "".to_owned()),
fetch_state(RoomEventType::RoomJoinRules, "".to_owned()),
None,

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

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

30
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::StateEvent;
pub use event::OriginalStateEvent;
static SERVER_TIMESTAMP: AtomicU64 = AtomicU64::new(0);
pub fn do_check(
events: &[Arc<StateEvent>],
events: &[Arc<OriginalStateEvent>],
edges: Vec<Vec<Box<EventId>>>,
expected_state_ids: Vec<Box<EventId>>,
) {
@ -52,7 +52,7 @@ pub fn do_check(
// This will be lexi_topo_sorted for resolution
let mut graph = HashMap::new();
// This is the same as in `resolve` event_id -> StateEvent
// This is the same as in `resolve` event_id -> OriginalStateEvent
let mut fake_event_map = HashMap::new();
// Create the DB of events that led up to this point
@ -76,8 +76,8 @@ pub fn do_check(
}
}
// event_id -> StateEvent
let mut event_map: HashMap<Box<EventId>, Arc<StateEvent>> = HashMap::new();
// event_id -> OriginalStateEvent
let mut event_map: HashMap<Box<EventId>, Arc<OriginalStateEvent>> = 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<StateEvent> {
impl TestStore<OriginalStateEvent> {
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<StateEvent> {
) -> Arc<OriginalStateEvent> {
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(StateEvent {
Arc::new(OriginalStateEvent {
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<StateEvent>
) -> Arc<OriginalStateEvent>
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(StateEvent {
Arc::new(OriginalStateEvent {
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<StateEvent>> {
pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
vec![
to_pdu_event::<&EventId>(
"CREATE",
@ -534,7 +534,7 @@ pub fn INITIAL_EVENTS() -> HashMap<Box<EventId>, Arc<StateEvent>> {
// all graphs start with these input events
#[allow(non_snake_case)]
pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<StateEvent>> {
pub fn INITIAL_EVENTS_CREATE_ROOM() -> HashMap<Box<EventId>, Arc<OriginalStateEvent>> {
vec![to_pdu_event::<&EventId>(
"CREATE",
alice(),
@ -567,7 +567,7 @@ pub mod event {
use crate::Event;
impl Event for StateEvent {
impl Event for OriginalStateEvent {
type Id = Box<EventId>;
fn event_id(&self) -> &Self::Id {
@ -658,13 +658,13 @@ pub mod event {
#[derive(Clone, Debug, Deserialize, Serialize)]
#[allow(clippy::exhaustive_structs)]
pub struct StateEvent {
pub struct OriginalStateEvent {
pub event_id: Box<EventId>,
#[serde(flatten)]
pub rest: Pdu,
}
//impl StateEvent {
//impl OriginalStateEvent {
// pub fn state_key(&self) -> &str {
// match &self.rest {
// Pdu::RoomV1Pdu(ev) => ev.state_key.as_ref().unwrap(),

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

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

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

@ -5,7 +5,7 @@ use ruma::{
api::client::{filter::FilterDefinition, sync::sync_events},
events::{
room::message::{MessageType, RoomMessageEventContent, TextMessageEventContent},
AnySyncMessageLikeEvent, AnySyncRoomEvent, SyncMessageLikeEvent,
AnyOriginalSyncMessageLikeEvent, AnySyncRoomEvent, OriginalSyncMessageLikeEvent,
},
presence::PresenceState,
};
@ -42,8 +42,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::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
SyncMessageLikeEvent {
if let AnySyncRoomEvent::OriginalMessageLike(
AnyOriginalSyncMessageLikeEvent::RoomMessage(OriginalSyncMessageLikeEvent {
content:
RoomMessageEventContent {
msgtype:
@ -54,8 +54,8 @@ async fn log_messages(
},
sender,
..
},
)) = event
}),
) = event
{
println!("{:?} in {:?}: {}", sender, room_id, msg_body);
}