Update serde dependency to 0.9.0

core/Cargo.toml

@@ -7,23 +7,17 @@ name = "jsonrpc-core"
 version = "5.1.0"
 authors = ["debris <marek.kotewicz@gmail.com>"]
 keywords = ["jsonrpc", "json-rpc", "json", "rpc", "serde"]
-build = "build.rs"
 documentation = "https://ethcore.github.io/jsonrpc/jsonrpc_core/index.html"
 
 [dependencies]
 log = "0.3"
 futures = "0.1.6"
 # always carefully check serde versions before an update
-serde = "0.8"
-serde_json = "0.8"
-serde_macros = { version = "0.8", optional = true }
+serde = "0.9"
+serde_json = "0.9"
+serde_derive = "0.9"
 # Optional dependencies for reactor support
 tokio-core = { version = "0.1", optional = true}
 
-[build-dependencies]
-serde_codegen = { version = "0.8", optional = true }
-
 [features]
-default = ["serde_codegen"]
-nightly = ["serde_macros"]
 reactor = ["tokio-core"]

core/src/lib.rs

@@ -22,12 +22,11 @@
 //! ```
 
 #![warn(missing_docs)]
-#![cfg_attr(feature="nightly", feature(custom_derive, plugin))]
-#![cfg_attr(feature="nightly", plugin(serde_macros))]
 
 #[macro_use] extern crate log;
 extern crate serde;
 extern crate serde_json;
+#[macro_use] extern crate serde_derive;
 
 pub extern crate futures;
 

core/src/types/error.rs

