code_ownership 2.1.0 → 2.1.1

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

@@ -0,0 +1,45 @@
+use super::{enums::nest, Serializer};
+use crate::error::Error;
+use magnus::{RHash, Ruby, Value};
+use serde::{ser::SerializeStructVariant, Serialize};
+
+pub struct StructVariantSerializer<'r> {
+    ruby: &'r Ruby,
+    variant: &'static str,
+    hash: RHash,
+}
+
+impl<'r> StructVariantSerializer<'r> {
+    pub fn new(ruby: &'r Ruby, variant: &'static str, hash: RHash) -> StructVariantSerializer<'r> {
+        StructVariantSerializer {
+            ruby,
+            variant,
+            hash,
+        }
+    }
+}
+
+impl<'r> SerializeStructVariant for StructVariantSerializer<'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> {
+        nest(self.ruby, self.variant, self.hash)
+    }
+}

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

@@ -0,0 +1,38 @@
+use super::{enums::nest, Serializer};
+use crate::error::Error;
+use magnus::{RArray, Ruby, Value};
+use serde::{ser::SerializeTupleVariant, Serialize};
+
+pub struct TupleVariantSerializer<'r> {
+    ruby: &'r Ruby,
+    variant: &'static str,
+    array: RArray,
+}
+
+impl<'r> TupleVariantSerializer<'r> {
+    pub fn new(ruby: &'r Ruby, variant: &'static str, array: RArray) -> TupleVariantSerializer<'r> {
+        TupleVariantSerializer {
+            ruby,
+            variant,
+            array,
+        }
+    }
+}
+
+impl<'r> SerializeTupleVariant for TupleVariantSerializer<'r> {
+    type Ok = Value;
+    type Error = Error;
+
+    fn serialize_field<Field>(&mut self, field: &Field) -> Result<(), Self::Error>
+    where
+        Field: Serialize + ?Sized,
+    {
+        self.array
+            .push(field.serialize(Serializer::new(self.ruby))?)
+            .map_err(Into::into)
+    }
+
+    fn end(self) -> Result<Self::Ok, self::Error> {
+        nest(self.ruby, self.variant, self.array)
+    }
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/deserializing_arrays.rs

@@ -3,10 +3,10 @@ use serde_magnus::deserialize;
 
 #[test]
 fn test_deserializing_arrays() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let input: RArray = eval!("[1, 2, 3]")?;
-    let output: [i64; 3] = deserialize(input)?;
+    let input: RArray = eval!(&ruby, "[1, 2, 3]")?;
+    let output: [i64; 3] = deserialize(&ruby, input)?;
     assert_eq!([1, 2, 3], output);
 
     Ok(())

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_booleans.rs

@@ -0,0 +1,15 @@
+use magnus::{value::ReprValue, Error};
+use serde_magnus::deserialize;
+
+#[test]
+fn test_deserializing_booleans() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let output: bool = deserialize(&ruby, ruby.qtrue().as_value())?;
+    assert_eq!(true, output);
+
+    let output: bool = deserialize(&ruby, ruby.qfalse().as_value())?;
+    assert_eq!(false, output);
+
+    Ok(())
+}

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_enums.rs

@@ -0,0 +1,39 @@
+use magnus::{eval, Error, RHash};
+use serde::Deserialize;
+use serde_magnus::deserialize;
+
+#[derive(Deserialize, PartialEq, Debug)]
+enum A {
+    A,
+    B(u64),
+    C(u64, bool, String),
+    D { message: String },
+}
+
+#[test]
+fn test_deserializing_enums() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let input = ruby.str_new("A");
+    let output: A = deserialize(&ruby, input)?;
+    assert_eq!(A::A, output);
+
+    let input: RHash = eval!(&ruby, "{ 'B' => 123 }")?;
+    let output: A = deserialize(&ruby, input)?;
+    assert_eq!(A::B(123), output);
+
+    let input: RHash = eval!(&ruby, "{ 'C' => [1234, true, 'Hello, world!'] }")?;
+    let output: A = deserialize(&ruby, input).unwrap();
+    assert_eq!(A::C(1234, true, "Hello, world!".into()), output);
+
+    let input: RHash = eval!(&ruby, "{ 'D' => { message: 'Hello, world!' } }")?;
+    let output: A = deserialize(&ruby, input)?;
+    assert_eq!(
+        A::D {
+            message: "Hello, world!".into()
+        },
+        output
+    );
+
+    Ok(())
+}

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_floats.rs

