code_ownership 2.1.0 → 2.1.1

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/src/typed_data.rs

@@ -18,8 +18,9 @@ use std::{
 #[cfg(ruby_gte_3_0)]
 use rb_sys::rbimpl_typeddata_flags::{self, RUBY_TYPED_FREE_IMMEDIATELY, RUBY_TYPED_WB_PROTECTED};
 use rb_sys::{
-    self, rb_data_type_struct__bindgen_ty_1, rb_data_type_t, rb_obj_reveal,
-    rb_singleton_class_attached, rb_singleton_class_clone, size_t, VALUE,
+    self, rb_data_type_struct__bindgen_ty_1, rb_data_type_t, rb_gc_writebarrier,
+    rb_gc_writebarrier_unprotect, rb_obj_reveal, rb_singleton_class_attached,
+    rb_singleton_class_clone, size_t, RTYPEDDATA_GET_DATA, VALUE,
 };
 
 #[cfg(ruby_lt_3_0)]
@@ -31,7 +32,7 @@ const RUBY_TYPED_WB_PROTECTED: u32 = rb_sys::ruby_fl_type::RUBY_FL_WB_PROTECTED
 use crate::{
     class::RClass,
     error::{bug_from_panic, Error},
-    gc,
+    gc::{self, Mark},
     into_value::IntoValue,
     object::Object,
     r_typed_data::RTypedData,
@@ -134,12 +135,12 @@ where
     /// in your [`mark`](Self::mark) function, you must update them in this
     /// function using [`gc::Compactor::location`].
     ///
-    /// Ruby values would be concidered moveable if marked with the
+    /// Ruby considers values are moveable if marked with the
     /// [`gc::Marker::mark_movable`] function. Other marking functions such as
     /// [`gc::Marker::mark`] will prevent values being moved.
     ///
     /// As it is only safe for this function to receive a shared `&self`
-    /// reference, you must implement interior mutablility to be able to update
+    /// reference, you must implement interior mutability to be able to update
     /// values. This is very hard to do correctly, and it is recommended to
     /// simply avoid using [`gc::Marker::mark_movable`] and `compact`.
     ///
@@ -157,7 +158,7 @@ where
     ///
     /// # Safety
     ///
-    /// `ptr` must be a vaild pointer to a `Box<Self>`, and must not be aliased
+    /// `ptr` must be a valid pointer to a `Box<Self>`, and must not be aliased
     /// This function will free the memory pointed to by `ptr`.
     ///
     /// This function must not panic.
@@ -172,7 +173,7 @@ where
     ///
     /// # Safety
     ///
-    /// `ptr` must be a vaild pointer to a `Self`, and must not be aliased.
+    /// `ptr` must be a valid pointer to a `Self`, and must not be aliased.
     ///
     /// This function must not panic.
     #[doc(hidden)]
@@ -187,7 +188,7 @@ where
     ///
     /// # Safety
     ///
-    /// `ptr` must be a vaild pointer to a `Self`.
+    /// `ptr` must be a valid pointer to a `Self`.
     ///
     /// This function must not panic.
     #[doc(hidden)]
@@ -202,7 +203,7 @@ where
     ///
     /// # Safety
     ///
-    /// `ptr` must be a vaild pointer to a `Self`, and must not be aliased.
+    /// `ptr` must be a valid pointer to a `Self`, and must not be aliased.
     ///
     /// This function must not panic.
     #[doc(hidden)]
@@ -299,7 +300,14 @@ where
 
     /// Enable the 'write barrier protected' flag.
     ///
-    /// You almost certainly don't want to enable this.
+    /// 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 [`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.
     pub const fn wb_protected(mut self) -> Self {
         self.wb_protected = true;
         self
@@ -840,7 +848,12 @@ where
     /// # Ruby::init(example).unwrap()
     /// ```
     fn deref(&self) -> &Self::Target {
-        self.inner.get().unwrap()
+        // Since we've already validated the inner during `TryConvert` via `RTypedData::get`, we
+        // can skip the extra checks and libruby calls and just access the data directly.
+        unsafe {
+            let data_ptr = RTYPEDDATA_GET_DATA(self.inner.as_rb_value()) as *mut Self::Target;
+            &*data_ptr
+        }
     }
 }
 
@@ -914,6 +927,95 @@ where
     }
 }
 
