macltok

public

Star0

Fork 0

Watch0

76 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `96680d38cc31`

tarball

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

4 files changed+138-5

mentions: keep highlighting keywords as Keyword mentions

An event that notifies and highlights with no Direct, Reply or Room reason was dropped, so loud keywords never reached the inbox. MentionReason::Keyword keeps them with the same capture and read state as any other mention.

Modified file: docs/mentions-discovery.md+5 additions−2 deletions@@ -196,8 +196,11 @@ A room mute can suppress evaluated notification actions while structured
 mention metadata remains present. The classifier retains explicit user
 mentions in muted rooms and marks notification delivery as suppressed. Room-wide
 reasons require the relevant push conditions and sender power level. Missing
-authorisation context remains unresolved for reevaluation. Keyword-only
-notifications are outside the inbox. The classifier excludes the signed-in
+authorisation context remains unresolved for reevaluation. An event that
+notifies and highlights with no other reason, such as a loud keyword, enters the
+inbox as `Keyword`. `add_notification_keyword` gives keyword rules a highlight
+tweak, and upgrades an existing rule for the pattern that lacks one, since the
+SDK's keyword rules only notify and play a sound. The classifier excludes the signed-in
 user's own events even when they contain explicit mention metadata.
 
 The existing `NotificationClient` combines notification evaluation with

Modified file: src/mentions/service.rs+3 additions@@ -988,6 +988,9 @@ impl Service {
                 _ => {}
             }
         }
+        if reasons.is_empty() && notify && highlight {
+            reasons.push(MentionReason::Keyword);
+        }
         (reasons, !notify, unresolved)
     }
 

Modified file: src/mentions_model.rs+3 additions@@ -17,6 +17,9 @@ pub enum MentionReason {
     Direct,
     Reply,
     Room,
+    /// a highlighting push rule matched with no structured mention or reply, such as a
+    /// notification keyword
+    Keyword,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

Modified file: tests/mentions_inbox.rs+127 additions−3 deletions@@ -11,21 +11,24 @@ use std::{
 
 #[cfg(feature = "sqlite")]
 use macltok::{EncryptedSessionStore, PasswordLogin, Restore, Session, SessionStore, StoreConfig};
-use macltok::{Engine, EngineConfig, Event, MentionsPage};
+use macltok::{Engine, EngineConfig, Event, MentionReason, MentionsPage};
 use matrix_sdk::{
     Client,
     ruma::{OwnedRoomId, OwnedUserId, event_id, events::Mentions, room_id, user_id},
     test_utils::mocks::{MatrixMockServer, RoomContextResponseTemplate},
 };
 use matrix_sdk_test::{ALICE, JoinedRoomBuilder, event_factory::EventFactory};
-use ruma::push::{EventMatchConditionData, NewConditionalPushRule, PushCondition, Ruleset};
+use ruma::push::{
+    Action, EventMatchConditionData, HighlightTweakValue, NewConditionalPushRule,
+    NewPatternedPushRule, PushCondition, Ruleset, SoundTweakValue, Tweak,
+};
 use serde_json::{Value, json};
 #[cfg(feature = "sqlite")]
 use support::receive_until;
 use support::shut_down;
 use wiremock::{
     Mock, Request, Respond, ResponseTemplate,
-    matchers::{method, path, path_regex, query_param},
+    matchers::{body_string_contains, method, path, path_regex, query_param},
 };
 
 #[cfg(feature = "serde")]
@@ -774,6 +777,127 @@ async fn event_context_uses_independent_direction_limits_and_saved_mention_conte
     server.server().verify().await;
 }
 
+#[tokio::test]
+async fn highlighting_keywords_are_mentions_and_quiet_ones_are_not() {
+    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!("!keyword-policy:localhost");
+    let sender = user_id!("@alice:localhost");
+    let mut rules = Ruleset::server_default(&own_user);
+    let notify = [
+        Action::Notify,
+        Action::SetTweak(Tweak::Sound(SoundTweakValue::Default)),
+    ];
+    let mut loud = notify.to_vec();
+    loud.push(Action::SetTweak(Tweak::Highlight(HighlightTweakValue::Yes)));
+    rules
+        .content
+        .insert(NewPatternedPushRule::new("deploy".to_owned(), "deploy".to_owned(), loud).into());
+    rules.content.insert(
+        NewPatternedPushRule::new("lunch".to_owned(), "lunch".to_owned(), notify.to_vec()).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;
+    let feed = SlidingFeed::new(
+        room_id.to_owned(),
+        vec![
+            message(
+                "$keyword",
+                sender.as_str(),
+                1_000,
+                "the deploy is done",
+                None,
+            ),
+            message("$quiet", sender.as_str(), 2_000, "lunch anyone", None),
+            message("$plain", sender.as_str(), 3_000, "nothing to see", None),
+            message(
+                "$keyword-direct",
+                sender.as_str(),
+                4_000,
+                "deploy now",
+                Some(own_user.as_str()),
+            ),
+            message("$own-keyword", own_user.as_str(), 5_000, "my deploy", None),
+        ],
+    );
+    feed.mount(&server).await;
+
+    let (engine, handle, mut events) = Engine::from_client(
+        client,
+        EngineConfig::default().with_initial_history_limit(0),
+    )
+    .await
+    .unwrap();
+    let running = tokio::spawn(engine.run());
+
+    let page = mentions_page(&mut events, room_id, |page| page.entries.len() >= 2).await;
+    assert_eq!(
+        entry_ids(&page),
+        HashSet::from(["$keyword".to_owned(), "$keyword-direct".to_owned()])
+    );
+    let reasons: BTreeMap<_, _> = page
+        .entries
+        .iter()
+        .map(|entry| (entry.key.event_id.to_string(), entry.reasons.clone()))
+        .collect();
+    assert_eq!(reasons["$keyword"], vec![MentionReason::Keyword]);
+    assert_eq!(reasons["$keyword-direct"], vec![MentionReason::Direct]);
+    assert_eq!(page.unread_count, 2);
+    assert!(
+        page.entries
+            .iter()
+            .all(|entry| !entry.notification_suppressed)
+    );
+
+    shut_down(&handle, &mut events, running).await;
+}
+
+#[tokio::test]
+async fn adding_a_keyword_gives_its_rule_a_highlight() {
+    let server = MatrixMockServer::new().await;
+    let room_id = room_id!("!keyword-rule:localhost");
+    let (client, _) = joined_client(&server, room_id).await;
+    Mock::given(method("PUT"))
+        .and(path("/_matrix/client/v3/pushrules/global/content/deploy"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))
+        .expect(1)
+        .mount(server.server())
+        .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"))
+        .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;
+}
+
 #[cfg(feature = "sqlite")]
 #[tokio::test]
 async fn sqlite_mentions_survive_engine_shutdown_and_session_resume() {

macltok

Commit 96680d38cc31

Commit `96680d38cc31`