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

use std::collections::HashMap;
use std::fmt::{Display, Formatter};
use proc_macro2::TokenStream;
use syn::{Attribute, Error, Ident, LitStr, Meta, Token};
use syn::parse::{Parse, ParseStream};

pub enum MetaName {
    XML,
    Declaration, DTD, PI
}

impl Display for MetaName {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let str = match self {
            MetaName::XML => { "xml".to_string() },
            MetaName::Declaration => { "declaration".to_string() },
            MetaName::DTD => { "dtd".to_string() },
            MetaName::PI => { "pi".to_string() },
        };
        write!(f, "{}", str)
    }
}

pub struct MetaInfo(pub HashMap<String, String>);

impl Parse for MetaInfo {
    fn parse(input: ParseStream) -> Result<MetaInfo, Error> {
        let mut result = HashMap::new();
        while input.peek(Ident) {
            if input.peek(Ident) {
                let key: Ident = input.parse()?;
                let mut value: Option<LitStr> = None;
                if input.peek(Token![=]) {
                    let _: Token![=] = input.parse()?;
                    value = input.parse()?;
                }
                if let Some(value) = value {
                    result.insert(key.to_string(), value.value());
                } else {
                    result.insert(key.to_string(), "true".to_string());
                }
            }
            if input.peek(Token![,]) {
                let _: Token![,] = input.parse()?;
            }
        }
        Ok(MetaInfo(result))
    }
}

impl MetaInfo {

    pub fn get_or(&self, meta_name: &str, default: String) -> String {
        self.0.get(meta_name).unwrap_or(&default).to_string()
    }

    pub fn contains(&self, meta_name: &str) -> bool {
        self.0.contains_key(meta_name)
    }

    pub fn from_name(attrs: &Vec<Attribute>, meta_name: MetaName) -> Option<MetaInfo> {
        let object_attr = MetaInfo::attr_by_name(&attrs, meta_name);
        if let Some(object_attr) = object_attr {
            Some(MetaInfo::from_attr(object_attr))
        } else {
            None
        }
    }

    pub fn attr_by_name(attrs: &Vec<Attribute>, meta_name: MetaName) -> Option<&Attribute> {
        let name = meta_name.to_string();
        attrs.iter().find(|attr| { attr.path().is_ident(&name) })
    }

    pub fn vec_attr_by_name(attrs: &Vec<Attribute>, meta_name: MetaName) -> Vec<&Attribute> {
        let name = meta_name.to_string();
        attrs.iter().filter_map(|attr| {
            if attr.path().is_ident(&name) { Some(attr) } else { None } }).collect()
    }

    pub fn empty() -> MetaInfo {
        MetaInfo(HashMap::new())
    }

    fn from_attr(attribute: &Attribute) -> MetaInfo {
        if let Meta::List(meta) = &attribute.meta {
            return syn::parse2(TokenStream::from(meta.clone().tokens)).unwrap();
        }
        MetaInfo(HashMap::new())
    }
}