From a834115d872730bd4b0bf6bace3919fb552639bf Mon Sep 17 00:00:00 2001
From: Michael Macias <zaeleus@gmail.com>
Date: Thu, 26 Jan 2017 16:58:46 -0600
Subject: [PATCH] Update to serde 0.9
serde 0.9.0 introduces breaking changes. See the release notes for more
details: <https://github.com/serde-rs/serde/releases/tag/v0.9.0>.
---
Cargo.toml | 2 +-
src/integrations/serde.rs | 97 +++++++++++++++++++++------------------
2 files changed, 54 insertions(+), 45 deletions(-)
diff --git a/Cargo.toml b/Cargo.toml
index b7388e89..ea97f5df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,7 +23,7 @@ expose-test-schema = []
[dependencies]
rustc-serialize = { version = "^0.3.19", optional = true }
iron = { version = "^0.4.0", optional = true }
-serde = { version = "^0.8.21", optional = true }
+serde = { version = "^0.9.1", optional = true }
[dev-dependencies]
iron = "^0.4.0"
diff --git a/src/integrations/serde.rs b/src/integrations/serde.rs
index 002d7d9b..e8662949 100644
--- a/src/integrations/serde.rs
+++ b/src/integrations/serde.rs
@@ -1,5 +1,7 @@
use serde::{de, ser};
+use serde::ser::SerializeMap;
use std::collections::HashMap;
+use std::fmt;
use ::{GraphQLError, Value};
use ast::InputValue;
@@ -8,26 +10,27 @@ use parser::{ParseError, Spanning, SourcePosition};
use validation::RuleError;
impl ser::Serialize for ExecutionError {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
- let mut state = try!(serializer.serialize_map(Some(3)));
+ let mut map = try!(serializer.serialize_map(Some(3)));
- try!(serializer.serialize_map_key(&mut state, "message"));
- try!(serializer.serialize_map_value(&mut state, self.message()));
+ try!(map.serialize_key("message"));
+ try!(map.serialize_value(self.message()));
- try!(serializer.serialize_map_key(&mut state, "locations"));
- try!(serializer.serialize_map_value(&mut state, vec![self.location()]));
+ let locations = vec![self.location()];
+ try!(map.serialize_key("locations"));
+ try!(map.serialize_value(&locations));
- try!(serializer.serialize_map_key(&mut state, "path"));
- try!(serializer.serialize_map_value(&mut state, self.path()));
+ try!(map.serialize_key("path"));
+ try!(map.serialize_value(self.path()));
- serializer.serialize_map_end(state)
+ map.end()
}
}
impl<'a> ser::Serialize for GraphQLError<'a> {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
match *self {
@@ -47,7 +50,7 @@ impl<'a> ser::Serialize for GraphQLError<'a> {
}
impl de::Deserialize for InputValue {
- fn deserialize<D>(deserializer: &mut D) -> Result<InputValue, D::Error>
+ fn deserialize<D>(deserializer: D) -> Result<InputValue, D::Error>
where D: de::Deserializer,
{
struct InputValueVisitor;
@@ -55,50 +58,54 @@ impl de::Deserialize for InputValue {
impl de::Visitor for InputValueVisitor {
type Value = InputValue;
- fn visit_bool<E>(&mut self, value: bool) -> Result<InputValue, E> {
+ fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter.write_str("a valid input value")
+ }
+
+ fn visit_bool<E>(self, value: bool) -> Result<InputValue, E> {
Ok(InputValue::boolean(value))
}
- fn visit_i64<E>(&mut self, value: i64) -> Result<InputValue, E> {
+ fn visit_i64<E>(self, value: i64) -> Result<InputValue, E> {
Ok(InputValue::int(value))
}
- fn visit_u64<E>(&mut self, value: u64) -> Result<InputValue, E>
+ fn visit_u64<E>(self, value: u64) -> Result<InputValue, E>
where E: de::Error,
{
self.visit_f64(value as f64)
}
- fn visit_f64<E>(&mut self, value: f64) -> Result<InputValue, E> {
+ fn visit_f64<E>(self, value: f64) -> Result<InputValue, E> {
Ok(InputValue::float(value))
}
- fn visit_str<E>(&mut self, value: &str) -> Result<InputValue, E>
+ fn visit_str<E>(self, value: &str) -> Result<InputValue, E>
where E: de::Error,
{
self.visit_string(value.into())
}
- fn visit_string<E>(&mut self, value: String) -> Result<InputValue, E> {
+ fn visit_string<E>(self, value: String) -> Result<InputValue, E> {
Ok(InputValue::string(value))
}
- fn visit_none<E>(&mut self) -> Result<InputValue, E> {
+ fn visit_none<E>(self) -> Result<InputValue, E> {
Ok(InputValue::null())
}
- fn visit_unit<E>(&mut self) -> Result<InputValue, E> {
+ fn visit_unit<E>(self) -> Result<InputValue, E> {
Ok(InputValue::null())
}
- fn visit_seq<V>(&mut self, visitor: V) -> Result<InputValue, V::Error>
+ fn visit_seq<V>(self, visitor: V) -> Result<InputValue, V::Error>
where V: de::SeqVisitor,
{
let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
Ok(InputValue::list(values))
}
- fn visit_map<V>(&mut self, visitor: V) -> Result<InputValue, V::Error>
+ fn visit_map<V>(self, visitor: V) -> Result<InputValue, V::Error>
where V: de::MapVisitor,
{
let values = try!(de::impls::HashMapVisitor::<String, InputValue, _>::new()
@@ -112,7 +119,7 @@ impl de::Deserialize for InputValue {
}
impl ser::Serialize for InputValue {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
match *self {
@@ -135,46 +142,48 @@ impl ser::Serialize for InputValue {
}
impl ser::Serialize for RuleError {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
- let mut state = try!(serializer.serialize_map(Some(2)));
+ let mut map = try!(serializer.serialize_map(Some(2)));
- try!(serializer.serialize_map_key(&mut state, "message"));
- try!(serializer.serialize_map_value(&mut state, self.message()));
+ try!(map.serialize_key("message"));
+ try!(map.serialize_value(self.message()));
- try!(serializer.serialize_map_key(&mut state, "locations"));
- try!(serializer.serialize_map_value(&mut state, self.locations()));
+ try!(map.serialize_key("locations"));
+ try!(map.serialize_value(self.locations()));
- serializer.serialize_map_end(state)
+ map.end()
}
}
impl ser::Serialize for SourcePosition {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
- let mut state = try!(serializer.serialize_map(Some(2)));
+ let mut map = try!(serializer.serialize_map(Some(2)));
- try!(serializer.serialize_map_key(&mut state, "line"));
- try!(serializer.serialize_map_value(&mut state, self.line() + 1));
+ let line = self.line() + 1;
+ try!(map.serialize_key("line"));
+ try!(map.serialize_value(&line));
- try!(serializer.serialize_map_key(&mut state, "column"));
- try!(serializer.serialize_map_value(&mut state, self.column() + 1));
+ let column = self.column() + 1;
+ try!(map.serialize_key("column"));
+ try!(map.serialize_value(&column));
- serializer.serialize_map_end(state)
+ map.end()
}
}
impl<'a> ser::Serialize for Spanning<ParseError<'a>> {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
- let mut state = try!(serializer.serialize_map(Some(2)));
+ let mut map = try!(serializer.serialize_map(Some(2)));
let message = format!("{}", self.item);
- try!(serializer.serialize_map_key(&mut state, "message"));
- try!(serializer.serialize_map_value(&mut state, message));
+ try!(map.serialize_key("message"));
+ try!(map.serialize_value(&message));
let mut location = HashMap::new();
location.insert("line".to_owned(), self.start.line() + 1);
@@ -182,15 +191,15 @@ impl<'a> ser::Serialize for Spanning<ParseError<'a>> {
let locations = vec![location];
- try!(serializer.serialize_map_key(&mut state, "locations"));
- try!(serializer.serialize_map_value(&mut state, locations));
+ try!(map.serialize_key("locations"));
+ try!(map.serialize_value(&locations));
- serializer.serialize_map_end(state)
+ map.end()
}
}
impl ser::Serialize for Value {
- fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
{
match *self {