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

Re-rustfmt ruma-events

Browse Source
This commit is contained in:
Jonas Platte 2020-06-10 22:17:59 +02:00
parent f304c04d1d
commit fbf0deacfe
No known key found for this signature in database
GPG Key ID: 7D261D771D915378
15 changed files with 56 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ruma-events/src/algorithm.rs
View File

@ -58,13 +58,7 @@ mod tests {
#[test]
fn serialize_and_deserialize_from_display_form() {
serde_json_eq(Algorithm::MegolmV1AesSha2, json!("m.megolm.v1.aes-sha2"));
serde_json_eq(
Algorithm::OlmV1Curve25519AesSha2,
json!("m.olm.v1.curve25519-aes-sha2"),
);
serde_json_eq(
Algorithm::Custom("io.ruma.test".to_string()),
json!("io.ruma.test"),
);
serde_json_eq(Algorithm::OlmV1Curve25519AesSha2, json!("m.olm.v1.curve25519-aes-sha2"));
serde_json_eq(Algorithm::Custom("io.ruma.test".to_string()), json!("io.ruma.test"));
}
}

11
ruma-events/src/direct.rs
View File

@ -66,10 +66,7 @@ mod tests {
#[test]
fn deserialization() {
let alice = UserId::new("ruma.io").unwrap();
let rooms = vec![
RoomId::new("ruma.io").unwrap(),
RoomId::new("ruma.io").unwrap(),
];
let rooms = vec![RoomId::new("ruma.io").unwrap(), RoomId::new("ruma.io").unwrap()];
let json_data = json!({
"content": {
@ -78,10 +75,8 @@ mod tests {
"type": "m.direct"
});
let event: DirectEvent = from_json_value::<EventJson<_>>(json_data)
.unwrap()
.deserialize()
.unwrap();
let event: DirectEvent =
from_json_value::<EventJson<_>>(json_data).unwrap().deserialize().unwrap();
let direct_rooms = event.content.get(&alice).unwrap();
assert!(direct_rooms.contains(&rooms[0]));

9
ruma-events/src/dummy.rs
View File

@ -47,9 +47,7 @@ mod tests {
#[test]
fn serialization() {
let dummy_event = DummyEvent {
content: DummyEventContent(Empty),
};
let dummy_event = DummyEvent { content: DummyEventContent(Empty) };
let actual = to_json_value(dummy_event).unwrap();
let expected = json!({
@ -67,9 +65,6 @@ mod tests {
"type": "m.dummy"
});
assert!(from_json_value::<EventJson<DummyEvent>>(json)
.unwrap()
.deserialize()
.is_ok());
assert!(from_json_value::<EventJson<DummyEvent>>(json).unwrap().deserialize().is_ok());
}
}

55
ruma-events/src/event_type.rs
View File

@ -271,64 +271,34 @@ mod tests {
serde_json_eq(EventType::Dummy, json!("m.dummy"));
serde_json_eq(EventType::ForwardedRoomKey, json!("m.forwarded_room_key"));
serde_json_eq(EventType::FullyRead, json!("m.fully_read"));
serde_json_eq(
EventType::KeyVerificationAccept,
json!("m.key.verification.accept"),
);
serde_json_eq(
EventType::KeyVerificationCancel,
json!("m.key.verification.cancel"),
);
serde_json_eq(
EventType::KeyVerificationKey,
json!("m.key.verification.key"),
);
serde_json_eq(
EventType::KeyVerificationMac,
json!("m.key.verification.mac"),
);
serde_json_eq(
EventType::KeyVerificationRequest,
json!("m.key.verification.request"),
);
serde_json_eq(
EventType::KeyVerificationStart,
json!("m.key.verification.start"),
);
serde_json_eq(EventType::KeyVerificationAccept, json!("m.key.verification.accept"));
serde_json_eq(EventType::KeyVerificationCancel, json!("m.key.verification.cancel"));
serde_json_eq(EventType::KeyVerificationKey, json!("m.key.verification.key"));
serde_json_eq(EventType::KeyVerificationMac, json!("m.key.verification.mac"));
serde_json_eq(EventType::KeyVerificationRequest, json!("m.key.verification.request"));
serde_json_eq(EventType::KeyVerificationStart, json!("m.key.verification.start"));
serde_json_eq(EventType::IgnoredUserList, json!("m.ignored_user_list"));
serde_json_eq(EventType::Presence, json!("m.presence"));
serde_json_eq(EventType::PushRules, json!("m.push_rules"));
serde_json_eq(EventType::Receipt, json!("m.receipt"));
serde_json_eq(EventType::RoomAliases, json!("m.room.aliases"));
serde_json_eq(EventType::RoomAvatar, json!("m.room.avatar"));
serde_json_eq(
EventType::RoomCanonicalAlias,
json!("m.room.canonical_alias"),
);
serde_json_eq(EventType::RoomCanonicalAlias, json!("m.room.canonical_alias"));
serde_json_eq(EventType::RoomCreate, json!("m.room.create"));
serde_json_eq(EventType::RoomEncrypted, json!("m.room.encrypted"));
serde_json_eq(EventType::RoomEncryption, json!("m.room.encryption"));
serde_json_eq(EventType::RoomGuestAccess, json!("m.room.guest_access"));
serde_json_eq(
EventType::RoomHistoryVisibility,
json!("m.room.history_visibility"),
);
serde_json_eq(EventType::RoomHistoryVisibility, json!("m.room.history_visibility"));
serde_json_eq(EventType::RoomJoinRules, json!("m.room.join_rules"));
serde_json_eq(EventType::RoomMember, json!("m.room.member"));
serde_json_eq(EventType::RoomMessage, json!("m.room.message"));
serde_json_eq(
EventType::RoomMessageFeedback,
json!("m.room.message.feedback"),
);
serde_json_eq(EventType::RoomMessageFeedback, json!("m.room.message.feedback"));
serde_json_eq(EventType::RoomName, json!("m.room.name"));
serde_json_eq(EventType::RoomPinnedEvents, json!("m.room.pinned_events"));
serde_json_eq(EventType::RoomPowerLevels, json!("m.room.power_levels"));
serde_json_eq(EventType::RoomRedaction, json!("m.room.redaction"));
serde_json_eq(EventType::RoomServerAcl, json!("m.room.server_acl"));
serde_json_eq(
EventType::RoomThirdPartyInvite,
json!("m.room.third_party_invite"),
);
serde_json_eq(EventType::RoomThirdPartyInvite, json!("m.room.third_party_invite"));
serde_json_eq(EventType::RoomTombstone, json!("m.room.tombstone"));
serde_json_eq(EventType::RoomTopic, json!("m.room.topic"));
serde_json_eq(EventType::RoomKey, json!("m.room_key"));
@ -336,9 +306,6 @@ mod tests {
serde_json_eq(EventType::Sticker, json!("m.sticker"));
serde_json_eq(EventType::Tag, json!("m.tag"));
serde_json_eq(EventType::Typing, json!("m.typing"));
serde_json_eq(
EventType::Custom("io.ruma.test".to_string()),
json!("io.ruma.test"),
);
serde_json_eq(EventType::Custom("io.ruma.test".to_string()), json!("io.ruma.test"));
}
}

18
ruma-events/src/json.rs
View File

@ -25,10 +25,7 @@ pub struct EventJson<T> {
impl<T> EventJson<T> {
fn new(json: Box<RawValue>) -> Self {
Self {
json,
_ev: PhantomData,
}
Self { json, _ev: PhantomData }
}
/// Create an `EventJson` from a boxed `RawValue`.
@ -55,10 +52,9 @@ where
pub fn deserialize(&self) -> Result<T, InvalidEvent> {
match serde_json::from_str(self.json.get()) {
Ok(value) => Ok(value),
Err(err) => Err(InvalidEvent {
message: err.to_string(),
kind: InvalidEventKind::Validation,
}),
Err(err) => {
Err(InvalidEvent { message: err.to_string(), kind: InvalidEventKind::Validation })
}
}
}
}
@ -69,10 +65,8 @@ where
{
/// Try to deserialize the JSON as event content
pub fn deserialize_content(self, event_type: &str) -> Result<T, InvalidEvent> {
T::from_parts(event_type, self.json).map_err(|err| InvalidEvent {
message: err,
kind: InvalidEventKind::Deserialization,
})
T::from_parts(event_type, self.json)
.map_err(|err| InvalidEvent { message: err, kind: InvalidEventKind::Deserialization })
}
}

5
ruma-events/src/key/verification/cancel.rs
View File

@ -139,10 +139,7 @@ mod tests {
#[test]
fn cancel_codes_deserialize_from_display_form() {
assert_eq!(
from_json_value::<CancelCode>(json!("m.user")).unwrap(),
CancelCode::User
);
assert_eq!(from_json_value::<CancelCode>(json!("m.user")).unwrap(), CancelCode::User);
}
#[test]

14
ruma-events/src/key/verification/start.rs
View File

@ -105,10 +105,7 @@ impl MSasV1Content {
/// `MessageAuthenticationCode::HkdfHmacSha256`.
/// * `short_authentication_string` does not include `ShortAuthenticationString::Decimal`.
pub fn new(options: MSasV1ContentOptions) -> Result<Self, InvalidInput> {
if !options
.key_agreement_protocols
.contains(&KeyAgreementProtocol::Curve25519)
{
if !options.key_agreement_protocols.contains(&KeyAgreementProtocol::Curve25519) {
return Err(InvalidInput("`key_agreement_protocols` must contain at least `KeyAgreementProtocol::Curve25519`".to_string()));
}
@ -125,10 +122,7 @@ impl MSasV1Content {
return Err(InvalidInput("`message_authentication_codes` must contain at least `MessageAuthenticationCode::HkdfHmacSha256`".to_string()));
}
if !options
.short_authentication_string
.contains(&ShortAuthenticationString::Decimal)
{
if !options.short_authentication_string.contains(&ShortAuthenticationString::Decimal) {
return Err(InvalidInput("`short_authentication_string` must contain at least `ShortAuthenticationString::Decimal`".to_string()));
}
@ -232,9 +226,7 @@ mod tests {
.unwrap(),
);
let key_verification_start = StartEvent {
content: key_verification_start_content,
};
let key_verification_start = StartEvent { content: key_verification_start_content };
let json_data = json!({
"content": {

15
ruma-events/src/push_rules.rs
View File

@ -189,10 +189,7 @@ mod tests {
"kind": "room_member_count"
});
assert_eq!(
to_json_value(&PushCondition::RoomMemberCount {
is: "2".to_string(),
})
.unwrap(),
to_json_value(&PushCondition::RoomMemberCount { is: "2".to_string() }).unwrap(),
json_data
);
}
@ -205,9 +202,7 @@ mod tests {
});
assert_eq!(
json_data,
to_json_value(&PushCondition::SenderNotificationPermission {
key: "room".to_string(),
})
to_json_value(&PushCondition::SenderNotificationPermission { key: "room".to_string() })
.unwrap()
);
}
@ -456,9 +451,7 @@ mod tests {
"type": "m.push_rules"
});
let _ = from_json_value::<EventJson<PushRulesEvent>>(json_data)
.unwrap()
.deserialize()
.unwrap();
let _ =
from_json_value::<EventJson<PushRulesEvent>>(json_data).unwrap().deserialize().unwrap();
}
}

5
ruma-events/src/room/encrypted.rs
View File

@ -92,10 +92,7 @@ mod tests {
"session_id": "session_id"
});
assert_eq!(
to_json_value(&key_verification_start_content).unwrap(),
json_data
);
assert_eq!(to_json_value(&key_verification_start_content).unwrap(), json_data);
}
#[test]

6
ruma-events/src/room/message.rs
View File

@ -384,11 +384,7 @@ pub struct InReplyTo {
impl TextMessageEventContent {
/// A convenience constructor to create a plain text message
pub fn new_plain(body: impl Into<String>) -> TextMessageEventContent {
TextMessageEventContent {
body: body.into(),
formatted: None,
relates_to: None,
}
TextMessageEventContent { body: body.into(), formatted: None, relates_to: None }
}
}

30
ruma-events/src/room/name.rs
View File

@ -27,9 +27,7 @@ impl NameEventContent {
match name.len() {
0 => Ok(Self { name: None }),
1..=255 => Ok(Self { name: Some(name) }),
_ => Err(InvalidInput(
"a room name cannot be more than 255 bytes".to_string(),
)),
_ => Err(InvalidInput("a room name cannot be more than 255 bytes".to_string())),
}
}
@ -50,9 +48,7 @@ where
Some(name) => match name.len() {
0 => Ok(None),
1..=255 => Ok(Some(name)),
_ => Err(D::Error::custom(
"a room name cannot be more than 255 bytes",
)),
_ => Err(D::Error::custom("a room name cannot be more than 255 bytes")),
},
None => Ok(None),
}
@ -78,9 +74,7 @@ mod tests {
#[test]
fn serialization_with_optional_fields_as_none() {
let name_event = StateEvent {
content: NameEventContent {
name: Some("The room name".to_string()),
},
content: NameEventContent { name: Some("The room name".to_string()) },
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UNIX_EPOCH + Duration::from_millis(1),
prev_content: None,
@ -109,21 +103,14 @@ mod tests {
#[test]
fn serialization_with_all_fields() {
let name_event = StateEvent {
content: NameEventContent {
name: Some("The room name".to_string()),
},
content: NameEventContent { name: Some("The room name".to_string()) },
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UNIX_EPOCH + Duration::from_millis(1),
prev_content: Some(NameEventContent {
name: Some("The old name".to_string()),
}),
prev_content: Some(NameEventContent { name: Some("The old name".to_string()) }),
room_id: RoomId::try_from("!n8f893n9:example.com").unwrap(),
sender: UserId::try_from("@carl:example.com").unwrap(),
state_key: "".to_string(),
unsigned: UnsignedData {
age: Some(Int::from(100)),
..UnsignedData::default()
},
unsigned: UnsignedData { age: Some(Int::from(100)), ..UnsignedData::default() },
};
let actual = to_json_value(&name_event).unwrap();
@ -185,10 +172,7 @@ mod tests {
fn json_with_empty_name_creates_content_as_none() {
let long_content_json = json!({ "name": "" });
let from_raw: EventJson<NameEventContent> = from_json_value(long_content_json).unwrap();
assert_matches!(
from_raw.deserialize().unwrap(),
NameEventContent { name: None }
);
assert_matches!(from_raw.deserialize().unwrap(), NameEventContent { name: None });
}
#[test]

42
ruma-events/src/room/power_levels.rs
View File

@ -17,10 +17,7 @@ pub type PowerLevelsEvent = StateEvent<PowerLevelsEventContent>;
#[ruma_event(type = "m.room.power_levels")]
pub struct PowerLevelsEventContent {
/// The level required to ban a user.
#[serde(
default = "default_power_level",
skip_serializing_if = "is_default_power_level"
)]
#[serde(default = "default_power_level", skip_serializing_if = "is_default_power_level")]
pub ban: Int,
/// The level required to send specific event types.
@ -34,31 +31,19 @@ pub struct PowerLevelsEventContent {
pub events_default: Int,
/// The level required to invite a user.
#[serde(
default = "default_power_level",
skip_serializing_if = "is_default_power_level"
)]
#[serde(default = "default_power_level", skip_serializing_if = "is_default_power_level")]
pub invite: Int,
/// The level required to kick a user.
#[serde(
default = "default_power_level",
skip_serializing_if = "is_default_power_level"
)]
#[serde(default = "default_power_level", skip_serializing_if = "is_default_power_level")]
pub kick: Int,
/// The level required to redact an event.
#[serde(
default = "default_power_level",
skip_serializing_if = "is_default_power_level"
)]
#[serde(default = "default_power_level", skip_serializing_if = "is_default_power_level")]
pub redact: Int,
/// The default level required to send state events.
#[serde(
default = "default_power_level",
skip_serializing_if = "is_default_power_level"
)]
#[serde(default = "default_power_level", skip_serializing_if = "is_default_power_level")]
pub state_default: Int,
/// The power levels for specific users.
@ -107,9 +92,7 @@ pub struct NotificationPowerLevels {
impl Default for NotificationPowerLevels {
fn default() -> Self {
Self {
room: default_power_level(),
}
Self { room: default_power_level() }
}
}
@ -198,9 +181,7 @@ mod tests {
user.clone() => Int::from(23)
},
users_default: Int::from(23),
notifications: NotificationPowerLevels {
room: Int::from(23),
},
notifications: NotificationPowerLevels { room: Int::from(23) },
},
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UNIX_EPOCH + Duration::from_millis(1),
@ -219,15 +200,10 @@ mod tests {
user.clone() => Int::from(42)
},
users_default: Int::from(42),
notifications: NotificationPowerLevels {
room: Int::from(42),
},
notifications: NotificationPowerLevels { room: Int::from(42) },
}),
room_id: RoomId::try_from("!n8f893n9:example.com").unwrap(),
unsigned: UnsignedData {
age: Some(Int::from(100)),
..UnsignedData::default()
},
unsigned: UnsignedData { age: Some(Int::from(100)), ..UnsignedData::default() },
sender: user,
state_key: "".to_string(),
};

