ormlitex-attr 0.17.1

See `ormlitex`.
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use proc_macro2::{TokenStream};
use syn::Meta;

#[derive(Debug)]
pub struct Derives {
    pub is_model: bool,
    pub is_type: bool,
    pub is_manual_type: bool,
}

#[derive(Debug)]
pub struct Attributes2 {
    pub derives: Derives,
    pub repr: Option<String>,
}

impl Attributes2 {
    pub fn has_derive(&self, trait_name: &str) -> bool {
        match trait_name {
            "Model" => self.derives.is_model,
            "Type" => self.derives.is_type,
            "ManualType" => self.derives.is_manual_type,
            _ => false,
        }
    }
}

fn decode_traits_from_derive_tokens(derives: &mut Derives, tokens: &TokenStream) {
    use proc_macro2::TokenTree;

    let mut iter = tokens.clone().into_iter().peekable();

    while let Some(tok) = iter.next() {
        match tok {
            TokenTree::Ident(i) => {
                let p = iter.peek();
                if p.is_none() || matches!(p.unwrap(), TokenTree::Punct(p) if p.as_char() == ',') {
                    match i.to_string().as_str() {
                        "Model" => derives.is_model = true,
                        "Type" => derives.is_type = true,
                        "ManualType" => derives.is_manual_type = true,
                        _ => {}
                    }
                    _ = iter.next();
                    continue;
                } else if matches!(p.unwrap(), TokenTree::Punct(p) if p.as_char() == ':') {
                    let ns = i.to_string();
                    if !(ns == "sqlx" || ns == "ormlitex") {
                        iter.find(|tok| matches!(tok, TokenTree::Punct(p) if p.as_char() == ','));
                        continue;
                    }
                    _ = iter.next(); // consume the colon
                    _ = iter.next(); // consume another colon
                    continue;
                } else {
                    panic!("Unexpected token in derive attribute: {:?}", p);
                }
            }
            _ => panic!("Unexpected token in derive attribute: {:?}", tok),
        }
    }
}

impl From<&[syn::Attribute]> for Attributes2 {
    fn from(attrs: &[syn::Attribute]) -> Self {
        let mut repr = None;
        let mut derives = Derives {
            is_model: false,
            is_type: false,
            is_manual_type: false,
        };
        for attr in attrs.iter() {
            match &attr.meta {
                Meta::List(l) => {
                    let Some(ident) = l.path.get_ident() else { continue; };
                    if ident == "derive" {
                        decode_traits_from_derive_tokens(&mut derives, &l.tokens);
                    } else if ident == "repr" {
                        let ident = l.tokens.clone().into_iter().next().expect("Encountered a repr attribute without an argument.");
                        repr = Some(ident.to_string());
                    }
                }
                _ => {}
            }
        }
        Attributes2 { derives, repr }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_repr() {
        let q = quote::quote! {
            #[derive(sqlx::Type)]
            #[repr(u8)]
            pub enum Foo {
                Bar,
                Baz,
            }
        };
        let item = syn::parse2::<syn::ItemEnum>(q).unwrap();
        let attrs = Attributes2::from(item.attrs.as_slice());
        dbg!(&attrs);
        assert!(attrs.has_derive("Type"));
        assert_eq!(attrs.repr, Some("u8".to_string()));
    }

    /// The attributes on this are sort of nonsense, but we want to test the dynamic attribute parsing
    /// in ormlitex_attr::Attribute
    #[test]
    fn test_attributes() {
        // the doc string is the regression test
        let code = r#"/// Json-serializable representation of query results
#[derive(Debug, Serialize, Deserialize, Clone, sqlx::Type, ormlitex::Model)]
#[repr(u8)]
#[ormlitex(table = "result")]
#[deprecated]
pub struct QuerySet {
    pub headers: Vec<String>,
    pub rows: Vec<Vec<Value>>,
}"#;
        let file: syn::File = syn::parse_str(code).unwrap();
        let syn::Item::Struct(item) = file.items.first().unwrap() else {
            panic!("expected struct");
        };
        let attr = Attributes2::from(item.attrs.as_slice());
        assert_eq!(attr.repr, Some("u8".to_string()));
        assert_eq!(attr.derives.is_model, true);
        assert_eq!(attr.derives.is_type, true);
        assert_eq!(attr.derives.is_manual_type, false);

    }
}