Implement choice

xml_schema/tests/choice.rs

@@ -0,0 +1,101 @@
+extern crate yaserde_derive;
+
+use xml_schema_derive::XmlSchema;
+use yaserde::de::from_str;
+use yaserde::ser::to_string;
+
+#[test]
+fn choice() {
+  #[derive(Debug, XmlSchema)]
+  #[xml_schema(source = "xml_schema/tests/choice.xsd")]
+  struct ChoiceTypeSchema;
+
+  use choice_type_schema::xml_schema_types::*;
+
+  let xml_1 = r#"<?xml version="1.0" encoding="UTF-8"?>
+  <person>
+    <firstname>John</firstname>
+  </person>
+  "#;
+
+  let sample_1: Person = from_str(xml_1).unwrap();
+
+  let model = Person {
+    firstname: Some(Firstname {
+      base: "John".to_string(),
+      scope: None,
+    }),
+    lastname: None,
+  };
+
+  assert_eq!(sample_1, model);
+
+  let data = to_string(&model).unwrap();
+  assert_eq!(
+    data,
+    r#"<?xml version="1.0" encoding="utf-8"?><Person><firstname>John</firstname></Person>"#
+  );
+}
+
+#[test]
+fn choice_sequence() {
+  #[derive(Debug, XmlSchema)]
+  #[xml_schema(source = "xml_schema/tests/choice_sequence.xsd")]
+  struct ChoiceTypeSchema;
+
+  use choice_type_schema::xml_schema_types::*;
+
+  let xml_1 = r#"<?xml version="1.0" encoding="UTF-8"?>
+  <person>
+    <name>Doe</name>
+    <firstname>John</firstname>
+  </person>
+  "#;
+
+  let sample_1: Person = from_str(xml_1).unwrap();
+
+  let model = Person {
+    name: "Doe".to_string(),
+    firstname: Some(Firstname {
+      base: "John".to_string(),
+      scope: None,
+    }),
+    lastname: None,
+  };
+
+  assert_eq!(sample_1, model);
+
+  let data = to_string(&model).unwrap();
+  assert_eq!(
+    data,
+    r#"<?xml version="1.0" encoding="utf-8"?><Person><name>Doe</name><firstname>John</firstname></Person>"#
+  );
+}
+
+#[test]
+fn choice_multiple() {
+  #[derive(Debug, XmlSchema)]
+  #[xml_schema(source = "xml_schema/tests/choice_multiple.xsd")]
+  struct ChoiceTypeSchema;
+
+  let xml_1 = r#"<?xml version="1.0" encoding="UTF-8"?>
+  <person>
+    <firstname>John</firstname>
+  </person>
+  "#;
+
+  let sample_1: Person = from_str(xml_1).unwrap();
+
+  let model = Person {
+    firstname_list: vec!["John".to_string()],
+    lastname_list: vec![],
+  };
+
+  assert_eq!(sample_1, model);
+
+  let data = to_string(&model).unwrap();
+  assert_eq!(
+    data,
+    r#"<?xml version="1.0" encoding="utf-8"?><Person><firstname>John</firstname></Person>"#
+  );
+}

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="person">
+        <xs:choice minOccurs="0">
+            <xs:element name="firstname" type="firstname"/>
+            <xs:element name="lastname" type="lastname"/>
+        </xs:choice>
+    </xs:complexType>
+</xs:schema>

xml_schema/tests/choice_multiple.xsd

@@ -0,0 +1,10 @@
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    <xs:element name="person">
+        <xs:complexType name="parents">
+            <xs:choice minOccurs="0" maxOccurs="unbounded">
+                <xs:element name="firstname" type="xs:string"/>
+                <xs:element name="lastname" type="xs:string"/>
+            </xs:choice>
+        </xs:complexType>
+    </xs:element>
+</xs:schema>

xml_schema/tests/choice_sequence.xsd

