rewrite network derive to work more consistently

this mainly ensures that the network and override_type / variant options
work across the board

3 files changed, 90 insertions, 78 deletions

diff --git a/derive/src/network/list.rs b/derive/src/network/list.rs
index 75aecd0..8b1556e 100644
--- a/derive/src/network/list.rs
+++ b/derive/src/network/list.rs
@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 
-use super::{gen_type, get_field_type, get_field_type_colon, get_field_variant_type, NetworkField};
+use super::{get_field_type, get_field_type_colon, get_field_variant_type, NetworkField};
 
 pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
     fields
@@ -13,7 +13,7 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
             };
 
             let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_type(&field);
+            let field_type = get_field_variant_type(&field);
 
             let field_inner = if field.network {
                 quote! { self.#field_name.to_network() }
@@ -21,18 +21,9 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
                 quote! { self.#field_name.clone() }
             };
 
-            match &field.variant {
-                Some(variant_type) => {
-                    let variant_type = gen_type(variant_type.as_str());
-                    quote! {
-                        res.push(crate::primitive::Variant::ByteArray(#field_rename.to_string()));
-                        res.push(crate::primitive::Variant::#variant_type(#field_inner));
-                    }
-                }
-                None => quote! {
-                    res.push(crate::primitive::Variant::ByteArray(#field_rename.to_string()));
-                    res.push(crate::primitive::Variant::#field_type(#field_inner));
-                },
+            quote! {
+                res.push(crate::primitive::Variant::ByteArray(#field_rename.to_string()));
+                res.push(crate::primitive::Variant::#field_type(#field_inner));
             }
         })
         .collect()
@@ -57,10 +48,10 @@ pub(crate) fn from(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
             let extract_inner = quote! {
                 let mut i = input.iter();
                 i.position(|x| *x == crate::primitive::Variant::ByteArray(String::from(#field_rename)))
-                    .unwrap();
+                    .expect(format!("failed to get field {}", #field_rename).as_str());
 
-                match i.next().unwrap() {
-                    crate::primitive::Variant::#field_variant_type(input) => input.clone(),
+                match i.next().expect("failed to get next field") {
+                    crate::primitive::Variant::#field_variant_type(var) => var.clone(),
                     _ => panic!("network::list::from: wrong variant type"),
                 }
             };
diff --git a/derive/src/network/maplist.rs b/derive/src/network/maplist.rs
index c92b279..09fbe50 100644
--- a/derive/src/network/maplist.rs
+++ b/derive/src/network/maplist.rs
@@ -1,6 +1,8 @@
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 
+use crate::network::get_field_variant_type;
+
 use super::{get_field_type, NetworkField};
 
 pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
@@ -13,21 +15,29 @@ pub(crate) fn to(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
             };
 
             let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_type(&field);
-
-            match &field.variant {
-                Some(variant_type) => match variant_type.as_str() {
-                    "StringList" => quote! {
-                        res.insert(#field_rename.to_string(),
-                            crate::primitive::Variant::StringList(
-                                std::vec::from_elem(self.#field_name.clone(), 1)));
-                    },
-                    _ => panic!("network::map::to: not one of the avaible variants")
+            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()
+                }
+            };
+
+            if let Some(_) = field.variant {
+                quote! {
+                    res.insert(#field_rename.to_string(),
+                        crate::primitive::Variant::#field_type(
+                            std::vec::from_elem(#field_inner, 1)));
                 }
-                None => quote! {
+            } else {
+                quote! {
                     res.insert(#field_rename.to_string(),
                         crate::primitive::Variant::VariantList(
-                            std::vec::from_elem(crate::primitive::Variant::#field_type(self.#field_name.clone()), 1)));
+                            std::vec::from_elem(#field_inner, 1)));
                 }
             }
         })
@@ -48,38 +58,42 @@ pub(crate) fn to_vec(_type_name: &Ident, fields: &Vec<NetworkField>) -> TokenStr
             };
 
             let field_name = field.ident.as_ref().unwrap();
-            let field_type = get_field_type(&field);
-
-            match &field.variant {
-                None => {
-                    lists.push(quote! {
-                        let mut #field_name: crate::primitive::VariantList = Vec::with_capacity(self.len());
-                    });
-
-                    for_each_inner.push(quote! {
-                        #field_name.push(crate::primitive::Variant::#field_type(item.#field_name.clone()));
-                    });
+            let field_type = get_field_variant_type(&field);
 
-                    map_inserts.push(quote! {
-                        map.insert(String::from(#field_rename), crate::primitive::Variant::VariantList(#field_name));
-                    });
+            let field_inner = if field.network {
+                quote! {
+                    item.#field_name.to_network()
                 }
-                Some(variant_type) => match variant_type.as_str() {
-                    "StringList" => {
-                        lists.push(quote! {
-                            let mut #field_name: crate::primitive::StringList = Vec::with_capacity(self.len());
-                        });
-
-                        for_each_inner.push(quote! {
-                            #field_name.push(item.#field_name.clone());
-                        });
-
-                        map_inserts.push(quote! {
-                            map.insert(String::from(#field_rename), crate::primitive::Variant::StringList(#field_name));
-                        });
-                    }
-                    _ => panic!("network::map::to: not one of the avaible variants")
+            } else {
+                quote! {
+                    item.#field_name.clone()
                 }
+            };
+
+            if let Some(_) = field.variant {
+                lists.push(quote! {
+                    let mut #field_name: crate::primitive::StringList = Vec::with_capacity(self.len());
+                });
+
+                for_each_inner.push(quote! {
+                    #field_name.push(#field_inner);
+                });
+
+                map_inserts.push(quote! {
+                    map.insert(String::from(#field_rename), crate::primitive::Variant::StringList(#field_name));
+                });
+            } else {
+                lists.push(quote! {
+                    let mut #field_name: crate::primitive::VariantList = Vec::with_capacity(self.len());
+                });
+
+                for_each_inner.push(quote! {
+                    #field_name.push(crate::primitive::Variant::#field_type(#field_inner));
+                });
+
+                map_inserts.push(quote! {
+                    map.insert(String::from(#field_rename), crate::primitive::Variant::VariantList(#field_name));
+                });
             }
 
             return (lists, for_each_inner, map_inserts);
@@ -112,23 +126,31 @@ pub(crate) fn from(fields: &Vec<NetworkField>) -> Vec<TokenStream> {
 
             let field_name = field.ident.as_ref().unwrap();
 
-            let _field_type = get_field_type(&field);
+            let field_type = get_field_variant_type(&field);
+
+            let field_inner = if field.network {
+                quote! {
+                    crate::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()
+                }
+            };
 
-            match &field.variant {
-                None => quote! {
+            if let Some(_) = field.variant {
+                quote! {
                     #field_name: match input.get_mut(#field_rename).unwrap() {
-                        crate::primitive::Variant::VariantList(input) => std::convert::TryInto::try_into(input.remove(0)).unwrap(),
+                        crate::primitive::Variant::#field_type(input) => #field_inner,
                         _ => panic!("#field_name: wrong variant")
                     },
-                },
-                Some(variant_type) => match variant_type.as_str() {
-                    "StringList" => quote! {
-                        #field_name: match input.get_mut(#field_rename).unwrap() {
-                            crate::primitive::Variant::StringList(input) => input.remove(0),
-                            _ => panic!("#field_name: wrong variant")
-                        },
+                }
+            } else {
+                quote! {
+                    #field_name: match input.get_mut(#field_rename).unwrap() {
+                        crate::primitive::Variant::VariantList(input) => #field_inner,
+                        _ => panic!("#field_name: wrong variant")
                     },
-                    _ => panic!("network::map::to: not one of the avaible variants"),
                 }
             }
         })
@@ -145,12 +167,14 @@ pub(crate) fn from_vec(type_name: &Ident, fields: &Vec<NetworkField>) -> TokenSt
 
     let _field_name = field.ident.as_ref().unwrap();
 
+    let field_type = get_field_variant_type(field);
+
     let field_variant = match &field.variant {
         None => quote! {crate::primitive::VariantList},
         Some(variant_type) => match variant_type.as_str() {
             "StringList" => quote! {crate::primitive::StringList},
             "VariantMap" => quote! {crate::primitive::VariantMap},
-            _ => panic!("network::map::from_vec: not one of the avaible variants"),
+            _ => quote! {crate::primitive::VariantMap},
         },
     };
 
diff --git a/derive/src/network/mod.rs b/derive/src/network/mod.rs
index f39bedd..d62ac98 100644
--- a/derive/src/network/mod.rs
+++ b/derive/src/network/mod.rs
@@ -18,6 +18,9 @@ pub struct Network {
     repr: Repr,
 }
 
+/// List:
+/// Map:
+/// Maplist:
 #[derive(Debug, Clone, Copy, FromMeta)]
 #[darling(default)]
 pub enum Repr {
@@ -182,13 +185,7 @@ fn get_field_type(field: &NetworkField) -> syn::Type {
 fn get_field_variant_type(field: &NetworkField) -> syn::Type {
     match &field.variant {
         Some(ty) => gen_type(&ty),
-        None => {
-            if let Some(override_type) = &field.override_type {
-                gen_type(override_type)
-            } else {
-                field.ty.clone()
-            }
-        }
+        None => get_field_type(field),
     }
 }