@@ -0,0 +1,12 @@
+use magnus::Error;
+use serde_magnus::deserialize;
+
+#[test]
+fn test_deserializing_floats() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let output: f64 = deserialize(&ruby, ruby.float_from_f64(1.23))?;
+    assert_eq!(1.23, output);
+
+    Ok(())
+}

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_integers.rs

@@ -0,0 +1,18 @@
+use magnus::Error;
+use serde_magnus::deserialize;
+
+#[test]
+fn test_deserializing_integers() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let output: i64 = deserialize(&ruby, ruby.integer_from_i64(123))?;
+    assert_eq!(123, output);
+
+    let output: i64 = deserialize(&ruby, ruby.integer_from_i64(-123))?;
+    assert_eq!(-123, output);
+
+    let output: u64 = deserialize(&ruby, ruby.integer_from_u64(123))?;
+    assert_eq!(123, output);
+
+    Ok(())
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/deserializing_maps.rs

@@ -4,9 +4,10 @@ use std::collections::HashMap;
 
 #[test]
 fn test_deserializing_maps() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
     let input: RHash = eval!(
+        &ruby,
         r#"
         {
           "Yes" => "No",
@@ -16,7 +17,7 @@ fn test_deserializing_maps() -> Result<(), Error> {
     "#
     )?;
 
-    let output: HashMap<String, String> = deserialize(input)?;
+    let output: HashMap<String, String> = deserialize(&ruby, input)?;
     assert_eq!(3, output.len());
     assert_eq!(Some(&"No".into()), output.get("Yes"));
     assert_eq!(Some(&"Go".into()), output.get("Stop"));

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_options.rs

@@ -0,0 +1,15 @@
+use magnus::{Error, IntoValue};
+use serde_magnus::deserialize;
+
+#[test]
+fn test_deserializing_options() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let output: Option<u64> = deserialize(&ruby, ruby.qnil().into_value_with(&ruby))?;
+    assert_eq!(None, output);
+
+    let output: Option<u64> = deserialize(&ruby, ruby.integer_from_u64(123))?;
+    assert_eq!(Some(123), output);
+
+    Ok(())
+}

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_results.rs

@@ -0,0 +1,17 @@
+use magnus::{eval, Error, RHash};
+use serde_magnus::deserialize;
+
+#[test]
+fn test_deserializing_results() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let input: RHash = eval!(&ruby, "{ 'Ok' => 1234 }")?;
+    let output: Result<u64, String> = deserialize(&ruby, input)?;
+    assert_eq!(Ok(1234), output);
+
+    let input: RHash = eval!(&ruby, "{ 'Err' => 'something went wrong' }")?;
+    let output: Result<u64, String> = deserialize(&ruby, input)?;
+    assert_eq!(Err("something went wrong".into()), output);
+
+    Ok(())
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/deserializing_strings.rs

@@ -1,30 +1,30 @@
-use magnus::{Error, RString};
+use magnus::Error;
 use serde_bytes::{ByteBuf, Bytes};
 use serde_magnus::deserialize;
 
 #[test]
 fn test_deserializing_strings() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let output: char = deserialize(RString::new("☃"))?;
+    let output: char = deserialize(&ruby, ruby.str_new("☃"))?;
     assert_eq!('☃', output);
 
-    let output: Result<&str, Error> = deserialize(RString::new("Hello, world!"));
+    let output: Result<&str, Error> = deserialize(&ruby, ruby.str_new("Hello, world!"));
     assert_eq!(
         r#"TypeError: invalid type: expected a borrowed string, got string "Hello, world!""#,
         output.unwrap_err().to_string()
     );
 
-    let output: String = deserialize(RString::new("Hello, world!"))?;
+    let output: String = deserialize(&ruby, ruby.str_new("Hello, world!"))?;
     assert_eq!("Hello, world!", output);
 
-    let output: Result<&Bytes, Error> = deserialize(RString::new("Hello, world!"));
+    let output: Result<&Bytes, Error> = deserialize(&ruby, ruby.str_new("Hello, world!"));
     assert_eq!(
         "TypeError: can't deserialize into byte slice",
         output.unwrap_err().to_string()
     );
 
-    let output: ByteBuf = deserialize(RString::new("Hello, world!"))?;
+    let output: ByteBuf = deserialize(&ruby, ruby.str_new("Hello, world!"))?;
     assert_eq!(b"Hello, world!", output.as_slice());
 
     Ok(())

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/deserializing_structs.rs

@@ -1,4 +1,4 @@
-use magnus::{eval, value::qnil, Error, Integer, IntoValue, RArray, RHash};
+use magnus::{eval, Error, IntoValue, RArray, RHash};
 use serde::Deserialize;
 use serde_magnus::deserialize;
 
@@ -18,20 +18,20 @@ struct D {
 
 #[test]
 fn test_deserializing_structs() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    assert_eq!(A, deserialize(qnil().into_value())?);
+    assert_eq!(A, deserialize(&ruby, ruby.qnil().into_value_with(&ruby))?);
 
-    let input = Integer::from_u64(123);
-    let output: B = deserialize(input)?;
+    let input = ruby.integer_from_u64(123);
+    let output: B = deserialize(&ruby, input)?;
     assert_eq!(B(123), output);
 
-    let input: RArray = eval!("[ 123, true, 'Hello, world!' ]")?;
-    let output: C = deserialize(input)?;
+    let input: RArray = eval!(&ruby, "[ 123, true, 'Hello, world!' ]")?;
+    let output: C = deserialize(&ruby, input)?;
     assert_eq!(C(123, true, "Hello, world!".into()), output);
 
-    let input: RHash = eval!("{ message: 'Hello, world!' }")?;
-    let output: D = deserialize(input)?;
+    let input: RHash = eval!(&ruby, "{ message: 'Hello, world!' }")?;
+    let output: D = deserialize(&ruby, input)?;
     assert_eq!(
         D {
             message: "Hello, world!".into()

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/deserializing_tuples.rs

@@ -0,0 +1,27 @@
+use magnus::{eval, value::ReprValue, Error, RArray};
+use serde_magnus::deserialize;
+
+#[test]
+fn test_deserializing_tuples() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    // From nil
+    assert_eq!((), deserialize(&ruby, ruby.qnil().as_value())?);
+
+    // From a homogeneous array
+    let input: RArray = eval!(&ruby, "[ 123, 456, 789 ]")?;
+    let output: (i64, i64, i64) = deserialize(&ruby, input)?;
+    assert_eq!((123, 456, 789), output);
+
+    // From a heterogeneous array
+    let input: RArray = eval!(&ruby, "[ 123, true, 'Hello, world!' ]")?;
+    let output: (i64, bool, String) = deserialize(&ruby, input)?;
+    assert_eq!((123, true, "Hello, world!".into()), output);
+
+    // From an array containing nil
+    let input: RArray = eval!(&ruby, "[ 123, nil, 'Hello, world!' ]")?;
+    let output: (i64, (), String) = deserialize(&ruby, input)?;
+    assert_eq!((123, (), "Hello, world!".into()), output);
+
+    Ok(())
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/deserializing_vecs.rs

@@ -3,10 +3,10 @@ use serde_magnus::deserialize;
 
 #[test]
 fn test_deserializing_vecs() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let input: RArray = eval!("[ 1, 2, 3 ]")?;
-    let output: Vec<i64> = deserialize(input)?;
+    let input: RArray = eval!(&ruby, "[ 1, 2, 3 ]")?;
+    let output: Vec<i64> = deserialize(&ruby, input)?;
     assert_eq!(&[1, 2, 3], &output[..]);
 
     Ok(())

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_arrays.rs

@@ -3,11 +3,11 @@ use serde_magnus::serialize;
 
 #[test]
 fn test_serializing_arrays() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
     let input: [u64; 3] = [1, 2, 3];
-    let output: RArray = serialize(&input)?;
-    assert!(eval!("output == [ 1, 2, 3 ]", output)?);
+    let output: RArray = serialize(&ruby, &input)?;
+    assert!(eval!(&ruby, "output == [ 1, 2, 3 ]", output)?);
 
     Ok(())
 }

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/serializing_booleans.rs

@@ -0,0 +1,15 @@
+use magnus::{eval, Error, Value};
+use serde_magnus::serialize;
+
+#[test]
+fn test_serializing_booleans() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let output: Value = serialize(&ruby, &true)?;
+    assert!(eval!(&ruby, "output == true", output)?);
+
+    let output: Value = serialize(&ruby, &false)?;
+    assert!(eval!(&ruby, "output == false", output)?);
+
+    Ok(())
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_enums.rs

@@ -12,18 +12,19 @@ enum A {
 
 #[test]
 fn test_serializing_enums() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let output: RString = serialize(&A::A)?;
-    assert!(eval!("output == 'A'", output)?);
+    let output: RString = serialize(&ruby, &A::A)?;
+    assert!(eval!(&ruby, "output == 'A'", output)?);
 
     let input = A::B(123);
-    let output: RHash = serialize(&input)?;
-    assert!(eval!("output == { 'B' => 123 }", output)?);
+    let output: RHash = serialize(&ruby, &input)?;
+    assert!(eval!(&ruby, "output == { 'B' => 123 }", output)?);
 
     let input = A::C(123, true, "Hello, world!".into());
-    let output: RHash = serialize(&input)?;
+    let output: RHash = serialize(&ruby, &input)?;
     assert!(eval!(
+        &ruby,
         "output == { 'C' => [ 123, true, 'Hello, world!' ] }",
         output
     )?);
@@ -31,8 +32,9 @@ fn test_serializing_enums() -> Result<(), Error> {
     let input = A::D {
         message: "Hello, world!".into(),
     };
-    let output: RHash = serialize(&input)?;
+    let output: RHash = serialize(&ruby, &input)?;
     assert!(eval!(
+        &ruby,
         "output == { 'D' => { message: 'Hello, world!' } }",
         output
     )?);

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_floats.rs

@@ -3,9 +3,9 @@ use serde_magnus::serialize;
 
 #[test]
 fn test_serializing_floats() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let float: Float = serialize(&1.23)?;
+    let float: Float = serialize(&ruby, &1.23)?;
     assert_eq!(1.23, float.to_f64());
 
     Ok(())

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_integers.rs

@@ -3,15 +3,15 @@ use serde_magnus::serialize;
 
 #[test]
 fn test_serializing_integers() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let output: Integer = serialize(&123i64)?;
+    let output: Integer = serialize(&ruby, &123i64)?;
     assert_eq!(123, output.to_i64()?);
 
-    let output: Integer = serialize(&-123i64)?;
+    let output: Integer = serialize(&ruby, &-123i64)?;
     assert_eq!(-123, output.to_i64()?);
 
-    let output: Integer = serialize(&123u64)?;
+    let output: Integer = serialize(&ruby, &123u64)?;
     assert_eq!(123, output.to_u64()?);
 
     Ok(())

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_maps.rs

@@ -4,16 +4,17 @@ use std::collections::HashMap;
 
 #[test]
 fn test_serializing_maps() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
     let mut input: HashMap<&str, &str> = HashMap::new();
     input.insert("Yes", "No");
     input.insert("Stop", "Go");
     input.insert("High", "Low");
 
-    let output: RHash = serialize(&input)?;
+    let output: RHash = serialize(&ruby, &input)?;
 
     assert!(eval!(
+        &ruby,
         r#"
             output == {
               "Yes" => "No",

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_options.rs

@@ -3,14 +3,14 @@ use serde_magnus::serialize;
 
 #[test]
 fn test_serializing_options() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
     let input: Option<u64> = None;
-    let output: Value = serialize(&input)?;
+    let output: Value = serialize(&ruby, &input)?;
     assert!(output.is_nil());
 
     let input = Some(123);
-    let output: Integer = serialize(&input)?;
+    let output: Integer = serialize(&ruby, &input)?;
     assert_eq!(123, output.to_u64()?);
 
     Ok(())

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_results.rs

@@ -3,15 +3,16 @@ use serde_magnus::serialize;
 
 #[test]
 fn test_serializing_results() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
     let input: Result<u64, &str> = Ok(1234);
-    let output: RHash = serialize(&input)?;
-    assert!(eval!("output == { 'Ok' => 1234 }", output)?);
+    let output: RHash = serialize(&ruby, &input)?;
+    assert!(eval!(&ruby, "output == { 'Ok' => 1234 }", output)?);
 
     let input: Result<u64, &str> = Err("something went wrong");
-    let output: RHash = serialize(&input)?;
+    let output: RHash = serialize(&ruby, &input)?;
     assert!(eval!(
+        &ruby,
         "output == { 'Err' => 'something went wrong' }",
         output
     )?);

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/serializing_strings.rs

@@ -0,0 +1,30 @@
+use magnus::{encoding::EncodingCapable, Error, RString};
+use serde_bytes::{ByteBuf, Bytes};
+use serde_magnus::serialize;
+
+#[test]
+fn test_serializing_strings() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let output: RString = serialize(&ruby, &'☃')?;
+    assert_eq!("☃", output.to_string()?);
+    assert!(output.enc_get() == ruby.utf8_encindex());
+
+    let output: RString = serialize(&ruby, &"Hello, world!")?;
+    assert_eq!("Hello, world!", output.to_string()?);
+    assert!(output.enc_get() == ruby.utf8_encindex());
+
+    let output: RString = serialize(&ruby, &String::from("Hello, world!"))?;
+    assert_eq!("Hello, world!", output.to_string()?);
+    assert!(output.enc_get() == ruby.utf8_encindex());
+
+    let output: RString = serialize(&ruby, &Bytes::new(b"Hello, world!"))?;
+    assert_eq!(b"Hello, world!", unsafe { output.as_slice() });
+    assert!(output.enc_get() == ruby.ascii8bit_encindex());
+
+    let output: RString = serialize(&ruby, &ByteBuf::from(*b"Hello, world!"))?;
+    assert_eq!(b"Hello, world!", unsafe { output.as_slice() });
+    assert!(output.enc_get() == ruby.ascii8bit_encindex());
+
+    Ok(())
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_structs.rs

@@ -18,24 +18,32 @@ struct D {
 
 #[test]
 fn test_serializing_structs() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
-    let output: Value = serialize(&A)?;
+    let output: Value = serialize(&ruby, &A)?;
     assert!(output.is_nil());
 
     let input = B(123);
-    let output: Integer = serialize(&input)?;
+    let output: Integer = serialize(&ruby, &input)?;
     assert_eq!(123, output.to_u64()?);
 
     let input = C(1234, true, "Hello, world!".into());
-    let output: RArray = serialize(&input)?;
-    assert!(eval!("output == [ 1234, true, 'Hello, world!' ]", output)?);
+    let output: RArray = serialize(&ruby, &input)?;
+    assert!(eval!(
+        &ruby,
+        "output == [ 1234, true, 'Hello, world!' ]",
+        output
+    )?);
 
     let input = D {
         message: "Hello, world!".into(),
     };
-    let output: RHash = serialize(&input)?;
-    assert!(eval!("output == { message: 'Hello, world!' }", output)?);
+    let output: RHash = serialize(&ruby, &input)?;
+    assert!(eval!(
+        &ruby,
+        "output == { message: 'Hello, world!' }",
+        output
+    )?);
 
     Ok(())
 }

data/ext/cargo-vendor/serde_magnus-0.10.0/tests/serializing_tuples.rs

@@ -0,0 +1,35 @@
+use magnus::{eval, value::ReprValue, Error, RArray, Value};
+use serde_magnus::serialize;
+
+#[test]
+fn test_serializing_tuples() -> Result<(), Error> {
+    let ruby = unsafe { magnus::embed::init() };
+
+    // To nil
+    let output: Value = serialize(&ruby, &())?;
+    assert!(output.is_nil());
+
+    // To a homogeneous array
+    let output: RArray = serialize(&ruby, &(1, 2, 3))?;
+    assert!(eval!(&ruby, "output == [ 1, 2, 3 ]", output)?);
+
+    // To a heterogeneous array
+    let input: (u64, bool, &str) = (1234, true, "Hello, world!");
+    let output: RArray = serialize(&ruby, &input)?;
+    assert!(eval!(
+        &ruby,
+        "output == [ 1234, true, 'Hello, world!' ]",
+        output
+    )?);
+
+    // To an array containing nil
+    let input: (u64, (), &str) = (1234, (), "Hello, world!");
+    let output: RArray = serialize(&ruby, &input)?;
+    assert!(eval!(
+        &ruby,
+        "output == [ 1234, nil, 'Hello, world!' ]",
+        output
+    )?);
+
+    Ok(())
+}

data/ext/cargo-vendor/{serde_magnus-0.9.0 → serde_magnus-0.10.0}/tests/serializing_vecs.rs

@@ -3,11 +3,11 @@ use serde_magnus::serialize;
 
 #[test]
 fn test_serializing_vecs() -> Result<(), Error> {
-    let _cleanup = unsafe { magnus::embed::init() };
+    let ruby = unsafe { magnus::embed::init() };
 
     let input: Vec<u64> = Vec::from([1, 2, 3]);
-    let output: RArray = serialize(&input)?;
-    assert!(eval!("output == [ 1, 2, 3 ]", output)?);
+    let output: RArray = serialize(&ruby, &input)?;
+    assert!(eval!(&ruby, "output == [ 1, 2, 3 ]", output)?);
 
     Ok(())
 }