Deserialization mapping from old Server enum to new Server enum.

Add fallback smart filtering for Server enums that were loaded without a nickname.
squidowl · Feb 13, 2024 · 9e459ef · 9e459ef
1 parent 921149b
commit 9e459ef
Show file tree

Hide file tree

Showing 2 changed files with 52 additions and 5 deletions.
diff --git a/data/src/history/manager.rs b/data/src/history/manager.rs
@@ -443,10 +443,10 @@ impl Data {
         let filtered = messages
             .iter()
             .filter(|message| match message.target.source() {
-                crate::message::Source::Server(Some(message_source)) => {
-                    let (message_source, nick) = server_messages.get(message_source);
+                crate::message::Source::Server(Some(source)) => {
+                    let (source, nick) = server_messages.get(source);
 
-                    match message_source.exclude {
+                    match source.exclude {
                         Exclude::All => false,
                         Exclude::None => true,
                         Exclude::Smart(seconds) => {
@@ -456,6 +456,16 @@ impl Data {
                                     &seconds,
                                     most_recent_messages.get(&nick.to_owned().unwrap()),
                                 )
+                            } else if let Some(nickname) =
+                                message.text.split(' ').collect::<Vec<_>>().get(1)
+                            {
+                                let nick = Nick::from(*nickname);
+
+                                !smart_filter_message(
+                                    message,
+                                    &seconds,
+                                    most_recent_messages.get(&nick),
+                                )
                             } else {
                                 true
                             }

diff --git a/data/src/message/source.rs b/data/src/message/source.rs
@@ -1,4 +1,5 @@
-use serde::{Deserialize, Serialize};
+use serde::de::Error;
+use serde::{Deserialize, Deserializer, Serialize};
 
 use crate::user::Nick;
 use crate::User;
@@ -11,14 +12,50 @@ pub enum Source {
     Internal(Internal),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum Server {
     Join(Option<Nick>),
     Part(Option<Nick>),
     Quit(Option<Nick>),
 }
 
+impl<'de> Deserialize<'de> for Server {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Debug, Deserialize)]
+        enum Mapping {
+            #[serde(rename = "join")]
+            JoinWithoutNick,
+            #[serde(rename = "join")]
+            Join(Option<Nick>),
+            #[serde(rename = "part")]
+            PartWithoutNick,
+            #[serde(rename = "part")]
+            Part(Option<Nick>),
+            #[serde(rename = "quit")]
+            QuitWithoutNick,
+            #[serde(rename = "quit")]
+            Quit(Option<Nick>),
+        }
+
+        if let Ok(mapping) = Mapping::deserialize(deserializer) {
+            match mapping {
+                Mapping::JoinWithoutNick => Ok(Server::Join(None)),
+                Mapping::Join(nick) => Ok(Server::Join(nick)),
+                Mapping::PartWithoutNick => Ok(Server::Part(None)),
+                Mapping::Part(nick) => Ok(Server::Part(nick)),
+                Mapping::QuitWithoutNick => Ok(Server::Quit(None)),
+                Mapping::Quit(nick) => Ok(Server::Quit(nick)),
+            }
+        } else {
+            Err(D::Error::custom("could not map to Server enum"))
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Internal {
     Status(Status),