xavier-derive 0.1.7

Derive module of Xavier. Xavier is a lightweight and versatile XML parsing library designed to streamline the process of handling XML data with ease and efficiency.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use proc_macro2::{Ident, TokenStream};
use quote::{quote, ToTokens};
use syn::{LitStr, Type};
use crate::common::meta::MetaInfo;
use crate::common::naming::names::XmlNames;
use crate::serialize::parser::extension::XmlExtension;
use crate::serialize::parser::types::is_outer_option;

pub enum XmlTagElement {
    Complex(Ident, LitStr, XmlExtension),
    Simple(Ident, Type, LitStr, bool, XmlExtension),
    Collection(Ident, Type, LitStr, LitStr, XmlExtension),
}

impl ToTokens for XmlTagElement {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let tag_tokens = match self {
            XmlTagElement::Simple(field, ty, name, is_value, extensions) => {
                if is_outer_option(&ty) {
                    quote! {
                        if self.#field.is_none() { "".to_string() }
                        else { format!("{}<{}>{}</{}>", #extensions, #name, self.#field.to_xml(None, false), #name) }}
                } else if *is_value {
                    quote! {  format!("{}", self.#field.to_xml(None, false)) }
                } else {
                    quote! {  format!("{}<{}>{}</{}>", #extensions, #name, self.#field.to_xml(None, false), #name) }
                }
            }
            XmlTagElement::Complex(field, name, extensions) =>  {
                quote! {
                    format!("{}{}", #extensions, self.#field.to_xml(Some(#name), false))
                }
            },
            XmlTagElement::Collection(field, ty, tag_name, inner_name, extensions) => {
                let items_constructor = if is_outer_option(&ty) {
                    quote!{
                        let xa_render = self.#field.is_some();
                        let xa_items = if let Some(xa_value_item) = &self.#field {
                            xa_value_item
                        } else {
                            &Vec::new()
                        };
                    }
                } else {
                    quote!{
                        let xa_render = true;
                        let xa_items = &self.#field;
                    }
                };
                quote! {
                    {
                         #items_constructor
                        let mut collection_xml = String::new();
                        if xa_render {
                            collection_xml.push_str(&format!("<{}>", #tag_name));
                            for item in xa_items {
                                collection_xml.push_str(&item.to_xml(Some(#inner_name), false));
                            }
                            collection_xml.push_str(&format!("</{}>", #tag_name));
                            format!("{}{}", #extensions, collection_xml)
                        } else {
                            "".to_string()
                        }
                    }
                }
            }
        };
        tokens.extend(tag_tokens);
    }
}

impl XmlTagElement {
    pub fn parse(field: Ident, ty: Type, obj_meta: Option<&MetaInfo>, meta: Option<&MetaInfo>, extension: XmlExtension) -> Option<XmlTagElement> {

        if let Some(meta) = meta {
            if !meta.contains("attribute") && !meta.contains("xmlns") {

                return if meta.contains("skip") {
                    None
                } else if meta.contains("flatten") || meta.contains("tree") {
                    let tag_name = XmlNames::tag(&field, obj_meta, Some(&meta))?;
                    Some(XmlTagElement::Complex(field, tag_name,  extension))
                }  else if meta.contains("inner") { //TODO Work on these question marks
                    let tag_name = XmlNames::tag(&field, obj_meta, Some(&meta))?;
                    let inner_name = XmlNames::inner(obj_meta, Some(&meta))?;
                    Some(XmlTagElement::Collection(field, ty, tag_name, inner_name, extension))
                } else {
                    let tag_name = XmlNames::tag(&field, obj_meta, Some(&meta))?;
                    Some(XmlTagElement::Simple(field, ty, tag_name, meta.contains("value") , extension))
                }
            }
        } else {
            let tag_name = XmlNames::tag(&field, obj_meta, None)?;
            return Some(XmlTagElement::Simple(field, ty, tag_name, false, extension))
        }
        None
    }
}