chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update serde to 0.9.

Browse Source
This commit is contained in:
Jimmy Cuadra 2017-01-26 01:23:38 -08:00
parent 32fb575db8
commit f01b722ae2
6 changed files with 49 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Cargo.toml
View File

@ -11,8 +11,8 @@ repository = "https://github.com/ruma/ruma-events"
version = "0.3.0" version = "0.3.0"
[dependencies] [dependencies]
ruma-identifiers = "0.6.0" ruma-identifiers = "0.7.0"
ruma-signatures = "0.1.0" ruma-signatures = "0.2.0"
serde = "0.8.19" serde = "0.9.1"
serde_derive = "0.8.19" serde_derive = "0.9.1"
serde_json = "0.8.4" serde_json = "0.9.1"

29
src/collections/all.rs
View File

@ -25,7 +25,8 @@ use room::topic::TopicEvent;
use tag::TagEvent; use tag::TagEvent;
use typing::TypingEvent; use typing::TypingEvent;
use serde::{Deserialize, Deserializer, Error as SerdeError, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value}; use serde_json::{Value, from_value};
/// A basic event, room event, or state event. /// A basic event, room event, or state event.
@ -160,7 +161,7 @@ pub enum StateEvent {
} }
impl Serialize for Event { impl Serialize for Event {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
Event::CallAnswer(ref event) => event.serialize(serializer), Event::CallAnswer(ref event) => event.serialize(serializer),
Event::CallCandidates(ref event) => event.serialize(serializer), Event::CallCandidates(ref event) => event.serialize(serializer),
@ -192,10 +193,10 @@ impl Serialize for Event {
} }
impl Deserialize for Event { impl Deserialize for Event {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let event_type_value = match value.find("type") { let event_type_value = match value.get("type") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("type")), None => return Err(D::Error::missing_field("type")),
}; };
@ -383,15 +384,15 @@ impl Deserialize for Event {
Ok(Event::Typing(event)) Ok(Event::Typing(event))
} }
EventType::Custom(_) => { EventType::Custom(_) => {
if value.find("state_key").is_some() { if value.get("state_key").is_some() {
let event = match from_value::<CustomStateEvent>(value) { let event = match from_value::<CustomStateEvent>(value) {
Ok(event) => event, Ok(event) => event,
Err(error) => return Err(D::Error::custom(error.to_string())), Err(error) => return Err(D::Error::custom(error.to_string())),
}; };
Ok(Event::CustomState(event)) Ok(Event::CustomState(event))
} else if value.find("event_id").is_some() && value.find("room_id").is_some() && } else if value.get("event_id").is_some() && value.get("room_id").is_some() &&
value.find("sender").is_some() { value.get("sender").is_some() {
let event = match from_value::<CustomRoomEvent>(value) { let event = match from_value::<CustomRoomEvent>(value) {
Ok(event) => event, Ok(event) => event,
Err(error) => return Err(D::Error::custom(error.to_string())), Err(error) => return Err(D::Error::custom(error.to_string())),
@ -412,7 +413,7 @@ impl Deserialize for Event {
} }
impl Serialize for RoomEvent { impl Serialize for RoomEvent {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
RoomEvent::CallAnswer(ref event) => event.serialize(serializer), RoomEvent::CallAnswer(ref event) => event.serialize(serializer),
RoomEvent::CallCandidates(ref event) => event.serialize(serializer), RoomEvent::CallCandidates(ref event) => event.serialize(serializer),
@ -439,10 +440,10 @@ impl Serialize for RoomEvent {
} }
impl Deserialize for RoomEvent { impl Deserialize for RoomEvent {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let event_type_value = match value.find("type") { let event_type_value = match value.get("type") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("type")), None => return Err(D::Error::missing_field("type")),
}; };
@ -598,7 +599,7 @@ impl Deserialize for RoomEvent {
Ok(RoomEvent::RoomTopic(event)) Ok(RoomEvent::RoomTopic(event))
} }
EventType::Custom(_) => { EventType::Custom(_) => {
if value.find("state_key").is_some() { if value.get("state_key").is_some() {
let event = match from_value::<CustomStateEvent>(value) { let event = match from_value::<CustomStateEvent>(value) {
Ok(event) => event, Ok(event) => event,
Err(error) => return Err(D::Error::custom(error.to_string())), Err(error) => return Err(D::Error::custom(error.to_string())),
@ -622,7 +623,7 @@ impl Deserialize for RoomEvent {
} }
impl Serialize for StateEvent { impl Serialize for StateEvent {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
StateEvent::RoomAliases(ref event) => event.serialize(serializer), StateEvent::RoomAliases(ref event) => event.serialize(serializer),
StateEvent::RoomAvatar(ref event) => event.serialize(serializer), StateEvent::RoomAvatar(ref event) => event.serialize(serializer),
@ -642,10 +643,10 @@ impl Serialize for StateEvent {
} }
impl Deserialize for StateEvent { impl Deserialize for StateEvent {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let event_type_value = match value.find("type") { let event_type_value = match value.get("type") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("type")), None => return Err(D::Error::missing_field("type")),
}; };

15
src/collections/only.rs
View File

@ -13,7 +13,8 @@ use room::redaction::RedactionEvent;
use tag::TagEvent; use tag::TagEvent;
use typing::TypingEvent; use typing::TypingEvent;
use serde::{Deserialize, Deserializer, Error as SerdeError, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value}; use serde_json::{Value, from_value};
pub use super::all::StateEvent; pub use super::all::StateEvent;
@ -53,7 +54,7 @@ pub enum RoomEvent {
} }
impl Serialize for Event { impl Serialize for Event {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
Event::Presence(ref event) => event.serialize(serializer), Event::Presence(ref event) => event.serialize(serializer),
Event::Receipt(ref event) => event.serialize(serializer), Event::Receipt(ref event) => event.serialize(serializer),
@ -65,10 +66,10 @@ impl Serialize for Event {
} }
impl Deserialize for Event { impl Deserialize for Event {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let event_type_value = match value.find("type") { let event_type_value = match value.get("type") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("type")), None => return Err(D::Error::missing_field("type")),
}; };
@ -132,7 +133,7 @@ impl Deserialize for Event {
} }
impl Serialize for RoomEvent { impl Serialize for RoomEvent {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
RoomEvent::CallAnswer(ref event) => event.serialize(serializer), RoomEvent::CallAnswer(ref event) => event.serialize(serializer),
RoomEvent::CallCandidates(ref event) => event.serialize(serializer), RoomEvent::CallCandidates(ref event) => event.serialize(serializer),
@ -146,10 +147,10 @@ impl Serialize for RoomEvent {
} }
impl Deserialize for RoomEvent { impl Deserialize for RoomEvent {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let event_type_value = match value.find("type") { let event_type_value = match value.get("type") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("type")), None => return Err(D::Error::missing_field("type")),
}; };

18
src/lib.rs
View File

@ -95,7 +95,7 @@
//! However, the `ruma_events::collections::only::Event` enum does *not* include *m.room.message*, //! However, the `ruma_events::collections::only::Event` enum does *not* include *m.room.message*,
//! because *m.room.message* implements a *more specific* event trait than `Event`. //! because *m.room.message* implements a *more specific* event trait than `Event`.
#![feature(proc_macro)] #![deny(missing_debug_implementations)]
#![deny(missing_docs)] #![deny(missing_docs)]
extern crate ruma_identifiers; extern crate ruma_identifiers;
@ -104,11 +104,11 @@ extern crate serde;
#[macro_use] extern crate serde_derive; #[macro_use] extern crate serde_derive;
extern crate serde_json; extern crate serde_json;
use std::fmt::{Debug, Display, Formatter, Error as FmtError}; use std::fmt::{Debug, Display, Formatter, Error as FmtError, Result as FmtResult};
use ruma_identifiers::{EventId, RoomId, UserId}; use ruma_identifiers::{EventId, RoomId, UserId};
use serde::{Deserialize, Deserializer, Error as SerdeError, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Visitor; use serde::de::{Error as SerdeError, Visitor};
use serde_json::Value; use serde_json::Value;
#[macro_use] mod macros; #[macro_use] mod macros;
@ -301,19 +301,23 @@ impl<'a> From<&'a str> for EventType {
} }
impl Serialize for EventType { impl Serialize for EventType {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), 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()) serializer.serialize_str(&self.to_string())
} }
} }
impl Deserialize for EventType { impl Deserialize for EventType {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
struct EventTypeVisitor; struct EventTypeVisitor;
impl Visitor for EventTypeVisitor { impl Visitor for EventTypeVisitor {
type Value = EventType; type Value = EventType;
fn visit_str<E>(&mut self, v: &str) -> Result<Self::Value, E> where E: SerdeError { fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
write!(formatter, "a Matrix event type as a string")
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: SerdeError {
Ok(EventType::from(v)) Ok(EventType::from(v))
} }
} }

9
src/room/message.rs
View File

@ -1,6 +1,7 @@
//! Types for the *m.room.message* event. //! Types for the *m.room.message* event.
use serde::{Deserialize, Deserializer, Error as SerdeError, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value}; use serde_json::{Value, from_value};
use super::ImageInfo; use super::ImageInfo;
@ -253,7 +254,7 @@ impl_enum! {
} }
impl Serialize for MessageEventContent { impl Serialize for MessageEventContent {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
MessageEventContent::Audio(ref content) => content.serialize(serializer), MessageEventContent::Audio(ref content) => content.serialize(serializer),
MessageEventContent::Emote(ref content) => content.serialize(serializer), MessageEventContent::Emote(ref content) => content.serialize(serializer),
@ -268,10 +269,10 @@ impl Serialize for MessageEventContent {
} }
impl Deserialize for MessageEventContent { impl Deserialize for MessageEventContent {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let message_type_value = match value.find("msgtype") { let message_type_value = match value.get("msgtype") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("msgtype")), None => return Err(D::Error::missing_field("msgtype")),
}; };

9
src/stripped.rs
View File

@ -5,7 +5,8 @@
//! state event to be created, when the other fields can be inferred from a larger context, or where //! state event to be created, when the other fields can be inferred from a larger context, or where
//! the other fields are otherwise inapplicable. //! the other fields are otherwise inapplicable.
use serde::{Deserialize, Deserializer, Error as SerdeError, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::Error;
use serde_json::{Value, from_value}; use serde_json::{Value, from_value};
use EventType; use EventType;
@ -75,7 +76,7 @@ pub struct StrippedStateContent<C> where C: Deserialize + Serialize {
} }
impl Serialize for StrippedState { impl Serialize for StrippedState {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
match *self { match *self {
StrippedState::RoomAliases(ref event) => event.serialize(serializer), StrippedState::RoomAliases(ref event) => event.serialize(serializer),
StrippedState::RoomAvatar(ref event) => event.serialize(serializer), StrippedState::RoomAvatar(ref event) => event.serialize(serializer),
@ -94,10 +95,10 @@ impl Serialize for StrippedState {
} }
impl Deserialize for StrippedState { impl Deserialize for StrippedState {
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer {
let value: Value = try!(Deserialize::deserialize(deserializer)); let value: Value = try!(Deserialize::deserialize(deserializer));
let event_type_value = match value.find("type") { let event_type_value = match value.get("type") {
Some(value) => value.clone(), Some(value) => value.clone(),
None => return Err(D::Error::missing_field("type")), None => return Err(D::Error::missing_field("type")),
}; };