drop gitpad.decode_toml Lua function

The function made sense when we had Lua shebangs but now that they
have been removed, the function doesn't make much sense anymore.

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();
-    }
-}