Move from_raw_json_value to ruma-serde

… and remove unnecessary copies of it.

crates/ruma-client-api/src/r0/session/get_login_types/login_type_serde.rs

@@ -1,8 +1,7 @@
+use ruma_serde::from_raw_json_value;
 use serde::{de, Deserialize};
 use serde_json::value::RawValue as RawJsonValue;
 
-use ruma_events::from_raw_json_value;
-
 use super::LoginType;
 
 /// Helper struct to determine the type from a `serde_json::value::RawValue`

crates/ruma-client-api/src/r0/uiaa.rs

@@ -11,7 +11,7 @@ use ruma_api::{
 };
 use ruma_common::thirdparty::Medium;
 use ruma_identifiers::{ClientSecret, SessionId, TransactionId};
-use ruma_serde::{JsonObject, Outgoing, StringEnum};
+use ruma_serde::{from_raw_json_value, JsonObject, Outgoing, StringEnum};
 use serde::{
     de::{self, DeserializeOwned},
     Deserialize, Deserializer, Serialize,
@@ -307,12 +307,6 @@ impl<'de> Deserialize<'de> for IncomingAuthData {
     where
         D: Deserializer<'de>,
     {
-        fn from_raw_json_value<T: DeserializeOwned, E: de::Error>(
-            raw: &RawJsonValue,
-        ) -> Result<T, E> {
-            serde_json::from_str(raw.get()).map_err(E::custom)
-        }
-
         let json = Box::<RawJsonValue>::deserialize(deserializer)?;
 
         #[derive(Deserialize)]

crates/ruma-events-macros/src/event_enum.rs

@@ -105,6 +105,7 @@ fn expand_deserialize_impl(
     variants: &[EventEnumVariant],
     ruma_events: &TokenStream,
 ) -> TokenStream {
+    let ruma_serde = quote! { #ruma_events::exports::ruma_serde };
     let serde = quote! { #ruma_events::exports::serde };
     let serde_json = quote! { #ruma_events::exports::serde_json };
 
@@ -127,7 +128,7 @@ fn expand_deserialize_impl(
 
                 let json = Box::<#serde_json::value::RawValue>::deserialize(deserializer)?;
                 let #ruma_events::EventTypeDeHelper { ev_type, .. } =
-                    #ruma_events::from_raw_json_value(&json)?;
+                    #ruma_serde::from_raw_json_value(&json)?;
 
                 match &*ev_type {
                     #(
@@ -366,6 +367,7 @@ fn expand_possibly_redacted_enum(
     var: EventKindVariation,
     ruma_events: &TokenStream,
 ) -> TokenStream {
+    let ruma_serde = quote! { #ruma_events::exports::ruma_serde };
     let serde = quote! { #ruma_events::exports::serde };
     let serde_json = quote! { #ruma_events::exports::serde_json };
 
@@ -393,13 +395,13 @@ fn expand_possibly_redacted_enum(
             {
                 let json = Box::<#serde_json::value::RawValue>::deserialize(deserializer)?;
                 let #ruma_events::RedactionDeHelper { unsigned } =
-                    #ruma_events::from_raw_json_value(&json)?;
+                    #ruma_serde::from_raw_json_value(&json)?;
 
                 Ok(match unsigned {
                     Some(unsigned) if unsigned.redacted_because.is_some() => {
-                        Self::Redacted(#ruma_events::from_raw_json_value(&json)?)
+                        Self::Redacted(#ruma_serde::from_raw_json_value(&json)?)
                     }
-                    _ => Self::Regular(#ruma_events::from_raw_json_value(&json)?),
+                    _ => Self::Regular(#ruma_serde::from_raw_json_value(&json)?),
                 })
             }
         }

crates/ruma-events/src/enums.rs

@@ -1,11 +1,12 @@
 use ruma_common::MilliSecondsSinceUnixEpoch;
 use ruma_events_macros::{event_enum, EventEnumFromEvent};
 use ruma_identifiers::{EventId, RoomId, RoomVersionId, UserId};
+use ruma_serde::from_raw_json_value;
 use serde::{de, Deserialize, Serialize};
 use serde_json::value::RawValue as RawJsonValue;
 
 use crate::{
-    from_raw_json_value, key,
+    key,
     room::{encrypted, message, redaction::SyncRoomRedactionEvent},
     Redact, UnsignedDeHelper,
 };

crates/ruma-events/src/lib.rs

@@ -119,10 +119,7 @@ use std::fmt::Debug;
 
 use ruma_identifiers::{EventEncryptionAlgorithm, RoomVersionId};
 use ruma_serde::Raw;
-use serde::{
+use serde::{de::IgnoredAny, Deserialize, Serialize, Serializer};
-    de::{self, IgnoredAny},
-    Deserialize, Serialize, Serializer,
-};
 use serde_json::value::RawValue as RawJsonValue;
 
 use self::room::redaction::SyncRoomRedactionEvent;
@@ -389,16 +386,6 @@ pub struct UnsignedDeHelper {
     pub redacted_because: Option<IgnoredAny>,
 }
 
-/// Helper function for `serde_json::value::RawValue` deserialization.
-#[doc(hidden)]
-pub fn from_raw_json_value<'a, T, E>(val: &'a RawJsonValue) -> Result<T, E>
-where
-    T: Deserialize<'a>,
-    E: de::Error,
-{
-    serde_json::from_str(val.get()).map_err(E::custom)
-}
-
 // Wrapper around `Box<str>` that cannot be used in a meaningful way outside of
 // this crate. Used for string enums because their `_Custom` variant can't be
 // truly private (only `#[doc(hidden)]`).

crates/ruma-events/src/room/join_rules.rs

@@ -5,8 +5,7 @@
 use ruma_events_macros::EventContent;
 #[cfg(feature = "unstable-spec")]
 use ruma_identifiers::RoomId;
-#[cfg(feature = "unstable-spec")]
+use ruma_serde::from_raw_json_value;
-use serde::de::DeserializeOwned;
 use serde::{
     de::{Deserializer, Error},
     Deserialize, Serialize,
@@ -113,11 +112,6 @@ impl<'de> Deserialize<'de> for JoinRule {
     where
         D: Deserializer<'de>,
     {
-        #[cfg(feature = "unstable-spec")]
-        fn from_raw_json_value<T: DeserializeOwned, E: Error>(raw: &RawJsonValue) -> Result<T, E> {
-            serde_json::from_str(raw.get()).map_err(E::custom)
-        }
-
         let json: Box<RawJsonValue> = Box::deserialize(deserializer)?;
 
         #[derive(Deserialize)]
@@ -215,10 +209,6 @@ impl<'de> Deserialize<'de> for AllowRule {
     where
         D: Deserializer<'de>,
     {
-        fn from_raw_json_value<T: DeserializeOwned, E: Error>(raw: &RawJsonValue) -> Result<T, E> {
-            serde_json::from_str(raw.get()).map_err(E::custom)
-        }
-
         let json: Box<RawJsonValue> = Box::deserialize(deserializer)?;
 
         // Extracts the `type` value.

crates/ruma-events/src/room/message/content_serde.rs

@@ -1,10 +1,10 @@
 //! `Deserialize` implementation for RoomMessageEventContent and MessageType.
 
+use ruma_serde::from_raw_json_value;
 use serde::{de, Deserialize};
 use serde_json::value::RawValue as RawJsonValue;
 
 use super::{MessageType, Relation, RoomMessageEventContent};
-use crate::from_raw_json_value;
 
 impl<'de> Deserialize<'de> for RoomMessageEventContent {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

crates/ruma-federation-api/src/transactions/edu.rs

@@ -6,9 +6,9 @@ use js_int::UInt;
 use ruma_common::{
     encryption::DeviceKeys, presence::PresenceState, to_device::DeviceIdOrAllDevices,
 };
-use ruma_events::{from_raw_json_value, receipt::Receipt, AnyToDeviceEventContent, EventType};
+use ruma_events::{receipt::Receipt, AnyToDeviceEventContent, EventType};
 use ruma_identifiers::{DeviceId, EventId, RoomId, TransactionId, UserId};
-use ruma_serde::Raw;
+use ruma_serde::{from_raw_json_value, Raw};
 use serde::{de, Deserialize, Serialize};
 use serde_json::{value::RawValue as RawJsonValue, Value as JsonValue};
 

crates/ruma-serde/src/lib.rs

@@ -4,7 +4,8 @@
 
 #![warn(missing_docs)]
 
-use serde_json::Value as JsonValue;
+use serde::{de, Deserialize};
+use serde_json::{value::RawValue as RawJsonValue, Value as JsonValue};
 
 pub mod base64;
 mod buf;
@@ -61,6 +62,15 @@ pub fn is_true(b: &bool) -> bool {
     *b
 }
 
+/// Helper function for `serde_json::value::RawValue` deserialization.
+pub fn from_raw_json_value<'a, T, E>(val: &'a RawJsonValue) -> Result<T, E>
+where
+    T: Deserialize<'a>,
+    E: de::Error,
+{
+    serde_json::from_str(val.get()).map_err(E::custom)
+}
+
 /// A type that can be sent to another party that understands the matrix protocol.
 ///
 /// If any of the fields of `Self` don't implement serde's `Deserialize`, you can derive this trait