code_ownership 2.1.0 → 2.1.1

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

@@ -1,36 +0,0 @@
-use super::Serializer;
-use crate::error::Error;
-use magnus::{IntoValue, RHash, Symbol, Value};
-use serde::{ser::SerializeStruct, Serialize};
-
-pub struct StructSerializer {
-    hash: RHash,
-}
-
-impl StructSerializer {
-    pub fn new(hash: RHash) -> StructSerializer {
-        StructSerializer { hash }
-    }
-}
-
-impl SerializeStruct for StructSerializer {
-    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(Symbol::new(name), value.serialize(Serializer)?)
-            .map_err(Into::into)
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.hash.into_value())
-    }
-}

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

@@ -1,37 +0,0 @@
-use super::{enums::nest, Serializer};
-use crate::error::Error;
-use magnus::{RHash, Symbol, Value};
-use serde::{ser::SerializeStructVariant, Serialize};
-
-pub struct StructVariantSerializer {
-    variant: &'static str,
-    hash: RHash,
-}
-
-impl StructVariantSerializer {
-    pub fn new(variant: &'static str, hash: RHash) -> StructVariantSerializer {
-        StructVariantSerializer { variant, hash }
-    }
-}
-
-impl SerializeStructVariant for StructVariantSerializer {
-    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(Symbol::new(name), value.serialize(Serializer)?)
-            .map_err(Into::into)
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        nest(self.variant, self.hash)
-    }
-}

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

@@ -1,33 +0,0 @@
-use super::{enums::nest, Serializer};
-use crate::error::Error;
-use magnus::{RArray, Value};
-use serde::{ser::SerializeTupleVariant, Serialize};
-
-pub struct TupleVariantSerializer {
-    variant: &'static str,
-    array: RArray,
-}
-
-impl TupleVariantSerializer {
-    pub fn new(variant: &'static str, array: RArray) -> TupleVariantSerializer {
-        TupleVariantSerializer { variant, array }
-    }
-}
-
-impl SerializeTupleVariant for TupleVariantSerializer {
-    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)?)
-            .map_err(Into::into)
-    }
-
-    fn end(self) -> Result<Self::Ok, self::Error> {
-        nest(self.variant, self.array)
-    }
-}

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

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

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

@@ -1,39 +0,0 @@
-use magnus::{eval, Error, RHash, RString};
-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 _cleanup = unsafe { magnus::embed::init() };
-
-    let input = RString::new("A");
-    let output: A = deserialize(input)?;
-    assert_eq!(A::A, output);
-
-    let input: RHash = eval!("{ 'B' => 123 }")?;
-    let output: A = deserialize(input)?;
-    assert_eq!(A::B(123), output);
-
-    let input: RHash = eval!("{ 'C' => [1234, true, 'Hello, world!'] }")?;
-    let output: A = deserialize(input).unwrap();
-    assert_eq!(A::C(1234, true, "Hello, world!".into()), output);
-
-    let input: RHash = eval!("{ 'D' => { message: 'Hello, world!' } }")?;
-    let output: A = deserialize(input)?;
-    assert_eq!(
-        A::D {
-            message: "Hello, world!".into()
-        },
-        output
-    );
-
-    Ok(())
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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