add default and skip properties to Network derive macros

4 files changed, 238 insertions, 198 deletions

diff --git a/derive/src/network/list.rs b/derive/src/network/list.rs
index 79f9739..0c6e626 100644
--- a/derive/src/network/list.rs
+++ b/derive/src/network/list.rs
@@ -7,30 +7,34 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
         .iter()
         .map(|field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
+            if !field.skip {
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
 
-            let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_variant_type(&field);
+                let field_name = field.ident.as_ref().unwrap();
+                let field_type = get_field_variant_type(&field);
 
-            let field_inner = if field.network {
-                if field.map {
-                    quote! { self.#field_name.to_network_map() }
-                } else {
-                    match field.variant.as_ref().map_or("", |m| m.as_str()) {
-                        "VariantMap" => quote! { self.#field_name.to_network_map() },
-                        &_ => quote! { self.#field_name.to_network() },
+                let field_inner = if field.network {
+                    if field.map {
+                        quote! { self.#field_name.to_network_map() }
+                    } else {
+                        match field.variant.as_ref().map_or("", |m| m.as_str()) {
+                            "VariantMap" => quote! { self.#field_name.to_network_map() },
+                            &_ => quote! { self.#field_name.to_network() },
+                        }
                     }
+                } else {
+                    quote! { self.#field_name.clone() }
+                };
+
+                quote! {
+                    res.push(libquassel::primitive::Variant::ByteArray(#field_rename.to_string()));
+                    res.push(libquassel::primitive::Variant::#field_type(#field_inner));
                 }
             } else {
-                quote! { self.#field_name.clone() }
-            };
-
-            quote! {
-                res.push(libquassel::primitive::Variant::ByteArray(#field_rename.to_string()));
-                res.push(libquassel::primitive::Variant::#field_type(#field_inner));
+                quote! {}
             }
         })
         .collect()
@@ -40,56 +44,62 @@ pub(crate) fn from(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
         .iter()
         .map(|field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
-
             let field_name = field.ident.as_ref().unwrap();
 
-            let field_type = get_field_type(&field);
-            let field_variant_type = get_field_variant_type(&field);
+            if field.default {
+                quote! {
+                    #field_name: Default::default(),
+                }
+            } else {
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
 
-            let field_type_colon = get_field_type_colon(field_type.clone());
+                let field_type = get_field_type(&field);
+                let field_variant_type = get_field_variant_type(&field);
 
-            let extract_inner = quote! {
-                let mut i = input.iter();
-                i.position(|x| *x == libquassel::primitive::Variant::ByteArray(String::from(#field_rename)))
-                    .expect(format!("failed to get field {}", #field_rename).as_str());
+                let field_type_colon = get_field_type_colon(field_type.clone());
 
-                match i.next().expect("failed to get next field") {
-                    libquassel::primitive::Variant::#field_variant_type(var) => var.clone(),
-                    _ => panic!("network::list::from: wrong variant type"),
-                }
-            };
+                let extract_inner = quote! {
+                    let mut i = input.iter();
+                    i.position(|x| *x == libquassel::primitive::Variant::ByteArray(String::from(#field_rename)))
+                        .expect(format!("failed to get field {}", #field_rename).as_str());
 
-            if field.network {
-                if field.map {
-                    quote! {
-                        #field_name: #field_type_colon::from_network_map(&mut {
-                            #extract_inner
-                        }),
+                    match i.next().expect("failed to get next field") {
+                        libquassel::primitive::Variant::#field_variant_type(var) => var.clone(),
+                        _ => panic!("network::list::from: wrong variant type"),
                     }
-                } else {
-                    match field.variant.as_ref().map_or("", |m| m.as_str()) {
-                        "VariantMap" => quote! {
+                };
+
+                if field.network {
+                    if field.map {
+                        quote! {
                             #field_name: #field_type_colon::from_network_map(&mut {
                                 #extract_inner
                             }),
-                        },
-                        &_ => quote! {
-                            #field_name: #field_type_colon::from_network(&mut {
-                                #extract_inner
-                            }),
+                        }
+                    } else {
+                        match field.variant.as_ref().map_or("", |m| m.as_str()) {
+                            "VariantMap" => quote! {
+                                #field_name: #field_type_colon::from_network_map(&mut {
+                                    #extract_inner
+                                }),
+                            },
+                            &_ => quote! {
+                                #field_name: #field_type_colon::from_network(&mut {
+                                    #extract_inner
+                                }),
+                            },
+                        }
+                    }
+                } else {
+                    quote! {
+                        #field_name: {
+                            #extract_inner
                         },
                     }
                 }
-            } else {
-                quote! {
-                    #field_name: {
-                        #extract_inner
-                    },
-                }
             }
         })
         .collect()
diff --git a/derive/src/network/map.rs b/derive/src/network/map.rs
index 506ccb3..5402f5a 100644
--- a/derive/src/network/map.rs
+++ b/derive/src/network/map.rs
@@ -7,39 +7,43 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
         .iter()
         .map(|field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
+            if !field.skip {
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
 
-            let field_name = field.ident.as_ref().unwrap();
-            let _field_type = get_field_type(&field);
-            let field_variant_type = get_field_variant_type(&field);
+                let field_name = field.ident.as_ref().unwrap();
+                let _field_type = get_field_type(&field);
+                let field_variant_type = get_field_variant_type(&field);
 
-            let field_inner = if field.network {
-                if field.map {
-                    quote! {
-                        self.#field_name.to_network_map()
+                let field_inner = if field.network {
+                    if field.map {
+                        quote! {
+                            self.#field_name.to_network_map()
+                        }
+                    } else {
+                        match field.variant.as_ref().map_or("", |m| m.as_str()) {
+                            "VariantMap" => quote! {
+                                self.#field_name.to_network_map()
+                            },
+                            &_ => quote! {
+                                self.#field_name.to_network()
+                            },
+                        }
                     }
                 } else {
-                    match field.variant.as_ref().map_or("", |m| m.as_str()) {
-                        "VariantMap" => quote! {
-                            self.#field_name.to_network_map()
-                        },
-                        &_ => quote! {
-                            self.#field_name.to_network()
-                        },
+                    quote! {
+                        self.#field_name.clone()
                     }
-                }
-            } else {
+                };
+
                 quote! {
-                    self.#field_name.clone()
+                    res.insert(#field_rename.to_string(),
+                        libquassel::primitive::Variant::#field_variant_type(#field_inner));
                 }
-            };
-
-            quote! {
-                res.insert(#field_rename.to_string(),
-                    libquassel::primitive::Variant::#field_variant_type(#field_inner));
+            } else {
+                quote! {}
             }
         })
         .collect()
@@ -49,39 +53,46 @@ pub(crate) fn from(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
         .iter()
         .map(|field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
-
             let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_type(&field);
-            let _field_variant_type = get_field_variant_type(&field);
 
-            let field_type_colon = get_field_type_colon(field_type.clone());
+            if field.default {
+                quote! {
+                    #field_name: Default::default(),
+                }
+            } else {
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
+
+                let field_type = get_field_type(&field);
+                let _field_variant_type = get_field_variant_type(&field);
 
-            if field.network {
-                if field.map {
-                    quote! {
-                        #field_name: #field_type_colon::from_network_map(
-                            &mut std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap()),
-                    }
-                } else {
-                    match field.variant.as_ref().map_or("", |m| m.as_str()) {
-                        "VariantMap" => quote! {
-                                    #field_name: #field_type_colon::from_network_map(
-                                        &mut std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap()),
-                                },
+                let field_type_colon = get_field_type_colon(field_type.clone());
 
-                        &_ => quote! {
-                            #field_name: #field_type_colon::from_network(
+                if field.network {
+                    if field.map {
+                        quote! {
+                            #field_name: #field_type_colon::from_network_map(
                                 &mut std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap()),
                         }
+                    } else {
+                        match field.variant.as_ref().map_or("", |m| m.as_str()) {
+                            "VariantMap" => quote! {
+                                        #field_name: #field_type_colon::from_network_map(
+                                            &mut std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap()),
+                                    },
+
+                            &_ => quote! {
+                                #field_name: #field_type_colon::from_network(
+                                    &mut std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap()),
+                            }
+                        }
+                    }
+                } else {
+                    quote! {
+                        #field_name: std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap(),
                     }
-                }
-            } else {
-                quote! {
-                    #field_name: std::convert::TryInto::try_into(input.remove(#field_rename).unwrap()).unwrap(),
                 }
             }
         })
diff --git a/derive/src/network/maplist.rs b/derive/src/network/maplist.rs
index 01d1e20..94eb04b 100644
--- a/derive/src/network/maplist.rs
+++ b/derive/src/network/maplist.rs
@@ -9,36 +9,40 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
         .iter()
         .map(|field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
+            if !field.skip {
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
 
-            let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_variant_type(&field);
+                let field_name = field.ident.as_ref().unwrap();
+                let field_type = get_field_variant_type(&field);
 
-            let field_inner = if field.network {
-                quote! {
-                    self.#field_name.to_network().into()
-                }
-            } else {
-                quote! {
-                    self.#field_name.clone().into()
-                }
-            };
+                let field_inner = if field.network {
+                    quote! {
+                        self.#field_name.to_network().into()
+                    }
+                } else {
+                    quote! {
+                        self.#field_name.clone().into()
+                    }
+                };
 
-            if let Some(_) = field.variant {
-                quote! {
-                    res.insert(#field_rename.to_string(),
-                        libquassel::primitive::Variant::#field_type(
-                            std::vec::from_elem(#field_inner, 1)));
+                if let Some(_) = field.variant {
+                    quote! {
+                        res.insert(#field_rename.to_string(),
+                            libquassel::primitive::Variant::#field_type(
+                                std::vec::from_elem(#field_inner, 1)));
+                    }
+                } else {
+                    quote! {
+                        res.insert(#field_rename.to_string(),
+                            libquassel::primitive::Variant::VariantList(
+                                std::vec::from_elem(#field_inner, 1)));
+                    }
                 }
             } else {
-                quote! {
-                    res.insert(#field_rename.to_string(),
-                        libquassel::primitive::Variant::VariantList(
-                            std::vec::from_elem(#field_inner, 1)));
-                }
+                quote! {}
             }
         })
         .collect()
@@ -52,54 +56,56 @@ pub(crate) fn to_vec(_type_name: &Ident, fields: &Vec<NetworkField>) -> TokenStr
     ) = fields.iter().fold(
         (Vec::new(), Vec::new(), Vec::new()),
         |(mut lists, mut for_each_inner, mut map_inserts), field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
-
-            let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_variant_type(&field);
-
-            let field_inner = if field.network {
-                if field.map {
-                    quote! {
-                        item.#field_name.to_network_map()
+            if !field.skip {
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
+
+                let field_name = field.ident.as_ref().unwrap();
+                let field_type = get_field_variant_type(&field);
+
+                let field_inner = if field.network {
+                    if field.map {
+                        quote! {
+                            item.#field_name.to_network_map()
+                        }
+                    } else {
+                        quote! {
+                            item.#field_name.to_network()
+                        }
                     }
                 } else {
                     quote! {
-                        item.#field_name.to_network()
+                        item.#field_name.clone()
                     }
-                }
-            } else {
-                quote! {
-                    item.#field_name.clone()
-                }
-            };
+                };
 
-            if let Some(_) = field.variant {
-                lists.push(quote! {
-                    let mut #field_name: libquassel::primitive::StringList = Vec::with_capacity(self.len());
-                });
+                if let Some(_) = field.variant {
+                    lists.push(quote! {
+                        let mut #field_name: libquassel::primitive::StringList = Vec::with_capacity(self.len());
+                    });
 
-                for_each_inner.push(quote! {
-                    #field_name.push(#field_inner);
-                });
+                    for_each_inner.push(quote! {
+                        #field_name.push(#field_inner);
+                    });
 
-                map_inserts.push(quote! {
-                    map.insert(String::from(#field_rename), libquassel::primitive::Variant::StringList(#field_name));
-                });
-            } else {
-                lists.push(quote! {
-                    let mut #field_name: libquassel::primitive::VariantList = Vec::with_capacity(self.len());
-                });
+                    map_inserts.push(quote! {
+                        map.insert(String::from(#field_rename), libquassel::primitive::Variant::StringList(#field_name));
+                    });
+                } else {
+                    lists.push(quote! {
+                        let mut #field_name: libquassel::primitive::VariantList = Vec::with_capacity(self.len());
+                    });
 
-                for_each_inner.push(quote! {
-                    #field_name.push(libquassel::primitive::Variant::#field_type(#field_inner));
-                });
+                    for_each_inner.push(quote! {
+                        #field_name.push(libquassel::primitive::Variant::#field_type(#field_inner));
+                    });
 
-                map_inserts.push(quote! {
-                    map.insert(String::from(#field_rename), libquassel::primitive::Variant::VariantList(#field_name));
-                });
+                    map_inserts.push(quote! {
+                        map.insert(String::from(#field_rename), libquassel::primitive::Variant::VariantList(#field_name));
+                    });
+                }
             }
 
             return (lists, for_each_inner, map_inserts);
@@ -125,38 +131,44 @@ pub(crate) fn from(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
         .iter()
         .map(|field| {
-            let field_rename = match &field.rename {
-                Some(name) => name.clone(),
-                None => format!("{}", field.ident.as_ref().unwrap()).into(),
-            };
-
             let field_name = field.ident.as_ref().unwrap();
 
-            let field_type = get_field_variant_type(&field);
-
-            let field_inner = if field.network {
+            if field.default {
                 quote! {
-                    libquassel::message::Network::from_network(&mut std::convert::TryInto::try_into(input.remove(0)).unwrap())
+                    #field_name: Default::default(),
                 }
             } else {
-                quote! {
-                    std::convert::TryInto::try_into(input.remove(0)).unwrap()
-                }
-            };
+                let field_rename = match &field.rename {
+                    Some(name) => name.clone(),
+                    None => format!("{}", field.ident.as_ref().unwrap()).into(),
+                };
 
-            if let Some(_) = field.variant {
-                quote! {
-                    #field_name: match input.get_mut(#field_rename).unwrap() {
-                        libquassel::primitive::Variant::#field_type(input) => #field_inner,
-                        _ => panic!("#field_name: wrong variant")
-                    },
-                }
-            } else {
-                quote! {
-                    #field_name: match input.get_mut(#field_rename).unwrap() {
-                        libquassel::primitive::Variant::VariantList(input) => #field_inner,
-                        _ => panic!("#field_name: wrong variant")
-                    },
+                let field_type = get_field_variant_type(&field);
+
+                let field_inner = if field.network {
+                    quote! {
+                        libquassel::message::Network::from_network(&mut std::convert::TryInto::try_into(input.remove(0)).unwrap())
+                    }
+                } else {
+                    quote! {
+                        std::convert::TryInto::try_into(input.remove(0)).unwrap()
+                    }
+                };
+
+                if let Some(_) = field.variant {
+                    quote! {
+                        #field_name: match input.get_mut(#field_rename).unwrap() {
+                            libquassel::primitive::Variant::#field_type(input) => #field_inner,
+                            _ => panic!("#field_name: wrong variant")
+                        },
+                    }
+                } else {
+                    quote! {
+                        #field_name: match input.get_mut(#field_rename).unwrap() {
+                            libquassel::primitive::Variant::VariantList(input) => #field_inner,
+                            _ => panic!("#field_name: wrong variant")
+                        },
+                    }
                 }
             }
         })
diff --git a/derive/src/network/mod.rs b/derive/src/network/mod.rs
index 61af9c4..61338e5 100644
--- a/derive/src/network/mod.rs
+++ b/derive/src/network/mod.rs
@@ -57,6 +57,13 @@ pub struct NetworkField {
     /// network representation for this field
     #[darling(default)]
     map: bool,
+    /// Skips this field when parsing from network
+    /// representation and uses the default value of the type
+    #[darling(default)]
+    default: bool,
+    /// Skips this field when serializing to network representation
+    #[darling(default)]
+    skip: bool,
 }
 
 fn parse_fields(input: &syn::DeriveInput) -> Vec<NetworkField> {