Got rson working, added format and verbose options

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snot"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["candifloss <candifloss.cc>"]
 
@@ -9,5 +9,6 @@ zbus = "4.4.0"
 zvariant = "4.2.0"
 tokio = { version = "1.40.0", features = ["full"] }
 futures-util = "0.3.30"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.128"
 rson_rs = "0.2.1"

src/formats/rson.rs

@@ -1,21 +1,19 @@
 // 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::ser::to_string;
+use rson_rs::ser::to_string as rson_string;
-use rson_rs::value::Value;
-use rson_rs::value::Value::Map;
 
 impl Notification {
-    pub fn actions_rson(&self) -> Value {
+    pub fn actions_rson(&self) -> String {
         if self.actions().is_empty() {
-            Value::from_str("{actions: Null}")
+            String::new()
         } else {
-            // Wrap the map into a rson_rs::value::Value
+            rson_string(&self.actions()).unwrap()
-            self.actions()
-                .iter()
-                .map(|(id, label)| {
-                    (id.clone(), Value::from_str(label)) // Create key-value pairs: id -> label
-                })
-                .collect::<Map<_, _>>() // Collect into a rson_rs::value::Value::Map
         }
     }
+    pub fn hints_rson(&self) -> String {
+        rson_string(&self.hints()).unwrap()
+    }
+    pub fn rson(&self) -> String {
+        rson_string(&self).unwrap()
+    }
 }

src/main.rs

@@ -1,7 +1,7 @@
 pub mod formats {
     pub mod json;
     pub mod plain;
-    //pub mod rson;
+    pub mod rson;
 }
 mod notification;
 use notification::{to_notif, Notification};
@@ -32,12 +32,18 @@ fn server_properties() -> HashMap<String, String> {
 #[tokio::main]
 async fn main() -> Result<()> {
     let args: Vec<String> = env::args().collect();
-    let op_format: String = if args.is_empty() || args[1] == "j" {
+    let op_format: &str = if args.is_empty() || args[1] == "j" {
-        "j".to_string() // Default value, json format
+        "j" // Default value, json format
+    } else if args[1] == "p" {
+        "p" // Plain format
+    } else if args[1] == "r" {
+        "r" // rson format
     } else {
-        "p".to_string() // Plain format
+        "j"
     };
 
+    let verbose: bool = (args.len() > 2) && (args[2] == "v");
+
     let connection = Connection::session().await?;
     connection
         .request_name(NOTIF_INTERFACE) // Requesting dbus for this service name. Any other services/procs using this name should be stopped/disabled before this
@@ -64,9 +70,13 @@ async fn main() -> Result<()> {
                         let properties = server_properties();
                         // Reply with the properties
                         connection.reply(&msg, &properties).await?;
+                        if verbose {
                             println!("GetAll request received for interface: {interface_name}");
+                        }
                     } else {
+                        if verbose {
                             println!("Unknown interface requested: {interface_name}");
+                        }
                         // Reply with an error
                         connection
                             .reply_error(
@@ -81,16 +91,20 @@ async fn main() -> Result<()> {
                     // Client requested server information. Respond with: (Server_name, author, software_version, dbus_spec_version)
                     let response = (SERVER_NAME, VENDOR, VERSION, SPEC_VERSION);
                     connection.reply(&msg, &response).await?;
+                    if verbose {
                         println!("Request received: {member}\n\tName: {SERVER_NAME}, Vendor: {VENDOR}, Version: {VERSION}, DBus spec version: {SPEC_VERSION}");
                         // Remove this LATER
                     }
+                }
                 "GetCapabilities" => {
                     // Client requested server capabilities. Respond with the supported capabilities
                     let capabilities = vec!["actions", "body", "body-hyperlinks"]; // Add more LATER
                     connection.reply(&msg, &capabilities).await?;
+                    if verbose {
                         println!("Request received: {member}\n\tCapabilities: {capabilities:?}");
                         // Remove this LATER
                     }
+                }
                 "Notify" => {
                     // New notification received. Now, respond to the client with a notification ID
                     notification_id += 1; // This could be incremented or generated.
@@ -102,10 +116,19 @@ async fn main() -> Result<()> {
                     // Convert the msg body to a Notification object
                     let notif: Notification = to_notif(&msg_body)?;
                     // Handle the notif
-                    if op_format == "j" {
+                    match op_format {
-                        println!("JSON!\n{}\n", &notif.json()); // Print the json version
+                        "j" => {
-                    } else {
+                            println!("{}", &notif.json()); // Print the json version
-                        println!("New notification!\n{}\n", &notif.plain()); // Print the plain version
+                        }
+                        "r" => {
+                            println!("{}", &notif.rson()); // Print the plain version
+                        }
+                        "p" => {
+                            println!("{}\n", &notif.plain()); // Print the plain version
+                        }
+                        _ => {
+                            println!("Onkown output format.");
+                        }
                     }
                 }
                 "CloseNotification" => {
@@ -114,17 +137,21 @@ async fn main() -> Result<()> {
 
                     // Tracking notifications by their IDs, closing them, and other features may be implemented later
                     // close_notification(notification_id);
+                    if verbose {
                         println!("Closing notification with ID: {notification_id}");
+                    }
 
                     // Respond to the client, acknowledging the closure
                     connection.reply(&msg, &()).await?;
                 }
                 _ => {
+                    if verbose {
                         println!("Unhandled method: {member}"); // Other methods are either irrelevant or unhandled at this stage of development
                     }
                 }
             }
         }
+    }
 
     Ok(())
 }

src/notification.rs

@@ -1,10 +1,10 @@
-// use serde::Serialize;
+use serde::Serialize;
 use std::collections::HashMap;
 use zbus::{message::Body, Result};
 use zvariant::OwnedValue;
 
 // A notificaion object
-// #[derive(Serialize)] // To help with json
+#[derive(Serialize)] // To help with json, rson
 pub struct Notification {
     // The application that sent the notification
     app_name: String,