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

Restore Rust 1.34.2 compatibility

Browse Source
This commit is contained in:
Jonas Platte 2019-10-23 02:09:34 +02:00
parent c925cd13f1
commit 60c817e1b0
11 changed files with 412 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -6,7 +6,7 @@
## Minimum Rust version ## Minimum Rust version
ruma-events requires Rust 1.34 or later. ruma-events requires Rust 1.34.2 or later.
## Documentation ## Documentation

6
ruma-events-macros/src/parse.rs
View File

@ -215,20 +215,20 @@ impl Parse for RumaEventField {
.into_iter() .into_iter()
.collect(); .collect();
Ok(Self::InlineStruct(FieldInlineStruct { Ok(RumaEventField::InlineStruct(FieldInlineStruct {
attrs, attrs,
member, member,
colon_token, colon_token,
fields, fields,
})) }))
} }
"content_type_alias" => Ok(Self::Block(FieldBlock { "content_type_alias" => Ok(RumaEventField::Block(FieldBlock {
attrs: input.call(Attribute::parse_outer)?, attrs: input.call(Attribute::parse_outer)?,
member: input.parse()?, member: input.parse()?,
colon_token: input.parse()?, colon_token: input.parse()?,
typedef: input.parse()?, typedef: input.parse()?,
})), })),
_ => Ok(Self::Value(input.parse()?)), _ => Ok(RumaEventField::Value(input.parse()?)),
} }
} }
} }

196
src/collections/all.rs
View File