+/// A trait for types that can be used with the `rb_gc_writebarrier` API.
+pub trait Writebarrier: ReprValue {
+    /// Inform Ruby that `self` contains a reference to `new`.
+    ///
+    /// If you have a Rust type that contains Ruby values, and itself is
+    /// wrapped as a Ruby object, and you choose to enable the `wb_protected`
+    /// flag so that it can participate in generational GC then all operations
+    /// that add a Ruby value to your data type must call this function.
+    ///
+    /// The write barrier is hard to get right. Magnus recommends you do not
+    /// enable the `wb_protected` flag, and thus you don't need to use this function.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::cell::RefCell;
+    ///
+    /// use magnus::{
+    ///     function, gc, method,
+    ///     prelude::*,
+    ///     typed_data::{Obj, Writebarrier},
+    ///     value::Opaque,
+    ///     DataTypeFunctions, Error, Ruby, TypedData, Value,
+    /// };
+    ///
+    /// #[derive(TypedData)]
+    /// #[magnus(class = "MyVec", free_immediately, mark, wb_protected)]
+    /// struct MyVec {
+    ///     values: RefCell<Vec<Opaque<Value>>>,
+    /// }
+    ///
+    /// impl DataTypeFunctions for MyVec {
+    ///     fn mark(&self, marker: &gc::Marker) {
+    ///         marker.mark_slice(self.values.borrow().as_slice());
+    ///     }
+    /// }
+    ///
+    /// impl MyVec {
+    ///     fn new() -> Self {
+    ///         Self {
+    ///             values: RefCell::new(Vec::new()),
+    ///         }
+    ///     }
+    ///
+    ///     fn push(ruby: &Ruby, rb_self: Obj<Self>, val: Value) -> Obj<Self> {
+    ///         rb_self.values.borrow_mut().push(val.into());
+    ///         rb_self.writebarrier(rb_self);
+    ///         rb_self
+    ///     }
+    /// }
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let class = ruby.define_class("MyVec", ruby.class_object())?;
+    ///     class.define_singleton_method("new", function!(MyVec::new, 0))?;
+    ///     class.define_method("push", method!(MyVec::push, 1))?;
+    ///
+    ///     let _: Value = ruby.eval(
+    ///         r#"
+    ///             vec = MyVec.new
+    ///             vec.push("test")
+    ///             vec.push("example")
+    ///         "#,
+    ///     )?;
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap();
+    /// ```
+    fn writebarrier<T>(&self, young: T)
+    where
+        T: Mark,
+    {
+        unsafe { rb_gc_writebarrier(self.as_rb_value(), young.raw()) };
+    }
+
+    /// Opts `self` out of generational GC / write barrier protection.
+    ///
+    /// After calling this function `self` will not participate in generational
+    /// GC and will always be scanned during a GC.
+    /// See [`RTypedData::writebarrier`].
+    fn writebarrier_unprotect<T, U>(&self) {
+        unsafe { rb_gc_writebarrier_unprotect(self.as_rb_value()) };
+    }
+}
+
+impl Writebarrier for RTypedData {}
+
+impl<T> Writebarrier for Obj<T> where T: TypedData {}
+
 /// Trait for a Ruby-compatible `#hash` method.
 ///
 /// Automatically implemented for any type implementing [`std::hash::Hash`].

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/src/value/flonum.rs

