fix: compile only on linux

src/api/functions.rs

@@ -12,9 +12,6 @@ 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>>,
@@ -166,9 +163,6 @@ 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()) };
@@ -180,9 +174,6 @@ 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

@@ -65,7 +65,11 @@ impl<'a> Notification {
     /// Create new notification.
     ///
     /// # Errors
-    /// This function can return LibnotifyError::{NewNotificationError, NulError}
+    /// 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.
     pub fn new<T, Y>(summary: &str, body: T, icon: Y) -> Result<Self, LibnotifyError>
     where
         T: Into<Option<&'a str>>,
@@ -101,9 +105,6 @@ 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,9 +147,6 @@ 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;
 
@@ -196,9 +194,6 @@ 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()) };
@@ -211,9 +206,6 @@ 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()) };
@@ -224,9 +216,6 @@ 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()) };
@@ -237,9 +226,6 @@ 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)?;
 
@@ -288,9 +274,6 @@ 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;
 
@@ -320,15 +303,12 @@ 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<(), LibnotifyError>
+    ) -> Result<(), std::ffi::NulError>
     where
         F: Into<Option<&'b str>>,
         I: Into<Option<&'b str>>,

src/lib.rs

@@ -17,6 +17,9 @@
 #![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,10 +15,6 @@ 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,
@@ -38,9 +34,6 @@ impl<'a> NotificationBuilder<'a> {
     }
 
     /// Sets app name for this specific notification.
-    ///
-    /// # Errors
-    /// This function can return LibnotifyError::{NulError}
     pub fn set_app_name<T: Into<Option<&'a str>>>(
         mut self,
         app_name: T,
@@ -53,9 +46,6 @@ impl<'a> NotificationBuilder<'a> {
     }
 
     /// Sets app icon fot this specific notification.
-    ///
-    /// # Errors
-    /// This function can return LibnotifyError::{NulError}
     pub fn set_app_icon<T: Into<Option<&'a str>>>(
         mut self,
         app_icon: T,
@@ -68,9 +58,6 @@ impl<'a> NotificationBuilder<'a> {
     }
 
     /// Sets category for this specific notification
-    ///
-    /// # Errors
-    /// This function can return LibnotifyError::{NulError}
     pub fn set_category<T: Into<Option<&'a str>>>(
         mut self,
         category: T,
@@ -83,8 +70,6 @@ impl<'a> NotificationBuilder<'a> {
     }
 
     /// Set hint for this specific notification
-    /// # 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)
@@ -109,15 +94,12 @@ impl<'a> NotificationBuilder<'a> {
     }
 
     /// Add callback
-    ///
-    /// # Errors
-    /// This function can return LibnotifyError::NulError
     pub fn add_action<F>(
         mut self,
         action: &str,
         label: &str,
         callback: F,
-    ) -> Result<Self, LibnotifyError>
+    ) -> Result<Self, Box<dyn std::error::Error>>
     where
         F: Fn(&str) + 'static,
     {
@@ -128,21 +110,13 @@ 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(())
     }