@ -343,54 +343,60 @@ impl TryFromRaw for Event {
use raw::Event::*; use raw::Event::*;
match raw { match raw {
CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c), CallAnswer(c) => conv(CallAnswer, Event::CallAnswer, c),
CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c), CallCandidates(c) => conv(CallCandidates, Event::CallCandidates, c),
CallHangup(c) => conv(CallHangup, Self::CallHangup, c), CallHangup(c) => conv(CallHangup, Event::CallHangup, c),
CallInvite(c) => conv(CallInvite, Self::CallInvite, c), CallInvite(c) => conv(CallInvite, Event::CallInvite, c),
Direct(c) => conv(Direct, Self::Direct, c), Direct(c) => conv(Direct, Event::Direct, c),
Dummy(c) => conv(Dummy, Self::Dummy, c), Dummy(c) => conv(Dummy, Event::Dummy, c),
ForwardedRoomKey(c) => conv(ForwardedRoomKey, Self::ForwardedRoomKey, c), ForwardedRoomKey(c) => conv(ForwardedRoomKey, Event::ForwardedRoomKey, c),
FullyRead(c) => conv(FullyRead, Self::FullyRead, c), FullyRead(c) => conv(FullyRead, Event::FullyRead, c),
IgnoredUserList(c) => conv(IgnoredUserList, Self::IgnoredUserList, c), IgnoredUserList(c) => conv(IgnoredUserList, Event::IgnoredUserList, c),
KeyVerificationAccept(c) => conv(KeyVerificationAccept, Self::KeyVerificationAccept, c), KeyVerificationAccept(c) => {
KeyVerificationCancel(c) => conv(KeyVerificationCancel, Self::KeyVerificationCancel, c), conv(KeyVerificationAccept, Event::KeyVerificationAccept, c)
KeyVerificationKey(c) => conv(KeyVerificationKey, Self::KeyVerificationKey, c),
KeyVerificationMac(c) => conv(KeyVerificationMac, Self::KeyVerificationMac, c),
KeyVerificationRequest(c) => {
conv(KeyVerificationRequest, Self::KeyVerificationRequest, c)
} }
KeyVerificationStart(c) => conv(KeyVerificationStart, Self::KeyVerificationStart, c), KeyVerificationCancel(c) => {
Presence(c) => conv(Presence, Self::Presence, c), conv(KeyVerificationCancel, Event::KeyVerificationCancel, c)
PushRules(c) => conv(PushRules, Self::PushRules, c), }
Receipt(c) => conv(Receipt, Self::Receipt, c), KeyVerificationKey(c) => conv(KeyVerificationKey, Event::KeyVerificationKey, c),
RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), KeyVerificationMac(c) => conv(KeyVerificationMac, Event::KeyVerificationMac, c),
RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), KeyVerificationRequest(c) => {
RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), conv(KeyVerificationRequest, Event::KeyVerificationRequest, c)
RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), }
RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c), KeyVerificationStart(c) => conv(KeyVerificationStart, Event::KeyVerificationStart, c),
RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c), Presence(c) => conv(Presence, Event::Presence, c),
RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), PushRules(c) => conv(PushRules, Event::PushRules, c),
RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), Receipt(c) => conv(Receipt, Event::Receipt, c),
RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), RoomAliases(c) => conv(RoomAliases, Event::RoomAliases, c),
RoomMember(c) => conv(RoomMember, Self::RoomMember, c), RoomAvatar(c) => conv(RoomAvatar, Event::RoomAvatar, c),
RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c), RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Event::RoomCanonicalAlias, c),
RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c), RoomCreate(c) => conv(RoomCreate, Event::RoomCreate, c),
RoomName(c) => conv(RoomName, Self::RoomName, c), RoomEncrypted(c) => conv(RoomEncrypted, Event::RoomEncrypted, c),
RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c), RoomEncryption(c) => conv(RoomEncryption, Event::RoomEncryption, c),
RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), RoomGuestAccess(c) => conv(RoomGuestAccess, Event::RoomGuestAccess, c),
RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c), RoomHistoryVisibility(c) => {
RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c), conv(RoomHistoryVisibility, Event::RoomHistoryVisibility, c)
RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), }
RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c), RoomJoinRules(c) => conv(RoomJoinRules, Event::RoomJoinRules, c),
RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), RoomMember(c) => conv(RoomMember, Event::RoomMember, c),
RoomKey(c) => conv(RoomKey, Self::RoomKey, c), RoomMessage(c) => conv(RoomMessage, Event::RoomMessage, c),
RoomKeyRequest(c) => conv(RoomKeyRequest, Self::RoomKeyRequest, c), RoomMessageFeedback(c) => conv(RoomMessageFeedback, Event::RoomMessageFeedback, c),
Sticker(c) => conv(Sticker, Self::Sticker, c), RoomName(c) => conv(RoomName, Event::RoomName, c),
Tag(c) => conv(Tag, Self::Tag, c), RoomPinnedEvents(c) => conv(RoomPinnedEvents, Event::RoomPinnedEvents, c),
Typing(c) => conv(Typing, Self::Typing, c), RoomPowerLevels(c) => conv(RoomPowerLevels, Event::RoomPowerLevels, c),
Custom(c) => Ok(Self::Custom(c)), RoomRedaction(c) => conv(RoomRedaction, Event::RoomRedaction, c),
CustomRoom(c) => Ok(Self::CustomRoom(c)), RoomServerAcl(c) => conv(RoomServerAcl, Event::RoomServerAcl, c),
CustomState(c) => Ok(Self::CustomState(c)), RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Event::RoomThirdPartyInvite, c),
RoomTombstone(c) => conv(RoomTombstone, Event::RoomTombstone, c),
RoomTopic(c) => conv(RoomTopic, Event::RoomTopic, c),
RoomKey(c) => conv(RoomKey, Event::RoomKey, c),
RoomKeyRequest(c) => conv(RoomKeyRequest, Event::RoomKeyRequest, c),
Sticker(c) => conv(Sticker, Event::Sticker, c),
Tag(c) => conv(Tag, Event::Tag, c),
Typing(c) => conv(Typing, Event::Typing, c),
Custom(c) => Ok(Event::Custom(c)),
CustomRoom(c) => Ok(Event::CustomRoom(c)),
CustomState(c) => Ok(Event::CustomState(c)),
} }
} }
} }
@ -404,33 +410,37 @@ impl TryFromRaw for RoomEvent {
use raw::RoomEvent::*; use raw::RoomEvent::*;
match raw { match raw {
CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c), CallAnswer(c) => conv(CallAnswer, RoomEvent::CallAnswer, c),
CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c), CallCandidates(c) => conv(CallCandidates, RoomEvent::CallCandidates, c),
CallHangup(c) => conv(CallHangup, Self::CallHangup, c), CallHangup(c) => conv(CallHangup, RoomEvent::CallHangup, c),
CallInvite(c) => conv(CallInvite, Self::CallInvite, c), CallInvite(c) => conv(CallInvite, RoomEvent::CallInvite, c),
RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), RoomAliases(c) => conv(RoomAliases, RoomEvent::RoomAliases, c),
RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), RoomAvatar(c) => conv(RoomAvatar, RoomEvent::RoomAvatar, c),
RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, RoomEvent::RoomCanonicalAlias, c),
RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), RoomCreate(c) => conv(RoomCreate, RoomEvent::RoomCreate, c),
RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c), RoomEncrypted(c) => conv(RoomEncrypted, RoomEvent::RoomEncrypted, c),
RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c), RoomEncryption(c) => conv(RoomEncryption, RoomEvent::RoomEncryption, c),
RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), RoomGuestAccess(c) => conv(RoomGuestAccess, RoomEvent::RoomGuestAccess, c),
RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), RoomHistoryVisibility(c) => {
RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), conv(RoomHistoryVisibility, RoomEvent::RoomHistoryVisibility, c)
RoomMember(c) => conv(RoomMember, Self::RoomMember, c), }
RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c), RoomJoinRules(c) => conv(RoomJoinRules, RoomEvent::RoomJoinRules, c),
RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c), RoomMember(c) => conv(RoomMember, RoomEvent::RoomMember, c),
RoomName(c) => conv(RoomName, Self::RoomName, c), RoomMessage(c) => conv(RoomMessage, RoomEvent::RoomMessage, c),
RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c), RoomMessageFeedback(c) => conv(RoomMessageFeedback, RoomEvent::RoomMessageFeedback, c),
RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), RoomName(c) => conv(RoomName, RoomEvent::RoomName, c),
RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c), RoomPinnedEvents(c) => conv(RoomPinnedEvents, RoomEvent::RoomPinnedEvents, c),
RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c), RoomPowerLevels(c) => conv(RoomPowerLevels, RoomEvent::RoomPowerLevels, c),
RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), RoomRedaction(c) => conv(RoomRedaction, RoomEvent::RoomRedaction, c),
RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c), RoomServerAcl(c) => conv(RoomServerAcl, RoomEvent::RoomServerAcl, c),
RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), RoomThirdPartyInvite(c) => {
Sticker(c) => conv(Sticker, Self::Sticker, c), conv(RoomThirdPartyInvite, RoomEvent::RoomThirdPartyInvite, c)
CustomRoom(c) => Ok(Self::CustomRoom(c)), }
CustomState(c) => Ok(Self::CustomState(c)), RoomTombstone(c) => conv(RoomTombstone, RoomEvent::RoomTombstone, c),
RoomTopic(c) => conv(RoomTopic, RoomEvent::RoomTopic, c),
Sticker(c) => conv(Sticker, RoomEvent::Sticker, c),
CustomRoom(c) => Ok(RoomEvent::CustomRoom(c)),
CustomState(c) => Ok(RoomEvent::CustomState(c)),
} }
} }
} }
@ -444,23 +454,27 @@ impl TryFromRaw for StateEvent {
use raw::StateEvent::*; use raw::StateEvent::*;
match raw { match raw {
RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), RoomAliases(c) => conv(RoomAliases, StateEvent::RoomAliases, c),
RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), RoomAvatar(c) => conv(RoomAvatar, StateEvent::RoomAvatar, c),
RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, StateEvent::RoomCanonicalAlias, c),
RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), RoomCreate(c) => conv(RoomCreate, StateEvent::RoomCreate, c),
RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c), RoomEncryption(c) => conv(RoomEncryption, StateEvent::RoomEncryption, c),
RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), RoomGuestAccess(c) => conv(RoomGuestAccess, StateEvent::RoomGuestAccess, c),
RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), RoomHistoryVisibility(c) => {
RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), conv(RoomHistoryVisibility, StateEvent::RoomHistoryVisibility, c)
RoomMember(c) => conv(RoomMember, Self::RoomMember, c), }
RoomName(c) => conv(RoomName, Self::RoomName, c), RoomJoinRules(c) => conv(RoomJoinRules, StateEvent::RoomJoinRules, c),
RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c), RoomMember(c) => conv(RoomMember, StateEvent::RoomMember, c),
RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), RoomName(c) => conv(RoomName, StateEvent::RoomName, c),
RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c), RoomPinnedEvents(c) => conv(RoomPinnedEvents, StateEvent::RoomPinnedEvents, c),
RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), RoomPowerLevels(c) => conv(RoomPowerLevels, StateEvent::RoomPowerLevels, c),
RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c), RoomServerAcl(c) => conv(RoomServerAcl, StateEvent::RoomServerAcl, c),
RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), RoomThirdPartyInvite(c) => {
CustomState(c) => Ok(Self::CustomState(c)), conv(RoomThirdPartyInvite, StateEvent::RoomThirdPartyInvite, c)
}
RoomTombstone(c) => conv(RoomTombstone, StateEvent::RoomTombstone, c),
RoomTopic(c) => conv(RoomTopic, StateEvent::RoomTopic, c),
CustomState(c) => Ok(StateEvent::CustomState(c)),
} }
} }
} }

