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

events: Keep data of unknown relations

Browse Source
This commit is contained in:
Kévin Commaille 2023-06-24 14:37:34 +02:00 committed by Kévin Commaille
parent df0eee30e1
commit 07bc06038f
8 changed files with 508 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
use super::AnyMessageLikeEvent;
use crate::{
serde::{Raw, StringEnum},
serde::{JsonObject, Raw, StringEnum},
OwnedEventId, PrivOwnedStr,
};
@ -81,8 +81,9 @@ impl<C> Replacement<C> {
/// The content of a [thread] relation.
///
/// [thread]: https://spec.matrix.org/latest/client-server-api/#threading
#[derive(Clone, Debug)]
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
#[serde(tag = "rel_type", rename = "m.thread")]
pub struct Thread {
/// The ID of the root message in the thread.
pub event_id: OwnedEventId,
@ -95,10 +96,12 @@ pub struct Thread {
/// If this event is not a reply, this is used as a fallback mechanism for clients that do not
/// support threads. This should point to the latest message-like event in the thread and
/// `is_falling_back` must be set to `true`.
#[serde(rename = "m.in_reply_to", skip_serializing_if = "Option::is_none")]
pub in_reply_to: Option<InReplyTo>,
/// Whether the `m.in_reply_to` field is a fallback for older clients or a genuine reply in a
/// thread.
#[serde(default, skip_serializing_if = "ruma_common::serde::is_default")]
pub is_falling_back: bool,
}
@ -302,3 +305,18 @@ pub enum RelationType {
#[doc(hidden)]
_Custom(PrivOwnedStr),
}
/// The payload for a custom relation.
#[doc(hidden)]
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CustomRelation {
/// A custom relation type.
pub(super) rel_type: String,
/// The ID of the event this relation applies to.
pub(super) event_id: OwnedEventId,
/// Remaining event content.
#[serde(flatten)]
pub(super) data: JsonObject,
}

60
crates/ruma-common/src/events/room/encrypted.rs
View File

@ -2,7 +2,7 @@
//!
//! [`m.room.encrypted`]: https://spec.matrix.org/latest/client-server-api/#mroomencrypted
use std::collections::BTreeMap;
use std::{borrow::Cow, collections::BTreeMap};
use js_int::UInt;
use ruma_macros::EventContent;
@ -10,11 +10,12 @@ use serde::{Deserialize, Serialize};
use super::message;
use crate::{
events::relation::{Annotation, InReplyTo, Reference, Thread},
OwnedDeviceId, OwnedEventId,
events::relation::{Annotation, CustomRelation, InReplyTo, Reference, RelationType, Thread},
serde::JsonObject,
EventId, OwnedDeviceId, OwnedEventId,
};
pub(crate) mod relation_serde;
mod relation_serde;
/// The content of an `m.room.encrypted` event.
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
@ -106,7 +107,54 @@ pub enum Relation {
Thread(Thread),
#[doc(hidden)]
_Custom,
_Custom(CustomRelation),
}
impl Relation {
/// The type of this `Relation`.
///
/// Returns an `Option` because the `Reply` relation does not have a`rel_type` field.
pub fn rel_type(&self) -> Option<RelationType> {
match self {
Relation::Reply { .. } => None,
Relation::Replacement(_) => Some(RelationType::Replacement),
Relation::Reference(_) => Some(RelationType::Reference),
Relation::Annotation(_) => Some(RelationType::Annotation),
Relation::Thread(_) => Some(RelationType::Thread),
Relation::_Custom(c) => Some(c.rel_type.as_str().into()),
}
}
/// The ID of the event this relates to.
///
/// This is the `event_id` field at the root of an `m.relates_to` object, except in the case of
/// a reply relation where it's the `event_id` field in the `m.in_reply_to` object.
pub fn event_id(&self) -> &EventId {
match self {
Relation::Reply { in_reply_to } => &in_reply_to.event_id,
Relation::Replacement(r) => &r.event_id,
Relation::Reference(r) => &r.event_id,
Relation::Annotation(a) => &a.event_id,
Relation::Thread(t) => &t.event_id,
Relation::_Custom(c) => &c.event_id,
}
}
/// The associated data.
///
/// The returned JSON object won't contain the `rel_type` field, use
/// [`.rel_type()`][Self::rel_type] to access it. It also won't contain data
/// outside of `m.relates_to` (e.g. `m.new_content` for `m.replace` relations).
///
/// Prefer to use the public variants of `Relation` where possible; this method is meant to
/// be used for custom relations only.
pub fn data(&self) -> Cow<'_, JsonObject> {
if let Relation::_Custom(c) = self {
Cow::Borrowed(&c.data)
} else {
Cow::Owned(self.serialize_data())
}
}
}
impl<C> From<message::Relation<C>> for Relation {
@ -121,7 +169,7 @@ impl<C> From<message::Relation<C>> for Relation {
in_reply_to: t.in_reply_to,
is_falling_back: t.is_falling_back,
}),
message::Relation::_Custom => Self::_Custom,
message::Relation::_Custom(c) => Self::_Custom(c),
}
}
}

