ruma_common/canonical_json/
value.rs

Help
1use std::{collections::BTreeMap, fmt};
2
3use as_variant::as_variant;
4use js_int::{Int, UInt};
5use serde::{de::Deserializer, ser::Serializer, Deserialize, Serialize};
6use serde_json::{to_string as to_json_string, Value as JsonValue};
7
8use super::CanonicalJsonError;
9
10/// The inner type of `CanonicalJsonValue::Object`.
11#[cfg(feature = "canonical-json")]
12pub type CanonicalJsonObject = BTreeMap<String, CanonicalJsonValue>;
13
14/// Represents a canonical JSON value as per the Matrix specification.
15#[cfg(feature = "canonical-json")]
16#[derive(Clone, Default, Eq, PartialEq)]
17#[allow(clippy::exhaustive_enums)]
18pub enum CanonicalJsonValue {
19    /// Represents a JSON null value.
20    ///
21    /// ```
22    /// # use serde_json::json;
23    /// # use ruma_common::CanonicalJsonValue;
24    /// let v: CanonicalJsonValue = json!(null).try_into().unwrap();
25    /// ```
26    #[default]
27    Null,
28
29    /// Represents a JSON boolean.
30    ///
31    /// ```
32    /// # use serde_json::json;
33    /// # use ruma_common::CanonicalJsonValue;
34    /// let v: CanonicalJsonValue = json!(true).try_into().unwrap();
35    /// ```
36    Bool(bool),
37
38    /// Represents a JSON integer.
39    ///
40    /// ```
41    /// # use serde_json::json;
42    /// # use ruma_common::CanonicalJsonValue;
43    /// let v: CanonicalJsonValue = json!(12).try_into().unwrap();
44    /// ```
45    Integer(Int),
46
47    /// Represents a JSON string.
48    ///
49    /// ```
50    /// # use serde_json::json;
51    /// # use ruma_common::CanonicalJsonValue;
52    /// let v: CanonicalJsonValue = json!("a string").try_into().unwrap();
53    /// ```
54    String(String),
55
56    /// Represents a JSON array.
57    ///
58    /// ```
59    /// # use serde_json::json;
60    /// # use ruma_common::CanonicalJsonValue;
61    /// let v: CanonicalJsonValue = json!(["an", "array"]).try_into().unwrap();
62    /// ```
63    Array(Vec<CanonicalJsonValue>),
64
65    /// Represents a JSON object.
66    ///
67    /// The map is backed by a BTreeMap to guarantee the sorting of keys.
68    ///
69    /// ```
70    /// # use serde_json::json;
71    /// # use ruma_common::CanonicalJsonValue;
72    /// let v: CanonicalJsonValue = json!({ "an": "object" }).try_into().unwrap();
73    /// ```
74    Object(CanonicalJsonObject),
75}
76
77impl CanonicalJsonValue {
78    /// If the `CanonicalJsonValue` is a `Bool`, return the inner value.
79    pub fn as_bool(&self) -> Option<bool> {
80        as_variant!(self, Self::Bool).copied()
81    }
82
83    /// If the `CanonicalJsonValue` is an `Integer`, return the inner value.
84    pub fn as_integer(&self) -> Option<Int> {
85        as_variant!(self, Self::Integer).copied()
86    }
87
88    /// If the `CanonicalJsonValue` is a `String`, return a reference to the inner value.
89    pub fn as_str(&self) -> Option<&str> {
90        as_variant!(self, Self::String)
91    }
92
93    /// If the `CanonicalJsonValue` is an `Array`, return a reference to the inner value.
94    pub fn as_array(&self) -> Option<&[CanonicalJsonValue]> {
95        as_variant!(self, Self::Array)
96    }
97
98    /// If the `CanonicalJsonValue` is an `Object`, return a reference to the inner value.
99    pub fn as_object(&self) -> Option<&CanonicalJsonObject> {
100        as_variant!(self, Self::Object)
101    }
102
103    /// If the `CanonicalJsonValue` is an `Array`, return a mutable reference to the inner value.
104    pub fn as_array_mut(&mut self) -> Option<&mut Vec<CanonicalJsonValue>> {
105        as_variant!(self, Self::Array)
106    }
107
108    /// If the `CanonicalJsonValue` is an `Object`, return a mutable reference to the inner value.
109    pub fn as_object_mut(&mut self) -> Option<&mut CanonicalJsonObject> {
110        as_variant!(self, Self::Object)
111    }
112
113    /// Returns `true` if the `CanonicalJsonValue` is a `Bool`.
114    pub fn is_bool(&self) -> bool {
115        matches!(self, Self::Bool(_))
116    }
117
118    /// Returns `true` if the `CanonicalJsonValue` is an `Integer`.
119    pub fn is_integer(&self) -> bool {
120        matches!(self, Self::Integer(_))
121    }
122
123    /// Returns `true` if the `CanonicalJsonValue` is a `String`.
124    pub fn is_string(&self) -> bool {
125        matches!(self, Self::String(_))
126    }
127
128    /// Returns `true` if the `CanonicalJsonValue` is an `Array`.
129    pub fn is_array(&self) -> bool {
130        matches!(self, Self::Array(_))
131    }
132
133    /// Returns `true` if the `CanonicalJsonValue` is an `Object`.
134    pub fn is_object(&self) -> bool {
135        matches!(self, Self::Object(_))
136    }
137}
138
139impl fmt::Debug for CanonicalJsonValue {
140    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
141        match *self {
142            Self::Null => formatter.debug_tuple("Null").finish(),
143            Self::Bool(v) => formatter.debug_tuple("Bool").field(&v).finish(),
144            Self::Integer(ref v) => fmt::Debug::fmt(v, formatter),
145            Self::String(ref v) => formatter.debug_tuple("String").field(v).finish(),
146            Self::Array(ref v) => {
147                formatter.write_str("Array(")?;
148                fmt::Debug::fmt(v, formatter)?;
149                formatter.write_str(")")
150            }
151            Self::Object(ref v) => {
152                formatter.write_str("Object(")?;
153                fmt::Debug::fmt(v, formatter)?;
154                formatter.write_str(")")
155            }
156        }
157    }
158}
159
160impl fmt::Display for CanonicalJsonValue {
161    /// Display this value as a string.
162    ///
163    /// This `Display` implementation is intentionally unaffected by any formatting parameters,
164    /// because adding extra whitespace or otherwise pretty-printing it would make it not the
165    /// canonical form anymore.
166    ///
167    /// If you want to pretty-print a `CanonicalJsonValue` for debugging purposes, use
168    /// one of `serde_json::{to_string_pretty, to_vec_pretty, to_writer_pretty}`.
169    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
170        write!(f, "{}", to_json_string(&self).map_err(|_| fmt::Error)?)
171    }
172}
173
174impl TryFrom<JsonValue> for CanonicalJsonValue {
175    type Error = CanonicalJsonError;
176
177    fn try_from(val: JsonValue) -> Result<Self, Self::Error> {
178        Ok(match val {
179            JsonValue::Bool(b) => Self::Bool(b),
180            JsonValue::Number(num) => Self::Integer(
181                Int::try_from(num.as_i64().ok_or(CanonicalJsonError::IntConvert)?)
182                    .map_err(|_| CanonicalJsonError::IntConvert)?,
183            ),
184            JsonValue::Array(vec) => {
185                Self::Array(vec.into_iter().map(TryInto::try_into).collect::<Result<Vec<_>, _>>()?)
186            }
187            JsonValue::String(string) => Self::String(string),
188            JsonValue::Object(obj) => Self::Object(
189                obj.into_iter()
190                    .map(|(k, v)| Ok((k, v.try_into()?)))
191                    .collect::<Result<CanonicalJsonObject, _>>()?,
192            ),
193            JsonValue::Null => Self::Null,
194        })
195    }
196}
197
198impl From<CanonicalJsonValue> for JsonValue {
199    fn from(val: CanonicalJsonValue) -> Self {
200        match val {
201            CanonicalJsonValue::Bool(b) => Self::Bool(b),
202            CanonicalJsonValue::Integer(int) => Self::Number(i64::from(int).into()),
203            CanonicalJsonValue::String(string) => Self::String(string),
204            CanonicalJsonValue::Array(vec) => {
205                Self::Array(vec.into_iter().map(Into::into).collect())
206            }
207            CanonicalJsonValue::Object(obj) => {
208                Self::Object(obj.into_iter().map(|(k, v)| (k, v.into())).collect())
209            }
210            CanonicalJsonValue::Null => Self::Null,
211        }
212    }
213}
214
215macro_rules! variant_impls {
216    ($variant:ident($ty:ty)) => {
217        impl From<$ty> for CanonicalJsonValue {
218            fn from(val: $ty) -> Self {
219                Self::$variant(val.into())
220            }
221        }
222
223        impl PartialEq<$ty> for CanonicalJsonValue {
224            fn eq(&self, other: &$ty) -> bool {
225                match self {
226                    Self::$variant(val) => val == other,
227                    _ => false,
228                }
229            }
230        }
231
232        impl PartialEq<CanonicalJsonValue> for $ty {
233            fn eq(&self, other: &CanonicalJsonValue) -> bool {
234                match other {
235                    CanonicalJsonValue::$variant(val) => self == val,
236                    _ => false,
237                }
238            }
239        }
240    };
241}
242
243variant_impls!(Bool(bool));
244variant_impls!(Integer(Int));
245variant_impls!(String(String));
246variant_impls!(String(&str));
247variant_impls!(Array(Vec<CanonicalJsonValue>));
248variant_impls!(Object(CanonicalJsonObject));
249
250impl From<UInt> for CanonicalJsonValue {
251    fn from(value: UInt) -> Self {
252        Self::Integer(value.into())
253    }
254}
255
256impl Serialize for CanonicalJsonValue {
257    #[inline]
258    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
259    where
260        S: Serializer,
261    {
262        match self {
263            Self::Null => serializer.serialize_unit(),
264            Self::Bool(b) => serializer.serialize_bool(*b),
265            Self::Integer(n) => n.serialize(serializer),
266            Self::String(s) => serializer.serialize_str(s),
267            Self::Array(v) => v.serialize(serializer),
268            Self::Object(m) => {
269                use serde::ser::SerializeMap;
270                let mut map = serializer.serialize_map(Some(m.len()))?;
271                for (k, v) in m {
272                    map.serialize_entry(k, v)?;
273                }
274                map.end()
275            }
276        }
277    }
278}
279
280impl<'de> Deserialize<'de> for CanonicalJsonValue {
281    #[inline]
282    fn deserialize<D>(deserializer: D) -> Result<CanonicalJsonValue, D::Error>
283    where
284        D: Deserializer<'de>,
285    {
286        let val = JsonValue::deserialize(deserializer)?;
287        val.try_into().map_err(serde::de::Error::custom)
288    }
289}
290
291#[cfg(test)]
292mod tests {
293    use serde_json::json;
294
295    use super::CanonicalJsonValue;
296
297    #[test]
298    fn to_string() {
299        const CANONICAL_STR: &str = r#"{"city":"London","street":"10 Downing Street"}"#;
300
301        let json: CanonicalJsonValue =
302            json!({ "city": "London", "street": "10 Downing Street" }).try_into().unwrap();
303
304        assert_eq!(format!("{json}"), CANONICAL_STR);
305        assert_eq!(format!("{json:#}"), CANONICAL_STR);
306    }
307}
ruma_common/canonical_json/value.rs

ruma_common/canonical_json/
value.rs