64
src/collections/only.rs
View File

@ -139,27 +139,31 @@ impl TryFromRaw for Event {
use raw::Event::*; use raw::Event::*;
match raw { match raw {
Direct(c) => conv(Direct, Self::Direct, c), Direct(c) => conv(Direct, Event::Direct, c),
Dummy(c) => conv(Dummy, Self::Dummy, c), Dummy(c) => conv(Dummy, Event::Dummy, c),
ForwardedRoomKey(c) => conv(ForwardedRoomKey, Self::ForwardedRoomKey, c), ForwardedRoomKey(c) => conv(ForwardedRoomKey, Event::ForwardedRoomKey, c),
FullyRead(c) => conv(FullyRead, Self::FullyRead, c), FullyRead(c) => conv(FullyRead, Event::FullyRead, c),
KeyVerificationAccept(c) => conv(KeyVerificationAccept, Self::KeyVerificationAccept, c), KeyVerificationAccept(c) => {
KeyVerificationCancel(c) => conv(KeyVerificationCancel, Self::KeyVerificationCancel, c), conv(KeyVerificationAccept, Event::KeyVerificationAccept, c)
KeyVerificationKey(c) => conv(KeyVerificationKey, Self::KeyVerificationKey, c),
KeyVerificationMac(c) => conv(KeyVerificationMac, Self::KeyVerificationMac, c),
KeyVerificationRequest(c) => {
conv(KeyVerificationRequest, Self::KeyVerificationRequest, c)
} }
KeyVerificationStart(c) => conv(KeyVerificationStart, Self::KeyVerificationStart, c), KeyVerificationCancel(c) => {
IgnoredUserList(c) => conv(IgnoredUserList, Self::IgnoredUserList, c), conv(KeyVerificationCancel, Event::KeyVerificationCancel, c)
Presence(c) => conv(Presence, Self::Presence, c), }
PushRules(c) => conv(PushRules, Self::PushRules, c), KeyVerificationKey(c) => conv(KeyVerificationKey, Event::KeyVerificationKey, c),
RoomKey(c) => conv(RoomKey, Self::RoomKey, c), KeyVerificationMac(c) => conv(KeyVerificationMac, Event::KeyVerificationMac, c),
RoomKeyRequest(c) => conv(RoomKeyRequest, Self::RoomKeyRequest, c), KeyVerificationRequest(c) => {
Receipt(c) => conv(Receipt, Self::Receipt, c), conv(KeyVerificationRequest, Event::KeyVerificationRequest, c)
Tag(c) => conv(Tag, Self::Tag, c), }
Typing(c) => conv(Typing, Self::Typing, c), KeyVerificationStart(c) => conv(KeyVerificationStart, Event::KeyVerificationStart, c),
Custom(c) => Ok(Self::Custom(c)), IgnoredUserList(c) => conv(IgnoredUserList, Event::IgnoredUserList, c),
Presence(c) => conv(Presence, Event::Presence, c),
PushRules(c) => conv(PushRules, Event::PushRules, c),
RoomKey(c) => conv(RoomKey, Event::RoomKey, c),
RoomKeyRequest(c) => conv(RoomKeyRequest, Event::RoomKeyRequest, c),
Receipt(c) => conv(Receipt, Event::Receipt, c),
Tag(c) => conv(Tag, Event::Tag, c),
Typing(c) => conv(Typing, Event::Typing, c),
Custom(c) => Ok(Event::Custom(c)),
} }
} }
} }
@ -173,16 +177,16 @@ impl TryFromRaw for RoomEvent {
use raw::RoomEvent::*; use raw::RoomEvent::*;
match raw { match raw {
CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c), CallAnswer(c) => conv(CallAnswer, RoomEvent::CallAnswer, c),
CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c), CallCandidates(c) => conv(CallCandidates, RoomEvent::CallCandidates, c),
CallHangup(c) => conv(CallHangup, Self::CallHangup, c), CallHangup(c) => conv(CallHangup, RoomEvent::CallHangup, c),
CallInvite(c) => conv(CallInvite, Self::CallInvite, c), CallInvite(c) => conv(CallInvite, RoomEvent::CallInvite, c),
RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c), RoomEncrypted(c) => conv(RoomEncrypted, RoomEvent::RoomEncrypted, c),
RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c), RoomMessage(c) => conv(RoomMessage, RoomEvent::RoomMessage, c),
RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c), RoomMessageFeedback(c) => conv(RoomMessageFeedback, RoomEvent::RoomMessageFeedback, c),
RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c), RoomRedaction(c) => conv(RoomRedaction, RoomEvent::RoomRedaction, c),
Sticker(c) => conv(Sticker, Self::Sticker, c), Sticker(c) => conv(Sticker, RoomEvent::Sticker, c),
CustomRoom(c) => Ok(Self::CustomRoom(c)), CustomRoom(c) => Ok(RoomEvent::CustomRoom(c)),
} }
} }
} }

226
src/collections/raw/all.rs
View File

