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

Remove Event, RoomEvent and StateEvent traits

Browse Source
This commit is contained in:
Ragotzy.devin 2020-05-08 12:58:37 -04:00 committed by Jonas Platte
parent c1ee72db0f
commit 3d01bfa96d
No known key found for this signature in database
GPG Key ID: 7D261D771D915378
14 changed files with 93 additions and 664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
ruma-events-macros/src/gen.rs
View File

@ -1,4 +1,7 @@
//! Details of generating code for the `ruma_event` procedural macro. //! Details of generating code for the `ruma_event` procedural macro.
#![allow(dead_code)]
use proc_macro2::{Span, TokenStream}; use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote, quote_spanned, ToTokens}; use quote::{format_ident, quote, quote_spanned, ToTokens};
use syn::{ use syn::{
@ -75,18 +78,9 @@ impl ToTokens for RumaEvent {
// allowance. // allowance.
#[allow(clippy::cognitive_complexity)] #[allow(clippy::cognitive_complexity)]
fn to_tokens(&self, tokens: &mut TokenStream) { fn to_tokens(&self, tokens: &mut TokenStream) {
let attrs = &self.attrs; // let attrs = &self.attrs;
let content_name = &self.content_name; let content_name = &self.content_name;
let event_fields = &self.fields; // let event_fields = &self.fields;
let event_type_variant = {
let event_type = to_camel_case(self.event_type.value());
let variant = Ident::new(&event_type, event_type.span());
quote! {
::ruma_events::EventType::#variant
}
};
let name = &self.name; let name = &self.name;
let content_docstring = format!("The payload for `{}`.", name); let content_docstring = format!("The payload for `{}`.", name);
@ -125,61 +119,6 @@ impl ToTokens for RumaEvent {
Content::Typedef(_) => TokenStream::new(), Content::Typedef(_) => TokenStream::new(),
}; };
let impl_room_event = match self.kind {
EventKind::RoomEvent | EventKind::StateEvent => {
quote! {
impl ::ruma_events::RoomEvent for #name {
/// The unique identifier for the event.
fn event_id(&self) -> &ruma_identifiers::EventId {
&self.event_id
}
/// Time on originating homeserver when this event was sent.
fn origin_server_ts(&self) -> std::time::SystemTime {
self.origin_server_ts
}
/// The unique identifier for the room associated with this event.
///
/// This can be `None` if the event came from a context where there is
/// no ambiguity which room it belongs to, like a `/sync` response for example.
fn room_id(&self) -> Option<&ruma_identifiers::RoomId> {
self.room_id.as_ref()
}
/// The unique identifier for the user who sent this event.
fn sender(&self) -> &ruma_identifiers::UserId {
&self.sender
}
/// Additional key-value pairs not signed by the homeserver.
fn unsigned(&self) -> &ruma_events::UnsignedData {
&self.unsigned
}
}
}
}
_ => TokenStream::new(),
};
let impl_state_event = if self.kind == EventKind::StateEvent {
quote! {
impl ::ruma_events::StateEvent for #name {
/// The previous content for this state key, if any.
fn prev_content(&self) -> Option<&Self::Content> {
self.prev_content.as_ref()
}
/// A key that determines which piece of room state the event represents.
fn state_key(&self) -> &str {
&self.state_key
}
}
}
} else {
TokenStream::new()
};
let impl_event_result_compatible_for_content = let impl_event_result_compatible_for_content =
if let Content::Struct(content_fields) = &self.content { if let Content::Struct(content_fields) = &self.content {
let mut content_field_values: Vec<TokenStream> = let mut content_field_values: Vec<TokenStream> =
@ -213,48 +152,16 @@ impl ToTokens for RumaEvent {
TokenStream::new() TokenStream::new()
}; };
let event_type_name = self.event_type.value(); // let event_type_name = self.event_type.value();
let output = quote!( let output = quote!(
#(#attrs)*
#[derive(Clone, Debug, serde::Serialize, ruma_events_macros::FromRaw)]
#[serde(rename = #event_type_name, tag = "type")]
pub struct #name {
#(#event_fields),*
}
#content #content
#impl_event_result_compatible_for_content #impl_event_result_compatible_for_content
impl ::ruma_events::Event for #name {
/// The type of this event's `content` field.
type Content = #content_name;
/// The event's content.
fn content(&self) -> &Self::Content {
&self.content
}
/// The type of the event.
fn event_type(&self) -> ::ruma_events::EventType {
#event_type_variant
}
}
#impl_room_event
#impl_state_event
/// "Raw" versions of the event and its content which implement `serde::Deserialize`. /// "Raw" versions of the event and its content which implement `serde::Deserialize`.
pub(crate) mod raw { pub(crate) mod raw {
use super::*; use super::*;
#(#attrs)*
#[derive(Clone, Debug, serde::Deserialize)]
pub struct #name {
#(#event_fields),*
}
#raw_content #raw_content
} }
); );