200
crates/ruma-common/src/events/room/encrypted/relation_serde.rs
View File

@ -1,151 +1,101 @@
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
use serde::{de, ser::SerializeStruct, Deserialize, Deserializer, Serialize};
use serde_json::{value::RawValue as RawJsonValue, Value as JsonValue};
use super::{Annotation, InReplyTo, Reference, Relation, Replacement, Thread};
use crate::OwnedEventId;
use super::{InReplyTo, Relation, Thread};
use crate::{
serde::{from_raw_json_value, JsonObject},
OwnedEventId,
};
impl<'de> Deserialize<'de> for Relation {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let relates_to = RelatesToJsonRepr::deserialize(deserializer)?;
let json = Box::<RawJsonValue>::deserialize(deserializer)?;
if let Some(
RelationJsonRepr::ThreadStable(ThreadStableJsonRepr { event_id, is_falling_back })
| RelationJsonRepr::ThreadUnstable(ThreadUnstableJsonRepr { event_id, is_falling_back }),
) = relates_to.relation
{
let in_reply_to = relates_to.in_reply_to;
return Ok(Relation::Thread(Thread { event_id, in_reply_to, is_falling_back }));
}
let rel = if let Some(in_reply_to) = relates_to.in_reply_to {
Relation::Reply { in_reply_to }
} else if let Some(relation) = relates_to.relation {
match relation {
RelationJsonRepr::Annotation(a) => Relation::Annotation(a),
RelationJsonRepr::Reference(r) => Relation::Reference(r),
RelationJsonRepr::Replacement(Replacement { event_id }) => {
Relation::Replacement(Replacement { event_id })
}
RelationJsonRepr::ThreadStable(_) | RelationJsonRepr::ThreadUnstable(_) => {
unreachable!()
}
// FIXME: Maybe we should log this, though at this point we don't even have
// access to the rel_type of the unknown relation.
RelationJsonRepr::Unknown => Relation::_Custom,
let RelationDeHelper { in_reply_to, rel_type } = from_raw_json_value(&json)?;
let rel = match (in_reply_to, rel_type.as_deref()) {
(None, None) => return Err(de::Error::missing_field("m.in_reply_to or rel_type")),
(_, Some("m.thread")) => Relation::Thread(from_raw_json_value(&json)?),
(in_reply_to, Some("io.element.thread")) => {
let ThreadUnstableDeHelper { event_id, is_falling_back } =
from_raw_json_value(&json)?;
Relation::Thread(Thread { event_id, in_reply_to, is_falling_back })
}
} else {
return Err(de::Error::missing_field("m.in_reply_to or rel_type"));
(_, Some("m.annotation")) => Relation::Annotation(from_raw_json_value(&json)?),
(_, Some("m.reference")) => Relation::Reference(from_raw_json_value(&json)?),
(_, Some("m.replace")) => Relation::Replacement(from_raw_json_value(&json)?),
(Some(in_reply_to), _) => Relation::Reply { in_reply_to },
_ => Relation::_Custom(from_raw_json_value(&json)?),
};
Ok(rel)
}
}
impl Serialize for Relation {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let relates_to = match self {
Relation::Annotation(r) => RelatesToJsonRepr {
relation: Some(RelationJsonRepr::Annotation(r.clone())),
..Default::default()
},
Relation::Reference(r) => RelatesToJsonRepr {
relation: Some(RelationJsonRepr::Reference(r.clone())),
..Default::default()
},
Relation::Replacement(r) => RelatesToJsonRepr {
relation: Some(RelationJsonRepr::Replacement(r.clone())),
..Default::default()
},
Relation::Reply { in_reply_to } => {
RelatesToJsonRepr { in_reply_to: Some(in_reply_to.clone()), ..Default::default() }
}
Relation::Thread(Thread { event_id, in_reply_to, is_falling_back }) => {
RelatesToJsonRepr {
in_reply_to: in_reply_to.clone(),
relation: Some(RelationJsonRepr::ThreadStable(ThreadStableJsonRepr {
event_id: event_id.clone(),
is_falling_back: *is_falling_back,
})),
}
}
Relation::_Custom => RelatesToJsonRepr::default(),
};
relates_to.serialize(serializer)
}
}
/// Struct modeling the different ways relationships can be expressed in a `m.relates_to` field of
/// an event.
#[derive(Default, Deserialize, Serialize)]
struct RelatesToJsonRepr {
#[serde(rename = "m.in_reply_to", skip_serializing_if = "Option::is_none")]
#[derive(Default, Deserialize)]
struct RelationDeHelper {
#[serde(rename = "m.in_reply_to")]
in_reply_to: Option<InReplyTo>,
#[serde(flatten, skip_serializing_if = "Option::is_none")]
relation: Option<RelationJsonRepr>,
}
/// A thread relation without the reply fallback, with stable names.
#[derive(Clone, Deserialize, Serialize)]
struct ThreadStableJsonRepr {
/// The ID of the root message in the thread.
event_id: OwnedEventId,
/// Whether the `m.in_reply_to` field is a fallback for older clients or a real reply in a
/// thread.
#[serde(default, skip_serializing_if = "ruma_common::serde::is_default")]
is_falling_back: bool,
rel_type: Option<String>,
}
/// A thread relation without the reply fallback, with unstable names.
#[derive(Clone, Deserialize, Serialize)]
struct ThreadUnstableJsonRepr {
/// The ID of the root message in the thread.
#[derive(Clone, Deserialize)]
struct ThreadUnstableDeHelper {
event_id: OwnedEventId,
/// Whether the `m.in_reply_to` field is a fallback for older clients or a real reply in a
/// thread.
#[serde(
rename = "io.element.show_reply",
default,
skip_serializing_if = "ruma_common::serde::is_default"
)]
#[serde(rename = "io.element.show_reply", default)]
is_falling_back: bool,
}
/// A relation, which associates new information to an existing event.
#[derive(Clone, Deserialize, Serialize)]
#[serde(tag = "rel_type")]
enum RelationJsonRepr {
/// An annotation to an event.
#[serde(rename = "m.annotation")]
Annotation(Annotation),
/// A reference to another event.
#[serde(rename = "m.reference")]
Reference(Reference),
/// An event that replaces another event.
#[serde(rename = "m.replace")]
Replacement(Replacement),
/// An event that belongs to a thread, with stable names.
#[serde(rename = "m.thread")]
ThreadStable(ThreadStableJsonRepr),
/// An event that belongs to a thread, with unstable names.
#[serde(rename = "io.element.thread")]
ThreadUnstable(ThreadUnstableJsonRepr),
/// An unknown relation type.
///
/// Not available in the public API, but exists here so deserialization
/// doesn't fail with new / custom `rel_type`s.
#[serde(other)]
Unknown,
impl Relation {
pub(super) fn serialize_data(&self) -> JsonObject {
match serde_json::to_value(self).expect("relation serialization to succeed") {
JsonValue::Object(mut obj) => {
obj.remove("rel_type");
obj
}
_ => panic!("all relations must serialize to objects"),
}
}
}
impl Serialize for Relation {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
match self {
Relation::Reply { in_reply_to } => {
let mut st = serializer.serialize_struct("Relation", 1)?;
st.serialize_field("m.in_reply_to", in_reply_to)?;
st.end()
}
Relation::Replacement(data) => {
RelationSerHelper { rel_type: "m.replace", data }.serialize(serializer)
}
Relation::Reference(data) => {
RelationSerHelper { rel_type: "m.reference", data }.serialize(serializer)
}
Relation::Annotation(data) => {
RelationSerHelper { rel_type: "m.annotation", data }.serialize(serializer)
}
Relation::Thread(data) => {
RelationSerHelper { rel_type: "m.thread", data }.serialize(serializer)
}
Relation::_Custom(c) => c.serialize(serializer),
}
}
}
#[derive(Serialize)]
struct RelationSerHelper<'a, T> {
rel_type: &'a str,
#[serde(flatten)]
data: &'a T,
}

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