@@ -49,9 +49,9 @@ impl ErrorCode {
 }
 
 impl Deserialize for ErrorCode {
-	fn deserialize<D>(deserializer: &mut D) -> Result<ErrorCode, D::Error>
+	fn deserialize<D>(deserializer: D) -> Result<ErrorCode, D::Error>
 	where D: Deserializer {
-		let v = try!(Value::deserialize(deserializer));
+		let v: Value = try!(Deserialize::deserialize(deserializer));
 		match v.as_i64() {
 			Some(-32700) => Ok(ErrorCode::ParseError),
 			Some(-32600) => Ok(ErrorCode::InvalidRequest),
@@ -66,7 +66,7 @@ impl Deserialize for ErrorCode {
 }
 
 impl Serialize for ErrorCode {
-	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where S: Serializer {
 		serializer.serialize_i64(self.code())
 	}

core/src/types/id.rs

@@ -1,6 +1,8 @@
 //! jsonrpc id field
-use serde::{Serialize, Serializer, Deserialize, Deserializer, Error};
-use serde::de::Visitor;
+use std::fmt;
+
+use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::de::{self, Visitor};
 
 /// Request Id
 #[derive(Debug, PartialEq, Clone)]
@@ -14,7 +16,7 @@ pub enum Id {
 }
 
 impl Serialize for Id {
-	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where S: Serializer {
 		match *self {
 			Id::Null => serializer.serialize_unit(),
@@ -25,7 +27,7 @@ impl Serialize for Id {
 }
 
 impl Deserialize for Id {
-	fn deserialize<D>(deserializer: &mut D) -> Result<Id, D::Error>
+	fn deserialize<D>(deserializer: D) -> Result<Id, D::Error>
 	where D: Deserializer {
 		deserializer.deserialize(IdVisitor)
 	}
@@ -36,19 +38,23 @@ struct IdVisitor;
 impl Visitor for IdVisitor {
 	type Value = Id;
 
-	fn visit_unit<E>(&mut self) -> Result<Self::Value, E> where E: Error {
+	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		formatter.write_str("a unit, integer or string")
+	}
+
+	fn visit_unit<E>(self) -> Result<Self::Value, E> where E: de::Error {
 		Ok(Id::Null)
 	}
 
-	fn visit_u64<E>(&mut self, value: u64) -> Result<Self::Value, E> where E: Error {
+	fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> where E: de::Error {
 		Ok(Id::Num(value))
 	}
 
-	fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: Error {
+	fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> where E: de::Error {
 		self.visit_string(value.to_owned())
 	}
 
-	fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: Error {
+	fn visit_string<E>(self, value: String) -> Result<Self::Value, E> where E: de::Error {
 		value.parse::<u64>().map(Id::Num).or(Ok(Id::Str(value)))
 	}
 }

core/src/types/mod.rs

@@ -1,7 +1,16 @@
-//! JSON-RPC types
+pub mod error;
+pub mod id;
+pub mod params;
+pub mod request;
+pub mod response;
+pub mod version;
 
-#[cfg(feature = "serde_macros")]
-include!("mod.rs.in");
+pub use serde_json::Value;
+pub use serde_json::value::to_value;
 
-#[cfg(not(feature = "serde_macros"))]
-include!(concat!(env!("OUT_DIR"), "/types.rs"));
+pub use self::error::{ErrorCode, Error};
+pub use self::id::Id;
+pub use self::params::Params;
+pub use self::request::{Request, Call, MethodCall, Notification};
+pub use self::response::{Output, Response, Success, Failure};
+pub use self::version::Version;

core/src/types/params.rs

@@ -1,9 +1,10 @@
 //! jsonrpc params field
-use std::collections::BTreeMap;
+use std::fmt;
 
 use serde::{Serialize, Serializer, Deserialize, Deserializer};
 use serde::de::{Visitor, SeqVisitor, MapVisitor};
-use serde::de::impls::{VecVisitor, BTreeMapVisitor};
+use serde::de::impls::{VecVisitor};
+use serde_json;
 use serde_json::value::from_value;
 
 use super::{Value, Error};
@@ -14,7 +15,7 @@ pub enum Params {
 	/// Array of values
 	Array(Vec<Value>),
 	/// Map of values
-	Map(BTreeMap<String, Value>),
+	Map(serde_json::Map<String, Value>),
 	/// No parameters
 	None
 }
@@ -33,7 +34,7 @@ impl Params {
 }
 
 impl Serialize for Params {
-	fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where S: Serializer {
 		match *self {
 			Params::Array(ref vec) => vec.serialize(serializer),
@@ -46,7 +47,7 @@ impl Serialize for Params {
 struct ParamsVisitor;
 
 impl Deserialize for Params {
-	fn deserialize<D>(deserializer: &mut D) -> Result<Params, D::Error>
+	fn deserialize<D>(deserializer: D) -> Result<Params, D::Error>
 	where D: Deserializer {
 		deserializer.deserialize(ParamsVisitor)
 	}
@@ -55,37 +56,42 @@ impl Deserialize for Params {
 impl Visitor for ParamsVisitor {
 	type Value = Params;
 
-	fn visit_seq<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+		formatter.write_str("a map or sequence")
+	}
+
+	fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
 	where V: SeqVisitor {
 		VecVisitor::new().visit_seq(visitor).and_then(|vec| match vec.is_empty() {
 			true => Ok(Params::None),
 			false => Ok(Params::Array(vec))
 		})
 	}
 
-	fn visit_map<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+	fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
 	where V: MapVisitor {
-		BTreeMapVisitor::new().visit_map(visitor).and_then(|map| match map.is_empty() {
-			true => Ok(Params::None),
-			false => Ok(Params::Map(map))
-		})
+		let mut values = serde_json::Map::with_capacity(visitor.size_hint().0);
+
+		while let Some((key, value)) = visitor.visit()? {
+			values.insert(key, value);
+		}
+
+		Ok(if values.is_empty() { Params::None } else { Params::Map(values) })
 	}
 }
 
 #[test]
 fn params_deserialization() {
 	use serde_json;
 
-	use std::collections::BTreeMap;
-
 	let s = r#"[null, true, -1, 4, 2.3, "hello", [0], {"key": "value"}]"#;
 	let deserialized: Params = serde_json::from_str(s).unwrap();
 
-	let mut map = BTreeMap::new();
+	let mut map = serde_json::Map::new();
 	map.insert("key".to_string(), Value::String("value".to_string()));
 
 	assert_eq!(Params::Array(vec![
-							 Value::Null, Value::Bool(true), Value::I64(-1), Value::U64(4),
-							 Value::F64(2.3), Value::String("hello".to_string()),
-							 Value::Array(vec![Value::U64(0)]), Value::Object(map)]), deserialized);
+							 Value::Null, Value::Bool(true), Value::from(-1), Value::from(4),
+							 Value::from(2.3), Value::String("hello".to_string()),
+							 Value::Array(vec![Value::from(0)]), Value::Object(map)]), deserialized);
 }