Update serde to 0.7

tarpc/Cargo.toml

@@ -11,10 +11,11 @@ readme = "../README.md"
 description = "An RPC framework for Rust with a focus on ease of use."
 
 [dependencies]
-bincode = "^0.4.0"
-log = "^0.3.5"
-scoped-pool = "^0.1.5"
-serde = "^0.6.14"
+bincode = "^0.5"
+log = "^0.3"
+scoped-pool = "^0.1"
+serde = "^0.7"
 
 [dev-dependencies]
-env_logger = "^0.3.2"
+lazy_static = "^0.1"
+env_logger = "^0.3"

tarpc/src/macros.rs

@@ -110,7 +110,7 @@ macro_rules! impl_serialize {
                 match *self {
                     $(
                         $impler::$name(ref field) =>
-                            $crate::macros::serde::Serializer::visit_newtype_variant(
+                            $crate::macros::serde::Serializer::serialize_newtype_variant(
                                 serializer,
                                 stringify!($impler),
                                 $n,
@@ -165,11 +165,12 @@ macro_rules! impl_deserialize {
                                     }
                                 )*
                                 return ::std::result::Result::Err(
-                                    $crate::macros::serde::de::Error::syntax("expected a field")
+                                    $crate::macros::serde::de::Error::custom(
+                                        format!("No variants have a value of {}!", value))
                                 );
                             }
                         }
-                        deserializer.visit_struct_field(__FieldVisitor)
+                        deserializer.deserialize_struct_field(__FieldVisitor)
                     }
                 }
 
@@ -197,7 +198,7 @@ macro_rules! impl_deserialize {
                         stringify!($name)
                     ),*
                 ];
-                deserializer.visit_enum(stringify!($impler), VARIANTS, __Visitor)
+                deserializer.deserialize_enum(stringify!($impler), VARIANTS, __Visitor)
             }
         }
     );

tarpc/src/protocol/mod.rs

@@ -6,6 +6,7 @@
 use bincode::{self, SizeLimit};
 use bincode::serde::{deserialize_from, serialize_into};
 use serde;
+use serde::de::value::Error::EndOfStream;
 use std::io::{self, Read, Write};
 use std::convert;
 use std::sync::Arc;
@@ -40,10 +41,14 @@ impl convert::From<bincode::serde::SerializeError> for Error {
 impl convert::From<bincode::serde::DeserializeError> for Error {
     fn from(err: bincode::serde::DeserializeError) -> Error {
         match err {
-            bincode::serde::DeserializeError::IoError(ref err)
-                if err.kind() == io::ErrorKind::ConnectionReset => Error::ConnectionBroken,
-            bincode::serde::DeserializeError::EndOfStreamError => Error::ConnectionBroken,
-            bincode::serde::DeserializeError::IoError(err) => Error::Io(Arc::new(err)),
+            bincode::serde::DeserializeError::Serde(EndOfStream) => Error::ConnectionBroken,
+            bincode::serde::DeserializeError::IoError(err) => {
+                match err.kind() {
+                    io::ErrorKind::ConnectionReset |
+                    io::ErrorKind::UnexpectedEof => Error::ConnectionBroken,
+                    _ => Error::Io(Arc::new(err)),
+                }
+            }
             err => panic!("Unexpected error during deserialization: {:?}", err),
         }
     }
@@ -180,9 +185,7 @@ mod test {
         let _ = env_logger::init();
         let server = Arc::new(Server::new());
         let serve_handle = server.spawn_with_config("localhost:0",
-                                                    Config {
-                                                        timeout: Some(Duration::new(0, 10))
-                                                    })
+                                                    Config { timeout: Some(Duration::new(0, 10)) })
                                  .unwrap();
         let addr = serve_handle.local_addr().clone();
         let client: Client<(), u64> = Client::new(addr).unwrap();
@@ -196,9 +199,7 @@ mod test {
         let _ = env_logger::init();
         let server = Arc::new(Server::new());
         let serve_handle = server.spawn_with_config("localhost:0",
-                                                    Config {
-                                                        timeout: test_timeout(),
-                                                    })
+                                                    Config { timeout: test_timeout() })
                                  .unwrap();
         let addr = serve_handle.local_addr().clone();
         let client: Arc<Client<(), u64>> = Arc::new(Client::new(addr).unwrap());

tarpc/src/protocol/packet.rs

@@ -19,11 +19,11 @@ impl<T: Serialize> Serialize for Packet<T> {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer
     {
-        serializer.visit_struct(PACKET,
-                                MapVisitor {
-                                    value: self,
-                                    state: 0,
-                                })
+        serializer.serialize_struct(PACKET,
+                                    MapVisitor {
+                                        value: self,
+                                        state: 0,
+                                    })
     }
 }
 
@@ -40,11 +40,11 @@ impl<'a, T: Serialize> ser::MapVisitor for MapVisitor<'a, T> {
         match self.state {
             0 => {
                 self.state += 1;
-                Ok(Some(try!(serializer.visit_struct_elt(RPC_ID, &self.value.rpc_id))))
+                Ok(Some(try!(serializer.serialize_struct_elt(RPC_ID, &self.value.rpc_id))))
             }
             1 => {
                 self.state += 1;
-                Ok(Some(try!(serializer.visit_struct_elt(MESSAGE, &self.value.message))))
+                Ok(Some(try!(serializer.serialize_struct_elt(MESSAGE, &self.value.message))))
             }
             _ => Ok(None),
         }
@@ -62,7 +62,7 @@ impl<T: Deserialize> Deserialize for Packet<T> {
         where D: Deserializer
     {
         const FIELDS: &'static [&'static str] = &[RPC_ID, MESSAGE];
-        deserializer.visit_struct(PACKET, FIELDS, Visitor(PhantomData))
+        deserializer.deserialize_struct(PACKET, FIELDS, Visitor(PhantomData))
     }
 }
 

tarpc/src/protocol/server.rs

@@ -214,15 +214,15 @@ pub trait Serve: Send + Sync + Sized {
     /// spawn
     fn spawn<A>(self, addr: A) -> io::Result<ServeHandle>
         where A: ToSocketAddrs,
-              Self: 'static,
+              Self: 'static
     {
         self.spawn_with_config(addr, Config::default())
     }
 
     /// spawn
     fn spawn_with_config<A>(self, addr: A, config: Config) -> io::Result<ServeHandle>
         where A: ToSocketAddrs,
-              Self: 'static,
+              Self: 'static
     {
         let listener = try!(TcpListener::bind(&addr));
         let addr = try!(listener.local_addr());