nitr 0.0.0-beta.1

A Rust web server embedding Lua for fast, efficient and safe dynamic backends.
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

//! Built-in Lua globals (userdata/functions) and their registration.

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;

bitflags::bitflags! {
    /// Built-in globals that can be exposed to Lua scripts.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct Builtins: u32 {
        /// `dbg(value)` debug-print function.
        const DEBUG = 1;
        /// `fetch(method, url, headers?)` HTTP client.
        const FETCH = 1 << 1;
        /// `template:render(name, data?)` template engine (minijinja).
        const TEMPLATE = 1 << 2;
        /// `json:encode(value)` / `json:decode(string)` JSON codec.
        const JSON = 1 << 3;
        /// `conn:execute/query/query_row/query_one` SQLite driver.
        const DATABASE = 1 << 4;
    }
}

impl Builtins {
    /// The Lua global variable name a builtin is registered under.
    ///
    /// Returns `None` unless `self` is a single flag.
    pub fn global_name(self) -> Option<&'static str> {
        match self {
            Builtins::DEBUG => Some("dbg"),
            Builtins::FETCH => Some("fetch"),
            Builtins::TEMPLATE => Some("template"),
            Builtins::JSON => Some("json"),
            Builtins::DATABASE => Some("conn"),
            _ => None,
        }
    }

    /// Resolves a configuration name (e.g. `"dbg"`, `"fetch"`, `"db"`) into
    /// its builtin flag.
    pub fn from_config_name(name: &str) -> Option<Self> {
        match name {
            "dbg" => Some(Builtins::DEBUG),
            "fetch" => Some(Builtins::FETCH),
            "template" => Some(Builtins::TEMPLATE),
            "json" => Some(Builtins::JSON),
            "db" => Some(Builtins::DATABASE),
            _ => None,
        }
    }
}

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

    #[test]
    fn config_names_round_trip() {
        for (name, flag) in [
            ("dbg", Builtins::DEBUG),
            ("fetch", Builtins::FETCH),
            ("template", Builtins::TEMPLATE),
            ("json", Builtins::JSON),
            ("db", Builtins::DATABASE),
        ] {
            assert_eq!(Builtins::from_config_name(name), Some(flag));
            assert!(flag.global_name().is_some());
        }
        assert_eq!(Builtins::from_config_name("nope"), None);
        // Combined flags have no single global name.
        assert_eq!((Builtins::DEBUG | Builtins::JSON).global_name(), None);
        assert_eq!(Builtins::DATABASE.global_name(), Some("conn"));
    }
}