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

Remove glob imports of C-like enums

Browse Source
This commit is contained in:
Jonas Platte 2020-07-26 17:13:08 +02:00
parent 3f3cf83ceb
commit 1862d15365
No known key found for this signature in database
GPG Key ID: 7D261D771D915378
4 changed files with 63 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
ruma-common/src/push/condition/room_member_count_is.rs
View File

@ -98,14 +98,14 @@ impl From<RangeToInclusive<UInt>> for RoomMemberCountIs {
impl Display for RoomMemberCountIs { impl Display for RoomMemberCountIs {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
use ComparisonOperator::*; use ComparisonOperator as Op;
let prefix = match self.prefix { let prefix = match self.prefix {
Eq => "", Op::Eq => "",
Lt => "<", Op::Lt => "<",
Gt => ">", Op::Gt => ">",
Ge => ">=", Op::Ge => ">=",
Le => "<=", Op::Le => "<=",
}; };
write!(f, "{}{}", prefix, self.count) write!(f, "{}{}", prefix, self.count)
@ -126,15 +126,15 @@ impl FromStr for RoomMemberCountIs {
type Err = js_int::ParseIntError; type Err = js_int::ParseIntError;
fn from_str(s: &str) -> Result<Self, Self::Err> { fn from_str(s: &str) -> Result<Self, Self::Err> {
use ComparisonOperator::*; use ComparisonOperator as Op;
let (prefix, count_str) = match s { let (prefix, count_str) = match s {
s if s.starts_with("<=") => (Le, &s[2..]), s if s.starts_with("<=") => (Op::Le, &s[2..]),
s if s.starts_with('<') => (Lt, &s[1..]), s if s.starts_with('<') => (Op::Lt, &s[1..]),
s if s.starts_with(">=") => (Ge, &s[2..]), s if s.starts_with(">=") => (Op::Ge, &s[2..]),
s if s.starts_with('>') => (Gt, &s[1..]), s if s.starts_with('>') => (Op::Gt, &s[1..]),
s if s.starts_with("==") => (Eq, &s[2..]), s if s.starts_with("==") => (Op::Eq, &s[2..]),
s => (Eq, s), s => (Op::Eq, s),
}; };
Ok(RoomMemberCountIs { prefix, count: UInt::from_str(count_str)? }) Ok(RoomMemberCountIs { prefix, count: UInt::from_str(count_str)? })
@ -153,24 +153,24 @@ impl<'de> Deserialize<'de> for RoomMemberCountIs {
impl RangeBounds<UInt> for RoomMemberCountIs { impl RangeBounds<UInt> for RoomMemberCountIs {
fn start_bound(&self) -> Bound<&UInt> { fn start_bound(&self) -> Bound<&UInt> {
use ComparisonOperator::*; use ComparisonOperator as Op;
match self.prefix { match self.prefix {
Eq => Bound::Included(&self.count), Op::Eq => Bound::Included(&self.count),
Lt | Le => Bound::Unbounded, Op::Lt | Op::Le => Bound::Unbounded,
Gt => Bound::Excluded(&self.count), Op::Gt => Bound::Excluded(&self.count),
Ge => Bound::Included(&self.count), Op::Ge => Bound::Included(&self.count),
} }
} }
fn end_bound(&self) -> Bound<&UInt> { fn end_bound(&self) -> Bound<&UInt> {
use ComparisonOperator::*; use ComparisonOperator as Op;
match self.prefix { match self.prefix {
Eq => Bound::Included(&self.count), Op::Eq => Bound::Included(&self.count),
Gt | Ge => Bound::Unbounded, Op::Gt | Op::Ge => Bound::Unbounded,
Lt => Bound::Excluded(&self.count), Op::Lt => Bound::Excluded(&self.count),
Le => Bound::Included(&self.count), Op::Le => Bound::Included(&self.count),
} }
} }
} }

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

@ -254,13 +254,13 @@ fn expand_any_redacted(
attrs: &[Attribute], attrs: &[Attribute],
variants: &[Ident], variants: &[Ident],
) -> TokenStream { ) -> TokenStream {
use EventKindVariation::*; use EventKindVariation as V;
if kind.is_state() { if kind.is_state() {
let full_state = expand_any_with_deser(kind, events, attrs, variants, &Redacted); let full_state = expand_any_with_deser(kind, events, attrs, variants, &V::Redacted);
let sync_state = expand_any_with_deser(kind, events, attrs, variants, &RedactedSync); let sync_state = expand_any_with_deser(kind, events, attrs, variants, &V::RedactedSync);
let stripped_state = let stripped_state =
expand_any_with_deser(kind, events, attrs, variants, &RedactedStripped); expand_any_with_deser(kind, events, attrs, variants, &V::RedactedStripped);
quote! { quote! {
#full_state #full_state
@ -270,8 +270,8 @@ fn expand_any_redacted(
#stripped_state #stripped_state
} }
} else if kind.is_message() { } else if kind.is_message() {
let full_message = expand_any_with_deser(kind, events, attrs, variants, &Redacted); let full_message = expand_any_with_deser(kind, events, attrs, variants, &V::Redacted);
let sync_message = expand_any_with_deser(kind, events, attrs, variants, &RedactedSync); let sync_message = expand_any_with_deser(kind, events, attrs, variants, &V::RedactedSync);
quote! { quote! {
#full_message #full_message
@ -495,9 +495,9 @@ fn generate_custom_variant(
event_struct: &Ident, event_struct: &Ident,
var: &EventKindVariation, var: &EventKindVariation,
) -> (TokenStream, TokenStream) { ) -> (TokenStream, TokenStream) {
use EventKindVariation::*; use EventKindVariation as V;
if matches!(var, Redacted | RedactedSync | 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
@ -559,12 +559,12 @@ fn accessor_methods(
var: &EventKindVariation, var: &EventKindVariation,
variants: &[Ident], variants: &[Ident],
) -> Option<TokenStream> { ) -> Option<TokenStream> {
use EventKindVariation::*; use EventKindVariation as V;
let ident = kind.to_event_enum_ident(var)?; let ident = kind.to_event_enum_ident(var)?;
// matching `EventKindVariation`s // matching `EventKindVariation`s
if let Redacted | RedactedSync | RedactedStripped = var { if let V::Redacted | V::RedactedSync | V::RedactedStripped = var {
return redacted_accessor_methods(kind, var, variants); return redacted_accessor_methods(kind, var, variants);
} }

22
ruma-events-macros/src/event_parse.rs
View File

@ -92,20 +92,20 @@ impl EventKind {
} }
pub fn to_event_ident(&self, var: &EventKindVariation) -> Option<Ident> { pub fn to_event_ident(&self, var: &EventKindVariation) -> Option<Ident> {
use EventKindVariation::*; use EventKindVariation as V;
// this match is only used to validate the input // this match is only used to validate the input
match (self, var) { match (self, var) {
(_, Full) (_, V::Full)
| (Self::Ephemeral, Sync) | (Self::Ephemeral, V::Sync)
| (Self::Message, Sync) | (Self::Message, V::Sync)
| (Self::State, Sync) | (Self::State, V::Sync)
| (Self::State, Stripped) | (Self::State, V::Stripped)
| (Self::Message, Redacted) | (Self::Message, V::Redacted)
| (Self::State, Redacted) | (Self::State, V::Redacted)
| (Self::Message, RedactedSync) | (Self::Message, V::RedactedSync)
| (Self::State, RedactedSync) | (Self::State, V::RedactedSync)
| (Self::State, RedactedStripped) => { | (Self::State, V::RedactedStripped) => {
Some(Ident::new(&format!("{}{}", var, self), Span::call_site())) Some(Ident::new(&format!("{}{}", var, self), Span::call_site()))
} }
_ => None, _ => None,

36
ruma-events/src/room/member.rs
View File

@ -170,7 +170,9 @@ fn membership_change(
sender: &UserId, sender: &UserId,
state_key: &str, state_key: &str,
) -> MembershipChange { ) -> MembershipChange {
use MembershipState::*; use MembershipChange as Ch;
use MembershipState as St;
let prev_content = if let Some(prev_content) = &prev_content { let prev_content = if let Some(prev_content) = &prev_content {
prev_content prev_content
} else { } else {
@ -178,38 +180,38 @@ fn membership_change(
avatar_url: None, avatar_url: None,
displayname: None, displayname: None,
is_direct: None, is_direct: None,
membership: Leave, membership: St::Leave,
third_party_invite: None, third_party_invite: None,
} }
}; };
match (prev_content.membership, &content.membership) { match (prev_content.membership, &content.membership) {
(Invite, Invite) | (Leave, Leave) | (Ban, Ban) => MembershipChange::None, (St::Invite, St::Invite) | (St::Leave, St::Leave) | (St::Ban, St::Ban) => Ch::None,
(Invite, Join) | (Leave, Join) => MembershipChange::Joined, (St::Invite, St::Join) | (St::Leave, St::Join) => Ch::Joined,
(Invite, Leave) => { (St::Invite, St::Leave) => {
if sender == state_key { if sender == state_key {
MembershipChange::InvitationRevoked Ch::InvitationRevoked
} else { } else {
MembershipChange::InvitationRejected Ch::InvitationRejected
} }
} }
(Invite, Ban) | (Leave, Ban) => MembershipChange::Banned, (St::Invite, St::Ban) | (St::Leave, St::Ban) => Ch::Banned,
(Join, Invite) | (Ban, Invite) | (Ban, Join) => MembershipChange::Error, (St::Join, St::Invite) | (St::Ban, St::Invite) | (St::Ban, St::Join) => Ch::Error,
(Join, Join) => MembershipChange::ProfileChanged { (St::Join, St::Join) => Ch::ProfileChanged {
displayname_changed: prev_content.displayname != content.displayname, displayname_changed: prev_content.displayname != content.displayname,
avatar_url_changed: prev_content.avatar_url != content.avatar_url, avatar_url_changed: prev_content.avatar_url != content.avatar_url,
}, },
(Join, Leave) => { (St::Join, St::Leave) => {
if sender == state_key { if sender == state_key {
MembershipChange::Left Ch::Left
} else { } else {
MembershipChange::Kicked Ch::Kicked
} }
} }
(Join, Ban) => MembershipChange::KickedAndBanned, (St::Join, St::Ban) => Ch::KickedAndBanned,
(Leave, Invite) => MembershipChange::Invited, (St::Leave, St::Invite) => Ch::Invited,
(Ban, Leave) => MembershipChange::Unbanned, (St::Ban, St::Leave) => Ch::Unbanned,
(Knock, _) | (_, Knock) => MembershipChange::NotImplemented, (St::Knock, _) | (_, St::Knock) => Ch::NotImplemented,
} }
} }