Release 0.8.22

Support deserializing ByteBuf from string

.travis.yml

@@ -1,8 +1,8 @@
 sudo: false
 language: rust
 rust:
-- 1.10.0
-- 1.11.0
+- 1.12.0
+- 1.13.0
 - stable
 - beta
 - nightly

README.md

@@ -11,12 +11,11 @@ You may be looking for:
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
 - [Examples](https://serde.rs/examples.html)
 - [API documentation](https://docs.serde.rs/serde/)
+- [Release notes](https://github.com/serde-rs/serde/releases)
 
 ## Serde in action
 
 ```rust
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

examples/serde-syntex-example/Cargo.toml

@@ -3,6 +3,7 @@ name = "serde-syntex-example"
 version = "0.1.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 build = "build.rs"
+publish = false
 
 [features]
 default = ["serde_codegen"]

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.8.18"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/src/bytes.rs

@@ -84,7 +84,7 @@ mod bytebuf {
     use de;
 
     #[cfg(feature = "collections")]
-    use collections::Vec;
+    use collections::{String, Vec};
 
     /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
     #[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
@@ -208,7 +208,7 @@ mod bytebuf {
         fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
             where E: de::Error,
         {
-            self.visit_byte_buf(v.to_vec())
+            Ok(ByteBuf::from(v))
         }
 
         #[inline]
@@ -217,6 +217,18 @@ mod bytebuf {
         {
             Ok(ByteBuf::from(v))
         }
+
+        fn visit_str<E>(&mut self, v: &str) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
+
+        fn visit_string<E>(&mut self, v: String) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
     }
 
     impl de::Deserialize for ByteBuf {

serde/src/de/impls.rs

@@ -283,6 +283,12 @@ impl Visitor for StringVisitor {
         Ok(v)
     }
 
+    fn visit_unit<E>(&mut self) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(String::new())
+    }
+
     fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
         where E: Error,
     {

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.8.18"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -22,8 +22,8 @@ with-syn = []
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-quote = "0.3"
-serde_codegen_internals = { version = "=0.11.0", default-features = false, path = "../serde_codegen_internals" }
+quote = "0.3.8"
+serde_codegen_internals = { version = "=0.11.3", default-features = false, path = "../serde_codegen_internals" }
 syn = { version = "0.10", features = ["aster", "visit"] }
-syntex = { version = "^0.50.0", optional = true }
-syntex_syntax = { version = "^0.50.0", optional = true }
+syntex = { version = "^0.54.0", optional = true }
+syntex_syntax = { version = "^0.54.0", optional = true }

serde_codegen/src/de.rs

@@ -496,6 +496,7 @@ fn deserialize_item_enum(
 
     let variant_visitor = deserialize_field_visitor(
         variants.iter()
+            .filter(|variant| !variant.attrs.skip_deserializing())
             .map(|variant| variant.attrs.name().deserialize_name())
             .collect(),
         item_attrs,
@@ -518,7 +519,7 @@ fn deserialize_item_enum(
 
     // Match arms to extract a variant from a string
     let mut variant_arms = vec![];
-    for (i, variant) in variants.iter().enumerate() {
+    for (i, variant) in variants.iter().filter(|variant| !variant.attrs.skip_deserializing()).enumerate() {
         let variant_name = aster::id(format!("__field{}", i));
         let variant_name = quote!(__Field::#variant_name);
 

serde_codegen/src/lib.rs

@@ -2,7 +2,6 @@
 #![cfg_attr(feature = "clippy", feature(plugin))]
 #![cfg_attr(feature = "clippy", allow(too_many_arguments))]
 #![cfg_attr(feature = "clippy", allow(used_underscore_binding))]
-#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
 
 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "192"]
@@ -16,13 +15,6 @@ extern crate syntex;
 #[macro_use]
 extern crate syntex_syntax as syntax;
 
-#[cfg(not(feature = "with-syntex"))]
-#[macro_use]
-extern crate syntax;
-
-#[cfg(not(feature = "with-syntex"))]
-extern crate rustc_plugin;
-
 extern crate syn;
 #[macro_use]
 extern crate quote;
@@ -30,9 +22,6 @@ extern crate quote;
 #[cfg(feature = "with-syntex")]
 use std::path::Path;
 
-#[cfg(not(feature = "with-syntex"))]
-use syntax::feature_gate::AttributeType;
-
 mod bound;
 mod de;
 mod ser;
@@ -49,11 +38,11 @@ fn syntex_registry() -> syntex::Registry {
 
         impl fold::Folder for StripAttributeFolder {
             fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-                match attr.node.value.node {
-                    ast::MetaItemKind::List(ref n, _) if n == &"serde" => { return None; }
-                    _ => {}
+                if attr.value.name == "serde" {
+                    if let ast::MetaItemKind::List(..) = attr.value.node {
+                        return None;
+                    }
                 }
-
                 Some(attr)
             }
 
@@ -104,21 +93,6 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
     syntex::with_extra_stack(expand_thread)
 }
 
-#[cfg(not(feature = "with-syntex"))]
-pub fn register(reg: &mut rustc_plugin::Registry) {
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Serialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(shim::expand_derive_serialize)));
-
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Deserialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(shim::expand_derive_deserialize)));
-
-    reg.register_attribute("serde".to_owned(), AttributeType::Normal);
-}
-
 macro_rules! shim {
     ($name:ident $pkg:ident :: $func:ident) => {
         pub fn $func(
@@ -142,13 +116,12 @@ macro_rules! shim {
 
             use syntax::{attr, ast, visit};
             struct MarkSerdeAttributesUsed;
-            impl visit::Visitor for MarkSerdeAttributesUsed {
+            impl<'a> visit::Visitor<'a> for MarkSerdeAttributesUsed {
                 fn visit_attribute(&mut self, attr: &ast::Attribute) {
-                    match attr.node.value.node {
-                        ast::MetaItemKind::List(ref name, _) if name == "serde" => {
+                    if attr.value.name == "serde" {
+                        if let ast::MetaItemKind::List(..) = attr.value.node {
                             attr::mark_used(attr);
                         }
-                        _ => {}
                     }
                 }
             }
@@ -176,6 +149,7 @@ macro_rules! shim {
     };
 }
 
+#[cfg(feature = "with-syntex")]
 mod shim {
     shim!(Serialize ser::expand_derive_serialize);
     shim!(Deserialize de::expand_derive_deserialize);
@@ -184,15 +158,15 @@ mod shim {
 #[cfg(feature = "with-syn")]
 #[doc(hidden)]
 /// Not public API. Use the serde_derive crate.
-pub fn expand_derive_serialize(item: &str) -> Result<String, String> {
+pub fn expand_derive_serialize(item: &str) -> Result<quote::Tokens, String> {
     let syn_item = syn::parse_macro_input(item).unwrap();
-    ser::expand_derive_serialize(&syn_item).map(|derive| derive.to_string())
+    ser::expand_derive_serialize(&syn_item)
 }
 
 #[cfg(feature = "with-syn")]
 #[doc(hidden)]
 /// Not public API. Use the serde_derive crate.
-pub fn expand_derive_deserialize(item: &str) -> Result<String, String> {
+pub fn expand_derive_deserialize(item: &str) -> Result<quote::Tokens, String> {
     let syn_item = syn::parse_macro_input(item).unwrap();
-    de::expand_derive_deserialize(&syn_item).map(|derive| derive.to_string())
+    de::expand_derive_deserialize(&syn_item)
 }

serde_codegen/src/ser.rs

@@ -256,76 +256,80 @@ fn serialize_variant(
     let variant_ident = variant.ident.clone();
     let variant_name = variant.attrs.name().serialize_name();
 
-    match variant.style {
-        Style::Unit => {
-            quote! {
-                #type_ident::#variant_ident =>
-                    _serde::ser::Serializer::serialize_unit_variant(
-                        _serializer,
-                        #type_name,
-                        #variant_index,
-                        #variant_name,
-                    ),
-            }
-        },
-        Style::Newtype => {
-            let block = serialize_newtype_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                ty,
-                generics,
-                &variant.fields[0],
-            );
-
-            quote! {
-                #type_ident::#variant_ident(ref __simple_value) => #block,
-            }
-        },
-        Style::Tuple => {
-            let field_names: Vec<Tokens> = (0 .. variant.fields.len())
-                .map(|i| {
-                    let id = aster::id(format!("__field{}", i));
-                    quote!(ref #id)
-                })
-                .collect();
-
-            let pat = quote!(#type_ident::#variant_ident(#(#field_names),*));
-
-            let block = serialize_tuple_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-            );
-
-            quote! {
-                #pat => { #block }
-            }
+    if variant.attrs.skip_serializing() {
+        let skipped_msg = format!("The enum variant {}::{} cannot be serialized",
+                                type_ident, variant_ident);
+        let skipped_err = quote! {
+            Err(_serde::ser::Error::invalid_value(#skipped_msg))
+        };
+        let fields_pat = match variant.style {
+            Style::Unit => quote!(),
+            Style::Newtype | Style::Tuple => quote!( (..) ),
+            Style::Struct => quote!( {..} ),
+        };
+        quote! {
+            #type_ident::#variant_ident #fields_pat => #skipped_err,
         }
-        Style::Struct => {
-            let fields = variant.fields.iter().map(|field| {
-                let id = match field.ident {
-                    Some(ref name) => name.clone(),
-                    None => panic!("struct variant has unnamed fields"),
-                };
-                quote!(ref #id)
-            });
-            let pat = quote!(#type_ident::#variant_ident { #(#fields),* });
+    } else { // variant wasn't skipped
+        match variant.style {
+            Style::Unit => {
+                quote! {
+                    #type_ident::#variant_ident =>
+                        _serde::ser::Serializer::serialize_unit_variant(
+                            _serializer,
+                            #type_name,
+                            #variant_index,
+                            #variant_name,
+                        ),
+                }
+            },
+            Style::Newtype => {
+                let block = serialize_newtype_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    ty,
+                    generics,
+                    &variant.fields[0],
+                );
 
-            let block = serialize_struct_variant(
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-                item_attrs,
-            );
+                quote! {
+                    #type_ident::#variant_ident(ref __simple_value) => #block,
+                }
+            },
+            Style::Tuple => {
+                let field_names = (0 .. variant.fields.len())
+                    .map(|i| aster::id(format!("__field{}", i)));
 
-            quote! {
-                #pat => { #block }
+                let block = serialize_tuple_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident(#(ref #field_names),*) => { #block }
+                }
+            }
+            Style::Struct => {
+                let fields = variant.fields.iter()
+                    .map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
+
+                let block = serialize_struct_variant(
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                    item_attrs,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident { #(ref #fields),* } => { #block }
+                }
             }
         }
     }

serde_codegen_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.11.0"
+version = "0.11.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."

serde_codegen_internals/src/attr.rs

@@ -187,12 +187,16 @@ impl Item {
 #[derive(Debug)]
 pub struct Variant {
     name: Name,
+    skip_deserializing: bool,
+    skip_serializing: bool,
 }
 
 impl Variant {
     pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
         let mut ser_name = Attr::none(cx, "rename");
         let mut de_name = Attr::none(cx, "rename");
+        let mut skip_deserializing = BoolAttr::none(cx, "skip_deserializing");
+        let mut skip_serializing = BoolAttr::none(cx, "skip_serializing");
 
         for meta_items in variant.attrs.iter().filter_map(get_serde_meta_items) {
             for meta_item in meta_items {
@@ -212,6 +216,14 @@ impl Variant {
                             de_name.set_opt(de);
                         }
                     }
+                    // Parse `#[serde(skip_deserializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_deserializing" => {
+                        skip_deserializing.set_true();
+                    }
+                    // Parse `#[serde(skip_serializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_serializing" => {
+                        skip_serializing.set_true();
+                    }
 
                     MetaItem(ref meta_item) => {
                         cx.error(format!("unknown serde variant attribute `{}`",
@@ -230,12 +242,22 @@ impl Variant {
                 serialize: ser_name.get().unwrap_or_else(|| variant.ident.to_string()),
                 deserialize: de_name.get().unwrap_or_else(|| variant.ident.to_string()),
             },
+            skip_deserializing: skip_deserializing.get(),
+            skip_serializing: skip_serializing.get(),
         }
     }
 
     pub fn name(&self) -> &Name {
         &self.name
     }
+
+    pub fn skip_deserializing(&self) -> bool {
+        self.skip_deserializing
+    }
+
+    pub fn skip_serializing(&self) -> bool {
+        self.skip_serializing
+    }
 }
 
 /// Represents field attribute information

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "0.8.18"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -15,7 +15,7 @@ name = "serde_derive"
 proc-macro = true
 
 [dependencies.serde_codegen]
-version = "=0.8.18"
+version = "=0.8.22"
 path = "../serde_codegen"
 default-features = false
 features = ["with-syn"]
@@ -23,5 +23,5 @@ features = ["with-syn"]
 [dev-dependencies]
 compiletest_rs = "^0.2.0"
 fnv = "1.0"
-serde = { version = "0.8.18", path = "../serde" }
-serde_test = { version = "0.8.18", path = "../serde_test" }
+serde = { version = "0.8.22", path = "../serde" }
+serde_test = { version = "0.8.22", path = "../serde_test" }

serde_derive/src/lib.rs

@@ -1,6 +1,3 @@
-#![feature(proc_macro, proc_macro_lib)]
-#![cfg(not(test))]
-
 extern crate proc_macro;
 extern crate serde_codegen;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-and-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-rename-de.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/two-rename-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/str_ref_deser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/container.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/field.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/variant.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/run-pass/identity-op.rs

@@ -1,4 +1,3 @@
-#![feature(proc_macro)]
 #![deny(identity_op)]
 
 #[macro_use]

serde_derive/tests/test.rs

@@ -1,4 +1,4 @@
-#![feature(test, proc_macro)]
+#![feature(test)]
 
 #[macro_use]
 extern crate serde_derive;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.8.18"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -12,4 +12,4 @@ keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]
 
 [dependencies]
-serde = { version = "0.8.18", path = "../serde" }
+serde = { version = "0.8.22", path = "../serde" }

testing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_testing"
-version = "0.8.18"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -10,6 +10,7 @@ documentation = "https://docs.serde.rs/serde/"
 readme = "README.md"
 keywords = ["serialization"]
 build = "build.rs"
+publish = false
 
 [features]
 unstable-testing = ["clippy", "serde/unstable-testing", "serde_codegen/unstable-testing"]

testing/tests/test.rs.in

@@ -1,4 +1,5 @@
 extern crate serde;
+extern crate serde_test;
 
 #[macro_use]
 mod macros;

testing/tests/test_bytes.rs

@@ -1,11 +1,13 @@
 use std::fmt;
 use std::error;
 
-use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
 use serde::bytes::{ByteBuf, Bytes};
 use serde::ser;
 use serde::de;
 
+use serde_test::{assert_de_tokens, Token};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #[derive(Debug, PartialEq)]
@@ -286,153 +288,6 @@ impl Serializer for BytesSerializer {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct BytesDeserializer {
-    bytes: Option<Vec<u8>>,
-}
-
-impl BytesDeserializer {
-    fn new(bytes: Vec<u8>) -> Self {
-        BytesDeserializer {
-            bytes: Some(bytes),
-        }
-    }
-}
-
-impl Deserializer for BytesDeserializer {
-    type Error = Error;
-
-    fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        Err(Error)
-    }
-
-    fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        visitor.visit_byte_buf(self.bytes.take().unwrap())
-    }
-
-    fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_option<__V>(&mut self, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_seq_fixed_size<__V>(&mut self, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_unit_struct<__V>(&mut self, _: &str, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_newtype_struct<__V>(&mut self, _: &str, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_tuple<__V>(&mut self, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::EnumVisitor {
-        Err(Error)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 #[test]
 fn test_bytes_ser_bytes() {
     let buf = vec![];
@@ -449,12 +304,42 @@ fn test_bytes_ser_bytes() {
 ///////////////////////////////////////////////////////////////////////////////
 
 #[test]
-fn test_byte_buf_de_bytes() {
-    let mut de = BytesDeserializer::new(vec![]);
-    let bytes = Deserialize::deserialize(&mut de);
-    assert_eq!(bytes, Ok(ByteBuf::new()));
+fn test_byte_buf_de() {
+    let empty = ByteBuf::new();
+    assert_de_tokens(&empty, &[Token::Bytes(b""),]);
+    assert_de_tokens(&empty, &[Token::Str("")]);
+    assert_de_tokens(&empty, &[Token::String(String::new())]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(None),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(Some(0)),
+        Token::SeqEnd,
+    ]);
 
-    let mut de = BytesDeserializer::new(vec![1, 2, 3]);
-    let bytes = Deserialize::deserialize(&mut de);
-    assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
+    let buf = ByteBuf::from(vec![65, 66, 67]);
+    assert_de_tokens(&buf, &[Token::Bytes(b"ABC")]);
+    assert_de_tokens(&buf, &[Token::Str("ABC")]);
+    assert_de_tokens(&buf, &[Token::String("ABC".to_owned())]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(None),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(Some(3)),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
 }

testing/tests/test_de.rs

@@ -37,7 +37,10 @@ enum Enum {
     Unit,
     Simple(i32),
     Seq(i32, i32, i32),
-    Map { a: i32, b: i32, c: i32 }
+    Map { a: i32, b: i32, c: i32 },
+    #[allow(dead_code)]
+    #[serde(skip_deserializing)]
+    Skipped,
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -215,6 +218,9 @@ declare_tests! {
             Token::SeqEnd,
         ],
     }
+    test_unit_string {
+        String::new() => &[Token::Unit],
+    }
     test_tuple_struct {
         TupleStruct(1, 2, 3) => &[
             Token::SeqStart(Some(3)),
@@ -802,6 +808,12 @@ declare_error_tests! {
         ],
         Error::UnknownVariant("Foo".to_owned()),
     }
+    test_enum_skipped_variant<Enum> {
+        &[
+            Token::EnumUnit("Enum", "Skipped"),
+        ],
+        Error::UnknownVariant("Skipped".to_owned()),
+    }
     test_struct_seq_too_long<Struct> {
         &[
             Token::SeqStart(Some(4)),

testing/tests/test_ser.rs

@@ -30,12 +30,20 @@ struct Struct {
     c: i32,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, PartialEq, Debug)]
 enum Enum {
     Unit,
     One(i32),
     Seq(i32, i32),
     Map { a: i32, b: i32 },
+    #[serde(skip_serializing)]
+    SkippedUnit,
+    #[serde(skip_serializing)]
+    SkippedOne(i32),
+    #[serde(skip_serializing)]
+    SkippedSeq(i32, i32),
+    #[serde(skip_serializing)]
+    SkippedMap { _a: i32, _b: i32 },
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -388,3 +396,23 @@ fn test_cannot_serialize_paths() {
         &[],
         Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
 }
+
+#[test]
+fn test_enum_skipped() {
+    assert_ser_tokens_error(
+        &Enum::SkippedUnit,
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedOne(42),
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedOne cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedSeq(1, 2),
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedMap { _a: 1, _b: 2 },
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedMap cannot be serialized".to_owned()));
+}