code_ownership 2.1.0 → 2.1.1

data/ext/cargo-vendor/serde_magnus-0.10.0/src/de/enum_deserializer.rs

@@ -0,0 +1,35 @@
+use super::VariantDeserializer;
+use crate::error::Error;
+use magnus::{Ruby, Value};
+use serde::de::{DeserializeSeed, EnumAccess, IntoDeserializer};
+
+pub struct EnumDeserializer<'r> {
+    ruby: &'r Ruby,
+    variant: String,
+    value: Value,
+}
+
+impl<'r> EnumDeserializer<'r> {
+    pub fn new(ruby: &'r Ruby, variant: String, value: Value) -> EnumDeserializer<'r> {
+        EnumDeserializer {
+            ruby,
+            variant,
+            value,
+        }
+    }
+}
+
+impl<'r, 'i> EnumAccess<'i> for EnumDeserializer<'r> {
+    type Variant = VariantDeserializer<'r>;
+    type Error = Error;
+
+    fn variant_seed<Seed>(self, seed: Seed) -> Result<(Seed::Value, Self::Variant), Error>
+    where
+        Seed: DeserializeSeed<'i>,
+    {
+        let deserializer = VariantDeserializer::new(self.ruby, self.value);
+
+        seed.deserialize(self.variant.into_deserializer())
+            .map(|value| (value, deserializer))
+    }
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/src/de/hash_deserializer.rs

@@ -1,24 +1,26 @@
 use super::{array_enumerator::ArrayEnumerator, Deserializer};
 use crate::error::Error;
-use magnus::{exception, value::ReprValue, RHash};
+use magnus::{value::ReprValue, RHash, Ruby};
 use serde::de::{DeserializeSeed, MapAccess};
 use std::iter::Peekable;
 
-pub struct HashDeserializer {
+pub struct HashDeserializer<'r> {
+    ruby: &'r Ruby,
     hash: RHash,
-    keys: Peekable<ArrayEnumerator>,
+    keys: Peekable<ArrayEnumerator<'r>>,
 }
 
-impl HashDeserializer {
-    pub fn new(hash: RHash) -> Result<HashDeserializer, Error> {
+impl<'r> HashDeserializer<'r> {
+    pub fn new(ruby: &'r Ruby, hash: RHash) -> Result<HashDeserializer<'r>, Error> {
         Ok(HashDeserializer {
+            ruby,
             hash,
-            keys: ArrayEnumerator::new(hash.funcall("keys", ())?).peekable(),
+            keys: ArrayEnumerator::new(ruby, hash.funcall("keys", ())?).peekable(),
         })
     }
 }
 
-impl<'i> MapAccess<'i> for HashDeserializer {
+impl<'r, 'i> MapAccess<'i> for HashDeserializer<'r> {
     type Error = Error;
 
     fn next_key_seed<Seed>(&mut self, seed: Seed) -> Result<Option<Seed::Value>, Self::Error>
@@ -26,10 +28,12 @@ impl<'i> MapAccess<'i> for HashDeserializer {
         Seed: DeserializeSeed<'i>,
     {
         match self.keys.peek() {
-            Some(&Ok(key)) => seed.deserialize(Deserializer::new(key)).map(Some),
+            Some(&Ok(key)) => seed
+                .deserialize(Deserializer::new(self.ruby, key))
+                .map(Some),
 
             Some(Err(error)) => Err(Error::new(
-                exception::runtime_error(),
+                self.ruby.exception_runtime_error(),
                 format!("encountered unexpected error: {}", error),
             )),
 
@@ -42,9 +46,12 @@ impl<'i> MapAccess<'i> for HashDeserializer {
         Seed: DeserializeSeed<'i>,
     {
         match self.keys.next() {
-            Some(Ok(key)) => seed.deserialize(Deserializer::new(self.hash.aref(key)?)),
+            Some(Ok(key)) => seed.deserialize(Deserializer::new(self.ruby, self.hash.aref(key)?)),
             Some(Err(error)) => Err(error.into()),
-            None => Err(Error::new(exception::index_error(), "index out of range")),
+            None => Err(Error::new(
+                self.ruby.exception_index_error(),
+                "index out of range",
+            )),
         }
     }
 }

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

@@ -13,7 +13,7 @@ use self::{
     hash_deserializer::HashDeserializer, variant_deserializer::VariantDeserializer,
 };
 
-use magnus::{Error, IntoValue};
+use magnus::{Error, IntoValue, Ruby};
 use serde::Deserialize;
 
 /// Deserialize a Ruby [`Value`][`magnus::Value`] to Rust.
@@ -25,13 +25,13 @@ use serde::Deserialize;
 /// #### Unit type
 ///
 /// ```
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use magnus::{eval, Value};
 /// use serde_magnus::deserialize;
 ///
-/// let input: Value = eval!("nil")?;
-/// let output: () = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "nil")?;
+/// let output: () = deserialize(&ruby, input)?;
 /// assert_eq!((), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -43,10 +43,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("true")?;
-/// let output: bool = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "true")?;
+/// let output: bool = deserialize(&ruby, input)?;
 /// assert_eq!(true, output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -58,10 +58,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("1234")?;
-/// let output: i64 = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "1234")?;
+/// let output: i64 = deserialize(&ruby, input)?;
 /// assert_eq!(1234, output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -73,10 +73,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("3.14")?;
-/// let output: f64 = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "3.14")?;
+/// let output: f64 = deserialize(&ruby, input)?;
 /// assert_eq!(3.14, output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -88,10 +88,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!(r#""Hello, world!""#)?;
-/// let output: String = deserialize(input)?;
+/// let input: Value = eval!(&ruby, r#""Hello, world!""#)?;
+/// let output: String = deserialize(&ruby, input)?;
 /// assert_eq!("Hello, world!", output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -103,14 +103,14 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("nil")?;
-/// let output: Option<i64> = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "nil")?;
+/// let output: Option<i64> = deserialize(&ruby, input)?;
 /// assert_eq!(None, output);
 ///
-/// let input: Value = eval!("1234")?;
-/// let output: Option<i64> = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "1234")?;
+/// let output: Option<i64> = deserialize(&ruby, input)?;
 /// assert_eq!(Some(1234), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -122,14 +122,14 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("{ 'Ok' => 1234 }")?;
-/// let output: Result<i64, String> = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "{ 'Ok' => 1234 }")?;
+/// let output: Result<i64, String> = deserialize(&ruby, input)?;
 /// assert_eq!(Ok(1234), output);
 ///
-/// let input: Value = eval!("{ 'Err' => 'something went wrong' }")?;
-/// let output: Result<i64, String> = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "{ 'Err' => 'something went wrong' }")?;
+/// let output: Result<i64, String> = deserialize(&ruby, input)?;
 /// assert_eq!(Err("something went wrong".into()), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -143,15 +143,15 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use serde::Deserialize;
 ///
 /// #[derive(PartialEq, Debug, Deserialize)]
 /// struct Foo;
 ///
-/// let input: Value = eval!("nil")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "nil")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(Foo, output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -163,15 +163,15 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use serde::Deserialize;
 ///
 /// #[derive(PartialEq, Debug, Deserialize)]
 /// struct Foo(u16);
 ///
-/// let input: Value = eval!("1234")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "1234")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(Foo(1234), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -183,15 +183,15 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use serde::Deserialize;
 ///
 /// #[derive(PartialEq, Debug, Deserialize)]
 /// struct Foo(u16, bool, String);
 ///
-/// let input: Value = eval!("[123, true, 'Hello, world!']")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "[123, true, 'Hello, world!']")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(Foo(123, true, "Hello, world!".into()), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -204,7 +204,7 @@ use serde::Deserialize;
 /// # use serde::Deserialize;
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// #[derive(PartialEq, Debug, Deserialize)]
 /// struct Foo {
@@ -213,8 +213,8 @@ use serde::Deserialize;
 ///     glorp: String
 /// }
 ///
-/// let input: Value = eval!("{ bar: 1234, baz: true, glorp: 'Hello, world!' }")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "{ bar: 1234, baz: true, glorp: 'Hello, world!' }")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(
 ///     Foo { bar: 1234, baz: true, glorp: "Hello, world!".into() },
 ///     output
@@ -247,13 +247,13 @@ use serde::Deserialize;
 /// # use serde::Deserialize;
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(PartialEq, Debug, Deserialize)]
 /// # enum Foo { Bar }
 /// #
-/// let input: Value = eval!("'Bar'")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "'Bar'")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(Foo::Bar, output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -266,13 +266,13 @@ use serde::Deserialize;
 /// # use serde::Deserialize;
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(PartialEq, Debug, Deserialize)]
 /// # enum Foo { Baz(u16) }
 /// #
-/// let input: Value = eval!("{ 'Baz' => 1234 }")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "{ 'Baz' => 1234 }")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(Foo::Baz(1234), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -285,13 +285,13 @@ use serde::Deserialize;
 /// # use serde::Deserialize;
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(PartialEq, Debug, Deserialize)]
 /// # enum Foo { Glorp(u16, bool, String) }
 /// #
-/// let input: Value = eval!("{ 'Glorp' => [123, true, 'Hello, world!'] }")?;
-/// let output: Foo = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "{ 'Glorp' => [123, true, 'Hello, world!'] }")?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(Foo::Glorp(123, true, "Hello, world!".into()), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -304,7 +304,7 @@ use serde::Deserialize;
 /// # use serde::Deserialize;
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// # #[derive(PartialEq, Debug, Deserialize)]
 /// # enum Foo {
@@ -315,7 +315,7 @@ use serde::Deserialize;
 /// #     }
 /// # }
 /// #
-/// let input: Value = eval!(r#"
+/// let input: Value = eval!(&ruby, r#"
 ///     {
 ///       "Quux" => {
 ///         frob: 1234,
@@ -324,7 +324,7 @@ use serde::Deserialize;
 ///       }
 ///     }
 /// "#)?;
-/// let output: Foo = deserialize(input)?;
+/// let output: Foo = deserialize(&ruby, input)?;
 /// assert_eq!(
 ///     Foo::Quux { frob: 1234, wally: true, plugh: "Hello, world!".into() },
 ///     output
@@ -341,10 +341,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("[123, true, 'Hello, world!']")?;
-/// let output: (i16, bool, String) = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "[123, true, 'Hello, world!']")?;
+/// let output: (i16, bool, String) = deserialize(&ruby, input)?;
 /// assert_eq!((123, true, "Hello, world!".into()), output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -356,10 +356,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("[123, 456, 789]")?;
-/// let output: [i64; 3] = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "[123, 456, 789]")?;
+/// let output: [i64; 3] = deserialize(&ruby, input)?;
 /// assert_eq!([123, 456, 789], output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -373,10 +373,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("[123, 456, 789]")?;
-/// let output: Vec<u64> = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "[123, 456, 789]")?;
+/// let output: Vec<u64> = deserialize(&ruby, input)?;
 /// assert_eq!(vec![123, 456, 789], output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -388,11 +388,11 @@ use serde::Deserialize;
 /// # use magnus::{eval, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use std::collections::HashMap;
 ///
-/// let input: Value = eval!(r#"
+/// let input: Value = eval!(&ruby, r#"
 ///     {
 ///       "yes" => "no",
 ///       "stop" => "go",
@@ -400,7 +400,7 @@ use serde::Deserialize;
 ///       "goodbye" => "hello"
 ///     }
 /// "#)?;
-/// let output: HashMap<String, String> = deserialize(input)?;
+/// let output: HashMap<String, String> = deserialize(&ruby, input)?;
 /// assert_eq!(4, output.len());
 /// assert_eq!(Some(&String::from("no")), output.get("yes"));
 /// #
@@ -424,10 +424,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Error, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("'Hello, world!'")?;
-/// let output: Result<&str, Error> = deserialize(input);
+/// let input: Value = eval!(&ruby, "'Hello, world!'")?;
+/// let output: Result<&str, Error> = deserialize(&ruby, input);
 /// assert!(output.is_err());
 /// assert_eq!(
 ///    r#"TypeError: invalid type: expected a borrowed string, got string "Hello, world!""#,
@@ -443,10 +443,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Error, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("'Hello, world!'")?;
-/// let output: String = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "'Hello, world!'")?;
+/// let output: String = deserialize(&ruby, input)?;
 /// assert_eq!("Hello, world!", output);
 /// #
 /// # Ok::<(), magnus::Error>(())
@@ -460,10 +460,10 @@ use serde::Deserialize;
 /// # use magnus::{eval, Error, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
-/// let input: Value = eval!("'☃'")?;
-/// let output: Result<&[u8], Error> = deserialize(input);
+/// let input: Value = eval!(&ruby, "'☃'")?;
+/// let output: Result<&[u8], Error> = deserialize(&ruby, input);
 /// assert!(output.is_err());
 /// assert_eq!(
 ///     "TypeError: can't deserialize into byte slice",
@@ -479,20 +479,20 @@ use serde::Deserialize;
 /// # use magnus::{eval, Error, Value};
 /// # use serde_magnus::deserialize;
 /// #
-/// # let _cleanup = unsafe { magnus::embed::init() };
+/// # let ruby = unsafe { magnus::embed::init() };
 /// #
 /// use serde_bytes::ByteBuf;
 ///
-/// let input: Value = eval!("'☃'")?;
-/// let output: ByteBuf = deserialize(input)?;
+/// let input: Value = eval!(&ruby, "'☃'")?;
+/// let output: ByteBuf = deserialize(&ruby, input)?;
 /// assert_eq!(vec![226, 152, 131], output.into_vec());
 /// #
 /// # Ok::<(), magnus::Error>(())
 /// ```
-pub fn deserialize<'i, Input, Output>(input: Input) -> Result<Output, Error>
+pub fn deserialize<'i, Input, Output>(ruby: &Ruby, input: Input) -> Result<Output, Error>
 where
     Input: IntoValue,
     Output: Deserialize<'i>,
 {
-    Output::deserialize(Deserializer::new(input.into_value())).map_err(Into::into)
+    Output::deserialize(Deserializer::new(ruby, input.into_value_with(ruby))).map_err(Into::into)
 }

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/src/de/variant_deserializer.rs

@@ -1,19 +1,20 @@
 use super::{ArrayDeserializer, Deserializer, HashDeserializer};
 use crate::error::Error;
-use magnus::{value::ReprValue, RArray, RHash, Value};
+use magnus::{value::ReprValue, RArray, RHash, Ruby, Value};
 use serde::de::{DeserializeSeed, Unexpected, VariantAccess};
 
-pub struct VariantDeserializer {
+pub struct VariantDeserializer<'r> {
+    ruby: &'r Ruby,
     value: Value,
 }
 
-impl VariantDeserializer {
-    pub fn new(value: Value) -> VariantDeserializer {
-        VariantDeserializer { value }
+impl<'r> VariantDeserializer<'r> {
+    pub fn new(ruby: &'r Ruby, value: Value) -> VariantDeserializer<'r> {
+        VariantDeserializer { ruby, value }
     }
 }
 
-impl<'i> VariantAccess<'i> for VariantDeserializer {
+impl<'r, 'i> VariantAccess<'i> for VariantDeserializer<'r> {
     type Error = Error;
 
     fn unit_variant(self) -> Result<(), Self::Error> {
@@ -32,7 +33,7 @@ impl<'i> VariantAccess<'i> for VariantDeserializer {
     where
         Seed: DeserializeSeed<'i>,
     {
-        seed.deserialize(Deserializer::new(self.value))
+        seed.deserialize(Deserializer::new(self.ruby, self.value))
     }
 
     fn tuple_variant<Visitor>(
@@ -44,7 +45,7 @@ impl<'i> VariantAccess<'i> for VariantDeserializer {
         Visitor: serde::de::Visitor<'i>,
     {
         if let Some(array) = RArray::from_value(self.value) {
-            visitor.visit_seq(&mut ArrayDeserializer::new(array))
+            visitor.visit_seq(&mut ArrayDeserializer::new(self.ruby, array))
         } else {
             Err(serde::de::Error::invalid_type(
                 #[allow(clippy::unnecessary_to_owned)]
@@ -63,7 +64,7 @@ impl<'i> VariantAccess<'i> for VariantDeserializer {
         Visitor: serde::de::Visitor<'i>,
     {
         if let Some(hash) = RHash::from_value(self.value) {
-            visitor.visit_map(&mut HashDeserializer::new(hash)?)
+            visitor.visit_map(&mut HashDeserializer::new(self.ruby, hash)?)
         } else {
             Err(serde::de::Error::invalid_type(
                 #[allow(clippy::unnecessary_to_owned)]

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

@@ -1,4 +1,4 @@
-use magnus::{exception, ExceptionClass};
+use magnus::{ExceptionClass, Ruby};
 use std::{borrow::Cow, fmt};
 
 #[derive(Debug)]
@@ -30,7 +30,10 @@ impl serde::ser::Error for Error {
     where
         Message: fmt::Display,
     {
-        Error::new(exception::runtime_error(), message.to_string())
+        Error::new(
+            Ruby::get().unwrap().exception_runtime_error(),
+            message.to_string(),
+        )
     }
 }
 
@@ -39,12 +42,15 @@ impl serde::de::Error for Error {
     where
         Message: fmt::Display,
     {
-        Error::new(exception::runtime_error(), message.to_string())
+        Error::new(
+            Ruby::get().unwrap().exception_runtime_error(),
+            message.to_string(),
+        )
     }
 
     fn invalid_type(unexpected: serde::de::Unexpected, expected: &dyn serde::de::Expected) -> Self {
         Error::new(
-            exception::type_error(),
+            Ruby::get().unwrap().exception_type_error(),
             format!("invalid type: expected {}, got {}", expected, unexpected),
         )
     }

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

@@ -9,7 +9,7 @@
 //! trait into a Ruby equivalent.
 //!
 //! ```
-//! # let _cleanup = unsafe { magnus::embed::init() };
+//! # let ruby = unsafe { magnus::embed::init() };
 //! #
 //! use serde::{Serialize, Deserialize};
 //! use magnus::{eval, Value};
@@ -42,9 +42,10 @@
 //!     ]
 //! };
 //!
-//! let post: Value = serialize(&post)?;
+//! let post: Value = serialize(&ruby, &post)?;
 //!
 //! assert!(eval!(
+//!     &ruby,
 //!     r#"
 //!     post == {
 //!       title: "Spring carnival planning update",
@@ -68,7 +69,7 @@
 //! # use serde::Deserialize;
 //! # use magnus::{eval, RHash};
 //! #
-//! # let _cleanup = unsafe { magnus::embed::init() };
+//! # let ruby = unsafe { magnus::embed::init() };
 //! #
 //! # #[derive(Deserialize, PartialEq, Debug)]
 //! # struct Post {
@@ -86,7 +87,7 @@
 //! #
 //! use serde_magnus::deserialize;
 //!
-//! let post: RHash = eval!(r#"
+//! let post: RHash = eval!(&ruby, r#"
 //!   {
 //!     title: "Spring carnival planning update",
 //!     content: "Here's what's new.",
@@ -98,7 +99,7 @@
 //!   }
 //! "#)?;
 //!
-//! let post: Post = deserialize(post)?;
+//! let post: Post = deserialize(&ruby, post)?;
 //!
 //! assert_eq!(
 //!     Post {

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

@@ -0,0 +1,11 @@
+use crate::error::Error;
+use magnus::{IntoValue, Ruby, Value};
+
+pub fn nest<Data>(ruby: &Ruby, variant: &'static str, data: Data) -> Result<Value, Error>
+where
+    Data: IntoValue,
+{
+    let hash = ruby.hash_new();
+    hash.aset(variant, data)?;
+    Ok(hash.into_value_with(ruby))
+}