@ -347,85 +347,95 @@ impl<'de> Deserialize<'de> for Event {
let event_type = get_field(&value, "type")?; let event_type = get_field(&value, "type")?;
match event_type { match event_type {
CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err), CallAnswer => from_value(value).map(Event::CallAnswer).map_err(conv_err),
CallCandidates => from_value(value) CallCandidates => from_value(value)
.map(Self::CallCandidates) .map(Event::CallCandidates)
.map_err(conv_err), .map_err(conv_err),
CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err), CallHangup => from_value(value).map(Event::CallHangup).map_err(conv_err),
CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err), CallInvite => from_value(value).map(Event::CallInvite).map_err(conv_err),
Direct => from_value(value).map(Self::Direct).map_err(conv_err), Direct => from_value(value).map(Event::Direct).map_err(conv_err),
Dummy => from_value(value).map(Self::Dummy).map_err(conv_err), Dummy => from_value(value).map(Event::Dummy).map_err(conv_err),
ForwardedRoomKey => from_value(value) ForwardedRoomKey => from_value(value)
.map(Self::ForwardedRoomKey) .map(Event::ForwardedRoomKey)
.map_err(conv_err), .map_err(conv_err),
FullyRead => from_value(value).map(Self::FullyRead).map_err(conv_err), FullyRead => from_value(value).map(Event::FullyRead).map_err(conv_err),
IgnoredUserList => from_value(value) IgnoredUserList => from_value(value)
.map(Self::IgnoredUserList) .map(Event::IgnoredUserList)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationAccept => from_value(value) KeyVerificationAccept => from_value(value)
.map(Self::KeyVerificationAccept) .map(Event::KeyVerificationAccept)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationCancel => from_value(value) KeyVerificationCancel => from_value(value)
.map(Self::KeyVerificationCancel) .map(Event::KeyVerificationCancel)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationKey => from_value(value) KeyVerificationKey => from_value(value)
.map(Self::KeyVerificationKey) .map(Event::KeyVerificationKey)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationMac => from_value(value) KeyVerificationMac => from_value(value)
.map(Self::KeyVerificationMac) .map(Event::KeyVerificationMac)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationRequest => from_value(value) KeyVerificationRequest => from_value(value)
.map(Self::KeyVerificationRequest) .map(Event::KeyVerificationRequest)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationStart => from_value(value) KeyVerificationStart => from_value(value)
.map(Self::KeyVerificationStart) .map(Event::KeyVerificationStart)
.map_err(conv_err), .map_err(conv_err),
Presence => from_value(value).map(Self::Presence).map_err(conv_err), Presence => from_value(value).map(Event::Presence).map_err(conv_err),
PushRules => from_value(value).map(Self::PushRules).map_err(conv_err), PushRules => from_value(value).map(Event::PushRules).map_err(conv_err),
Receipt => from_value(value).map(Self::Receipt).map_err(conv_err), Receipt => from_value(value).map(Event::Receipt).map_err(conv_err),
RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err), RoomAliases => from_value(value).map(Event::RoomAliases).map_err(conv_err),
RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err), RoomAvatar => from_value(value).map(Event::RoomAvatar).map_err(conv_err),
RoomCanonicalAlias => from_value(value) RoomCanonicalAlias => from_value(value)
.map(Self::RoomCanonicalAlias) .map(Event::RoomCanonicalAlias)
.map_err(conv_err),
RoomCreate => from_value(value).map(Event::RoomCreate).map_err(conv_err),
RoomEncrypted => from_value(value)
.map(Event::RoomEncrypted)
.map_err(conv_err), .map_err(conv_err),
RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err),
RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err),
RoomEncryption => from_value(value) RoomEncryption => from_value(value)
.map(Self::RoomEncryption) .map(Event::RoomEncryption)
.map_err(conv_err), .map_err(conv_err),
RoomGuestAccess => from_value(value) RoomGuestAccess => from_value(value)
.map(Self::RoomGuestAccess) .map(Event::RoomGuestAccess)
.map_err(conv_err), .map_err(conv_err),
RoomHistoryVisibility => from_value(value) RoomHistoryVisibility => from_value(value)
.map(Self::RoomHistoryVisibility) .map(Event::RoomHistoryVisibility)
.map_err(conv_err), .map_err(conv_err),
RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err), RoomJoinRules => from_value(value)
RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err), .map(Event::RoomJoinRules)
RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err), .map_err(conv_err),
RoomMember => from_value(value).map(Event::RoomMember).map_err(conv_err),
RoomMessage => from_value(value).map(Event::RoomMessage).map_err(conv_err),
RoomMessageFeedback => from_value(value) RoomMessageFeedback => from_value(value)
.map(Self::RoomMessageFeedback) .map(Event::RoomMessageFeedback)
.map_err(conv_err), .map_err(conv_err),
RoomName => from_value(value).map(Self::RoomName).map_err(conv_err), RoomName => from_value(value).map(Event::RoomName).map_err(conv_err),
RoomPinnedEvents => from_value(value) RoomPinnedEvents => from_value(value)
.map(Self::RoomPinnedEvents) .map(Event::RoomPinnedEvents)
.map_err(conv_err), .map_err(conv_err),
RoomPowerLevels => from_value(value) RoomPowerLevels => from_value(value)
.map(Self::RoomPowerLevels) .map(Event::RoomPowerLevels)
.map_err(conv_err),
RoomRedaction => from_value(value)
.map(Event::RoomRedaction)
.map_err(conv_err),
RoomServerAcl => from_value(value)
.map(Event::RoomServerAcl)
.map_err(conv_err), .map_err(conv_err),
RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err),
RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err),
RoomThirdPartyInvite => from_value(value) RoomThirdPartyInvite => from_value(value)
.map(Self::RoomThirdPartyInvite) .map(Event::RoomThirdPartyInvite)
.map_err(conv_err), .map_err(conv_err),
RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err), RoomTombstone => from_value(value)
RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err), .map(Event::RoomTombstone)
RoomKey => from_value(value).map(Self::RoomKey).map_err(conv_err), .map_err(conv_err),
RoomTopic => from_value(value).map(Event::RoomTopic).map_err(conv_err),
RoomKey => from_value(value).map(Event::RoomKey).map_err(conv_err),
RoomKeyRequest => from_value(value) RoomKeyRequest => from_value(value)
.map(Self::RoomKeyRequest) .map(Event::RoomKeyRequest)
.map_err(conv_err), .map_err(conv_err),
Sticker => from_value(value).map(Self::Sticker).map_err(conv_err), Sticker => from_value(value).map(Event::Sticker).map_err(conv_err),
Tag => from_value(value).map(Self::Tag).map_err(conv_err), Tag => from_value(value).map(Event::Tag).map_err(conv_err),
Typing => from_value(value).map(Self::Typing).map_err(conv_err), Typing => from_value(value).map(Event::Typing).map_err(conv_err),
// TODO // TODO
Custom(_event_type_name) => Err(D::Error::custom("invalid event type")), Custom(_event_type_name) => Err(D::Error::custom("invalid event type")),
__Nonexhaustive => { __Nonexhaustive => {
@ -446,49 +456,77 @@ impl<'de> Deserialize<'de> for RoomEvent {
let event_type = get_field(&value, "type")?; let event_type = get_field(&value, "type")?;
match event_type { match event_type {
CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err), CallAnswer => from_value(value)
.map(RoomEvent::CallAnswer)
.map_err(conv_err),
CallCandidates => from_value(value) CallCandidates => from_value(value)
.map(Self::CallCandidates) .map(RoomEvent::CallCandidates)
.map_err(conv_err),
CallHangup => from_value(value)
.map(RoomEvent::CallHangup)
.map_err(conv_err),
CallInvite => from_value(value)
.map(RoomEvent::CallInvite)
.map_err(conv_err),
RoomAliases => from_value(value)
.map(RoomEvent::RoomAliases)
.map_err(conv_err),
RoomAvatar => from_value(value)
.map(RoomEvent::RoomAvatar)
.map_err(conv_err), .map_err(conv_err),
CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err),
CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err),
RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err),
RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err),
RoomCanonicalAlias => from_value(value) RoomCanonicalAlias => from_value(value)
.map(Self::RoomCanonicalAlias) .map(RoomEvent::RoomCanonicalAlias)
.map_err(conv_err),
RoomCreate => from_value(value)
.map(RoomEvent::RoomCreate)
.map_err(conv_err),
RoomEncrypted => from_value(value)
.map(RoomEvent::RoomEncrypted)
.map_err(conv_err), .map_err(conv_err),
RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err),
RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err),
RoomEncryption => from_value(value) RoomEncryption => from_value(value)
.map(Self::RoomEncryption) .map(RoomEvent::RoomEncryption)
.map_err(conv_err), .map_err(conv_err),
RoomGuestAccess => from_value(value) RoomGuestAccess => from_value(value)
.map(Self::RoomGuestAccess) .map(RoomEvent::RoomGuestAccess)
.map_err(conv_err), .map_err(conv_err),
RoomHistoryVisibility => from_value(value) RoomHistoryVisibility => from_value(value)
.map(Self::RoomHistoryVisibility) .map(RoomEvent::RoomHistoryVisibility)
.map_err(conv_err),
RoomJoinRules => from_value(value)
.map(RoomEvent::RoomJoinRules)
.map_err(conv_err),
RoomMember => from_value(value)
.map(RoomEvent::RoomMember)
.map_err(conv_err),
RoomMessage => from_value(value)
.map(RoomEvent::RoomMessage)
.map_err(conv_err), .map_err(conv_err),
RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err),
RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err),
RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err),
RoomMessageFeedback => from_value(value) RoomMessageFeedback => from_value(value)
.map(Self::RoomMessageFeedback) .map(RoomEvent::RoomMessageFeedback)
.map_err(conv_err), .map_err(conv_err),
RoomName => from_value(value).map(Self::RoomName).map_err(conv_err), RoomName => from_value(value).map(RoomEvent::RoomName).map_err(conv_err),
RoomPinnedEvents => from_value(value) RoomPinnedEvents => from_value(value)
.map(Self::RoomPinnedEvents) .map(RoomEvent::RoomPinnedEvents)
.map_err(conv_err), .map_err(conv_err),
RoomPowerLevels => from_value(value) RoomPowerLevels => from_value(value)
.map(Self::RoomPowerLevels) .map(RoomEvent::RoomPowerLevels)
.map_err(conv_err),
RoomRedaction => from_value(value)
.map(RoomEvent::RoomRedaction)
.map_err(conv_err),
RoomServerAcl => from_value(value)
.map(RoomEvent::RoomServerAcl)
.map_err(conv_err), .map_err(conv_err),
RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err),
RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err),
RoomThirdPartyInvite => from_value(value) RoomThirdPartyInvite => from_value(value)
.map(Self::RoomThirdPartyInvite) .map(RoomEvent::RoomThirdPartyInvite)
.map_err(conv_err), .map_err(conv_err),
RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err), RoomTombstone => from_value(value)
RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err), .map(RoomEvent::RoomTombstone)
Sticker => from_value(value).map(Self::Sticker).map_err(conv_err), .map_err(conv_err),
RoomTopic => from_value(value)
.map(RoomEvent::RoomTopic)
.map_err(conv_err),
Sticker => from_value(value).map(RoomEvent::Sticker).map_err(conv_err),
//Custom(_event_type_name) => unimplemented!("todo"), //Custom(_event_type_name) => unimplemented!("todo"),
_ => Err(D::Error::custom("invalid event type")), _ => Err(D::Error::custom("invalid event type")),
} }
@ -506,36 +544,54 @@ impl<'de> Deserialize<'de> for StateEvent {
let event_type = get_field(&value, "type")?; let event_type = get_field(&value, "type")?;
match event_type { match event_type {
RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err), RoomAliases => from_value(value)
RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err), .map(StateEvent::RoomAliases)
RoomCanonicalAlias => from_value(value) .map_err(conv_err),
.map(Self::RoomCanonicalAlias) RoomAvatar => from_value(value)
.map(StateEvent::RoomAvatar)
.map_err(conv_err),
RoomCanonicalAlias => from_value(value)
.map(StateEvent::RoomCanonicalAlias)
.map_err(conv_err),
RoomCreate => from_value(value)
.map(StateEvent::RoomCreate)
.map_err(conv_err), .map_err(conv_err),
RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err),
RoomEncryption => from_value(value) RoomEncryption => from_value(value)
.map(Self::RoomEncryption) .map(StateEvent::RoomEncryption)
.map_err(conv_err), .map_err(conv_err),
RoomGuestAccess => from_value(value) RoomGuestAccess => from_value(value)
.map(Self::RoomGuestAccess) .map(StateEvent::RoomGuestAccess)
.map_err(conv_err), .map_err(conv_err),
RoomHistoryVisibility => from_value(value) RoomHistoryVisibility => from_value(value)
.map(Self::RoomHistoryVisibility) .map(StateEvent::RoomHistoryVisibility)
.map_err(conv_err),
RoomJoinRules => from_value(value)
.map(StateEvent::RoomJoinRules)
.map_err(conv_err),
RoomMember => from_value(value)
.map(StateEvent::RoomMember)
.map_err(conv_err),
RoomName => from_value(value)
.map(StateEvent::RoomName)
.map_err(conv_err), .map_err(conv_err),
RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err),
RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err),
RoomName => from_value(value).map(Self::RoomName).map_err(conv_err),
RoomPinnedEvents => from_value(value) RoomPinnedEvents => from_value(value)
.map(Self::RoomPinnedEvents) .map(StateEvent::RoomPinnedEvents)
.map_err(conv_err), .map_err(conv_err),
RoomPowerLevels => from_value(value) RoomPowerLevels => from_value(value)
.map(Self::RoomPowerLevels) .map(StateEvent::RoomPowerLevels)
.map_err(conv_err),
RoomServerAcl => from_value(value)
.map(StateEvent::RoomServerAcl)
.map_err(conv_err), .map_err(conv_err),
RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err),
RoomThirdPartyInvite => from_value(value) RoomThirdPartyInvite => from_value(value)
.map(Self::RoomThirdPartyInvite) .map(StateEvent::RoomThirdPartyInvite)
.map_err(conv_err),
RoomTombstone => from_value(value)
.map(StateEvent::RoomTombstone)
.map_err(conv_err),
RoomTopic => from_value(value)
.map(StateEvent::RoomTopic)
.map_err(conv_err), .map_err(conv_err),
RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err),
RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err),
//Custom(_event_type_name) => unimplemented!("todo"), //Custom(_event_type_name) => unimplemented!("todo"),
_ => Err(D::Error::custom("invalid event type")), _ => Err(D::Error::custom("invalid event type")),
} }

