arcature-macros 0.1.0

Proc-macro crate for Arcature: #[model], #[request], #[controller], #[derive(Job)], #[derive(Event)].
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

//! The HTTP method of a `routes!` entry.
//!
//! One responsibility: the macro-side method enum and the two renderings the
//! expansion needs -- the `Route::<S>::<fn>` constructor name and the
//! `RouteMethod::<Variant>` metadata ident.

/// The HTTP method as parsed from a `routes!` method keyword.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RouteMethodKind {
    Get,
    Post,
    Put,
    Patch,
    Delete,
    Head,
    Options,
}

impl RouteMethodKind {
    /// Returns the `arcature::Route` constructor name (`get`, `post`, ...).
    pub const fn constructor(self) -> &'static str {
        match self {
            Self::Get => "get",
            Self::Post => "post",
            Self::Put => "put",
            Self::Patch => "patch",
            Self::Delete => "delete",
            Self::Head => "head",
            Self::Options => "options",
        }
    }

    /// Returns the `arcature::RouteMethod` variant name (`Get`, `Post`, ...).
    pub const fn variant(self) -> &'static str {
        match self {
            Self::Get => "Get",
            Self::Post => "Post",
            Self::Put => "Put",
            Self::Patch => "Patch",
            Self::Delete => "Delete",
            Self::Head => "Head",
            Self::Options => "Options",
        }
    }

    /// Returns true when the method is state-changing (POST/PUT/PATCH/DELETE).
    ///
    /// An `action:` route must use an unsafe method: a GET must never mutate.
    pub const fn is_unsafe(self) -> bool {
        matches!(self, Self::Post | Self::Put | Self::Patch | Self::Delete)
    }
}

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

    #[test]
    fn constructor_is_the_lowercase_method() {
        assert_eq!(RouteMethodKind::Get.constructor(), "get");
        assert_eq!(RouteMethodKind::Delete.constructor(), "delete");
    }

    #[test]
    fn variant_is_the_pascal_case_method() {
        assert_eq!(RouteMethodKind::Patch.variant(), "Patch");
    }

    #[test]
    fn only_mutating_methods_are_unsafe() {
        assert!(RouteMethodKind::Post.is_unsafe());
        assert!(RouteMethodKind::Delete.is_unsafe());
        assert!(!RouteMethodKind::Get.is_unsafe());
        assert!(!RouteMethodKind::Head.is_unsafe());
        assert!(!RouteMethodKind::Options.is_unsafe());
    }
}