Upgrade to Serde 1.0

Cargo.toml

@@ -12,8 +12,8 @@ keywords = ["rustdt", "jsonrpc", "json-rpc", "rpc"]
 [dependencies]
 rustdt_util = "0.2.3"
 log = "0.3.6"
-serde = "0.8"
-serde_json = "0.8"
+serde = "1.0"
+serde_json = "1.0"
 futures = "0.1.3"
 
 [dev-dependencies]

src/json_util.rs

@@ -5,27 +5,18 @@
 // This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::BTreeMap;
 use std::fmt;
+use std::marker::PhantomData;
 
 use serde;
 
 use serde_json::Map;
 use serde_json::Value;
-use serde_json::builder::ObjectBuilder;
 
 pub type JsonObject = Map<String, Value>;
 
 /* ----------------- deserialize helpers ----------------- */
 
-pub fn new_object() -> JsonObject {
-    BTreeMap::new()
-}
-
-pub fn unwrap_object_builder(ob: ObjectBuilder) -> JsonObject {
-    unwrap_object(ob.build())
-}
-
 pub fn unwrap_object(value: Value) -> JsonObject {
     match value {
         Value::Object(o) => o ,
@@ -79,16 +70,20 @@ pub trait JsonDeserializerHelper<ERR> {
 
     fn as_u32(&mut self, value: Value) -> Result<u32, ERR> {
         match value {
-            Value::I64(num) => Ok(num as u32), // FIXME: check for truncation
-            Value::U64(num) => Ok(num as u32), // FIXME: check for truncation
+            Value::Number(num) => match num.as_u64() {
+                Some(num) => Ok(num as u32), // FIXME: check for truncation
+                None => Err(self.new_error(&format!("Value `{}` is not an Integer.", num))),
+            },
             _ => Err(self.new_error(&format!("Value `{}` is not an Integer.", value))),
         }
     }
 
     fn as_i64(&mut self, value: Value) -> Result<i64, ERR> {
         match value {
-            Value::I64(num) => Ok(num),
-            Value::U64(num) => Ok(num as i64), // FIXME: check for truncation
+            Value::Number(num) => match num.as_i64() {
+                Some(num) => Ok(num),
+                None => Err(self.new_error(&format!("Value `{}` is not an Integer.", num))),
+            },
             _ => Err(self.new_error(&format!("Value `{}` is not an Integer.", value))),
         }
     }
@@ -131,10 +126,16 @@ pub trait JsonDeserializerHelper<ERR> {
 
 }
 
-pub struct SerdeJsonDeserializerHelper<DE>(pub DE);
+pub struct SerdeJsonDeserializerHelper<DE>(PhantomData<DE>);
 
-impl<'a, DE : serde::Deserializer> 
-    JsonDeserializerHelper<DE::Error> for SerdeJsonDeserializerHelper<&'a mut DE> 
+impl<DE> SerdeJsonDeserializerHelper<DE> {
+    pub fn new(_deserializer: &DE) -> SerdeJsonDeserializerHelper<DE> {
+        SerdeJsonDeserializerHelper(PhantomData)
+    }
+}
+
+impl<'de, DE : serde::Deserializer<'de>> 
+    JsonDeserializerHelper<DE::Error> for SerdeJsonDeserializerHelper<DE> 
 {
     fn new_error(&self, error_message: &str) -> DE::Error {
         new_de_error(error_message.into())
@@ -145,14 +146,14 @@ pub fn to_de_error<DISPLAY, DE_ERROR>(display: DISPLAY)
     -> DE_ERROR   
 where 
     DISPLAY: fmt::Display,
-    DE_ERROR: serde::Error, 
+    DE_ERROR: serde::de::Error, 
 {
     DE_ERROR::custom(format!("{}", display))
 }
 
 pub fn new_de_error<DE_ERROR>(message: String) 
     -> DE_ERROR
-    where DE_ERROR: serde::Error 
+    where DE_ERROR: serde::de::Error 
 {
     DE_ERROR::custom(message)
 }
@@ -173,30 +174,30 @@ pub mod test_util {
         serde_json::to_string(value).unwrap()
     }
 
-    pub fn from_json<T: Deserialize>(json: &str) -> T {
+    pub fn from_json<'de, T: Deserialize<'de>>(json: &'de str) -> T {
         serde_json::from_str(json).unwrap()
     }
 
     pub fn test_serde<T>(obj: &T) 
         -> (T, String)
-        where T : Serialize + Deserialize + PartialEq + Debug
+        where for<'de> T : Serialize + Deserialize<'de> + PartialEq + Debug
     {
         let json = to_json(obj);
         let reserialized : T = from_json(&json);
         check_equal(&reserialized, obj);
         (reserialized, json)
     }
 
-    pub fn test_error_de<T>(json: &str, expected_err_contains: &str) 
-        where T : Deserialize + PartialEq + Debug
+    pub fn test_error_de<'de, T>(json: &'de str, expected_err_contains: &str) 
+        where T : Deserialize<'de> + PartialEq + Debug
     {
         let res = serde_json::from_str::<T>(json).unwrap_err();
         check_err_contains(res, expected_err_contains);
     }
 
     pub fn test_serde_expecting<T>(obj: &T, expected_value: &Value) 
         -> Value
-        where T : Serialize + Deserialize + PartialEq + Debug
+        where for<'de> T : Serialize + Deserialize<'de> + PartialEq + Debug
     {
         let json = test_serde(obj).1;
 
@@ -205,4 +206,4 @@ pub mod test_util {
         as_value
     }
 
-}
+}

src/jsonrpc.rs

@@ -24,7 +24,7 @@ https://github.com/RustDT/rustdt-json_rpc/blob/master/tests/example.rs
 #![allow(non_camel_case_types)]
 
 #[macro_use] extern crate log;
-extern crate serde_json;
+#[macro_use] extern crate serde_json;
 extern crate serde;
 
 extern crate rustdt_util as util;
@@ -275,7 +275,7 @@ impl ResponseCompletable {
         self, params: RequestParams, method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         RET : serde::Serialize, 
         RET_ERROR : serde::Serialize,
         METHOD : FnOnce(PARAMS, MethodCompletable<RET, RET_ERROR>),
@@ -288,7 +288,7 @@ impl ResponseCompletable {
         self, params: RequestParams, sync_method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         RET : serde::Serialize, 
         RET_ERROR : serde::Serialize ,
         METHOD : FnOnce(PARAMS) -> MethodResult<RET, RET_ERROR>,
@@ -303,7 +303,7 @@ impl ResponseCompletable {
         self, params: RequestParams, method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         METHOD : FnOnce(PARAMS),
     {
         let mc = MethodCompletable::<(), ()>::new(self);
@@ -318,7 +318,7 @@ impl ResponseCompletable {
         self, params: RequestParams, sync_method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         METHOD : FnOnce(PARAMS),
     {
         self.handle_notification_with(params, |params| {
@@ -359,7 +359,7 @@ impl<
         method_fn: METHOD
     )
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         RET : serde::Serialize, 
         RET_ERROR : serde::Serialize,
         METHOD : FnOnce(PARAMS, Self),
@@ -421,11 +421,14 @@ impl Endpoint {
 
     /// Send a (non-notification) request
     pub fn send_request<
+        RET,
+        RET_ERROR,
         PARAMS : serde::Serialize, 
-        RET: serde::Deserialize, 
-        RET_ERROR : serde::Deserialize, 
     >(&mut self, method_name: &str, params: PARAMS) 
         -> GResult<RequestFuture<RET, RET_ERROR>> 
+    where
+        for<'de> RET: serde::Deserialize<'de>, 
+        for<'de> RET_ERROR : serde::Deserialize<'de>, 
     {
         let (completable, future) = futures::oneshot::<ResponseResult>();
         let future : futures::Oneshot<ResponseResult> = future;
@@ -459,7 +462,7 @@ impl Endpoint {
     >(&self, id: Option<Id>, method_name: &str, params: PARAMS) 
         -> GResult<()> 
     {
-        let params_value = serde_json::to_value(&params);
+        let params_value = serde_json::to_value(&params)?;
         let params = jsonrpc_request::to_jsonrpc_params(params_value)?;
 
         let rpc_request = Request { id: id.clone(), method : method_name.into(), params : params };
@@ -593,12 +596,12 @@ mod tests_ {
         let request = Request::new(1, "sample_fn".to_string(), JsonObject::new());
         invoke_method(&mut request_handler, &request.method, request.params, 
             |result| 
-            check_request(result.unwrap(), ResponseResult::Error(error_JSON_RPC_InvalidParams(r#"missing field "x""#)))
+            check_request(result.unwrap(), ResponseResult::Error(error_JSON_RPC_InvalidParams(r#"missing field `x`"#)))
         );
 
         // test with valid params
         let params_value = match serde_json::to_value(&new_sample_params(10, 20)) {
-            Value::Object(object) => object, 
+            Ok(Value::Object(object)) => object, 
             _ => panic!("Not serialized into Object") 
         };
         let request = Request::new(1, "sample_fn".to_string(), params_value);

src/jsonrpc_common.rs

@@ -9,11 +9,12 @@ use std::fmt;
 
 use serde;
 use serde::de::Visitor;
-use serde::Error;
+use serde::ser::SerializeStruct;
 
 use serde_json::Value;
 use serde_json;
 use json_util::*;
+use json_util::JsonDeserializerHelper;
 
 
 
@@ -33,7 +34,7 @@ pub fn parse_jsonrpc_id(id: Value) -> JsonRpcParseResult<Option<Id>> {
 pub enum Id { Number(u64), String(String), Null, }
 
 impl serde::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: serde::Serializer,
     {
         match *self {
@@ -44,33 +45,38 @@ impl serde::Serialize for Id {
     }
 }
 
-impl serde::Deserialize for Id {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for Id {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        deserializer.deserialize(IdDeserializeVisitor)
+        deserializer.deserialize_any(IdDeserializeVisitor)
     }
 }
 
 struct IdDeserializeVisitor;
 
-impl Visitor for IdDeserializeVisitor {
+impl<'de> Visitor<'de> for IdDeserializeVisitor {
     type Value = Id;
 
-    fn visit_unit<E>(&mut self) -> Result<Self::Value, E> where E: Error,
+    fn visit_unit<E>(self) -> Result<Self::Value, E>
     {
         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>
     {
         Ok(Id::Number(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>
     {
         Ok(Id::String(value.to_string()))
     }
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+    {
+        formatter.write_str("an ID")
+    }
 }
 
 impl fmt::Display for Id {
@@ -130,28 +136,28 @@ pub fn error_JSON_RPC_InvalidResponse<T: fmt::Display>(error: T) -> RequestError
 }
 
 impl serde::Serialize for RequestError {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         let elem_count = 3;
         let mut state = try!(serializer.serialize_struct("RequestError", elem_count)); 
         {
-            try!(serializer.serialize_struct_elt(&mut state, "code", self.code));
-            try!(serializer.serialize_struct_elt(&mut state, "message", &self.message));
+            try!(state.serialize_field("code", &self.code));
+            try!(state.serialize_field("message", &self.message));
             if let Some(ref data) = self.data {
-                try!(serializer.serialize_struct_elt(&mut state, "data", data));
+                try!(state.serialize_field("data", data));
             }
         }
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 }
 
-impl serde::Deserialize for RequestError {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for RequestError {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        let mut helper = SerdeJsonDeserializerHelper(deserializer);
-        let value : Value = try!(Value::deserialize(helper.0));
+        let mut helper = SerdeJsonDeserializerHelper::new(&deserializer);
+        let value : Value = try!(Value::deserialize(deserializer));
         let mut json_obj = try!(helper.as_Object(value));
 
         let code = try!(helper.obtain_i64(&mut json_obj, "code"));

src/jsonrpc_message.rs

@@ -36,7 +36,7 @@ impl From<Request> for Message {
 }
 
 impl serde::Serialize for Message {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         match *self {
@@ -46,12 +46,12 @@ impl serde::Serialize for Message {
     }
 }
 
-impl serde::Deserialize for Message {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for Message {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        let mut helper = SerdeJsonDeserializerHelper(deserializer);
-        let value = try!(Value::deserialize(helper.0));
+        let mut helper = SerdeJsonDeserializerHelper::new(&deserializer);
+        let value = try!(Value::deserialize(deserializer));
         let json_obj = try!(helper.as_Object(value));
 
         if json_obj.contains_key("method") {
@@ -93,4 +93,4 @@ pub mod message_tests {
         test_serde::<Message>(&Request::new(1, "myMethod".to_string(), sample_params).into());
     }
 
-}
+}