`6d67c7e`

feat(rules): add notification filtering and modification rules

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 6d67c7e600d4c6587e02fb0bbedaddab048eb734
Parents: 939c9b8
Tree: 34cfbcd

7 changed files

Status	File	+
M	`Cargo.toml`	1
M	`garnotify/Cargo.toml`	1
M	`garnotify/src/config.rs`	6
M	`garnotify/src/main.rs`	1
A	`garnotify/src/rules/actions.rs`	204
A	`garnotify/src/rules/matcher.rs`	113
A	`garnotify/src/rules/mod.rs`	209

Cargo.tomlmodified

  # Utilities
  dirs = "5.0"
  shellexpand = "3.0"
 +regex = "1.10"
  # Icon loading
  image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }

garnotify/Cargo.tomlmodified

  # Utilities
  dirs = { workspace = true }
  shellexpand = { workspace = true }
 +regex = { workspace = true }
  # Icon loading
  image = { workspace = true }

garnotify/src/config.rsmodified

  use serde::{Deserialize, Serialize};
  use std::path::PathBuf;
 +use crate::rules::Rule;
++
  /// Get the default configuration file path
  fn config_path() -> PathBuf {
      dirs::config_dir()
      pub appearance: AppearanceConfig,
      pub animation: AnimationConfig,
      pub history: HistoryConfig,
 +    /// Notification rules (use [[rules]] in TOML)
 +    #[serde(rename = "rules", default)]
 +    pub rules: Vec<Rule>,
+ }
  impl Default for Config {
              appearance: AppearanceConfig::default(),
              animation: AnimationConfig::default(),
              history: HistoryConfig::default(),
 +            rules: Vec::new(),
+         }
+     }
+ }

garnotify/src/main.rsmodified

  mod dbus;
  mod ipc;
  mod notification;
 +mod rules;
  mod ui;
  /// garnotify - Notification daemon for gar desktop

garnotify/src/rules/actions.rsadded

 +//! Rule actions for modifying notifications
++
 +use serde::{Deserialize, Serialize};
 +use tracing::debug;
++
 +use crate::notification::{Notification, Urgency};
++
 +/// Actions that can be performed on a matched notification
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "type", rename_all = "snake_case")]
 +pub enum RuleAction {
 +    /// Suppress the notification (don't show it)
 +    Suppress,
++
 +    /// Set the urgency level
 +    SetUrgency {
 +        urgency: String, // "low", "normal", "critical"
 +    },
++
 +    /// Override the timeout (in milliseconds, 0 = use default, -1 = never expire)
 +    SetTimeout { timeout: i32 },
++
 +    /// Replace the summary text
 +    SetSummary { summary: String },
++
 +    /// Replace the body text
 +    SetBody { body: String },
++
 +    /// Append text to the body
 +    AppendBody { text: String },
++
 +    /// Prepend text to the summary
 +    PrependSummary { text: String },
++
 +    /// Set a custom sound (hint)
 +    SetSound { sound: String },
++
 +    /// Mark as transient (won't be saved to history)
 +    SetTransient { transient: bool },
++
 +    /// Execute a shell command (the notification data is available as env vars)
 +    Exec { command: String },
 +}
