code_ownership 2.1.0 → 2.1.1

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/src/ser/map_serializer.rs

@@ -1,26 +1,25 @@
 use super::Serializer;
 use crate::error::Error;
-use magnus::{
-    value::{qnil, ReprValue},
-    IntoValue, RHash, Value,
-};
+use magnus::{value::ReprValue, IntoValue, RHash, Ruby, Value};
 use serde::{ser::SerializeMap, Serialize};
 
-pub struct MapSerializer {
+pub struct MapSerializer<'r> {
+    ruby: &'r Ruby,
     hash: RHash,
     key: Value,
 }
 
-impl MapSerializer {
-    pub fn new(hash: RHash) -> MapSerializer {
+impl<'r> MapSerializer<'r> {
+    pub fn new(ruby: &'r Ruby, hash: RHash) -> MapSerializer<'r> {
         MapSerializer {
+            ruby,
             hash,
-            key: qnil().as_value(),
+            key: ruby.qnil().as_value(),
         }
     }
 }
 
-impl SerializeMap for MapSerializer {
+impl<'r> SerializeMap for MapSerializer<'r> {
     type Ok = Value;
     type Error = Error;
 
@@ -28,7 +27,7 @@ impl SerializeMap for MapSerializer {
     where
         Key: Serialize + ?Sized,
     {
-        self.key = key.serialize(Serializer)?;
+        self.key = key.serialize(Serializer::new(self.ruby))?;
         Ok(())
     }
 
@@ -37,11 +36,11 @@ impl SerializeMap for MapSerializer {
         Value: Serialize + ?Sized,
     {
         self.hash
-            .aset(self.key, value.serialize(Serializer)?)
+            .aset(self.key, value.serialize(Serializer::new(self.ruby))?)
             .map_err(Into::into)
     }
 
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.hash.into_value())
+        Ok(self.hash.into_value_with(self.ruby))
     }
 }

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/src/ser/mod.rs

@@ -15,7 +15,7 @@ use self::{
     tuple_variant_serializer::TupleVariantSerializer,
 };
 
-use magnus::{Error, TryConvert};
+use magnus::{Error, Ruby, TryConvert};
 use serde::Serialize;
 
 /// Serialize Rust data to a Ruby [`Value`][`magnus::Value`].
@@ -35,16 +35,16 @@ use serde::Serialize;
 /// | `&[u8]`                   | A `String` with ASCII-8BIT encoding |
 ///
 /// ```
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use magnus::{eval, Value};
 /// use serde_magnus::serialize;
 ///
-/// let output: Value = serialize(&1234)?;
-/// assert!(eval!("output == 1234", output)?);
+/// let output: Value = serialize(&ruby, &1234)?;
+/// assert!(eval!(&ruby, "output == 1234", output)?);
 ///
-/// let output: Value = serialize("Hello, world!")?;
-/// assert!(eval!("output == 'Hello, world!'", output)?);
+/// let output: Value = serialize(&ruby, "Hello, world!")?;
+/// assert!(eval!(&ruby, "output == 'Hello, world!'", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -57,15 +57,15 @@ use serde::Serialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// let input: Option<u64> = None;
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == nil", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == nil", output)?);
 ///
 /// let input: Option<u64> = Some(1234);
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == 1234", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == 1234", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -78,15 +78,15 @@ use serde::Serialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// let input: Result<u64, &str> = Ok(1234);
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == { 'Ok' => 1234 }", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == { 'Ok' => 1234 }", output)?);
 ///
 /// let input: Result<u64, &str> = Err("something went wrong");
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == { 'Err' => 'something went wrong' }", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == { 'Err' => 'something went wrong' }", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -99,15 +99,15 @@ use serde::Serialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use serde::Serialize;
 ///
 /// #[derive(Serialize)]
 /// struct Foo;
 ///