119
src/custom.rs
View File

@ -2,7 +2,7 @@
use std::time::SystemTime; use std::time::SystemTime;
use crate::{Event, EventType, RoomEvent, StateEvent, UnsignedData}; use crate::{EventType, UnsignedData};
use ruma_events_macros::FromRaw; use ruma_events_macros::FromRaw;
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
@ -22,21 +22,6 @@ pub struct CustomEvent {
/// The payload for `CustomEvent`. /// The payload for `CustomEvent`.
pub type CustomEventContent = JsonValue; pub type CustomEventContent = JsonValue;
impl Event for CustomEvent {
/// The type of this event's `content` field.
type Content = CustomEventContent;
/// The event's content.
fn content(&self) -> &Self::Content {
&self.content
}
/// The type of the event.
fn event_type(&self) -> EventType {
EventType::Custom(self.event_type.clone())
}
}
/// A custom room event not covered by the Matrix specification. /// A custom room event not covered by the Matrix specification.
#[derive(Clone, Debug, FromRaw, Serialize)] #[derive(Clone, Debug, FromRaw, Serialize)]
pub struct CustomRoomEvent { pub struct CustomRoomEvent {
@ -62,51 +47,6 @@ pub struct CustomRoomEvent {
/// The payload for `CustomRoomEvent`. /// The payload for `CustomRoomEvent`.
pub type CustomRoomEventContent = JsonValue; pub type CustomRoomEventContent = JsonValue;
impl Event for CustomRoomEvent {
/// The type of this event's `content` field.
type Content = CustomRoomEventContent;
/// The event's content.
fn content(&self) -> &Self::Content {
&self.content
}
/// The type of the event.
fn event_type(&self) -> EventType {
EventType::Custom(self.event_type.clone())
}
}
impl RoomEvent for CustomRoomEvent {
/// The unique identifier for the event.
fn event_id(&self) -> &EventId {
&self.event_id
}
/// Time on originating homeserver when this event was sent.
fn origin_server_ts(&self) -> SystemTime {
self.origin_server_ts
}
/// The unique identifier for the room associated with this event.
///
/// This can be `None` if the event came from a context where there is
/// no ambiguity which room it belongs to, like a `/sync` response for example.
fn room_id(&self) -> Option<&RoomId> {
self.room_id.as_ref()
}
/// The unique identifier for the user who sent this event.
fn sender(&self) -> &UserId {
&self.sender
}
/// Additional key-value pairs not signed by the homeserver.
fn unsigned(&self) -> &UnsignedData {
&self.unsigned
}
}
/// A custom state event not covered by the Matrix specification. /// A custom state event not covered by the Matrix specification.
#[derive(Clone, Debug, FromRaw, Serialize)] #[derive(Clone, Debug, FromRaw, Serialize)]
pub struct CustomStateEvent { pub struct CustomStateEvent {
@ -136,63 +76,6 @@ pub struct CustomStateEvent {
/// The payload for `CustomStateEvent`. /// The payload for `CustomStateEvent`.
pub type CustomStateEventContent = JsonValue; pub type CustomStateEventContent = JsonValue;
impl Event for CustomStateEvent {
/// The type of this event's `content` field.
type Content = CustomStateEventContent;
/// The event's content.
fn content(&self) -> &Self::Content {
&self.content
}
/// The type of the event.
fn event_type(&self) -> EventType {
EventType::Custom(self.event_type.clone())
}
}
impl RoomEvent for CustomStateEvent {
/// The unique identifier for the event.
fn event_id(&self) -> &EventId {
&self.event_id
}
/// Time on originating homeserver when this event was sent.
fn origin_server_ts(&self) -> SystemTime {
self.origin_server_ts
}
/// The unique identifier for the room associated with this event.
///
/// This can be `None` if the event came from a context where there is
/// no ambiguity which room it belongs to, like a `/sync` response for example.
fn room_id(&self) -> Option<&RoomId> {
self.room_id.as_ref()
}
/// The unique identifier for the user who sent this event.
fn sender(&self) -> &UserId {
&self.sender
}
/// Additional key-value pairs not signed by the homeserver.
fn unsigned(&self) -> &UnsignedData {
&self.unsigned
}
}
impl StateEvent for CustomStateEvent {
/// The previous content for this state key, if any.
fn prev_content(&self) -> Option<&Self::Content> {
self.prev_content.as_ref()
}
/// A key that determines which piece of room state the event represents.
fn state_key(&self) -> &str {
&self.state_key
}
}
pub(crate) mod raw { pub(crate) mod raw {
use std::time::SystemTime; use std::time::SystemTime;

8
src/key/verification/start.rs
View File

@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
use super::{ use super::{
HashAlgorithm, KeyAgreementProtocol, MessageAuthenticationCode, ShortAuthenticationString, HashAlgorithm, KeyAgreementProtocol, MessageAuthenticationCode, ShortAuthenticationString,
}; };
use crate::{EventType, InvalidInput, TryFromRaw}; use crate::{InvalidInput, TryFromRaw};
/// Begins an SAS key verification process. /// Begins an SAS key verification process.
/// ///
@ -36,12 +36,6 @@ impl TryFromRaw for StartEvent {
} }
} }
impl_event!(
StartEvent,
StartEventContent,
EventType::KeyVerificationStart
);
impl TryFromRaw for StartEventContent { impl TryFromRaw for StartEventContent {
type Raw = raw::StartEventContent; type Raw = raw::StartEventContent;
type Err = &'static str; type Err = &'static str;

93
src/lib.rs
View File

@ -113,23 +113,22 @@
#![warn(missing_debug_implementations, missing_docs, rust_2018_idioms)] #![warn(missing_debug_implementations, missing_docs, rust_2018_idioms)]
// Since we support Rust 1.36.0, we can't apply this suggestion yet // Since we support Rust 1.36.0, we can't apply this suggestion yet
#![allow(clippy::use_self)] #![allow(clippy::use_self)]
#![allow(dead_code)]
#![allow(unused_imports)]
use std::{fmt::Debug, time::SystemTime}; use std::fmt::Debug;
use js_int::Int; use js_int::Int;
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use self::room::redaction::RedactionEvent; // use self::room::redaction::RedactionEvent;
pub use self::custom::{CustomEvent, CustomRoomEvent, CustomStateEvent}; pub use self::custom::{CustomEvent, CustomRoomEvent, CustomStateEvent};
#[deprecated = "Use ruma_serde::empty::Empty directly instead."] #[deprecated = "Use ruma_serde::empty::Empty directly instead."]
pub use ruma_serde::empty::Empty; pub use ruma_serde::empty::Empty;
#[macro_use]
mod macros;
mod algorithm; mod algorithm;
mod error; mod error;
mod event_type; mod event_type;
@ -145,31 +144,31 @@ extern crate self as ruma_events;
pub mod call; pub mod call;
pub mod custom; pub mod custom;
/// Enums for heterogeneous collections of events. /// Enums for heterogeneous collections of events.
pub mod collections { // pub mod collections {
pub mod all; // pub mod all;
pub mod only; // pub mod only;
mod raw { // mod raw {
pub mod all; // pub mod all;
pub mod only; // pub mod only;
} // }
} // }
pub mod direct; // pub mod direct;
pub mod dummy; // pub mod dummy;
pub mod forwarded_room_key; pub mod forwarded_room_key;
pub mod fully_read; pub mod fully_read;
pub mod ignored_user_list; // pub mod ignored_user_list;
pub mod key; pub mod key;
pub mod presence; // pub mod presence;
pub mod push_rules; // pub mod push_rules;
pub mod receipt; pub mod receipt;
pub mod room; pub mod room;
pub mod room_key; // pub mod room_key;
pub mod room_key_request; pub mod room_key_request;
pub mod sticker; pub mod sticker;
pub mod stripped; // pub mod stripped;
pub mod tag; pub mod tag;
pub mod to_device; // pub mod to_device;
pub mod typing; pub mod typing;
pub use self::{ pub use self::{
@ -180,48 +179,6 @@ pub use self::{
json::EventJson, json::EventJson,
}; };
/// A basic event.
pub trait Event: Debug + Serialize + Sized + TryFromRaw {
/// The type of this event's `content` field.
type Content: Debug + Serialize;
/// The event's content.
fn content(&self) -> &Self::Content;
/// The type of the event.
fn event_type(&self) -> EventType;
}
/// An event within the context of a room.
pub trait RoomEvent: Event {
/// The unique identifier for the event.
fn event_id(&self) -> &EventId;
/// Time on originating homeserver when this event was sent.
fn origin_server_ts(&self) -> SystemTime;
/// The unique identifier for the room associated with this event.
///
/// This can be `None` if the event came from a context where there is
/// no ambiguity which room it belongs to, like a `/sync` response for example.
fn room_id(&self) -> Option<&RoomId>;
/// The unique identifier for the user who sent this event.
fn sender(&self) -> &UserId;
/// Additional key-value pairs not signed by the homeserver.
fn unsigned(&self) -> &UnsignedData;
}
/// An event that describes persistent state about a room.
pub trait StateEvent: RoomEvent {
/// The previous content for this state key, if any.
fn prev_content(&self) -> Option<&Self::Content>;
/// A key that determines which piece of room state the event represents.
fn state_key(&self) -> &str;
}
/// Extra information about an event that is not incorporated into the event's /// Extra information about an event that is not incorporated into the event's
/// hash. /// hash.
#[derive(Clone, Debug, Default, Deserialize, Serialize)] #[derive(Clone, Debug, Default, Deserialize, Serialize)]
@ -233,10 +190,9 @@ pub struct UnsignedData {
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
pub age: Option<Int>, pub age: Option<Int>,
/// The event that redacted this event, if any. // /// The event that redacted this event, if any.
#[serde(skip_serializing_if = "Option::is_none")] // #[serde(skip_serializing_if = "Option::is_none")]
pub redacted_because: Option<EventJson<RedactionEvent>>, // pub redacted_because: Option<EventJson<RedactionEvent>>,
/// The client-supplied transaction ID, if the client being given the event /// The client-supplied transaction ID, if the client being given the event
/// is the same one which sent it. /// is the same one which sent it.
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
@ -251,6 +207,7 @@ impl UnsignedData {
/// an incoming `unsigned` field was present - it could still have been /// an incoming `unsigned` field was present - it could still have been
/// present but contained none of the known fields. /// present but contained none of the known fields.
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.age.is_none() && self.redacted_because.is_none() && self.transaction_id.is_none() self.age.is_none() && self.transaction_id.is_none()
// && self.redacted_because.is_none()
} }
} }

82
src/macros.rs
View File

@ -1,82 +0,0 @@
macro_rules! impl_event {
($name:ident, $content_name:ident, $event_type:path) => {
impl crate::Event for $name {
/// The type of this event's `content` field.
type Content = $content_name;
/// The event's content.
fn content(&self) -> &Self::Content {
&self.content
}
/// The type of the event.
fn event_type(&self) -> crate::EventType {
$event_type
}
}
};
}
macro_rules! impl_room_event {
($name:ident, $content_name:ident, $event_type:path) => {
impl_event!($name, $content_name, $event_type);
impl crate::RoomEvent for $name {
/// The unique identifier for the event.
fn event_id(&self) -> &EventId {
&self.event_id
}
/// Time on originating homeserver when this event was sent.
fn origin_server_ts(&self) -> ::std::time::SystemTime {
self.origin_server_ts
}
/// The unique identifier for the room associated with this event.
///
/// This can be `None` if the event came from a context where there is
/// no ambiguity which room it belongs to, like a `/sync` response for example.
fn room_id(&self) -> Option<&::ruma_identifiers::RoomId> {
self.room_id.as_ref()
}
/// The unique identifier for the user who sent this event.
fn sender(&self) -> &::ruma_identifiers::UserId {
&self.sender
}
/// Additional key-value pairs not signed by the homeserver.
fn unsigned(&self) -> &::ruma_events::UnsignedData {
&self.unsigned
}
}
};
}
macro_rules! impl_state_event {
($name:ident, $content_name:ident, $event_type:path) => {
impl_room_event!($name, $content_name, $event_type);
impl crate::StateEvent for $name {
/// The previous content for this state key, if any.
fn prev_content(&self) -> Option<&Self::Content> {
self.prev_content.as_ref()
}
/// A key that determines which piece of room state the event represents.
fn state_key(&self) -> &str {
&self.state_key
}
}
};
}
macro_rules! impl_from_for_enum {
($self_ty:ident, $inner_ty:ty, $variant:ident) => {
impl ::std::convert::From<$inner_ty> for $self_ty {
fn from(event: $inner_ty) -> Self {
$self_ty::$variant(event)
}
}
};
}

2
src/presence.rs
View File

@ -51,7 +51,7 @@ mod tests {
use ruma_identifiers::UserId; use ruma_identifiers::UserId;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value}; use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{PresenceEvent, PresenceEventContent, PresenceState}; use super::{PresenceEventContent, PresenceState};
use crate::EventJson; use crate::EventJson;
#[test] #[test]

2
src/push_rules.rs
View File

@ -153,7 +153,7 @@ mod tests {
use matches::assert_matches; use matches::assert_matches;
use serde_json::{from_value as from_json_value, json, to_value as to_json_value}; use serde_json::{from_value as from_json_value, json, to_value as to_json_value};
use super::{PushCondition, PushRulesEvent}; use super::PushCondition;
use crate::EventJson; use crate::EventJson;
#[test] #[test]

14
src/room.rs
View File

@ -9,20 +9,20 @@ use serde::{Deserialize, Serialize};
pub mod aliases; pub mod aliases;
pub mod avatar; pub mod avatar;
pub mod canonical_alias; // pub mod canonical_alias;
pub mod create; pub mod create;
pub mod encrypted; pub mod encrypted;
pub mod encryption; pub mod encryption;
pub mod guest_access; pub mod guest_access;
pub mod history_visibility; pub mod history_visibility;
pub mod join_rules; pub mod join_rules;
pub mod member; // pub mod member;
pub mod message; // pub mod message;
pub mod name; // pub mod name;
pub mod pinned_events; // pub mod pinned_events;
pub mod power_levels; // pub mod power_levels;
pub mod redaction; pub mod redaction;
pub mod server_acl; // pub mod server_acl;
pub mod third_party_invite; pub mod third_party_invite;
pub mod tombstone; pub mod tombstone;
pub mod topic; pub mod topic;

79
src/room/encrypted.rs
View File

@ -6,36 +6,7 @@ use js_int::UInt;
use ruma_identifiers::{DeviceId, EventId, RoomId, UserId}; use ruma_identifiers::{DeviceId, EventId, RoomId, UserId};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::{EventType, FromRaw, UnsignedData}; use crate::{FromRaw, UnsignedData};
/// This event type is used when sending encrypted events.
///
/// This type is to be used within a room. For a to-device event, use `EncryptedEventContent`
/// directly.
#[derive(Clone, Debug, Serialize)]
#[serde(tag = "type", rename = "m.room.encrypted")]
pub struct EncryptedEvent {
/// The event's content.
pub content: EncryptedEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Time on originating homeserver when this event was sent.
#[serde(with = "ruma_serde::time::ms_since_unix_epoch")]
pub origin_server_ts: SystemTime,
/// The unique identifier for the room associated with this event.
#[serde(skip_serializing_if = "Option::is_none")]
pub room_id: Option<RoomId>,
/// The unique identifier for the user who sent this event.
pub sender: UserId,
/// Additional key-value pairs not signed by the homeserver.
#[serde(skip_serializing_if = "UnsignedData::is_empty")]
pub unsigned: UnsignedData,
}
/// The payload for `EncryptedEvent`. /// The payload for `EncryptedEvent`.
#[derive(Clone, Debug, Serialize)] #[derive(Clone, Debug, Serialize)]
@ -51,21 +22,6 @@ pub enum EncryptedEventContent {
MegolmV1AesSha2(MegolmV1AesSha2Content), MegolmV1AesSha2(MegolmV1AesSha2Content),
} }
impl FromRaw for EncryptedEvent {
type Raw = raw::EncryptedEvent;
fn from_raw(raw: raw::EncryptedEvent) -> Self {
Self {
content: FromRaw::from_raw(raw.content),
event_id: raw.event_id,
origin_server_ts: raw.origin_server_ts,
room_id: raw.room_id,
sender: raw.sender,
unsigned: raw.unsigned,
}
}
}
impl FromRaw for EncryptedEventContent { impl FromRaw for EncryptedEventContent {
type Raw = raw::EncryptedEventContent; type Raw = raw::EncryptedEventContent;
@ -81,12 +37,6 @@ impl FromRaw for EncryptedEventContent {
} }
} }
impl_room_event!(
EncryptedEvent,
EncryptedEventContent,
EventType::RoomEncrypted
);
pub(crate) mod raw { pub(crate) mod raw {
use std::time::SystemTime; use std::time::SystemTime;
@ -96,33 +46,6 @@ pub(crate) mod raw {
use super::{MegolmV1AesSha2Content, OlmV1Curve25519AesSha2Content}; use super::{MegolmV1AesSha2Content, OlmV1Curve25519AesSha2Content};
use crate::UnsignedData; use crate::UnsignedData;
/// This event type is used when sending encrypted events.
///
/// This type is to be used within a room. For a to-device event, use `EncryptedEventContent`
/// directly.
#[derive(Clone, Debug, Deserialize)]
pub struct EncryptedEvent {
/// The event's content.
pub content: EncryptedEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Time on originating homeserver when this event was sent.
#[serde(with = "ruma_serde::time::ms_since_unix_epoch")]
pub origin_server_ts: SystemTime,
/// The unique identifier for the room associated with this event.
pub room_id: Option<RoomId>,
/// The unique identifier for the user who sent this event.
pub sender: UserId,
/// Additional key-value pairs not signed by the homeserver.
#[serde(default)]
pub unsigned: UnsignedData,
}
/// The payload for `EncryptedEvent`. /// The payload for `EncryptedEvent`.
#[derive(Clone, Debug, Deserialize)] #[derive(Clone, Debug, Deserialize)]
#[serde(tag = "algorithm")] #[serde(tag = "algorithm")]

76
src/room/member.rs
View File

@ -154,44 +154,44 @@ pub enum MembershipChange {
NotImplemented, NotImplemented,
} }
impl MemberEvent { // impl MemberEvent {
/// Helper function for membership change. Check [the specification][spec] for details. // /// Helper function for membership change. Check [the specification][spec] for details.
/// // ///
/// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member // /// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
pub fn membership_change(&self) -> MembershipChange { // pub fn membership_change(&self) -> MembershipChange {
use MembershipState::*; // use MembershipState::*;
let prev_membership = if let Some(prev_content) = &self.prev_content { // let prev_membership = if let Some(prev_content) = &self.prev_content {
prev_content.membership // prev_content.membership
} else { // } else {
Leave // Leave
}; // };
match (prev_membership, &self.content.membership) { // match (prev_membership, &self.content.membership) {
(Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None, // (Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None,
(Invite, Join) | (Leave, Join) => MembershipChange::Joined, // (Invite, Join) | (Leave, Join) => MembershipChange::Joined,
(Invite, Leave) => { // (Invite, Leave) => {
if self.sender == self.state_key { // if self.sender == self.state_key {
MembershipChange::InvitationRevoked // MembershipChange::InvitationRevoked
} else { // } else {
MembershipChange::InvitationRejected // MembershipChange::InvitationRejected
} // }
} // }
(Invite, Ban) | (Leave, Ban) => MembershipChange::Banned, // (Invite, Ban) | (Leave, Ban) => MembershipChange::Banned,
(Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error, // (Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error,
(Join, Join) => MembershipChange::ProfileChanged, // (Join, Join) => MembershipChange::ProfileChanged,
(Join, Leave) => { // (Join, Leave) => {
if self.sender == self.state_key { // if self.sender == self.state_key {
MembershipChange::Left // MembershipChange::Left
} else { // } else {
MembershipChange::Kicked // MembershipChange::Kicked
} // }
} // }
(Join, Ban) => MembershipChange::KickedAndBanned, // (Join, Ban) => MembershipChange::KickedAndBanned,
(Leave, Invite) => MembershipChange::Invited, // (Leave, Invite) => MembershipChange::Invited,
(Ban, Leave) => MembershipChange::Unbanned, // (Ban, Leave) => MembershipChange::Unbanned,
(Knock, _) | (_, Knock) => MembershipChange::NotImplemented, // (Knock, _) | (_, Knock) => MembershipChange::NotImplemented,
} // }
} // }
} // }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {

69
src/room/message.rs
View File

@ -7,36 +7,10 @@ use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use super::{EncryptedFile, ImageInfo, ThumbnailInfo}; use super::{EncryptedFile, ImageInfo, ThumbnailInfo};
use crate::{EventType, FromRaw, UnsignedData}; use crate::{FromRaw, UnsignedData};
pub mod feedback; pub mod feedback;
/// A message sent to a room.
#[derive(Clone, Debug, Serialize)]
#[serde(rename = "m.room.message", tag = "type")]
pub struct MessageEvent {
/// The event's content.
pub content: MessageEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Time on originating homeserver when this event was sent.
#[serde(with = "ruma_serde::time::ms_since_unix_epoch")]
pub origin_server_ts: SystemTime,
/// The unique identifier for the room associated with this event.
#[serde(skip_serializing_if = "Option::is_none")]
pub room_id: Option<RoomId>,
/// The unique identifier for the user who sent this event.
pub sender: UserId,
/// Additional key-value pairs not signed by the homeserver.
#[serde(skip_serializing_if = "UnsignedData::is_empty")]
pub unsigned: UnsignedData,
}
/// The payload for `MessageEvent`. /// The payload for `MessageEvent`.
#[derive(Clone, Debug, Serialize)] #[derive(Clone, Debug, Serialize)]
#[serde(tag = "msgtype")] #[serde(tag = "msgtype")]
@ -78,21 +52,6 @@ pub enum MessageEventContent {
Video(VideoMessageEventContent), Video(VideoMessageEventContent),
} }
impl FromRaw for MessageEvent {
type Raw = raw::MessageEvent;
fn from_raw(raw: raw::MessageEvent) -> Self {
Self {
content: FromRaw::from_raw(raw.content),
event_id: raw.event_id,
origin_server_ts: raw.origin_server_ts,
room_id: raw.room_id,
sender: raw.sender,
unsigned: raw.unsigned,
}
}
}
impl FromRaw for MessageEventContent { impl FromRaw for MessageEventContent {
type Raw = raw::MessageEventContent; type Raw = raw::MessageEventContent;
@ -113,8 +72,6 @@ impl FromRaw for MessageEventContent {
} }
} }
impl_room_event!(MessageEvent, MessageEventContent, EventType::RoomMessage);
pub(crate) mod raw { pub(crate) mod raw {
use std::time::SystemTime; use std::time::SystemTime;
@ -128,30 +85,6 @@ pub(crate) mod raw {
}; };
use crate::UnsignedData; use crate::UnsignedData;
/// A message sent to a room.
#[derive(Clone, Debug, Deserialize)]
pub struct MessageEvent {
/// The event's content.
pub content: MessageEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Time on originating homeserver when this event was sent.
#[serde(with = "ruma_serde::time::ms_since_unix_epoch")]
pub origin_server_ts: SystemTime,
/// The unique identifier for the room associated with this event.
pub room_id: Option<RoomId>,
/// The unique identifier for the user who sent this event.
pub sender: UserId,
/// Additional key-value pairs not signed by the homeserver.
#[serde(default)]
pub unsigned: UnsignedData,
}
/// The payload for `MessageEvent`. /// The payload for `MessageEvent`.
#[allow(clippy::large_enum_variant)] #[allow(clippy::large_enum_variant)]
#[derive(Clone, Debug, Deserialize)] #[derive(Clone, Debug, Deserialize)]

90
src/room/name.rs
View File

@ -5,40 +5,7 @@ use std::time::SystemTime;
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::{EventType, InvalidInput, TryFromRaw, UnsignedData}; use crate::{InvalidInput, TryFromRaw, UnsignedData};
/// A human-friendly room name designed to be displayed to the end-user.
#[derive(Clone, Debug, Serialize)]
#[serde(rename = "m.room.name", tag = "type")]
pub struct NameEvent {
/// The event's content.
pub content: NameEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Time on originating homeserver when this event was sent.
#[serde(with = "ruma_serde::time::ms_since_unix_epoch")]
pub origin_server_ts: SystemTime,
/// The previous content for this state key, if any.
#[serde(skip_serializing_if = "Option::is_none")]
pub prev_content: Option<NameEventContent>,
/// The unique identifier for the room associated with this event.
#[serde(skip_serializing_if = "Option::is_none")]
pub room_id: Option<RoomId>,
/// The unique identifier for the user who sent this event.
pub sender: UserId,
/// A key that determines which piece of room state the event represents.
pub state_key: String,
/// Additional key-value pairs not signed by the homeserver.
#[serde(skip_serializing_if = "UnsignedData::is_empty")]
pub unsigned: UnsignedData,
}
/// The payload for `NameEvent`. /// The payload for `NameEvent`.
#[derive(Clone, Debug, Serialize)] #[derive(Clone, Debug, Serialize)]
@ -47,27 +14,6 @@ pub struct NameEventContent {
pub(crate) name: Option<String>, pub(crate) name: Option<String>,
} }
impl TryFromRaw for NameEvent {
type Raw = raw::NameEvent;
type Err = InvalidInput;
fn try_from_raw(raw: Self::Raw) -> Result<Self, Self::Err> {
let content = TryFromRaw::try_from_raw(raw.content)?;
let prev_content = raw.prev_content.map(TryFromRaw::try_from_raw).transpose()?;
Ok(NameEvent {
content,
event_id: raw.event_id,
origin_server_ts: raw.origin_server_ts,
prev_content,
room_id: raw.room_id,
sender: raw.sender,
state_key: raw.state_key,
unsigned: raw.unsigned,
})
}
}
impl TryFromRaw for NameEventContent { impl TryFromRaw for NameEventContent {
type Raw = raw::NameEventContent; type Raw = raw::NameEventContent;
@ -81,8 +27,6 @@ impl TryFromRaw for NameEventContent {
} }
} }
impl_state_event!(NameEvent, NameEventContent, EventType::RoomName);
impl NameEventContent { impl NameEventContent {
/// Create a new `NameEventContent` with the given name. /// Create a new `NameEventContent` with the given name.
/// ///
@ -108,36 +52,6 @@ impl NameEventContent {
pub(crate) mod raw { pub(crate) mod raw {
use super::*; use super::*;
/// A human-friendly room name designed to be displayed to the end-user.
#[derive(Clone, Debug, Deserialize)]
pub struct NameEvent {
/// The event's content.
pub content: NameEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Time on originating homeserver when this event was sent.
#[serde(with = "ruma_serde::time::ms_since_unix_epoch")]
pub origin_server_ts: SystemTime,
/// The previous content for this state key, if any.
pub prev_content: Option<NameEventContent>,
/// The unique identifier for the room associated with this event.
pub room_id: Option<RoomId>,
/// The unique identifier for the user who sent this event.
pub sender: UserId,
/// A key that determines which piece of room state the event represents.
pub state_key: String,
/// Additional key-value pairs not signed by the homeserver.
#[serde(default)]
pub unsigned: UnsignedData,
}
/// The payload of a `NameEvent`. /// The payload of a `NameEvent`.
#[derive(Clone, Debug, Deserialize)] #[derive(Clone, Debug, Deserialize)]
pub struct NameEventContent { pub struct NameEventContent {
@ -164,7 +78,7 @@ mod tests {
use crate::{EventJson, UnsignedData}; use crate::{EventJson, UnsignedData};
use super::{NameEvent, NameEventContent}; use super::NameEventContent;
#[test] #[test]
fn serialization_with_optional_fields_as_none() { fn serialization_with_optional_fields_as_none() {

18
src/room/pinned_events.rs
View File

@ -24,7 +24,7 @@ mod tests {
use crate::{ use crate::{
room::pinned_events::{PinnedEventsEvent, PinnedEventsEventContent}, room::pinned_events::{PinnedEventsEvent, PinnedEventsEventContent},
Event, EventJson, RoomEvent, StateEvent, UnsignedData, EventJson, UnsignedData,
}; };
#[test] #[test]
@ -52,14 +52,14 @@ mod tests {
.deserialize() .deserialize()
.unwrap(); .unwrap();
assert_eq!(parsed_event.event_id(), event.event_id()); assert_eq!(parsed_event.event_id, event.event_id);
assert_eq!(parsed_event.room_id(), event.room_id()); assert_eq!(parsed_event.room_id, event.room_id);
assert_eq!(parsed_event.sender(), event.sender()); assert_eq!(parsed_event.sender, event.sender);
assert_eq!(parsed_event.state_key(), event.state_key()); assert_eq!(parsed_event.state_key, event.state_key);
assert_eq!(parsed_event.origin_server_ts(), event.origin_server_ts()); assert_eq!(parsed_event.origin_server_ts, event.origin_server_ts);
assert_eq!(parsed_event.content().pinned, event.content.pinned); assert_eq!(parsed_event.content.pinned, event.content.pinned);
assert_eq!(parsed_event.content().pinned[0], content.pinned[0]); assert_eq!(parsed_event.content.pinned[0], content.pinned[0]);
assert_eq!(parsed_event.content().pinned[1], content.pinned[1]); assert_eq!(parsed_event.content.pinned[1], content.pinned[1]);
} }
} }

0
tests/ruma_events_macros.rs → tests_backup/ruma_events_macros.rs
View File