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

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

Browse Source
This commit is contained in:
Kévin Commaille 2021-03-22 11:53:28 +01:00 committed by Jonas Platte
parent 22f7f28e1b
commit b79ef0303a
5 changed files with 176 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
ruma-client-api/src/r0/push.rs
View File

@ -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")]

7
ruma-client-api/src/r0/push/get_pushrule.rs
View File

@ -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 }
}
}

2
ruma-common/CHANGELOG.md
View File

@ -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)

55
ruma-common/src/push.rs
View File

@ -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 {
type Item = AnyPushRule;
// impl Iterator for RulesetIter {
// type Item = AnyPushRule;
fn next(&mut self) -> Option<Self::Item> {
self.override_
.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.sender.next().map(|x| x.0.into()))
.or_else(|| self.underride.next().map(|x| x.0.into()))
}
}
// fn next(&mut self) -> Option<Self::Item> {
// self.override_
// .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.sender.next().map(|x| x.0.into()))
// .or_else(|| self.underride.next().map(|x| x.0.into()))
// }
// }
impl IntoIterator for Ruleset {
type Item = AnyPushRule;
type IntoIter = RulesetIter;
// impl IntoIterator for Ruleset {
// type Item = AnyPushRule;
// type IntoIter = RulesetIter;
fn into_iter(self) -> Self::IntoIter {
RulesetIter {
content: self.content.into_iter(),
override_: self.override_.into_iter(),
room: self.room.into_iter(),
sender: self.sender.into_iter(),
underride: self.underride.into_iter(),
}
}
}
// fn into_iter(self) -> Self::IntoIter {
// RulesetIter {
// content: self.content.into_iter(),
// override_: self.override_.into_iter(),
// room: self.room.into_iter(),
// sender: self.sender.into_iter(),
// underride: self.underride.into_iter(),
// }
// }
// }
/// A trait for types that can be added in a Ruleset
pub trait RulesetMember: private::Sealed {

154
ruma-common/src/push/any_push_rule.rs
View File

@ -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)
}
}
}