Merge pull request #49 from ImJeremyHe/jh/deny-unknown

feat: support deny_unknown_fields

Author: ImJeremyHe

Diff for: derives/src/container.rs

@@ -1,5 +1,6 @@
 use crate::symbol::{
-    DEFAULT, NAME, ROOT, SKIP_SERIALIZING, TYPE, VEC_SIZE, WITH_CUSTOM_NS, WITH_NS, XML_SERDE,
+    DEFAULT, DENY_UNKNOWN, NAME, ROOT, SKIP_SERIALIZING, TYPE, VEC_SIZE, WITH_CUSTOM_NS, WITH_NS,
+    XML_SERDE,
 };
 use proc_macro2::{Group, Span, TokenStream, TokenTree};
 use syn::parse::{self, Parse};
@@ -16,6 +17,7 @@ pub struct Container<'a> {
     pub with_ns: Option<syn::LitByteStr>,
     pub custom_ns: Vec<(syn::LitByteStr, syn::LitByteStr)>,
     pub root: Option<syn::LitByteStr>,
+    pub deny_unknown: bool,
 }
 
 impl<'a> Container<'a> {
@@ -27,12 +29,16 @@ impl<'a> Container<'a> {
         if self.root.is_some() && self.is_enum() {
             panic!("for clarity, enum should not have the root attribute. please use a struct to wrap the enum and set its type to untag")
         }
+        if self.deny_unknown && self.is_enum() {
+            panic!("`deny_unknown_fields` is not supported in enum type")
+        }
     }
 
     pub fn from_ast(item: &'a syn::DeriveInput, _derive: Derive) -> Container<'a> {
         let mut with_ns = Option::<syn::LitByteStr>::None;
         let mut custom_ns = Vec::<(syn::LitByteStr, syn::LitByteStr)>::new();
         let mut root = Option::<syn::LitByteStr>::None;
+        let mut deny_unknown = false;
         for meta_item in item
             .attrs
             .iter()
@@ -49,6 +55,9 @@ impl<'a> Container<'a> {
                     let s = get_lit_byte_str(&m.value).expect("parse root failed");
                     root = Some(s.clone());
                 }
+                Meta::Path(p) if p == DENY_UNKNOWN => {
+                    deny_unknown = true;
+                }
                 Meta::List(l) if l.path == WITH_CUSTOM_NS => {
                     let strs = l
                         .parse_args_with(Punctuated::<syn::LitByteStr, Comma>::parse_terminated)
@@ -80,6 +89,7 @@ impl<'a> Container<'a> {
                     with_ns,
                     custom_ns,
                     root,
+                    deny_unknown,
                 }
             }
             syn::Data::Enum(e) => {
@@ -95,6 +105,7 @@ impl<'a> Container<'a> {
                     with_ns,
                     custom_ns,
                     root,
+                    deny_unknown,
                 }
             }
             syn::Data::Union(_) => panic!("Only support struct and enum type, union is found"),

Diff for: derives/src/de.rs

@@ -169,6 +169,21 @@ pub fn get_de_struct_impl_block(container: Container) -> proc_macro2::TokenStrea
     } else {
         quote! {}
     };
+    let encounter_unknown = if container.deny_unknown {
+        quote! {panic!("encoutnering unknown field: {_filed:?}")}
+    } else {
+        quote! {}
+    };
+    let encounter_unknown_branch = quote! {
+        Ok(Event::Empty(_s)) => {
+            let _field = _s.name().into_inner();
+            #encounter_unknown
+        }
+        Ok(Event::Start(_s)) => {
+            let _field = _s.name().into_inner();
+            #encounter_unknown
+        }
+    };
     quote! {
         #[allow(unused_assignments)]
         impl #impl_generics ::xmlserde::XmlDeserialize for #ident #type_generics #where_clause {
@@ -183,7 +198,10 @@ pub fn get_de_struct_impl_block(container: Container) -> proc_macro2::TokenStrea
                     if let Ok(attr) = attr {
                         match attr.key.into_inner() {
                             #(#attr_branches)*
-                            _ => {},
+                            _ => {
+                                let _field = attr.key.into_inner();
+                                #encounter_unknown;
+                            },
                         }
                     }
                 });
@@ -199,6 +217,7 @@ pub fn get_de_struct_impl_block(container: Container) -> proc_macro2::TokenStrea
                             #sfc_branch
                             #child_branches
                             #text_branch
+                            #encounter_unknown_branch
                             Ok(Event::Eof) => break,
                             Err(_) => break,
                             _ => {},

Diff for: derives/src/symbol.rs

@@ -4,6 +4,7 @@ use syn::{Ident, Path};
 #[derive(Copy, Clone)]
 pub struct Symbol(&'static str);
 
+pub const DENY_UNKNOWN: Symbol = Symbol("deny_unknown_fields");
 pub const WITH_NS: Symbol = Symbol("with_ns");
 pub const WITH_CUSTOM_NS: Symbol = Symbol("with_custom_ns");
 pub const ROOT: Symbol = Symbol("root");

Diff for: tests/lib.rs

@@ -689,4 +689,56 @@ mod tests {
         let expect = xml_serialize(text_p);
         assert_eq!(expect, xml);
     }
+
+    #[test]
+    #[should_panic]
+    fn test_unknown_fields_in_struct_deny_unknown_attr() {
+        #[derive(Debug, XmlSerialize, XmlDeserialize)]
+        #[xmlserde(root = b"pet")]
+        #[xmlserde(deny_unknown_fields)]
+        pub struct Pet {
+            #[xmlserde(ty = "attr", name = b"name")]
+            pub name: String,
+        }
+        let xml = r#"<pet name="Chaplin" age="1"/>"#;
+        let _ = xml_deserialize_from_str::<Pet>(&xml);
+    }
+
+    #[test]
+    fn test_unknown_fields_in_struct_accept_unknown_attr() {
+        #[derive(Debug, XmlSerialize, XmlDeserialize)]
+        #[xmlserde(root = b"pet")]
+        pub struct Pet {
+            #[xmlserde(ty = "attr", name = b"name")]
+            pub name: String,
+        }
+        let xml = r#"<pet name="Chaplin" age="1"/>"#;
+        let _ = xml_deserialize_from_str::<Pet>(&xml);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_unknown_fields_in_struct_deny_unknown_field() {
+        #[derive(Debug, XmlSerialize, XmlDeserialize)]
+        #[xmlserde(root = b"pet")]
+        #[xmlserde(deny_unknown_fields)]
+        pub struct Pet {
+            #[xmlserde(ty = "attr", name = b"name")]
+            pub name: String,
+        }
+        let xml = r#"<pet name="Chaplin"><weight/></pet>"#;
+        let _ = xml_deserialize_from_str::<Pet>(&xml);
+    }
+
+    #[test]
+    fn test_unknown_fields_in_struct_accept_unknown_field() {
+        #[derive(Debug, XmlSerialize, XmlDeserialize)]
+        #[xmlserde(root = b"pet")]
+        pub struct Pet {
+            #[xmlserde(ty = "attr", name = b"name")]
+            pub name: String,
+        }
+        let xml = r#"<pet name="Chaplin"><weight/></pet>"#;
+        let _ = xml_deserialize_from_str::<Pet>(&xml);
+    }
 }