format code

Author: MarcAntoine-Arnaud

xml_schema/tests/complex_type.rs

@@ -0,0 +1,39 @@
+#[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 complex_type_string() {
+  #[derive(Debug, XmlSchema)]
+  #[xml_schema(source = "xml_schema/tests/complex_type.xsd")]
+  struct ComplexTypeSchema;
+
+  let xml_1 = r#"
+  <?xml version="1.0" encoding="UTF-8"?>
+  <ComplexListOfElements>
+    <Annotation>Test content</Annotation>
+    <Label>Label content</Label>
+  </ComplexListOfElements>
+  "#;
+
+  let sample_1: ComplexListOfElements = from_str(xml_1).unwrap();
+
+  let model = ComplexListOfElements {
+    annotation: Some("Test content".to_string()),
+    label: "Label content".to_string(),
+  };
+
+  assert_eq!(sample_1, model);
+
+  let data = to_string(&model).unwrap();
+  assert_eq!(
+    data,
+    r#"<?xml version="1.0" encoding="utf-8"?><ComplexListOfElements><Annotation>Test content</Annotation><Label>Label content</Label></ComplexListOfElements>"#
+  );
+}

xml_schema/tests/complex_type.xsd

@@ -0,0 +1,16 @@
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:complexType name="ComplexListOfElements">
+    <xs:sequence>
+      <xs:element name="Annotation" type="xs:string" minOccurs="0"/>
+      <xs:element name="Label">
+        <xs:complexType>
+          <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>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>

xml_schema/tests/simple_type_list.xsd

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
-  xmlns:am="http://www.smpte-ra.org/schemas/429-9/2007/AM">
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
 
   <xs:complexType name="BaseType">
     <xs:attribute name="strings" type="StringList"/>

xml_schema_derive/src/xsd/complex_content.rs

@@ -1,5 +1,6 @@
-use crate::xsd::extension::Extension;
+use crate::xsd::{extension::Extension, xsd_context::XsdContext};
 use log::debug;
+use proc_macro2::TokenStream;
 use std::io::Read;
 use yaserde::YaDeserialize;
 
@@ -8,3 +9,17 @@ use yaserde::YaDeserialize;
 pub struct ComplexContent {
   pub extension: Option<Extension>,
 }
+
+impl ComplexContent {
+  pub fn get_field_implementation(
+    &self,
+    context: &XsdContext,
+    prefix: &Option<String>,
+  ) -> TokenStream {
+    self
+      .extension
+      .as_ref()
+      .unwrap()
+      .get_field_implementation(context, prefix)
+  }
+}

xml_schema_derive/src/xsd/complex_type.rs

