Move common::push::AnyPushRule to client_api::r0::push::PushRule

ruma-client-api/src/r0/push.rs

@@ -1,6 +1,14 @@
 //! Endpoints for push notifications.
+use std::{
+    convert::TryFrom,
+    error::Error,
+    fmt::{self, Display, Formatter},
+};
 
-use ruma_common::push::PusherData;
+use ruma_common::push::{
+    Action, ConditionalPushRule, ConditionalPushRuleInit, PatternedPushRule, PatternedPushRuleInit,
+    PushCondition, PusherData, SimplePushRule, SimplePushRuleInit,
+};
 use ruma_serde::StringEnum;
 use serde::{Deserialize, Serialize};
 
@@ -17,6 +25,143 @@ pub mod set_pushrule;
 pub mod set_pushrule_actions;
 pub mod set_pushrule_enabled;
 
+/// Like `SimplePushRule`, but may represent any kind of push rule
+/// thanks to `pattern` and `conditions` being optional.
+///
+/// To create an instance of this type, use one of its `From` implementations.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
+pub struct PushRule {
+    /// The actions to perform when this rule is matched.
+    pub actions: Vec<Action>,
+
+    /// Whether this is a default rule, or has been set explicitly.
+    pub default: bool,
+
+    /// Whether the push rule is enabled or not.
+    pub enabled: bool,
+
+    /// The ID of this rule.
+    pub rule_id: String,
+
+    /// The conditions that must hold true for an event in order for a rule to be applied to an
+    /// event. A rule with no conditions always matches.
+    ///
+    /// Only applicable to underride and override rules.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub conditions: Option<Vec<PushCondition>>,
+
+    /// The glob-style pattern to match against. Only applicable to content rules.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pattern: Option<String>,
+}
+
+impl From<SimplePushRule> for PushRule {
+    fn from(push_rule: SimplePushRule) -> Self {
+        let SimplePushRule { actions, default, enabled, rule_id, .. } = push_rule;
+        Self { actions, default, enabled, rule_id, conditions: None, pattern: None }
+    }
+}
+
+impl From<PatternedPushRule> for PushRule {
+    fn from(push_rule: PatternedPushRule) -> Self {
+        let PatternedPushRule { actions, default, enabled, rule_id, pattern, .. } = push_rule;
+        Self { actions, default, enabled, rule_id, conditions: None, pattern: Some(pattern) }
+    }
+}
+
+impl From<ConditionalPushRule> for PushRule {
+    fn from(push_rule: ConditionalPushRule) -> Self {
+        let ConditionalPushRule { actions, default, enabled, rule_id, conditions, .. } = push_rule;
+        Self { actions, default, enabled, rule_id, conditions: Some(conditions), pattern: None }
+    }
+}
+
+impl From<SimplePushRuleInit> for PushRule {
+    fn from(init: SimplePushRuleInit) -> Self {
+        let SimplePushRuleInit { actions, default, enabled, rule_id } = init;
+        Self { actions, default, enabled, rule_id, pattern: None, conditions: None }
+    }
+}
+
+impl From<ConditionalPushRuleInit> for PushRule {
+    fn from(init: ConditionalPushRuleInit) -> Self {
+        let ConditionalPushRuleInit { actions, default, enabled, rule_id, conditions } = init;
+        Self { actions, default, enabled, rule_id, pattern: None, conditions: Some(conditions) }
+    }
+}
+
+impl From<PatternedPushRuleInit> for PushRule {
+    fn from(init: PatternedPushRuleInit) -> Self {
+        let PatternedPushRuleInit { actions, default, enabled, rule_id, pattern } = init;
+        Self { actions, default, enabled, rule_id, pattern: Some(pattern), conditions: None }
+    }
+}
+
+impl From<PushRule> for SimplePushRule {
+    fn from(push_rule: PushRule) -> Self {
+        let PushRule { actions, default, enabled, rule_id, .. } = push_rule;
+        SimplePushRuleInit { actions, default, enabled, rule_id }.into()
+    }
+}
+
+/// An error that happens when `PushRule` cannot
+/// be converted into `PatternedPushRule`
+#[derive(Debug)]
+#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
+pub struct MissingPatternError;
+
+impl Display for MissingPatternError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "Push rule does not have a pattern.")
+    }
+}
+
+impl Error for MissingPatternError {}
+
+impl TryFrom<PushRule> for PatternedPushRule {
+    type Error = MissingPatternError;
+
+    fn try_from(push_rule: PushRule) -> Result<Self, Self::Error> {
+        if let PushRule { actions, default, enabled, rule_id, pattern: Some(pattern), .. } =
+            push_rule
+        {
+            Ok(PatternedPushRuleInit { actions, default, enabled, rule_id, pattern }.into())
+        } else {
+            Err(MissingPatternError)
+        }
+    }
+}
+
+/// An error that happens when `PushRule` cannot
+/// be converted into `ConditionalPushRule`
+#[derive(Debug)]
+#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
+pub struct MissingConditionsError;
+
+impl Display for MissingConditionsError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "Push rule has no conditions.")
+    }
+}
+
+impl Error for MissingConditionsError {}
+
+impl TryFrom<PushRule> for ConditionalPushRule {
+    type Error = MissingConditionsError;
+
+    fn try_from(push_rule: PushRule) -> Result<Self, Self::Error> {
+        if let PushRule {
+            actions, default, enabled, rule_id, conditions: Some(conditions), ..
+        } = push_rule
+        {
+            Ok(ConditionalPushRuleInit { actions, default, enabled, rule_id, conditions }.into())
+        } else {
+            Err(MissingConditionsError)
+        }
+    }
+}
+
 /// The kinds of push rules that are available.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, StringEnum)]
 #[ruma_enum(rename_all = "snake_case")]

