Merge pull request 'dev' (#2) from dev into main

Reviewed-on: #2

Cargo.toml

@@ -1,14 +1,8 @@
 [package]
 name = "snot"
-version = "0.1.3"
+version = "0.1.1"
 edition = "2021"
 authors = ["candifloss <candifloss.cc>"]
-description = "Simple NOTification"
-license = "GPL-3.0-or-later"
-repository = "https://git.candifloss.cc/candifloss/SNot"
-homepage = "https://git.candifloss.cc/candifloss/SNot"
-documentation = "https://git.candifloss.cc/candifloss/SNot"
-readme = "README.md"
 
 [dependencies]
 zbus = "4.4.0"

src/formats/rson.rs

@@ -1,11 +1,10 @@
 // This module deals with converting the notification object into rson format, which can be used instead of json if preferred
 use crate::notification::Notification;
-use rson_rs::de::Error as RsonError;
 use rson_rs::ser::to_string as rson_string;
+use rson_rs::de::Error as RsonError;
 
 impl Notification {
     pub fn rson(&self) -> Result<String, RsonError> {
-        rson_string(self)
+        rson_string(self).map_err(|e| RsonError::Message(format!("RSON serialization error: {}", e)))
-            .map_err(|e| RsonError::Message(format!("RSON serialization error: {}", e)))
     }
 }

src/formats/serde.rs

@@ -1,10 +1,8 @@
-use serde::ser::{Serialize, Serializer, SerializeMap};
+use serde::{Serialize, Serializer};
+/*
 use std::collections::HashMap;
-use zvariant::OwnedValue;
+use std::hash::BuildHasher;
-//use std::hash::BuildHasher;
+use zvariant::OwnedValue;   */
-//use serde::ser::SerializeMap;
-use serde_json::{Map,Value};
-use zvariant::SerializeValue;
 
 pub fn serialize_actions<S>(actions: &[String], serializer: S) -> Result<S::Ok, S::Error>
 where
@@ -12,9 +10,9 @@ where
 {
     let mut map = serde_json::Map::new();
 
-    // Actions are in pairs: [id, label, id, label, ...]
+    // Assuming actions are in pairs: [id, label, id, label, ...]
-    for pair in actions.chunks(2) {
+    for chunk in actions.chunks(2) {
-        if let [id, label] = pair {
+        if let [id, label] = chunk {
             map.insert(id.clone(), serde_json::Value::String(label.clone()));
         }
     }
@@ -22,38 +20,22 @@ where
     map.serialize(serializer)
 }
 
-pub fn serialize_hints<S>(
+/*
-    hints: &HashMap<String, OwnedValue>,
+pub fn serialize_hints<S, H>(
+    hints: &HashMap<String, OwnedValue, H>,
     serializer: S,
 ) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
+    H: BuildHasher,
 {
-    // Start serializing the map
+    let mut map = serde_json::Map::new();
-    let mut map = serializer.serialize_map(Some(hints.len()))?;
+
     for (key, value) in hints {
-        // Serialize each entry as desired
+        // Customize OwnedValue serialization as needed
-        map.serialize_entry(key, &HintValueSerializer(value))?;
+        map.insert(key.clone(), serde_json::Value::String(value.to_string()));
-    }
-    map.end()
-}
-
-// A custom struct to handle serialization of OwnedValue
-struct HintValueSerializer<'a>(&'a OwnedValue);
-
-impl<'a> Serialize for HintValueSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        // Access the signature and value parts of the OwnedValue
-        let signature = self.0.value_signature().to_string();
-        let value = &self.0;
-
-        // Serialize them as a map with "signature" and "value" fields
-        let mut map = serializer.serialize_map(Some(2))?;
-        map.serialize_entry("signature", &signature)?;
-        map.serialize_entry("value", value)?;
-        map.end()
     }
+
+    map.serialize(serializer)
 }
+*/

src/main.rs

@@ -13,8 +13,8 @@ use futures_util::stream::TryStreamExt;
 use zbus::{message::Body, Connection, Result};
 
 const SERVER_NAME: &str = "SNot"; // Server software name
-const VENDOR: &str = env!("CARGO_PKG_AUTHORS"); // Server software vendor
+const VENDOR: &str = "candifloss.cc"; // Server software vendor
-const VERSION: &str = env!("CARGO_PKG_VERSION"); // Server software version, from Cargo.toml
+const VERSION: &str = "0.1.2"; // Server software version
 const SPEC_VERSION: &str = "0.42"; // DBus specification version
 const NOTIF_INTERFACE: &str = "org.freedesktop.Notifications"; // DBus interface name
 
@@ -109,7 +109,7 @@ async fn main() -> Result<()> {
                 }
                 "GetCapabilities" => {
                     // Client requested server capabilities. Respond with the supported capabilities
-                    let capabilities = vec![/*"actions",*/ "body", "body-hyperlinks"]; // Add more LATER
+                    let capabilities = vec!["actions", "body", "body-hyperlinks"]; // Add more LATER
                     connection.reply(&msg, &capabilities).await?;
                     if verbose {
                         println!("Request received: {member}\n\tCapabilities: {capabilities:?}");

src/notification.rs

@@ -1,4 +1,4 @@
-use crate::formats::serde::{serialize_actions, serialize_hints};
+use crate::formats::serde::serialize_actions;
 use serde::Serialize;
 use std::collections::HashMap;
 use zbus::{message::Body, Result};
@@ -21,7 +21,7 @@ pub struct Notification {
     #[serde(serialize_with = "serialize_actions")]
     actions: Vec<String>,
     // Useful extra data - notif type, urgency, notif sound, icon data, etc.
-    #[serde(serialize_with = "serialize_hints")]
+    //#[serde(serialize_with = "serialize_hints")]
     hints: HashMap<String, OwnedValue>,
     // Seconds till this notif expires. Optional
     expir_timeout: i32,