@ -9,9 +9,9 @@ use serde::{de::DeserializeOwned, Deserialize, Serialize};
use serde_json::Value as JsonValue;
use crate::{
events::relation::{InReplyTo, Replacement, Thread},
events::relation::{CustomRelation, InReplyTo, RelationType, Replacement, Thread},
serde::{JsonObject, StringEnum},
OwnedEventId, PrivOwnedStr,
EventId, OwnedEventId, PrivOwnedStr,
};
mod audio;
@ -648,7 +648,53 @@ pub enum Relation<C> {
Thread(Thread),
#[doc(hidden)]
_Custom,
_Custom(CustomRelation),
}
impl<C> Relation<C> {
/// The type of this `Relation`.
///
/// Returns an `Option` because the `Reply` relation does not have a`rel_type` field.
pub fn rel_type(&self) -> Option<RelationType> {
match self {
Relation::Reply { .. } => None,
Relation::Replacement(_) => Some(RelationType::Replacement),
Relation::Thread(_) => Some(RelationType::Thread),
Relation::_Custom(c) => Some(c.rel_type.as_str().into()),
}
}
/// The ID of the event this relates to.
///
/// This is the `event_id` field at the root of an `m.relates_to` object, except in the case of
/// a reply relation where it's the `event_id` field in the `m.in_reply_to` object.
pub fn event_id(&self) -> &EventId {
match self {
Relation::Reply { in_reply_to } => &in_reply_to.event_id,
Relation::Replacement(r) => &r.event_id,
Relation::Thread(t) => &t.event_id,
Relation::_Custom(c) => &c.event_id,
}
}
/// The associated data.
///
/// The returned JSON object won't contain the `rel_type` field, use
/// [`.rel_type()`][Self::rel_type] to access it. It also won't contain data
/// outside of `m.relates_to` (e.g. `m.new_content` for `m.replace` relations).
///
/// Prefer to use the public variants of `Relation` where possible; this method is meant to
/// be used for custom relations only.
pub fn data(&self) -> Cow<'_, JsonObject>
where
C: Clone,
{
if let Relation::_Custom(c) = self {
Cow::Borrowed(&c.data)
} else {
Cow::Owned(self.serialize_data())
}
}
}
/// The format for the formatted representation of a message body.

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

