Add json module

Author: khvzak

Cargo.toml

@@ -13,7 +13,14 @@ lua52 = ["mlua/lua52"]
 lua53 = ["mlua/lua53"]
 lua54 = ["mlua/lua54"]
 luau = ["mlua/luau"]
+send = ["mlua/send"]
+vendored = ["mlua/vendored"]
+
+json = ["mlua/serde", "dep:ouroboros", "dep:serde", "dep:serde_json"]
 
 [dependencies]
 mlua = { version = "0.11" }
+ouroboros = { version = "0.18", optional = true }
+serde = { version = "1.0", optional = true }
+serde_json = { version = "1.0", optional = true }
 owo-colors = "4"

lua/testing.lua

@@ -211,7 +211,7 @@ function Testing:_print_results()
         failed,
         skipped,
         total,
-        duration
+        tostring(duration)
     )
     println()
     println(prefix, stats)

src/bytes.rs

@@ -0,0 +1,68 @@
+use std::ops::Deref;
+
+use mlua::{BorrowedBytes, Error, FromLua, Lua, Result, String as LuaString, UserData, UserDataRef, Value};
+
+use crate::types::MaybeSend;
+
+/// A wrapper around a byte slice that can be passed to Lua as userdata.
+#[cfg(not(feature = "send"))]
+pub struct BytesBox(Box<dyn AsRef<[u8]>>);
+
+/// A wrapper around a byte slice that can be passed to Lua as userdata.
+#[cfg(feature = "send")]
+pub struct BytesBox(Box<dyn AsRef<[u8]> + Send>);
+
+impl<T: AsRef<[u8]> + MaybeSend + 'static> From<T> for BytesBox {
+    #[inline(always)]
+    fn from(value: T) -> Self {
+        Self(Box::new(value))
+    }
+}
+
+impl UserData for BytesBox {}
+
+pub(crate) enum StringOrBytes {
+    String(LuaString),
+    Bytes(UserDataRef<BytesBox>),
+}
+
+impl FromLua for StringOrBytes {
+    fn from_lua(value: Value, _lua: &Lua) -> Result<Self> {
+        match value {
+            Value::String(s) => Ok(Self::String(s)),
+            Value::UserData(ud) => Ok(Self::Bytes(ud.borrow::<BytesBox>()?)),
+            _ => Err(Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "string or bytes".into(),
+                message: None,
+            }),
+        }
+    }
+}
+
+impl StringOrBytes {
+    #[inline]
+    pub(crate) fn as_bytes_deref(&self) -> impl Deref<Target = [u8]> {
+        match self {
+            StringOrBytes::String(s) => AsBytesRefImpl::Lua(s.as_bytes()),
+            StringOrBytes::Bytes(b) => AsBytesRefImpl::Ref((*b.0).as_ref()),
+        }
+    }
+}
+
+enum AsBytesRefImpl<'a> {
+    Ref(&'a [u8]),
+    Lua(BorrowedBytes<'a>),
+}
+
+impl Deref for AsBytesRefImpl<'_> {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Self::Ref(b) => b,
+            Self::Lua(s) => s.as_ref(),
+        }
+    }
+}

src/json.rs

