From 8080bae293437276e20c43bd8ec0bee0ebda9b9f Mon Sep 17 00:00:00 2001
From: ppom <reaction@ppom.me>
Date: Thu, 24 Oct 2024 12:00:00 +0200
Subject: [PATCH] deactivate PatternStatus special formatting

---
 src/concepts/socket_messages.rs | 58 ++++++++++++++++-----------------
 src/daemon/socket.rs            |  2 +-
 2 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/concepts/socket_messages.rs b/src/concepts/socket_messages.rs
index 2f71125..5f00d79 100644
--- a/src/concepts/socket_messages.rs
+++ b/src/concepts/socket_messages.rs
@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use super::Match;
 
 use serde::{
-    ser::{SerializeMap, SerializeStruct},
+    // ser::{SerializeMap, SerializeStruct},
     Deserialize, Serialize,
 };
 
@@ -37,36 +37,36 @@ pub enum DaemonResponse {
 
 pub type ClientStatus = BTreeMap<String, BTreeMap<String, BTreeMap<String, PatternStatus>>>;
 
-#[derive(Debug, Default, Deserialize)]
+#[derive(Debug, Default, Deserialize, Serialize)]
 pub struct PatternStatus {
     pub matches: usize,
     pub actions: BTreeMap<String, Vec<String>>,
 }
 
-impl Serialize for PatternStatus {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        // We only skip serializing emptiness if we're on a human-readable format
-        // This means we're printing for user, not exchanging it over a socket
-        if serializer.is_human_readable() {
-            let ser_matches = self.matches != 0;
-            let ser_actions = !self.actions.is_empty();
-            let mut state =
-                serializer.serialize_map(Some(ser_matches as usize + ser_actions as usize))?;
-            if ser_matches {
-                state.serialize_entry("matches", &self.matches)?;
-            }
-            if ser_actions {
-                state.serialize_entry("actions", &self.actions)?;
-            }
-            state.end()
-        } else {
-            let mut state = serializer.serialize_struct("PatternStatus", 2)?;
-            state.serialize_field("matches", &self.matches)?;
-            state.serialize_field("actions", &self.actions)?;
-            state.end()
-        }
-    }
-}
+// impl Serialize for PatternStatus {
+//     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+//     where
+//         S: serde::Serializer,
+//     {
+//         // We only skip serializing emptiness if we're on a human-readable format
+//         // This means we're printing for user, not exchanging it over a socket
+//         if serializer.is_human_readable() {
+//             let ser_matches = self.matches != 0;
+//             let ser_actions = !self.actions.is_empty();
+//             let mut state =
+//                 serializer.serialize_map(Some(ser_matches as usize + ser_actions as usize))?;
+//             if ser_matches {
+//                 state.serialize_entry("matches", &self.matches)?;
+//             }
+//             if ser_actions {
+//                 state.serialize_entry("actions", &self.actions)?;
+//             }
+//             state.end()
+//         } else {
+//             let mut state = serializer.serialize_struct("PatternStatus", 2)?;
+//             state.serialize_field("matches", &self.matches)?;
+//             state.serialize_field("actions", &self.actions)?;
+//             state.end()
+//         }
+//     }
+// }
diff --git a/src/daemon/socket.rs b/src/daemon/socket.rs
index 269b38e..599f530 100644
--- a/src/daemon/socket.rs
+++ b/src/daemon/socket.rs
@@ -183,7 +183,7 @@ pub async fn socket_manager(
                         };
                         // Encode
                         let encoded_response =
-                            or_next!("failed to serialize response", bin.serialize(&response));
+                            or_next!("failed to serialize response", bin.serialize::<DaemonResponse>(&response));
                         or_next!(
                             "failed to send response:",
                             transport.send(Bytes::from(encoded_response)).await