nitr 0.0.0-beta.0

A dynamic web server written in Rust with Lua scripting support.
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

use mlua::{IntoLua, LuaSerdeExt};
use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};

pub(crate) mod db;
pub(crate) mod fetch;
pub(crate) mod json;
pub(crate) mod request;
pub(crate) mod response;
pub(crate) mod template;
pub(crate) mod utils;

pub const USERDATA_LIBS: &[UserData] = &[
    UserData::NONE,
    UserData::DEBUG,
    UserData::FETCH,
    UserData::TEMPLATE,
    UserData::JSON,
    UserData::DATABASE,
    UserData::ALL,
];

#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct UserData(u32);

impl UserData {
    pub const NONE: UserData = UserData(0);
    pub const DEBUG: UserData = UserData(1);
    pub const FETCH: UserData = UserData(1 << 1);
    pub const TEMPLATE: UserData = UserData(1 << 2);
    pub const JSON: UserData = UserData(1 << 3);
    pub const DATABASE: UserData = UserData(1 << 4);
    pub const ALL: UserData = UserData(u32::MAX);

    pub fn contains(self, lib: Self) -> bool {
        (self & lib).0 != 0
    }

    pub fn is_all(self) -> bool {
        self == UserData::ALL
    }

    pub fn is_none(self) -> bool {
        self == UserData::NONE
    }

    pub fn to_str(self) -> &'static str {
        match self {
            UserData::NONE => "none",
            UserData::DEBUG => "dbg",
            UserData::FETCH => "fetch",
            UserData::TEMPLATE => "template",
            UserData::JSON => "json",
            UserData::DATABASE => "conn",
            UserData::ALL => "all",
            _ => "",
        }
    }
}

impl BitAnd for UserData {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self::Output {
        UserData(self.0 & rhs.0)
    }
}

impl BitAndAssign for UserData {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = UserData(self.0 & rhs.0)
    }
}

impl BitOr for UserData {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self::Output {
        UserData(self.0 | rhs.0)
    }
}

impl BitOrAssign for UserData {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = UserData(self.0 | rhs.0)
    }
}

impl BitXor for UserData {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self::Output {
        UserData(self.0 ^ rhs.0)
    }
}

impl BitXorAssign for UserData {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = UserData(self.0 ^ rhs.0)
    }
}

// implement to_str for LuaUserData
impl std::fmt::Display for UserData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut libs = Vec::new();
        if self.contains(UserData::DEBUG) {
            libs.push("DEBUG");
        }
        if self.contains(UserData::FETCH) {
            libs.push("FETCH");
        }
        if self.contains(UserData::TEMPLATE) {
            libs.push("TEMPLATE");
        }
        if self.contains(UserData::JSON) {
            libs.push("JSON");
        }
        if self.contains(UserData::DATABASE) {
            libs.push("database");
        }
        write!(f, "{}", libs.join(", "))
    }
}

impl IntoLua for UserData {
    fn into_lua(self, lua: &mlua::Lua) -> mlua::Result<mlua::Value> {
        lua.to_value(self.to_str())
    }
}