Skip to main content

kasl/libs/messages/
mod.rs

1//! All user-facing text, one enum away from the code that prints it.
2//!
3//! Keeping every string behind [`Message`] means the wording lives in one
4//! place, the compiler checks the parameters, and a future locale layer has a
5//! single seam to hook into.
6//!
7//! ```rust
8//! use kasl::libs::messages::{Message, success, error};
9//! use kasl::{msg_info, msg_error, msg_success};
10//!
11//! msg_success!(Message::TaskCreated);
12//! msg_error!(Message::ConfigSaveError);
13//! msg_info!(Message::MonitorStarted {
14//!     pause_threshold: 60,
15//!     poll_interval: 500,
16//!     activity_threshold: 30,
17//! });
18//! ```
19
20pub mod display;
21pub mod macros;
22pub mod types;
23
24pub use types::Message;
25
26/// Prefixes the message with the success mark.
27///
28/// ```rust
29/// use kasl::libs::messages::{Message, success};
30///
31/// let message = success(Message::TaskCreated);
32/// println!("{}", message); // "✅ Task created successfully"
33///
34/// let report_message = success(Message::DailyReportSent("2025-01-15".to_string()));
35/// println!("{}", report_message);
36/// ```
37///
38/// The [`crate::msg_success`] macro prints the same thing directly:
39/// ```rust
40/// use kasl::msg_success;
41/// use kasl::libs::messages::Message;
42///
43/// msg_success!(Message::TaskCreated);
44/// ```
45pub fn success(msg: Message) -> String {
46    format!("✅ {}", msg)
47}
48
49/// Prefixes the message with the error mark.
50///
51/// ```rust
52/// use kasl::libs::messages::{Message, error};
53///
54/// let message = error(Message::ConfigSaveError);
55/// println!("{}", message); // "❌ Failed to save configuration"
56///
57/// let detailed = error(Message::GitlabFetchFailed("Network timeout".to_string()));
58/// println!("{}", detailed);
59/// ```
60///
61/// ```rust
62/// use kasl::msg_error;
63/// use kasl::libs::messages::Message;
64/// use anyhow::Result;
65///
66/// # fn operation() -> Result<()> { Ok(()) }
67/// fn save_config() -> Result<()> {
68///     if let Err(_) = operation() {
69///         msg_error!(Message::ConfigSaveError);
70///         return Err(anyhow::anyhow!("Configuration save failed"));
71///     }
72///     Ok(())
73/// }
74/// ```
75pub fn error(msg: Message) -> String {
76    format!("❌ {}", msg)
77}
78
79/// Prefixes the message with the warning mark.
80///
81/// ```rust
82/// use kasl::libs::messages::{Message, warning};
83///
84/// let message = warning(Message::AutostartRequiresAdmin);
85/// println!("{}", message);
86///
87/// let data_warning = warning(Message::ShortIntervalsDetected(3, "45 minutes".to_string()));
88/// println!("{}", data_warning);
89/// ```
90///
91/// ```rust
92/// use kasl::msg_warning;
93/// use kasl::libs::messages::Message;
94///
95/// let count = 3;
96/// let duration = "45 minutes".to_string();
97/// msg_warning!(Message::ShortIntervalsDetected(count, duration));
98/// ```
99pub fn warning(msg: Message) -> String {
100    format!("⚠️  {}", msg)
101}
102
103/// Prefixes the message with the info mark.
104///
105/// ```rust
106/// use kasl::libs::messages::{Message, info};
107///
108/// let message = info(Message::MonitorStarted {
109///     pause_threshold: 60,
110///     poll_interval: 500,
111///     activity_threshold: 30,
112/// });
113/// println!("{}", message);
114///
115/// let config_info = info(Message::AutostartStatus("enabled".to_string()));
116/// println!("{}", config_info); // "ℹ️  Autostart is currently: enabled"
117/// ```
118///
119/// ```rust
120/// use kasl::{msg_info, msg_success};
121/// use kasl::libs::messages::Message;
122///
123/// msg_info!(Message::WatcherStartingForeground);
124/// msg_success!(Message::WatcherStarted(12345));
125/// ```
126pub fn info(msg: Message) -> String {
127    format!("ℹ️  {}", msg)
128}
129
130/// Wraps the message in blank lines for emphasis; use sparingly.
131///
132/// ```rust
133/// use kasl::libs::messages::{Message, wrap_msg};
134///
135/// let message = wrap_msg(Message::ConfirmDeleteAllTodayTasksFinal);
136/// println!("{}", message);
137///
138/// let summary = wrap_msg(Message::AllMigrationsCompleted);
139/// println!("{}", summary);
140/// ```
141///
142/// ```rust
143/// use kasl::libs::messages::{Message, success, wrap_msg};
144///
145/// let emphasized_success = format!("\n{}\n", success(Message::OperationCompleted));
146/// let wrapped_success = wrap_msg(Message::OperationCompleted);
147/// ```
148pub fn wrap_msg(msg: Message) -> String {
149    format!("\n{}\n", msg)
150}