`9694ee5`

Use osascript for macOS reminders

Authored by

espadonne 2 weeks ago

SHA: 9694ee567d53ca48480d5ffa3ee53ce16f8ca87f
Parents: adeab44
Tree: 56cc91d

3 changed files

Status	File	+	-
M	`README.md`	4	2
M	`src/cli.rs`	47	6
M	`src/reminders.rs`	83	6

README.mdmodified

  rcal reminders install [--events-file PATH]
  rcal reminders uninstall
  rcal reminders status
 -rcal reminders test
 +rcal reminders test [--verbose]
  ```
  Options:
  all-day events, recurrence, location, notes, and multiple reminder offsets.
  Reminder notifications are delivered by a user-level background service. Use
  `rcal reminders install` to install it, `rcal reminders status` to inspect it,
 -and `rcal reminders test` to send a test notification.
 +and `rcal reminders test` to send a test notification. On macOS, notification
 +delivery uses `osascript` because it is more reliable for CLI-launched
 +notifications than the generic notification backend.
  ## Layout

src/cli.rsmodified

      },
      calendar::CalendarDate,
      reminders::{
 -        ReminderDaemonConfig, ReminderError, SystemNotifier, default_state_file, run_daemon,
 -        run_once, test_notification,
 +        ReminderDaemonConfig, ReminderError, SystemNotifier, default_state_file,
 +        notification_backend_name, run_daemon, run_once, test_notification,
      },
      services::{
          ServiceConfig, ServiceError, SystemCommandRunner, install_service, service_status,
      "  rcal reminders install [--events-file PATH]\n",
      "  rcal reminders uninstall\n",
      "  rcal reminders status\n",
 -    "  rcal reminders test\n\n",
 +    "  rcal reminders test [--verbose]\n\n",
      "Options:\n",
      "  --date YYYY-MM-DD                   Open with the given date selected.\n",
      "  --events-file PATH                  Read and write local user events at PATH.\n",
      Install { events_file: PathBuf },
      Uninstall,
      Status,
 -    Test,
 +    Test { verbose: bool },
+ }
  #[derive(Debug, Clone, PartialEq, Eq)]
          "install" => parse_reminder_install_args(args),
          "uninstall" => no_extra_reminder_args(args, ReminderCliAction::Uninstall),
          "status" => no_extra_reminder_args(args, ReminderCliAction::Status),
 -        "test" => no_extra_reminder_args(args, ReminderCliAction::Test),
 +        "test" => parse_reminder_test_args(args),
          "--help" | "-h" => Ok(CliAction::Help),
          _ => Err(CliError::UnknownReminderCommand(command.to_string())),
+     }
      }))
+ }
 +fn parse_reminder_test_args<I>(args: I) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut verbose = false;
++
 +    for arg in args {
 +        if arg == "--verbose" {
 +            verbose = true;
 +            continue;
 +        }
++
 +        return Err(CliError::UnknownArgument(display_arg(&arg)));
 +    }
++
 +    Ok(CliAction::Reminders(ReminderCliAction::Test { verbose }))
 +}
++
  fn no_extra_reminder_args<I>(args: I, action: ReminderCliAction) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
                  Err(err) => service_error_exit(stderr, err),
+             }
+         }
 -        ReminderCliAction::Test => {
 +        ReminderCliAction::Test { verbose } => {
              let mut notifier = SystemNotifier;
 +            if verbose {
 +                let _ = writeln!(
 +                    stdout,
 +                    "notification_backend={}",
 +                    notification_backend_name()
 +                );
 +            }
              match test_notification(&mut notifier) {
                  Ok(()) => {
                      let _ = writeln!(stdout, "sent test reminder notification");
          );
+     }
 +    #[test]
 +    fn reminder_test_accepts_verbose_diagnostic_flag() {
 +        let today = date(2026, Month::April, 23);
++
 +        let action = parse_args(
 +            [arg("reminders"), arg("test"), arg("--verbose")],
 +            today.into(),
 +        )
 +        .expect("parse succeeds");
++
 +        assert_eq!(
 +            action,
 +            CliAction::Reminders(ReminderCliAction::Test { verbose: true })
 +        );
 +    }
++
      #[test]
      fn reminder_args_are_rejected_when_invalid() {
          let today = date(2026, Month::April, 23);

src/reminders.rsmodified

  use directories::ProjectDirs;
  use fs2::FileExt;
 +#[cfg(not(target_os = "macos"))]
  use notify_rust::Notification;
  use serde::{Deserialize, Serialize};
 +#[cfg(target_os = "macos")]
 +use std::process::Command;
  use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time};
  use crate::{
  impl Notifier for SystemNotifier {
      fn notify(&mut self, reminder: &ReminderInstance) -> Result<(), ReminderError> {
 -        Notification::new()
 -            .summary(&reminder.notification_title())
 -            .body(&reminder.notification_body())
 -            .show()
 -            .map(|_| ())
 -            .map_err(|err| ReminderError::Notification(err.to_string()))
 +        show_system_notification(
 +            &reminder.notification_title(),
 +            &reminder.notification_body(),
 +        )
 +    }
 +}
++
 +pub const fn notification_backend_name() -> &'static str {
 +    #[cfg(target_os = "macos")]
 +    {
 +        "macos-osascript"
 +    }
 +    #[cfg(not(target_os = "macos"))]
 +    {
 +        "notify-rust"
+     }
+ }
 +#[cfg(target_os = "macos")]
 +fn show_system_notification(summary: &str, body: &str) -> Result<(), ReminderError> {
 +    let output = Command::new("osascript")
 +        .args(macos_display_notification_args(summary, body))
 +        .output()
 +        .map_err(|err| ReminderError::Notification(format!("osascript failed: {err}")))?;
++
 +    if output.status.success() {
 +        return Ok(());
 +    }
++
 +    let stderr = String::from_utf8_lossy(&output.stderr);
 +    Err(ReminderError::Notification(format!(
 +        "osascript exited with {}: {}",
 +        output.status,
 +        stderr.trim()
 +    )))
 +}
++
 +#[cfg(target_os = "macos")]
 +fn macos_display_notification_args(summary: &str, body: &str) -> Vec<String> {
 +    [
 +        "-e",
 +        "on run argv",
 +        "-e",
 +        "display notification (item 2 of argv) with title (item 1 of argv)",
 +        "-e",
 +        "end run",
 +        summary,
 +        body,
 +    ]
 +    .into_iter()
 +    .map(str::to_string)
 +    .collect()
 +}
++
 +#[cfg(not(target_os = "macos"))]
 +fn show_system_notification(summary: &str, body: &str) -> Result<(), ReminderError> {
 +    Notification::new()
 +        .summary(summary)
 +        .body(body)
 +        .show()
 +        .map(|_| ())
 +        .map_err(|err| ReminderError::Notification(err.to_string()))
 +}
++
  pub fn default_state_file() -> PathBuf {
      if let Some(project_dirs) = ProjectDirs::from("com", "tenseleyFlow", "rcal") {
          if let Some(state_dir) = project_dirs.state_dir() {
          assert!(reminder.notification_body().contains("Starts at 09:00"));
          assert!(reminder.notification_body().contains("Location: Room 1"));
+     }
++
 +    #[cfg(target_os = "macos")]
 +    #[test]
 +    fn macos_notification_uses_osascript_with_separate_user_text_args() {
 +        let args = macos_display_notification_args(
 +            "Reminder: Planning \"review\"",
 +            "Starts now\nLocation: Room 1",
 +        );
++
 +        assert_eq!(args[0], "-e");
 +        assert_eq!(args[1], "on run argv");
 +        assert_eq!(
 +            args[3],
 +            "display notification (item 2 of argv) with title (item 1 of argv)"
 +        );
 +        assert_eq!(args[5], "end run");
 +        assert_eq!(args[6], "Reminder: Planning \"review\"");
 +        assert_eq!(args[7], "Starts now\nLocation: Room 1");
 +    }
+ }