66
src/collections/raw/only.rs
View File

@ -154,42 +154,42 @@ impl<'de> Deserialize<'de> for Event {
let event_type = get_field(&value, "type")?; let event_type = get_field(&value, "type")?;
match event_type { match event_type {
Direct => from_value(value).map(Self::Direct).map_err(conv_err), Direct => from_value(value).map(Event::Direct).map_err(conv_err),
Dummy => from_value(value).map(Self::Dummy).map_err(conv_err), Dummy => from_value(value).map(Event::Dummy).map_err(conv_err),
ForwardedRoomKey => from_value(value) ForwardedRoomKey => from_value(value)
.map(Self::ForwardedRoomKey) .map(Event::ForwardedRoomKey)
.map_err(conv_err), .map_err(conv_err),
FullyRead => from_value(value).map(Self::FullyRead).map_err(conv_err), FullyRead => from_value(value).map(Event::FullyRead).map_err(conv_err),
KeyVerificationAccept => from_value(value) KeyVerificationAccept => from_value(value)
.map(Self::KeyVerificationAccept) .map(Event::KeyVerificationAccept)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationCancel => from_value(value) KeyVerificationCancel => from_value(value)
.map(Self::KeyVerificationCancel) .map(Event::KeyVerificationCancel)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationKey => from_value(value) KeyVerificationKey => from_value(value)
.map(Self::KeyVerificationKey) .map(Event::KeyVerificationKey)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationMac => from_value(value) KeyVerificationMac => from_value(value)
.map(Self::KeyVerificationMac) .map(Event::KeyVerificationMac)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationRequest => from_value(value) KeyVerificationRequest => from_value(value)
.map(Self::KeyVerificationRequest) .map(Event::KeyVerificationRequest)
.map_err(conv_err), .map_err(conv_err),
KeyVerificationStart => from_value(value) KeyVerificationStart => from_value(value)
.map(Self::KeyVerificationStart) .map(Event::KeyVerificationStart)
.map_err(conv_err), .map_err(conv_err),
IgnoredUserList => from_value(value) IgnoredUserList => from_value(value)
.map(Self::IgnoredUserList) .map(Event::IgnoredUserList)
.map_err(conv_err), .map_err(conv_err),
Presence => from_value(value).map(Self::Presence).map_err(conv_err), Presence => from_value(value).map(Event::Presence).map_err(conv_err),
PushRules => from_value(value).map(Self::PushRules).map_err(conv_err), PushRules => from_value(value).map(Event::PushRules).map_err(conv_err),
RoomKey => from_value(value).map(Self::RoomKey).map_err(conv_err), RoomKey => from_value(value).map(Event::RoomKey).map_err(conv_err),
RoomKeyRequest => from_value(value) RoomKeyRequest => from_value(value)
.map(Self::RoomKeyRequest) .map(Event::RoomKeyRequest)
.map_err(conv_err), .map_err(conv_err),
Receipt => from_value(value).map(Self::Receipt).map_err(conv_err), Receipt => from_value(value).map(Event::Receipt).map_err(conv_err),
Tag => from_value(value).map(Self::Tag).map_err(conv_err), Tag => from_value(value).map(Event::Tag).map_err(conv_err),
Typing => from_value(value).map(Self::Typing).map_err(conv_err), Typing => from_value(value).map(Event::Typing).map_err(conv_err),
//Custom(_event_type_name) => unimplemented!("todo"), //Custom(_event_type_name) => unimplemented!("todo"),
_ => Err(D::Error::custom("invalid event type")), _ => Err(D::Error::custom("invalid event type")),
} }
@ -207,19 +207,31 @@ impl<'de> Deserialize<'de> for RoomEvent {
let event_type = get_field(&value, "type")?; let event_type = get_field(&value, "type")?;
match event_type { match event_type {
CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err), CallAnswer => from_value(value)
.map(RoomEvent::CallAnswer)
.map_err(conv_err),
CallCandidates => from_value(value) CallCandidates => from_value(value)
.map(Self::CallCandidates) .map(RoomEvent::CallCandidates)
.map_err(conv_err),
CallHangup => from_value(value)
.map(RoomEvent::CallHangup)
.map_err(conv_err),
CallInvite => from_value(value)
.map(RoomEvent::CallInvite)
.map_err(conv_err),
RoomEncrypted => from_value(value)
.map(RoomEvent::RoomEncrypted)
.map_err(conv_err),
RoomMessage => from_value(value)
.map(RoomEvent::RoomMessage)
.map_err(conv_err), .map_err(conv_err),
CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err),
CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err),
RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err),
RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err),
RoomMessageFeedback => from_value(value) RoomMessageFeedback => from_value(value)
.map(Self::RoomMessageFeedback) .map(RoomEvent::RoomMessageFeedback)
.map_err(conv_err), .map_err(conv_err),
RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err), RoomRedaction => from_value(value)
Sticker => from_value(value).map(Self::Sticker).map_err(conv_err), .map(RoomEvent::RoomRedaction)
.map_err(conv_err),
Sticker => from_value(value).map(RoomEvent::Sticker).map_err(conv_err),
//Custom(_event_type_name) => unimplemented!("todo"), //Custom(_event_type_name) => unimplemented!("todo"),
_ => Err(D::Error::custom("invalid event type")), _ => Err(D::Error::custom("invalid event type")),
} }

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

