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

feat(codegen): Remove #[serde(skip_serializing_if_{none,empty})]

Browse Source 
`#[serde(skip_serializing_if="...")]` can replace this functionality.
This commit is contained in:
Erick Tryzelaar 2016-02-18 19:31:43 -08:00
parent 40f8e6b061
commit c268eb2258
3 changed files with 16 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
serde_codegen/src/attr.rs
View File

@ -167,8 +167,6 @@ pub struct FieldAttrs {
deserialize_name: Option<ast::Lit>,
skip_serializing_field: bool,
skip_serializing_field_if: Option<P<ast::Expr>>,
skip_serializing_field_if_empty: bool,
skip_serializing_field_if_none: bool,
default_expr_if_missing: Option<P<ast::Expr>>,
serialize_with: Option<P<ast::Expr>>,
deserialize_with: Option<P<ast::Expr>>,
@ -193,8 +191,6 @@ impl FieldAttrs {
deserialize_name: None,
skip_serializing_field: false,
skip_serializing_field_if: None,
skip_serializing_field_if_empty: false,
skip_serializing_field_if_none: false,
default_expr_if_missing: None,
serialize_with: None,
deserialize_with: None,
@ -251,16 +247,6 @@ impl FieldAttrs {
field_attrs.skip_serializing_field_if = Some(expr);
}
// Parse `#[serde(skip_serializing_if_none)]`
ast::MetaItemKind::Word(ref name) if name == &"skip_serializing_if_none" => {
field_attrs.skip_serializing_field_if_none = true;
}
// Parse `#[serde(skip_serializing_if_empty)]`
ast::MetaItemKind::Word(ref name) if name == &"skip_serializing_if_empty" => {
field_attrs.skip_serializing_field_if_empty = true;
}
// Parse `#[serde(serialize_with="...")]`
ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize_with" => {
let expr = wrap_serialize_with(
@ -345,14 +331,6 @@ impl FieldAttrs {
self.skip_serializing_field_if.as_ref()
}
pub fn skip_serializing_field_if_empty(&self) -> bool {
self.skip_serializing_field_if_empty
}
pub fn skip_serializing_field_if_none(&self) -> bool {
self.skip_serializing_field_if_none
}
pub fn serialize_with(&self) -> Option<&P<ast::Expr>> {
self.serialize_with.as_ref()
}

44
serde_codegen/src/ser.rs
View File

@ -657,19 +657,10 @@ fn serialize_struct_visitor(
let key_expr = field_attr.serialize_name_expr();
let stmt = match field_attr.skip_serializing_field_if() {
Some(expr) => {
let stmt = if let Some(expr) = field_attr.skip_serializing_field_if() {
Some(quote_stmt!(cx, if $expr { continue; }))
}
None => {
if field_attr.skip_serializing_field_if_empty() {
Some(quote_stmt!(cx, if self.value.$name.is_empty() { continue; }))
} else if field_attr.skip_serializing_field_if_none() {
Some(quote_stmt!(cx, if self.value.$name.is_none() { continue; }))
} else {
None
}
}
} else {
None
};
let field_expr = match field_attr.serialize_with() {
@ -702,26 +693,15 @@ fn serialize_struct_visitor(
.strip_bounds()
.build();
let len = fields.iter().zip(field_attrs.iter())
.map(|(field, field_attr)| {
if field_attr.skip_serializing_field() {
quote_expr!(cx, 0)
} else {
match field_attr.skip_serializing_field_if() {
Some(expr) => {
quote_expr!(cx, if $expr { 0 } else { 1 })
}
None => {
let name = field.node.ident().expect("struct has unnamed field");
if field_attr.skip_serializing_field_if_empty() {
quote_expr!(cx, if self.value.$name.is_empty() { 0 } else { 1 })
} else if field_attr.skip_serializing_field_if_none() {
quote_expr!(cx, if self.value.$name.is_none() { 0 } else { 1 })
} else {
quote_expr!(cx, 1)
}
}
let len = field_attrs.iter()
.filter(|field_attr| !field_attr.skip_serializing_field())
.map(|field_attr| {
match field_attr.skip_serializing_field_if() {
Some(expr) => {
quote_expr!(cx, if $expr { 0 } else { 1 })
}
None => {
quote_expr!(cx, 1)
}
}
})

48
serde_tests/tests/test_annotations.rs
View File

@ -389,16 +389,12 @@ fn test_rename_enum() {
}
#[derive(Debug, PartialEq, Serialize)]
struct SkipSerializingStruct<'a, B, C, D, E> where C: Trait {
struct SkipSerializingStruct<'a, B, C> where C: Trait {
a: &'a i8,
#[serde(skip_serializing)]
b: B,
#[serde(skip_serializing_if="self.c.should_skip()")]
c: C,
#[serde(skip_serializing_if_none)]
d: Option<D>,
#[serde(skip_serializing_if_empty)]
e: Vec<E>,
}
#[test]
@ -409,11 +405,9 @@ fn test_skip_serializing_struct() {
a: &a,
b: 2,
c: 3,
d: Some(4),
e: vec![5],
},
&[
Token::StructStart("SkipSerializingStruct", Some(4)),
Token::StructStart("SkipSerializingStruct", Some(2)),
Token::StructSep,
Token::Str("a"),
@ -423,18 +417,6 @@ fn test_skip_serializing_struct() {
Token::Str("c"),
Token::I32(3),
Token::StructSep,
Token::Str("d"),
Token::Option(true),
Token::I32(4),
Token::StructSep,
Token::Str("e"),
Token::SeqStart(Some(1)),
Token::SeqSep,
Token::I32(5),
Token::SeqEnd,
Token::StructEnd,
]
);
@ -444,8 +426,6 @@ fn test_skip_serializing_struct() {
a: &a,
b: 2,
c: 123,
d: None::<u8>,
e: Vec::<u8>::new(),
},
&[
Token::StructStart("SkipSerializingStruct", Some(1)),
@ -460,17 +440,13 @@ fn test_skip_serializing_struct() {
}
#[derive(Debug, PartialEq, Serialize)]
enum SkipSerializingEnum<'a, B, C, D, E> where C: Trait {
enum SkipSerializingEnum<'a, B, C> where C: Trait {
Struct {
a: &'a i8,
#[serde(skip_serializing)]
_b: B,
#[serde(skip_serializing_if="self.c.should_skip()")]
c: C,
#[serde(skip_serializing_if_none)]
d: Option<D>,
#[serde(skip_serializing_if_empty)]
e: Vec<E>,
}
}
@ -482,11 +458,9 @@ fn test_skip_serializing_enum() {
a: &a,
_b: 2,
c: 3,
d: Some(4),
e: vec![5],
},
&[
Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(4)),
Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(2)),
Token::EnumMapSep,
Token::Str("a"),
@ -496,18 +470,6 @@ fn test_skip_serializing_enum() {
Token::Str("c"),
Token::I32(3),
Token::EnumMapSep,
Token::Str("d"),
Token::Option(true),
Token::I32(4),
Token::EnumMapSep,
Token::Str("e"),
Token::SeqStart(Some(1)),
Token::SeqSep,
Token::I32(5),
Token::SeqEnd,
Token::EnumMapEnd,
]
);
@ -517,8 +479,6 @@ fn test_skip_serializing_enum() {
a: &a,
_b: 2,
c: 123,
d: None::<u8>,
e: Vec::<u8>::new(),
},
&[
Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)),