4
ruma-events/src/room/redaction.rs
View File

@ -81,9 +81,7 @@ mod tests {
#[test]
fn serialization() {
let event = RedactionEvent {
content: RedactionEventContent {
reason: Some("redacted because".into()),
},
content: RedactionEventContent { reason: Some("redacted because".into()) },
redacts: EventId::try_from("$h29iv0s8:example.com").unwrap(),
event_id: EventId::try_from("$h29iv0s8:example.com").unwrap(),
origin_server_ts: UNIX_EPOCH + Duration::from_millis(1),

5
ruma-events/src/room/server_acl.rs
View File

@ -17,10 +17,7 @@ pub struct ServerAclEventContent {
/// This is strongly recommended to be set to false as servers running with IP literal
/// names are strongly discouraged in order to require legitimate homeservers to be
/// backed by a valid registered domain name.
#[serde(
default = "ruma_serde::default_true",
skip_serializing_if = "ruma_serde::is_true"
)]
#[serde(default = "ruma_serde::default_true", skip_serializing_if = "ruma_serde::is_true")]
pub allow_ip_literals: bool,
/// The server names to allow in the room, excluding any port information. Wildcards may

11
ruma-events/src/util.rs
View File

@ -6,9 +6,7 @@ where
T: DeserializeOwned,
E: serde::de::Error,
{
serde_json::from_value(value)
.map(variant)
.map_err(serde_json_error_to_generic_de_error)
serde_json::from_value(value).map(variant).map_err(serde_json_error_to_generic_de_error)
}
pub fn serde_json_error_to_generic_de_error<E: serde::de::Error>(error: serde_json::Error) -> E {
@ -20,11 +18,6 @@ where
T: DeserializeOwned,
E: serde::de::Error,
{
serde_json::from_value(
value
.get(field)
.cloned()
.ok_or_else(|| E::missing_field(field))?,
)
serde_json::from_value(value.get(field).cloned().ok_or_else(|| E::missing_field(field))?)
.map_err(serde_json_error_to_generic_de_error)
}