aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Cargo.lock1
-rw-r--r--Cargo.toml1
-rw-r--r--src/lua.rs14
-rw-r--r--src/lua/serde/de.rs436
-rw-r--r--src/lua/serde/error.rs58
-rw-r--r--src/lua/serde/mod.rs57
-rw-r--r--src/lua/serde/ser.rs481
7 files changed, 0 insertions, 1048 deletions
diff --git a/Cargo.lock b/Cargo.lock
index c53e499..28a2416 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -239,7 +239,6 @@ dependencies = [
"pulldown-cmark",
"rlua",
"serde",
- "serde_derive",
"sputnik",
"tempdir",
"tokio",
diff --git a/Cargo.toml b/Cargo.toml
index 4e7474e..73c92ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,4 +46,3 @@ hyperlocal = { version = "0.8", features = ["server"] }
[dev-dependencies]
tempdir = "0.3.7"
-serde_derive = "1.0"
diff --git a/src/lua.rs b/src/lua.rs
index d8d82b2..70f63c5 100644
--- a/src/lua.rs
+++ b/src/lua.rs
@@ -1,7 +1,6 @@
use std::fmt::Display;
use std::path::Path;
use std::str::from_utf8;
-use std::sync::Arc;
use rlua::Function;
use rlua::HookTriggers;
@@ -13,7 +12,6 @@ use crate::Context;
use self::template::ArgIndex;
-mod serde;
pub mod template;
pub enum ScriptError {
@@ -49,18 +47,6 @@ pub fn lua_context<A>(run: impl FnOnce(rlua::Context) -> rlua::Result<A>) -> rlu
.eval::<Table>()
.expect("error in api.lua");
- api.set(
- "decode_toml",
- ctx.create_function(|_ctx, text: String| {
- toml::from_str::<toml::Value>(&text)
- .map_err(|e| rlua::Error::ExternalError(Arc::new(e)))
- .and_then(|v| {
- serde::to_value(_ctx, v)
- .map_err(|e| rlua::Error::ExternalError(Arc::new(e)))
- })
- })?,
- )?;
-
ctx.globals().raw_set("gitpad", api).unwrap();
run(ctx)
diff --git a/src/lua/serde/de.rs b/src/lua/serde/de.rs
deleted file mode 100644
index 4d78a83..0000000
--- a/src/lua/serde/de.rs
+++ /dev/null
@@ -1,436 +0,0 @@
-// vendored from https://github.com/zrkn/rlua_serde because it dependend on an outdated rlua version
-// Copyright (c) 2018 zrkn <zrkn@email.su>, licensed under the MIT License
-
-use serde::de::IntoDeserializer;
-use serde::{self, forward_to_deserialize_any};
-
-use rlua::{TablePairs, TableSequence, Value};
-
-use super::error::{Error, Result};
-
-pub struct Deserializer<'lua> {
- pub value: Value<'lua>,
-}
-
-impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
- type Error = Error;
-
- #[inline]
- fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- match self.value {
- Value::Nil => visitor.visit_unit(),
- Value::Boolean(v) => visitor.visit_bool(v),
- Value::Integer(v) => visitor.visit_i64(v),
- Value::Number(v) => visitor.visit_f64(v),
- Value::String(v) => visitor.visit_str(v.to_str()?),
- Value::Table(v) => {
- let len = v.len()? as usize;
- let mut deserializer = MapDeserializer(v.pairs(), None);
- let map = visitor.visit_map(&mut deserializer)?;
- let remaining = deserializer.0.count();
- if remaining == 0 {
- Ok(map)
- } else {
- Err(serde::de::Error::invalid_length(
- len,
- &"fewer elements in array",
- ))
- }
- }
- _ => Err(serde::de::Error::custom("invalid value type")),
- }
- }
-
- #[inline]
- fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- match self.value {
- Value::Nil => visitor.visit_none(),
- _ => visitor.visit_some(self),
- }
- }
-
- #[inline]
- fn deserialize_enum<V>(
- self,
- _name: &str,
- _variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- let (variant, value) = match self.value {
- Value::Table(value) => {
- let mut iter = value.pairs::<String, Value>();
- let (variant, value) = match iter.next() {
- Some(v) => v?,
- None => {
- return Err(serde::de::Error::invalid_value(
- serde::de::Unexpected::Map,
- &"map with a single key",
- ))
- }
- };
-
- if iter.next().is_some() {
- return Err(serde::de::Error::invalid_value(
- serde::de::Unexpected::Map,
- &"map with a single key",
- ));
- }
- (variant, Some(value))
- }
- Value::String(variant) => (variant.to_str()?.to_owned(), None),
- _ => return Err(serde::de::Error::custom("bad enum value")),
- };
-
- visitor.visit_enum(EnumDeserializer { variant, value })
- }
-
- #[inline]
- fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- match self.value {
- Value::Table(v) => {
- let len = v.len()? as usize;
- let mut deserializer = SeqDeserializer(v.sequence_values());
- let seq = visitor.visit_seq(&mut deserializer)?;
- let remaining = deserializer.0.count();
- if remaining == 0 {
- Ok(seq)
- } else {
- Err(serde::de::Error::invalid_length(
- len,
- &"fewer elements in array",
- ))
- }
- }
- _ => Err(serde::de::Error::custom("invalid value type")),
- }
- }
-
- #[inline]
- fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- self.deserialize_seq(visitor)
- }
-
- #[inline]
- fn deserialize_tuple_struct<V>(
- self,
- _name: &'static str,
- _len: usize,
- visitor: V,
- ) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- self.deserialize_seq(visitor)
- }
-
- forward_to_deserialize_any! {
- bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
- byte_buf unit unit_struct newtype_struct
- map struct identifier ignored_any
- }
-}
-
-struct SeqDeserializer<'lua>(TableSequence<'lua, Value<'lua>>);
-
-impl<'lua, 'de> serde::de::SeqAccess<'de> for SeqDeserializer<'lua> {
- type Error = Error;
-
- fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
- where
- T: serde::de::DeserializeSeed<'de>,
- {
- match self.0.next() {
- Some(value) => seed.deserialize(Deserializer { value: value? }).map(Some),
- None => Ok(None),
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- match self.0.size_hint() {
- (lower, Some(upper)) if lower == upper => Some(upper),
- _ => None,
- }
- }
-}
-
-struct MapDeserializer<'lua>(
- TablePairs<'lua, Value<'lua>, Value<'lua>>,
- Option<Value<'lua>>,
-);
-
-impl<'lua, 'de> serde::de::MapAccess<'de> for MapDeserializer<'lua> {
- type Error = Error;
-
- fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
- where
- T: serde::de::DeserializeSeed<'de>,
- {
- match self.0.next() {
- Some(item) => {
- let (key, value) = item?;
- self.1 = Some(value);
- let key_de = Deserializer { value: key };
- seed.deserialize(key_de).map(Some)
- }
- None => Ok(None),
- }
- }
-
- fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value>
- where
- T: serde::de::DeserializeSeed<'de>,
- {
- match self.1.take() {
- Some(value) => seed.deserialize(Deserializer { value }),
- None => Err(serde::de::Error::custom("value is missing")),
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- match self.0.size_hint() {
- (lower, Some(upper)) if lower == upper => Some(upper),
- _ => None,
- }
- }
-}
-
-struct EnumDeserializer<'lua> {
- variant: String,
- value: Option<Value<'lua>>,
-}
-
-impl<'lua, 'de> serde::de::EnumAccess<'de> for EnumDeserializer<'lua> {
- type Error = Error;
- type Variant = VariantDeserializer<'lua>;
-
- fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant)>
- where
- T: serde::de::DeserializeSeed<'de>,
- {
- let variant = self.variant.into_deserializer();
- let variant_access = VariantDeserializer { value: self.value };
- seed.deserialize(variant).map(|v| (v, variant_access))
- }
-}
-
-struct VariantDeserializer<'lua> {
- value: Option<Value<'lua>>,
-}
-
-impl<'lua, 'de> serde::de::VariantAccess<'de> for VariantDeserializer<'lua> {
- type Error = Error;
-
- fn unit_variant(self) -> Result<()> {
- match self.value {
- Some(_) => Err(serde::de::Error::invalid_type(
- serde::de::Unexpected::NewtypeVariant,
- &"unit variant",
- )),
- None => Ok(()),
- }
- }
-
- fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
- where
- T: serde::de::DeserializeSeed<'de>,
- {
- match self.value {
- Some(value) => seed.deserialize(Deserializer { value }),
- None => Err(serde::de::Error::invalid_type(
- serde::de::Unexpected::UnitVariant,
- &"newtype variant",
- )),
- }
- }
-
- fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- match self.value {
- Some(value) => serde::Deserializer::deserialize_seq(Deserializer { value }, visitor),
- None => Err(serde::de::Error::invalid_type(
- serde::de::Unexpected::UnitVariant,
- &"tuple variant",
- )),
- }
- }
-
- fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
- where
- V: serde::de::Visitor<'de>,
- {
- match self.value {
- Some(value) => serde::Deserializer::deserialize_map(Deserializer { value }, visitor),
- None => Err(serde::de::Error::invalid_type(
- serde::de::Unexpected::UnitVariant,
- &"struct variant",
- )),
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use rlua::Lua;
-
- use super::super::from_value;
- use serde::Deserialize;
-
- #[test]
- fn test_struct() {
- #[derive(Deserialize, PartialEq, Debug)]
- struct Test {
- int: u32,
- seq: Vec<String>,
- map: std::collections::HashMap<i32, i32>,
- empty: Vec<()>,
- }
-
- let expected = Test {
- int: 1,
- seq: vec!["a".to_owned(), "b".to_owned()],
- map: vec![(1, 2), (4, 1)].into_iter().collect(),
- empty: vec![],
- };
-
- println!("{:?}", expected);
- let lua = Lua::new();
- lua.context(|lua| {
- let value = lua
- .load(
- r#"
- a = {}
- a.int = 1
- a.seq = {"a", "b"}
- a.map = {2, [4]=1}
- a.empty = {}
- return a
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
- });
- }
-
- #[test]
- fn test_tuple() {
- #[derive(Deserialize, PartialEq, Debug)]
- struct Rgb(u8, u8, u8);
-
- let lua = Lua::new();
- lua.context(|lua| {
- let expected = Rgb(1, 2, 3);
- let value = lua
- .load(
- r#"
- a = {1, 2, 3}
- return a
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
-
- let expected = (1, 2, 3);
- let value = lua
- .load(
- r#"
- a = {1, 2, 3}
- return a
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
- });
- }
-
- #[test]
- fn test_enum() {
- #[derive(Deserialize, PartialEq, Debug)]
- enum E {
- Unit,
- Newtype(u32),
- Tuple(u32, u32),
- Struct { a: u32 },
- }
-
- let lua = Lua::new();
- lua.context(|lua| {
- let expected = E::Unit;
- let value = lua
- .load(
- r#"
- return "Unit"
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
-
- let expected = E::Newtype(1);
- let value = lua
- .load(
- r#"
- a = {}
- a["Newtype"] = 1
- return a
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
-
- let expected = E::Tuple(1, 2);
- let value = lua
- .load(
- r#"
- a = {}
- a["Tuple"] = {1, 2}
- return a
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
-
- let expected = E::Struct { a: 1 };
- let value = lua
- .load(
- r#"
- a = {}
- a["Struct"] = {}
- a["Struct"]["a"] = 1
- return a
- "#,
- )
- .eval()
- .unwrap();
- let got = from_value(value).unwrap();
- assert_eq!(expected, got);
- });
- }
-}
diff --git a/src/lua/serde/error.rs b/src/lua/serde/error.rs
deleted file mode 100644
index 8d5debf..0000000
--- a/src/lua/serde/error.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// vendored from https://github.com/zrkn/rlua_serde because it dependend on an outdated rlua version
-// Copyright (c) 2018 zrkn <zrkn@email.su>, licensed under the MIT License
-
-use std::error::Error as StdError;
-use std::fmt;
-use std::result::Result as StdResult;
-
-use rlua::Error as LuaError;
-use serde;
-
-#[derive(Debug)]
-pub struct Error(LuaError);
-
-pub type Result<T> = StdResult<T, Error>;
-
-impl From<LuaError> for Error {
- fn from(err: LuaError) -> Error {
- Error(err)
- }
-}
-
-impl From<Error> for LuaError {
- fn from(err: Error) -> LuaError {
- err.0
- }
-}
-
-impl fmt::Display for Error {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(fmt)
- }
-}
-
-impl StdError for Error {
- fn description(&self) -> &'static str {
- "Failed to serialize to Lua value"
- }
-}
-
-impl serde::ser::Error for Error {
- fn custom<T: fmt::Display>(msg: T) -> Self {
- Error(LuaError::ToLuaConversionError {
- from: "serialize",
- to: "value",
- message: Some(format!("{}", msg)),
- })
- }
-}
-
-impl serde::de::Error for Error {
- fn custom<T: fmt::Display>(msg: T) -> Self {
- Error(LuaError::FromLuaConversionError {
- from: "value",
- to: "deserialize",
- message: Some(format!("{}", msg)),
- })
- }
-}
diff --git a/src/lua/serde/mod.rs b/src/lua/serde/mod.rs
deleted file mode 100644
index 82a928a..0000000
--- a/src/lua/serde/mod.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// vendored from https://github.com/zrkn/rlua_serde because it dependend on an outdated rlua version
-// Copyright (c) 2018 zrkn <zrkn@email.su>, licensed under the MIT License
-
-//! This crate allows you to serialize and deserialize any type that implements
-//! `serde::Serialize` and `serde::Deserialize` into/from `rlua::Value`.
-//!
-//! Implementation is similar to `serde_json::Value`
-//!
-//! Example usage:
-//!
-//! ```rust
-//! extern crate serde;
-//! #[macro_use]
-//! extern crate serde_derive;
-//! extern crate rlua;
-//! extern crate rlua_serde;
-//!
-//! fn main() {
-//! #[derive(Serialize, Deserialize)]
-//! struct Foo {
-//! bar: u32,
-//! baz: Vec<String>,
-//! }
-//!
-//! let lua = rlua::Lua::new();
-//! lua.context(|lua| {
-//! let foo = Foo {
-//! bar: 42,
-//! baz: vec![String::from("fizz"), String::from("buzz")],
-//! };
-//!
-//! let value = rlua_serde::to_value(lua, &foo).unwrap();
-//! lua.globals().set("value", value).unwrap();
-//! lua.load(
-//! r#"
-//! assert(value["bar"] == 42)
-//! assert(value["baz"][2] == "buzz")
-//! "#).exec().unwrap();
-//! });
-//! }
-//! ```
-
-pub mod de;
-pub mod error;
-pub mod ser;
-
-use rlua::{Context, Error, Value};
-
-pub fn to_value<T: serde::Serialize>(lua: Context, t: T) -> Result<Value, Error> {
- let serializer = ser::Serializer { lua };
- Ok(t.serialize(serializer)?)
-}
-
-pub fn from_value<'de, T: serde::Deserialize<'de>>(value: Value<'de>) -> Result<T, Error> {
- let deserializer = de::Deserializer { value };
- Ok(T::deserialize(deserializer)?)
-}
diff --git a/src/lua/serde/ser.rs b/src/lua/serde/ser.rs
deleted file mode 100644
index 8af978a..0000000
--- a/src/lua/serde/ser.rs
+++ /dev/null
@@ -1,481 +0,0 @@
-// vendored from https://github.com/zrkn/rlua_serde because it dependend on an outdated rlua version
-// Copyright (c) 2018 zrkn <zrkn@email.su>, licensed under the MIT License
-
-use serde;
-
-use rlua::{Context, String as LuaString, Table, Value};
-
-use super::error::{Error, Result};
-use super::to_value;
-
-pub struct Serializer<'lua> {
- pub lua: Context<'lua>,
-}
-
-impl<'lua> serde::Serializer for Serializer<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- type SerializeSeq = SerializeVec<'lua>;
- type SerializeTuple = SerializeVec<'lua>;
- type SerializeTupleStruct = SerializeVec<'lua>;
- type SerializeTupleVariant = SerializeTupleVariant<'lua>;
- type SerializeMap = SerializeMap<'lua>;
- type SerializeStruct = SerializeMap<'lua>;
- type SerializeStructVariant = SerializeStructVariant<'lua>;
-
- #[inline]
- fn serialize_bool(self, value: bool) -> Result<Value<'lua>> {
- Ok(Value::Boolean(value))
- }
-
- #[inline]
- fn serialize_i8(self, value: i8) -> Result<Value<'lua>> {
- self.serialize_i64(i64::from(value))
- }
-
- #[inline]
- fn serialize_i16(self, value: i16) -> Result<Value<'lua>> {
- self.serialize_i64(i64::from(value))
- }
-
- #[inline]
- fn serialize_i32(self, value: i32) -> Result<Value<'lua>> {
- self.serialize_i64(i64::from(value))
- }
-
- #[inline]
- fn serialize_i64(self, value: i64) -> Result<Value<'lua>> {
- Ok(Value::Integer(value))
- }
-
- #[inline]
- fn serialize_u8(self, value: u8) -> Result<Value<'lua>> {
- self.serialize_i64(i64::from(value))
- }
-
- #[inline]
- fn serialize_u16(self, value: u16) -> Result<Value<'lua>> {
- self.serialize_i64(i64::from(value))
- }
-
- #[inline]
- fn serialize_u32(self, value: u32) -> Result<Value<'lua>> {
- self.serialize_i64(i64::from(value))
- }
-
- #[inline]
- fn serialize_u64(self, value: u64) -> Result<Value<'lua>> {
- self.serialize_i64(value as i64)
- }
-
- #[inline]
- fn serialize_f32(self, value: f32) -> Result<Value<'lua>> {
- self.serialize_f64(f64::from(value))
- }
-
- #[inline]
- fn serialize_f64(self, value: f64) -> Result<Value<'lua>> {
- Ok(Value::Number(value))
- }
-
- #[inline]
- fn serialize_char(self, value: char) -> Result<Value<'lua>> {
- let mut s = String::new();
- s.push(value);
- self.serialize_str(&s)
- }
-
- #[inline]
- fn serialize_str(self, value: &str) -> Result<Value<'lua>> {
- Ok(Value::String(self.lua.create_string(value)?))
- }
-
- #[inline]
- fn serialize_bytes(self, value: &[u8]) -> Result<Value<'lua>> {
- Ok(Value::Table(
- self.lua.create_sequence_from(value.iter().cloned())?,
- ))
- }
-
- #[inline]
- fn serialize_unit(self) -> Result<Value<'lua>> {
- Ok(Value::Nil)
- }
-
- #[inline]
- fn serialize_unit_struct(self, _name: &'static str) -> Result<Value<'lua>> {
- self.serialize_unit()
- }
-
- #[inline]
- fn serialize_unit_variant(
- self,
- _name: &'static str,
- _variant_index: u32,
- variant: &'static str,
- ) -> Result<Value<'lua>> {
- self.serialize_str(variant)
- }
-
- #[inline]
- fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value<'lua>>
- where
- T: ?Sized + serde::Serialize,
- {
- value.serialize(self)
- }
-
- fn serialize_newtype_variant<T>(
- self,
- _name: &'static str,
- _variant_index: u32,
- variant: &'static str,
- value: &T,
- ) -> Result<Value<'lua>>
- where
- T: ?Sized + serde::Serialize,
- {
- let table = self.lua.create_table()?;
- let variant = self.lua.create_string(variant)?;
- let value = to_value(self.lua, value)?;
- table.set(variant, value)?;
- Ok(Value::Table(table))
- }
-
- #[inline]
- fn serialize_none(self) -> Result<Value<'lua>> {
- self.serialize_unit()
- }
-
- #[inline]
- fn serialize_some<T>(self, value: &T) -> Result<Value<'lua>>
- where
- T: ?Sized + serde::Serialize,
- {
- value.serialize(self)
- }
-
- fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
- let table = self.lua.create_table()?;
- Ok(SerializeVec {
- lua: self.lua,
- idx: 1,
- table,
- })
- }
-
- fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
- self.serialize_seq(Some(len))
- }
-
- fn serialize_tuple_struct(
- self,
- _name: &'static str,
- len: usize,
- ) -> Result<Self::SerializeTupleStruct> {
- self.serialize_seq(Some(len))
- }
-
- fn serialize_tuple_variant(
- self,
- _name: &'static str,
- _variant_index: u32,
- variant: &'static str,
- _len: usize,
- ) -> Result<Self::SerializeTupleVariant> {
- let name = self.lua.create_string(variant)?;
- let table = self.lua.create_table()?;
- Ok(SerializeTupleVariant {
- lua: self.lua,
- idx: 1,
- name,
- table,
- })
- }
-
- fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
- let table = self.lua.create_table()?;
- Ok(SerializeMap {
- lua: self.lua,
- next_key: None,
- table,
- })
- }
-
- fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
- self.serialize_map(Some(len))
- }
-
- fn serialize_struct_variant(
- self,
- _name: &'static str,
- _variant_index: u32,
- variant: &'static str,
- _len: usize,
- ) -> Result<Self::SerializeStructVariant> {
- let name = self.lua.create_string(variant)?;
- let table = self.lua.create_table()?;
- Ok(SerializeStructVariant {
- lua: self.lua,
- name,
- table,
- })
- }
-}
-
-pub struct SerializeVec<'lua> {
- lua: Context<'lua>,
- table: Table<'lua>,
- idx: u64,
-}
-
-impl<'lua> serde::ser::SerializeSeq for SerializeVec<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_element<T>(&mut self, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- self.table.set(self.idx, to_value(self.lua, value)?)?;
- self.idx += 1;
- Ok(())
- }
-
- fn end(self) -> Result<Value<'lua>> {
- Ok(Value::Table(self.table))
- }
-}
-
-impl<'lua> serde::ser::SerializeTuple for SerializeVec<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_element<T>(&mut self, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- serde::ser::SerializeSeq::serialize_element(self, value)
- }
-
- fn end(self) -> Result<Value<'lua>> {
- serde::ser::SerializeSeq::end(self)
- }
-}
-
-impl<'lua> serde::ser::SerializeTupleStruct for SerializeVec<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_field<T>(&mut self, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- serde::ser::SerializeSeq::serialize_element(self, value)
- }
-
- fn end(self) -> Result<Value<'lua>> {
- serde::ser::SerializeSeq::end(self)
- }
-}
-
-pub struct SerializeTupleVariant<'lua> {
- lua: Context<'lua>,
- name: LuaString<'lua>,
- table: Table<'lua>,
- idx: u64,
-}
-
-impl<'lua> serde::ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_field<T>(&mut self, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- self.table.set(self.idx, to_value(self.lua, value)?)?;
- self.idx += 1;
- Ok(())
- }
-
- fn end(self) -> Result<Value<'lua>> {
- let table = self.lua.create_table()?;
- table.set(self.name, self.table)?;
- Ok(Value::Table(table))
- }
-}
-
-pub struct SerializeMap<'lua> {
- lua: Context<'lua>,
- table: Table<'lua>,
- next_key: Option<Value<'lua>>,
-}
-
-impl<'lua> serde::ser::SerializeMap for SerializeMap<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_key<T>(&mut self, key: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- self.next_key = Some(to_value(self.lua, key)?);
- Ok(())
- }
-
- fn serialize_value<T>(&mut self, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- let key = self.next_key.take();
- // Panic because this indicates a bug in the program rather than an
- // expected failure.
- let key = key.expect("serialize_value called before serialize_key");
- self.table.set(key, to_value(self.lua, value)?)?;
- Ok(())
- }
-
- fn end(self) -> Result<Value<'lua>> {
- Ok(Value::Table(self.table))
- }
-}
-
-impl<'lua> serde::ser::SerializeStruct for SerializeMap<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- serde::ser::SerializeMap::serialize_key(self, key)?;
- serde::ser::SerializeMap::serialize_value(self, value)
- }
-
- fn end(self) -> Result<Value<'lua>> {
- serde::ser::SerializeMap::end(self)
- }
-}
-
-pub struct SerializeStructVariant<'lua> {
- lua: Context<'lua>,
- name: LuaString<'lua>,
- table: Table<'lua>,
-}
-
-impl<'lua> serde::ser::SerializeStructVariant for SerializeStructVariant<'lua> {
- type Ok = Value<'lua>;
- type Error = Error;
-
- fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
- where
- T: ?Sized + serde::Serialize,
- {
- self.table.set(key, to_value(self.lua, value)?)?;
- Ok(())
- }
-
- fn end(self) -> Result<Value<'lua>> {
- let table = self.lua.create_table()?;
- table.set(self.name, self.table)?;
- Ok(Value::Table(table))
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use rlua::Lua;
- use serde::Serialize;
-
- #[test]
- fn test_struct() {
- #[derive(Serialize)]
- struct Test {
- int: u32,
- seq: Vec<&'static str>,
- }
-
- let test = Test {
- int: 1,
- seq: vec!["a", "b"],
- };
-
- let lua = Lua::new();
- lua.context(|lua| {
- let value = to_value(lua, &test).unwrap();
- lua.globals().set("value", value).unwrap();
- lua.load(
- r#"
- assert(value["int"] == 1)
- assert(value["seq"][1] == "a")
- assert(value["seq"][2] == "b")
- "#,
- )
- .exec()
- })
- .unwrap()
- }
-
- #[test]
- fn test_num() {
- #[derive(Serialize)]
- enum E {
- Unit,
- Newtype(u32),
- Tuple(u32, u32),
- Struct { a: u32 },
- }
-
- let lua = Lua::new();
-
- lua.context(|lua| {
- let u = E::Unit;
- let value = to_value(lua, &u).unwrap();
- lua.globals().set("value", value).unwrap();
- lua.load(
- r#"
- assert(value == "Unit")
- "#,
- )
- .exec()
- .unwrap();
-
- let n = E::Newtype(1);
- let value = to_value(lua, &n).unwrap();
- lua.globals().set("value", value).unwrap();
- lua.load(
- r#"
- assert(value["Newtype"] == 1)
- "#,
- )
- .exec()
- .unwrap();
-
- let t = E::Tuple(1, 2);
- let value = to_value(lua, &t).unwrap();
- lua.globals().set("value", value).unwrap();
- lua.load(
- r#"
- assert(value["Tuple"][1] == 1)
- assert(value["Tuple"][2] == 2)
- "#,
- )
- .exec()
- .unwrap();
-
- let s = E::Struct { a: 1 };
- let value = to_value(lua, &s).unwrap();
- lua.globals().set("value", value).unwrap();
- lua.load(
- r#"
- assert(value["Struct"]["a"] == 1)
- "#,
- )
- .exec()
- })
- .unwrap();
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-18 10:45:40 +0000