rjango 0.1.1

A full-stack Rust backend framework inspired by Django
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

/// Macro to create an integer choices enum (like Django's IntegerChoices).
#[macro_export]
macro_rules! integer_choices {
    (
        $name:ident {
            $( $variant:ident = $value:expr, $label:literal ),* $(,)?
        }
    ) => {
        #[repr(i32)]
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        pub enum $name {
            $( $variant = $value, )*
        }

        impl $name {
            pub fn label(&self) -> &'static str {
                match self {
                    $( Self::$variant => $label, )*
                }
            }

            pub fn value(&self) -> i32 {
                *self as i32
            }

            pub fn choices() -> Vec<(i32, &'static str)> {
                vec![ $( ($value, $label), )* ]
            }
        }
    };
}

/// Macro to create a text choices enum (like Django's TextChoices).
#[macro_export]
macro_rules! text_choices {
    (
        $name:ident {
            $( $variant:ident = $value:expr, $label:literal ),* $(,)?
        }
    ) => {
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        pub enum $name {
            $( $variant, )*
        }

        impl $name {
            pub fn label(&self) -> &'static str {
                match self {
                    $( Self::$variant => $label, )*
                }
            }

            pub fn value(&self) -> &'static str {
                match self {
                    $( Self::$variant => $value, )*
                }
            }

            pub fn choices() -> Vec<(&'static str, &'static str)> {
                vec![ $( ($value, $label), )* ]
            }
        }
    };
}

#[cfg(test)]
mod tests {
    crate::integer_choices! {
        Status {
            Draft = 0, "Draft",
            Published = 1, "Published",
        }
    }

    crate::text_choices! {
        Visibility {
            Private = "private", "Private",
            Public = "public", "Public",
        }
    }

    #[test]
    fn integer_choices_returns_variant_label() {
        assert_eq!(Status::Draft.label(), "Draft");
        assert_eq!(Status::Published.label(), "Published");
    }

    #[test]
    fn integer_choices_returns_variant_value() {
        assert_eq!(Status::Draft.value(), 0);
        assert_eq!(Status::Published.value(), 1);
    }

    #[test]
    fn integer_choices_returns_choices_list() {
        assert_eq!(Status::choices(), vec![(0, "Draft"), (1, "Published")]);
    }

    #[test]
    fn text_choices_returns_variant_label() {
        assert_eq!(Visibility::Private.label(), "Private");
        assert_eq!(Visibility::Public.label(), "Public");
    }

    #[test]
    fn text_choices_returns_variant_value() {
        assert_eq!(Visibility::Private.value(), "private");
        assert_eq!(Visibility::Public.value(), "public");
    }

    #[test]
    fn text_choices_returns_choices_list() {
        assert_eq!(
            Visibility::choices(),
            vec![("private", "Private"), ("public", "Public")]
        );
    }
}