code_ownership 2.1.0 → 2.1.1

data/ext/cargo-vendor/magnus-macros-0.8.0/src/lib.rs

@@ -0,0 +1,545 @@
+//! Derive and proc macros for magnus.
+//!
+//! ```
+//! #[magnus::wrap(class = "RbPoint", free_immediately, size)]
+//! struct Point {
+//!     x: isize,
+//!     y: isize,
+//! }
+//!
+//! #[magnus::init]
+//! fn init(ruby: &magnus::Ruby) -> Result<(), magnus::Error> {
+//!     ruby.define_class("RbPoint", ruby.class_object())?;
+//!     Ok(())
+//! }
+//! ```
+
+#![warn(missing_docs)]
+
+use proc_macro::TokenStream;
+use syn::parse_macro_input;
+
+mod init;
+mod typed_data;
+mod util;
+
+/// Mark a function as the 'init' function to be run for a library when it is
+/// `require`d by Ruby code.
+///
+/// The init function is used to define your Ruby modules & classes, bind
+/// functions as Ruby methods, etc.
+///
+/// # Attributes
+///
+/// * `name = "..."` - sets the name of the init function exported for Ruby.
+///   This default's to the current crate's name. The name will be prepended
+///   with `Init_` and `-` will be replaced with `_`. This (minus the `Init_`
+///   prefix) must match the name of the final `.so`/`.bundle` file.
+///
+/// # Examples
+///
+/// ```
+/// fn distance(a: (f64, f64), b: (f64, f64)) -> f64 {
+///     ((b.0 - a.0).powi(2) + (b.1 - a.1).powi(2)).sqrt()
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &magnus::Ruby) {
+///     ruby.define_global_function("distance", magnus::function!(distance, 2));
+/// }
+/// ```
+/// The init function can also return `Result<(), magnus::Error>`.
+/// ```
+/// use magnus::{function, method, prelude::*, Error, Ruby};
+///
+/// #[magnus::wrap(class = "Euclid::Point", free_immediately, size)]
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// impl Point {
+///     fn new(x: isize, y: isize) -> Self {
+///         Self { x, y }
+///     }
+///
+///     fn x(&self) -> isize {
+///         self.x
+///     }
+///
+///     fn y(&self) -> isize {
+///         self.y
+///     }
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) -> Result<(), Error> {
+///     let module = ruby.define_module("Euclid")?;
+///     let class = module.define_class("Point", ruby.class_object())?;
+///     class.define_singleton_method("new", function!(Point::new, 2))?;
+///     class.define_method("x", method!(Point::x, 0))?;
+///     class.define_method("y", method!(Point::y, 0))?;
+///     Ok(())
+/// }
+/// ```
+/// Setting the name.
+/// ```
+/// #[magnus::init(name = "example")]
+/// fn init() {
+///     ()
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn init(attrs: TokenStream, item: TokenStream) -> TokenStream {
+    let mut name = None;
+    if !attrs.is_empty() {
+        let attr_parser = syn::meta::parser(|meta| {
+            if meta.path.is_ident("name") {
+                name = Some(meta.value()?.parse::<syn::LitStr>()?.value());
+                Ok(())
+            } else {
+                Err(meta.error("unsupported attribute"))
+            }
+        });
+        parse_macro_input!(attrs with attr_parser);
+    }
+    match init::expand(name, parse_macro_input!(item)) {
+        Ok(tokens) => tokens,
+        Err(e) => e.into_compile_error(),
+    }
+    .into()
+}
+
+/// Allows a Rust type to be passed to Ruby, where it is automatically wrapped
+/// as a Ruby object.
+///
+/// For more control over the wrapping behavior, see [`TypedData`].
+///
+/// # Attributes
+///
+/// The `#[wrap]` macro supports several attributes to configure its behavior:
+///
+/// * `class = "..."` (required):  
+///   Specifies the Ruby class associated with the Rust type. Supports module
+///   paths, such as `Foo::Bar::Baz`, to locate nested classes.
+///   
+/// * `name = "..."`:  
+///   Specifies a debug name for the type. This name must be unique and
+///   defaults to the class name if not explicitly provided.
+///
+/// * `free_immediately`:  
+///   Indicates that the Rust type should be dropped as soon as the Ruby object
+///   is garbage collected. This is only safe if the type's [`Drop`]
+///   implementation does not call Ruby, as calling Ruby during the garbage
+///   collection process is unsafe and can lead to undefined behavior.
+///
+/// * `size`:  
+///   Reports the [`std::mem::size_of_val`] of the type to Ruby, helping Ruby's
+///   garbage collector determine when to run.
+///
+/// * `unsafe_generics`:  
+///   Disables compile-time checks for types with generics, allowing their use
+///   with `#[wrap]`. This should only be used if you are confident that the
+///   derived implementation of [`TypedData`] is correct for your generic type.
+///
+/// # Variant Attributes
+///
+/// When wrapping enums, the `#[magnus(...)]` attribute can also be applied to
+/// individual variants to define specific behavior for them:
+///
+/// * `class = "..."`:  
+///   Specifies the Ruby class associated with a particular variant. This is
+///   useful for defining subclasses for the variants.
+///
+/// # Examples
+///
+/// Wrapping a struct:
+///
+/// ```
+/// use magnus::{function, prelude::*, wrap, Ruby};
+///
+/// #[wrap(class = "Point", free_immediately, size)]
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// fn point(x: isize, y: isize) -> Point {
+///     Point { x, y }
+/// }
+///
+/// fn distance(a: &Point, b: &Point) -> f64 {
+///     (((b.x - a.x).pow(2) + (b.y - a.y).pow(2)) as f64).sqrt()
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) {
+///     ruby.define_global_function("point", function!(point, 2));
+///     ruby.define_global_function("distance", function!(distance, 2));
+/// }
+/// ```
+///
+/// See [`examples/point.rs`] for the complete example.
+///
+/// [`examples/point.rs`]: https://github.com/matsadler/magnus/blob/main/examples/point.rs
+///
+/// Handling mutability:
+///
+/// ```
+/// use std::cell::RefCell;
+///
+/// use magnus::{prelude::*, wrap};
+///
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// #[wrap(class = "Point")]
+/// struct MutPoint(RefCell<Point>);
+///
+/// impl MutPoint {
+///     fn set_x(&self, i: isize) {
+///         self.0.borrow_mut().x = i;
+///     }
+/// }
+/// ```
+///
+/// See [`examples/mut_point.rs`] for the complete example.
+///
+/// [`examples/mut_point.rs`]: https://github.com/matsadler/magnus/blob/main/examples/mut_point.rs
+///
+/// Supporting subclassing:
+///
+/// ```
+/// use std::cell::RefCell;
+///
+/// use magnus::{function, method, prelude::*, wrap, Error, Ruby};
+///
+/// #[derive(Default)]
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// #[derive(Default)]
+/// #[wrap(class = "Point")]
+/// struct MutPoint(RefCell<Point>);
+///
+/// impl MutPoint {
+///     fn initialize(&self, x: isize, y: isize) {
+///         let mut this = self.0.borrow_mut();
+///         this.x = x;
+///         this.y = y;
+///     }
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) -> Result<(), Error> {
+///     let class = ruby.define_class("Point", ruby.class_object()).unwrap();
+///     class.define_alloc_func::<MutPoint>();
+///     class.define_method("initialize", method!(MutPoint::initialize, 2))?;
+///     Ok(())
+/// }
+/// ```
+///
+/// Error handling:
+///
+/// ```
+/// use std::cell::RefCell;
+///
+/// use magnus::{prelude::*, wrap, Error, Ruby};
+///
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// #[wrap(class = "Point")]
+/// struct MutPoint(RefCell<Point>);
+///
+/// impl MutPoint {
+///     fn add_x(ruby: &Ruby, rb_self: &Self, val: isize) -> Result<isize, Error> {
+///         if let Some(sum) = rb_self.0.borrow().x.checked_add(val) {
+///             rb_self.0.borrow_mut().x = sum;
+///             Ok(sum)
+///         } else {
+///             return Err(Error::new(
+///                 ruby.exception_range_error(),
+///                 "result out of range",
+///             ));
+///         }
+///     }
+/// }
+/// ```
+///
+/// Wrapping an enum with subclasses:
+///
+/// ```
+/// use std::f64::consts::PI;
+///
+/// use magnus::{function, method, prelude::*, wrap, Ruby};
+///
+/// #[wrap(class = "Shape")]
+/// enum Shape {
+///     #[magnus(class = "Circle")]
+///     Circle { r: f64 },
+///     #[magnus(class = "Rectangle")]
+///     Rectangle { x: f64, y: f64 },
+/// }
+///
+/// impl Shape {
+///     fn area(&self) -> f64 {
+///         match self {
+///             Shape::Circle { r } => PI * r * r,
+///             Shape::Rectangle { x, y } => x * y,
+///         }
+///     }
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
+///     let shape = ruby.define_class("Shape", ruby.class_object())?;
+///     shape.define_method("area", method!(Shape::area, 0))?;
+///
+///     let circle = ruby.define_class("Circle", shape)?;
+///     circle.define_singleton_method("new", function!(|r| Shape::Circle { r }, 1))?;
+///
+///     let rectangle = ruby.define_class("Rectangle", shape)?;
+///     rectangle.define_singleton_method("new", function!(|x, y| Shape::Rectangle { x, y }, 2))?;
+///
+///     Ok(())
+/// }
+/// ```
+///
+/// See [`examples/inheritance.rs`] for the complete example.
+///
+/// [`examples/inheritance.rs`]: https://github.com/matsadler/magnus/blob/main/examples/inheritance.rs
+#[proc_macro_attribute]
+pub fn wrap(attrs: TokenStream, item: TokenStream) -> TokenStream {
+    typed_data::expand(parse_macro_input!(attrs), parse_macro_input!(item)).into()
+}
+
+/// Derives `DataTypeFunctions` with default implementations, for simple uses
+/// of [`TypedData`].
+///
+/// For cases where no custom `DataTypeFunctions` are required a default
+/// implementation can be derived. The [`macro@wrap`] macro may be a simpler
+/// alternative in this use case.
+#[proc_macro_derive(DataTypeFunctions)]
+pub fn derive_data_type_functions(input: TokenStream) -> TokenStream {
+    typed_data::expand_derive_data_type_functions(parse_macro_input!(input)).into()
+}
+
+/// Derives `TypedData`, allowing a Rust type to be passed to Ruby and
+/// automatically wrapped as a Ruby object.
+///
+/// For simpler use cases, consider using [`macro@wrap`].
+///
+/// # Attributes
+///
+/// The `#[magnus(...)]` attribute supports the following values to configure
+/// its behavior:
+///
+/// * `class = "..."` (required):  
+///   Specifies the Ruby class associated with the Rust type. Supports module
+///   paths, such as `Foo::Bar::Baz`.
+///
+/// * `name = "..."`:  
+///   Specifies a debug name for the type. This name must be unique and
+///   defaults to the class name if not explicitly provided.
+///
+/// * `free_immediately`:  
+///   Indicates that the Rust type should be dropped as soon as the Ruby object
+///   is garbage collected. This is only safe if the type's [`Drop`] and
+///   `DataTypeFunctions::free` implementations do not call Ruby.
+///   If safe this should be enabled as this performs better and is more
+///   memory efficient.
+///
+/// * `mark`:  
+///   Enables Ruby to call the `DataTypeFunctions::mark` function.
+///
+/// * `size`:  
+///   Enables Ruby to call the `DataTypeFunctions::size` function.
+///
+/// * `compact`:  
+///   Enables Ruby to call the `DataTypeFunctions::compact` function.
+///
+/// * `wb_protected`:  
+///   Enable the 'write barrier protected' flag.
+///
+///   Types that contain Ruby values by default do not participate in
+///   generational GC (they are scanned every GC). This flag asserts all
+///   operations that write Ruby values to this type are protected with
+///   write barriers (see `typed_data::Writebarrier::writebarrier`) so this
+///   type can participate in generational GC.
+///
+///   The write barrier is hard to get right. Magnus recommends you do not use
+///   this flag.
+///
+/// * `frozen_shareable`:  
+///   Sets the `frozen_shareable` flag for objects that can be safely accessed
+///   concurrently from multiple threads when frozen. This allows objects to
+///   shared between Ractors.
+///
+/// * `unsafe_generics`:  
+///   Disables compile-time checks for types with generics, allowing their use
+///   with `#[magnus(...)]`. Use this only if you are confident the derived
+///   implementation is correct for your generic type.
+///
+/// # Field Attributes
+///
+/// The `#[magnus(...)]` attribute can be set on struct fields with the
+/// following values:
+///
+/// * `opaque_attr_reader`:  
+///   For a Ruby value wrapped in `Opaque`, creates an accessor method that
+///   returns the unwrapped Ruby value.
+///
+/// # Variant Attributes
+///
+/// The `#[magnus(...)]` attribute can be set on enum variants with the
+/// following values:
+///
+/// * `class = "..."`:  
+///   Specifies the Ruby class associated with the variant. Supports module
+///   paths, such as `Foo::Bar::Baz`.
+///
+/// # Examples
+///
+/// Wrapping a struct
+///
+/// ```
+/// use magnus::{function, prelude::*, DataTypeFunctions, Ruby, TypedData};
+///
+/// #[derive(DataTypeFunctions, TypedData)]
+/// #[magnus(class = "Point", size, free_immediately)]
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// // wraps `Point` struct in a Ruby `Point` object when returned to Ruby.
+/// fn point(x: isize, y: isize) -> Point {
+///     Point { x, y }
+/// }
+///
+/// // automatically unwraps `Point` objects to references to `Point`` structs
+/// // when invoking the function.
+/// fn distance(a: &Point, b: &Point) -> f64 {
+///     (((b.x - a.x).pow(2) + (b.y - a.y).pow(2)) as f64).sqrt()
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) {
+///     ruby.define_global_function("point", function!(point, 2));
+///     ruby.define_global_function("distance", function!(distance, 2));
+/// }
+/// ```
+///
+/// Wrapping an enum with subclasses:
+///
+/// ```
+/// use magnus::{class, prelude::*, wrap, Error, Ruby};
+///
+/// #[wrap(class = "Shape")]
+/// enum Shape {
+///     #[magnus(class = "Circle")]
+///     Circle { r: f64 },
+///     #[magnus(class = "Rectangle")]
+///     Rectangle { x: f64, y: f64 },
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) -> Result<(), Error> {
+///     let shape = ruby.define_class("Shape", ruby.class_object())?;
+///     ruby.define_class("Circle", shape)?;
+///     ruby.define_class("Rectangle", shape)?;
+///     Ok(())
+/// }
+/// ```
+///
+/// Custom `DataTypeFunctions` implementation:
+///
+/// ```
+/// use std::mem::size_of_val;
+///
+/// use magnus::{DataTypeFunctions, TypedData};
+///
+/// #[derive(TypedData)]
+/// #[magnus(class = "Name", size, free_immediately)]
+/// struct Name {
+///     first: String,
+///     last: String,
+/// }
+///
+/// impl DataTypeFunctions for Name {
+///     fn size(&self) -> usize {
+///         size_of_val(&self.first) + size_of_val(&self.last)
+///     }
+/// }
+/// ```
+///
+/// Struct containing Ruby values:
+///
+/// ```
+/// use magnus::{
+///     class, function, gc, method, prelude::*, typed_data::Obj, value::Opaque, DataTypeFunctions,
+///     Ruby, TypedData,
+/// };
+///
+/// #[derive(DataTypeFunctions, TypedData)]
+/// #[magnus(class = "Point", size, free_immediately)]
+/// struct Point {
+///     x: isize,
+///     y: isize,
+/// }
+///
+/// #[derive(TypedData)]
+/// #[magnus(class = "Line", free_immediately, mark)]
+/// struct Line {
+///     #[magnus(opaque_attr_reader)]
+///     start: Opaque<Obj<Point>>,
+///     #[magnus(opaque_attr_reader)]
+///     end: Opaque<Obj<Point>>,
+/// }
+///
+/// impl Line {
+///     fn new(start: Obj<Point>, end: Obj<Point>) -> Self {
+///         Self {
+///             start: start.into(),
+///             end: end.into(),
+///         }
+///     }
+///
+///     fn length(&self) -> f64 {
+///         let start = self.start();
+///         let end = self.end();
+///
+///         (((end.x - start.x).pow(2) + (end.y - start.y).pow(2)) as f64).sqrt()
+///     }
+/// }
+///
+/// impl DataTypeFunctions for Line {
+///     fn mark(&self, marker: &gc::Marker) {
+///         marker.mark(self.start);
+///         marker.mark(self.end);
+///     }
+/// }
+///
+/// #[magnus::init]
+/// fn init(ruby: &Ruby) -> Result<(), magnus::Error> {
+///     let line = ruby.define_class("Line", ruby.class_object())?;
+///     line.define_singleton_method("new", function!(Line::new, 2))?;
+///     line.define_method("length", method!(Line::length, 0))?;
+///     Ok(())
+/// }
+/// ```
+#[proc_macro_derive(TypedData, attributes(magnus))]
+pub fn derive_typed_data(input: TokenStream) -> TokenStream {
+    match typed_data::expand_derive_typed_data(parse_macro_input!(input)) {
+        Ok(tokens) => tokens,
+        Err(e) => e.into_compile_error(),
+    }
+    .into()
+}

data/ext/cargo-vendor/{magnus-macros-0.6.0 → magnus-macros-0.8.0}/src/typed_data.rs

@@ -23,7 +23,7 @@ pub fn expand_derive_data_type_functions(input: DeriveInput) -> TokenStream {
 }
 
 pub fn expand_derive_typed_data(input: DeriveInput) -> Result<TokenStream, Error> {
-    let attrs = match util::get_magnus_attrubute(&input.attrs)? {
+    let attrs = match util::get_magnus_attribute(&input.attrs)? {
         Some(v) => v,
         None => return Err(Error::new(input.span(), "missing #[magnus] attribute")),
     };
@@ -101,7 +101,7 @@ pub fn expand_derive_typed_data(input: DeriveInput) -> Result<TokenStream, Error
     let mut arms = Vec::new();
     if let Data::Enum(DataEnum { ref variants, .. }) = input.data {
         for variant in variants.into_iter() {
-            let attrs = match util::get_magnus_attrubute(&variant.attrs)? {
+            let attrs = match util::get_magnus_attribute(&variant.attrs)? {
                 Some(v) => v,
                 None => continue,
             };
@@ -156,7 +156,7 @@ pub fn expand_derive_typed_data(input: DeriveInput) -> Result<TokenStream, Error
     }) = input.data
     {
         for field in named {
-            let attrs = match util::get_magnus_attrubute(&field.attrs)? {
+            let attrs = match util::get_magnus_attribute(&field.attrs)? {
                 Some(v) => v,
                 None => continue,
             };

data/ext/cargo-vendor/{magnus-macros-0.6.0 → magnus-macros-0.8.0}/src/util.rs

@@ -1,6 +1,6 @@
 use syn::{spanned::Spanned, Attribute, Error};
 
-pub fn get_magnus_attrubute(attrs: &[Attribute]) -> Result<Option<&Attribute>, Error> {
+pub fn get_magnus_attribute(attrs: &[Attribute]) -> Result<Option<&Attribute>, Error> {
     let attrs = attrs
         .iter()
         .filter(|attr| attr.path().is_ident("magnus"))

data/ext/cargo-vendor/serde_magnus-0.10.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"2c38e040fea253142cb5a88f405d5f4c062118b5550641a009bf3b30e7f9699f","Cargo.lock":"1ed6717180355d2a3b20b126d28fefa66ee37c3f8b60d1cc6fa4f74702c8d202","Cargo.toml":"5079fbefcc7954a3ad0dac5b30941a3e40f9d2b5660bfe4487b532b115728562","Cargo.toml.orig":"248511fc699d0cee31cc2a37210092049a626e73ae30225797b03a90d59b1b9f","LICENSE":"b13a15a45244679c4be9cc2e3a6e93e18d971fe890350e131f68a8f7d013d8ad","README.md":"e503b7e52e357adadf3827053e7f57a11500988c0a416c216ad474a9b3e3e119","src/de/array_deserializer.rs":"1f42ec33e453dc3f7da70fd67205514a39a103ab53a4f1694ccffbd6d35e4022","src/de/array_enumerator.rs":"32811edb0e1bbf621a16ee350985c246ee1d2ae9d64ec1b939fce7b3f4224cec","src/de/deserializer.rs":"99b25308b7635a09b297626b9fda4f215b025c215ee00a04fe5bd87852f19deb","src/de/enum_deserializer.rs":"4d381ecf4dc8ef9d619a9095d01376c3ccdc798d1ca434166c655fafea1420e6","src/de/hash_deserializer.rs":"8e30abfb865d99506585faaba06473cbb2b81fbc4969a518979a0417111d4344","src/de/mod.rs":"b3246446aa3a753fc2e5bb105fcc714c72928952697eaf8df4d38b57bee5c2ce","src/de/variant_deserializer.rs":"12e050e8d1aad7c1729086c2e0bc5bb9e5fb50749f0abc62f587684e222400aa","src/error.rs":"f3490e6323cfb1d2f311eb127393a755d077bf5a8c4990e14d2dfd546a18482e","src/lib.rs":"e62af27388e0bcbf91986b2789590c9b1b939031d494ecdeeb2f002d46db2b32","src/ser/enums.rs":"b68468f459f98aaa89cf86fdacf8f91439a53b53a25af66d11660772d79bba6c","src/ser/map_serializer.rs":"a8fa655d63ca8ca12107061c8ffc4779908acd608952a77b1ee7bcde52751812","src/ser/mod.rs":"cea133e2e4abd68f3d4b9f1ec7985bbea6b0790b76f9243cf32f3b4fe3770ad4","src/ser/seq_serializer.rs":"1521207de5b8469f33ddb936f1a126ee8b5117aa9c9067b6558d95d63709ebec","src/ser/serializer.rs":"c8e3834042d72c7fee92d029f7743be57607a13c70627ff9988674b9c68049e4","src/ser/struct_serializer.rs":"07b6de2746f11914660e82f9cb8c7fa714fddc3af1bc0f0ac0cb30dadea9a604","src/ser/struct_variant_serializer.rs":"dea6fbe823045d86128c3dde0b1613653a7199390939f1ce092a41c88ba4ee3f","src/ser/tuple_variant_serializer.rs":"0f0879f939d822cd83e86813f5b30741ce9dccae69572ea62c4336b1783277ca","tests/deserializing_arrays.rs":"00f2c4aaa2da6e1e32d4b7b50f8841087518074e5701ec4e2667df151d05b908","tests/deserializing_booleans.rs":"c36ef7e1bce155166bfd89626e4a0e3a56e8f31948f8691a2ab2f439a6c9bd57","tests/deserializing_enums.rs":"9930b4fc875ffed2a168fe32c8d42848fca7109175c7cc84455dd554abe25f60","tests/deserializing_floats.rs":"0d1b7c7c7f607f3599a3bd090f47113856ed6ca484a1b2b4d9336186fe3202a2","tests/deserializing_integers.rs":"fb8994ec18f91404583141f82703c02291dfda4571d43e843631f9f606ca8c7f","tests/deserializing_maps.rs":"bbadcee9578f92a56a0101698d97887d0b1ed719290cf4de6f803d237707e575","tests/deserializing_options.rs":"64a17c3bda53526a6a03c5d3aa43ea693a7f53251e80265b5ffe5256e5a0c7cd","tests/deserializing_results.rs":"538fac6cd2f76142b80beed35aabbc1641aa8927dd750c9d7e01614fe5cbfb3f","tests/deserializing_strings.rs":"b74758e444f53549d31c26defe5f8896ab661e461a2b2958d0f3a6626dae795e","tests/deserializing_structs.rs":"f4a145c10442ad689fe3d3f6d750c286bbab266fa7231802e38a6df03d3f2fee","tests/deserializing_tuples.rs":"0ab7ccf9c143fb3da2e238bc6e3c5b82ccecaee1dd1b0def36d762df2b0583bf","tests/deserializing_vecs.rs":"26d09798e73a315ce3c70e1463bef5a5f67b76f33575cc0b9012d6785b588b41","tests/serializing_arrays.rs":"c2be6d3dcc28334bcdd97d8da0f0c87816caafc13197e2f708c683eac4f9ab5d","tests/serializing_booleans.rs":"301afdc45cd5d96c2534d0a4e485cc856e2381cbf89b106b758b562eb82e7a8b","tests/serializing_enums.rs":"2b03414a7560e3979ed3f3cf312c417833e7d48343e462ff46effacde25328e1","tests/serializing_floats.rs":"2a4a73cb8b4f92c7f3ae66926f7cc174d547af3ba5cef876193fa9b11fe2130f","tests/serializing_integers.rs":"70cc2836f5ea96e2ffe8f671cf64cc1f499ca703ca5d6b83fd2c2dd489503591","tests/serializing_maps.rs":"ed1ba4644f93c97c53969cbbcee082bdeb80ea42b034be5cb74706a66617f42a","tests/serializing_options.rs":"adec0f3cee27f8144b4eaab90c29ac02f72faf8d93a2b7ac2be1192904f4018d","tests/serializing_results.rs":"547106207266e648280bf60e4c8a36df50be0a7d467b59bf083d4accc9484d36","tests/serializing_strings.rs":"84cbbd43f497857be9129dc45184c827061b665dc88efd43702bd78f573de233","tests/serializing_structs.rs":"5287d45724a83ad0f075e54095fb71aeca45b228c745136f9159b157bdc2de6b","tests/serializing_tuples.rs":"a4ea4e188f59341a6c2bba4acc91848a32a113fadc1754e3c3a31a1322b04cf0","tests/serializing_vecs.rs":"fad941c4641fa142c80ce866633d0d37adfd3922783de5776b2dbd2aad3563bd"},"package":"c4a5121544138e6a14036e48ecbe589fb63577f35620caaa32642257b412c317"}

data/ext/cargo-vendor/serde_magnus-0.10.0/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "0d583c6926757460a27e7bc99c07bd6139fc5350"
+  },
+  "path_in_vcs": ""
+}