@@ -0,0 +1,232 @@
+use std::result::Result as StdResult;
+use std::sync::Arc;
+
+use mlua::{
+    AnyUserData, Error as LuaError, ExternalResult, Function, Integer as LuaInteger, IntoLuaMulti, Lua,
+    LuaSerdeExt, MetaMethod, MultiValue, Result, String as LuaString, Table, UserData, UserDataMethods,
+    UserDataRefMut, Value,
+};
+use ouroboros::self_referencing;
+use serde::{Serialize, Serializer};
+
+use crate::bytes::StringOrBytes;
+
+/// Represents a native Json object in Lua.
+#[derive(Clone)]
+pub(crate) struct JsonObject {
+    root: Arc<serde_json::Value>,
+    current: *const serde_json::Value,
+}
+
+impl Serialize for JsonObject {
+    fn serialize<S: Serializer>(&self, serializer: S) -> StdResult<S::Ok, S::Error> {
+        self.current().serialize(serializer)
+    }
+}
+
+impl JsonObject {
+    /// Creates a new `JsonObject` from the given JSON value.
+    ///
+    /// SAFETY:
+    /// The caller must ensure that `current` is a value inside `root`.
+    unsafe fn new(root: &Arc<serde_json::Value>, current: &serde_json::Value) -> Self {
+        let root = root.clone();
+        JsonObject { root, current }
+    }
+
+    /// Returns a reference to the current JSON value.
+    #[inline(always)]
+    fn current(&self) -> &serde_json::Value {
+        unsafe { &*self.current }
+    }
+
+    /// Returns a new `JsonObject` which points to the value at the given key.
+    ///
+    /// This operation is cheap and does not clone the underlying data.
+    fn get(&self, key: Value) -> Option<Self> {
+        let value = match key {
+            Value::Integer(index) if index > 0 => self.current().get(index as usize - 1),
+            Value::String(key) => key.to_str().ok().and_then(|s| self.current().get(&*s)),
+            _ => None,
+        }?;
+        unsafe { Some(Self::new(&self.root, value)) }
+    }
+
+    /// Returns a new `JsonObject` by following the given JSON Pointer path.
+    fn pointer(&self, path: &str) -> Option<Self> {
+        unsafe { Some(JsonObject::new(&self.root, self.root.pointer(path)?)) }
+    }
+
+    /// Converts this `JsonObject` into a Lua `Value`.
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        match self.current() {
+            serde_json::Value::Null => Ok(Value::NULL),
+            serde_json::Value::Bool(b) => Ok(Value::Boolean(*b)),
+            serde_json::Value::Number(n) => {
+                if let Some(n) = n.as_i64() {
+                    Ok(Value::Integer(n as _))
+                } else if let Some(n) = n.as_f64() {
+                    Ok(Value::Number(n))
+                } else {
+                    Err(LuaError::ToLuaConversionError {
+                        from: "number".to_string(),
+                        to: "integer or float",
+                        message: Some("number is too big to fit in a Lua integer".to_owned()),
+                    })
+                }
+            }
+            serde_json::Value::String(s) => Ok(Value::String(lua.create_string(s)?)),
+            value @ serde_json::Value::Array(_) | value @ serde_json::Value::Object(_) => {
+                let obj_ud = lua.create_ser_userdata(unsafe { JsonObject::new(&self.root, value) })?;
+                Ok(Value::UserData(obj_ud))
+            }
+        }
+    }
+
+    fn lua_iterator(&self, lua: &Lua) -> Result<MultiValue> {
+        match self.current() {
+            serde_json::Value::Array(_) => {
+                let next = Self::lua_array_iterator(lua)?;
+                let iter_ud = AnyUserData::wrap(LuaJsonArrayIter {
+                    value: self.clone(),
+                    next: 1, // index starts at 1
+                });
+                (next, iter_ud).into_lua_multi(lua)
+            }
+            serde_json::Value::Object(_) => {
+                let next = Self::lua_map_iterator(lua)?;
+                let iter_builder = LuaJsonMapIterBuilder {
+                    value: self.clone(),
+                    iter_builder: |value| value.current().as_object().unwrap().iter(),
+                };
+                let iter_ud = AnyUserData::wrap(iter_builder.build());
+                (next, iter_ud).into_lua_multi(lua)
+            }
+            _ => ().into_lua_multi(lua),
+        }
+    }
+
+    /// Returns an iterator function for arrays.
+    fn lua_array_iterator(lua: &Lua) -> Result<Function> {
+        if let Ok(Some(f)) = lua.named_registry_value("__json_array_iterator") {
+            return Ok(f);
+        }
+
+        let f = lua.create_function(|lua, mut it: UserDataRefMut<LuaJsonArrayIter>| {
+            it.next += 1;
+            match it.value.get(Value::Integer(it.next - 1)) {
+                Some(next_value) => (it.next - 1, next_value.into_lua(lua)?).into_lua_multi(lua),
+                None => ().into_lua_multi(lua),
+            }
+        })?;
+        lua.set_named_registry_value("__json_array_iterator", &f)?;
+        Ok(f)
+    }
+
+    /// Returns an iterator function for objects.
+    fn lua_map_iterator(lua: &Lua) -> Result<Function> {
+        if let Ok(Some(f)) = lua.named_registry_value("__json_map_iterator") {
+            return Ok(f);
+        }
+
+        let f = lua.create_function(|lua, mut it: UserDataRefMut<LuaJsonMapIter>| {
+            let root = it.borrow_value().root.clone();
+            it.with_iter_mut(move |iter| match iter.next() {
+                Some((key, value)) => {
+                    let key = lua.create_string(key)?;
+                    let value = unsafe { JsonObject::new(&root, value) }.into_lua(lua)?;
+                    (key, value).into_lua_multi(lua)
+                }
+                None => ().into_lua_multi(lua),
+            })
+        })?;
+        lua.set_named_registry_value("__json_map_iterator", &f)?;
+        Ok(f)
+    }
+}
+
+impl From<serde_json::Value> for JsonObject {
+    fn from(value: serde_json::Value) -> Self {
+        let root = Arc::new(value);
+        unsafe { Self::new(&root, &root) }
+    }
+}
+
+impl UserData for JsonObject {
+    fn register(registry: &mut mlua::UserDataRegistry<Self>) {
+        registry.add_method("pointer", |lua, this, path: LuaString| {
+            this.pointer(&path.to_str()?)
+                .map(|obj| obj.into_lua(lua))
+                .unwrap_or(Ok(Value::Nil))
+        });
+
+        registry.add_method("dump", |lua, this, ()| lua.to_value(this));
+
+        registry.add_method("iter", |lua, this, ()| this.lua_iterator(lua));
+
+        registry.add_meta_method(MetaMethod::Index, |lua, this, key: Value| {
+            this.get(key)
+                .map(|obj| obj.into_lua(lua))
+                .unwrap_or(Ok(Value::Nil))
+        });
+
+        registry.add_meta_method(crate::METAMETHOD_ITER, |lua, this, ()| this.lua_iterator(lua));
+    }
+}
+
+struct LuaJsonArrayIter {
+    value: JsonObject,
+    next: LuaInteger,
+}
+
+#[self_referencing]
+struct LuaJsonMapIter {
+    value: JsonObject,
+
+    #[borrows(value)]
+    #[covariant]
+    iter: serde_json::map::Iter<'this>,
+}
+
+fn decode(lua: &Lua, data: StringOrBytes) -> Result<StdResult<Value, String>> {
+    let json: serde_json::Value = lua_try!(serde_json::from_slice(&data.as_bytes_deref()).into_lua_err());
+    Ok(Ok(lua.to_value(&json)?))
+}
+
+fn decode_native(lua: &Lua, data: StringOrBytes) -> Result<StdResult<Value, String>> {
+    let json: serde_json::Value = lua_try!(serde_json::from_slice(&data.as_bytes_deref()).into_lua_err());
+    Ok(Ok(lua_try!(JsonObject::from(json).into_lua(lua))))
+}
+
+fn encode(value: Value, options: Option<Table>) -> StdResult<String, String> {
+    let mut value = value.to_serializable();
+    let options = options.as_ref();
+
+    if options.and_then(|t| t.get::<bool>("relaxed").ok()) == Some(true) {
+        value = value.deny_recursive_tables(false).deny_unsupported_types(false);
+    }
+
+    if options.and_then(|t| t.get::<bool>("pretty").ok()) == Some(true) {
+        value = value.sort_keys(true);
+        return serde_json::to_string_pretty(&value).map_err(|e| e.to_string());
+    }
+
+    serde_json::to_string(&value).map_err(|e| e.to_string())
+}
+
+/// A loader for the `json` module.
+fn loader(lua: &Lua) -> Result<Table> {
+    let t = lua.create_table()?;
+    t.set("decode", lua.create_function(decode)?)?;
+    t.set("decode_native", lua.create_function(decode_native)?)?;
+    t.set("encode", Function::wrap_raw(encode))?;
+    Ok(t)
+}
+
+/// Registers the `json` module in the given Lua state.
+pub fn register(lua: &Lua, name: Option<&str>) -> Result<Table> {
+    let name = name.unwrap_or("@json");
+    let value = loader(lua)?;
+    lua.register_module(name, &value)?;
+    Ok(value)
+}