@ -1,7 +1,7 @@
//! Types for the *m.key.verification.start* event. //! Types for the *m.key.verification.start* event.
use ruma_identifiers::DeviceId; use ruma_identifiers::DeviceId;
use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{from_value, Value}; use serde_json::{from_value, Value};
use super::{ use super::{
@ -157,6 +157,8 @@ pub(crate) mod raw {
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
use serde::de::Error as _;
let value: Value = Deserialize::deserialize(deserializer)?; let value: Value = Deserialize::deserialize(deserializer)?;
let method_value = match value.get("method") { let method_value = match value.get("method") {

4
src/lib.rs
View File

@ -128,9 +128,7 @@ use serde::{
}; };
use serde_json::Value; use serde_json::Value;
pub use custom::CustomEvent; pub use self::{custom::CustomEvent, custom_room::CustomRoomEvent, custom_state::CustomStateEvent};
pub use custom_room::CustomRoomEvent;
pub use custom_state::CustomStateEvent;
#[macro_use] #[macro_use]
mod macros; mod macros;

10
src/room/encrypted.rs
View File

@ -2,7 +2,7 @@
use js_int::UInt; use js_int::UInt;
use ruma_identifiers::{DeviceId, EventId, RoomId, UserId}; use ruma_identifiers::{DeviceId, EventId, RoomId, UserId};
use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
use serde_json::{from_value, Value}; use serde_json::{from_value, Value};
use crate::{Algorithm, Event, EventType, FromRaw}; use crate::{Algorithm, Event, EventType, FromRaw};
@ -70,8 +70,10 @@ impl FromRaw for EncryptedEventContent {
use raw::EncryptedEventContent::*; use raw::EncryptedEventContent::*;
match raw { match raw {
OlmV1Curve25519AesSha2(content) => Self::OlmV1Curve25519AesSha2(content), OlmV1Curve25519AesSha2(content) => {
MegolmV1AesSha2(content) => Self::MegolmV1AesSha2(content), EncryptedEventContent::OlmV1Curve25519AesSha2(content)
}
MegolmV1AesSha2(content) => EncryptedEventContent::MegolmV1AesSha2(content),
__Nonexhaustive => { __Nonexhaustive => {
unreachable!("__Nonexhaustive variant should be impossible to obtain.") unreachable!("__Nonexhaustive variant should be impossible to obtain.")
} }
@ -185,6 +187,8 @@ pub(crate) mod raw {
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
use serde::de::Error as _;
let value: Value = Deserialize::deserialize(deserializer)?; let value: Value = Deserialize::deserialize(deserializer)?;
let method_value = match value.get("algorithm") { let method_value = match value.get("algorithm") {

28
src/room/message.rs
View File

@ -2,11 +2,7 @@
use js_int::UInt; use js_int::UInt;
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{ use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
de::Error as _,
ser::{Error as _, SerializeStruct},
Deserialize, Deserializer, Serialize, Serializer,
};
use serde_json::{from_value, Value}; use serde_json::{from_value, Value};
use super::{EncryptedFile, ImageInfo, ThumbnailInfo}; use super::{EncryptedFile, ImageInfo, ThumbnailInfo};
@ -96,15 +92,15 @@ impl FromRaw for MessageEventContent {
use raw::MessageEventContent::*; use raw::MessageEventContent::*;
match raw { match raw {
Audio(content) => Self::Audio(content), Audio(content) => MessageEventContent::Audio(content),
Emote(content) => Self::Emote(content), Emote(content) => MessageEventContent::Emote(content),
File(content) => Self::File(content), File(content) => MessageEventContent::File(content),
Image(content) => Self::Image(content), Image(content) => MessageEventContent::Image(content),
Location(content) => Self::Location(content), Location(content) => MessageEventContent::Location(content),
Notice(content) => Self::Notice(content), Notice(content) => MessageEventContent::Notice(content),
ServerNotice(content) => Self::ServerNotice(content), ServerNotice(content) => MessageEventContent::ServerNotice(content),
Text(content) => Self::Text(content), Text(content) => MessageEventContent::Text(content),
Video(content) => Self::Video(content), Video(content) => MessageEventContent::Video(content),
__Nonexhaustive => { __Nonexhaustive => {
unreachable!("It should be impossible to obtain a __Nonexhaustive variant.") unreachable!("It should be impossible to obtain a __Nonexhaustive variant.")
} }
@ -155,6 +151,8 @@ impl Serialize for MessageEventContent {
where where
S: Serializer, S: Serializer,
{ {
use serde::ser::Error as _;
match *self { match *self {
MessageEventContent::Audio(ref content) => content.serialize(serializer), MessageEventContent::Audio(ref content) => content.serialize(serializer),
MessageEventContent::Emote(ref content) => content.serialize(serializer), MessageEventContent::Emote(ref content) => content.serialize(serializer),
@ -240,6 +238,8 @@ pub(crate) mod raw {
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
use serde::de::Error as _;
let value: Value = Deserialize::deserialize(deserializer)?; let value: Value = Deserialize::deserialize(deserializer)?;
let message_type_value = match value.get("msgtype") { let message_type_value = match value.get("msgtype") {

109
src/stripped.rs
View File

@ -126,18 +126,24 @@ impl TryFromRaw for StrippedState {
use raw::StrippedState::*; use raw::StrippedState::*;
match raw { match raw {
RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), RoomAliases(c) => conv(RoomAliases, StrippedState::RoomAliases, c),
RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), RoomAvatar(c) => conv(RoomAvatar, StrippedState::RoomAvatar, c),
RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, StrippedState::RoomCanonicalAlias, c),
RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), RoomCreate(c) => conv(RoomCreate, StrippedState::RoomCreate, c),
RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), RoomGuestAccess(c) => conv(RoomGuestAccess, StrippedState::RoomGuestAccess, c),
RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), RoomHistoryVisibility(c) => conv(
RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), RoomHistoryVisibility,
RoomMember(c) => conv(RoomMember, Self::RoomMember, c), StrippedState::RoomHistoryVisibility,
RoomName(c) => conv(RoomName, Self::RoomName, c), c,
RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), ),
RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), RoomJoinRules(c) => conv(RoomJoinRules, StrippedState::RoomJoinRules, c),
RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), RoomMember(c) => conv(RoomMember, StrippedState::RoomMember, c),
RoomName(c) => conv(RoomName, StrippedState::RoomName, c),
RoomPowerLevels(c) => conv(RoomPowerLevels, StrippedState::RoomPowerLevels, c),
RoomThirdPartyInvite(c) => {
conv(RoomThirdPartyInvite, StrippedState::RoomThirdPartyInvite, c)
}
RoomTopic(c) => conv(RoomTopic, StrippedState::RoomTopic, c),
} }
} }
} }
@ -210,6 +216,7 @@ where
mod raw { mod raw {
use serde::{Deserialize, Deserializer}; use serde::{Deserialize, Deserializer};
use serde_json::Value;
use super::StrippedStateContent; use super::StrippedStateContent;
use crate::room::{ use crate::room::{
@ -304,44 +311,56 @@ mod raw {
where where
D: Deserializer<'de>, D: Deserializer<'de>,
{ {
use crate::EventType::*; use crate::{
util::{get_field, serde_json_error_to_generic_de_error as conv_err},
EventType::*,
};
use serde::de::Error as _; use serde::de::Error as _;
use serde_json::{from_value, Value}; use serde_json::from_value;
let conv_err = |error: serde_json::Error| D::Error::custom(error.to_string());
// TODO: Optimize // TODO: Optimize
let value = Value::deserialize(deserializer)?; let value = Value::deserialize(deserializer)?;
let event_type = get_field(&value, "type")?;
let event_type = from_value( match event_type {
value RoomAliases => from_value(value)
.get("type") .map(StrippedState::RoomAliases)
.cloned() .map_err(conv_err),
.ok_or_else(|| D::Error::missing_field("type"))?, RoomAvatar => from_value(value)
) .map(StrippedState::RoomAvatar)
.map_err(conv_err)?; .map_err(conv_err),
RoomCanonicalAlias => from_value(value)
Ok(match event_type { .map(StrippedState::RoomCanonicalAlias)
RoomAliases => StrippedState::RoomAliases(from_value(value).map_err(conv_err)?), .map_err(conv_err),
RoomAvatar => Self::RoomAvatar(from_value(value).map_err(conv_err)?), RoomCreate => from_value(value)
RoomCanonicalAlias => { .map(StrippedState::RoomCreate)
Self::RoomCanonicalAlias(from_value(value).map_err(conv_err)?) .map_err(conv_err),
} RoomGuestAccess => from_value(value)
RoomCreate => Self::RoomCreate(from_value(value).map_err(conv_err)?), .map(StrippedState::RoomGuestAccess)
RoomGuestAccess => Self::RoomGuestAccess(from_value(value).map_err(conv_err)?), .map_err(conv_err),
RoomHistoryVisibility => { RoomHistoryVisibility => from_value(value)
Self::RoomHistoryVisibility(from_value(value).map_err(conv_err)?) .map(StrippedState::RoomHistoryVisibility)
} .map_err(conv_err),
RoomJoinRules => Self::RoomJoinRules(from_value(value).map_err(conv_err)?), RoomJoinRules => from_value(value)
RoomMember => Self::RoomMember(from_value(value).map_err(conv_err)?), .map(StrippedState::RoomJoinRules)
RoomName => Self::RoomName(from_value(value).map_err(conv_err)?), .map_err(conv_err),
RoomPowerLevels => Self::RoomPowerLevels(from_value(value).map_err(conv_err)?), RoomMember => from_value(value)
RoomThirdPartyInvite => { .map(StrippedState::RoomMember)
Self::RoomThirdPartyInvite(from_value(value).map_err(conv_err)?) .map_err(conv_err),
} RoomName => from_value(value)
RoomTopic => Self::RoomTopic(from_value(value).map_err(conv_err)?), .map(StrippedState::RoomName)
_ => return Err(D::Error::custom("not a state event")), .map_err(conv_err),
}) RoomPowerLevels => from_value(value)
.map(StrippedState::RoomPowerLevels)
.map_err(conv_err),
RoomThirdPartyInvite => from_value(value)
.map(StrippedState::RoomThirdPartyInvite)
.map_err(conv_err),
RoomTopic => from_value(value)
.map(StrippedState::RoomTopic)
.map_err(conv_err),
_ => Err(D::Error::custom("not a state event")),
}
} }
} }
} }