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

events-macros: Improve readability, fix lines >100 chars

Browse Source
This commit is contained in:
Jonas Platte 2020-11-27 22:46:06 +01:00
parent 5175d3d622
commit 675efbc5f1
No known key found for this signature in database
GPG Key ID: CC154DE0E30B7C67
4 changed files with 279 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
ruma-events-macros/src/event.rs
View File

@ -11,7 +11,7 @@ use crate::{
/// Derive `Event` macro code generation. /// Derive `Event` macro code generation.
pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> { pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let ident = &input.ident; let ident = &input.ident;
let (kind, var) = to_kind_variation(ident).ok_or_else(|| { let (kind, var) = to_kind_variation(ident).ok_or_else(|| {
@ -41,19 +41,16 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
)); ));
}; };
let serialize_impl = expand_serialize_event(&input, &var, &fields, &import_path); let serialize_impl = expand_serialize_event(&input, &var, &fields, &ruma_events);
let deserialize_impl = expand_deserialize_event(&input, &var, &fields, &import_path); let deserialize_impl = expand_deserialize_event(&input, &var, &fields, &ruma_events);
let conversion_impl = expand_from_into(&input, &kind, &var, &fields, &import_path); let conversion_impl = expand_from_into(&input, &kind, &var, &fields, &ruma_events);
let eq_impl = expand_eq_ord_event(&input, &fields); let eq_impl = expand_eq_ord_event(&input, &fields);
Ok(quote! { Ok(quote! {
#conversion_impl #conversion_impl
#serialize_impl #serialize_impl
#deserialize_impl #deserialize_impl
#eq_impl #eq_impl
}) })
} }
@ -62,8 +59,11 @@ fn expand_serialize_event(
input: &DeriveInput, input: &DeriveInput,
var: &EventKindVariation, var: &EventKindVariation,
fields: &[Field], fields: &[Field],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let js_int = quote! { #ruma_events::exports::js_int };
let serde = quote! { #ruma_events::exports::serde };
let ident = &input.ident; let ident = &input.ident;
let (impl_gen, ty_gen, where_clause) = input.generics.split_for_impl(); let (impl_gen, ty_gen, where_clause) = input.generics.split_for_impl();
let serialize_fields = fields let serialize_fields = fields
@ -72,7 +72,7 @@ fn expand_serialize_event(
let name = field.ident.as_ref().unwrap(); let name = field.ident.as_ref().unwrap();
if name == "content" && var.is_redacted() { if name == "content" && var.is_redacted() {
quote! { quote! {
if #import_path::RedactedEventContent::has_serialize_fields(&self.content) { if #ruma_events::RedactedEventContent::has_serialize_fields(&self.content) {
state.serialize_field("content", &self.content)?; state.serialize_field("content", &self.content)?;
} }
} }
@ -87,7 +87,7 @@ fn expand_serialize_event(
let time_since_epoch = let time_since_epoch =
self.origin_server_ts.duration_since(::std::time::UNIX_EPOCH).unwrap(); self.origin_server_ts.duration_since(::std::time::UNIX_EPOCH).unwrap();
let timestamp = <#import_path::exports::js_int::UInt as ::std::convert::TryFrom<_>>::try_from( let timestamp = <#js_int::UInt as ::std::convert::TryFrom<_>>::try_from(
time_since_epoch.as_millis(), time_since_epoch.as_millis(),
).map_err(S::Error::custom)?; ).map_err(S::Error::custom)?;
@ -108,14 +108,14 @@ fn expand_serialize_event(
.collect::<Vec<_>>(); .collect::<Vec<_>>();
quote! { quote! {
impl #impl_gen #import_path::exports::serde::ser::Serialize for #ident #ty_gen #where_clause { impl #impl_gen #serde::ser::Serialize for #ident #ty_gen #where_clause {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: #import_path::exports::serde::ser::Serializer, S: #serde::ser::Serializer,
{ {
use #import_path::exports::serde::ser::{SerializeStruct as _, Error as _}; use #serde::ser::{SerializeStruct as _, Error as _};
let event_type = #import_path::EventContent::event_type(&self.content); let event_type = #ruma_events::EventContent::event_type(&self.content);
let mut state = serializer.serialize_struct(stringify!(#ident), 7)?; let mut state = serializer.serialize_struct(stringify!(#ident), 7)?;
@ -131,8 +131,12 @@ fn expand_deserialize_event(
input: &DeriveInput, input: &DeriveInput,
var: &EventKindVariation, var: &EventKindVariation,
fields: &[Field], fields: &[Field],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let js_int = quote! { #ruma_events::exports::js_int };
let serde = quote! { #ruma_events::exports::serde };
let serde_json = quote! { #ruma_events::exports::serde_json };
let ident = &input.ident; let ident = &input.ident;
// we know there is a content field already // we know there is a content field already
let content_type = fields let content_type = fields
@ -160,12 +164,12 @@ fn expand_deserialize_event(
let ty = &field.ty; let ty = &field.ty;
if name == "content" || name == "prev_content" { if name == "content" || name == "prev_content" {
if is_generic { if is_generic {
quote! { Box<#import_path::exports::serde_json::value::RawValue> } quote! { Box<#serde_json::value::RawValue> }
} else { } else {
quote! { #content_type } quote! { #content_type }
} }
} else if name == "origin_server_ts" { } else if name == "origin_server_ts" {
quote! { #import_path::exports::js_int::UInt } quote! { #js_int::UInt }
} else { } else {
quote! { #ty } quote! { #ty }
} }
@ -180,18 +184,18 @@ fn expand_deserialize_event(
if is_generic && var.is_redacted() { if is_generic && var.is_redacted() {
quote! { quote! {
let content = match C::has_deserialize_fields() { let content = match C::has_deserialize_fields() {
#import_path::HasDeserializeFields::False => { #ruma_events::HasDeserializeFields::False => {
C::empty(&event_type).map_err(A::Error::custom)? C::empty(&event_type).map_err(A::Error::custom)?
}, },
#import_path::HasDeserializeFields::True => { #ruma_events::HasDeserializeFields::True => {
let json = content.ok_or_else( let json = content.ok_or_else(
|| #import_path::exports::serde::de::Error::missing_field("content"), || #serde::de::Error::missing_field("content"),
)?; )?;
C::from_parts(&event_type, json).map_err(A::Error::custom)? C::from_parts(&event_type, json).map_err(A::Error::custom)?
}, },
#import_path::HasDeserializeFields::Optional => { #ruma_events::HasDeserializeFields::Optional => {
let json = content.unwrap_or( let json = content.unwrap_or(
#import_path::exports::serde_json::value::RawValue::from_string("{}".to_string()) #serde_json::value::RawValue::from_string("{}".to_string())
.unwrap() .unwrap()
); );
C::from_parts(&event_type, json).map_err(A::Error::custom)? C::from_parts(&event_type, json).map_err(A::Error::custom)?
@ -200,13 +204,14 @@ fn expand_deserialize_event(
} }
} else if is_generic { } else if is_generic {
quote! { quote! {
let json = content.ok_or_else(|| #import_path::exports::serde::de::Error::missing_field("content"))?; let json =
content.ok_or_else(|| #serde::de::Error::missing_field("content"))?;
let content = C::from_parts(&event_type, json).map_err(A::Error::custom)?; let content = C::from_parts(&event_type, json).map_err(A::Error::custom)?;
} }
} else { } else {
quote! { quote! {
let content = content.ok_or_else( let content = content.ok_or_else(
|| #import_path::exports::serde::de::Error::missing_field("content"), || #serde::de::Error::missing_field("content"),
)?; )?;
} }
} }
@ -235,14 +240,14 @@ fn expand_deserialize_event(
let t = time.into(); let t = time.into();
::std::time::UNIX_EPOCH + ::std::time::Duration::from_millis(t) ::std::time::UNIX_EPOCH + ::std::time::Duration::from_millis(t)
}) })
.ok_or_else(|| #import_path::exports::serde::de::Error::missing_field("origin_server_ts"))?; .ok_or_else(|| #serde::de::Error::missing_field("origin_server_ts"))?;
} }
} else if name == "unsigned" { } else if name == "unsigned" {
quote! { let unsigned = unsigned.unwrap_or_default(); } quote! { let unsigned = unsigned.unwrap_or_default(); }
} else { } else {
quote! { quote! {
let #name = #name.ok_or_else(|| { let #name = #name.ok_or_else(|| {
#import_path::exports::serde::de::Error::missing_field(stringify!(#name)) #serde::de::Error::missing_field(stringify!(#name))
})?; })?;
} }
} }
@ -264,12 +269,12 @@ fn expand_deserialize_event(
}; };
quote! { quote! {
impl #deserialize_impl_gen #import_path::exports::serde::de::Deserialize<'de> for #ident #ty_gen #where_clause { impl #deserialize_impl_gen #serde::de::Deserialize<'de> for #ident #ty_gen #where_clause {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where where
D: #import_path::exports::serde::de::Deserializer<'de>, D: #serde::de::Deserializer<'de>,
{ {
#[derive(#import_path::exports::serde::Deserialize)] #[derive(#serde::Deserialize)]
#[serde(field_identifier, rename_all = "snake_case")] #[serde(field_identifier, rename_all = "snake_case")]
enum Field { enum Field {
// since this is represented as an enum we have to add it so the JSON picks it // since this is represented as an enum we have to add it so the JSON picks it
@ -284,7 +289,7 @@ fn expand_deserialize_event(
/// the `content` and `prev_content` fields. /// the `content` and `prev_content` fields.
struct EventVisitor #impl_generics (#deserialize_phantom_type #ty_gen); struct EventVisitor #impl_generics (#deserialize_phantom_type #ty_gen);
impl #deserialize_impl_gen #import_path::exports::serde::de::Visitor<'de> impl #deserialize_impl_gen #serde::de::Visitor<'de>
for EventVisitor #ty_gen #where_clause for EventVisitor #ty_gen #where_clause
{ {
type Value = #ident #ty_gen; type Value = #ident #ty_gen;
@ -298,9 +303,9 @@ fn expand_deserialize_event(
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where where
A: #import_path::exports::serde::de::MapAccess<'de>, A: #serde::de::MapAccess<'de>,
{ {
use #import_path::exports::serde::de::Error as _; use #serde::de::Error as _;
let mut event_type: Option<String> = None; let mut event_type: Option<String> = None;
#( let mut #field_names: Option<#deserialize_var_types> = None; )* #( let mut #field_names: Option<#deserialize_var_types> = None; )*
@ -308,18 +313,18 @@ fn expand_deserialize_event(
while let Some(key) = map.next_key()? { while let Some(key) = map.next_key()? {
match key { match key {
Field::Unknown => { Field::Unknown => {
let _: #import_path::exports::serde::de::IgnoredAny = map.next_value()?; let _: #serde::de::IgnoredAny = map.next_value()?;
}, },
Field::Type => { Field::Type => {
if event_type.is_some() { if event_type.is_some() {
return Err(#import_path::exports::serde::de::Error::duplicate_field("type")); return Err(#serde::de::Error::duplicate_field("type"));
} }
event_type = Some(map.next_value()?); event_type = Some(map.next_value()?);
} }
#( #(
Field::#enum_variants => { Field::#enum_variants => {
if #field_names.is_some() { if #field_names.is_some() {
return Err(#import_path::exports::serde::de::Error::duplicate_field( return Err(#serde::de::Error::duplicate_field(
stringify!(#field_names), stringify!(#field_names),
)); ));
} }
@ -330,7 +335,7 @@ fn expand_deserialize_event(
} }
let event_type = let event_type =
event_type.ok_or_else(|| #import_path::exports::serde::de::Error::missing_field("type"))?; event_type.ok_or_else(|| #serde::de::Error::missing_field("type"))?;
#( #ok_or_else_fields )* #( #ok_or_else_fields )*
Ok(#ident { Ok(#ident {
@ -350,8 +355,10 @@ fn expand_from_into(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
fields: &[Field], fields: &[Field],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
let ident = &input.ident; let ident = &input.ident;
let (impl_generics, ty_gen, where_clause) = input.generics.split_for_impl(); let (impl_generics, ty_gen, where_clause) = input.generics.split_for_impl();
@ -385,7 +392,7 @@ fn expand_from_into(
/// Convert this sync event into a full event, one with a room_id field. /// Convert this sync event into a full event, one with a room_id field.
pub fn into_full_event( pub fn into_full_event(
self, self,
room_id: #import_path::exports::ruma_identifiers::RoomId, room_id: #ruma_identifiers::RoomId,
) -> #full_struct #ty_gen { ) -> #full_struct #ty_gen {
let Self { #( #fields, )* } = self; let Self { #( #fields, )* } = self;
#full_struct { #full_struct {

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

@ -79,8 +79,12 @@ impl Parse for MetaAttrs {
pub fn expand_event_content( pub fn expand_event_content(
input: &DeriveInput, input: &DeriveInput,
emit_redacted: bool, emit_redacted: bool,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
let serde = quote! { #ruma_events::exports::serde };
let serde_json = quote! { #ruma_events::exports::serde_json };
let ident = &input.ident; let ident = &input.ident;
let content_attr = input let content_attr = input
@ -151,7 +155,7 @@ pub fn expand_event_content(
{ #( #kept_redacted_fields, )* } { #( #kept_redacted_fields, )* }
}, },
quote! { quote! {
Err(#import_path::exports::serde::de::Error::custom( Err(#serde::de::Error::custom(
format!("this redacted event has fields that cannot be constructed") format!("this redacted event has fields that cannot be constructed")
)) ))
}, },
@ -159,9 +163,9 @@ pub fn expand_event_content(
}; };
let has_deserialize_fields = if kept_redacted_fields.is_empty() { let has_deserialize_fields = if kept_redacted_fields.is_empty() {
quote! { #import_path::HasDeserializeFields::False } quote! { #ruma_events::HasDeserializeFields::False }
} else { } else {
quote! { #import_path::HasDeserializeFields::True } quote! { #ruma_events::HasDeserializeFields::True }
}; };
let has_serialize_fields = if kept_redacted_fields.is_empty() { let has_serialize_fields = if kept_redacted_fields.is_empty() {
@ -171,32 +175,29 @@ pub fn expand_event_content(
}; };
let redacted_event_content = let redacted_event_content =
generate_event_content_impl(&redacted_ident, event_type, import_path); generate_event_content_impl(&redacted_ident, event_type, ruma_events);
quote! { quote! {
// this is the non redacted event content's impl // this is the non redacted event content's impl
impl #ident { impl #ident {
/// Transforms the full event content into a redacted content according to spec. /// Transforms the full event content into a redacted content according to spec.
pub fn redact(self, version: #import_path::exports::ruma_identifiers::RoomVersionId) -> #redacted_ident { pub fn redact(self, version: #ruma_identifiers::RoomVersionId) -> #redacted_ident {
#redacted_ident { #( #redaction_struct_fields: self.#redaction_struct_fields, )* } #redacted_ident {
#( #redaction_struct_fields: self.#redaction_struct_fields, )*
}
} }
} }
#[doc = #doc] #[doc = #doc]
#[derive( #[derive(Clone, Debug, #serde::Deserialize, #serde::Serialize)]
Clone,
Debug,
#import_path::exports::serde::Deserialize,
#import_path::exports::serde::Serialize
)]
pub struct #redacted_ident #redacted_fields pub struct #redacted_ident #redacted_fields
#redacted_event_content #redacted_event_content
impl #import_path::RedactedEventContent for #redacted_ident { impl #ruma_events::RedactedEventContent for #redacted_ident {
fn empty(ev_type: &str) -> Result<Self, #import_path::exports::serde_json::Error> { fn empty(ev_type: &str) -> Result<Self, #serde_json::Error> {
if ev_type != #event_type { if ev_type != #event_type {
return Err(#import_path::exports::serde::de::Error::custom( return Err(#serde::de::Error::custom(
format!("expected event type `{}`, found `{}`", #event_type, ev_type) format!("expected event type `{}`, found `{}`", #event_type, ev_type)
)); ));
} }
@ -208,7 +209,7 @@ pub fn expand_event_content(
#has_serialize_fields #has_serialize_fields
} }
fn has_deserialize_fields() -> #import_path::HasDeserializeFields { fn has_deserialize_fields() -> #ruma_events::HasDeserializeFields {
#has_deserialize_fields #has_deserialize_fields
} }
} }
@ -217,7 +218,7 @@ pub fn expand_event_content(
TokenStream::new() TokenStream::new()
}; };
let event_content = generate_event_content_impl(ident, event_type, import_path); let event_content = generate_event_content_impl(ident, event_type, ruma_events);
Ok(quote! { Ok(quote! {
#event_content #event_content
@ -229,60 +230,60 @@ pub fn expand_event_content(
/// Create a `BasicEventContent` implementation for a struct /// Create a `BasicEventContent` implementation for a struct
pub fn expand_basic_event_content( pub fn expand_basic_event_content(
input: &DeriveInput, input: &DeriveInput,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = input.ident.clone(); let ident = input.ident.clone();
let event_content_impl = expand_event_content(input, false, import_path)?; let event_content_impl = expand_event_content(input, false, ruma_events)?;
Ok(quote! { Ok(quote! {
#event_content_impl #event_content_impl
impl #import_path::BasicEventContent for #ident { } impl #ruma_events::BasicEventContent for #ident { }
}) })
} }
/// Create a `EphemeralRoomEventContent` implementation for a struct /// Create a `EphemeralRoomEventContent` implementation for a struct
pub fn expand_ephemeral_room_event_content( pub fn expand_ephemeral_room_event_content(
input: &DeriveInput, input: &DeriveInput,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = input.ident.clone(); let ident = input.ident.clone();
let event_content_impl = expand_event_content(input, false, import_path)?; let event_content_impl = expand_event_content(input, false, ruma_events)?;
Ok(quote! { Ok(quote! {
#event_content_impl #event_content_impl
impl #import_path::EphemeralRoomEventContent for #ident { } impl #ruma_events::EphemeralRoomEventContent for #ident { }
}) })
} }
/// Create a `RoomEventContent` implementation for a struct. /// Create a `RoomEventContent` implementation for a struct.
pub fn expand_room_event_content( pub fn expand_room_event_content(
input: &DeriveInput, input: &DeriveInput,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = input.ident.clone(); let ident = input.ident.clone();
let event_content_impl = expand_event_content(input, true, import_path)?; let event_content_impl = expand_event_content(input, true, ruma_events)?;
Ok(quote! { Ok(quote! {
#event_content_impl #event_content_impl
impl #import_path::RoomEventContent for #ident { } impl #ruma_events::RoomEventContent for #ident { }
}) })
} }
/// Create a `MessageEventContent` implementation for a struct /// Create a `MessageEventContent` implementation for a struct
pub fn expand_message_event_content( pub fn expand_message_event_content(
input: &DeriveInput, input: &DeriveInput,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = input.ident.clone(); let ident = input.ident.clone();
let room_ev_content = expand_room_event_content(input, import_path)?; let room_ev_content = expand_room_event_content(input, ruma_events)?;
let redacted_marker_trait = if needs_redacted_from_input(input) { let redacted_marker_trait = if needs_redacted_from_input(input) {
let ident = format_ident!("Redacted{}", &ident); let ident = format_ident!("Redacted{}", &ident);
quote! { quote! {
impl #import_path::RedactedMessageEventContent for #ident { } impl #ruma_events::RedactedMessageEventContent for #ident { }
} }
} else { } else {
TokenStream::new() TokenStream::new()
@ -291,7 +292,7 @@ pub fn expand_message_event_content(
Ok(quote! { Ok(quote! {
#room_ev_content #room_ev_content
impl #import_path::MessageEventContent for #ident { } impl #ruma_events::MessageEventContent for #ident { }
#redacted_marker_trait #redacted_marker_trait
}) })
@ -300,15 +301,15 @@ pub fn expand_message_event_content(
/// Create a `StateEventContent` implementation for a struct /// Create a `StateEventContent` implementation for a struct
pub fn expand_state_event_content( pub fn expand_state_event_content(
input: &DeriveInput, input: &DeriveInput,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> syn::Result<TokenStream> { ) -> syn::Result<TokenStream> {
let ident = input.ident.clone(); let ident = input.ident.clone();
let room_ev_content = expand_room_event_content(input, import_path)?; let room_ev_content = expand_room_event_content(input, ruma_events)?;
let redacted_marker_trait = if needs_redacted_from_input(input) { let redacted_marker_trait = if needs_redacted_from_input(input) {
let ident = format_ident!("Redacted{}", input.ident); let ident = format_ident!("Redacted{}", input.ident);
quote! { quote! {
impl #import_path::RedactedStateEventContent for #ident { } impl #ruma_events::RedactedStateEventContent for #ident { }
} }
} else { } else {
TokenStream::new() TokenStream::new()
@ -317,7 +318,7 @@ pub fn expand_state_event_content(
Ok(quote! { Ok(quote! {
#room_ev_content #room_ev_content
impl #import_path::StateEventContent for #ident { } impl #ruma_events::StateEventContent for #ident { }
#redacted_marker_trait #redacted_marker_trait
}) })
@ -326,25 +327,28 @@ pub fn expand_state_event_content(
fn generate_event_content_impl( fn generate_event_content_impl(
ident: &Ident, ident: &Ident,
event_type: &LitStr, event_type: &LitStr,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let serde = quote! { #ruma_events::exports::serde };
let serde_json = quote! { #ruma_events::exports::serde_json };
quote! { quote! {
impl #import_path::EventContent for #ident { impl #ruma_events::EventContent for #ident {
fn event_type(&self) -> &str { fn event_type(&self) -> &str {
#event_type #event_type
} }
fn from_parts( fn from_parts(
ev_type: &str, ev_type: &str,
content: Box<#import_path::exports::serde_json::value::RawValue> content: Box<#serde_json::value::RawValue>
) -> Result<Self, #import_path::exports::serde_json::Error> { ) -> Result<Self, #serde_json::Error> {
if ev_type != #event_type { if ev_type != #event_type {
return Err(#import_path::exports::serde::de::Error::custom( return Err(#serde::de::Error::custom(
format!("expected event type `{}`, found `{}`", #event_type, ev_type) format!("expected event type `{}`, found `{}`", #event_type, ev_type)
)); ));
} }
#import_path::exports::serde_json::from_str(content.get()) #serde_json::from_str(content.get())
} }
} }
} }

215
ruma-events-macros/src/event_enum.rs
View File

@ -44,7 +44,7 @@ const EVENT_FIELDS: &[(&str, EventKindFn)] = &[
/// Create a content enum from `EventEnumInput`. /// Create a content enum from `EventEnumInput`.
pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> { pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
let import_path = crate::import_ruma_events(); let ruma_events = crate::import_ruma_events();
let name = &input.name; let name = &input.name;
let attrs = &input.attrs; let attrs = &input.attrs;
@ -58,7 +58,7 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
attrs, attrs,
&variants, &variants,
&EventKindVariation::Full, &EventKindVariation::Full,
&import_path, &ruma_events,
); );
let sync_event_enum = expand_any_with_deser( let sync_event_enum = expand_any_with_deser(
@ -67,7 +67,7 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
attrs, attrs,
&variants, &variants,
&EventKindVariation::Sync, &EventKindVariation::Sync,
&import_path, &ruma_events,
); );
let stripped_event_enum = expand_any_with_deser( let stripped_event_enum = expand_any_with_deser(
@ -76,7 +76,7 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
attrs, attrs,
&variants, &variants,
&EventKindVariation::Stripped, &EventKindVariation::Stripped,
&import_path, &ruma_events,
); );
let initial_event_enum = expand_any_with_deser( let initial_event_enum = expand_any_with_deser(
@ -85,12 +85,12 @@ pub fn expand_event_enum(input: EventEnumInput) -> syn::Result<TokenStream> {
attrs, attrs,
&variants, &variants,
&EventKindVariation::Initial, &EventKindVariation::Initial,
&import_path, &ruma_events,
); );
let redacted_event_enums = expand_any_redacted(name, &events, attrs, &variants, &import_path); let redacted_event_enums = expand_any_redacted(name, &events, attrs, &variants, &ruma_events);
let event_content_enum = expand_content_enum(name, &events, attrs, &variants, &import_path); let event_content_enum = expand_content_enum(name, &events, attrs, &variants, &ruma_events);
Ok(quote! { Ok(quote! {
#event_enum #event_enum
@ -113,8 +113,11 @@ fn expand_any_with_deser(
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
var: &EventKindVariation, var: &EventKindVariation,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let serde = quote! { #ruma_events::exports::serde };
let serde_json = quote! { #ruma_events::exports::serde_json };
// If the event cannot be generated this bails out returning None which is rendered the same // If the event cannot be generated this bails out returning None which is rendered the same
// as an empty `TokenStream`. This is effectively the check if the given input generates // as an empty `TokenStream`. This is effectively the check if the given input generates
// a valid event enum. // a valid event enum.
@ -122,18 +125,18 @@ fn expand_any_with_deser(
let content = events let content = events
.iter() .iter()
.map(|event| to_event_path(event, &event_struct, import_path)) .map(|event| to_event_path(event, &event_struct, ruma_events))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let variant_decls = variants.iter().map(|v| v.decl()); let variant_decls = variants.iter().map(|v| v.decl());
let self_variants = variants.iter().map(|v| v.ctor(quote!(Self))); let self_variants = variants.iter().map(|v| v.ctor(quote!(Self)));
let (custom_variant, custom_deserialize) = let (custom_variant, custom_deserialize) =
generate_custom_variant(&event_struct, var, import_path); generate_custom_variant(&event_struct, var, ruma_events);
let any_enum = quote! { let any_enum = quote! {
#( #attrs )* #( #attrs )*
#[derive(Clone, Debug, #import_path::exports::serde::Serialize)] #[derive(Clone, Debug, #serde::Serialize)]
#[serde(untagged)] #[serde(untagged)]
#[allow(clippy::large_enum_variant)] #[allow(clippy::large_enum_variant)]
pub enum #ident { pub enum #ident {
@ -151,21 +154,21 @@ fn expand_any_with_deser(
}); });
let event_deserialize_impl = quote! { let event_deserialize_impl = quote! {
impl<'de> #import_path::exports::serde::de::Deserialize<'de> for #ident { impl<'de> #serde::de::Deserialize<'de> for #ident {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where where
D: #import_path::exports::serde::de::Deserializer<'de>, D: #serde::de::Deserializer<'de>,
{ {
use #import_path::exports::serde::de::Error as _; use #serde::de::Error as _;
let json = Box::<#import_path::exports::serde_json::value::RawValue>::deserialize(deserializer)?; let json = Box::<#serde_json::value::RawValue>::deserialize(deserializer)?;
let #import_path::EventDeHelper { ev_type, .. } = let #ruma_events::EventDeHelper { ev_type, .. } =
#import_path::from_raw_json_value(&json)?; #ruma_events::from_raw_json_value(&json)?;
match ev_type.as_str() { match ev_type.as_str() {
#( #(
#variant_attrs #events => { #variant_attrs #events => {
let event = #import_path::exports::serde_json::from_str::<#content>(json.get()) let event = #serde_json::from_str::<#content>(json.get())
.map_err(D::Error::custom)?; .map_err(D::Error::custom)?;
Ok(#self_variants(event)) Ok(#self_variants(event))
}, },
@ -176,13 +179,13 @@ fn expand_any_with_deser(
} }
}; };
let event_enum_to_from_sync = expand_conversion_impl(kind, var, &variants, import_path); let event_enum_to_from_sync = expand_conversion_impl(kind, var, &variants, ruma_events);
let redacted_enum = expand_redacted_enum(kind, var, import_path); let redacted_enum = expand_redacted_enum(kind, var, ruma_events);
let field_accessor_impl = accessor_methods(kind, var, &variants, import_path); let field_accessor_impl = accessor_methods(kind, var, &variants, ruma_events);
let redact_impl = expand_redact(&ident, kind, var, &variants, import_path); let redact_impl = expand_redact(&ident, kind, var, &variants, ruma_events);
Some(quote! { Some(quote! {
#any_enum #any_enum
@ -203,8 +206,10 @@ fn expand_conversion_impl(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var)?;
let variants = &variants let variants = &variants
.iter() .iter()
@ -235,7 +240,7 @@ fn expand_conversion_impl(
let redaction = if let (EventKind::Message, EventKindVariation::Full) = (kind, var) { let redaction = if let (EventKind::Message, EventKindVariation::Full) = (kind, var) {
quote! { quote! {
#ident::RoomRedaction(event) => Self::RoomRedaction( #ident::RoomRedaction(event) => Self::RoomRedaction(
#import_path::room::redaction::SyncRedactionEvent::from(event), #ruma_events::room::redaction::SyncRedactionEvent::from(event),
), ),
} }
} else { } else {
@ -248,12 +253,12 @@ fn expand_conversion_impl(
match event { match event {
#( #(
#ident_variants(event) => { #ident_variants(event) => {
#self_variants(#import_path::#sync_struct::from(event)) #self_variants(#ruma_events::#sync_struct::from(event))
}, },
)* )*
#redaction #redaction
#ident::Custom(event) => { #ident::Custom(event) => {
Self::Custom(#import_path::#sync_struct::from(event)) Self::Custom(#ruma_events::#sync_struct::from(event))
}, },
} }
} }
@ -286,7 +291,7 @@ fn expand_conversion_impl(
/// Convert this sync event into a full event, one with a room_id field. /// Convert this sync event into a full event, one with a room_id field.
pub fn into_full_event( pub fn into_full_event(
self, self,
room_id: #import_path::exports::ruma_identifiers::RoomId room_id: #ruma_identifiers::RoomId
) -> #full { ) -> #full {
match self { match self {
#( #(
@ -317,17 +322,17 @@ fn expand_any_redacted(
events: &[LitStr], events: &[LitStr],
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
use EventKindVariation as V; use EventKindVariation as V;
if kind.is_state() { if kind.is_state() {
let full_state = let full_state =
expand_any_with_deser(kind, events, attrs, variants, &V::Redacted, import_path); expand_any_with_deser(kind, events, attrs, variants, &V::Redacted, ruma_events);
let sync_state = let sync_state =
expand_any_with_deser(kind, events, attrs, variants, &V::RedactedSync, import_path); expand_any_with_deser(kind, events, attrs, variants, &V::RedactedSync, ruma_events);
let stripped_state = let stripped_state =
expand_any_with_deser(kind, events, attrs, variants, &V::RedactedStripped, import_path); expand_any_with_deser(kind, events, attrs, variants, &V::RedactedStripped, ruma_events);
quote! { quote! {
#full_state #full_state
@ -338,9 +343,9 @@ fn expand_any_redacted(
} }
} else if kind.is_message() { } else if kind.is_message() {
let full_message = let full_message =
expand_any_with_deser(kind, events, attrs, variants, &V::Redacted, import_path); expand_any_with_deser(kind, events, attrs, variants, &V::Redacted, ruma_events);
let sync_message = let sync_message =
expand_any_with_deser(kind, events, attrs, variants, &V::RedactedSync, import_path); expand_any_with_deser(kind, events, attrs, variants, &V::RedactedSync, ruma_events);
quote! { quote! {
#full_message #full_message
@ -358,19 +363,22 @@ fn expand_content_enum(
events: &[LitStr], events: &[LitStr],
attrs: &[Attribute], attrs: &[Attribute],
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let serde = quote! { #ruma_events::exports::serde };
let serde_json = quote! { #ruma_events::exports::serde_json };
let ident = kind.to_content_enum(); let ident = kind.to_content_enum();
let event_type_str = events; let event_type_str = events;
let content = let content =
events.iter().map(|ev| to_event_content_path(ev, import_path)).collect::<Vec<_>>(); events.iter().map(|ev| to_event_content_path(ev, ruma_events)).collect::<Vec<_>>();
let variant_decls = variants.iter().map(|v| v.decl()); let variant_decls = variants.iter().map(|v| v.decl());
let content_enum = quote! { let content_enum = quote! {
#( #attrs )* #( #attrs )*
#[derive(Clone, Debug, #import_path::exports::serde::Serialize)] #[derive(Clone, Debug, #serde::Serialize)]
#[serde(untagged)] #[serde(untagged)]
#[allow(clippy::large_enum_variant)] #[allow(clippy::large_enum_variant)]
pub enum #ident { pub enum #ident {
@ -379,7 +387,7 @@ fn expand_content_enum(
#variant_decls(#content), #variant_decls(#content),
)* )*
/// Content of an event not defined by the Matrix specification. /// Content of an event not defined by the Matrix specification.
Custom(#import_path::custom::CustomEventContent), Custom(#ruma_events::custom::CustomEventContent),
} }
}; };
@ -391,7 +399,7 @@ fn expand_content_enum(
let variant_ctors = variants.iter().map(|v| v.ctor(quote!(Self))); let variant_ctors = variants.iter().map(|v| v.ctor(quote!(Self)));
let event_content_impl = quote! { let event_content_impl = quote! {
impl #import_path::EventContent for #ident { impl #ruma_events::EventContent for #ident {
fn event_type(&self) -> &str { fn event_type(&self) -> &str {
match self { match self {
#( #variant_arms(content) => content.event_type(), )* #( #variant_arms(content) => content.event_type(), )*
@ -400,8 +408,8 @@ fn expand_content_enum(
} }
fn from_parts( fn from_parts(
event_type: &str, input: Box<#import_path::exports::serde_json::value::RawValue>, event_type: &str, input: Box<#serde_json::value::RawValue>,
) -> Result<Self, #import_path::exports::serde_json::Error> { ) -> Result<Self, #serde_json::Error> {
match event_type { match event_type {
#( #(
#variant_attrs #event_type_str => { #variant_attrs #event_type_str => {
@ -411,7 +419,7 @@ fn expand_content_enum(
)* )*
ev_type => { ev_type => {
let content = let content =
#import_path::custom::CustomEventContent::from_parts(ev_type, input)?; #ruma_events::custom::CustomEventContent::from_parts(ev_type, input)?;
Ok(Self::Custom(content)) Ok(Self::Custom(content))
}, },
} }
@ -419,7 +427,7 @@ fn expand_content_enum(
} }
}; };
let marker_trait_impls = marker_traits(&kind, import_path); let marker_trait_impls = marker_traits(&kind, ruma_events);
quote! { quote! {
#content_enum #content_enum
@ -435,32 +443,34 @@ fn expand_redact(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
if let EventKindVariation::Full | EventKindVariation::Sync | EventKindVariation::Stripped = var if let EventKindVariation::Full | EventKindVariation::Sync | EventKindVariation::Stripped = var
{ {
let (param, redaction_type, redaction_enum) = match var { let (param, redaction_type, redaction_enum) = match var {
EventKindVariation::Full => { EventKindVariation::Full => {
let struct_id = kind.to_event_ident(&EventKindVariation::Redacted)?; let struct_id = kind.to_event_ident(&EventKindVariation::Redacted)?;
( (
quote! { #import_path::room::redaction::RedactionEvent }, quote! { #ruma_events::room::redaction::RedactionEvent },
quote! { #import_path::#struct_id }, quote! { #ruma_events::#struct_id },
kind.to_event_enum_ident(&EventKindVariation::Redacted)?, kind.to_event_enum_ident(&EventKindVariation::Redacted)?,
) )
} }
EventKindVariation::Sync => { EventKindVariation::Sync => {
let struct_id = kind.to_event_ident(&EventKindVariation::RedactedSync)?; let struct_id = kind.to_event_ident(&EventKindVariation::RedactedSync)?;
( (
quote! { #import_path::room::redaction::SyncRedactionEvent }, quote! { #ruma_events::room::redaction::SyncRedactionEvent },
quote! { #import_path::#struct_id }, quote! { #ruma_events::#struct_id },
kind.to_event_enum_ident(&EventKindVariation::RedactedSync)?, kind.to_event_enum_ident(&EventKindVariation::RedactedSync)?,
) )
} }
EventKindVariation::Stripped => { EventKindVariation::Stripped => {
let struct_id = kind.to_event_ident(&EventKindVariation::RedactedStripped)?; let struct_id = kind.to_event_ident(&EventKindVariation::RedactedStripped)?;
( (
quote! { #import_path::room::redaction::SyncRedactionEvent }, quote! { #ruma_events::room::redaction::SyncRedactionEvent },
quote! { #import_path::#struct_id }, quote! { #ruma_events::#struct_id },
kind.to_event_enum_ident(&EventKindVariation::RedactedStripped)?, kind.to_event_enum_ident(&EventKindVariation::RedactedStripped)?,
) )
} }
@ -471,7 +481,7 @@ fn expand_redact(
let redaction_variants = variants.iter().map(|v| v.ctor(&redaction_enum)); let redaction_variants = variants.iter().map(|v| v.ctor(&redaction_enum));
let fields = EVENT_FIELDS.iter().map(|(name, has_field)| { let fields = EVENT_FIELDS.iter().map(|(name, has_field)| {
generate_redacted_fields(name, kind, var, *has_field, import_path) generate_redacted_fields(name, kind, var, *has_field, ruma_events)
}); });
let fields = quote! { #( #fields )* }; let fields = quote! { #( #fields )* };
@ -482,7 +492,7 @@ fn expand_redact(
pub fn redact( pub fn redact(
self, self,
redaction: #param, redaction: #param,
version: #import_path::exports::ruma_identifiers::RoomVersionId, version: #ruma_identifiers::RoomVersionId,
) -> #redaction_enum { ) -> #redaction_enum {
match self { match self {
#( #(
@ -513,8 +523,11 @@ fn expand_redact(
fn expand_redacted_enum( fn expand_redacted_enum(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let serde = quote! { #ruma_events::exports::serde };
let serde_json = quote! { #ruma_events::exports::serde_json };
if let EventKind::State | EventKind::Message = kind { if let EventKind::State | EventKind::Message = kind {
let ident = format_ident!("AnyPossiblyRedacted{}", kind.to_event_ident(var)?); let ident = format_ident!("AnyPossiblyRedacted{}", kind.to_event_ident(var)?);
@ -528,7 +541,7 @@ fn expand_redacted_enum(
Some(quote! { Some(quote! {
/// An enum that holds either regular un-redacted events or redacted events. /// An enum that holds either regular un-redacted events or redacted events.
#[derive(Clone, Debug, #import_path::exports::serde::Serialize)] #[derive(Clone, Debug, #serde::Serialize)]
#[serde(untagged)] #[serde(untagged)]
pub enum #ident { pub enum #ident {
/// An un-redacted event. /// An un-redacted event.
@ -538,20 +551,20 @@ fn expand_redacted_enum(
Redacted(#redacted_enum_ident), Redacted(#redacted_enum_ident),
} }
impl<'de> #import_path::exports::serde::de::Deserialize<'de> for #ident { impl<'de> #serde::de::Deserialize<'de> for #ident {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where where
D: #import_path::exports::serde::de::Deserializer<'de>, D: #serde::de::Deserializer<'de>,
{ {
let json = Box::<#import_path::exports::serde_json::value::RawValue>::deserialize(deserializer)?; let json = Box::<#serde_json::value::RawValue>::deserialize(deserializer)?;
let #import_path::EventDeHelper { unsigned, .. } = let #ruma_events::EventDeHelper { unsigned, .. } =
#import_path::from_raw_json_value(&json)?; #ruma_events::from_raw_json_value(&json)?;
Ok(match unsigned { Ok(match unsigned {
Some(unsigned) if unsigned.redacted_because.is_some() => { Some(unsigned) if unsigned.redacted_because.is_some() => {
Self::Redacted(#import_path::from_raw_json_value(&json)?) Self::Redacted(#ruma_events::from_raw_json_value(&json)?)
} }
_ => Self::Regular(#import_path::from_raw_json_value(&json)?), _ => Self::Regular(#ruma_events::from_raw_json_value(&json)?),
}) })
} }
} }
@ -570,7 +583,7 @@ fn generate_redacted_fields(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
is_event_kind: EventKindFn, is_event_kind: EventKindFn,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
if is_event_kind(kind, var) { if is_event_kind(kind, var) {
let name = Ident::new(name, Span::call_site()); let name = Ident::new(name, Span::call_site());
@ -583,7 +596,7 @@ fn generate_redacted_fields(
}; };
quote! { quote! {
unsigned: #import_path::#redaction_type { unsigned: #ruma_events::#redaction_type {
redacted_because: Some(::std::boxed::Box::new(redaction)), redacted_because: Some(::std::boxed::Box::new(redaction)),
}, },
} }
@ -600,21 +613,25 @@ fn generate_redacted_fields(
fn generate_custom_variant( fn generate_custom_variant(
event_struct: &Ident, event_struct: &Ident,
var: &EventKindVariation, var: &EventKindVariation,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> (TokenStream, TokenStream) { ) -> (TokenStream, TokenStream) {
use EventKindVariation as V; use EventKindVariation as V;
let serde_json = quote! { #ruma_events::exports::serde_json };
if matches!(var, V::Redacted | V::RedactedSync | V::RedactedStripped) { if matches!(var, V::Redacted | V::RedactedSync | V::RedactedStripped) {
( (
quote! { quote! {
/// A redacted event not defined by the Matrix specification /// A redacted event not defined by the Matrix specification
Custom(#import_path::#event_struct<#import_path::custom::RedactedCustomEventContent>), Custom(
#ruma_events::#event_struct<#ruma_events::custom::RedactedCustomEventContent>,
),
}, },
quote! { quote! {
event => { event => {
let event = #import_path::exports::serde_json::from_str::< let event = #serde_json::from_str::<#ruma_events::#event_struct<
#import_path::#event_struct<#import_path::custom::RedactedCustomEventContent>, #ruma_events::custom::RedactedCustomEventContent,
>(json.get()) >>(json.get())
.map_err(D::Error::custom)?; .map_err(D::Error::custom)?;
Ok(Self::Custom(event)) Ok(Self::Custom(event))
@ -625,13 +642,13 @@ fn generate_custom_variant(
( (
quote! { quote! {
/// An event not defined by the Matrix specification /// An event not defined by the Matrix specification
Custom(#import_path::#event_struct<#import_path::custom::CustomEventContent>), Custom(#ruma_events::#event_struct<#ruma_events::custom::CustomEventContent>),
}, },
quote! { quote! {
event => { event => {
let event = let event =
#import_path::exports::serde_json::from_str::< #serde_json::from_str::<
#import_path::#event_struct<#import_path::custom::CustomEventContent> #ruma_events::#event_struct<#ruma_events::custom::CustomEventContent>
>(json.get()) >(json.get())
.map_err(D::Error::custom)?; .map_err(D::Error::custom)?;
@ -642,22 +659,22 @@ fn generate_custom_variant(
} }
} }
fn marker_traits(kind: &EventKind, import_path: &TokenStream) -> TokenStream { fn marker_traits(kind: &EventKind, ruma_events: &TokenStream) -> TokenStream {
let ident = kind.to_content_enum(); let ident = kind.to_content_enum();
match kind { match kind {
EventKind::State => quote! { EventKind::State => quote! {
impl #import_path::RoomEventContent for #ident {} impl #ruma_events::RoomEventContent for #ident {}
impl #import_path::StateEventContent for #ident {} impl #ruma_events::StateEventContent for #ident {}
}, },
EventKind::Message => quote! { EventKind::Message => quote! {
impl #import_path::RoomEventContent for #ident {} impl #ruma_events::RoomEventContent for #ident {}
impl #import_path::MessageEventContent for #ident {} impl #ruma_events::MessageEventContent for #ident {}
}, },
EventKind::Ephemeral => quote! { EventKind::Ephemeral => quote! {
impl #import_path::EphemeralRoomEventContent for #ident {} impl #ruma_events::EphemeralRoomEventContent for #ident {}
}, },
EventKind::Basic => quote! { EventKind::Basic => quote! {
impl #import_path::BasicEventContent for #ident {} impl #ruma_events::BasicEventContent for #ident {}
}, },
_ => TokenStream::new(), _ => TokenStream::new(),
} }
@ -667,7 +684,7 @@ fn accessor_methods(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
use EventKindVariation as V; use EventKindVariation as V;
@ -675,11 +692,11 @@ fn accessor_methods(
// matching `EventKindVariation`s // matching `EventKindVariation`s
if let V::Redacted | V::RedactedSync | V::RedactedStripped = var { if let V::Redacted | V::RedactedSync | V::RedactedStripped = var {
return redacted_accessor_methods(kind, var, variants, import_path); return redacted_accessor_methods(kind, var, variants, ruma_events);
} }
let methods = EVENT_FIELDS.iter().map(|(name, has_field)| { let methods = EVENT_FIELDS.iter().map(|(name, has_field)| {
generate_accessor(name, kind, var, *has_field, variants, import_path) generate_accessor(name, kind, var, *has_field, variants, ruma_events)
}); });
let content_enum = kind.to_content_enum(); let content_enum = kind.to_content_enum();
@ -752,11 +769,11 @@ fn redacted_accessor_methods(
kind: &EventKind, kind: &EventKind,
var: &EventKindVariation, var: &EventKindVariation,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> Option<TokenStream> { ) -> Option<TokenStream> {
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var)?;
let methods = EVENT_FIELDS.iter().map(|(name, has_field)| { let methods = EVENT_FIELDS.iter().map(|(name, has_field)| {
generate_accessor(name, kind, var, *has_field, variants, import_path) generate_accessor(name, kind, var, *has_field, variants, ruma_events)
}); });
Some(quote! { Some(quote! {
@ -766,7 +783,7 @@ fn redacted_accessor_methods(
}) })
} }
fn to_event_path(name: &LitStr, struct_name: &Ident, import_path: &TokenStream) -> TokenStream { fn to_event_path(name: &LitStr, struct_name: &Ident, ruma_events: &TokenStream) -> TokenStream {
let span = name.span(); let span = name.span();
let name = name.value(); let name = name.value();
@ -790,7 +807,7 @@ fn to_event_path(name: &LitStr, struct_name: &Ident, import_path: &TokenStream)
} else { } else {
quote! { SyncRedactionEvent } quote! { SyncRedactionEvent }
}; };
quote! { #import_path::room::redaction::#redaction } quote! { #ruma_events::room::redaction::#redaction }
} }
"ToDeviceEvent" "ToDeviceEvent"
| "SyncStateEvent" | "SyncStateEvent"
@ -799,20 +816,20 @@ fn to_event_path(name: &LitStr, struct_name: &Ident, import_path: &TokenStream)
| "SyncMessageEvent" | "SyncMessageEvent"
| "SyncEphemeralRoomEvent" => { | "SyncEphemeralRoomEvent" => {
let content = format_ident!("{}EventContent", event); let content = format_ident!("{}EventContent", event);
quote! { #import_path::#struct_name<#import_path::#( #path )::*::#content> } quote! { #ruma_events::#struct_name<#ruma_events::#( #path )::*::#content> }
} }
struct_str if struct_str.contains("Redacted") => { struct_str if struct_str.contains("Redacted") => {
let content = format_ident!("Redacted{}EventContent", event); let content = format_ident!("Redacted{}EventContent", event);
quote! { #import_path::#struct_name<#import_path::#( #path )::*::#content> } quote! { #ruma_events::#struct_name<#ruma_events::#( #path )::*::#content> }
} }
_ => { _ => {
let event_name = format_ident!("{}Event", event); let event_name = format_ident!("{}Event", event);
quote! { #import_path::#( #path )::*::#event_name } quote! { #ruma_events::#( #path )::*::#event_name }
} }
} }
} }
fn to_event_content_path(name: &LitStr, import_path: &TokenStream) -> TokenStream { fn to_event_content_path(name: &LitStr, ruma_events: &TokenStream) -> TokenStream {
let span = name.span(); let span = name.span();
let name = name.value(); let name = name.value();
@ -830,7 +847,7 @@ fn to_event_content_path(name: &LitStr, import_path: &TokenStream) -> TokenStrea
let content_str = format_ident!("{}EventContent", event); let content_str = format_ident!("{}EventContent", event);
let path = path.iter().map(|s| Ident::new(s, span)); let path = path.iter().map(|s| Ident::new(s, span));
quote! { quote! {
#import_path::#( #path )::*::#content_str #ruma_events::#( #path )::*::#content_str
} }
} }
@ -861,12 +878,12 @@ fn generate_accessor(
var: &EventKindVariation, var: &EventKindVariation,
is_event_kind: EventKindFn, is_event_kind: EventKindFn,
variants: &[EventEnumVariant], variants: &[EventEnumVariant],
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
if is_event_kind(kind, var) { if is_event_kind(kind, var) {
let docs = format!("Returns this event's {} field.", name); let docs = format!("Returns this event's {} field.", name);
let ident = Ident::new(name, Span::call_site()); let ident = Ident::new(name, Span::call_site());
let field_type = field_return_type(name, var, import_path); let field_type = field_return_type(name, var, ruma_events);
let variants = variants.iter().map(|v| v.match_arm(quote!(Self))); let variants = variants.iter().map(|v| v.match_arm(quote!(Self)));
quote! { quote! {
@ -886,21 +903,23 @@ fn generate_accessor(
fn field_return_type( fn field_return_type(
name: &str, name: &str,
var: &EventKindVariation, var: &EventKindVariation,
import_path: &TokenStream, ruma_events: &TokenStream,
) -> TokenStream { ) -> TokenStream {
let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
match name { match name {
"origin_server_ts" => quote! { ::std::time::SystemTime }, "origin_server_ts" => quote! { ::std::time::SystemTime },
"room_id" => quote! { #import_path::exports::ruma_identifiers::RoomId }, "room_id" => quote! { #ruma_identifiers::RoomId },
"event_id" => quote! { #import_path::exports::ruma_identifiers::EventId }, "event_id" => quote! { #ruma_identifiers::EventId },
"sender" => quote! { #import_path::exports::ruma_identifiers::UserId }, "sender" => quote! { #ruma_identifiers::UserId },
"state_key" => quote! { str }, "state_key" => quote! { str },
"unsigned" if &EventKindVariation::RedactedSync == var => { "unsigned" if &EventKindVariation::RedactedSync == var => {
quote! { #import_path::RedactedSyncUnsigned } quote! { #ruma_events::RedactedSyncUnsigned }
} }
"unsigned" if &EventKindVariation::Redacted == var => { "unsigned" if &EventKindVariation::Redacted == var => {
quote! { #import_path::RedactedUnsigned } quote! { #ruma_events::RedactedUnsigned }
} }
"unsigned" => quote! { #import_path::Unsigned }, "unsigned" => quote! { #ruma_events::Unsigned },
_ => panic!("the `ruma_events_macros::event_enum::EVENT_FIELD` const was changed"), _ => panic!("the `ruma_events_macros::event_enum::EVENT_FIELD` const was changed"),
} }
} }

24
ruma-events-macros/src/lib.rs
View File

@ -54,10 +54,10 @@ pub fn event_enum(input: TokenStream) -> TokenStream {
/// Generates an implementation of `ruma_events::EventContent`. /// Generates an implementation of `ruma_events::EventContent`.
#[proc_macro_derive(EventContent, attributes(ruma_event))] #[proc_macro_derive(EventContent, attributes(ruma_event))]
pub fn derive_event_content(input: TokenStream) -> TokenStream { pub fn derive_event_content(input: TokenStream) -> TokenStream {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
expand_event_content(&input, true, &import_path) expand_event_content(&input, true, &ruma_events)
.unwrap_or_else(|err| err.to_compile_error()) .unwrap_or_else(|err| err.to_compile_error())
.into() .into()
} }
@ -65,10 +65,10 @@ pub fn derive_event_content(input: TokenStream) -> TokenStream {
/// Generates an implementation of `ruma_events::BasicEventContent` and it's super traits. /// Generates an implementation of `ruma_events::BasicEventContent` and it's super traits.
#[proc_macro_derive(BasicEventContent, attributes(ruma_event))] #[proc_macro_derive(BasicEventContent, attributes(ruma_event))]
pub fn derive_basic_event_content(input: TokenStream) -> TokenStream { pub fn derive_basic_event_content(input: TokenStream) -> TokenStream {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
expand_basic_event_content(&input, &import_path) expand_basic_event_content(&input, &ruma_events)
.unwrap_or_else(|err| err.to_compile_error()) .unwrap_or_else(|err| err.to_compile_error())
.into() .into()
} }
@ -76,10 +76,10 @@ pub fn derive_basic_event_content(input: TokenStream) -> TokenStream {
/// Generates an implementation of `ruma_events::RoomEventContent` and it's super traits. /// Generates an implementation of `ruma_events::RoomEventContent` and it's super traits.
#[proc_macro_derive(RoomEventContent, attributes(ruma_event))] #[proc_macro_derive(RoomEventContent, attributes(ruma_event))]
pub fn derive_room_event_content(input: TokenStream) -> TokenStream { pub fn derive_room_event_content(input: TokenStream) -> TokenStream {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
expand_room_event_content(&input, &import_path) expand_room_event_content(&input, &ruma_events)
.unwrap_or_else(|err| err.to_compile_error()) .unwrap_or_else(|err| err.to_compile_error())
.into() .into()
} }
@ -87,10 +87,10 @@ pub fn derive_room_event_content(input: TokenStream) -> TokenStream {
/// Generates an implementation of `ruma_events::MessageEventContent` and it's super traits. /// Generates an implementation of `ruma_events::MessageEventContent` and it's super traits.
#[proc_macro_derive(MessageEventContent, attributes(ruma_event))] #[proc_macro_derive(MessageEventContent, attributes(ruma_event))]
pub fn derive_message_event_content(input: TokenStream) -> TokenStream { pub fn derive_message_event_content(input: TokenStream) -> TokenStream {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
expand_message_event_content(&input, &import_path) expand_message_event_content(&input, &ruma_events)
.unwrap_or_else(|err| err.to_compile_error()) .unwrap_or_else(|err| err.to_compile_error())
.into() .into()
} }
@ -98,10 +98,10 @@ pub fn derive_message_event_content(input: TokenStream) -> TokenStream {
/// Generates an implementation of `ruma_events::StateEventContent` and it's super traits. /// Generates an implementation of `ruma_events::StateEventContent` and it's super traits.
#[proc_macro_derive(StateEventContent, attributes(ruma_event))] #[proc_macro_derive(StateEventContent, attributes(ruma_event))]
pub fn derive_state_event_content(input: TokenStream) -> TokenStream { pub fn derive_state_event_content(input: TokenStream) -> TokenStream {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
expand_state_event_content(&input, &import_path) expand_state_event_content(&input, &ruma_events)
.unwrap_or_else(|err| err.to_compile_error()) .unwrap_or_else(|err| err.to_compile_error())
.into() .into()
} }
@ -109,10 +109,10 @@ pub fn derive_state_event_content(input: TokenStream) -> TokenStream {
/// Generates an implementation of `ruma_events::EphemeralRoomEventContent` and it's super traits. /// Generates an implementation of `ruma_events::EphemeralRoomEventContent` and it's super traits.
#[proc_macro_derive(EphemeralRoomEventContent, attributes(ruma_event))] #[proc_macro_derive(EphemeralRoomEventContent, attributes(ruma_event))]
pub fn derive_ephemeral_room_event_content(input: TokenStream) -> TokenStream { pub fn derive_ephemeral_room_event_content(input: TokenStream) -> TokenStream {
let import_path = import_ruma_events(); let ruma_events = import_ruma_events();
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
expand_ephemeral_room_event_content(&input, &import_path) expand_ephemeral_room_event_content(&input, &ruma_events)
.unwrap_or_else(|err| err.to_compile_error()) .unwrap_or_else(|err| err.to_compile_error())
.into() .into()
} }