macltok

public

Star0

Fork 0

Watch0

80 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `e9af9e0e0f31`

tarball

atagen <boss@atagen.co>2026-10-25 11:09 UTC

2 files changed+121-51

notifications: add only the highlight to the keyword's own rule

Reading NotificationSettings::ruleset to find the rule depended on the sdk's cache, and rewriting the actions added notify and a sound to a rule the user had made quiet. The sdk's add_keyword creates the content rule under the keyword as its id, so the rule is fetched by that id and gains a highlight tweak with its other actions kept.

Modified file: src/engine/commands.rs+42 additions−48 deletions@@ -4,14 +4,15 @@ use futures_util::FutureExt;
 use matrix_sdk::encryption::verification::VerificationRequest;
 use matrix_sdk::{
     Client,
-    notification_settings::{
-        IsEncrypted, IsOneToOne, NotificationSettings, RoomNotificationMode as SdkMode,
-    },
+    notification_settings::{IsEncrypted, IsOneToOne, RoomNotificationMode as SdkMode},
     ruma::{
         OwnedDeviceId, OwnedEventId, OwnedMxcUri, RoomId, TransactionId,
-        api::client::{push::set_pushrule_actions, receipt::create_receipt::v3::ReceiptType},
+        api::client::{
+            push::{get_pushrule, set_pushrule_actions},
+            receipt::create_receipt::v3::ReceiptType,
+        },
         events::receipt::ReceiptThread,
-        push::{Action, HighlightTweakValue, RuleKind, SoundTweakValue, Tweak},
+        push::{Action, HighlightTweakValue, RuleKind, Tweak},
     },
     send_queue::{LocalEchoContent, SendHandle},
 };
@@ -140,7 +141,7 @@ async fn notification(client: &Client, command: NotificationCommand) -> Result<(
         }
         NotificationCommand::AddKeyword(keyword) => {
             match settings.add_keyword(keyword.clone()).await {
-                Ok(()) => return highlight_keyword(client, &settings, &keyword).await,
+                Ok(()) => return highlight_keyword(client, &keyword).await,
                 Err(error) => Err(error),
             }
         }
@@ -156,53 +157,46 @@ async fn notification(client: &Client, command: NotificationCommand) -> Result<(
 }
 
 /// sdk keyword rules carry only notify and a sound, while Element's loud keywords also
