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

Integrate generic event types and EventContent trait with TryFromRaw

Browse Source
This commit is contained in:
Jonas Platte 2020-05-31 17:29:22 +02:00
parent 3814690b29
commit 5091b9a9a8
No known key found for this signature in database
GPG Key ID: 7D261D771D915378
8 changed files with 420 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ruma-events-macros/src/collection.rs
View File

@ -28,8 +28,8 @@ pub fn expand_collection(input: RumaCollectionInput) -> syn::Result<TokenStream>
let collection = quote! {
#( #attrs )*
#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
#[derive(Clone, Debug, /*Serialize*/)]
//#[serde(untagged)]
#[allow(clippy::large_enum_variant)]
pub enum #ident {
#( #variants ),*

11
ruma-events-macros/src/event_content.rs
View File

@ -52,19 +52,18 @@ fn expand_room_event(input: DeriveInput) -> syn::Result<TokenStream> {
fn event_type(&self) -> &str {
#event_type
}
}
impl ::ruma_events::RawEventContent for raw::#ident {
fn from_parts(
ev_type: &str,
content: Box<::serde_json::value::RawValue>
) -> Result<Self, ::ruma_events::InvalidEvent> {
) -> Result<Self, String> {
if ev_type != #event_type {
return Err(
::ruma_events::InvalidEvent::wrong_event_type(#event_type, ev_type)
);
return Err(format!("expected `{}` found {}", #event_type, ev_type));
}
let ev_json = ::ruma_events::EventJson::from(content);
ev_json.deserialize()
::serde_json::from_str(content.get()).map_err(|e| e.to_string())
}
}
};

4
src/from_raw.rs
View File

@ -9,7 +9,7 @@ use serde::de::DeserializeOwned;
/// [try]: trait.TryFromRaw.html
pub trait FromRaw: Sized {
/// The raw type.
type Raw: DeserializeOwned;
type Raw;
/// Converts the raw type to `Self`.
fn from_raw(_: Self::Raw) -> Self;
@ -19,7 +19,7 @@ pub trait FromRaw: Sized {
/// corresponding 'raw' type, a potentially invalid representation that can be converted to `Self`.
pub trait TryFromRaw: Sized {
/// The raw type.
type Raw: DeserializeOwned;
type Raw;
/// The error type returned if conversion fails.
type Err: Display;

35
src/json.rs
View File

@ -5,14 +5,14 @@ use std::{
};
use serde::{
de::{Deserialize, Deserializer},
de::{Deserialize, DeserializeOwned, Deserializer},
ser::{Serialize, Serializer},
};
use serde_json::value::RawValue;
use crate::{
error::{InvalidEvent, InvalidEventKind},
TryFromRaw,
EventContent, RawEventContent, TryFromRaw,
};
/// A wrapper around `Box<RawValue>`, to be used in place of event [content] [collection] types in
@ -42,7 +42,10 @@ impl<T> EventJson<T> {
}
}
impl<T: TryFromRaw> EventJson<T> {
impl<T: TryFromRaw> EventJson<T>
where
T::Raw: DeserializeOwned,
{
/// Try to deserialize the JSON into the expected event type.
pub fn deserialize(&self) -> Result<T, InvalidEvent> {
let raw_ev: T::Raw = match serde_json::from_str(self.json.get()) {
@ -65,6 +68,32 @@ impl<T: TryFromRaw> EventJson<T> {
}
}
impl<T: EventContent> EventJson<T>
where
T::Raw: RawEventContent,
{
/// Try to deserialize the JSON as event content
pub fn deserialize_content(self, event_type: &str) -> Result<T, InvalidEvent> {
let raw_content = match T::Raw::from_parts(event_type, self.json) {
Ok(raw) => raw,
Err(message) => {
return Err(InvalidEvent {
message,
kind: InvalidEventKind::Deserialization,
});
}
};
match T::try_from_raw(raw_content) {
Ok(value) => Ok(value),
Err(err) => Err(InvalidEvent {
message: err.to_string(),
kind: InvalidEventKind::Validation,
}),
}
}
}
impl<T: Serialize> From<&T> for EventJson<T> {
fn from(val: &T) -> Self {
Self::new(serde_json::value::to_raw_value(val).unwrap())

34
src/lib.rs
View File

@ -168,7 +168,7 @@ pub use self::{
event_type::EventType,
from_raw::{FromRaw, TryFromRaw},
json::EventJson,
state::{AnyStateEventContent, StateEvent},
state::StateEvent,
};
/// Extra information about an event that is not incorporated into the event's
@ -207,19 +207,37 @@ impl UnsignedData {
/// The base trait that all event content types implement.
///
/// Implementing this trait allows content types to be serialized as well as deserialized.
pub trait EventContent: Sized + Serialize {
/// Constructs the given event content.
fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, InvalidEvent>;
pub trait EventContent: TryFromRaw + Serialize
where
Self::Raw: RawEventContent,
{
/// A matrix event identifier, like `m.room.message`.
fn event_type(&self) -> &str;
}
#[doc(hidden)]
pub trait RawEventContent: Sized {
/// Constructs the given event content.
fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, String>;
}
/// Marker trait for the content of a room event.
pub trait RoomEventContent: EventContent {}
pub trait RoomEventContent: EventContent
where
Self::Raw: RawEventContent,
{
}
/// Marker trait for the content of a message event.
pub trait MessageEventContent: RoomEventContent {}
pub trait MessageEventContent: RoomEventContent
where
Self::Raw: RawEventContent,
{
}
/// Marker trait for the content of a state event.
pub trait StateEventContent: RoomEventContent {}
pub trait StateEventContent: RoomEventContent
where
Self::Raw: RawEventContent,
{
}

2
src/room.rs
View File

@ -16,7 +16,7 @@ pub mod encryption;
pub mod guest_access;
pub mod history_visibility;
pub mod join_rules;
// pub mod member;
pub mod member;
// pub mod message;
// pub mod name;
// pub mod pinned_events;

108
src/room/member.rs
View File

@ -7,6 +7,8 @@ use ruma_identifiers::UserId;
use serde::{Deserialize, Serialize};
use strum::{Display, EnumString};
use crate::StateEvent;
/// The current membership state of a user in the room.
///
/// Adjusts the membership state for a user in a room. It is preferable to use the membership
@ -150,44 +152,44 @@ pub enum MembershipChange {
NotImplemented,
}
// impl MemberEvent {
// /// Helper function for membership change. Check [the specification][spec] for details.
// ///
// /// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
// pub fn membership_change(&self) -> MembershipChange {
// use MembershipState::*;
// let prev_membership = if let Some(prev_content) = &self.prev_content {
// prev_content.membership
// } else {
// Leave
// };
// match (prev_membership, &self.content.membership) {
// (Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None,
// (Invite, Join) | (Leave, Join) => MembershipChange::Joined,
// (Invite, Leave) => {
// if self.sender == self.state_key {
// MembershipChange::InvitationRevoked
// } else {
// MembershipChange::InvitationRejected
// }
// }
// (Invite, Ban) | (Leave, Ban) => MembershipChange::Banned,
// (Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error,
// (Join, Join) => MembershipChange::ProfileChanged,
// (Join, Leave) => {
// if self.sender == self.state_key {
// MembershipChange::Left
// } else {
// MembershipChange::Kicked
// }
// }
// (Join, Ban) => MembershipChange::KickedAndBanned,
// (Leave, Invite) => MembershipChange::Invited,
// (Ban, Leave) => MembershipChange::Unbanned,
// (Knock, _) | (_, Knock) => MembershipChange::NotImplemented,
// }
// }
// }
impl StateEvent<MemberEventContent> {
/// Helper function for membership change. Check [the specification][spec] for details.
///
/// [spec]: https://matrix.org/docs/spec/client_server/latest#m-room-member
pub fn membership_change(&self) -> MembershipChange {
use MembershipState::*;
let prev_membership = if let Some(prev_content) = &self.prev_content {
prev_content.membership
} else {
Leave
};
match (prev_membership, &self.content.membership) {
(Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None,
(Invite, Join) | (Leave, Join) => MembershipChange::Joined,
(Invite, Leave) => {
if self.sender == self.state_key {
MembershipChange::InvitationRevoked
} else {
MembershipChange::InvitationRejected
}
}
(Invite, Ban) | (Leave, Ban) => MembershipChange::Banned,
(Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error,
(Join, Join) => MembershipChange::ProfileChanged,
(Join, Leave) => {
if self.sender == self.state_key {
MembershipChange::Left
} else {
MembershipChange::Kicked
}
}
(Join, Ban) => MembershipChange::KickedAndBanned,
(Leave, Invite) => MembershipChange::Invited,
(Ban, Leave) => MembershipChange::Unbanned,
(Knock, _) | (_, Knock) => MembershipChange::NotImplemented,
}
}
}
#[cfg(test)]
mod tests {
@ -197,10 +199,8 @@ mod tests {
use matches::assert_matches;
use serde_json::{from_value as from_json_value, json};
use super::{
MemberEvent, MemberEventContent, MembershipState, SignedContent, ThirdPartyInvite,
};
use crate::EventJson;
use super::{MemberEventContent, MembershipState, SignedContent, ThirdPartyInvite};
use crate::{EventJson, StateEvent};
#[test]
fn serde_with_no_prev_content() {
@ -217,11 +217,11 @@ mod tests {
});
assert_matches!(
from_json_value::<EventJson<MemberEvent>>(json)
from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
MemberEvent {
StateEvent::<MemberEventContent> {
content: MemberEventContent {
avatar_url: None,
displayname: None,
@ -231,7 +231,7 @@ mod tests {
},
event_id,
origin_server_ts,
room_id: Some(room_id),
room_id,
sender,
state_key,
unsigned,
@ -263,11 +263,11 @@ mod tests {
});
assert_matches!(
from_json_value::<EventJson<MemberEvent>>(json)
from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
MemberEvent {
StateEvent::<MemberEventContent> {
content: MemberEventContent {
avatar_url: None,
displayname: None,
@ -277,7 +277,7 @@ mod tests {
},
event_id,
origin_server_ts,
room_id: Some(room_id),
room_id,
sender,
state_key,
unsigned,
@ -327,11 +327,11 @@ mod tests {
});
assert_matches!(
from_json_value::<EventJson<MemberEvent>>(json)
from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
MemberEvent {
StateEvent::<MemberEventContent> {
content: MemberEventContent {
avatar_url: Some(avatar_url),
displayname: Some(displayname),
@ -344,7 +344,7 @@ mod tests {
},
event_id,
origin_server_ts,
room_id: Some(room_id),
room_id,
sender,
state_key,
unsigned,
@ -401,11 +401,11 @@ mod tests {
});
assert_matches!(
from_json_value::<EventJson<MemberEvent>>(json)
from_json_value::<EventJson<StateEvent<MemberEventContent>>>(json)
.unwrap()
.deserialize()
.unwrap(),
MemberEvent {
StateEvent::<MemberEventContent> {
content: MemberEventContent {
avatar_url: None,
displayname: None,
@ -415,7 +415,7 @@ mod tests {
},
event_id,
origin_server_ts,
room_id: Some(room_id),
room_id,
sender,
state_key,
unsigned,

456
src/state.rs
View File

@ -20,7 +20,8 @@ use serde_json::value::RawValue as RawJsonValue;
use crate::{
error::{InvalidEvent, InvalidEventKind},
room::{aliases::AliasesEventContent, avatar::AvatarEventContent},
EventContent, RoomEventContent, StateEventContent, TryFromRaw, UnsignedData,
EventContent, FromRaw, RawEventContent, RoomEventContent, StateEventContent, TryFromRaw,
UnsignedData,
};
use ruma_events_macros::event_content_collection;
@ -32,7 +33,10 @@ event_content_collection! {
/// State event.
#[derive(Clone, Debug)]
pub struct StateEvent<C: StateEventContent> {
pub struct StateEvent<C: StateEventContent>
where
C::Raw: RawEventContent,
{
/// Data specific to the event type.
pub content: C,
@ -61,6 +65,31 @@ pub struct StateEvent<C: StateEventContent> {
pub unsigned: UnsignedData,
}
impl FromRaw for AnyStateEventContent {
type Raw = raw::AnyStateEventContent;
fn from_raw(raw: Self::Raw) -> Self {
use raw::AnyStateEventContent::*;
match raw {
RoomAliases(c) => Self::RoomAliases(FromRaw::from_raw(c)),
RoomAvatar(c) => Self::RoomAvatar(FromRaw::from_raw(c)),
}
}
}
impl Serialize for AnyStateEventContent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
AnyStateEventContent::RoomAliases(content) => content.serialize(serializer),
AnyStateEventContent::RoomAvatar(content) => content.serialize(serializer),
}
}
}
impl EventContent for AnyStateEventContent {
fn event_type(&self) -> &str {
match self {
@ -68,41 +97,38 @@ impl EventContent for AnyStateEventContent {
AnyStateEventContent::RoomAvatar(content) => content.event_type(),
}
}
fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, InvalidEvent> {
fn deserialize_variant<T: StateEventContent>(
ev_type: &str,
input: Box<RawJsonValue>,
variant: fn(T) -> AnyStateEventContent,
) -> Result<AnyStateEventContent, InvalidEvent> {
let content = T::from_parts(ev_type, input)?;
Ok(variant(content))
}
match event_type {
"m.room.avatar" => deserialize_variant::<AvatarEventContent>(
event_type,
content,
AnyStateEventContent::RoomAvatar,
),
"m.room.aliases" => deserialize_variant::<AliasesEventContent>(
event_type,
content,
AnyStateEventContent::RoomAliases,
),
ev => Err(InvalidEvent {
kind: InvalidEventKind::Deserialization,
message: format!("event not supported {}", ev),
}),
}
}
}
impl RoomEventContent for AnyStateEventContent {}
impl StateEventContent for AnyStateEventContent {}
impl<C: StateEventContent> Serialize for StateEvent<C> {
impl<C> TryFromRaw for StateEvent<C>
where
C: StateEventContent + TryFromRaw,
C::Raw: RawEventContent,
{
type Raw = raw::StateEvent<C::Raw>;
type Err = C::Err;
fn try_from_raw(raw: Self::Raw) -> Result<Self, Self::Err> {
Ok(Self {
content: C::try_from_raw(raw.content)?,
event_id: raw.event_id,
sender: raw.sender,
origin_server_ts: raw.origin_server_ts,
room_id: raw.room_id,
state_key: raw.state_key,
prev_content: raw.prev_content.map(C::try_from_raw).transpose()?,
unsigned: raw.unsigned,
})
}
}
impl<C: StateEventContent> Serialize for StateEvent<C>
where
C::Raw: RawEventContent,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
@ -130,146 +156,238 @@ impl<C: StateEventContent> Serialize for StateEvent<C> {
}
}
impl<'de, C: StateEventContent> Deserialize<'de> for StateEvent<C> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_map(StateEventVisitor(std::marker::PhantomData))
}
}
mod raw {
use std::{
fmt,
marker::PhantomData,
time::{Duration, SystemTime, UNIX_EPOCH},
};
#[derive(serde::Deserialize)]
#[serde(field_identifier, rename_all = "snake_case")]
enum Field {
Type,
Content,
EventId,
Sender,
OriginServerTs,
RoomId,
StateKey,
PrevContent,
Unsigned,
}
use js_int::UInt;
use ruma_events_macros::event_content_collection;
use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{
de::{self, Deserialize, Deserializer, Error as _, MapAccess, Visitor},
Serialize,
};
use serde_json::value::RawValue as RawJsonValue;
/// Visits the fields of a StateEvent<C> to handle deserialization of
/// the `content` and `prev_content` fields.
struct StateEventVisitor<C: StateEventContent>(PhantomData<C>);
use crate::{
room::{aliases::raw::AliasesEventContent, avatar::raw::AvatarEventContent},
RawEventContent, UnsignedData,
};
impl<'de, C: StateEventContent> Visitor<'de> for StateEventVisitor<C> {
type Value = StateEvent<C>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "struct implementing StateEventContent")
event_content_collection! {
/// A state event.
name: AnyStateEventContent,
events: ["m.room.aliases", "m.room.avatar"]
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut content: Option<Box<RawJsonValue>> = None;
let mut event_type: Option<String> = None;
let mut event_id: Option<EventId> = None;
let mut sender: Option<UserId> = None;
let mut origin_server_ts: Option<UInt> = None;
let mut room_id: Option<RoomId> = None;
let mut state_key: Option<String> = None;
let mut prev_content: Option<Box<RawJsonValue>> = None;
let mut unsigned: Option<UnsignedData> = None;
impl RawEventContent for AnyStateEventContent {
fn from_parts(event_type: &str, content: Box<RawJsonValue>) -> Result<Self, String> {
fn deserialize_variant<T: RawEventContent>(
ev_type: &str,
input: Box<RawJsonValue>,
variant: fn(T) -> AnyStateEventContent,
) -> Result<AnyStateEventContent, String> {
let content = T::from_parts(ev_type, input)?;
Ok(variant(content))
}
while let Some(key) = map.next_key()? {
match key {
Field::Content => {
if content.is_some() {
return Err(de::Error::duplicate_field("content"));
}
content = Some(map.next_value()?);
}
Field::EventId => {
if event_id.is_some() {
return Err(de::Error::duplicate_field("event_id"));
}
event_id = Some(map.next_value()?);
}
Field::Sender => {
if sender.is_some() {
return Err(de::Error::duplicate_field("sender"));
}
sender = Some(map.next_value()?);
}
Field::OriginServerTs => {
if origin_server_ts.is_some() {
return Err(de::Error::duplicate_field("origin_server_ts"));
}
origin_server_ts = Some(map.next_value()?);
}
Field::RoomId => {
if room_id.is_some() {
return Err(de::Error::duplicate_field("room_id"));
}
room_id = Some(map.next_value()?);
}
Field::StateKey => {
if state_key.is_some() {
return Err(de::Error::duplicate_field("state_key"));
}
state_key = Some(map.next_value()?);
}
Field::PrevContent => {
if prev_content.is_some() {
return Err(de::Error::duplicate_field("prev_content"));
}
prev_content = Some(map.next_value()?);
}
Field::Type => {
if event_type.is_some() {
return Err(de::Error::duplicate_field("type"));
}
event_type = Some(map.next_value()?);
}
Field::Unsigned => {
if unsigned.is_some() {
return Err(de::Error::duplicate_field("unsigned"));
}
unsigned = Some(map.next_value()?);
}
match event_type {
"m.room.avatar" => deserialize_variant::<AvatarEventContent>(
event_type,
content,
AnyStateEventContent::RoomAvatar,
),
"m.room.aliases" => deserialize_variant::<AliasesEventContent>(
event_type,
content,
AnyStateEventContent::RoomAliases,
),
ev => Err(format!("event not supported {}", ev)),
}
}
}
let event_type = event_type.ok_or_else(|| de::Error::missing_field("type"))?;
/// State event.
#[derive(Clone, Debug)]
pub struct StateEvent<C> {
/// Data specific to the event type.
pub content: C,
let raw = content.ok_or_else(|| de::Error::missing_field("content"))?;
let content = C::from_parts(&event_type, raw).map_err(A::Error::custom)?;
/// The globally unique event identifier for the user who sent the event.
pub event_id: EventId,
let event_id = event_id.ok_or_else(|| de::Error::missing_field("event_id"))?;
let sender = sender.ok_or_else(|| de::Error::missing_field("sender"))?;
/// Contains the fully-qualified ID of the user who sent this event.
pub sender: UserId,
let origin_server_ts = origin_server_ts
.map(|time| UNIX_EPOCH + Duration::from_millis(time.into()))
.ok_or_else(|| de::Error::missing_field("origin_server_ts"))?;
/// Timestamp in milliseconds on originating homeserver when this event was sent.
pub origin_server_ts: SystemTime,
let room_id = room_id.ok_or_else(|| de::Error::missing_field("room_id"))?;
let state_key = state_key.ok_or_else(|| de::Error::missing_field("state_key"))?;
/// The ID of the room associated with this event.
pub room_id: RoomId,
let prev_content = if let Some(raw) = prev_content {
Some(C::from_parts(&event_type, raw).map_err(A::Error::custom)?)
} else {
None
};
/// A unique key which defines the overwriting semantics for this piece of room state.
///
/// This is often an empty string, but some events send a `UserId` to show
/// which user the event affects.
pub state_key: String,
let unsigned = unsigned.unwrap_or_default();
/// Optional previous content for this event.
pub prev_content: Option<C>,
Ok(StateEvent {
content,
event_id,
sender,
origin_server_ts,
room_id,
state_key,
prev_content,
unsigned,
})
/// Additional key-value pairs not signed by the homeserver.
pub unsigned: UnsignedData,
}
impl<'de, C> Deserialize<'de> for StateEvent<C>
where
C: RawEventContent,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_map(StateEventVisitor(std::marker::PhantomData))
}
}
#[derive(serde::Deserialize)]
#[serde(field_identifier, rename_all = "snake_case")]
enum Field {
Type,
Content,
EventId,
Sender,
OriginServerTs,
RoomId,
StateKey,
PrevContent,
Unsigned,
}
/// Visits the fields of a StateEvent<C> to handle deserialization of
/// the `content` and `prev_content` fields.
struct StateEventVisitor<C>(PhantomData<C>);
impl<'de, C> Visitor<'de> for StateEventVisitor<C>
where
C: RawEventContent,
{
type Value = StateEvent<C>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "struct implementing StateEventContent")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut content: Option<Box<RawJsonValue>> = None;
let mut event_type: Option<String> = None;
let mut event_id: Option<EventId> = None;
let mut sender: Option<UserId> = None;
let mut origin_server_ts: Option<UInt> = None;
let mut room_id: Option<RoomId> = None;
let mut state_key: Option<String> = None;
let mut prev_content: Option<Box<RawJsonValue>> = None;
let mut unsigned: Option<UnsignedData> = None;
while let Some(key) = map.next_key()? {
match key {
Field::Content => {
if content.is_some() {
return Err(de::Error::duplicate_field("content"));
}
content = Some(map.next_value()?);
}
Field::EventId => {
if event_id.is_some() {
return Err(de::Error::duplicate_field("event_id"));
}
event_id = Some(map.next_value()?);
}
Field::Sender => {
if sender.is_some() {
return Err(de::Error::duplicate_field("sender"));
}
sender = Some(map.next_value()?);
}
Field::OriginServerTs => {
if origin_server_ts.is_some() {
return Err(de::Error::duplicate_field("origin_server_ts"));
}
origin_server_ts = Some(map.next_value()?);
}
Field::RoomId => {
if room_id.is_some() {
return Err(de::Error::duplicate_field("room_id"));
}
room_id = Some(map.next_value()?);
}
Field::StateKey => {
if state_key.is_some() {
return Err(de::Error::duplicate_field("state_key"));
}
state_key = Some(map.next_value()?);
}
Field::PrevContent => {
if prev_content.is_some() {
return Err(de::Error::duplicate_field("prev_content"));
}
prev_content = Some(map.next_value()?);
}
Field::Type => {
if event_type.is_some() {
return Err(de::Error::duplicate_field("type"));
}
event_type = Some(map.next_value()?);
}
Field::Unsigned => {
if unsigned.is_some() {
return Err(de::Error::duplicate_field("unsigned"));
}
unsigned = Some(map.next_value()?);
}
}
}
let event_type = event_type.ok_or_else(|| de::Error::missing_field("type"))?;
let raw = content.ok_or_else(|| de::Error::missing_field("content"))?;
let content = C::from_parts(&event_type, raw).map_err(A::Error::custom)?;
let event_id = event_id.ok_or_else(|| de::Error::missing_field("event_id"))?;
let sender = sender.ok_or_else(|| de::Error::missing_field("sender"))?;
let origin_server_ts = origin_server_ts
.map(|time| UNIX_EPOCH + Duration::from_millis(time.into()))
.ok_or_else(|| de::Error::missing_field("origin_server_ts"))?;
let room_id = room_id.ok_or_else(|| de::Error::missing_field("room_id"))?;
let state_key = state_key.ok_or_else(|| de::Error::missing_field("state_key"))?;
let prev_content = if let Some(raw) = prev_content {
Some(C::from_parts(&event_type, raw).map_err(A::Error::custom)?)
} else {
None
};
let unsigned = unsigned.unwrap_or_default();
Ok(StateEvent {
content,
event_id,
sender,
origin_server_ts,
room_id,
state_key,
prev_content,
unsigned,
})
}
}
}
@ -288,7 +406,7 @@ mod tests {
use super::{AliasesEventContent, AnyStateEventContent, AvatarEventContent, StateEvent};
use crate::{
room::{ImageInfo, ThumbnailInfo},
UnsignedData,
EventJson, UnsignedData,
};
#[test]
@ -358,6 +476,22 @@ mod tests {
assert_eq!(actual, expected);
}
#[test]
fn deserialize_aliases_content() {
let json_data = json!({
"aliases": [ "#somewhere:localhost" ]
});
assert_matches!(
from_json_value::<EventJson<AnyStateEventContent>>(json_data)
.unwrap()
.deserialize_content("m.room.aliases")
.unwrap(),
AnyStateEventContent::RoomAliases(content)
if content.aliases == vec![RoomAliasId::try_from("#somewhere:localhost").unwrap()]
);
}
#[test]
fn deserialize_aliases_with_prev_content() {
let json_data = json!({
@ -376,7 +510,10 @@ mod tests {
});
assert_matches!(
from_json_value::<StateEvent<AnyStateEventContent>>(json_data).unwrap(),
from_json_value::<EventJson<StateEvent<AnyStateEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
StateEvent {
content: AnyStateEventContent::RoomAliases(content),
event_id,
@ -425,7 +562,10 @@ mod tests {
});
assert_matches!(
from_json_value::<StateEvent<AnyStateEventContent>>(json_data).unwrap(),
from_json_value::<EventJson<StateEvent<AnyStateEventContent>>>(json_data)
.unwrap()
.deserialize()
.unwrap(),
StateEvent {
content: AnyStateEventContent::RoomAvatar(AvatarEventContent {
info: Some(info),