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

Convert m.room.canonical_alias to the new API. Reorder additional fields

Browse Source 
alphabetically. Remove unused serde attributes.
This commit is contained in:
Jimmy Cuadra 2019-06-22 00:01:51 -07:00
parent 71646445d5
commit 5b505cc501
4 changed files with 216 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/room.rs
View File

@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
pub mod aliases;
pub mod avatar;
// pub mod canonical_alias;
pub mod canonical_alias;
// pub mod create;
// pub mod encrypted;
pub mod encryption;

227
src/room/canonical_alias.rs
View File

@ -1,43 +1,222 @@
//! Types for the *m.room.canonical_alias* event.
use std::{convert::TryFrom, str::FromStr};
use js_int::UInt;
use ruma_identifiers::RoomAliasId;
use serde::{Deserialize, Serialize};
use ruma_identifiers::{EventId, RoomAliasId, RoomId, UserId};
use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
use serde_json::Value;
use crate::empty_string_as_none;
use crate::{
empty_string_as_none, Event, EventType, InvalidEvent, InvalidInput, RoomEvent, StateEvent,
};
state_event! {
/// Informs the room as to which alias is the canonical one.
pub struct CanonicalAliasEvent(CanonicalAliasEventContent) {}
/// Informs the room as to which alias is the canonical one.
#[derive(Clone, Debug, PartialEq)]
pub struct CanonicalAliasEvent {
/// The event's content.
pub content: CanonicalAliasEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Timestamp (milliseconds since the UNIX epoch) on originating homeserver when this
/// event was sent.
pub origin_server_ts: UInt,
/// The previous content for this state key, if any.
pub prev_content: Option<CanonicalAliasEventContent>,
/// 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.
pub unsigned: Option<Value>,
}
/// The payload of a `CanonicalAliasEvent`.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct CanonicalAliasEventContent {
/// The canonical alias.
///
/// Rooms with `alias: None` should be treated the same as a room with no canonical alias.
// The spec says “A room with an m.room.canonical_alias event with an absent, null, or empty alias field
// should be treated the same as a room with no m.room.canonical_alias event.”.
// Serde maps null fields to None by default, serde(default) maps an absent field to None,
// and empty_string_as_none does exactly that, preventing empty strings getting parsed as RoomAliasId.
#[serde(default)]
#[serde(deserialize_with = "empty_string_as_none")]
pub alias: Option<RoomAliasId>,
}
impl FromStr for CanonicalAliasEvent {
type Err = InvalidEvent;
/// Attempt to create `Self` from parsing a string of JSON data.
fn from_str(json: &str) -> Result<Self, Self::Err> {
let raw = serde_json::from_str::<raw::CanonicalAliasEvent>(json)?;
Ok(Self {
content: CanonicalAliasEventContent {
alias: raw.content.alias,
},
event_id: raw.event_id,
origin_server_ts: raw.origin_server_ts,
prev_content: raw
.prev_content
.map(|prev| CanonicalAliasEventContent { alias: prev.alias }),
room_id: raw.room_id,
sender: raw.sender,
state_key: raw.state_key,
unsigned: raw.unsigned,
})
}
}
impl<'a> TryFrom<&'a str> for CanonicalAliasEvent {
type Error = InvalidEvent;
/// Attempt to create `Self` from parsing a string of JSON data.
fn try_from(json: &'a str) -> Result<Self, Self::Error> {
FromStr::from_str(json)
}
}
impl Serialize for CanonicalAliasEvent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut len = 6;
if self.prev_content.is_some() {
len += 1;
}
if self.room_id.is_some() {
len += 1;
}
if self.unsigned.is_some() {
len += 1;
}
let mut state = serializer.serialize_struct("CanonicalAliasEvent", len)?;
state.serialize_field("content", &self.content)?;
state.serialize_field("event_id", &self.event_id)?;
state.serialize_field("origin_server_ts", &self.origin_server_ts)?;
if self.prev_content.is_some() {
state.serialize_field("prev_content", &self.prev_content)?;
}
if self.room_id.is_some() {
state.serialize_field("room_id", &self.room_id)?;
}
if self.unsigned.is_some() {
state.serialize_field("unsigned", &self.unsigned)?;
}
state.serialize_field("sender", &self.sender)?;
state.serialize_field("state_key", &self.state_key)?;
state.serialize_field("type", &self.event_type())?;
state.end()
}
}
impl_state_event!(
CanonicalAliasEvent,
CanonicalAliasEventContent,
EventType::RoomCanonicalAlias
);
mod raw {
use super::*;
/// Informs the room as to which alias is the canonical one.
#[derive(Clone, Debug, Deserialize, PartialEq)]
pub struct CanonicalAliasEvent {
/// The event's content.
pub content: CanonicalAliasEventContent,
/// The unique identifier for the event.
pub event_id: EventId,
/// Timestamp (milliseconds since the UNIX epoch) on originating homeserver when this
/// event was sent.
pub origin_server_ts: UInt,
/// The previous content for this state key, if any.
pub prev_content: Option<CanonicalAliasEventContent>,
/// 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.
pub unsigned: Option<Value>,
}
/// The payload of a `CanonicalAliasEvent`.
#[derive(Clone, Debug, Deserialize, PartialEq)]
pub struct CanonicalAliasEventContent {
/// The canonical alias.
///
/// Rooms with `alias: None` should be treated the same as a room with no canonical alias.
// The spec says "A room with an m.room.canonical_alias event with an absent, null, or empty
// alias field should be treated the same as a room with no m.room.canonical_alias event."
#[serde(default)]
#[serde(deserialize_with = "empty_string_as_none")]
pub alias: Option<RoomAliasId>,
}
}
#[cfg(test)]
mod tests {
use serde_json::from_str;
use super::CanonicalAliasEventContent;
use ruma_identifiers::RoomAliasId;
use std::convert::TryFrom;
use js_int::UInt;
use ruma_identifiers::{EventId, RoomAliasId, RoomId, UserId};
use serde_json::Value;
use super::{CanonicalAliasEvent, CanonicalAliasEventContent};
#[test]
fn serialization_with_optional_fields_as_none() {
let canonical_alias_event = CanonicalAliasEvent {
content: CanonicalAliasEventContent {
alias: Some(RoomAliasId::try_from("#somewhere:localhost").unwrap()),
},
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UInt::try_from(1).unwrap(),
prev_content: None,
room_id: None,
sender: UserId::try_from("@carl:example.com").unwrap(),
state_key: "".to_string(),
unsigned: None,
};
let actual = serde_json::to_string(&canonical_alias_event).unwrap();
let expected = r##"{"content":{"alias":"#somewhere:localhost"},"event_id":"$h29iv0s8:example.com","origin_server_ts":1,"sender":"@carl:example.com","state_key":"","type":"m.room.canonical_alias"}"##;
assert_eq!(actual, expected);
}
#[test]
fn absent_field_as_none() {
assert_eq!(
from_str::<CanonicalAliasEventContent>(r#"{}"#)
r#"{"content":{},"event_id":"$h29iv0s8:example.com","origin_server_ts":1,"sender":"@carl:example.com","state_key":"","type":"m.room.canonical_alias"}"#
.parse::<CanonicalAliasEvent>()
.unwrap()
.content
.alias,
None
);
@ -46,8 +225,10 @@ mod tests {
#[test]
fn null_field_as_none() {
assert_eq!(
from_str::<CanonicalAliasEventContent>(r#"{"alias":null}"#)
r#"{"content":{"alias":null},"event_id":"$h29iv0s8:example.com","origin_server_ts":1,"sender":"@carl:example.com","state_key":"","type":"m.room.canonical_alias"}"#
.parse::<CanonicalAliasEvent>()
.unwrap()
.content
.alias,
None
);
@ -56,8 +237,10 @@ mod tests {
#[test]
fn empty_field_as_none() {
assert_eq!(
from_str::<CanonicalAliasEventContent>(r#"{"alias":""}"#)
r#"{"content":{"alias":""},"event_id":"$h29iv0s8:example.com","origin_server_ts":1,"sender":"@carl:example.com","state_key":"","type":"m.room.canonical_alias"}"#
.parse::<CanonicalAliasEvent>()
.unwrap()
.content
.alias,
None
);
@ -68,8 +251,10 @@ mod tests {
let alias = Some(RoomAliasId::try_from("#somewhere:localhost").unwrap());
assert_eq!(
from_str::<CanonicalAliasEventContent>(r##"{"alias":"#somewhere:localhost"}"##)
r##"{"content":{"alias":"#somewhere:localhost"},"event_id":"$h29iv0s8:example.com","origin_server_ts":1,"sender":"@carl:example.com","state_key":"","type":"m.room.canonical_alias"}"##
.parse::<CanonicalAliasEvent>()
.unwrap()
.content
.alias,
alias
);

24
src/room/name.rs
View File

@ -44,12 +44,6 @@ pub struct NameEvent {
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct NameEventContent {
/// The name of the room. This MUST NOT exceed 255 bytes.
// The spec says “A room with an m.room.name event with an absent, null, or empty name field
// should be treated the same as a room with no m.room.name event.”.
// Serde maps null fields to None by default, serde(default) maps an absent field to None,
// and empty_string_as_none completes the handling.
#[serde(default)]
#[serde(deserialize_with = "empty_string_as_none")]
pub(crate) name: Option<String>,
}
@ -70,9 +64,9 @@ impl FromStr for NameEvent {
.prev_content
.map(|prev| NameEventContent { name: prev.name }),
room_id: raw.room_id,
unsigned: raw.unsigned,
sender: raw.sender,
state_key: raw.state_key,
unsigned: raw.unsigned,
})
}
}
@ -177,24 +171,22 @@ mod raw {
/// The unique identifier for the room associated with this event.
pub room_id: Option<RoomId>,
/// Additional key-value pairs not signed by the homeserver.
pub unsigned: Option<Value>,
/// 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.
pub unsigned: Option<Value>,
}
/// The payload of a `NameEvent`.
#[derive(Clone, Debug, Deserialize, PartialEq)]
pub struct NameEventContent {
/// The name of the room. This MUST NOT exceed 255 bytes.
// The spec says “A room with an m.room.name event with an absent, null, or empty name field
// should be treated the same as a room with no m.room.name event.”.
// Serde maps null fields to None by default, serde(default) maps an absent field to None,
// and empty_string_as_none completes the handling.
// The spec says "A room with an m.room.name event with an absent, null, or empty name field
// should be treated the same as a room with no m.room.name event."
#[serde(default)]
#[serde(deserialize_with = "empty_string_as_none")]
pub(crate) name: Option<String>,
@ -221,9 +213,9 @@ mod tests {
origin_server_ts: UInt::try_from(1).unwrap(),
prev_content: None,
room_id: None,
unsigned: None,
sender: UserId::try_from("@carl:example.com").unwrap(),
state_key: "".to_string(),
unsigned: None,
};
let actual = serde_json::to_string(&name_event).unwrap();
@ -244,9 +236,9 @@ mod tests {
name: Some("The old name".to_string()),
}),
room_id: Some(RoomId::try_from("!n8f893n9:example.com").unwrap()),
unsigned: Some(serde_json::from_str::<Value>(r#"{"foo":"bar"}"#).unwrap()),
sender: UserId::try_from("@carl:example.com").unwrap(),
state_key: "".to_string(),
unsigned: Some(serde_json::from_str::<Value>(r#"{"foo":"bar"}"#).unwrap()),
};
let actual = serde_json::to_string(&name_event).unwrap();

2
src/room/power_levels.rs
View File

@ -120,9 +120,9 @@ impl FromStr for PowerLevelsEvent {
notifications: prev.notifications,
}),
room_id: raw.room_id,
unsigned: raw.unsigned,
sender: raw.sender,
state_key: raw.state_key,
unsigned: raw.unsigned,
})
}
}