ruma-client-api/src/r0/push/get_pushrule.rs

@@ -1,9 +1,8 @@
 //! [GET /_matrix/client/r0/pushrules/{scope}/{kind}/{ruleId}](https://matrix.org/docs/spec/client_server/r0.6.0#get-matrix-client-r0-pushrules-scope-kind-ruleid)
 
 use ruma_api::ruma_api;
-use ruma_common::push::AnyPushRule;
 
-use super::RuleKind;
+use super::{PushRule, RuleKind};
 
 ruma_api! {
     metadata: {
@@ -32,7 +31,7 @@ ruma_api! {
     response: {
         /// The specific push rule.
         #[ruma_api(body)]
-        pub rule: AnyPushRule,
+        pub rule: PushRule,
     }
 
     error: crate::Error
@@ -47,7 +46,7 @@ impl<'a> Request<'a> {
 
 impl Response {
     /// Creates a new `Response` with the given rule.
-    pub fn new(rule: AnyPushRule) -> Self {
+    pub fn new(rule: PushRule) -> Self {
         Self { rule }
     }
 }

ruma-common/CHANGELOG.md

@@ -4,6 +4,8 @@ Breaking changes:
 
 * Update set of conversion trait implementations for enums
 * Replace `BTreeSet` by `IndexSet` in `push::Ruleset`.
+* Remove `push::AnyPushRule`. Use `r0::push::PushRule`
+  from `ruma-client-api`.
 * … (there's a lot more, but this changelog was not kept up to date; PRs to
   improve it are welcome)
 

ruma-common/src/push.rs

@@ -30,9 +30,6 @@
 //!
 //! It is still possible to write code that is generic over a representation by manipulating
 //! `SimplePushRule`, `ConditonalPushRule` or `PatternedPushRule` directly, instead of the wrappers.
-//!
-//! There is also the `AnyPushRule` type that is the most generic form of push rule, with all
-//! the possible fields.
 
 use std::hash::{Hash, Hasher};
 
@@ -44,13 +41,11 @@ use ruma_serde::StringEnum;
 use serde::{Deserialize, Serialize};
 
 mod action;
-mod any_push_rule;
 mod condition;
 mod predefined;
 
 pub use self::{
     action::{Action, Tweak},
-    any_push_rule::{AnyPushRule, MissingConditionsError, MissingPatternError},
     condition::{ComparisonOperator, PushCondition, RoomMemberCountIs},
 };
 
@@ -108,34 +103,34 @@ pub struct RulesetIter {
     underride: IndexSetIter<UnderridePushRule>,
 }
 
-impl Iterator for RulesetIter {
+// impl Iterator for RulesetIter {
-    type Item = AnyPushRule;
+//     type Item = AnyPushRule;
 
-    fn next(&mut self) -> Option<Self::Item> {
+//     fn next(&mut self) -> Option<Self::Item> {
-        self.override_
+//         self.override_
-            .next()
+//             .next()
-            .map(|x| x.0.into())
+//             .map(|x| x.0.into())
-            .or_else(|| self.content.next().map(|x| x.0.into()))
+//             .or_else(|| self.content.next().map(|x| x.0.into()))
-            .or_else(|| self.room.next().map(|x| x.0.into()))
+//             .or_else(|| self.room.next().map(|x| x.0.into()))
-            .or_else(|| self.sender.next().map(|x| x.0.into()))
+//             .or_else(|| self.sender.next().map(|x| x.0.into()))
-            .or_else(|| self.underride.next().map(|x| x.0.into()))
+//             .or_else(|| self.underride.next().map(|x| x.0.into()))
-    }
+//     }
-}
+// }
 
-impl IntoIterator for Ruleset {
+// impl IntoIterator for Ruleset {
-    type Item = AnyPushRule;
+//     type Item = AnyPushRule;
-    type IntoIter = RulesetIter;
+//     type IntoIter = RulesetIter;
 
-    fn into_iter(self) -> Self::IntoIter {
+//     fn into_iter(self) -> Self::IntoIter {
-        RulesetIter {
+//         RulesetIter {
-            content: self.content.into_iter(),
+//             content: self.content.into_iter(),
-            override_: self.override_.into_iter(),
+//             override_: self.override_.into_iter(),
-            room: self.room.into_iter(),
+//             room: self.room.into_iter(),
-            sender: self.sender.into_iter(),
+//             sender: self.sender.into_iter(),
-            underride: self.underride.into_iter(),
+//             underride: self.underride.into_iter(),
-        }
+//         }
-    }
+//     }
-}
+// }
 
 /// A trait for types that can be added in a Ruleset
 pub trait RulesetMember: private::Sealed {

ruma-common/src/push/any_push_rule.rs

@@ -1,154 +0,0 @@
-use std::{
-    convert::TryFrom,
-    error::Error,
-    fmt::{self, Display, Formatter},
-};
-
-use serde::{Deserialize, Serialize};
-
-use super::{
-    Action, ConditionalPushRule, ConditionalPushRuleInit, PatternedPushRule, PatternedPushRuleInit,
-    PushCondition, SimplePushRule, SimplePushRuleInit,
-};
-
-/// Like `SimplePushRule`, but may represent any kind of push rule
-/// thanks to `pattern` and `conditions` being optional.
-///
-/// To create an instance of this type, use one of its `From` implementations.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
-pub struct AnyPushRule {
-    /// The actions to perform when this rule is matched.
-    pub actions: Vec<Action>,
-
-    /// Whether this is a default rule, or has been set explicitly.
-    pub default: bool,
-
-    /// Whether the push rule is enabled or not.
-    pub enabled: bool,
-
-    /// The ID of this rule.
-    pub rule_id: String,
-
-    /// The conditions that must hold true for an event in order for a rule to be applied to an
-    /// event. A rule with no conditions always matches.
-    ///
-    /// Only applicable to underride and override rules.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub conditions: Option<Vec<PushCondition>>,
-
-    /// The glob-style pattern to match against. Only applicable to content rules.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pattern: Option<String>,
-}
-
-impl From<SimplePushRule> for AnyPushRule {
-    fn from(push_rule: SimplePushRule) -> Self {
-        let SimplePushRule { actions, default, enabled, rule_id } = push_rule;
-        Self { actions, default, enabled, rule_id, conditions: None, pattern: None }
-    }
-}
-
-impl From<PatternedPushRule> for AnyPushRule {
-    fn from(push_rule: PatternedPushRule) -> Self {
-        let PatternedPushRule { actions, default, enabled, rule_id, pattern } = push_rule;
-        Self { actions, default, enabled, rule_id, conditions: None, pattern: Some(pattern) }
-    }
-}
-
-impl From<ConditionalPushRule> for AnyPushRule {
-    fn from(push_rule: ConditionalPushRule) -> Self {
-        let ConditionalPushRule { actions, default, enabled, rule_id, conditions } = push_rule;
-        Self { actions, default, enabled, rule_id, conditions: Some(conditions), pattern: None }
-    }
-}
-
-impl From<SimplePushRuleInit> for AnyPushRule {
-    fn from(init: SimplePushRuleInit) -> Self {
-        let SimplePushRuleInit { actions, default, enabled, rule_id } = init;
-        Self { actions, default, enabled, rule_id, pattern: None, conditions: None }
-    }
-}
-
-impl From<ConditionalPushRuleInit> for AnyPushRule {
-    fn from(init: ConditionalPushRuleInit) -> Self {
-        let ConditionalPushRuleInit { actions, default, enabled, rule_id, conditions } = init;
-        Self { actions, default, enabled, rule_id, pattern: None, conditions: Some(conditions) }
-    }
-}
-
-impl From<PatternedPushRuleInit> for AnyPushRule {
-    fn from(init: PatternedPushRuleInit) -> Self {
-        let PatternedPushRuleInit { actions, default, enabled, rule_id, pattern } = init;
-        Self { actions, default, enabled, rule_id, pattern: Some(pattern), conditions: None }
-    }
-}
-
-impl From<AnyPushRule> for SimplePushRule {
-    fn from(push_rule: AnyPushRule) -> Self {
-        let AnyPushRule { actions, default, enabled, rule_id, .. } = push_rule;
-        Self { actions, default, enabled, rule_id }
-    }
-}
-
-/// An error that happens when `AnyPushRule` cannot
-/// be converted into `PatternedPushRule`
-#[derive(Debug)]
-#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
-pub struct MissingPatternError;
-
-impl Display for MissingPatternError {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Push rule does not have a pattern.")
-    }
-}
-
-impl Error for MissingPatternError {}
-
-impl TryFrom<AnyPushRule> for PatternedPushRule {
-    type Error = MissingPatternError;
-
-    fn try_from(push_rule: AnyPushRule) -> Result<Self, Self::Error> {
-        if let AnyPushRule { actions, default, enabled, rule_id, pattern: Some(pattern), .. } =
-            push_rule
-        {
-            Ok(PatternedPushRule { actions, default, enabled, rule_id, pattern })
-        } else {
-            Err(MissingPatternError)
-        }
-    }
-}
-
-/// An error that happens when `AnyPushRule` cannot
-/// be converted into `ConditionalPushRule`
-#[derive(Debug)]
-#[cfg_attr(not(feature = "unstable-exhaustive-types"), non_exhaustive)]
-pub struct MissingConditionsError;
-
-impl Display for MissingConditionsError {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Push rule has no conditions.")
-    }
-}
-
-impl Error for MissingConditionsError {}
-
-impl TryFrom<AnyPushRule> for ConditionalPushRule {
-    type Error = MissingConditionsError;
-
-    fn try_from(push_rule: AnyPushRule) -> Result<Self, Self::Error> {
-        if let AnyPushRule {
-            actions,
-            default,
-            enabled,
-            rule_id,
-            conditions: Some(conditions),
-            ..
-        } = push_rule
-        {
-            Ok(ConditionalPushRule { actions, default, enabled, rule_id, conditions })
-        } else {
-            Err(MissingConditionsError)
-        }
-    }
-}