@@ -54,9 +54,17 @@ impl Implementation for ComplexType {
       .map(|simple_content| simple_content.implement(namespace_definition, prefix, context))
       .unwrap_or_else(TokenStream::new);
 
-    if self.complex_content.is_some() {
-      debug!("Complex Content: {:?}", self);
-    }
+    let complex_content = self
+      .complex_content
+      .as_ref()
+      .map(|complex_content| {
+        let complex_content_type = complex_content.get_field_implementation(context, prefix);
+        quote!(
+          #[yaserde(flatten)]
+          #complex_content_type,
+        )
+      })
+      .unwrap_or_else(TokenStream::new);
 
     let attributes: TokenStream = self
       .attributes
@@ -84,6 +92,7 @@ impl Implementation for ComplexType {
       pub struct #struct_name {
         #sequence
         #simple_content
+        #complex_content
         #attributes
       }
 
@@ -95,14 +104,22 @@ impl Implementation for ComplexType {
 impl ComplexType {
   pub fn get_field_implementation(
     &self,
-    prefix: &Option<String>,
     context: &XsdContext,
+    prefix: &Option<String>,
   ) -> TokenStream {
-    self
-      .sequence
-      .as_ref()
-      .map(|sequence| sequence.get_field_implementation(context, prefix))
-      .unwrap_or_else(TokenStream::new)
+    if self.sequence.is_some() {
+      self
+        .sequence
+        .as_ref()
+        .map(|sequence| sequence.get_field_implementation(context, prefix))
+        .unwrap_or_else(TokenStream::new)
+    } else {
+      self
+        .simple_content
+        .as_ref()
+        .map(|simple_content| simple_content.get_field_implementation(context, prefix))
+        .unwrap_or_else(TokenStream::new)
+    }
   }
 
   pub fn get_integrated_implementation(&self, parent_name: &str) -> TokenStream {
@@ -116,9 +133,5 @@ impl ComplexType {
     }
 
     quote!(String)
-    // println!("{:?}", self);
-    // panic!(
-    //   "[Complex Type] Unimplemented complex type for parent element {:?}", parent_name
-    // );
   }
 }

xml_schema_derive/src/xsd/element.rs

@@ -1,6 +1,6 @@
 use crate::xsd::{
   annotation::Annotation, complex_type::ComplexType, max_occurences::MaxOccurences,
-  rust_types_mapping::RustTypesMapping, Implementation, XsdContext,
+  rust_types_mapping::RustTypesMapping, simple_type::SimpleType, Implementation, XsdContext,
 };
 use heck::{CamelCase, SnakeCase};
 use log::{debug, info};
@@ -23,7 +23,9 @@ pub struct Element {
   #[yaserde(rename = "maxOccurs", attribute)]
   pub max_occurences: Option<MaxOccurences>,
   #[yaserde(rename = "complexType")]
-  pub complex_type: Vec<ComplexType>,
+  pub complex_type: Option<ComplexType>,
+  #[yaserde(rename = "simpleType")]
+  pub simple_type: Option<SimpleType>,
   #[yaserde(rename = "annotation")]
   pub annotation: Option<Annotation>,
 }
@@ -40,7 +42,7 @@ impl Implementation for Element {
       Span::call_site(),
     );
 
-    let fields = if let Some(kind) = &self.kind {
+    let (fields, extra_structs) = if let Some(kind) = &self.kind {
       let subtype_mode = if RustTypesMapping::is_xs_string(context, kind) {
         quote!(text)
       } else {
@@ -49,16 +51,21 @@ impl Implementation for Element {
 
       let extern_type = RustTypesMapping::get(context, kind);
 
-      quote!(
-        #[yaserde(#subtype_mode)]
-        pub content: #extern_type,
+      (
+        quote!(
+          #[yaserde(#subtype_mode)]
+          pub content: #extern_type,
+        ),
+        quote!(),
       )
     } else {
-      self
+      let fields_definition = self
         .complex_type
         .iter()
-        .map(|complex_type| complex_type.get_field_implementation(prefix, context))
-        .collect()
+        .map(|complex_type| complex_type.get_field_implementation(context, prefix))
+        .collect();
+
+      (fields_definition, quote!())
     };
 
     let docs = self
@@ -74,6 +81,8 @@ impl Implementation for Element {
       pub struct #struct_name {
         #fields
       }
+
+      #extra_structs
     }
   }
 }
@@ -85,7 +94,7 @@ impl Element {
     prefix: &Option<String>,
     context: &XsdContext,
   ) -> TokenStream {
-    if self.complex_type.is_empty() {
+    if self.complex_type.is_none() {
       return quote!();
     }
 
@@ -115,8 +124,10 @@ impl Element {
     let attribute_name = Ident::new(&name, Span::call_site());
     let yaserde_rename = &self.name;
 
-    let rust_type = if let Some(complex_type) = self.complex_type.first() {
+    let rust_type = if let Some(complex_type) = &self.complex_type {
       complex_type.get_integrated_implementation(&self.name)
+    } else if let Some(simple_type) = &self.simple_type {
+      simple_type.get_type_implementation(context, &Some(self.name.to_owned()))
     } else if let Some(kind) = &self.kind {
       RustTypesMapping::get(context, kind)
     } else {
@@ -168,7 +179,8 @@ mod tests {
       refers: None,
       min_occurences: None,
       max_occurences: None,
-      complex_type: vec![],
+      complex_type: None,
+      simple_type: None,
       annotation: Some(Annotation {
         id: None,
         attributes: vec![],
@@ -199,7 +211,8 @@ mod tests {
       refers: None,
       min_occurences: None,
       max_occurences: None,
-      complex_type: vec![],
+      complex_type: None,
+      simple_type: None,
       annotation: Some(Annotation {
         id: None,
         attributes: vec![],

xml_schema_derive/src/xsd/extension.rs

@@ -51,6 +51,17 @@ impl Implementation for Extension {
   }
 }
 
+impl Extension {
+  pub fn get_field_implementation(
+    &self,
+    context: &XsdContext,
+    _prefix: &Option<String>,
+  ) -> TokenStream {
+    let rust_type = RustTypesMapping::get(context, &self.base);
+    quote!(pub content : #rust_type)
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;

xml_schema_derive/src/xsd/rust_types_mapping.rs

@@ -23,7 +23,7 @@ impl RustTypesMapping {
         RustTypesMapping::basic_type(*items.last().unwrap())
       }
     } else {
-      unimplemented!();
+      panic!("Unknown type {}", kind)
     }
   }
 

xml_schema_derive/src/xsd/simple_content.rs

@@ -23,3 +23,13 @@ impl Implementation for SimpleContent {
       .implement(namespace_definition, prefix, context)
   }
 }
+
+impl SimpleContent {
+  pub fn get_field_implementation(
+    &self,
+    context: &XsdContext,
+    prefix: &Option<String>,
+  ) -> TokenStream {
+    self.extension.get_field_implementation(context, prefix)
+  }
+}