mlua-json 1.0.1

A Rust-native implementation of LuaRocks openresty/lua-cjson or grafi/lunajson for mlua.
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

use mlua::{Error, ExternalError, Lua, Value};
use std::collections::HashMap;

pub fn encode(_lua: &Lua, value: &Value) -> Result<Option<String>, Error> {
    if value.is_nil() {
        Ok(None)
    } else if value.is_boolean() {
        Ok(Some(value.as_boolean().unwrap().to_string()))
    } else if value.is_integer() {
        Ok(Some(value.as_integer().unwrap().to_string()))
    } else if value.is_number() {
        Ok(Some(value.as_number().unwrap().to_string()))
    } else if value.is_string() {
        Ok(Some(serde_json::to_string(&value).map_err(|e| e.into_lua_err())?))
    } else if value.is_table() {
        let res_json = serde_json::to_string(&value).map_err(|e| e.into_lua_err())?;
        let m: HashMap<serde_json::Value, serde_json::Value> =
            serde_json::from_str(&res_json).map_err(|e| e.into_lua_err())?;
        Ok(Some(serde_json::to_string(&m).map_err(|e| e.into_lua_err())?))
    } else {
        Ok(None)
    }
}

#[cfg(test)]
mod tests {
    use mlua::Lua;
    use std::error::Error;

    #[test]
    fn can_encode_a_boolean() -> Result<(), Box<dyn Error>> {
        let lua = Lua::new();
        crate::preload(&lua)?;
        let result: String = lua
            .load(
                r#"
                local json = require('json')
                return json.encode(true)
            "#,
            )
            .eval()?;
        assert_eq!(result, "true");
        Ok(())
    }

    #[test]
    fn can_encode_a_nil() -> Result<(), Box<dyn Error>> {
        let lua = Lua::new();
        crate::preload(&lua)?;
        let result: Option<String> = lua
            .load(
                r#"
                local json = require('json')
                return json.encode(nil)
            "#,
            )
            .eval()?;
        assert!(result.is_none());
        Ok(())
    }

    #[test]
    fn can_encode_a_number() -> Result<(), Box<dyn Error>> {
        let lua = Lua::new();
        crate::preload(&lua)?;
        let result: String = lua
            .load(
                r#"
                local json = require('json')
                return json.encode(123)
            "#,
            )
            .eval()?;
        assert_eq!(result, "123");
        Ok(())
    }

    #[test]
    fn can_encode_a_string() -> Result<(), Box<dyn Error>> {
        let lua = Lua::new();
        crate::preload(&lua)?;
        let result: String = lua
            .load(
                r#"
                local json = require('json')
                return json.encode('abc')
            "#,
            )
            .eval()?;
        assert_eq!(result, "\"abc\"");
        Ok(())
    }

    #[test]
    fn can_encode_a_table() -> Result<(), Box<dyn Error>> {
        let lua = Lua::new();
        crate::preload(&lua)?;
        let result: String = lua
            .load(
                r#"
                local json = require('json')
                return json.encode({abc = '123', def = 456, ghi = true, jkl = {7,8,9}})
            "#,
            )
            .eval()?;
        assert!(result.contains(r#""abc":"123""#));
        assert!(result.contains(r#""def":456"#));
        assert!(result.contains(r#""ghi":true"#));
        assert!(result.contains(r#""jkl":[7,8,9]"#));
        Ok(())
    }
}