fix namespace check on deserilization of enum

yaserde/src/ser/mod.rs

@@ -4,7 +4,6 @@
 use crate::YaSerialize;
 use std::io::{Cursor, Write};
 use std::str;
-use xml;
 use xml::writer::XmlEvent;
 use xml::{EmitterConfig, EventWriter};
 

yaserde/tests/namespace.rs

@@ -376,7 +376,7 @@ fn enum_multi_namespaces() {
 fn enum_attribute_namespace() {
   #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
   #[yaserde(
-    rename = "root",
+    rename = "rootA",
     prefix = "ns",
     namespace = "ns: http://www.sample.com/ns/domain"
   )]
@@ -394,9 +394,9 @@ fn enum_attribute_namespace() {
   }
 
   let content = r#"
-    <ns:root xmlns:ns="http://www.sample.com/ns/domain">
+    <ns:rootA xmlns:ns="http://www.sample.com/ns/domain">
       ns:Item
-    </ns:root>
+    </ns:rootA>
   "#;
 
   let model = XmlStruct::Item;
@@ -405,10 +405,10 @@ fn enum_attribute_namespace() {
 
   let model = XmlStruct::ItemWithField("Value".to_string());
 
-  let content = r#"<ns:root xmlns:ns="http://www.sample.com/ns/domain"><ns:ItemWithField>Value</ns:ItemWithField></ns:root>"#;
+  let content = r#"<ns:rootA xmlns:ns="http://www.sample.com/ns/domain"><ns:ItemWithField>Value</ns:ItemWithField></ns:rootA>"#;
   serialize_and_validate!(model, content);
   // TODO
-  // deserialize_and_validate!(content, model, XmlStruct);
+  deserialize_and_validate!(content, model, XmlStruct);
 }
 
 #[test]

yaserde_derive/src/common/attribute.rs

@@ -1,4 +1,4 @@
-use proc_macro2::{token_stream::IntoIter, Delimiter, TokenStream, TokenTree};
+use proc_macro2::{token_stream::IntoIter, Delimiter, Ident, TokenStream, TokenTree};
 use std::collections::BTreeMap;
 use syn::Attribute;
 
@@ -108,6 +108,21 @@ impl YaSerdeAttribute {
     }
   }
 
