rlibphonenumbers_macro 0.1.3

Package for "Region" enum generation for a high-performance Rust port of Google's libphonenumber for parsing, formatting, and validating international phone numbers.
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

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use xml::{EventReader, reader::XmlEvent};

fn get_country_list() -> Vec<String> {
    let file = include_str!(concat!(env!("OUT_DIR"), "/ShortNumberMetadata.xml"));
    let mut countries = Vec::new();

    let parser = EventReader::from_str(file);
    for e in parser {
        if let Ok(XmlEvent::StartElement {
            name, attributes, ..
        }) = e
            && name.borrow().local_name == "territory"
            && let Some(id_attr) = attributes.iter().find(|attr| attr.name.local_name == "id")
        {
            countries.push(id_attr.value.clone());
        }
    }

    countries
}

#[proc_macro]
pub fn countries_enum(name: TokenStream) -> TokenStream {
    let country_list = get_country_list();
    let countries = country_list
        .iter()
        .map(|country| format_ident!("{}", country.to_uppercase()));

    let str_mapper = country_list.iter().map(|country| {
        let item = format_ident!("{}", country.to_uppercase());
        let value = proc_macro2::Literal::string(country);

        quote! { Self::#item => #value }
    });

    let from_str_mapper = country_list.iter().map(|country| {
        let item = format_ident!("{}", country.to_uppercase());
        let value = proc_macro2::Literal::string(country);
        quote! { #value => ::core::result::Result::Ok(Self::#item) }
    });

    let name = format_ident!("{}", name.to_string());

    quote! {
        #[derive(
            ::core::fmt::Debug,
            ::core::clone::Clone,
            ::core::marker::Copy,
            ::core::cmp::PartialEq,
            ::core::cmp::Eq,
            ::core::hash::Hash,
            ::core::cmp::PartialOrd,
            ::core::cmp::Ord
        )]
        pub enum #name {
            #(#countries),*
        }

        impl ::core::convert::AsRef<str> for #name {
            fn as_ref(&self) -> &str {
                match self {
                    #(#str_mapper),*
                }
            }
        }

        impl ::core::fmt::Display for #name {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                f.write_str(self.as_ref())
            }
        }

        impl ::core::str::FromStr for #name {
            type Err = String;

            fn from_str(s: &str) -> ::core::result::Result<Self, Self::Err> {
                match s {
                    #(#from_str_mapper,)*
                    _ => ::core::result::Result::Err(format!("Unknown country code: {}", s)),
                }
            }
        }
    }
    .into()
}