-/// highlight, which is what lets the inbox keep them as mentions
-async fn highlight_keyword(
-    client: &Client,
-    settings: &NotificationSettings,
-    keyword: &str,
-) -> Result<(), Error> {
-    let ruleset = settings.ruleset().await;
-    for rule in ruleset
-        .content
-        .iter()
-        .filter(|rule| !rule.default && rule.pattern == keyword)
-        .filter(|rule| !rule.actions.iter().any(Action::is_highlight))
+/// highlight, which is what lets the inbox keep them as mentions. The sdk names a
+/// keyword's content rule after the keyword itself, a rule under another id is left
+/// alone.
+async fn highlight_keyword(client: &Client, keyword: &str) -> Result<(), Error> {
+    let failed = |source| Error::from_http("highlighting a notification keyword failed", source);
+    let rule = match client
+        .send(get_pushrule::v3::Request::new(
+            RuleKind::Content,
+            keyword.to_owned(),
+        ))
+        .await
     {
-        client
-            .send(set_pushrule_actions::v3::Request::new(
-                RuleKind::Content,
-                rule.rule_id.clone(),
-                keyword_actions(&rule.actions),
-            ))
-            .await
-            .map_err(|source| {
-                Error::from_sdk("highlighting a notification keyword failed", source.into())
-            })?;
+        Ok(response) => response.rule,
+        Err(error)
+            if error
+                .as_client_api_error()
+                .is_some_and(|error| error.status_code.as_u16() == 404) =>
+        {
+            return Ok(());
+        }
+        Err(error) => return Err(failed(error)),
+    };
+    if rule.actions.iter().any(Action::is_highlight) {
+        return Ok(());
     }
-    Ok(())
-}
-
-fn keyword_actions(existing: &[Action]) -> Vec<Action> {
-    let mut actions: Vec<_> = existing
-        .iter()
+    let mut actions: Vec<_> = rule
+        .actions
+        .into_iter()
         .filter(|action| !matches!(action, Action::SetTweak(Tweak::Highlight(_))))
-        .cloned()
         .collect();
-    if !actions
-        .iter()
-        .any(|action| matches!(action, Action::Notify))
-    {
-        actions.insert(0, Action::Notify);
-    }
-    if !actions
-        .iter()
-        .any(|action| matches!(action, Action::SetTweak(Tweak::Sound(_))))
-    {
-        actions.push(Action::SetTweak(Tweak::Sound(SoundTweakValue::Default)));
-    }
     actions.push(Action::SetTweak(Tweak::Highlight(HighlightTweakValue::Yes)));
-    actions
+    client
+        .send(set_pushrule_actions::v3::Request::new(
+            RuleKind::Content,
+            keyword.to_owned(),
+            actions,
+        ))
+        .await
+        .map_err(failed)?;
+    Ok(())
 }
 
 const fn sdk_mode(mode: RoomNotificationMode) -> SdkMode {

Modified file: tests/mentions_inbox.rs+79 additions−3 deletions@@ -28,7 +28,7 @@ use support::receive_until;
 use support::shut_down;
 use wiremock::{
     Mock, Request, Respond, ResponseTemplate,
-    matchers::{body_string_contains, method, path, path_regex, query_param},
+    matchers::{method, path, path_regex, query_param},
 };
 
 #[cfg(feature = "serde")]
@@ -864,6 +864,26 @@ async fn highlighting_keywords_are_mentions_and_quiet_ones_are_not() {
     shut_down(&handle, &mut events, running).await;
 }
 
+fn actions_are(expected: Value) -> impl Fn(&Request) -> bool + Send + Sync + 'static {
+    move |request: &Request| {
+        serde_json::from_slice::<Value>(&request.body).is_ok_and(|body| body["actions"] == expected)
+    }
+}
+
+async fn mount_keyword_rule(server: &MatrixMockServer, actions: Value) {
+    Mock::given(method("GET"))
+        .and(path("/_matrix/client/v3/pushrules/global/content/deploy"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "rule_id": "deploy",
+            "pattern": "deploy",
+            "default": false,
+            "enabled": true,
+            "actions": actions,
+        })))
+        .mount(server.server())
+        .await;
+}
+
 #[tokio::test]
 async fn adding_a_keyword_gives_its_rule_a_highlight() {
     let server = MatrixMockServer::new().await;
@@ -875,12 +895,68 @@ async fn adding_a_keyword_gives_its_rule_a_highlight() {
         .expect(1)
         .mount(server.server())
         .await;
+    mount_keyword_rule(
+        &server,
+        json!(["notify", {"set_tweak": "sound", "value": "default"}]),
+    )
+    .await;
     Mock::given(method("PUT"))
         .and(path(
             "/_matrix/client/v3/pushrules/global/content/deploy/actions",
         ))
-        .and(body_string_contains("highlight"))
-        .and(body_string_contains("notify"))
+        .and(actions_are(json!([
+            "notify",
+            {"set_tweak": "sound", "value": "default"},
+            {"set_tweak": "highlight"},
+        ])))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))
+        .expect(1)
+        .mount(server.server())
+        .await;
+    SlidingFeed::new(room_id.to_owned(), Vec::new())
+        .mount(&server)
+        .await;
+
+    let (engine, handle, mut events) = Engine::from_client(client, EngineConfig::default())
+        .await
+        .unwrap();
+    let running = tokio::spawn(engine.run());
+    handle.add_notification_keyword("deploy").await.unwrap();
+    shut_down(&handle, &mut events, running).await;
+    server.server().verify().await;
+}
+
+#[tokio::test]
+async fn a_quiet_keyword_rule_only_gains_the_highlight() {
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+    let own_user = client.user_id().unwrap().to_owned();
+    let room_id = room_id!("!quiet-keyword-rule:localhost");
+    let mut rules = Ruleset::server_default(&own_user);
+    rules.content.insert(
+        NewPatternedPushRule::new("deploy".to_owned(), "deploy".to_owned(), Vec::new()).into(),
+    );
+    server
+        .mock_sync()
+        .ok_and_run(&client, {
+            let own_user = own_user.clone();
+            move |builder| {
+                let factory = EventFactory::new().room(room_id);
+                builder.add_global_account_data(factory.push_rules(rules));
+                builder.add_joined_room(
+                    JoinedRoomBuilder::new(room_id).add_state_event(factory.member(&own_user)),
+                );
+            }
+        })
+        .await;
+    mount_keyword_rule(&server, json!([])).await;
+    Mock::given(method("PUT"))
+        .and(path(
+            "/_matrix/client/v3/pushrules/global/content/deploy/actions",
+        ))
+        .and(actions_are(
+            json!([{"set_tweak": "highlight"}]),
+        ))
         .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))
         .expect(1)
         .mount(server.server())

macltok

Commit e9af9e0e0f31

Commit `e9af9e0e0f31`