@ -1,7 +1,8 @@
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::{de, Deserialize, Deserializer, Serialize};
use serde_json::Value as JsonValue;
use super::{InReplyTo, Relation, Replacement, Thread};
use crate::OwnedEventId;
use crate::{events::relation::CustomRelation, serde::JsonObject, OwnedEventId};
/// Deserialize an event's `relates_to` field.
///
@ -25,39 +26,39 @@ where
D: Deserializer<'de>,
C: Deserialize<'de>,
{
let ev = EventWithRelatesToJsonRepr::deserialize(deserializer)?;
if let Some(
RelationJsonRepr::ThreadStable(ThreadStableJsonRepr { event_id, is_falling_back })
| RelationJsonRepr::ThreadUnstable(ThreadUnstableJsonRepr { event_id, is_falling_back }),
) = ev.relates_to.relation
{
let in_reply_to = ev.relates_to.in_reply_to;
return Ok(Some(Relation::Thread(Thread { event_id, in_reply_to, is_falling_back })));
}
let rel = if let Some(in_reply_to) = ev.relates_to.in_reply_to {
Some(Relation::Reply { in_reply_to })
} else if let Some(relation) = ev.relates_to.relation {
match relation {
RelationJsonRepr::Replacement(ReplacementJsonRepr { event_id }) => {
let new_content = ev
.new_content
.ok_or_else(|| serde::de::Error::missing_field("m.new_content"))?;
Some(Relation::Replacement(Replacement { event_id, new_content }))
}
// FIXME: Maybe we should log this, though at this point we don't even have
// access to the rel_type of the unknown relation.
RelationJsonRepr::Unknown => Some(Relation::_Custom),
RelationJsonRepr::ThreadStable(_) | RelationJsonRepr::ThreadUnstable(_) => {
unreachable!()
}
}
} else {
None
let EventWithRelatesToDeHelper { relates_to, new_content } =
EventWithRelatesToDeHelper::deserialize(deserializer)?;
let Some(relates_to) = relates_to else {
return Ok(None);
};
Ok(rel)
let RelatesToDeHelper { in_reply_to, relation } = relates_to;
let rel = if let Some(RelationDeHelper::Known(relation)) = relation {
match relation {
KnownRelationDeHelper::Replacement(ReplacementJsonRepr { event_id }) => {
match new_content {
Some(new_content) => {
Relation::Replacement(Replacement { event_id, new_content })
}
None => return Err(de::Error::missing_field("m.new_content")),
}
}
KnownRelationDeHelper::Thread(ThreadDeHelper { event_id, is_falling_back })
| KnownRelationDeHelper::ThreadUnstable(ThreadUnstableDeHelper {
event_id,
is_falling_back,
}) => Relation::Thread(Thread { event_id, in_reply_to, is_falling_back }),
}
} else if let Some(in_reply_to) = in_reply_to {
Relation::Reply { in_reply_to }
} else if let Some(RelationDeHelper::Unknown(c)) = relation {
Relation::_Custom(c)
} else {
return Err(de::Error::missing_field("m.in_reply_to or rel_type"));
};
Ok(Some(rel))
}
impl<C> Serialize for Relation<C>
@ -66,133 +67,157 @@ where
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
S: serde::Serializer,
{
let json_repr = match self {
Relation::Reply { in_reply_to } => {
EventWithRelatesToJsonRepr::<C>::new(RelatesToJsonRepr {
in_reply_to: Some(in_reply_to.clone()),
..Default::default()
})
}
Relation::Replacement(Replacement { event_id, new_content }) => {
EventWithRelatesToJsonRepr {
relates_to: RelatesToJsonRepr {
relation: Some(RelationJsonRepr::Replacement(ReplacementJsonRepr {
event_id: event_id.clone(),
})),
..Default::default()
},
new_content: Some(new_content.clone()),
}
}
Relation::Thread(Thread { event_id, in_reply_to, is_falling_back }) => {
EventWithRelatesToJsonRepr::new(RelatesToJsonRepr {
in_reply_to: in_reply_to.clone(),
relation: Some(RelationJsonRepr::ThreadStable(ThreadStableJsonRepr {
event_id: event_id.clone(),
is_falling_back: *is_falling_back,
})),
})
}
Relation::_Custom => EventWithRelatesToJsonRepr::<C>::default(),
};
let (relates_to, new_content) = self.clone().into_parts();
json_repr.serialize(serializer)
EventWithRelatesToSerHelper { relates_to, new_content }.serialize(serializer)
}
}
#[derive(Deserialize)]
struct EventWithRelatesToDeHelper<C> {
#[serde(rename = "m.relates_to")]
relates_to: Option<RelatesToDeHelper>,
#[serde(rename = "m.new_content")]
new_content: Option<C>,
}
#[derive(Deserialize)]
struct RelatesToDeHelper {
#[serde(rename = "m.in_reply_to")]
in_reply_to: Option<InReplyTo>,
#[serde(flatten)]
relation: Option<RelationDeHelper>,
}
#[derive(Deserialize)]
#[serde(untagged)]
enum RelationDeHelper {
Known(KnownRelationDeHelper),
Unknown(CustomRelation),
}
#[derive(Deserialize)]
#[serde(tag = "rel_type")]
enum KnownRelationDeHelper {
#[serde(rename = "m.replace")]
Replacement(ReplacementJsonRepr),
#[serde(rename = "m.thread")]
Thread(ThreadDeHelper),
#[serde(rename = "io.element.thread")]
ThreadUnstable(ThreadUnstableDeHelper),
}
/// A replacement relation without `m.new_content`.
#[derive(Deserialize, Serialize)]
struct EventWithRelatesToJsonRepr<C> {
#[serde(rename = "m.relates_to", default, skip_serializing_if = "RelatesToJsonRepr::is_empty")]
relates_to: RelatesToJsonRepr,
pub(super) struct ReplacementJsonRepr {
event_id: OwnedEventId,
}
/// A thread relation without the reply fallback, with stable names.
#[derive(Deserialize)]
struct ThreadDeHelper {
event_id: OwnedEventId,
#[serde(default)]
is_falling_back: bool,
}
/// A thread relation without the reply fallback, with unstable names.
#[derive(Deserialize)]
struct ThreadUnstableDeHelper {
event_id: OwnedEventId,
#[serde(rename = "io.element.show_reply", default)]
is_falling_back: bool,
}
#[derive(Serialize)]
pub(super) struct EventWithRelatesToSerHelper<C> {
#[serde(rename = "m.relates_to")]
relates_to: RelationSerHelper,
#[serde(rename = "m.new_content", skip_serializing_if = "Option::is_none")]
new_content: Option<C>,
}
impl<C> EventWithRelatesToJsonRepr<C> {
fn new(relates_to: RelatesToJsonRepr) -> Self {
Self { relates_to, new_content: None }
}
}
impl<C> Default for EventWithRelatesToJsonRepr<C> {
fn default() -> Self {
Self { relates_to: RelatesToJsonRepr::default(), new_content: None }
}
}
/// Struct modeling the different ways relationships can be expressed in a `m.relates_to` field of
/// an event.
#[derive(Default, Deserialize, Serialize)]
struct RelatesToJsonRepr {
#[serde(rename = "m.in_reply_to", skip_serializing_if = "Option::is_none")]
in_reply_to: Option<InReplyTo>,
#[serde(flatten, skip_serializing_if = "Option::is_none")]
relation: Option<RelationJsonRepr>,
}
impl RelatesToJsonRepr {
fn is_empty(&self) -> bool {
self.in_reply_to.is_none() && self.relation.is_none()
}
}
/// A relation, which associates new information to an existing event.
#[derive(Clone, Deserialize, Serialize)]
#[derive(Serialize)]
#[serde(tag = "rel_type")]
enum RelationJsonRepr {
pub(super) enum RelationSerHelper {
/// An event that replaces another event.
#[serde(rename = "m.replace")]
Replacement(ReplacementJsonRepr),
/// An event that belongs to a thread, with stable names.
#[serde(rename = "m.thread")]
ThreadStable(ThreadStableJsonRepr),
/// An event that belongs to a thread, with unstable names.
#[serde(rename = "io.element.thread")]
ThreadUnstable(ThreadUnstableJsonRepr),
Thread(Thread),
/// An unknown relation type.
///
/// Not available in the public API, but exists here so deserialization
/// doesn't fail with new / custom `rel_type`s.
#[serde(other)]
Unknown,
#[serde(untagged)]
Custom(CustomSerHelper),
}
#[derive(Clone, Deserialize, Serialize)]
struct ReplacementJsonRepr {
event_id: OwnedEventId,
impl<C> Relation<C> {
fn into_parts(self) -> (RelationSerHelper, Option<C>) {
match self {
Relation::Replacement(Replacement { event_id, new_content }) => (
RelationSerHelper::Replacement(ReplacementJsonRepr { event_id }),
Some(new_content),
),
Relation::Reply { in_reply_to } => {
(RelationSerHelper::Custom(in_reply_to.into()), None)
}
Relation::Thread(t) => (RelationSerHelper::Thread(t), None),
Relation::_Custom(c) => (RelationSerHelper::Custom(c.into()), None),
}
}
pub(super) fn serialize_data(&self) -> JsonObject
where
C: Clone,
{
let (relates_to, _) = self.clone().into_parts();
match serde_json::to_value(relates_to).expect("relation serialization to succeed") {
JsonValue::Object(mut obj) => {
obj.remove("rel_type");
obj
}
_ => panic!("all relations must serialize to objects"),
}
}
}
/// A thread relation without the reply fallback, with stable names.
#[derive(Clone, Deserialize, Serialize)]
struct ThreadStableJsonRepr {
/// The ID of the root message in the thread.
event_id: OwnedEventId,
#[derive(Default, Serialize)]
pub(super) struct CustomSerHelper {
#[serde(rename = "m.in_reply_to", skip_serializing_if = "Option::is_none")]
in_reply_to: Option<InReplyTo>,
/// Whether the `m.in_reply_to` field is a fallback for older clients or a real reply in a
/// thread.
#[serde(default, skip_serializing_if = "ruma_common::serde::is_default")]
is_falling_back: bool,
#[serde(skip_serializing_if = "Option::is_none")]
rel_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
event_id: Option<OwnedEventId>,
#[serde(flatten, skip_serializing_if = "JsonObject::is_empty")]
data: JsonObject,
}
/// A thread relation without the reply fallback, with unstable names.
#[derive(Clone, Deserialize, Serialize)]
struct ThreadUnstableJsonRepr {
/// The ID of the root message in the thread.
event_id: OwnedEventId,
/// Whether the `m.in_reply_to` field is a fallback for older clients or a real reply in a
/// thread.
#[serde(
rename = "io.element.show_reply",
default,
skip_serializing_if = "ruma_common::serde::is_default"
)]
is_falling_back: bool,
impl From<InReplyTo> for CustomSerHelper {
fn from(value: InReplyTo) -> Self {
Self { in_reply_to: Some(value), ..Default::default() }
}
}
impl From<CustomRelation> for CustomSerHelper {
fn from(value: CustomRelation) -> Self {
let CustomRelation { rel_type, event_id, data } = value;
Self { rel_type: Some(rel_type), event_id: Some(event_id), data, ..Default::default() }
}
}

77
crates/ruma-common/tests/events/encrypted.rs
View File

@ -1,7 +1,7 @@
use assert_matches2::assert_matches;
use ruma_common::{
events::{
relation::{InReplyTo, Reference, Thread},
relation::{CustomRelation, InReplyTo, Reference, Thread},
room::encrypted::{
EncryptedEventScheme, MegolmV1AesSha2ContentInit, Relation, Replacement,
RoomEncryptedEventContent,
@ -428,3 +428,78 @@ fn content_annotation_deserialization() {
assert_eq!(annotation.event_id, "$annotated_event");
assert_eq!(annotation.key, "some_key");
}
#[test]
fn custom_relation_deserialization() {
let json = json!({
"algorithm": "m.megolm.v1.aes-sha2",
"sender_key": "aV9BpqYFqJpKYmgERyGv/6QyKMcgLqxM05V0gvzg9Yk",
"ciphertext": "AwgAEpABjy6BHczo7UZE3alyej6y2YQ5v+L9eB+fBqL7yteCPv8Jig\
FCXKWWuwpbZ4nQpvhUbqW0ZX2474FQf0l1dXGQWDMm0VP5p20elkzSf\
n0uzmHVKGQe+NHUKIczRWsUJ6AbrLBbfFKoIPwfbZ7nQQndjA6F0+PW\
MoMQHqcrtROrCV/TMux6kDKp7h7O77Y6wp6LD4rU1lwTmKnMYkQGnju\
c3+FAMvkow26TuS0/fhJG5m+f0GLlP8FQ3fu0Kjw2YUOLl/BU6gPWdk\
lDl5mzVO3tPnJMKZ0hn+AF",
"session_id": "IkwqWxT2zy3DI1E/zM2Wq+CE8tr3eEpsxsVGjGrMPdw",
"device_id": "DEVICE",
"m.relates_to": {
"rel_type": "io.ruma.custom",
"event_id": "$related_event",
"field": "value",
},
});
let content = from_json_value::<RoomEncryptedEventContent>(json).unwrap();
assert_matches!(content.scheme, EncryptedEventScheme::MegolmV1AesSha2(encrypted_content));
assert_eq!(encrypted_content.session_id, "IkwqWxT2zy3DI1E/zM2Wq+CE8tr3eEpsxsVGjGrMPdw");
assert_eq!(
encrypted_content.ciphertext,
"AwgAEpABjy6BHczo7UZE3alyej6y2YQ5v+L9eB+fBqL7yteCPv8Jig\
FCXKWWuwpbZ4nQpvhUbqW0ZX2474FQf0l1dXGQWDMm0VP5p20elkzSf\
n0uzmHVKGQe+NHUKIczRWsUJ6AbrLBbfFKoIPwfbZ7nQQndjA6F0+PW\
MoMQHqcrtROrCV/TMux6kDKp7h7O77Y6wp6LD4rU1lwTmKnMYkQGnju\
c3+FAMvkow26TuS0/fhJG5m+f0GLlP8FQ3fu0Kjw2YUOLl/BU6gPWdk\
lDl5mzVO3tPnJMKZ0hn+AF"
);
let relation = content.relates_to.unwrap();
assert_eq!(relation.rel_type().unwrap().as_str(), "io.ruma.custom");
assert_eq!(relation.event_id(), "$related_event");
let data = relation.data();
assert_eq!(data.get("field").unwrap().as_str(), Some("value"));
}
#[test]
fn custom_relation_serialization() {
let json = json!({
"rel_type": "io.ruma.custom",
"event_id": "$related_event",
"field": "value",
});
let relation = from_json_value::<CustomRelation>(json).unwrap();
let content =
RoomEncryptedEventContent::new(encrypted_scheme(), Some(Relation::_Custom(relation)));
assert_eq!(
to_json_value(&content).unwrap(),
json!({
"algorithm": "m.megolm.v1.aes-sha2",
"sender_key": "aV9BpqYFqJpKYmgERyGv/6QyKMcgLqxM05V0gvzg9Yk",
"ciphertext": "AwgAEpABjy6BHczo7UZE3alyej6y2YQ5v+L9eB+fBqL7yteCPv8Jig\
FCXKWWuwpbZ4nQpvhUbqW0ZX2474FQf0l1dXGQWDMm0VP5p20elkzSf\
n0uzmHVKGQe+NHUKIczRWsUJ6AbrLBbfFKoIPwfbZ7nQQndjA6F0+PW\
MoMQHqcrtROrCV/TMux6kDKp7h7O77Y6wp6LD4rU1lwTmKnMYkQGnju\
c3+FAMvkow26TuS0/fhJG5m+f0GLlP8FQ3fu0Kjw2YUOLl/BU6gPWdk\
lDl5mzVO3tPnJMKZ0hn+AF",
"session_id": "IkwqWxT2zy3DI1E/zM2Wq+CE8tr3eEpsxsVGjGrMPdw",
"device_id": "DEVICE",
"m.relates_to": {
"rel_type": "io.ruma.custom",
"event_id": "$related_event",
"field": "value",
},
})
);
}

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

@ -129,7 +129,7 @@ fn markdown_content_serialization() {
}
#[test]
fn relates_to_content_serialization() {
fn reply_content_serialization() {
#[rustfmt::skip] // rustfmt wants to merge the next two lines
let message_event_content =
assign!(MessageEventContent::plain("> <@test:example.com> test\n\ntest reply"), {
@ -214,7 +214,7 @@ fn html_and_text_content_deserialization() {
}
#[test]
fn relates_to_content_deserialization() {
fn reply_content_deserialization() {
let json_data = json!({
"org.matrix.msc1767.text": [
{ "body": "> <@test:example.com> test\n\ntest reply" },
@ -237,6 +237,26 @@ fn relates_to_content_deserialization() {
assert_eq!(event_id, "$15827405538098VGFWH:example.com");
}
#[test]
fn thread_content_deserialization() {
let json_data = json!({
"org.matrix.msc1767.text": [
{ "body": "Test in thread" },
],
"m.relates_to": {
"rel_type": "m.thread",
"event_id": "$15827405538098VGFWH:example.com",
}
});
let content = from_json_value::<MessageEventContent>(json_data).unwrap();
assert_eq!(content.text.find_plain(), Some("Test in thread"));
assert_eq!(content.text.find_html(), None);
assert_matches!(content.relates_to, Some(Relation::Thread(thread)));
assert_eq!(thread.event_id, "$15827405538098VGFWH:example.com");
}
#[test]
fn message_event_deserialization() {
let json_data = json!({

54
crates/ruma-common/tests/events/relations.rs
View File

@ -2,7 +2,7 @@ use assert_matches2::assert_matches;
use assign::assign;
use ruma_common::{
events::{
relation::{InReplyTo, Replacement, Thread},
relation::{CustomRelation, InReplyTo, Replacement, Thread},
room::message::{MessageType, Relation, RoomMessageEventContent},
},
owned_event_id,
@ -249,3 +249,55 @@ fn thread_unstable_deserialize() {
assert_eq!(thread.in_reply_to.unwrap().event_id, "$latesteventid");
assert!(!thread.is_falling_back);
}
#[test]
fn custom_deserialize() {
let json = json!({
"msgtype": "m.text",
"body": "<text msg>",
"m.relates_to": {
"rel_type": "io.ruma.unknown",
"event_id": "$related_event",
"key": "value",
},
});
assert_matches!(
from_json_value::<RoomMessageEventContent>(json),
Ok(RoomMessageEventContent {
msgtype: MessageType::Text(_),
relates_to: Some(relation),
..
})
);
assert_eq!(relation.rel_type().unwrap().as_str(), "io.ruma.unknown");
assert_eq!(relation.event_id().as_str(), "$related_event");
let data = relation.data();
assert_eq!(data.get("key").unwrap().as_str(), Some("value"));
}
#[test]
fn custom_serialize() {
let json = json!({
"rel_type": "io.ruma.unknown",
"event_id": "$related_event",
"key": "value",
});
let relation = from_json_value::<CustomRelation>(json).unwrap();
let mut content = RoomMessageEventContent::text_plain("<text msg>");
content.relates_to = Some(Relation::_Custom(relation));
assert_eq!(
to_json_value(&content).unwrap(),
json!({
"msgtype": "m.text",
"body": "<text msg>",
"m.relates_to": {
"rel_type": "io.ruma.unknown",
"event_id": "$related_event",
"key": "value",
},
})
);
}