taitan-orm-parser 0.1.12

Next Generation ORM based on sqlx
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

use std::borrow::Cow;
use syn::{parse_quote, Attribute, DeriveInput};
use syn::Expr::Field;
use taitan_orm_parser::attr_parser::{AttrParser, NamedAttribute};
use taitan_orm_parser::{InputParser};

fn check_attr(attrs: &[Attribute], index: usize, name: &str, value_str: &str) {
    let value_opt = AttrParser::parse(&attrs[index]);
    let value = value_opt.unwrap();
    assert_eq!(value.name, Cow::<'static, str>::Owned(name.to_string()));
    let values = value_str
        .split(|c: char| c ==' ' || c == ',')
        .filter(|s| !s.is_empty())
        .map(|s| Cow::Owned(s.to_string()))
        .collect::<Vec<_>>();
    let expected: Vec<Cow<'static, str>> = values;
    assert_eq!(value.values, expected);
}
#[test]
fn attr_parser_struct_spec() {
    let input: DeriveInput = parse_quote! {
        #[table1("user1")]
        #[table2 = "user2"]
        #[table3(user3)]
        #[table4 = user4]
        #[table5 = "user50, user51"]
        #[table6(user60, user61)]
        struct Foo<'a, 'b> {
            a: &'a str,
            b: Cow<'b, str>,
            c: String,
            d: Option<Cow<'b, str>>,
            e: Optional<Cow<'b, str>>
        }
    };

    let attrs = input.attrs;
    check_attr(&attrs, 0, "table1", "user1");
    check_attr(&attrs, 1, "table2", "user2");
    check_attr(&attrs, 2, "table3", "user3");
    check_attr(&attrs, 3, "table4", "user4");
    check_attr(&attrs, 4, "table5", "user50,  user51");
    check_attr(&attrs, 5, "table6", "user60,  user61");
}

fn check_multi_attrs(attrs: &[Attribute], index: usize, attr0: &NamedAttribute, attr1: &NamedAttribute) {
    let named_attrs = AttrParser::parse_list(&attrs[index]);
    let named_attr0 = named_attrs[0].clone();
    let named_attr1 = named_attrs[1].clone();
    assert_eq!(&named_attr0, attr0);
    assert_eq!(&named_attr1, attr1);
}

#[test]
fn attr_parser_spec_multi() {
    let input: DeriveInput = parse_quote! {
        #[table1(index = user60, fields = (f1, f2, f3))]
        #[table2(index = user60, fields = "f1, f2, f3")]
        #[table3(index(user60), fields(f1, f2, f3))]
        struct Foo<'a, 'b> {
            a: &'a str,
            b: Cow<'b, str>,
            c: String,
            d: Option<Cow<'b, str>>,
            e: Optional<Cow<'b, str>>
        }
    };

    let attrs = input.attrs;
    let expected_attr1 = NamedAttribute::from_str("index", "user60");
    let expected_attr2 = NamedAttribute::from_str("fields", "f1, f2, f3");
    check_multi_attrs(&attrs, 0, &expected_attr1, &expected_attr2);
    check_multi_attrs(&attrs, 1, &expected_attr1, &expected_attr2);
    check_multi_attrs(&attrs, 2, &expected_attr1, &expected_attr2);
}


#[test]
fn attr_parser_spec_field_multi() {
    let input: DeriveInput = parse_quote! {
        struct Foo<'a> {
            #[field(name = user_name, db_type = BIGINT, nullable = true, auto_inc = true)]
            name: &'a str,
        }
    };

    let fields = InputParser::get_fields(&input.data);
    let name_field = &fields[0];
    let field_attrs = &name_field.attrs;
    let name_field_attr = &field_attrs[0];
    let named_attr_list = AttrParser::parse_list(name_field_attr);
    let expected_named_attr = NamedAttribute::from_str("name", "user_name");
    assert_eq!(named_attr_list[0], expected_named_attr);
    let expected_named_attr = NamedAttribute::from_str("db_type", "BIGINT");
    assert_eq!(named_attr_list[1], expected_named_attr);
    let expected_named_attr = NamedAttribute::from_str("nullable", "true");
    assert_eq!(named_attr_list[2], expected_named_attr);
    let expected_named_attr = NamedAttribute::from_str("auto_inc", "true");
    assert_eq!(named_attr_list[3], expected_named_attr);
}