+  pub fn xml_element_name(&self, ident: &Ident) -> String {
+    self.rename.clone().unwrap_or_else(|| ident.to_string())
+  }
+
+  pub fn prefix_namespace(&self) -> String {
+    if self.default_namespace == self.prefix {
+      "".to_string()
+    } else {
+      self
+        .clone()
+        .prefix
+        .map_or("".to_string(), |prefix| prefix + ":")
+    }
+  }
+
   pub fn get_namespace_matching(
     &self,
     prefix: &Option<String>,

yaserde_derive/src/common/field.rs

@@ -2,7 +2,6 @@ use crate::common::attribute::YaSerdeAttribute;
 use proc_macro2::Span;
 use proc_macro2::{Ident, TokenStream};
 use std::fmt;
-use syn;
 use syn::spanned::Spanned;
 use syn::Type::Path;
 
@@ -34,10 +33,6 @@ impl YaSerdeField {
     self.attributes.flatten
   }
 
-  // pub fn get_attributes(&self) -> YaSerdeAttribute {
-  //   self.attributes.clone()
-  // }
-
   pub fn label(&self) -> Option<Ident> {
     self.syn_field.ident.clone()
   }

yaserde_derive/src/de/expand_enum.rs

@@ -8,6 +8,13 @@ pub fn parse(
   root: &str,
   root_attributes: &YaSerdeAttribute,
 ) -> TokenStream {
+  let namespaces_matching = root_attributes.get_namespace_matching(
+    &None,
+    quote!(enum_namespace),
+    quote!(named_element),
+    true,
+  );
+
   let match_to_enum: TokenStream = data_enum
     .variants
     .iter()
@@ -27,21 +34,24 @@ pub fn parse(
     impl YaDeserialize for #name {
       #[allow(unused_variables)]
       fn deserialize<R: Read>(reader: &mut yaserde::de::Deserializer<R>) -> Result<Self, String> {
-        let named_element =
+        let (named_element, enum_namespace) =
           if let XmlEvent::StartElement{name, ..} = reader.peek()?.to_owned() {
-            name.local_name.to_owned()
+            (name.local_name.to_owned(), name.namespace.clone())
           } else {
-            String::from(#root)
+            (String::from(#root), None)
           };
+
         debug!("Enum: start to parse {:?}", named_element);
 
+        #namespaces_matching
+
         #[allow(unused_assignments, unused_mut)]
         let mut enum_value = None;
 
         loop {
           match reader.peek()?.to_owned() {
             XmlEvent::StartElement{ref name, ref attributes, ..} => {
-
+              println!("{:?}", name.local_name.as_str());
               match name.local_name.as_str() {
                 #match_to_enum
                 _named_element => {
@@ -90,9 +100,7 @@ pub fn parse(
 }
 
 fn parse_variant(variant: &syn::Variant, name: &Ident) -> Option<TokenStream> {
-  let xml_element_name = YaSerdeAttribute::parse(&variant.attrs)
+  let xml_element_name = YaSerdeAttribute::parse(&variant.attrs).xml_element_name(&variant.ident);
-    .rename
-    .unwrap_or_else(|| variant.ident.to_string());
 
   let variant_name = {
     let label = &variant.ident;
@@ -218,17 +226,6 @@ fn build_unnamed_visitor_calls(
         Some(quote! {
           let visitor = #visitor_label{};
 
-          if let Some(namespace) = name.namespace.as_ref() {
-            match namespace.as_str() {
-              bad_ns => {
-                let msg = format!("bad field namespace for {}, found {}",
-                  name.local_name.as_str(),
-                  bad_ns);
-                return Err(msg);
-              }
-            }
-          }
-
           let result = reader.read_inner_value::<#field_type, _>(|reader| {
             if let XmlEvent::EndElement { .. } = *reader.peek()? {
               return visitor.#visitor("");

yaserde_derive/src/de/mod.rs

@@ -4,7 +4,6 @@ pub mod expand_struct;
 
 use crate::common::YaSerdeAttribute;
 use proc_macro2::TokenStream;
-use syn;
 use syn::Ident;
 
 pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<TokenStream, String> {
@@ -13,10 +12,12 @@ pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<TokenStream,
   let data = &ast.data;
 
   let root_attributes = YaSerdeAttribute::parse(attrs);
-  let root_name = root_attributes
+
-    .clone()
+  let root_name = format!(
-    .rename
+    "{}{}",
-    .unwrap_or_else(|| name.to_string());
+    root_attributes.prefix_namespace(),
+    root_attributes.xml_element_name(name)
+  );
 
   let impl_block = match *data {
     syn::Data::Struct(ref data_struct) => {

yaserde_derive/src/ser/mod.rs

@@ -7,7 +7,6 @@ pub mod namespace;
 
 use crate::common::YaSerdeAttribute;
 use proc_macro2::TokenStream;
-use syn;
 use syn::Ident;
 
 pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<TokenStream, String> {
@@ -16,21 +15,12 @@ pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<TokenStream, St
   let data = &ast.data;
 
   let root_attributes = YaSerdeAttribute::parse(attrs);
-  let root_name = root_attributes
-    .clone()
-    .rename
-    .unwrap_or_else(|| name.to_string());
 
-  let prefix = if root_attributes.default_namespace == root_attributes.prefix {
+  let root_name = format!(
-    "".to_string()
+    "{}{}",
-  } else {
+    root_attributes.prefix_namespace(),
-    root_attributes
+    root_attributes.xml_element_name(name)
-      .clone()
+  );
-      .prefix
-      .map_or("".to_string(), |prefix| prefix + ":")
-  };
-
-  let root_name = format!("{}{}", prefix, root_name);
 
   let impl_block = match *data {
     syn::Data::Struct(ref data_struct) => {