From c69e1c6204020322cdfc77afdd31e06ac064c89c Mon Sep 17 00:00:00 2001
From: Jimmy Cuadra <jimmy@jimmycuadra.com>
Date: Tue, 6 Aug 2019 14:45:18 -0700
Subject: [PATCH] impl Deserialize for m.ignored_user_list

---
 src/ignored_user_list.rs | 63 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 59 insertions(+), 4 deletions(-)

diff --git a/src/ignored_user_list.rs b/src/ignored_user_list.rs
index 449c0917..9da415ed 100644
--- a/src/ignored_user_list.rs
+++ b/src/ignored_user_list.rs
@@ -3,9 +3,9 @@
 use std::{collections::HashMap, convert::TryFrom, str::FromStr};
 
 use ruma_identifiers::UserId;
-use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
+use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::{Empty, Event, EventType, InnerInvalidEvent, InvalidEvent};
+use crate::{Empty, Event, EventResult, EventType, InnerInvalidEvent, InvalidEvent};
 
 /// A list of users to ignore.
 #[derive(Clone, Debug, PartialEq)]
@@ -21,6 +21,33 @@ pub struct IgnoredUserListEventContent {
     pub ignored_users: Vec<UserId>,
 }
 
+impl<'de> Deserialize<'de> for EventResult<IgnoredUserListEvent> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let json = serde_json::Value::deserialize(deserializer)?;
+
+        let raw: raw::IgnoredUserListEvent = match serde_json::from_value(json.clone()) {
+            Ok(raw) => raw,
+            Err(error) => {
+                return Ok(EventResult::Err(InvalidEvent(
+                    InnerInvalidEvent::Validation {
+                        json,
+                        message: error.to_string(),
+                    },
+                )));
+            }
+        };
+
+        Ok(EventResult::Ok(IgnoredUserListEvent {
+            content: IgnoredUserListEventContent {
+                ignored_users: raw.content.ignored_users.keys().cloned().collect(),
+            },
+        }))
+    }
+}
+
 impl FromStr for IgnoredUserListEvent {
     type Err = InvalidEvent;
 
@@ -78,6 +105,31 @@ impl_event!(
     EventType::IgnoredUserList
 );
 
+impl<'de> Deserialize<'de> for EventResult<IgnoredUserListEventContent> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let json = serde_json::Value::deserialize(deserializer)?;
+
+        let raw: raw::IgnoredUserListEventContent = match serde_json::from_value(json.clone()) {
+            Ok(raw) => raw,
+            Err(error) => {
+                return Ok(EventResult::Err(InvalidEvent(
+                    InnerInvalidEvent::Validation {
+                        json,
+                        message: error.to_string(),
+                    },
+                )));
+            }
+        };
+
+        Ok(EventResult::Ok(IgnoredUserListEventContent {
+            ignored_users: raw.ignored_users.keys().cloned().collect(),
+        }))
+    }
+}
+
 impl FromStr for IgnoredUserListEventContent {
     type Err = InvalidEvent;
 
@@ -155,7 +207,7 @@ mod tests {
 
     use ruma_identifiers::UserId;
 
-    use super::{IgnoredUserListEvent, IgnoredUserListEventContent};
+    use super::{EventResult, IgnoredUserListEvent, IgnoredUserListEventContent};
 
     #[test]
     fn serialization() {
@@ -174,7 +226,10 @@ mod tests {
     fn deserialization() {
         let json = r#"{"content":{"ignored_users":{"@carl:example.com":{}}},"type":"m.ignored_user_list"}"#;
 
-        let actual: IgnoredUserListEvent = json.parse().unwrap();
+        let actual = serde_json::from_str::<EventResult<IgnoredUserListEvent>>(json)
+            .unwrap()
+            .into_result()
+            .unwrap();
 
         let expected = IgnoredUserListEvent {
             content: IgnoredUserListEventContent {