++
 +impl RuleAction {
 +    /// Apply this action to a notification
 +    /// Returns None if the notification should be suppressed
 +    pub fn apply(&self, notification: &mut Notification) -> Option<()> {
 +        match self {
 +            RuleAction::Suppress => {
 +                debug!("Suppressing notification {}", notification.id);
 +                return None;
 +            }
++
 +            RuleAction::SetUrgency { urgency } => {
 +                let new_urgency = match urgency.to_lowercase().as_str() {
 +                    "low" => Urgency::Low,
 +                    "normal" => Urgency::Normal,
 +                    "critical" => Urgency::Critical,
 +                    _ => {
 +                        debug!("Invalid urgency '{}', ignoring", urgency);
 +                        return Some(());
 +                    }
 +                };
 +                debug!(
 +                    "Setting urgency for notification {} to {:?}",
 +                    notification.id, new_urgency
 +                );
 +                notification.hints.urgency = new_urgency;
 +            }
++
 +            RuleAction::SetTimeout { timeout } => {
 +                debug!(
 +                    "Setting timeout for notification {} to {}ms",
 +                    notification.id, timeout
 +                );
 +                notification.expire_timeout = *timeout;
 +            }
++
 +            RuleAction::SetSummary { summary } => {
 +                debug!(
 +                    "Setting summary for notification {} to '{}'",
 +                    notification.id, summary
 +                );
 +                notification.summary = summary.clone();
 +            }
++
 +            RuleAction::SetBody { body } => {
 +                debug!(
 +                    "Setting body for notification {} to '{}'",
 +                    notification.id, body
 +                );
 +                notification.body = body.clone();
 +            }
++
 +            RuleAction::AppendBody { text } => {
 +                debug!("Appending to body of notification {}", notification.id);
 +                notification.body.push_str(text);
 +            }
++
 +            RuleAction::PrependSummary { text } => {
 +                debug!("Prepending to summary of notification {}", notification.id);
 +                notification.summary = format!("{}{}", text, notification.summary);
 +            }
++
 +            RuleAction::SetSound { sound } => {
 +                debug!(
 +                    "Setting sound for notification {} to '{}'",
 +                    notification.id, sound
 +                );
 +                notification.hints.sound_name = Some(sound.clone());
 +            }
++
 +            RuleAction::SetTransient { transient } => {
 +                debug!(
 +                    "Setting transient for notification {} to {}",
 +                    notification.id, transient
 +                );
 +                notification.hints.transient = *transient;
 +            }
++
 +            RuleAction::Exec { command } => {
 +                debug!(
 +                    "Executing command for notification {}: {}",
 +                    notification.id, command
 +                );
 +                // Execute command in background with notification data as env vars
 +                let cmd = command.clone();
 +                let app_name = notification.app_name.clone();
 +                let summary = notification.summary.clone();
 +                let body = notification.body.clone();
 +                let id = notification.id;
++
 +                std::thread::spawn(move || {
 +                    let result = std::process::Command::new("sh")
 +                        .arg("-c")
 +                        .arg(&cmd)
 +                        .env("NOTIFICATION_ID", id.to_string())
 +                        .env("NOTIFICATION_APP", &app_name)
 +                        .env("NOTIFICATION_SUMMARY", &summary)
 +                        .env("NOTIFICATION_BODY", &body)
 +                        .output();
++
 +                    if let Err(e) = result {
 +                        tracing::warn!("Failed to execute rule command '{}': {}", cmd, e);
 +                    }
 +                });
 +            }
 +        }
++
 +        Some(())
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_suppress_action() {
 +        let action = RuleAction::Suppress;
 +        let mut notif = Notification::default();
 +        assert!(action.apply(&mut notif).is_none());
 +    }
++
 +    #[test]
 +    fn test_set_urgency() {
 +        let action = RuleAction::SetUrgency {
 +            urgency: "critical".to_string(),
 +        };
 +        let mut notif = Notification::default();
 +        assert!(action.apply(&mut notif).is_some());
 +        assert_eq!(notif.hints.urgency, Urgency::Critical);
 +    }
++
 +    #[test]
 +    fn test_set_timeout() {
 +        let action = RuleAction::SetTimeout { timeout: 10000 };
 +        let mut notif = Notification::default();
 +        action.apply(&mut notif);
 +        assert_eq!(notif.expire_timeout, 10000);
 +    }
++
 +    #[test]
 +    fn test_set_summary() {
 +        let action = RuleAction::SetSummary {
 +            summary: "New Summary".to_string(),
 +        };
 +        let mut notif = Notification::default();
 +        action.apply(&mut notif);
 +        assert_eq!(notif.summary, "New Summary");
 +    }
++
 +    #[test]
 +    fn test_prepend_summary() {
 +        let action = RuleAction::PrependSummary {
 +            text: "[Important] ".to_string(),
 +        };
 +        let mut notif = Notification::default();
 +        notif.summary = "Original".to_string();
 +        action.apply(&mut notif);
 +        assert_eq!(notif.summary, "[Important] Original");
 +    }
 +}

garnotify/src/rules/matcher.rsadded

 +//! Pattern matching for notification rules
 +//!
 +//! Supports glob patterns (* and ?) and regex (prefixed with ~)
++
 +use regex::Regex;
++
 +/// Pattern matcher for rule conditions
 +pub struct Matcher;
++
 +impl Matcher {
 +    /// Check if a pattern matches a string
 +    ///
 +    /// Pattern types:
 +    /// - Simple string: exact match (case-insensitive)
 +    /// - Glob pattern: * matches any chars, ? matches single char
 +    /// - Regex: prefix with ~ (e.g., "~.*error.*")
 +    pub fn matches(pattern: &str, text: &str) -> bool {
 +        if pattern.is_empty() {
 +            return true;
 +        }
++
 +        // Regex pattern (starts with ~)
 +        if let Some(regex_pattern) = pattern.strip_prefix('~') {
 +            return Self::matches_regex(regex_pattern, text);
 +        }
++
 +        // Glob pattern (contains * or ?)
 +        if pattern.contains('*') || pattern.contains('?') {
 +            return Self::matches_glob(pattern, text);
 +        }
++
 +        // Simple case-insensitive substring match
 +        text.to_lowercase().contains(&pattern.to_lowercase())
 +    }
++
 +    /// Match using a regex pattern
 +    fn matches_regex(pattern: &str, text: &str) -> bool {
 +        match Regex::new(pattern) {
 +            Ok(re) => re.is_match(text),
 +            Err(_) => {
 +                // Invalid regex, fall back to literal match
 +                text.contains(pattern)
 +            }
 +        }
 +    }
++
 +    /// Match using a glob pattern
 +    fn matches_glob(pattern: &str, text: &str) -> bool {
 +        let pattern = pattern.to_lowercase();
 +        let text = text.to_lowercase();
++
 +        // Convert glob to regex
 +        let mut regex_pattern = String::from("^");
 +        for ch in pattern.chars() {
 +            match ch {
 +                '*' => regex_pattern.push_str(".*"),
 +                '?' => regex_pattern.push('.'),
 +                // Escape regex special characters
 +                '.' | '+' | '(' | ')' | '[' | ']' | '{' | '}' | '^' | '$' | '|' | '\\' => {
 +                    regex_pattern.push('\\');
 +                    regex_pattern.push(ch);
 +                }
 +                _ => regex_pattern.push(ch),
 +            }
 +        }
 +        regex_pattern.push('$');
++
 +        match Regex::new(&regex_pattern) {
 +            Ok(re) => re.is_match(&text),
 +            Err(_) => false,
 +        }
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_simple_match() {
 +        assert!(Matcher::matches("firefox", "Firefox"));
 +        assert!(Matcher::matches("Firefox", "Mozilla Firefox"));
 +        assert!(!Matcher::matches("chrome", "Firefox"));
 +    }
++
 +    #[test]
 +    fn test_glob_star() {
 +        assert!(Matcher::matches("fire*", "Firefox"));
 +        assert!(Matcher::matches("*fox", "Firefox"));
 +        assert!(Matcher::matches("*ire*", "Firefox"));
 +        assert!(!Matcher::matches("chrome*", "Firefox"));
 +    }
++
 +    #[test]
 +    fn test_glob_question() {
 +        assert!(Matcher::matches("Firefo?", "Firefox"));
 +        assert!(Matcher::matches("?irefox", "Firefox"));
 +        assert!(!Matcher::matches("Firefo?", "Firefoxx"));
 +    }
++
 +    #[test]
 +    fn test_regex() {
 +        assert!(Matcher::matches("~[Ff]irefox", "Firefox"));
 +        assert!(Matcher::matches("~[Ff]irefox", "firefox"));
 +        assert!(Matcher::matches("~.*error.*", "An error occurred"));
 +        assert!(!Matcher::matches("~^Chrome$", "Firefox"));
 +    }
++
 +    #[test]
 +    fn test_empty_pattern() {
 +        assert!(Matcher::matches("", "anything"));
 +    }
 +}

garnotify/src/rules/mod.rsadded

 +//! Notification rules system
 +//!
 +//! Allows filtering and modifying notifications based on pattern matching.
++
 +mod actions;
 +mod matcher;
++
 +pub use actions::RuleAction;
 +pub use matcher::Matcher;
++
 +use serde::{Deserialize, Serialize};
 +use tracing::{debug, info};
++
 +use crate::notification::Notification;
++
 +/// A notification rule that can match and modify notifications
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct Rule {
 +    /// Rule name (for enable/disable)
 +    pub name: String,
 +    /// Whether this rule is enabled
 +    #[serde(default = "default_enabled")]
 +    pub enabled: bool,
 +    /// Matcher conditions (all must match)
 +    #[serde(default)]
 +    pub match_app_name: Option<String>,
 +    #[serde(default)]
 +    pub match_summary: Option<String>,
 +    #[serde(default)]
 +    pub match_body: Option<String>,
 +    #[serde(default)]
 +    pub match_urgency: Option<String>,
 +    /// Actions to perform when matched
 +    #[serde(default)]
 +    pub actions: Vec<RuleAction>,
 +}
++
 +fn default_enabled() -> bool {
 +    true
 +}
++
 +impl Rule {
 +    /// Check if this rule matches a notification
 +    pub fn matches(&self, notification: &Notification) -> bool {
 +        if !self.enabled {
 +            return false;
 +        }
++
 +        // All specified conditions must match
 +        if let Some(ref pattern) = self.match_app_name {
 +            if !Matcher::matches(pattern, &notification.app_name) {
 +                return false;
 +            }
 +        }
++
 +        if let Some(ref pattern) = self.match_summary {
 +            if !Matcher::matches(pattern, &notification.summary) {
 +                return false;
 +            }
 +        }
++
 +        if let Some(ref pattern) = self.match_body {
 +            if !Matcher::matches(pattern, &notification.body) {
 +                return false;
 +            }
 +        }
++
 +        if let Some(ref pattern) = self.match_urgency {
 +            let urgency_str = format!("{:?}", notification.hints.urgency).to_lowercase();
 +            if !Matcher::matches(pattern, &urgency_str) {
 +                return false;
 +            }
 +        }
++
 +        true
 +    }
++
 +    /// Apply this rule's actions to a notification
 +    /// Returns None if the notification should be suppressed
 +    pub fn apply(&self, notification: &mut Notification) -> Option<()> {
 +        for action in &self.actions {
 +            match action.apply(notification) {
 +                Some(()) => {}
 +                None => {
 +                    debug!("Rule '{}' suppressed notification {}", self.name, notification.id);
 +                    return None;
 +                }
 +            }
 +        }
 +        Some(())
 +    }
 +}
++
 +/// Rule engine that manages and applies rules
 +#[derive(Debug, Default)]
 +pub struct RuleEngine {
 +    rules: Vec<Rule>,
 +}
++
 +impl RuleEngine {
 +    /// Create a new rule engine
 +    pub fn new() -> Self {
 +        Self { rules: Vec::new() }
 +    }
++
 +    /// Create a rule engine with initial rules
 +    pub fn with_rules(rules: Vec<Rule>) -> Self {
 +        info!("Loaded {} notification rules", rules.len());
 +        Self { rules }
 +    }
++
 +    /// Add a rule
 +    pub fn add_rule(&mut self, rule: Rule) {
 +        self.rules.push(rule);
 +    }
++
 +    /// Get all rules
 +    pub fn rules(&self) -> &[Rule] {
 +        &self.rules
 +    }
++
 +    /// Get mutable reference to rules
 +    pub fn rules_mut(&mut self) -> &mut Vec<Rule> {
 +        &mut self.rules
 +    }
++
 +    /// Enable a rule by name
 +    pub fn enable_rule(&mut self, name: &str) -> bool {
 +        for rule in &mut self.rules {
 +            if rule.name == name {
 +                rule.enabled = true;
 +                info!("Enabled rule '{}'", name);
 +                return true;
 +            }
 +        }
 +        false
 +    }
++
 +    /// Disable a rule by name
 +    pub fn disable_rule(&mut self, name: &str) -> bool {
 +        for rule in &mut self.rules {
 +            if rule.name == name {
 +                rule.enabled = false;
 +                info!("Disabled rule '{}'", name);
 +                return true;
 +            }
 +        }
 +        false
 +    }
++
 +    /// Process a notification through all rules
 +    /// Returns None if the notification should be suppressed
 +    pub fn process(&self, notification: &mut Notification) -> Option<()> {
 +        for rule in &self.rules {
 +            if rule.matches(notification) {
 +                debug!(
 +                    "Rule '{}' matched notification {} (app='{}', summary='{}')",
 +                    rule.name, notification.id, notification.app_name, notification.summary
 +                );
 +                if rule.apply(notification).is_none() {
 +                    return None;
 +                }
 +            }
 +        }
 +        Some(())
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_rule_matching() {
 +        let rule = Rule {
 +            name: "test".to_string(),
 +            enabled: true,
 +            match_app_name: Some("Firefox".to_string()),
 +            match_summary: None,
 +            match_body: None,
 +            match_urgency: None,
 +            actions: vec![],
 +        };
++
 +        let mut notif = Notification::default();
 +        notif.app_name = "Firefox".to_string();
 +        assert!(rule.matches(&notif));
++
 +        notif.app_name = "Chrome".to_string();
 +        assert!(!rule.matches(&notif));
 +    }
++
 +    #[test]
 +    fn test_disabled_rule() {
 +        let rule = Rule {
 +            name: "test".to_string(),
 +            enabled: false,
 +            match_app_name: Some("Firefox".to_string()),
 +            match_summary: None,
 +            match_body: None,
 +            match_urgency: None,
 +            actions: vec![],
 +        };
++
 +        let mut notif = Notification::default();
 +        notif.app_name = "Firefox".to_string();
 +        assert!(!rule.matches(&notif));
 +    }
 +}