@@ -0,0 +1,29 @@
+<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:element name="person">
+        <xs:complexType name="parent">
+            <xs:sequence>
+                <xs:element name="name" type="xs:string" minOccurs="1"/>
+                <xs:choice>
+                    <xs:element name="firstname" type="firstname"/>
+                    <xs:element name="lastname" type="lastname"/>
+                </xs:choice>
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+</xs:schema>

xml_schema_derive/src/xsd/choice.rs

@@ -0,0 +1,89 @@
+//! 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::info;
+use proc_macro2::TokenStream;
+
+#[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_sub_types_implementation(
+    &self,
+    context: &XsdContext,
+    namespace_definition: &TokenStream,
+    prefix: &Option<String>,
+  ) -> TokenStream {
+    info!("Generate choice sub types implementation");
+    self
+      .element
+      .iter()
+      .map(|element| element.get_subtypes_implementation(namespace_definition, prefix, context))
+      .collect()
+  }
+
+  pub fn get_field_implementation(
+    &self,
+    context: &XsdContext,
+    prefix: &Option<String>,
+  ) -> TokenStream {
+    info!("Generate choice elements");
+
+    let multiple = matches!(self.min_occurences, Some(min_occurences) if min_occurences > 1)
+      || matches!(self.max_occurences, Some(MaxOccurences::Unbounded))
+      || matches!(self.max_occurences, Some(MaxOccurences::Number{value}) if value > 1);
+
+    // Element fields are by default declared as Option type due to the nature of the choice element.
+    // Since a vector can also be empty, use Vec<_>, rather than Option<Vec<_>>.
+    let optional = !multiple;
+
+    self
+      .element
+      .iter()
+      .map(|element| element.get_field_implementation(context, prefix, multiple, optional))
+      .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::ToUpperCamelCase;
@@ -17,13 +17,16 @@
   pub name: String,
   #[yaserde(rename = "attribute")]
   pub attributes: Vec<Attribute>,
+  #[yaserde(rename = "sequence")]
   pub sequence: Option<Sequence>,
   #[yaserde(rename = "simpleContent")]
   pub simple_content: Option<SimpleContent>,
   #[yaserde(rename = "complexContent")]
   pub complex_content: Option<ComplexContent>,
   #[yaserde(rename = "annotation")]
   pub annotation: Option<Annotation>,
+  #[yaserde(rename = "choice")]
+  pub choice: Option<Choice>,
 }
 
 impl Implementation for ComplexType {
@@ -69,7 +72,7 @@
       .map(|attribute| attribute.implement(namespace_definition, prefix, context))
       .collect();
 
-    let sub_types_implementation = self
+    let sequence_sub_types = self
       .sequence
       .as_ref()
       .map(|sequence| sequence.get_sub_types_implementation(context, namespace_definition, prefix))
@@ -81,6 +84,18 @@
       .map(|annotation| annotation.implement(namespace_definition, prefix, context))
       .unwrap_or_default();
 
+    let choice_sub_types = self
+      .choice
+      .as_ref()
+      .map(|choice| choice.get_sub_types_implementation(context, &namespace_definition, prefix))
+      .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
 
@@ -90,10 +105,12 @@
         #sequence
         #simple_content
         #complex_content
+        #choice_field
         #attributes
       }
 
-      #sub_types_implementation
+      #sequence_sub_types
+      #choice_sub_types
     }
   }
 }
@@ -110,12 +127,20 @@
         .as_ref()
         .map(|sequence| sequence.get_field_implementation(context, prefix))
         .unwrap_or_default()
-    } else {
+    } else if self.simple_content.is_some() {
       self
         .simple_content
         .as_ref()
         .map(|simple_content| simple_content.get_field_implementation(context, prefix))
         .unwrap_or_default()
+    } else if self.choice.is_some() {
+      self
+        .choice
+        .as_ref()
+        .map(|choice| choice.get_field_implementation(context, prefix))
+        .unwrap_or_else(TokenStream::new)
+    } else {
+      TokenStream::new()
     }
   }