Merge branch 'master' of github.com:szymon-jozef/libnotify-rs

fix: set messages next to crash during build

Cargo.lock

@@ -11,6 +11,56 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
 [[package]]
 name = "bindgen"
 version = "0.73.2"
@@ -72,6 +122,39 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "clap"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -229,6 +312,12 @@ dependencies = [
  "hashbrown",
 ]
 
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
 [[package]]
 name = "libc"
 version = "0.2.190"
@@ -247,9 +336,10 @@ dependencies = [
 
 [[package]]
 name = "libnotify-rs"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "bindgen",
+ "clap",
  "glib",
  "pkg-config",
  "serial_test",
@@ -298,6 +388,12 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -483,6 +579,12 @@ version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e"
 
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
 [[package]]
 name = "syn"
 version = "3.0.6"
@@ -558,6 +660,12 @@ version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "version-compare"
 version = "0.2.1"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libnotify-rs"
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 authors = [ "szymon_jozef"]
 description = "Rust bindings for libnotify"
@@ -11,6 +11,9 @@ license = "MIT"
 keywords = [ "bindings", "libnotify" ]
 build = "./build.rs"
 
+[dependencies]
+clap = {version = "4.6.7", optional = true}
+
 [build-dependencies]
 pkg-config = "0.3.34"
 bindgen = "0.73.2"
@@ -18,3 +21,6 @@ bindgen = "0.73.2"
 [dev-dependencies]
 glib = "0.22.10"
 serial_test = "4.0.1"
+
+[features]
+clap = [ "dep:clap" ]

README.md

@@ -27,9 +27,11 @@ Available at [github pages](https://szymon-jozef.github.io/libnotify-rs/libnotif
 ## Add to project
 Type in:
 ```bash
-cargo add --git "https://github.com/szymon-jozef/libnotify-rs"
+cargo add --git "https://github.com/szymon-jozef/libnotify-rs" --tag <desired version>
 ```
 
+Tag argument is optional, but encouraged.
+
 ### Nix flake
 For nix users, there is also a flake inside. If you want to use it add this to your flake:
 

build.rs

@@ -2,7 +2,9 @@ use std::env;
 use std::path::PathBuf;
 
 fn main() {
-    let library = pkg_config::Config::new().probe("libnotify").unwrap();
+    let library = pkg_config::Config::new()
+        .probe("libnotify")
+        .expect("Cannot locate libnotify. Is it installed?");
 
     let paths = library
         .include_paths
@@ -17,7 +19,8 @@ fn main() {
         .generate()
         .expect("Unable to generate bindings");
 
-    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let out_path =
+        PathBuf::from(env::var("OUT_DIR").expect("Out $OUT_DIR not set. Perhaps a bindgen error?"));
 
     bindings
         .write_to_file(out_path.join("bindings.rs"))

src/api/functions.rs

@@ -12,6 +12,9 @@ use super::libnotify::*;
 /// Initialized libnotify. This must be called before any other functions.
 ///
 /// Starting from 0.8, if the provided app_name is NULL, libnotify will try to figure it out from the running application. Before it was not allowed, and was causing libnotify not to be initialized.
+///
+/// # Errors
+/// This function can return LibnotifyError::{InitError, NulError}
 pub fn init<'a, T>(app_name: T) -> Result<(), LibnotifyError>
 where
     T: Into<Option<&'a str>>,
@@ -163,6 +166,9 @@ pub fn get_server_info() -> Option<ServerInfo> {
 */
 
 /// Sets the application name
+///
+/// # Errors
+/// This function can return LibnotifyError::NulError
 pub fn set_app_name(app_name: &str) -> Result<(), LibnotifyError> {
     let app_name_c = std::ffi::CString::new(app_name)?;
     unsafe { notify_set_app_name(app_name_c.as_ptr()) };
@@ -174,6 +180,9 @@ pub fn set_app_name(app_name: &str) -> Result<(), LibnotifyError> {
 /// Available since: 0.8.4
 ///
 /// app_icon is icon name or path to an image
+///
+/// # Errors
+/// This function can return LibnotifyError::NulError
 pub fn set_app_icon(app_icon: &str) -> Result<(), LibnotifyError> {
     let app_icon_c = std::ffi::CString::new(app_icon)?;
     unsafe { notify_set_app_icon(app_icon_c.as_ptr()) };

src/api/notification.rs

@@ -3,6 +3,7 @@ use crate::api::errors::LibnotifyError;
 use super::libnotify::*;
 
 #[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
 /// Notification urgency level. Refer to [libnotify docs](https://gnome.pages.gitlab.gnome.org/libnotify/enum.Urgency.html) for more info
 pub enum Urgency {
     /// Low urgency. Used for unimportant notifications
@@ -64,11 +65,7 @@ impl<'a> Notification {
     /// Create new notification.
     ///
     /// # Errors
-    /// This function will return an error if the supplied bytes contain an
-    /// internal 0 byte. The [`NulError`](https://doc.rust-lang.org/stable/alloc/ffi/c_str/struct.NulError.html) returned will contain the bytes as well as
-    /// the position of the nul byte.
-    ///
-    /// On libnotify fail it will return Err(&str.into). May change in the future.
+    /// This function can return LibnotifyError::{NewNotificationError, NulError}
     pub fn new<T, Y>(summary: &str, body: T, icon: Y) -> Result<Self, LibnotifyError>
     where
         T: Into<Option<&'a str>>,
@@ -104,6 +101,9 @@ impl<'a> Notification {
     /// `label` – label for user
     ///
     /// `callback` - any closure that accepts &str as an argument, where &str is action name.
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::NulError
     pub fn add_action<F>(
         &mut self,
         action: &str,
@@ -146,6 +146,9 @@ impl<'a> Notification {
     }
 
     /// Synchronously tells the notification server to hide the notification on the screen
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{AllocationError, GerrorError}
     pub fn close(&self) -> Result<(), LibnotifyError> {
         let mut gerror = std::ptr::null_mut() as *mut GError;
 
@@ -193,6 +196,9 @@ impl<'a> Notification {
     /// `set_app_icon()`.
     ///
     /// Available since: 0.8.4
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
     pub fn set_app_icon(&mut self, app_icon: &str) -> Result<(), LibnotifyError> {
         let app_icon_c = std::ffi::CString::new(app_icon)?;
         unsafe { notify_notification_set_app_icon(self.inner, app_icon_c.as_ptr()) };
@@ -205,6 +211,9 @@ impl<'a> Notification {
     /// If this function is not called, the application name will be set from the value used in init() or overridden with set_app_name().
     ///
     /// Available since: 0.7.3
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
     pub fn set_app_name(&mut self, app_name: &str) -> Result<(), LibnotifyError> {
         let app_name_c = std::ffi::CString::new(app_name)?;
         unsafe { notify_notification_set_app_name(self.inner, app_name_c.as_ptr()) };
@@ -215,6 +224,9 @@ impl<'a> Notification {
     /// Sets the category of this notification.
     ///
     /// This can be used by the notification server to filter or display the data in a certain way
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
     pub fn set_category(&mut self, category: &str) -> Result<(), LibnotifyError> {
         let category_c = std::ffi::CString::new(category)?;
         unsafe { notify_notification_set_category(self.inner, category_c.as_ptr()) };
@@ -225,6 +237,9 @@ impl<'a> Notification {
     /// Sets a hint for key with value value
     ///
     /// Available since: 0.6
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError, AllocationError}
     pub fn set_hint(&mut self, key: &str, value: HintValue) -> Result<(), LibnotifyError> {
         let key_c = std::ffi::CString::new(key)?;
 
@@ -273,6 +288,9 @@ impl<'a> Notification {
     }
 
     /// Tells the notification server to display the notification on the screen
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{GerrorError, AllocationError}
     pub fn show(&self) -> Result<(), LibnotifyError> {
         let mut gerror = std::ptr::null_mut() as *mut GError;
 
@@ -302,12 +320,15 @@ impl<'a> Notification {
     /// Updates the notification text and icon.
     ///
     /// This won’t send the update out and display it on the screen. For that, you will need to call `show()`.
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
     pub fn update<'b, F, I>(
         &mut self,
         summary: &str,
         body: F,
         icon: I,
-    ) -> Result<(), std::ffi::NulError>
+    ) -> Result<(), LibnotifyError>
     where
         F: Into<Option<&'b str>>,
         I: Into<Option<&'b str>>,

src/lib.rs

@@ -1,17 +1,25 @@
 //! This crate exposes two modules:
 //!
-//! # Api
+//! # Crate structure
+//! ## Api
 //! This module contains a basic wrapper for libnotify calls. It just translates data types, etc,
 //! so usage is basically the same as libnotify.
 //!
-//! # Wrappers
+//! ## Wrappers
 //! This module is a higher level abstraction over api. Recommended to use over api.
 //!
+//! # Features
+//!
+//! - clap – enables [clap] support for `Urgency`
+//!
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 #![warn(missing_docs)]
 
+#[cfg(not(target_os = "linux"))]
+compile_error!("Libnotify-rs only supports linux");
+
 /// Basic libnotify rust wrapper
 pub mod api;
 /// Higher level abstraction over api

src/wrappers/builder.rs

@@ -15,6 +15,10 @@ pub struct NotificationBuilder<'a> {
 
 impl<'a> NotificationBuilder<'a> {
     /// Create new NotificationBuilder, with given context.
+    ///
+    /// # Errors
+    ///
+    /// This function can return LibnotifyError::{NewNotificationError, NulError}
     pub fn new<T, Y>(
         summary: &str,
         body: T,
@@ -34,52 +38,86 @@ impl<'a> NotificationBuilder<'a> {
     }
 
     /// Sets app name for this specific notification.
-    pub fn set_app_name(mut self, app_name: &str) -> Result<Self, LibnotifyError> {
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
+    pub fn set_app_name<T: Into<Option<&'a str>>>(
+        mut self,
+        app_name: T,
+    ) -> Result<Self, LibnotifyError> {
+        if let Some(app_name) = app_name.into() {
             self.notification.set_app_name(app_name)?;
+        }
+
         Ok(self)
     }
 
     /// Sets app icon fot this specific notification.
-    pub fn set_app_icon(mut self, app_icon: &str) -> Result<Self, LibnotifyError> {
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
+    pub fn set_app_icon<T: Into<Option<&'a str>>>(
+        mut self,
+        app_icon: T,
+    ) -> Result<Self, LibnotifyError> {
+        if let Some(app_icon) = app_icon.into() {
             self.notification.set_app_icon(app_icon)?;
+        }
+
         Ok(self)
     }
 
     /// Sets category for this specific notification
-    pub fn set_category(mut self, category: &str) -> Result<Self, LibnotifyError> {
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError}
+    pub fn set_category<T: Into<Option<&'a str>>>(
+        mut self,
+        category: T,
+    ) -> Result<Self, LibnotifyError> {
+        if let Some(category) = category.into() {
             self.notification.set_category(category)?;
+        }
+
         Ok(self)
     }
 
     /// Set hint for this specific notification
-    pub fn set_hint(
-        mut self,
-        key: &str,
-        value: HintValue,
-    ) -> Result<Self, Box<dyn std::error::Error>> {
+    /// # Errors
+    /// This function can return LibnotifyError::{NulError, AllocationError}
+    pub fn set_hint(mut self, key: &str, value: HintValue) -> Result<Self, LibnotifyError> {
         self.notification.set_hint(key, value)?;
         Ok(self)
     }
 
     /// Set timeout until close
-    pub fn set_timeout(mut self, timeout: Timeout) -> Self {
+    pub fn set_timeout<T: Into<Option<Timeout>>>(mut self, timeout: T) -> Self {
+        if let Some(timeout) = timeout.into() {
             self.notification.set_timeout(timeout);
+        }
+
         self
     }
 
     /// Set notification urgency level
-    pub fn set_urgency(mut self, urgency: Urgency) -> Self {
+    pub fn set_urgency<T: Into<Option<Urgency>>>(mut self, urgency: T) -> Self {
+        if let Some(urgency) = urgency.into() {
             self.notification.set_urgency(urgency);
+        }
+
         self
     }
 
     /// Add callback
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::NulError
     pub fn add_action<F>(
         mut self,
         action: &str,
         label: &str,
         callback: F,
-    ) -> Result<Self, Box<dyn std::error::Error>>
+    ) -> Result<Self, LibnotifyError>
     where
         F: Fn(&str) + 'static,
     {
@@ -90,13 +128,21 @@ impl<'a> NotificationBuilder<'a> {
     /// Show notification
     ///
     /// Uses `&self` borrow, so you can use this object later, after showing.
-    pub fn show(&self) -> Result<(), Box<dyn std::error::Error>> {
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{GerrorError, AllocationError}
+    pub fn show(&self) -> Result<(), LibnotifyError> {
         self.notification.show()?;
         Ok(())
     }
 
     /// Close notification synchronously.
-    pub fn close(&self) -> Result<(), Box<dyn std::error::Error>> {
+    ///
+    /// Uses `&self` borrow, so you can use this object later, after closing.
+    ///
+    /// # Errors
+    /// This function can return LibnotifyError::{GerrorError, AllocationError}
+    pub fn close(&self) -> Result<(), LibnotifyError> {
         self.notification.close()?;
         Ok(())
     }