WidgetDriver: rename EventFilter->Filter & MatrixEventFilterInput -> FilterInput

This is a simple devtool refactor rename. Nothing fancy here.

Author: toger5

bindings/matrix-sdk-ffi/src/widget.rs

@@ -490,7 +490,7 @@ pub enum WidgetEventFilter {
     StateWithTypeAndStateKey { event_type: String, state_key: String },
 }
 
-impl From<WidgetEventFilter> for matrix_sdk::widget::EventFilter {
+impl From<WidgetEventFilter> for matrix_sdk::widget::Filter {
     fn from(value: WidgetEventFilter) -> Self {
         match value {
             WidgetEventFilter::MessageLikeWithType { event_type } => {
@@ -509,9 +509,9 @@ impl From<WidgetEventFilter> for matrix_sdk::widget::EventFilter {
     }
 }
 
-impl From<matrix_sdk::widget::EventFilter> for WidgetEventFilter {
-    fn from(value: matrix_sdk::widget::EventFilter) -> Self {
-        use matrix_sdk::widget::EventFilter as F;
+impl From<matrix_sdk::widget::Filter> for WidgetEventFilter {
+    fn from(value: matrix_sdk::widget::Filter) -> Self {
+        use matrix_sdk::widget::Filter as F;
 
         match value {
             F::MessageLike(MessageLikeEventFilter::WithType(event_type)) => {

crates/matrix-sdk/src/widget/capabilities.rs

@@ -22,9 +22,7 @@ use ruma::{events::AnyTimelineEvent, serde::Raw};
 use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
 use tracing::{debug, error};
 
-use super::{
-    filter::MatrixEventFilterInput, EventFilter, MessageLikeEventFilter, StateEventFilter,
-};
+use super::{filter::FilterInput, Filter, MessageLikeEventFilter, StateEventFilter};
 
 /// Must be implemented by a component that provides functionality of deciding
 /// whether a widget is allowed to use certain capabilities (typically by
@@ -42,9 +40,9 @@ pub trait CapabilitiesProvider: Send + Sync + 'static {
 #[cfg_attr(test, derive(PartialEq))]
 pub struct Capabilities {
     /// Types of the messages that a widget wants to be able to fetch.
-    pub read: Vec<EventFilter>,
+    pub read: Vec<Filter>,
     /// Types of the messages that a widget wants to be able to send.
-    pub send: Vec<EventFilter>,
+    pub send: Vec<Filter>,
     /// If this capability is requested by the widget, it can not operate
     /// separately from the matrix client.
     ///
@@ -60,7 +58,7 @@ pub struct Capabilities {
 impl Capabilities {
     /// Tells if a given raw event matches the read filter.
     pub fn raw_event_matches_read_filter(&self, raw: &Raw<AnyTimelineEvent>) -> bool {
-        let filter_in = match raw.deserialize_as::<MatrixEventFilterInput>() {
+        let filter_in = match raw.deserialize_as::<FilterInput>() {
             Ok(filter) => filter,
             Err(err) => {
                 error!("Failed to deserialize raw event as MatrixEventFilterInput: {err}");
@@ -85,12 +83,12 @@ impl Serialize for Capabilities {
     where
         S: Serializer,
     {
-        struct PrintEventFilter<'a>(&'a EventFilter);
+        struct PrintEventFilter<'a>(&'a Filter);
         impl fmt::Display for PrintEventFilter<'_> {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 match self.0 {
-                    EventFilter::MessageLike(filter) => PrintMessageLikeEventFilter(filter).fmt(f),
-                    EventFilter::State(filter) => PrintStateEventFilter(filter).fmt(f),
+                    Filter::MessageLike(filter) => PrintMessageLikeEventFilter(filter).fmt(f),
+                    Filter::State(filter) => PrintStateEventFilter(filter).fmt(f),
                 }
             }
         }
@@ -136,15 +134,15 @@ impl Serialize for Capabilities {
         }
         for filter in &self.read {
             let name = match filter {
-                EventFilter::MessageLike(_) => READ_EVENT,
-                EventFilter::State(_) => READ_STATE,
+                Filter::MessageLike(_) => READ_EVENT,
+                Filter::State(_) => READ_STATE,
             };
             seq.serialize_element(&format!("{name}:{}", PrintEventFilter(filter)))?;
         }
         for filter in &self.send {
             let name = match filter {
-                EventFilter::MessageLike(_) => SEND_EVENT,
-                EventFilter::State(_) => SEND_STATE,
+                Filter::MessageLike(_) => SEND_EVENT,
+                Filter::State(_) => SEND_STATE,
             };
             seq.serialize_element(&format!("{name}:{}", PrintEventFilter(filter)))?;
         }
@@ -162,8 +160,8 @@ impl<'de> Deserialize<'de> for Capabilities {
             RequiresClient,
             UpdateDelayedEvent,
             SendDelayedEvent,
-            Read(EventFilter),
-            Send(EventFilter),
+            Read(Filter),
+            Send(Filter),
             Unknown,
         }
 
@@ -184,17 +182,17 @@ impl<'de> Deserialize<'de> for Capabilities {
                 }
 
                 match s.split_once(':') {
-                    Some((READ_EVENT, filter_s)) => Ok(Permission::Read(EventFilter::MessageLike(
+                    Some((READ_EVENT, filter_s)) => Ok(Permission::Read(Filter::MessageLike(
                         parse_message_event_filter(filter_s),
                     ))),
-                    Some((SEND_EVENT, filter_s)) => Ok(Permission::Send(EventFilter::MessageLike(
+                    Some((SEND_EVENT, filter_s)) => Ok(Permission::Send(Filter::MessageLike(
                         parse_message_event_filter(filter_s),
                     ))),
                     Some((READ_STATE, filter_s)) => {
-                        Ok(Permission::Read(EventFilter::State(parse_state_event_filter(filter_s))))
+                        Ok(Permission::Read(Filter::State(parse_state_event_filter(filter_s))))
                     }
                     Some((SEND_STATE, filter_s)) => {
-                        Ok(Permission::Send(EventFilter::State(parse_state_event_filter(filter_s))))
+                        Ok(Permission::Send(Filter::State(parse_state_event_filter(filter_s))))
                     }
                     _ => {
                         debug!("Unknown capability `{s}`");
@@ -272,19 +270,17 @@ mod tests {
         let parsed = serde_json::from_str::<Capabilities>(capabilities_str).unwrap();
         let expected = Capabilities {
             read: vec![
-                EventFilter::MessageLike(MessageLikeEventFilter::WithType(
+                Filter::MessageLike(MessageLikeEventFilter::WithType(
                     "org.matrix.rageshake_request".into(),
                 )),
-                EventFilter::State(StateEventFilter::WithType(StateEventType::RoomMember)),
-                EventFilter::State(StateEventFilter::WithType(
-                    "org.matrix.msc3401.call.member".into(),
-                )),
+                Filter::State(StateEventFilter::WithType(StateEventType::RoomMember)),
+                Filter::State(StateEventFilter::WithType("org.matrix.msc3401.call.member".into())),
             ],
             send: vec![
-                EventFilter::MessageLike(MessageLikeEventFilter::WithType(
+                Filter::MessageLike(MessageLikeEventFilter::WithType(
                     "org.matrix.rageshake_request".into(),
                 )),
-                EventFilter::State(StateEventFilter::WithTypeAndStateKey(
+                Filter::State(StateEventFilter::WithTypeAndStateKey(
                     "org.matrix.msc3401.call.member".into(),
                     "@user:matrix.server".into(),
                 )),
@@ -301,20 +297,16 @@ mod tests {
     fn serialization_and_deserialization_are_symmetrical() {
         let capabilities = Capabilities {
             read: vec![
-                EventFilter::MessageLike(MessageLikeEventFilter::WithType(
-                    "io.element.custom".into(),
-                )),
-                EventFilter::State(StateEventFilter::WithType(StateEventType::RoomMember)),
-                EventFilter::State(StateEventFilter::WithTypeAndStateKey(
+                Filter::MessageLike(MessageLikeEventFilter::WithType("io.element.custom".into())),
+                Filter::State(StateEventFilter::WithType(StateEventType::RoomMember)),
+                Filter::State(StateEventFilter::WithTypeAndStateKey(
                     "org.matrix.msc3401.call.member".into(),
                     "@user:matrix.server".into(),
                 )),
             ],
             send: vec![
-                EventFilter::MessageLike(MessageLikeEventFilter::WithType(
-                    "io.element.custom".into(),
-                )),
-                EventFilter::State(StateEventFilter::WithTypeAndStateKey(
+                Filter::MessageLike(MessageLikeEventFilter::WithType("io.element.custom".into())),
+                Filter::State(StateEventFilter::WithTypeAndStateKey(
                     "org.matrix.msc3401.call.member".into(),
                     "@user:matrix.server".into(),
                 )),

crates/matrix-sdk/src/widget/filter.rs

@@ -18,18 +18,18 @@ use serde::Deserialize;
 /// Different kinds of filters for timeline events.
 #[derive(Clone, Debug)]
 #[cfg_attr(test, derive(PartialEq))]
-pub enum EventFilter {
+pub enum Filter {
     /// Filter for message-like events.
     MessageLike(MessageLikeEventFilter),
     /// Filter for state events.
     State(StateEventFilter),
 }
 
-impl EventFilter {
-    pub(super) fn matches(&self, matrix_event: &MatrixEventFilterInput) -> bool {
+impl Filter {
+    pub(super) fn matches(&self, matrix_event: &FilterInput) -> bool {
         match self {
-            EventFilter::MessageLike(message_filter) => message_filter.matches(matrix_event),
-            EventFilter::State(state_filter) => state_filter.matches(matrix_event),
+            Filter::MessageLike(message_filter) => message_filter.matches(matrix_event),
+            Filter::State(state_filter) => state_filter.matches(matrix_event),
         }
     }
 
@@ -65,7 +65,7 @@ pub enum MessageLikeEventFilter {
 }
 
 impl MessageLikeEventFilter {
-    fn matches(&self, matrix_event: &MatrixEventFilterInput) -> bool {
+    fn matches(&self, matrix_event: &FilterInput) -> bool {
         if matrix_event.state_key.is_some() {
             // State event doesn't match a message-like event filter.
             return false;
@@ -103,7 +103,7 @@ pub enum StateEventFilter {
 }
 
 impl StateEventFilter {
-    fn matches(&self, matrix_event: &MatrixEventFilterInput) -> bool {
+    fn matches(&self, matrix_event: &FilterInput) -> bool {
         let Some(state_key) = &matrix_event.state_key else {
             // Message-like event doesn't match a state event filter.
             return false;
@@ -126,7 +126,7 @@ impl StateEventFilter {
 }
 
 #[derive(Debug, Deserialize)]
-pub(super) struct MatrixEventFilterInput {
+pub(super) struct FilterInput {
     #[serde(rename = "type")]
     pub(super) event_type: TimelineEventType,
     pub(super) state_key: Option<String>,
@@ -143,38 +143,28 @@ mod tests {
     use ruma::events::{MessageLikeEventType, StateEventType, TimelineEventType};
 
     use super::{
-        EventFilter, MatrixEventContent, MatrixEventFilterInput, MessageLikeEventFilter,
-        StateEventFilter,
+        Filter, FilterInput, MatrixEventContent, MessageLikeEventFilter, StateEventFilter,
     };
 
-    fn message_event(event_type: TimelineEventType) -> MatrixEventFilterInput {
-        MatrixEventFilterInput { event_type, state_key: None, content: Default::default() }
+    fn message_event(event_type: TimelineEventType) -> FilterInput {
+        FilterInput { event_type, state_key: None, content: Default::default() }
     }
 
-    fn message_event_with_msgtype(
-        event_type: TimelineEventType,
-        msgtype: String,
-    ) -> MatrixEventFilterInput {
-        MatrixEventFilterInput {
+    fn message_event_with_msgtype(event_type: TimelineEventType, msgtype: String) -> FilterInput {
+        FilterInput {
             event_type,
             state_key: None,
             content: MatrixEventContent { msgtype: Some(msgtype) },
         }
     }
 
-    fn state_event(event_type: TimelineEventType, state_key: String) -> MatrixEventFilterInput {
-        MatrixEventFilterInput {
-            event_type,
-            state_key: Some(state_key),
-            content: Default::default(),
-        }
+    fn state_event(event_type: TimelineEventType, state_key: String) -> FilterInput {
+        FilterInput { event_type, state_key: Some(state_key), content: Default::default() }
     }
 
     // Tests against an `m.room.message` filter with `msgtype = m.text`
-    fn room_message_text_event_filter() -> EventFilter {
-        EventFilter::MessageLike(MessageLikeEventFilter::RoomMessageWithMsgtype(
-            "m.text".to_owned(),
-        ))
+    fn room_message_text_event_filter() -> Filter {
+        Filter::MessageLike(MessageLikeEventFilter::RoomMessageWithMsgtype("m.text".to_owned()))
     }
 
     #[test]
@@ -202,8 +192,8 @@ mod tests {
     }
 
     // Tests against an `m.reaction` filter
-    fn reaction_event_filter() -> EventFilter {
-        EventFilter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::Reaction))
+    fn reaction_event_filter() -> Filter {
+        Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::Reaction))
     }
 
     #[test]
@@ -238,8 +228,8 @@ mod tests {
     }
 
     // Tests against an `m.room.member` filter with `state_key = "@self:example.me"`
-    fn self_member_event_filter() -> EventFilter {
-        EventFilter::State(StateEventFilter::WithTypeAndStateKey(
+    fn self_member_event_filter() -> Filter {
+        Filter::State(StateEventFilter::WithTypeAndStateKey(
             StateEventType::RoomMember,
             "@self:example.me".to_owned(),
         ))
@@ -279,8 +269,8 @@ mod tests {
     }
 
     // Tests against an `m.room.member` filter with any `state_key`.
-    fn member_event_filter() -> EventFilter {
-        EventFilter::State(StateEventFilter::WithType(StateEventType::RoomMember))
+    fn member_event_filter() -> Filter {
+        Filter::State(StateEventFilter::WithType(StateEventType::RoomMember))
     }
 
     #[test]
@@ -307,8 +297,8 @@ mod tests {
     }
 
     // Tests against an `m.room.topic` filter with `state_key = ""`
-    fn topic_event_filter() -> EventFilter {
-        EventFilter::State(StateEventFilter::WithTypeAndStateKey(
+    fn topic_event_filter() -> Filter {
+        Filter::State(StateEventFilter::WithTypeAndStateKey(
             StateEventType::RoomTopic,
             "".to_owned(),
         ))
@@ -321,17 +311,13 @@ mod tests {
     }
 
     // Tests against an `m.room.message` filter with `msgtype = m.custom`
-    fn room_message_custom_event_filter() -> EventFilter {
-        EventFilter::MessageLike(MessageLikeEventFilter::RoomMessageWithMsgtype(
-            "m.custom".to_owned(),
-        ))
+    fn room_message_custom_event_filter() -> Filter {
+        Filter::MessageLike(MessageLikeEventFilter::RoomMessageWithMsgtype("m.custom".to_owned()))
     }
 
     // Tests against an `m.room.message` filter without a `msgtype`
-    fn room_message_filter() -> EventFilter {
-        EventFilter::MessageLike(MessageLikeEventFilter::WithType(
-            MessageLikeEventType::RoomMessage,
-        ))
+    fn room_message_filter() -> Filter {
+        Filter::MessageLike(MessageLikeEventFilter::WithType(MessageLikeEventType::RoomMessage))
     }
 
     #[test]

crates/matrix-sdk/src/widget/machine/mod.rs

@@ -49,7 +49,7 @@ use self::{
 use super::WidgetDriver;
 use super::{
     capabilities::{SEND_DELAYED_EVENT, UPDATE_DELAYED_EVENT},
-    filter::{MatrixEventContent, MatrixEventFilterInput},
+    filter::{MatrixEventContent, FilterInput},
     Capabilities, StateKeySelector,
 };
 use crate::Result;
@@ -376,7 +376,7 @@ impl WidgetMachine {
                         .any(|filter| filter.matches_state_event_with_any_state_key(&event_type)),
 
                     StateKeySelector::Key(state_key) => {
-                        let filter_in = MatrixEventFilterInput {
+                        let filter_in = FilterInput {
                             event_type: event_type.to_string().into(),
                             state_key: Some(state_key.clone()),
                             // content doesn't matter for state events
@@ -418,7 +418,7 @@ impl WidgetMachine {
             return None;
         };
 
-        let filter_in = MatrixEventFilterInput {
+        let filter_in = FilterInput {
             event_type: request.event_type.clone(),
             state_key: request.state_key.clone(),
             content: serde_json::from_str(request.content.get()).unwrap_or_else(|e| {

crates/matrix-sdk/src/widget/mod.rs

@@ -40,7 +40,7 @@ mod settings;
 
 pub use self::{
     capabilities::{Capabilities, CapabilitiesProvider},
-    filter::{EventFilter, MessageLikeEventFilter, StateEventFilter},
+    filter::{Filter, MessageLikeEventFilter, StateEventFilter},
     settings::{
         ClientProperties, EncryptionSystem, Intent, VirtualElementCallWidgetOptions, WidgetSettings,
     },