initial choice type support

Author: marcelbuesing

xml_schema/tests/choice.rs

@@ -0,0 +1,41 @@
+#[macro_use]
+extern crate yaserde_derive;
+
+use log::debug;
+use std::io::prelude::*;
+use xml_schema_derive::XmlSchema;
+use yaserde::de::from_str;
+use yaserde::ser::to_string;
+use yaserde::{YaDeserialize, YaSerialize};
+
+#[test]
+fn choice() {
+  #[derive(Debug, XmlSchema)]
+  #[xml_schema(source = "xml_schema/tests/choice.xsd")]
+  struct ChoiceTypeSchema;
+
+  let xml_1 = r#"
+  <?xml version="1.0" encoding="UTF-8"?>
+  <Parent>
+    <XFirstname>John</XFirstname>
+  </Parent>
+  "#;
+
+  let sample_1: Parent = from_str(xml_1).unwrap();
+
+  let model = Parent {
+    x_firstname: Some(Firstname {
+      content: "John".to_string(),
+      scope: None,
+    }),
+    x_lastname: None,
+  };
+
+  assert_eq!(sample_1, model);
+
+  let data = to_string(&model).unwrap();
+  assert_eq!(
+    data,
+    r#"<?xml version="1.0" encoding="utf-8"?><Parent><XFirstname>John</XFirstname></Parent>"#
+  );
+}

xml_schema/tests/choice.xsd

@@ -0,0 +1,25 @@
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    <xs:complexType name="Firstname">
+        <xs:simpleContent>
+            <xs:extension base="xs:string">
+                <xs:attribute name="scope" type="xs:anyURI" use="optional" default="http://example.com#elements"/>
+            </xs:extension>
+        </xs:simpleContent>
+    </xs:complexType>
+
+    <xs:complexType name="Lastname">
+        <xs:simpleContent>
+            <xs:extension base="xs:string">
+                <xs:attribute name="scope" type="xs:anyURI" use="optional" default="http://example.com#elements"/>
+            </xs:extension>
+        </xs:simpleContent>
+    </xs:complexType>
+
+
+    <xs:complexType name="Parent">
+        <xs:choice maxOccurs="unbounded" minOccurs="0">
+            <xs:element name="XFirstname" type="Firstname"/>
+            <xs:element name="XLastname" type="Lastname"/>
+        </xs:choice>
+    </xs:complexType>
+</xs:schema>

xml_schema_derive/src/xsd/choice.rs

@@ -0,0 +1,68 @@
+//! The children of a choice are mapped to Option fields.
+//! Generating an enum would have been the better way but the choice element
+//! may not have a name, so it's impossible to name the generated Rust enum.
+//! The enum would have been nice to avoid runtime checks that only a single choice element is used.
+
+use crate::xsd::{
+  annotation::Annotation, attribute::Attribute, element::Element, max_occurences::MaxOccurences,
+  Implementation, XsdContext,
+};
+use log::{debug, info};
+use proc_macro2::TokenStream;
+use std::io::prelude::*;
+use yaserde::YaDeserialize;
+
+#[derive(Clone, Default, Debug, PartialEq, YaDeserialize)]
+#[yaserde(
+  rename = "choice"
+  prefix = "xs",
+  namespace = "xs: http://www.w3.org/2001/XMLSchema"
+)]
+pub struct Choice {
+  #[yaserde(attribute)]
+  pub id: Option<String>,
+  #[yaserde(rename = "attribute")]
+  pub attributes: Vec<Attribute>,
+  #[yaserde(rename = "minOccurs", attribute)]
+  pub min_occurences: Option<u64>,
+  #[yaserde(rename = "maxOccurs", attribute)]
+  pub max_occurences: Option<MaxOccurences>,
+  #[yaserde(rename = "annotation")]
+  pub annotation: Option<Annotation>,
+  #[yaserde(rename = "element")]
+  pub element: Vec<Element>,
+}
+
+impl Implementation for Choice {
+  fn implement(
+    &self,
+    namespace_definition: &TokenStream,
+    prefix: &Option<String>,
+    context: &XsdContext,
+  ) -> TokenStream {
+    let elements: TokenStream = self
+      .element
+      .iter()
+      .map(|element| element.implement(&namespace_definition, prefix, context))
+      .collect();
+
+    quote! {
+      #elements
+    }
+  }
+}
+
+impl Choice {
+  pub fn get_field_implementation(
+    &self,
+    context: &XsdContext,
+    prefix: &Option<String>,
+  ) -> TokenStream {
+    info!("Generate choice elements");
+    self
+      .element
+      .iter()
+      .map(|element| element.get_field_implementation(context, prefix, false, true))
+      .collect()
+  }
+}

