genies_derive 1.6.0

A powerful derive macro for configuration management in Rust
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

use std::fmt;
//
// /// Http request method.
// pub enum Method {
//     GET,
//     POST,
//     PUT,
//     DELETE,
// }
//
// impl Method {
//     pub fn to_str(&self) -> &str {
//         match *self {
//             Method::GET => "GET",
//             Method::POST => "POST",
//             Method::PUT => "PUT",
//             Method::DELETE => "DELETE",
//         }
//     }
//     pub fn from_str(str: &str) -> Result<Method, String> {
//         match str {
//             "get" | "GET" => Ok(Method::GET),
//             "post" | "POST" => Ok(Method::POST),
//             "put" | "PUT" => Ok(Method::PUT),
//             "delete" | "DELETE" => Ok(Method::DELETE),
//             _ => Err("unknown request method marker: ".to_string() + str),
//         }
//     }
// }

/// Arg type.
#[derive(PartialEq)]
pub enum ArgType {
    HEADER,
    PATH,
    QUERY,
    FORM,
    BODY,
    PARAM,
}

impl fmt::Display for ArgType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let t = match self {
            ArgType::HEADER => "header",
            ArgType::PATH => "path",
            ArgType::QUERY => "query",
            ArgType::FORM => "form",
            ArgType::BODY => "body",
            ArgType::PARAM => "PARAM",
        };
        write!(f, "{}", t)
    }
}

impl ArgType {
    pub fn from_str(arg_type: &str) -> Result<ArgType, String> {
        match arg_type {
            "header" | "HEADER" => Ok(ArgType::HEADER),
            "path" | "PATH" => Ok(ArgType::PATH),
            "query" | "QUERY" => Ok(ArgType::QUERY),
            "form" | "FORM" => Ok(ArgType::FORM),
            "body" | "BODY" => Ok(ArgType::BODY),
            "param" | "PARAM" => Ok(ArgType::PARAM),
            _ => Err("unknown arg type: ".to_string() + arg_type),
        }
    }
}


#[allow(dead_code)]
pub struct FnArg {
    pub arg_type: ArgType,
    pub name: String,
    pub var: syn::Ident,
    pub var_type: syn::Type,
}