mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format with rustfmt 0.6.0

Browse Source
This commit is contained in:
David Tolnay 2018-04-30 01:41:22 -07:00
parent 89278996c5
commit d82d1707d6
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
10 changed files with 152 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
serde/src/private/de.rs
View File

@ -1311,9 +1311,7 @@ mod content {
V: Visitor<'de>,
{
match self.content {
Content::Newtype(v) => {
visitor.visit_newtype_struct(ContentDeserializer::new(*v))
}
Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
_ => visitor.visit_newtype_struct(self),
}
}

2
serde_derive/src/try.rs
View File

@ -1,5 +1,5 @@
use quote::Tokens;
use proc_macro2::{Op, Spacing};
use quote::Tokens;
// None of our generated code requires the `From::from` error conversion
// performed by the standard library's `try!` macro. With this simplified macro

20
test_suite/tests/bytes/mod.rs
View File

@ -1,8 +1,9 @@
use serde::de::{Deserializer, Visitor, SeqAccess, Error};
use serde::de::{Deserializer, Error, SeqAccess, Visitor};
use std::fmt;
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
deserializer.deserialize_byte_buf(ByteBufVisitor)
}
@ -17,7 +18,8 @@ impl<'de> Visitor<'de> for ByteBufVisitor {
}
fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where V: SeqAccess<'de>
where
V: SeqAccess<'de>,
{
let mut values = Vec::new();
while let Some(value) = try!(visitor.next_element()) {
@ -27,25 +29,29 @@ impl<'de> Visitor<'de> for ByteBufVisitor {
}
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v.to_vec())
}
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v)
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v.as_bytes().to_vec())
}
fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
where E: Error
where
E: Error,
{
Ok(v.into_bytes())
}

102
test_suite/tests/test_annotations.rs
View File