xml_schema_derive/src/xsd/complex_type.rs

@@ -1,5 +1,5 @@
 use crate::xsd::{
-  annotation::Annotation, attribute::Attribute, complex_content::ComplexContent,
+  annotation::Annotation, attribute::Attribute, choice::Choice, complex_content::ComplexContent,
   sequence::Sequence, simple_content::SimpleContent, Implementation, XsdContext,
 };
 use heck::CamelCase;
@@ -27,6 +27,8 @@ pub struct ComplexType {
   pub complex_content: Option<ComplexContent>,
   #[yaserde(rename = "annotation")]
   pub annotation: Option<Annotation>,
+  #[yaserde(rename = "choice")]
+  pub choice: Option<Choice>,
 }
 
 impl Implementation for ComplexType {
@@ -84,6 +86,18 @@ impl Implementation for ComplexType {
       .map(|annotation| annotation.implement(&namespace_definition, prefix, context))
       .unwrap_or_else(TokenStream::new);
 
+    let choice = self
+      .choice
+      .as_ref()
+      .map(|choice| choice.implement(&namespace_definition, prefix, context))
+      .unwrap_or_else(TokenStream::new);
+
+    let choice_field = self
+      .choice
+      .as_ref()
+      .map(|choice| choice.get_field_implementation(context, prefix))
+      .unwrap_or_else(TokenStream::new);
+
     quote! {
       #docs
 
@@ -93,10 +107,13 @@ impl Implementation for ComplexType {
         #sequence
         #simple_content
         #complex_content
+        #choice_field
         #attributes
       }
 
       #sub_types_implementation
+
+      #choice
     }
   }
 }

xml_schema_derive/src/xsd/element.rs

@@ -106,6 +106,7 @@ impl Element {
     context: &XsdContext,
     prefix: &Option<String>,
     multiple: bool,
+    optional: bool,
   ) -> TokenStream {
     if self.name == "" {
       return quote!();
@@ -143,7 +144,7 @@ impl Element {
       rust_type
     };
 
-    let rust_type = if self.min_occurences == Some(0) {
+    let rust_type = if optional || self.min_occurences == Some(0) {
       quote!(Option<#rust_type>)
     } else {
       rust_type

xml_schema_derive/src/xsd/extension.rs

@@ -1,6 +1,6 @@
 use crate::xsd::{
-  attribute::Attribute, rust_types_mapping::RustTypesMapping, sequence::Sequence, Implementation,
-  XsdContext,
+  attribute::Attribute, choice::Choice, rust_types_mapping::RustTypesMapping, sequence::Sequence,
+  Implementation, XsdContext,
 };
 use log::debug;
 use proc_macro2::TokenStream;

xml_schema_derive/src/xsd/mod.rs

@@ -1,6 +1,7 @@
 mod annotation;
 mod attribute;
 mod attribute_group;
+mod choice;
 mod complex_content;
 mod complex_type;
 mod element;

xml_schema_derive/src/xsd/sequence.rs

@@ -22,7 +22,7 @@ impl Implementation for Sequence {
     self
       .elements
       .iter()
-      .map(|element| element.get_field_implementation(context, prefix, false))
+      .map(|element| element.get_field_implementation(context, prefix, false, false))
       .collect()
   }
 }
@@ -50,7 +50,7 @@ impl Sequence {
     self
       .elements
       .iter()
-      .map(|element| element.get_field_implementation(context, prefix, true))
+      .map(|element| element.get_field_implementation(context, prefix, true, false))
       .collect()
   }
 }