-/// let output: Value = serialize(&Foo)?;
-/// assert!(eval!("output == nil", output)?);
+/// let output: Value = serialize(&ruby, &Foo)?;
+/// assert!(eval!(&ruby, "output == nil", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -119,14 +119,14 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// #[derive(Serialize)]
 /// struct Foo(u16);
 ///
 /// let input = Foo(1234);
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == 1234", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == 1234", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -138,14 +138,14 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// #[derive(Serialize)]
 /// struct Foo<'a>(u16, bool, &'a str);
 ///
 /// let input = Foo(1234, false, "Hello, world!");
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == [1234, false, 'Hello, world!']", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == [1234, false, 'Hello, world!']", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -157,7 +157,7 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// #[derive(Serialize)]
 /// struct Foo<'a> {
@@ -167,8 +167,9 @@ use serde::Serialize;
 /// }
 ///
 /// let input = Foo { bar: 1234, baz: false, glorp: "Hello, world!" };
-/// let output: Value = serialize(&input)?;
+/// let output: Value = serialize(&ruby, &input)?;
 /// assert!(eval!(
+///     &ruby,
 ///     r#"
 ///     output == {
 ///       bar: 1234,
@@ -207,7 +208,7 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(Serialize)]
 /// # enum Foo<'a> {
@@ -221,8 +222,8 @@ use serde::Serialize;
 /// #     }
 /// # }
 /// #
-/// let output: Value = serialize(&Foo::Bar)?;
-/// assert!(eval!("output == 'Bar'", output)?);
+/// let output: Value = serialize(&ruby, &Foo::Bar)?;
+/// assert!(eval!(&ruby, "output == 'Bar'", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -237,7 +238,7 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(Serialize)]
 /// # enum Foo<'a> {
@@ -252,8 +253,8 @@ use serde::Serialize;
 /// # }
 /// #
 /// let input = Foo::Baz(1234);
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == { 'Baz' => 1234 }", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == { 'Baz' => 1234 }", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -265,7 +266,7 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(Serialize)]
 /// # enum Foo<'a> {
@@ -280,8 +281,8 @@ use serde::Serialize;
 /// # }
 /// #
 /// let input = Foo::Glorp(1234, false, "Hello, world!");
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == { 'Glorp' => [1234, false, 'Hello, world!'] }", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == { 'Glorp' => [1234, false, 'Hello, world!'] }", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -293,7 +294,7 @@ use serde::Serialize;
 /// # use serde::Serialize;
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(Serialize)]
 /// # enum Foo<'a> {
@@ -308,8 +309,9 @@ use serde::Serialize;
 /// # }
 /// #
 /// let input = Foo::Quux { frob: 1234, wally: false, plugh: "Hello, world!" };
-/// let output: Value = serialize(&input)?;
+/// let output: Value = serialize(&ruby, &input)?;
 /// assert!(eval!(
+///     &ruby,
 ///     r#"
 ///     output == {
 ///       "Quux" => {
@@ -334,15 +336,15 @@ use serde::Serialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// let input = (123, false, "Hello, world!");
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == [123, false, 'Hello, world!']", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == [123, false, 'Hello, world!']", output)?);
 ///
 /// let input = [123, 456, 789];
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == [123, 456, 789]", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == [123, 456, 789]", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -355,11 +357,11 @@ use serde::Serialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// let input = vec![123, 456, 789];
-/// let output: Value = serialize(&input)?;
-/// assert!(eval!("output == [123, 456, 789]", output)?);
+/// let output: Value = serialize(&ruby, &input)?;
+/// assert!(eval!(&ruby, "output == [123, 456, 789]", output)?);
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
@@ -370,7 +372,7 @@ use serde::Serialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::serialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use std::collections::HashMap;
 ///
@@ -380,8 +382,9 @@ use serde::Serialize;
 /// input.insert("high", "low");
 /// input.insert("goodbye", "hello");
 ///
-/// let output: Value = serialize(&input)?;
+/// let output: Value = serialize(&ruby, &input)?;
 /// assert!(eval!(
+///     &ruby,
 ///     r#"
 ///     output == {
 ///       "yes"     => "no",
