next-web-macros 0.2.0

Provide a series of commonly used macros
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

use quote::ToTokens;
use syn::{GenericArgument, PathArguments};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FieldType {
    String,
    Number,
    Boolean,
    Array,
    Object,
    Option,
    Result,
}

impl FieldType {
    pub fn from_type(ty: &syn::Type) -> FieldType {
        match ty {
            syn::Type::Array(_) => FieldType::Array,
            syn::Type::Path(type_path) => {
                if FieldType::is_result(ty) {
                    return FieldType::Result;
                }

                if FieldType::is_option(ty) {
                    return FieldType::Option;
                }

                if FieldType::is_string(&ty) {
                    return FieldType::String;
                }

                if type_path.path.segments.len() == 1 {
                    if FieldType::is_number(&ty) {
                        return FieldType::Number;
                    }

                    if FieldType::is_boolean(&ty) {
                        return FieldType::Boolean;
                    }
                }
                FieldType::Object
            }
            syn::Type::Reference(_) => {
                if FieldType::is_string(&ty) {
                    return FieldType::String;
                }
                FieldType::Object
            }
            _ => FieldType::Object,
        }
    }

    pub fn is_number(ty: &syn::Type) -> bool {
        if let syn::Type::Path(type_path) = ty {
            if let Some(segment) = type_path.path.segments.last() {
                return match segment.ident.to_string().as_str() {
                    "u8" | "u16" | "u32" | "u64" | "u128" | "usize" | "i8" | "i16" | "i32"
                    | "i64" | "i128" | "isize" | "f32" | "f64" => true,
                    _ => false,
                };
            }
        }
        false
    }

    pub fn is_string(ty: &syn::Type) -> bool {
        match ty {
            syn::Type::Path(type_path) => {
                if let Some(segment) = type_path.path.segments.last() {
                    return match segment.ident.to_string().as_str() {
                        "String" => true,
                        _ => ty.to_token_stream().to_string().contains("str"),
                    };
                }
                false
            }
            syn::Type::Reference(_) => ty.to_token_stream().to_string().contains("str"),
            _ => false,
        }
    }

    pub fn is_boolean(ty: &syn::Type) -> bool {
        if let syn::Type::Path(type_path) = ty {
            if let Some(segment) = type_path.path.segments.last() {
                return match segment.ident.to_string().as_str() {
                    "bool" => true,
                    _ => false,
                };
            }
        }
        false
    }

    /// Check if it is an Option type
    pub fn is_option(ty: &syn::Type) -> bool {
        if let syn::Type::Path(type_path) = ty {
            if let Some(segment) = type_path.path.segments.last() {
                return segment.ident == "Option";
            }
        }
        false
    }

    pub fn is_result(ty: &syn::Type) -> bool {
        if let syn::Type::Path(type_path) = ty {
            if let Some(segment) = type_path.path.segments.last() {
                return segment.ident == "Result";
            }
        }
        false
    }

    /// Extract the inner type of Option type
    pub fn extract_option_inner_type(ty: &syn::Type) -> Option<syn::Type> {
        // 检查是否为 Option 类型
        if let syn::Type::Path(type_path) = ty {
            if let Some(segment) = type_path.path.segments.last() {
                if segment.ident == "Option" {
                    // 提取泛型参数
                    if let PathArguments::AngleBracketed(args) = &segment.arguments {
                        if let Some(GenericArgument::Type(inner_type)) = args.args.first() {
                            return Some(inner_type.clone());
                        }
                    }
                }
            }
        }

        None
    }
}