Run rustfmt.

src/call/mod.rs

@@ -11,7 +11,7 @@ pub mod invite;
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct SessionDescription {
     /// The type of session description.
-    #[serde(rename="type")]
+    #[serde(rename = "type")]
     pub session_type: SessionDescriptionType,
     /// The SDP text of the session description.
     pub sdp: String,
@@ -21,10 +21,10 @@ pub struct SessionDescription {
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub enum SessionDescriptionType {
     /// An answer.
-    #[serde(rename="answer")]
+    #[serde(rename = "answer")]
     Answer,
     /// An offer.
-    #[serde(rename="offer")]
+    #[serde(rename = "offer")]
     Offer,
 }
 

src/collections/all.rs

@@ -1,7 +1,6 @@
 //! Enums for heterogeneous collections of events, inclusive for every event type that implements
 //! the trait of the same name.
 
-use {CustomEvent, CustomRoomEvent, CustomStateEvent, EventType};
 use call::answer::AnswerEvent;
 use call::candidates::CandidatesEvent;
 use call::hangup::HangupEvent;
@@ -26,10 +25,11 @@ use room::third_party_invite::ThirdPartyInviteEvent;
 use room::topic::TopicEvent;
 use tag::TagEvent;
 use typing::TypingEvent;
+use {CustomEvent, CustomRoomEvent, CustomStateEvent, EventType};
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::de::Error;
-use serde_json::{Value, from_value};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::{from_value, Value};
 
 /// A basic event, room event, or state event.
 #[derive(Clone, Debug)]
@@ -171,7 +171,10 @@ pub enum StateEvent {
 }
 
 impl Serialize for Event {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             Event::CallAnswer(ref event) => event.serialize(serializer),
             Event::CallCandidates(ref event) => event.serialize(serializer),
@@ -205,7 +208,10 @@ impl Serialize for Event {
 }
 
 impl<'de> Deserialize<'de> for Event {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let event_type_value = match value.get("type") {
@@ -419,8 +425,9 @@ impl<'de> Deserialize<'de> for Event {
                     };
 
                     Ok(Event::CustomState(event))
-                } else if value.get("event_id").is_some() && value.get("room_id").is_some() &&
+                } else if value.get("event_id").is_some() && value.get("room_id").is_some()
-                    value.get("sender").is_some() {
+                    && value.get("sender").is_some()
+                {
                     let event = match from_value::<CustomRoomEvent>(value) {
                         Ok(event) => event,
                         Err(error) => return Err(D::Error::custom(error.to_string())),
@@ -441,7 +448,10 @@ impl<'de> Deserialize<'de> for Event {
 }
 
 impl Serialize for RoomEvent {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             RoomEvent::CallAnswer(ref event) => event.serialize(serializer),
             RoomEvent::CallCandidates(ref event) => event.serialize(serializer),
@@ -469,7 +479,10 @@ impl Serialize for RoomEvent {
 }
 
 impl<'de> Deserialize<'de> for RoomEvent {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let event_type_value = match value.get("type") {
@@ -652,11 +665,11 @@ impl<'de> Deserialize<'de> for RoomEvent {
                     Ok(RoomEvent::CustomRoom(event))
                 }
             }
-            EventType::Direct |
+            EventType::Direct
-            EventType::Presence |
+            | EventType::Presence
-            EventType::Receipt |
+            | EventType::Receipt
-            EventType::Tag |
+            | EventType::Tag
-            EventType::Typing => {
+            | EventType::Typing => {
                 return Err(D::Error::custom("not a room event".to_string()));
             }
         }
@@ -664,7 +677,10 @@ impl<'de> Deserialize<'de> for RoomEvent {
 }
 
 impl Serialize for StateEvent {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             StateEvent::RoomAliases(ref event) => event.serialize(serializer),
             StateEvent::RoomAvatar(ref event) => event.serialize(serializer),
@@ -685,7 +701,10 @@ impl Serialize for StateEvent {
 }
 
 impl<'de> Deserialize<'de> for StateEvent {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let event_type_value = match value.get("type") {
@@ -811,17 +830,17 @@ impl<'de> Deserialize<'de> for StateEvent {
 
                 Ok(StateEvent::CustomState(event))
             }
-            EventType::CallAnswer |
+            EventType::CallAnswer
-            EventType::CallCandidates |
+            | EventType::CallCandidates
-            EventType::CallHangup |
+            | EventType::CallHangup
-            EventType::CallInvite |
+            | EventType::CallInvite
-            EventType::Direct |
+            | EventType::Direct
-            EventType::Presence |
+            | EventType::Presence
-            EventType::Receipt |
+            | EventType::Receipt
-            EventType::RoomMessage |
+            | EventType::RoomMessage
-            EventType::RoomRedaction |
+            | EventType::RoomRedaction
-            EventType::Tag |
+            | EventType::Tag
-            EventType::Typing => {
+            | EventType::Typing => {
                 return Err(D::Error::custom("not a state event".to_string()));
             }
         }

src/collections/only.rs

@@ -1,7 +1,6 @@
 //! Enums for heterogeneous collections of events, exclusive to event types that implement "at
 //! most" the trait of the same name.
 
-use {CustomEvent, CustomRoomEvent, EventType};
 use call::answer::AnswerEvent;
 use call::candidates::CandidatesEvent;
 use call::hangup::HangupEvent;
@@ -13,10 +12,11 @@ use room::message::MessageEvent;
 use room::redaction::RedactionEvent;
 use tag::TagEvent;
 use typing::TypingEvent;
+use {CustomEvent, CustomRoomEvent, EventType};
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::de::Error;
-use serde_json::{Value, from_value};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::{from_value, Value};
 
 pub use super::all::StateEvent;
 
@@ -57,7 +57,10 @@ pub enum RoomEvent {
 }
 
 impl Serialize for Event {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             Event::Direct(ref event) => event.serialize(serializer),
             Event::Presence(ref event) => event.serialize(serializer),
@@ -70,7 +73,10 @@ impl Serialize for Event {
 }
 
 impl<'de> Deserialize<'de> for Event {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let event_type_value = match value.get("type") {
@@ -132,21 +138,38 @@ impl<'de> Deserialize<'de> for Event {
 
                 Ok(Event::Custom(event))
             }
-            EventType::CallAnswer | EventType::CallCandidates | EventType::CallHangup |
+            EventType::CallAnswer
-            EventType::CallInvite | EventType::RoomAliases | EventType::RoomAvatar |
+            | EventType::CallCandidates
-            EventType::RoomCanonicalAlias | EventType::RoomCreate | EventType::RoomGuestAccess |
+            | EventType::CallHangup
-            EventType::RoomHistoryVisibility | EventType::RoomJoinRules | EventType::RoomMember |
+            | EventType::CallInvite
-            EventType::RoomMessage | EventType::RoomName | EventType::RoomPinnedEvents |
+            | EventType::RoomAliases
-            EventType::RoomPowerLevels | EventType::RoomRedaction | EventType::RoomThirdPartyInvite |
+            | EventType::RoomAvatar
-            EventType::RoomTopic => {
+            | EventType::RoomCanonicalAlias
-                return Err(D::Error::custom("not exclusively a basic event".to_string()));
+            | EventType::RoomCreate
+            | EventType::RoomGuestAccess
+            | EventType::RoomHistoryVisibility
+            | EventType::RoomJoinRules
+            | EventType::RoomMember
+            | EventType::RoomMessage
+            | EventType::RoomName
+            | EventType::RoomPinnedEvents
+            | EventType::RoomPowerLevels
+            | EventType::RoomRedaction
+            | EventType::RoomThirdPartyInvite
+            | EventType::RoomTopic => {
+                return Err(D::Error::custom(
+                    "not exclusively a basic event".to_string(),
+                ));
             }
         }
     }
 }
 
 impl Serialize for RoomEvent {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             RoomEvent::CallAnswer(ref event) => event.serialize(serializer),
             RoomEvent::CallCandidates(ref event) => event.serialize(serializer),
@@ -160,7 +183,10 @@ impl Serialize for RoomEvent {
 }
 
 impl<'de> Deserialize<'de> for RoomEvent {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let event_type_value = match value.get("type") {
@@ -230,24 +256,24 @@ impl<'de> Deserialize<'de> for RoomEvent {
 
                 Ok(RoomEvent::CustomRoom(event))
             }
-            EventType::Direct |
+            EventType::Direct
-            EventType::Presence |
+            | EventType::Presence
-            EventType::Receipt |
+            | EventType::Receipt
-            EventType::RoomAliases |
+            | EventType::RoomAliases
-            EventType::RoomAvatar |
+            | EventType::RoomAvatar
-            EventType::RoomCanonicalAlias |
+            | EventType::RoomCanonicalAlias
-            EventType::RoomCreate |
+            | EventType::RoomCreate
-            EventType::RoomGuestAccess |
+            | EventType::RoomGuestAccess
-            EventType::RoomHistoryVisibility |
+            | EventType::RoomHistoryVisibility
-            EventType::RoomJoinRules |
+            | EventType::RoomJoinRules
-            EventType::RoomMember |
+            | EventType::RoomMember
-            EventType::RoomName |
+            | EventType::RoomName
-            EventType::RoomPinnedEvents |
+            | EventType::RoomPinnedEvents
-            EventType::RoomPowerLevels |
+            | EventType::RoomPowerLevels
-            EventType::RoomThirdPartyInvite |
+            | EventType::RoomThirdPartyInvite
-            EventType::RoomTopic |
+            | EventType::RoomTopic
-            EventType::Tag |
+            | EventType::Tag
-            EventType::Typing => {
+            | EventType::Typing => {
                 return Err(D::Error::custom("not exclusively a room event".to_string()));
             }
         }

src/direct.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 
-use ruma_identifiers::{UserId, RoomId};
+use ruma_identifiers::{RoomId, UserId};
 
 event! {
     /// Informs the client about the rooms that are considered direct by a user.
@@ -19,12 +19,12 @@ pub type DirectEventContent = HashMap<UserId, Vec<RoomId>>;
 mod tests {
     use std::collections::HashMap;
 
-    use ruma_identifiers::{UserId, RoomId};
+    use ruma_identifiers::{RoomId, UserId};
     use serde_json::{from_str, to_string};
 
+    use super::super::EventType;
     use collections;
     use direct::{DirectEvent, DirectEventContent};
-    use super::super::EventType;
 
     #[test]
     fn serialization() {
@@ -43,7 +43,8 @@ mod tests {
             to_string(&event).unwrap(),
             format!(
                 r#"{{"content":{{"{}":["{}"]}},"type":"m.direct"}}"#,
-                alice.to_string(), room[0].to_string()
+                alice.to_string(),
+                room[0].to_string()
             )
         );
     }
@@ -53,13 +54,18 @@ mod tests {
         let alice = UserId::new("ruma.io").unwrap();
         let rooms = vec![
             RoomId::new("ruma.io").unwrap(),
-            RoomId::new("ruma.io").unwrap()
+            RoomId::new("ruma.io").unwrap(),
         ];
 
-        let json_data = format!(r#"{{
+        let json_data = format!(
+            r#"{{
             "content": {{ "{}": ["{}", "{}"] }},
             "type": "m.direct"
-        }}"#, alice.to_string(), rooms[0].to_string(), rooms[1].to_string());
+        }}"#,
+            alice.to_string(),
+            rooms[0].to_string(),
+            rooms[1].to_string()
+        );
 
         let event = from_str::<DirectEvent>(&json_data).unwrap();
         assert_eq!(event.event_type, EventType::Direct);
@@ -75,8 +81,8 @@ mod tests {
                 let direct_rooms = event.content.get(&alice).unwrap();
                 assert!(direct_rooms.contains(&rooms[0]));
                 assert!(direct_rooms.contains(&rooms[1]));
-            },
+            }
-            _ => assert!(false)
+            _ => assert!(false),
         };
 
         match from_str::<collections::only::Event>(&json_data).unwrap() {
@@ -86,8 +92,8 @@ mod tests {
                 let direct_rooms = event.content.get(&alice).unwrap();
                 assert!(direct_rooms.contains(&rooms[0]));
                 assert!(direct_rooms.contains(&rooms[1]));
-            },
+            }
-            _ => assert!(false)
+            _ => assert!(false),
         };
     }
 }

src/lib.rs

@@ -102,17 +102,19 @@
 extern crate ruma_identifiers;
 extern crate ruma_signatures;
 extern crate serde;
-#[macro_use] extern crate serde_derive;
+#[macro_use]
+extern crate serde_derive;
 extern crate serde_json;
 
-use std::fmt::{Debug, Display, Formatter, Error as FmtError, Result as FmtResult};
+use std::fmt::{Debug, Display, Error as FmtError, Formatter, Result as FmtResult};
 
 use ruma_identifiers::{EventId, RoomId, UserId};
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::de::{Error as SerdeError, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::Value;
 
-#[macro_use] mod macros;
+#[macro_use]
+mod macros;
 
 pub mod call;
 /// Enums for heterogeneous collections of events.
@@ -188,7 +190,10 @@ pub enum EventType {
 }
 
 /// A basic event.
-pub trait Event where Self: Debug + for<'a> Deserialize<'a> + Serialize {
+pub trait Event
+where
+    Self: Debug + for<'a> Deserialize<'a> + Serialize,
+{
     /// The event-type-specific payload this event carries.
     type Content: Debug + for<'a> Deserialize<'a> + Serialize;
 
@@ -261,7 +266,7 @@ impl Display for EventType {
             EventType::RoomMember => "m.room.member",
             EventType::RoomMessage => "m.room.message",
             EventType::RoomName => "m.room.name",
-            EventType::RoomPinnedEvents=> "m.room.pinned_events",
+            EventType::RoomPinnedEvents => "m.room.pinned_events",
             EventType::RoomPowerLevels => "m.room.power_levels",
             EventType::RoomRedaction => "m.room.redaction",
             EventType::RoomThirdPartyInvite => "m.room.third_party_invite",
@@ -308,13 +313,19 @@ impl<'a> From<&'a str> for EventType {
 }
 
 impl Serialize for EventType {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         serializer.serialize_str(&self.to_string())
     }
 }
 
 impl<'de> Deserialize<'de> for EventType {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         struct EventTypeVisitor;
 
         impl<'de> Visitor<'de> for EventTypeVisitor {
@@ -324,7 +335,10 @@ impl<'de> Deserialize<'de> for EventType {
                 write!(formatter, "a Matrix event type as a string")
             }
 
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: SerdeError {
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: SerdeError,
+            {
                 Ok(EventType::from(v))
             }
         }

src/macros.rs

@@ -65,7 +65,7 @@ macro_rules! impl_event {
                 &self.event_type
             }
         }
-    }
+    };
 }
 
 macro_rules! room_event {
@@ -138,7 +138,7 @@ macro_rules! impl_room_event {
                 &self.sender
             }
         }
-    }
+    };
 }
 
 macro_rules! state_event {
@@ -207,5 +207,5 @@ macro_rules! impl_state_event {
                 &self.state_key
             }
         }
-    }
+    };
 }

src/presence.rs

@@ -14,19 +14,19 @@ event! {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct PresenceEventContent {
     /// The current avatar URL for this user.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub avatar_url: Option<String>,
 
     /// Whether or not the user is currently active.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub currently_active: Option<bool>,
 
     /// The current display name for this user.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub displayname: Option<String>,
 
     /// The last time since this user performed some action, in milliseconds.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub last_active_ago: Option<u64>,
 
     /// The presence state for this user.
@@ -40,15 +40,15 @@ pub struct PresenceEventContent {
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub enum PresenceState {
     /// Disconnected from the service.
-    #[serde(rename="offline")]
+    #[serde(rename = "offline")]
     Offline,
 
     /// Connected to the service.
-    #[serde(rename="online")]
+    #[serde(rename = "online")]
     Online,
 
     /// Connected to the service but not available for chat.
-    #[serde(rename="unavailable")]
+    #[serde(rename = "unavailable")]
     Unavailable,
 }
 

src/receipt.rs

@@ -22,7 +22,7 @@ pub type ReceiptEventContent = HashMap<EventId, Receipts>;
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Receipts {
     /// A collection of users who have sent *m.read* receipts for this event.
-    #[serde(rename="m.read")]
+    #[serde(rename = "m.read")]
     #[serde(default)]
     pub m_read: UserReceipts,
 }

src/room/avatar.rs

@@ -13,13 +13,13 @@ state_event! {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct AvatarEventContent {
     /// Information about the avatar image.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub info: Option<ImageInfo>,
     /// Information about the avatar thumbnail image.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_info: Option<ImageInfo>,
     /// URL of the avatar thumbnail image.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_url: Option<String>,
     /// URL of the avatar image.
     pub url: String,

src/room/create.rs

@@ -14,6 +14,6 @@ pub struct CreateEventContent {
     /// The `user_id` of the room creator. This is set by the homeserver.
     pub creator: UserId,
     /// Whether or not this room's data should be transferred to other homeservers.
-    #[serde(rename="m.federate")]
+    #[serde(rename = "m.federate")]
     pub federate: Option<bool>,
 }

src/room/guest_access.rs

@@ -19,11 +19,11 @@ pub struct GuestAccessEventContent {
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub enum GuestAccess {
     /// Guests are allowed to join the room.
-    #[serde(rename="can_join")]
+    #[serde(rename = "can_join")]
     CanJoin,
 
     /// Guests are not allowed to join the room.
-    #[serde(rename="forbidden")]
+    #[serde(rename = "forbidden")]
     Forbidden,
 }
 

src/room/history_visibility.rs

@@ -19,23 +19,23 @@ pub enum HistoryVisibility {
     /// Previous events are accessible to newly joined members from the point they were invited
     /// onwards. Events stop being accessible when the member's state changes to something other
     /// than *invite* or *join*.
-    #[serde(rename="invited")]
+    #[serde(rename = "invited")]
     Invited,
 
     /// Previous events are accessible to newly joined members from the point they joined the room
     /// onwards. Events stop being accessible when the member's state changes to something other
     /// than *join*.
-    #[serde(rename="joined")]
+    #[serde(rename = "joined")]
     Joined,
 
     /// Previous events are always accessible to newly joined members. All events in the room are
     /// accessible, even those sent when the member was not a part of the room.
-    #[serde(rename="shared")]
+    #[serde(rename = "shared")]
     Shared,
 
     /// All events while this is the `HistoryVisibility` value may be shared by any
     /// participating homeserver with anyone, regardless of whether they have ever joined the room.
-    #[serde(rename="world_readable")]
+    #[serde(rename = "world_readable")]
     WorldReadable,
 }
 

src/room/join_rules.rs

@@ -17,19 +17,19 @@ pub struct JoinRulesEventContent {
 pub enum JoinRule {
     /// A user who wishes to join the room must first receive an invite to the room from someone
     /// already inside of the room.
-    #[serde(rename="invite")]
+    #[serde(rename = "invite")]
     Invite,
 
     /// Reserved but not yet implemented by the Matrix specification.
-    #[serde(rename="knock")]
+    #[serde(rename = "knock")]
     Knock,
 
     /// Reserved but not yet implemented by the Matrix specification.
-    #[serde(rename="private")]
+    #[serde(rename = "private")]
     Private,
 
     /// Anyone can join the room without any prior action.
-    #[serde(rename="public")]
+    #[serde(rename = "public")]
     Public,
 }
 

src/room/member.rs

@@ -31,16 +31,16 @@ state_event! {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct MemberEventContent {
     /// The avatar URL for this user.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub avatar_url: Option<String>,
 
     /// The display name for this user.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub displayname: Option<String>,
 
     /// Flag indicating if the room containing this event was created
     /// with the intention of being a direct chat.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub is_direct: Option<bool>,
 
     /// The membership state of this user.
@@ -48,7 +48,7 @@ pub struct MemberEventContent {
 
     /// If this member event is the successor to a third party invitation, this field will contain
     /// information about that invitation.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub third_party_invite: Option<ThirdPartyInvite>,
 }
 
@@ -56,23 +56,23 @@ pub struct MemberEventContent {
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub enum MembershipState {
     /// The user is banned.
-    #[serde(rename="ban")]
+    #[serde(rename = "ban")]
     Ban,
 
     /// The user has been invited.
-    #[serde(rename="invite")]
+    #[serde(rename = "invite")]
     Invite,
 
     /// The user has joined.
-    #[serde(rename="join")]
+    #[serde(rename = "join")]
     Join,
 
     /// The user has requested to join.
-    #[serde(rename="knock")]
+    #[serde(rename = "knock")]
     Knock,
 
     /// The user has left.
-    #[serde(rename="leave")]
+    #[serde(rename = "leave")]
     Leave,
 }
 

src/room/message.rs

@@ -1,8 +1,8 @@
 //! Types for the *m.room.message* event.
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::de::Error;
-use serde_json::{Value, from_value};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::{from_value, Value};
 
 use super::{ImageInfo, ThumbnailInfo};
 
@@ -15,35 +15,35 @@ room_event! {
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
 pub enum MessageType {
     /// An audio message.
-    #[serde(rename="m.audio")]
+    #[serde(rename = "m.audio")]
     Audio,
 
     /// An emote message.
-    #[serde(rename="m.emote")]
+    #[serde(rename = "m.emote")]
     Emote,
 
     /// A file message.
-    #[serde(rename="m.file")]
+    #[serde(rename = "m.file")]
     File,
 
     /// An image message.
-    #[serde(rename="m.image")]
+    #[serde(rename = "m.image")]
     Image,
 
     /// A location message.
-    #[serde(rename="m.location")]
+    #[serde(rename = "m.location")]
     Location,
 
     /// A notice message.
-    #[serde(rename="m.notice")]
+    #[serde(rename = "m.notice")]
     Notice,
 
     /// A text message.
-    #[serde(rename="m.text")]
+    #[serde(rename = "m.text")]
     Text,
 
     /// A video message.
-    #[serde(rename="m.video")]
+    #[serde(rename = "m.video")]
     Video,
 }
 
@@ -81,7 +81,7 @@ pub struct AudioMessageEventContent {
     /// The textual representation of this message.
     pub body: String,
     /// Metadata for the audio clip referred to in `url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub info: Option<AudioInfo>,
     /// The message type. Always *m.audio*.
     pub msgtype: MessageType,
@@ -93,13 +93,13 @@ pub struct AudioMessageEventContent {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct AudioInfo {
     /// The duration of the audio in milliseconds.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub duration: Option<u64>,
     /// The mimetype of the audio, e.g. "audio/aac."
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub mimetype: Option<String>,
     /// The size of the audio clip in bytes.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub size: Option<u64>,
 }
 
@@ -121,7 +121,7 @@ pub struct FileMessageEventContent {
     /// The original filename of the uploaded file.
     pub filename: String,
     /// Metadata about the file referred to in `url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub info: Option<FileInfo>,
     /// The message type. Always *m.file*.
     pub msgtype: MessageType,
@@ -137,10 +137,10 @@ pub struct FileInfo {
     /// The size of the file in bytes.
     pub size: u64,
     /// Metadata about the image referred to in `thumbnail_url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_info: Option<ThumbnailInfo>,
     /// The URL to the thumbnail of the file.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_url: Option<String>,
 }
 
@@ -151,7 +151,7 @@ pub struct ImageMessageEventContent {
     /// of the image, or some kind of content description for accessibility e.g. "image attachment."
     pub body: String,
     /// Metadata about the image referred to in `url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub info: Option<ImageInfo>,
     /// The message type. Always *m.image*.
     pub msgtype: MessageType,
@@ -170,7 +170,7 @@ pub struct LocationMessageEventContent {
     /// The message type. Always *m.location*.
     pub msgtype: MessageType,
     /// Info about the location being represented.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub info: Option<LocationInfo>,
 }
 
@@ -178,10 +178,10 @@ pub struct LocationMessageEventContent {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct LocationInfo {
     /// Metadata about the image referred to in `thumbnail_url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_info: Option<ThumbnailInfo>,
     /// The URL to a thumbnail of the location being represented.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_url: Option<String>,
 }
 
@@ -210,7 +210,7 @@ pub struct VideoMessageEventContent {
     /// accessibility, e.g. "video attachment."
     pub body: String,
     /// Metadata about the video clip referred to in `url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub info: Option<VideoInfo>,
     /// The message type. Always *m.video*.
     pub msgtype: MessageType,
@@ -222,27 +222,27 @@ pub struct VideoMessageEventContent {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct VideoInfo {
     /// The duration of the video in milliseconds.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub duration: Option<u64>,
     /// The height of the video in pixels.
     #[serde(rename = "h")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub height: Option<u64>,
     /// The mimetype of the video, e.g. "video/mp4."
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub mimetype: Option<String>,
     /// The size of the video in bytes.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub size: Option<u64>,
     /// Metadata about an image.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_info: Option<ThumbnailInfo>,
     /// The URL to a thumbnail of the video clip.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_url: Option<String>,
     /// The width of the video in pixels.
     #[serde(rename = "w")]
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub width: Option<u64>,
 }
 
@@ -260,7 +260,10 @@ impl_enum! {
 }
 
 impl Serialize for MessageEventContent {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             MessageEventContent::Audio(ref content) => content.serialize(serializer),
             MessageEventContent::Emote(ref content) => content.serialize(serializer),
@@ -275,7 +278,10 @@ impl Serialize for MessageEventContent {
 }
 
 impl<'de> Deserialize<'de> for MessageEventContent {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let message_type_value = match value.get("msgtype") {
@@ -361,18 +367,16 @@ impl<'de> Deserialize<'de> for MessageEventContent {
 mod tests {
     use serde_json::{from_str, to_string};
 
-    use super::{AudioMessageEventContent, MessageType, MessageEventContent};
+    use super::{AudioMessageEventContent, MessageEventContent, MessageType};
 
     #[test]
     fn serialization() {
-        let message_event_content = MessageEventContent::Audio(
+        let message_event_content = MessageEventContent::Audio(AudioMessageEventContent {
-            AudioMessageEventContent {
+            body: "test".to_string(),
-                body: "test".to_string(),
+            info: None,
-                info: None,
+            msgtype: MessageType::Audio,
-                msgtype: MessageType::Audio,
+            url: "http://example.com/audio.mp3".to_string(),
-                url: "http://example.com/audio.mp3".to_string(),
+        });
-            }
-        );
 
         assert_eq!(
             to_string(&message_event_content).unwrap(),
@@ -382,14 +386,12 @@ mod tests {
 
     #[test]
     fn deserialization() {
-        let message_event_content = MessageEventContent::Audio(
+        let message_event_content = MessageEventContent::Audio(AudioMessageEventContent {
-            AudioMessageEventContent {
+            body: "test".to_string(),
-                body: "test".to_string(),
+            info: None,
-                info: None,
+            msgtype: MessageType::Audio,
-                msgtype: MessageType::Audio,
+            url: "http://example.com/audio.mp3".to_string(),
-                url: "http://example.com/audio.mp3".to_string(),
+        });
-            }
-        );
 
         assert_eq!(
             from_str::<MessageEventContent>(

src/room/mod.rs

@@ -22,20 +22,20 @@ pub mod topic;
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct ImageInfo {
     /// The height of the image in pixels.
-    #[serde(rename="h")]
+    #[serde(rename = "h")]
     pub height: u64,
     /// The MIME type of the image, e.g. "image/png."
     pub mimetype: String,
     /// The file size of the image in bytes.
     pub size: u64,
     /// Metadata about the image referred to in `thumbnail_url`.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_info: Option<ThumbnailInfo>,
     /// The URL to the thumbnail of the image.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub thumbnail_url: Option<String>,
     /// The width of the image in pixels.
-    #[serde(rename="w")]
+    #[serde(rename = "w")]
     pub width: u64,
 }
 
@@ -43,13 +43,13 @@ pub struct ImageInfo {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct ThumbnailInfo {
     /// The height of the thumbnail in pixels.
-    #[serde(rename="h")]
+    #[serde(rename = "h")]
     pub height: u64,
     /// The MIME type of the thumbnail, e.g. "image/png."
     pub mimetype: String,
     /// The file size of the thumbnail in bytes.
     pub size: u64,
     /// The width of the thumbnail in pixels.
-    #[serde(rename="w")]
+    #[serde(rename = "w")]
     pub width: u64,
 }

src/room/pinned_events.rs

@@ -19,17 +19,15 @@ mod tests {
     use ruma_identifiers::{EventId, RoomId, UserId};
     use serde_json::{from_str, to_string};
 
+    use room::pinned_events::{PinnedEventsContent, PinnedEventsEvent};
     use Event;
     use EventType;
     use RoomEvent;
     use StateEvent;
-    use room::pinned_events::{PinnedEventsEvent, PinnedEventsContent};
 
     #[test]
     fn serialization_deserialization() {
-        let mut content: PinnedEventsContent = PinnedEventsContent {
+        let mut content: PinnedEventsContent = PinnedEventsContent { pinned: Vec::new() };
-            pinned: Vec::new()
-        };
 
         content.pinned.push(EventId::new("example.com").unwrap());
         content.pinned.push(EventId::new("example.com").unwrap());

src/room/power_levels.rs

@@ -15,7 +15,7 @@ state_event! {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct PowerLevelsEventContent {
     /// The level required to ban a user.
-    #[serde(default="default_power_level")]
+    #[serde(default = "default_power_level")]
     pub ban: u64,
 
     /// The level required to send specific event types.
@@ -28,19 +28,19 @@ pub struct PowerLevelsEventContent {
     pub events_default: u64,
 
     /// The level required to invite a user.
-    #[serde(default="default_power_level")]
+    #[serde(default = "default_power_level")]
     pub invite: u64,
 
     /// The level required to kick a user.
-    #[serde(default="default_power_level")]
+    #[serde(default = "default_power_level")]
     pub kick: u64,
 
     /// The level required to redact an event.
-    #[serde(default="default_power_level")]
+    #[serde(default = "default_power_level")]
     pub redact: u64,
 
     /// The default level required to send state events.
-    #[serde(default="default_power_level")]
+    #[serde(default = "default_power_level")]
     pub state_default: u64,
 
     /// The power levels for specific users.

src/room/redaction.rs

@@ -14,6 +14,6 @@ room_event! {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct RedactionEventContent {
     /// The reason for the redaction, if any.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub reason: Option<String>,
 }

src/room/third_party_invite.rs

@@ -22,7 +22,7 @@ pub struct ThirdPartyInviteEventContent {
     pub public_key: String,
 
     /// Keys with which the token may be signed.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub public_keys: Option<Vec<PublicKey>>,
 }
 
@@ -33,7 +33,7 @@ pub struct PublicKey {
     ///
     /// The URL must return a JSON object containing a boolean property named 'valid'.
     /// If this URL is absent, the key must be considered valid indefinitely.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub key_validity_url: Option<String>,
 
     /// A Base64-encoded Ed25519 key with which the token must be signed.

src/stripped.rs

@@ -5,11 +5,10 @@
 //! state event to be created, when the other fields can be inferred from a larger context, or where
 //! the other fields are otherwise inapplicable.
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde::de::Error;
-use serde_json::{Value, from_value};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::{from_value, Value};
 
-use EventType;
 use room::aliases::AliasesEventContent;
 use room::avatar::AvatarEventContent;
 use room::canonical_alias::CanonicalAliasEventContent;
@@ -22,6 +21,7 @@ use room::name::NameEventContent;
 use room::power_levels::PowerLevelsEventContent;
 use room::third_party_invite::ThirdPartyInviteEventContent;
 use room::topic::TopicEventContent;
+use EventType;
 
 /// A stripped-down version of a state event that is included along with some other events.
 #[derive(Clone, Debug)]
@@ -69,14 +69,17 @@ pub struct StrippedStateContent<C> {
     /// Data specific to the event type.
     pub content: C,
     /// The type of the event.
-    #[serde(rename="type")]
+    #[serde(rename = "type")]
     pub event_type: EventType,
     /// A key that determines which piece of room state the event represents.
     pub state_key: String,
 }
 
 impl Serialize for StrippedState {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
         match *self {
             StrippedState::RoomAliases(ref event) => event.serialize(serializer),
             StrippedState::RoomAvatar(ref event) => event.serialize(serializer),
@@ -95,7 +98,10 @@ impl Serialize for StrippedState {
 }
 
 impl<'de> Deserialize<'de> for StrippedState {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
         let value: Value = Deserialize::deserialize(deserializer)?;
 
         let event_type_value = match value.get("type") {
@@ -116,7 +122,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomAliases(event))
-            },
+            }
             EventType::RoomAvatar => {
                 let event = match from_value::<StrippedRoomAvatar>(value) {
                     Ok(event) => event,
@@ -124,7 +130,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomAvatar(event))
-            },
+            }
             EventType::RoomCanonicalAlias => {
                 let event = match from_value::<StrippedRoomCanonicalAlias>(value) {
                     Ok(event) => event,
@@ -132,7 +138,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomCanonicalAlias(event))
-            },
+            }
             EventType::RoomCreate => {
                 let event = match from_value::<StrippedRoomCreate>(value) {
                     Ok(event) => event,
@@ -140,7 +146,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomCreate(event))
-            },
+            }
             EventType::RoomGuestAccess => {
                 let event = match from_value::<StrippedRoomGuestAccess>(value) {
                     Ok(event) => event,
@@ -148,7 +154,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomGuestAccess(event))
-            },
+            }
             EventType::RoomHistoryVisibility => {
                 let event = match from_value::<StrippedRoomHistoryVisibility>(value) {
                     Ok(event) => event,
@@ -156,7 +162,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomHistoryVisibility(event))
-            },
+            }
             EventType::RoomJoinRules => {
                 let event = match from_value::<StrippedRoomJoinRules>(value) {
                     Ok(event) => event,
@@ -164,7 +170,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomJoinRules(event))
-            },
+            }
             EventType::RoomMember => {
                 let event = match from_value::<StrippedRoomMember>(value) {
                     Ok(event) => event,
@@ -172,7 +178,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomMember(event))
-            },
+            }
             EventType::RoomName => {
                 let event = match from_value::<StrippedRoomName>(value) {
                     Ok(event) => event,
@@ -180,7 +186,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomName(event))
-            },
+            }
             EventType::RoomPowerLevels => {
                 let event = match from_value::<StrippedRoomPowerLevels>(value) {
                     Ok(event) => event,
@@ -188,7 +194,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomPowerLevels(event))
-            },
+            }
             EventType::RoomThirdPartyInvite => {
                 let event = match from_value::<StrippedRoomThirdPartyInvite>(value) {
                     Ok(event) => event,
@@ -196,7 +202,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomThirdPartyInvite(event))
-            },
+            }
             EventType::RoomTopic => {
                 let event = match from_value::<StrippedRoomTopic>(value) {
                     Ok(event) => event,
@@ -204,7 +210,7 @@ impl<'de> Deserialize<'de> for StrippedState {
                 };
 
                 Ok(StrippedState::RoomTopic(event))
-            },
+            }
             _ => {
                 return Err(D::Error::custom("not a state event".to_string()));
             }
@@ -250,18 +256,20 @@ pub type StrippedRoomTopic = StrippedStateContent<TopicEventContent>;
 
 #[cfg(test)]
 mod tests {
-    use EventType;
+    use super::{StrippedRoomTopic, StrippedState};
     use room::join_rules::JoinRule;
     use room::topic::TopicEventContent;
     use serde_json::{from_str, to_string};
-    use super::{StrippedRoomTopic, StrippedState};
+    use EventType;
 
     #[test]
     fn serialize_stripped_state_event() {
         let content = StrippedRoomTopic {
-            content: TopicEventContent { topic: "Testing room".to_string() },
+            content: TopicEventContent {
+                topic: "Testing room".to_string(),
+            },
             state_key: "".to_string(),
-            event_type: EventType::RoomTopic
+            event_type: EventType::RoomTopic,
         };
 
         let event = StrippedState::RoomTopic(content);
@@ -319,7 +327,7 @@ mod tests {
                 assert_eq!(event.content.name, "Ruma");
                 assert_eq!(event.event_type, EventType::RoomName);
                 assert_eq!(event.state_key, "");
-            },
+            }
             _ => {
                 assert!(false);
             }
@@ -330,7 +338,7 @@ mod tests {
                 assert_eq!(event.content.join_rule, JoinRule::Public);
                 assert_eq!(event.event_type, EventType::RoomJoinRules);
                 assert_eq!(event.state_key, "");
-            },
+            }
             _ => {
                 assert!(false);
             }
@@ -348,7 +356,7 @@ mod tests {
                 assert_eq!(event.content.url, "https://domain.com/image.jpg");
                 assert_eq!(event.event_type, EventType::RoomAvatar);
                 assert_eq!(event.state_key, "");
-            },
+            }
             _ => {
                 assert!(false);
             }

src/tag.rs

@@ -18,6 +18,6 @@ pub struct TagEventContent {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct TagInfo {
     /// Value to use for lexicographically ordering rooms with this tag.
-    #[serde(skip_serializing_if="Option::is_none")]
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub order: Option<String>,
 }