@@ -395,10 +398,10 @@ use serde::Serialize;
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
-pub fn serialize<Input, Output>(input: &Input) -> Result<Output, Error>
+pub fn serialize<Input, Output>(ruby: &Ruby, input: &Input) -> Result<Output, Error>
 where
     Input: Serialize + ?Sized,
     Output: TryConvert,
 {
-    TryConvert::try_convert(input.serialize(Serializer)?)
+    TryConvert::try_convert(input.serialize(Serializer::new(ruby))?)
 }

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/src/ser/seq_serializer.rs

@@ -1,22 +1,23 @@
 use super::Serializer;
 use crate::error::Error;
-use magnus::{IntoValue, RArray, Value};
+use magnus::{IntoValue, RArray, Ruby, Value};
 use serde::{
     ser::{SerializeSeq, SerializeTuple, SerializeTupleStruct},
     Serialize,
 };
 
-pub struct SeqSerializer {
+pub struct SeqSerializer<'r> {
+    ruby: &'r Ruby,
     array: RArray,
 }
 
-impl SeqSerializer {
-    pub fn new(array: RArray) -> SeqSerializer {
-        SeqSerializer { array }
+impl<'r> SeqSerializer<'r> {
+    pub fn new(ruby: &'r Ruby, array: RArray) -> SeqSerializer<'r> {
+        SeqSerializer { ruby, array }
     }
 }
 
-impl SerializeSeq for SeqSerializer {
+impl<'r> SerializeSeq for SeqSerializer<'r> {
     type Ok = Value;
     type Error = Error;
 
@@ -25,16 +26,16 @@ impl SerializeSeq for SeqSerializer {
         Element: Serialize + ?Sized,
     {
         self.array
-            .push(element.serialize(Serializer)?)
+            .push(element.serialize(Serializer::new(self.ruby))?)
             .map_err(Into::into)
     }
 
     fn end(self) -> Result<Self::Ok, self::Error> {
-        Ok(self.array.into_value())
+        Ok(self.array.into_value_with(self.ruby))
     }
 }
 
-impl SerializeTuple for SeqSerializer {
+impl<'r> SerializeTuple for SeqSerializer<'r> {
     type Ok = Value;
     type Error = Error;
 
@@ -50,7 +51,7 @@ impl SerializeTuple for SeqSerializer {
     }
 }
 
-impl SerializeTupleStruct for SeqSerializer {
+impl<'r> SerializeTupleStruct for SeqSerializer<'r> {
     type Ok = Value;
     type Error = Error;
 

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/src/ser/serializer.rs

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, RArray, RHash, RString, Value};
+use magnus::{IntoValue, Ruby, Value};
 use serde::Serialize;
 
 use super::{
@@ -7,78 +7,86 @@ use super::{
 };
 use crate::error::Error;
 
-pub struct Serializer;
+pub struct Serializer<'r> {
+    ruby: &'r Ruby,
+}
+
+impl<'r> Serializer<'r> {
+    pub fn new(ruby: &'r Ruby) -> Self {
+        Self { ruby }
+    }
+}
 
-impl serde::Serializer for Serializer {
+impl<'r> serde::Serializer for Serializer<'r> {
     type Ok = Value;
     type Error = Error;
 
-    type SerializeSeq = SeqSerializer;
-    type SerializeTuple = SeqSerializer;
-    type SerializeTupleStruct = SeqSerializer;
-    type SerializeTupleVariant = TupleVariantSerializer;
-    type SerializeMap = MapSerializer;
-    type SerializeStruct = StructSerializer;
-    type SerializeStructVariant = StructVariantSerializer;
+    type SerializeSeq = SeqSerializer<'r>;
+    type SerializeTuple = SeqSerializer<'r>;
+    type SerializeTupleStruct = SeqSerializer<'r>;
+    type SerializeTupleVariant = TupleVariantSerializer<'r>;
+    type SerializeMap = MapSerializer<'r>;
+    type SerializeStruct = StructSerializer<'r>;
+    type SerializeStructVariant = StructVariantSerializer<'r>;
 
     fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_f32(self, value: f32) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_f64(self, value: f64) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
-        Ok(value.into_value())
+        Ok(value.into_value_with(self.ruby))
     }
 
     fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Ok(RString::from_slice(value).into_value())
+        Ok(self.ruby.str_from_slice(value).into_value_with(self.ruby))
     }
 
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Ok(().into_value())
+        Ok(().into_value_with(self.ruby))
     }
 
     fn serialize_some<Value>(self, value: &Value) -> Result<Self::Ok, Self::Error>
@@ -89,11 +97,11 @@ impl serde::Serializer for Serializer {
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Ok(().into_value())
+        Ok(().into_value_with(self.ruby))
     }
 
     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Ok(().into_value())
+        Ok(().into_value_with(self.ruby))
     }
 
     fn serialize_unit_variant(
@@ -102,7 +110,7 @@ impl serde::Serializer for Serializer {
         _index: u32,
         variant: &'static str,
     ) -> Result<Self::Ok, Self::Error> {
-        Ok(variant.into_value())
+        Ok(variant.into_value_with(self.ruby))
     }
 
     fn serialize_newtype_struct<Value>(
@@ -126,11 +134,14 @@ impl serde::Serializer for Serializer {
     where
         Value: Serialize + ?Sized,
     {
-        nest(variant, value.serialize(self)?)
+        nest(self.ruby, variant, value.serialize(self)?)
     }
 
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Ok(SeqSerializer::new(RArray::with_capacity(len.unwrap_or(0))))
+        Ok(SeqSerializer::new(
+            self.ruby,
+            self.ruby.ary_new_capa(len.unwrap_or(0)),
+        ))
     }
 
     fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
@@ -153,13 +164,14 @@ impl serde::Serializer for Serializer {
         len: usize,
     ) -> Result<Self::SerializeTupleVariant, Self::Error> {
         Ok(TupleVariantSerializer::new(
+            self.ruby,
             variant,
-            RArray::with_capacity(len),
+            self.ruby.ary_new_capa(len),
         ))
     }
 
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Ok(MapSerializer::new(RHash::new()))
+        Ok(MapSerializer::new(self.ruby, self.ruby.hash_new()))
     }
 
     fn serialize_struct(
@@ -167,7 +179,7 @@ impl serde::Serializer for Serializer {
         _name: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeStruct, Self::Error> {
-        Ok(StructSerializer::new(RHash::new()))
+        Ok(StructSerializer::new(self.ruby, self.ruby.hash_new()))
     }
 
     fn serialize_struct_variant(
@@ -177,6 +189,10 @@ impl serde::Serializer for Serializer {
         variant: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Ok(StructVariantSerializer::new(variant, RHash::new()))
+        Ok(StructVariantSerializer::new(
+            self.ruby,
+            variant,
+            self.ruby.hash_new(),
+        ))
     }
 }

data/ext/cargo-vendor/serde_magnus-0.10.0/src/ser/struct_serializer.rs

@@ -0,0 +1,40 @@
+use super::Serializer;
+use crate::error::Error;
+use magnus::{IntoValue, RHash, Ruby, Value};
+use serde::{ser::SerializeStruct, Serialize};
+
+pub struct StructSerializer<'r> {
+    ruby: &'r Ruby,
+    hash: RHash,
+}
+
+impl<'r> StructSerializer<'r> {
+    pub fn new(ruby: &'r Ruby, hash: RHash) -> StructSerializer<'r> {
+        StructSerializer { ruby, hash }
+    }
+}
+
+impl<'r> SerializeStruct for StructSerializer<'r> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_field<Value>(
+        &mut self,
+        name: &'static str,
+        value: &Value,
+    ) -> Result<(), Self::Error>
+    where
+        Value: Serialize + ?Sized,
+    {
+        self.hash
+            .aset(
+                self.ruby.to_symbol(name),
+                value.serialize(Serializer::new(self.ruby))?,
+            )
+            .map_err(Into::into)
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(self.hash.into_value_with(self.ruby))
+    }
+}