src/lib.rs

@@ -1,5 +1,17 @@
+#[rustfmt::skip]
+#[allow(unused)]
+pub(crate) const METAMETHOD_ITER: &str = if cfg!(feature = "luau") { "__iter" } else { "__pairs" };
+
+#[macro_use]
+mod macros;
+mod types;
+
 pub(crate) mod terminal;
 pub(crate) mod time;
 
 pub mod assertions;
+pub mod bytes;
 pub mod testing;
+
+#[cfg(feature = "json")]
+pub mod json;

src/macros.rs

@@ -0,0 +1,8 @@
+macro_rules! lua_try {
+    ($result:expr) => {
+        match $result {
+            Ok(ok) => ok,
+            Err(err) => return Ok(Err(format!("{err:#}"))),
+        }
+    };
+}

src/types.rs

@@ -0,0 +1,10 @@
+/// A trait that adds `Send` requirement if `send` feature is enabled.
+#[cfg(feature = "send")]
+pub trait MaybeSend: Send {}
+#[cfg(feature = "send")]
+impl<T: Send> MaybeSend for T {}
+
+#[cfg(not(feature = "send"))]
+pub trait MaybeSend {}
+#[cfg(not(feature = "send"))]
+impl<T> MaybeSend for T {}

tests/lib.rs

@@ -11,6 +11,9 @@ fn run_file(modname: &str) -> Result<()> {
     mlua_stdlib::assertions::register(&lua, None)?;
     let testing = mlua_stdlib::testing::register(&lua, None)?;
 
+    #[cfg(feature = "json")]
+    mlua_stdlib::json::register(&lua, None)?;
+
     // Add `testing` global variable (an instance of the testing framework)
     let testing = testing.call_function::<Table>("new", modname)?;
     lua.globals().set("testing", &testing)?;
@@ -29,14 +32,21 @@ fn run_file(modname: &str) -> Result<()> {
 }
 
 macro_rules! include_tests {
-    ($($name:ident, )*) => { $(
+    ($($name:ident,)*) => {
+        $(
         #[test]
         fn $name() -> Result<()> {
             run_file(stringify!($name))
         }
-    )*}
+        )*
+    };
+
+    ($name:ident) => { include_tests! { $name, } };
 }
 
 include_tests! {
     assertions,
 }
+
+#[cfg(feature = "json")]
+include_tests!(json);