@@ -90,7 +90,7 @@ impl Flonum {
     #[inline]
     pub(crate) fn from_f64_impl(d: f64) -> Option<Self> {
         let v = d.to_bits();
-        let bits = v >> 60 & 0x7;
+        let bits = (v >> 60) & 0x7;
         if v != 0x3000000000000000 && bits.wrapping_sub(3) & !0x01 == 0 {
             return Some(unsafe { Self::from_rb_value_unchecked(v.rotate_left(3) & !0x01 | 0x02) });
         } else if v == 0 {

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/src/value.rs

@@ -130,6 +130,15 @@ impl IntoValue for i64 {
 
 unsafe impl IntoValueFromNative for i64 {}
 
+impl IntoValue for i128 {
+    #[inline]
+    fn into_value_with(self, handle: &Ruby) -> Value {
+        handle.integer_from_i128(self).into_value_with(handle)
+    }
+}
+
+unsafe impl IntoValueFromNative for i128 {}
+
 impl IntoValue for isize {
     #[inline]
     fn into_value_with(self, handle: &Ruby) -> Value {
@@ -175,6 +184,15 @@ impl IntoValue for u64 {
 
 unsafe impl IntoValueFromNative for u64 {}
 
+impl IntoValue for u128 {
+    #[inline]
+    fn into_value_with(self, handle: &Ruby) -> Value {
+        handle.integer_from_u128(self).into_value_with(handle)
+    }
+}
+
+unsafe impl IntoValueFromNative for u128 {}
+
 impl IntoValue for usize {
     #[inline]
     fn into_value_with(self, handle: &Ruby) -> Value {
@@ -758,7 +776,7 @@ pub(crate) mod private {
         /// Ruby may modify or free the memory backing the returned
         /// str, the caller must ensure this does not happen.
         #[allow(clippy::wrong_self_convention)]
-        unsafe fn to_s_infallible(&self) -> Cow<str> {
+        unsafe fn to_s_infallible(&self) -> Cow<'_, str> {
             match self.as_value_ref().to_s() {
                 Ok(v) => v,
                 Err(_) => Cow::Owned(
@@ -1437,7 +1455,7 @@ pub trait ReprValue: private::ReprValue {
 
     /// Check if `self` responds to the given Ruby method.
     ///
-    /// The `include_private` agument controls whether `self`'s private methods
+    /// The `include_private` argument controls whether `self`'s private methods
     /// are checked. If `false` they are not, if `true` they are.
     ///
     /// See also [`Value::check_funcall`].
@@ -1452,8 +1470,8 @@ pub trait ReprValue: private::ReprValue {
     ///     assert!(s.respond_to("to_str", false)?);
     ///     assert!(!s.respond_to("puts", false)?);
     ///     assert!(s.respond_to("puts", true)?);
-    ///     assert!(!s.respond_to("non_existant", false)?);
-    ///     assert!(!s.respond_to("non_existant", true)?);
+    ///     assert!(!s.respond_to("non_existent", false)?);
+    ///     assert!(!s.respond_to("non_existent", true)?);
     ///
     ///     Ok(())
     /// }
@@ -1530,7 +1548,7 @@ pub trait ReprValue: private::ReprValue {
     /// # Ruby::init(example).unwrap()
     /// ```
     #[allow(clippy::wrong_self_convention)]
-    unsafe fn to_s(&self) -> Result<Cow<str>, Error> {
+    unsafe fn to_s(&self) -> Result<Cow<'_, str>, Error> {
         if let Some(s) = RString::ref_from_value(self.as_value_ref()) {
             if s.is_utf8_compatible_encoding() {
                 return s.as_str().map(Cow::Borrowed);
@@ -1596,7 +1614,7 @@ pub trait ReprValue: private::ReprValue {
     /// }
     /// # Ruby::init(example).unwrap()
     /// ```
-    unsafe fn classname(&self) -> Cow<str> {
+    unsafe fn classname(&self) -> Cow<'_, str> {
         let ptr = rb_obj_classname(self.as_rb_value());
         let cstr = CStr::from_ptr(ptr);
         cstr.to_string_lossy()
@@ -2594,6 +2612,35 @@ impl Fixnum {
         self.to_isize() as i64
     }
 
+    /// Convert `self` to an `i128`. This is infallible as `i128` can represent a
+    /// larger range than `Fixnum`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{Error, Fixnum, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    /// # #[cfg(not(windows))]
+    ///     assert_eq!(
+    ///         ruby.eval::<Fixnum>("4611686018427387903")?.to_i128(),
+    ///         4611686018427387903
+    ///     );
+    /// # #[cfg(not(windows))]
+    ///     assert_eq!(
+    ///         ruby.eval::<Fixnum>("-4611686018427387904")?.to_i128(),
+    ///         -4611686018427387904
+    ///     );
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    #[inline]
+    pub fn to_i128(self) -> i128 {
+        self.to_isize() as i128
+    }
+
     /// Convert `self` to an `isize`. Returns `Err` if `self` is out of range
     /// for `isize`.
     ///
@@ -2764,6 +2811,36 @@ impl Fixnum {
         Ok(self.to_isize() as u64)
     }
 
+    /// Convert `self` to a `u128`. Returns `Err` if `self` is negative.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{Error, Fixnum, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    /// # #[cfg(not(windows))]
+    ///     assert_eq!(
+    ///         ruby.eval::<Fixnum>("4611686018427387903")?.to_u128()?,
+    ///         4611686018427387903
+    ///     );
+    ///     assert!(ruby.eval::<Fixnum>("-1")?.to_u128().is_err());
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    #[inline]
+    pub fn to_u128(self) -> Result<u128, Error> {
+        if self.is_negative() {
+            return Err(Error::new(
+                Ruby::get_with(self).exception_range_error(),
+                "can't convert negative integer to unsigned",
+            ));
+        }
+        Ok(self.to_isize() as u128)
+    }
+
     /// Convert `self` to a `usize`. Returns `Err` if `self` is negative or out
     /// of range for `usize`.
     ///

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/test

@@ -7,7 +7,7 @@ for VERSION in $RUBY_VERSIONS; do
   eval "$(rbenv init - sh)"
   rbenv shell $VERSION
   printf "testing Ruby $VERSION..."
-  if OUTPUT=$(env RUBY="$(rbenv which ruby)" cargo +1.61 test --workspace 2>&1); then
+  if OUTPUT=$(env RUBY="$(rbenv which ruby)" cargo +1.65 test --workspace 2>&1); then
     echo ✅
   else
     ERRORS="$ERRORS\n\n\n$VERSION\n\n$OUTPUT"

data/ext/cargo-vendor/magnus-0.8.2/tests/hash.rs

@@ -0,0 +1,44 @@
+use std::collections::{BTreeMap, HashMap};
+
+#[test]
+fn it_converts_maps() {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let map: HashMap<String, u8> = ruby
+        .eval(r#"{"foo" => 1, "bar" => 2, "baz" => 3}"#)
+        .unwrap();
+
+    let mut expected = HashMap::new();
+    expected.insert("foo".to_owned(), 1);
+    expected.insert("bar".to_owned(), 2);
+    expected.insert("baz".to_owned(), 3);
+    assert_eq!(expected, map);
+
+    let mut map = HashMap::new();
+    map.insert("test", (0, 0.5));
+    map.insert("example", (1, 3.75));
+    magnus::rb_assert!(
+        ruby,
+        r#"map == {"test" => [0, 0.5], "example" => [1, 3.75]}"#,
+        map
+    );
+
+    let map: BTreeMap<String, u8> = ruby
+        .eval(r#"{"foo" => 1, "bar" => 2, "baz" => 3}"#)
+        .unwrap();
+
+    let mut expected = BTreeMap::new();
+    expected.insert("foo".to_owned(), 1);
+    expected.insert("bar".to_owned(), 2);
+    expected.insert("baz".to_owned(), 3);
+    assert_eq!(expected, map);
+
+    let mut map = BTreeMap::new();
+    map.insert("test", (0, 0.5));
+    map.insert("example", (1, 3.75));
+    magnus::rb_assert!(
+        ruby,
+        r#"map == {"test" => [0, 0.5], "example" => [1, 3.75]}"#,
+        map
+    );
+}

data/ext/cargo-vendor/magnus-0.8.2/tests/io.rs

@@ -0,0 +1,62 @@
+use magnus::{
+    encoding::Index, io::*, value::ReprValue, Error, Fixnum, IntoValue, Module, Ruby, TryConvert,
+};
+
+#[test]
+fn test_io_all() {
+    magnus::Ruby::init(|ruby| {
+        test_io_extract_modeenc_extracts_open_flags(ruby)?;
+        test_io_extract_modeenc_extracts_fmode_flags(ruby)?;
+        test_io_extract_modeenc_extracts_io_encoding(ruby)?;
+        Ok(())
+    })
+    .unwrap();
+}
+
+fn run_io_extract_modeenc(
+    ruby: &Ruby,
+    mode: &str,
+) -> Result<(OpenFlags, FMode, IoEncoding), Error> {
+    let mut mode = ruby.str_new(mode).into_value_with(&ruby);
+    let mut permission = ruby.qnil().into_value_with(&ruby);
+    let kwargs = ruby.hash_new();
+    let _ = kwargs.aset(ruby.to_symbol("encoding"), "GBK:UTF-8"); // follows "extern:intern". read more on `IO::new`
+    ruby.io_extract_modeenc(&mut mode, &mut permission, &kwargs)
+}
+
+fn test_io_extract_modeenc_extracts_open_flags(ruby: &Ruby) -> Result<(), Error> {
+    let (open_flags, _, _) = run_io_extract_modeenc(&ruby, "a")?;
+
+    let file_class = ruby.class_file();
+    let append_flag = file_class.const_get::<_, Fixnum>("APPEND")?.to_i32()?;
+
+    assert!(open_flags.contains(append_flag));
+    Ok(())
+}
+
+fn test_io_extract_modeenc_extracts_fmode_flags(ruby: &Ruby) -> Result<(), Error> {
+    let (_, fmode_flags, _) = run_io_extract_modeenc(&ruby, "a")?;
+
+    assert!(fmode_flags.contains(FMode::APPEND));
+    assert!(fmode_flags.contains(FMode::READ_WRITE));
+    assert!(fmode_flags.contains(FMode::CREATE));
+
+    Ok(())
+}
+
+fn test_io_extract_modeenc_extracts_io_encoding(ruby: &Ruby) -> Result<(), Error> {
+    let (_, _, io_encoding) = run_io_extract_modeenc(&ruby, "a")?;
+
+    assert!(io_encoding.internal.is_some());
+    assert!(io_encoding.external.is_some());
+
+    let internal_index = Index::from(io_encoding.internal.unwrap());
+    let external_index = Index::from(io_encoding.external.unwrap());
+    let utf_8 = ruby.utf8_encindex();
+    let gbk = Index::try_convert(ruby.str_new("GBK").as_value())?;
+
+    assert!(internal_index == utf_8, "Internal encoding is not UTF-8");
+    assert!(external_index == gbk, "External encoding is not GBK");
+
+    Ok(())
+}

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/tests/return_iter.rs

@@ -2,7 +2,7 @@ use magnus::{block::Yield, eval, method, prelude::*, rb_assert, Ruby, Value};
 
 fn count_to_3(ruby: &Ruby, rb_self: Value) -> Yield<impl Iterator<Item = u8>> {
     if ruby.block_given() {
-        Yield::Iter((1..=3).into_iter())
+        Yield::Iter(1..=3)
     } else {
         Yield::Enumerator(rb_self.enumeratorize("count_to_3", ()))
     }

data/ext/cargo-vendor/magnus-0.8.2/tests/string.rs

@@ -0,0 +1,23 @@
+use magnus::{prelude::*, Value};
+
+#[test]
+fn it_converts_to_utf8_string() {
+    let ruby = unsafe { magnus::embed::init() };
+
+    let val: Value = ruby
+        .eval(r#""caf\xE9".force_encoding("ISO-8859-1")"#)
+        .unwrap();
+    let s = String::try_convert(val).unwrap();
+
+    assert_eq!("café", s);
+
+    let val: Value = magnus::eval!(r#""\xFF\xFF""#).unwrap();
+    let err = String::try_convert(val).unwrap_err();
+
+    let expected_error = "invalid byte sequence in UTF-8";
+    assert!(
+        err.to_string().contains(expected_error),
+        "Expected \"{}\" to contain \"{expected_error}\" but it didn't",
+        err.to_string()
+    );
+}

data/ext/cargo-vendor/magnus-0.8.2/tests/time.rs

@@ -0,0 +1,71 @@
+use std::time::SystemTime;
+
+use magnus::{rb_assert, Error, Ruby};
+
+#[test]
+fn test_all() {
+    magnus::Ruby::init(|ruby| {
+        test_supports_system_time(ruby)?;
+        #[cfg(feature = "chrono")]
+        test_supports_chrono(ruby)?;
+        Ok(())
+    })
+    .unwrap();
+}
+
+fn test_supports_system_time(ruby: &Ruby) -> Result<(), Error> {
+    let t = ruby.eval::<SystemTime>("Time.new(1971)").unwrap();
+    rb_assert!(ruby, "t.year == 1971", t);
+
+    let t = ruby.eval::<SystemTime>("Time.new(1960)").unwrap();
+    rb_assert!(ruby, "t.year == 1960", t);
+
+    Ok(())
+}
+
+fn test_supports_chrono(ruby: &Ruby) -> Result<(), Error> {
+    use chrono::{DateTime, Datelike, FixedOffset, Utc};
+
+    let t = ruby.eval::<DateTime<Utc>>("Time.at(0, 10, :nsec)").unwrap();
+    assert_eq!(t.year(), 1970);
+    assert_eq!(t.month(), 1);
+    assert_eq!(t.day(), 1);
+    assert_eq!(t.timestamp_subsec_nanos(), 10);
+
+    let dt = ruby
+        .eval::<DateTime<Utc>>(r#"Time.new(1971, 1, 1, 2, 2, 2.0000001, "Z")"#)
+        .unwrap();
+    assert_eq!(&dt.to_rfc3339(), "1971-01-01T02:02:02.000000099+00:00");
+    rb_assert!(ruby, "dt.utc?", dt);
+    rb_assert!(ruby, "dt.utc_offset == 0", dt);
+
+    let dt = ruby
+        .eval::<DateTime<Utc>>(r#"Time.new(1950, 1, 1, 0, 0, 0, "Z")"#)
+        .unwrap();
+    assert_eq!(&dt.to_rfc3339(), "1950-01-01T00:00:00+00:00");
+
+    let dt = ruby
+        .eval::<DateTime<Utc>>(r#"Time.new(1971, 1, 1, 2, 2, 2.0000001, "-07:00")"#)
+        .unwrap();
+    assert_eq!(&dt.to_rfc3339(), "1971-01-01T09:02:02.000000099+00:00");
+
+    let dt = ruby
+        .eval::<DateTime<FixedOffset>>(
+            r#"Time.new(2022, 5, 31, 9, 8, 123456789/1000000000r, "-07:00")"#,
+        )
+        .unwrap();
+    assert_eq!(&dt.to_rfc3339(), "2022-05-31T09:08:00.123456789-07:00");
+    rb_assert!(ruby, "!dt.utc?", dt);
+    rb_assert!(ruby, "dt.utc_offset == -25200", dt);
+
+    let dt = ruby
+        .eval::<DateTime<FixedOffset>>(
+            r#"Time.new(2022, 5, 31, 9, 8, 123456789/1000000000r, "+05:30")"#,
+        )
+        .unwrap();
+    assert_eq!(&dt.to_rfc3339(), "2022-05-31T09:08:00.123456789+05:30");
+    rb_assert!(ruby, "!dt.utc?", dt);
+    rb_assert!(ruby, "dt.utc_offset == 19800", dt);
+
+    Ok(())
+}

data/ext/cargo-vendor/magnus-macros-0.8.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"3799c49c0a41fefcee2b738bc923889af371a49341656d66801347a258ae4dc1","Cargo.lock":"2d7d7ea1ed593ad0699d570db1f655f3af4e0b355291c4eba02d60a1bdf2358c","Cargo.toml":"15867dafbc2b17bfdbfc4bca82a976f7a18533aa718b64a199fe17811f0757b2","Cargo.toml.orig":"7de5dc395d511e7519fa96ff211015802b02ba17d6ba6a79e30af7c8b1794eb0","LICENSE":"79e69d34457af5881b9b7410144cac786098fd86f242a98f419aa8abd1b0578a","src/init.rs":"c0204a41d747889cfd6723f4f3bf4aa2f9f868c288738d29cc6229de4260debf","src/lib.rs":"ee63e82cfc6c9d9ea9e338244f979d7059665d272e8339f414c4e652c07b0b76","src/typed_data.rs":"e44f4ba8d82f4d2a2377158b1815a0a4b09c3ab547b580ffa95b7f521ee572b8","src/util.rs":"f72750d079f31600d4bfa3dd8022550f63e1625e3cf184756f629ab5af69d241"},"package":"47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"}

data/ext/cargo-vendor/magnus-macros-0.8.0/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "108c87edff240ad930070b83b8801fcc0851c676"
+  },
+  "path_in_vcs": "magnus-macros"
+}

data/ext/cargo-vendor/magnus-macros-0.8.0/Cargo.lock

@@ -0,0 +1,47 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "magnus-macros"
+version = "0.8.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50f3b39ccfb720540debaa0164757101c08ecb8d326b15358ce76a62c7e85965"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04361975b3f5e348b2189d8dc55bc942f278b2d482a6a0365de5bdd62d351567"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"

data/ext/cargo-vendor/{magnus-macros-0.6.0 → magnus-macros-0.8.0}/Cargo.toml

@@ -12,13 +12,22 @@
 [package]
 edition = "2021"
 name = "magnus-macros"
-version = "0.6.0"
+version = "0.8.0"
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
 description = "Derive and proc macros for magnus"
 homepage = "https://github.com/matsadler/magnus"
+readme = false
 license = "MIT"
 repository = "https://github.com/matsadler/magnus"
 
 [lib]
+name = "magnus_macros"
+path = "src/lib.rs"
 proc-macro = true
 
 [dependencies.proc-macro2]

data/ext/cargo-vendor/{magnus-macros-0.6.0 → magnus-macros-0.8.0}/Cargo.toml.orig

@@ -1,6 +1,6 @@
 [package]
 name = "magnus-macros"
-version = "0.6.0"
+version = "0.8.0"
 edition = "2021"
 description = "Derive and proc macros for magnus"
 repository = "https://github.com/matsadler/magnus"