@ -12,9 +12,9 @@
extern crate serde_derive;
extern crate serde;
use std::collections::HashMap;
use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
use self::serde::de::{self, Unexpected};
use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::collections::HashMap;
extern crate serde_test;
use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens,
@ -114,10 +114,7 @@ struct FlattenStructEnumWrapper {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
enum FlattenStructEnum {
InsertInteger {
index: u32,
value: u32
},
InsertInteger { index: u32, value: u32 },
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
@ -133,10 +130,7 @@ struct FlattenStructTagContentEnumNewtype(pub FlattenStructTagContentEnum);
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case", tag = "type", content = "value")]
enum FlattenStructTagContentEnum {
InsertInteger {
index: u32,
value: u32
},
InsertInteger { index: u32, value: u32 },
NewtypeVariant(FlattenStructTagContentEnumNewtypeVariant),
}
@ -529,12 +523,10 @@ enum RenameEnumSerializeDeserialize<A> {
fn test_rename_enum() {
assert_tokens(
&RenameEnum::Batman,
&[
Token::UnitVariant {
name: "Superhero",
variant: "bruce_wayne",
},
],
&[Token::UnitVariant {
name: "Superhero",
variant: "bruce_wayne",
}],
);
assert_tokens(
@ -1221,12 +1213,7 @@ fn test_missing_renamed_field_enum() {
#[derive(Debug, PartialEq, Deserialize)]
enum InvalidLengthEnum {
A(i32, i32, i32),
B(
#[serde(skip_deserializing)]
i32,
i32,
i32,
),
B(#[serde(skip_deserializing)] i32, i32, i32),
}
#[test]
@ -1345,7 +1332,7 @@ fn test_flatten_struct_enum() {
let change_request = FlattenStructEnumWrapper {
data: FlattenStructEnum::InsertInteger {
index: 0,
value: 42
value: 42,
},
extra,
};
@ -1362,7 +1349,7 @@ fn test_flatten_struct_enum() {
Token::MapEnd,
Token::Str("extra_key"),
Token::Str("extra value"),
Token::MapEnd
Token::MapEnd,
],
);
assert_ser_tokens(
@ -1370,7 +1357,10 @@ fn test_flatten_struct_enum() {
&[
Token::Map { len: None },
Token::Str("insert_integer"),
Token::Struct { len: 2, name: "insert_integer" },
Token::Struct {
len: 2,
name: "insert_integer",
},
Token::Str("index"),
Token::U32(0),
Token::Str("value"),
@ -1378,7 +1368,7 @@ fn test_flatten_struct_enum() {
Token::StructEnd,
Token::Str("extra_key"),
Token::Str("extra value"),
Token::MapEnd
Token::MapEnd,
],
);
}
@ -1387,12 +1377,10 @@ fn test_flatten_struct_enum() {
fn test_flatten_struct_tag_content_enum() {
let change_request = FlattenStructTagContentEnumWrapper {
outer: 42,
data: FlattenStructTagContentEnumNewtype(
FlattenStructTagContentEnum::InsertInteger {
index: 0,
value: 42
}
),
data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::InsertInteger {
index: 0,
value: 42,
}),
};
assert_de_tokens(
&change_request,
@ -1421,7 +1409,10 @@ fn test_flatten_struct_tag_content_enum() {
Token::Str("type"),
Token::Str("insert_integer"),
Token::Str("value"),
Token::Struct { len: 2, name: "insert_integer" },
Token::Struct {
len: 2,
name: "insert_integer",
},
Token::Str("index"),
Token::U32(0),
Token::Str("value"),
@ -1436,13 +1427,9 @@ fn test_flatten_struct_tag_content_enum() {
fn test_flatten_struct_tag_content_enum_newtype() {
let change_request = FlattenStructTagContentEnumWrapper {
outer: 42,
data: FlattenStructTagContentEnumNewtype(
FlattenStructTagContentEnum::NewtypeVariant(
FlattenStructTagContentEnumNewtypeVariant {
value: 23
}
)
),
data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::NewtypeVariant(
FlattenStructTagContentEnumNewtypeVariant { value: 23 },
)),
};
assert_de_tokens(
&change_request,
@ -1469,7 +1456,10 @@ fn test_flatten_struct_tag_content_enum_newtype() {
Token::Str("type"),
Token::Str("newtype_variant"),
Token::Str("value"),
Token::Struct { len: 1, name: "FlattenStructTagContentEnumNewtypeVariant" },
Token::Struct {
len: 1,
name: "FlattenStructTagContentEnumNewtypeVariant",
},
Token::Str("value"),
Token::U32(23),
Token::StructEnd,
@ -1525,7 +1515,7 @@ fn test_complex_flatten() {
first: First,
#[serde(flatten)]
second: Second,
z: u32
z: u32,
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
@ -1552,10 +1542,8 @@ fn test_complex_flatten() {
d: "c".into(),
e: Some(2),
},
second: Second {
f: 3
},
z: 4
second: Second { f: 3 },
z: 4,
},
&[
Token::Map { len: None },
@ -1592,10 +1580,8 @@ fn test_complex_flatten() {
d: "c".into(),
e: Some(2),
},
second: Second {
f: 3
},
z: 4
second: Second { f: 3 },
z: 4,
},
&[
Token::Map { len: None },
@ -1652,7 +1638,7 @@ fn test_flatten_unsupported_type() {
Token::Str("foo"),
Token::Str("a"),
Token::Str("b"),
Token::MapEnd
Token::MapEnd,
],
"can only flatten structs and maps",
);
@ -1671,7 +1657,11 @@ fn test_non_string_keys() {
let mut mapping = HashMap::new();
mapping.insert(0, 42);
assert_tokens(
&TestStruct { name: "peter".into(), age: 3, mapping },
&TestStruct {
name: "peter".into(),
age: 3,
mapping,
},
&[
Token::Map { len: None },
Token::Str("name"),
@ -1720,7 +1710,9 @@ fn test_lifetime_propagation_for_flatten() {
let mut borrowed_map = HashMap::new();
borrowed_map.insert("x", 42u32);
assert_ser_tokens(
&B { t: borrowed_map.clone() },
&B {
t: borrowed_map.clone(),
},
&[
Token::Map { len: None },
Token::BorrowedStr("x"),
@ -1742,7 +1734,9 @@ fn test_lifetime_propagation_for_flatten() {
let mut borrowed_map = HashMap::new();
borrowed_map.insert(&b"x"[..], 42u32);
assert_ser_tokens(
&C { t: borrowed_map.clone() },
&C {
t: borrowed_map.clone(),
},
&[
Token::Map { len: None },
Token::Seq { len: Some(1) },

8
test_suite/tests/test_de.rs
View File

@ -12,14 +12,14 @@
extern crate serde_derive;
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::net;
use std::path::{Path, PathBuf};
use std::time::{Duration, UNIX_EPOCH};
use std::default::Default;
use std::ffi::{CString, OsString};
use std::net;
use std::num::Wrapping;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::Arc;
use std::num::Wrapping;
use std::time::{Duration, UNIX_EPOCH};
#[cfg(feature = "unstable")]
use std::ffi::CStr;

75
test_suite/tests/test_gen.rs
View File

@ -17,8 +17,8 @@
extern crate serde_derive;
extern crate serde;
use self::serde::ser::{Serialize, Serializer};
use self::serde::de::{DeserializeOwned, Deserializer};
use self::serde::ser::{Serialize, Serializer};
use std::borrow::Cow;
use std::marker::PhantomData;
@ -92,14 +92,10 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
enum EnumWith<T> {
Unit,
Newtype(
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
X,
),
Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X),
Tuple(
T,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
X,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
),
Struct {
t: T,
@ -122,17 +118,13 @@ fn test_gen() {
assert_ser::<MultipleRef<i32>>();
#[derive(Serialize, Deserialize)]
struct Newtype(
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
X,
);
struct Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X);
assert::<Newtype>();
#[derive(Serialize, Deserialize)]
struct Tuple<T>(
T,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
X,
#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
);
assert::<Tuple<i32>>();
@ -191,12 +183,16 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
#[serde(bound = "D: SerializeWith + DeserializeWith")]
struct WithTraits1<D, E> {
#[serde(serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with")]
#[serde(
serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with"
)]
d: D,
#[serde(serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with",
bound = "E: SerializeWith + DeserializeWith")]
#[serde(
serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with",
bound = "E: SerializeWith + DeserializeWith"
)]
e: E,
}
assert::<WithTraits1<X, X>>();
@ -204,13 +200,18 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
#[serde(bound(serialize = "D: SerializeWith", deserialize = "D: DeserializeWith"))]
struct WithTraits2<D, E> {
#[serde(serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with")]
#[serde(
serialize_with = "SerializeWith::serialize_with",
deserialize_with = "DeserializeWith::deserialize_with"
)]
d: D,
#[serde(serialize_with = "SerializeWith::serialize_with",
bound(serialize = "E: SerializeWith"))]
#[serde(deserialize_with = "DeserializeWith::deserialize_with",
bound(deserialize = "E: DeserializeWith"))]
#[serde(
serialize_with = "SerializeWith::serialize_with", bound(serialize = "E: SerializeWith")
)]
#[serde(
deserialize_with = "DeserializeWith::deserialize_with",
bound(deserialize = "E: DeserializeWith")
)]
e: E,
}
assert::<WithTraits2<X, X>>();
@ -270,17 +271,11 @@ fn test_gen() {
struct EmptyTupleDenyUnknown();
#[derive(Serialize, Deserialize)]
struct TupleSkipAll(
#[serde(skip_deserializing)]
u8,
);
struct TupleSkipAll(#[serde(skip_deserializing)] u8);
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct TupleSkipAllDenyUnknown(
#[serde(skip_deserializing)]
u8,
);
struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
#[derive(Serialize, Deserialize)]
enum EmptyEnum {}
@ -305,10 +300,7 @@ fn test_gen() {
#[serde(skip_deserializing)]
f: u8,
},
TupleSkip(
#[serde(skip_deserializing)]
u8,
),
TupleSkip(#[serde(skip_deserializing)] u8),
}
#[cfg(feature = "unstable")]
@ -321,10 +313,7 @@ fn test_gen() {
#[serde(skip_deserializing)]
f: u8,
},
TupleSkip(
#[serde(skip_deserializing)]
u8,
),
TupleSkip(#[serde(skip_deserializing)] u8),
}
#[derive(Serialize, Deserialize)]
@ -531,7 +520,9 @@ fn test_gen() {
assert::<SkippedStaticStr>();
macro_rules! T {
() => { () }
() => {
()
};
}
#[derive(Serialize, Deserialize)]
@ -559,7 +550,7 @@ fn test_gen() {
#[derive(Serialize, Deserialize)]
struct AssocDerive<T: AssocSerde> {
assoc: T::Assoc
assoc: T::Assoc,
}
assert::<AssocDerive<NoSerdeImpl>>();

78
test_suite/tests/test_macros.rs
View File

@ -7,7 +7,6 @@
// except according to those terms.
#![deny(trivial_numeric_casts)]
#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
#[macro_use]
@ -226,12 +225,10 @@ fn test_de_named_map() {
fn test_ser_enum_unit() {
assert_ser_tokens(
&SerEnum::Unit::<u32, u32, u32>,
&[
Token::UnitVariant {
name: "SerEnum",
variant: "Unit",
},
],
&[Token::UnitVariant {
name: "SerEnum",
variant: "Unit",
}],
);
}
@ -296,12 +293,10 @@ fn test_ser_enum_map() {
fn test_de_enum_unit() {
assert_tokens(
&DeEnum::Unit::<u32, u32, u32>,
&[
Token::UnitVariant {
name: "DeEnum",
variant: "Unit",
},
],
&[Token::UnitVariant {
name: "DeEnum",
variant: "Unit",
}],
);
}
@ -478,10 +473,7 @@ fn test_adjacently_tagged_newtype_struct() {
assert_de_tokens(
&E::Newtype(GenericNewTypeStruct(5u32)),
&[
Token::Struct {
name: "E",
len: 2,
},
Token::Struct { name: "E", len: 2 },
Token::Str("c"),
Token::NewtypeStruct {
name: "GenericNewTypeStruct",
@ -514,12 +506,10 @@ fn test_generic_tuple_struct() {
fn test_generic_enum_unit() {
assert_tokens(
&GenericEnum::Unit::<u32, u32>,
&[
Token::UnitVariant {
name: "GenericEnum",
variant: "Unit",
},
],
&[Token::UnitVariant {
name: "GenericEnum",
variant: "Unit",
}],
);
}
@ -846,7 +836,9 @@ fn test_internally_tagged_bytes() {
}
assert_de_tokens(
&InternallyTagged::String { string: "\0".to_owned() },
&InternallyTagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "String",
@ -861,7 +853,9 @@ fn test_internally_tagged_bytes() {
);
assert_de_tokens(
&InternallyTagged::String { string: "\0".to_owned() },
&InternallyTagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "String",
@ -876,7 +870,9 @@ fn test_internally_tagged_bytes() {
);
assert_de_tokens(
&InternallyTagged::String { string: "\0".to_owned() },
&InternallyTagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "String",
@ -891,7 +887,9 @@ fn test_internally_tagged_bytes() {
);
assert_de_tokens(
&InternallyTagged::String { string: "\0".to_owned() },
&InternallyTagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "String",
@ -1402,12 +1400,10 @@ fn test_enum_in_untagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Unit),
&[
Token::UnitVariant {
name: "Inner",
variant: "Unit",
},
],
&[Token::UnitVariant {
name: "Inner",
variant: "Unit",
}],
);
assert_tokens(
@ -1465,7 +1461,9 @@ fn test_untagged_bytes() {
}
assert_de_tokens(
&Untagged::String { string: "\0".to_owned() },
&Untagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "Untagged",
@ -1478,7 +1476,9 @@ fn test_untagged_bytes() {
);
assert_de_tokens(
&Untagged::String { string: "\0".to_owned() },
&Untagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "Untagged",
@ -1491,7 +1491,9 @@ fn test_untagged_bytes() {
);
assert_de_tokens(
&Untagged::String { string: "\0".to_owned() },
&Untagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "Untagged",
@ -1504,7 +1506,9 @@ fn test_untagged_bytes() {
);
assert_de_tokens(
&Untagged::String { string: "\0".to_owned() },
&Untagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "Untagged",

27
test_suite/tests/test_remote.rs
View File

@ -121,10 +121,7 @@ struct UnitDef;
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::PrimitivePriv")]
struct PrimitivePrivDef(
#[serde(getter = "remote::PrimitivePriv::get")]
u8,
);
struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] u8);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::PrimitivePub")]
@ -132,34 +129,22 @@ struct PrimitivePubDef(u8);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePriv")]
struct NewtypePrivDef(
#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")]
remote::Unit,
);
struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePub")]
struct NewtypePubDef(
#[serde(with = "UnitDef")]
remote::Unit,
);
struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::TuplePriv")]
struct TuplePrivDef(
#[serde(getter = "remote::TuplePriv::first")]
u8,
#[serde(getter = "remote::TuplePriv::second", with = "UnitDef")]
remote::Unit,
#[serde(getter = "remote::TuplePriv::first")] u8,
#[serde(getter = "remote::TuplePriv::second", with = "UnitDef")] remote::Unit,
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::TuplePub")]
struct TuplePubDef(
u8,
#[serde(with = "UnitDef")]
remote::Unit,
);
struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::StructPriv")]

8
test_suite/tests/test_ser.rs
View File

@ -10,13 +10,13 @@
extern crate serde_derive;
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
use std::net;
use std::path::{Path, PathBuf};
use std::time::{Duration, UNIX_EPOCH};
use std::ffi::CString;
use std::net;
use std::num::Wrapping;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::Arc;
use std::num::Wrapping;
use std::time::{Duration, UNIX_EPOCH};
#[cfg(unix)]
use std::str;

2
test_suite/tests/test_value.rs
View File

@ -10,8 +10,8 @@
extern crate serde_derive;
extern crate serde;
use serde::Deserialize;
use serde::de::{value, IntoDeserializer};
use serde::Deserialize;
#[test]
fn test_u32_to_enum() {