code_ownership 2.1.0 → 2.1.2

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/README.md

@@ -82,13 +82,24 @@ make sure the return type is `magnus::Value`.
 
 ### Wrapping Rust Types in Ruby Objects
 
-Rust structs and enums can be wrapped in Ruby objects so they can be returned
-to Ruby.
+Magnus allows you to wrap Rust structs and enums as Ruby objects, enabling seamless interaction between Rust and Ruby. This functionality is ideal for exposing Rust logic to Ruby modules.
 
-Types can opt-in to this with the `magnus::wrap` macro (or by implementing
-`magnus::TypedData`). Whenever a compatible type is returned to Ruby it will be
-wrapped in the specified class, and whenever it is passed back to Rust it will
-be unwrapped to a reference.
+Use one of the following approaches to expose a Rust type to Ruby:
+
+* A convenience macro [`#[magnus::wrap]`][magnus-wrap].
+* More customised approach by implementing the [`magnus::TypedData`] trait.
+
+[magnus-wrap]: https://docs.rs/magnus/latest/magnus/attr.wrap.html
+[`magnus::TypedData`]: https://docs.rs/magnus/latest/magnus/derive.TypedData.html
+
+Then this Rust type can be:
+
+* Returned to Ruby as a wrapped object.
+* Passed back to Rust and automatically unwrapped to a native Rust reference.
+
+#### Basic Usage
+
+Here’s how you can wrap a simple Rust struct and expose its methods to Ruby:
 
 ```rust
 use magnus::{function, method, prelude::*, Error, Ruby};
@@ -128,16 +139,20 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 }
 ```
 
-The newtype pattern and `RefCell` can be used if mutability is required:
+#### Handling Mutability
+
+Because Ruby's GC manages the memory where your Rust type is stored, Magnus can't bind functions with mutable references. To allow mutable fields in wrapped Rust structs, you can use the newtype pattern with `RefCell`:
 
 ```rust
+use std::cell::RefCell;
+
 struct Point {
     x: isize,
     y: isize,
 }
 
 #[magnus::wrap(class = "Point")]
-struct MutPoint(std::cell::RefCell<Point>);
+struct MutPoint(RefCell<Point>);
 
 impl MutPoint {
     fn set_x(&self, i: isize) {
@@ -146,8 +161,17 @@ impl MutPoint {
 }
 ```
 
-To allow wrapped types to be subclassed they must implement `Default`, and
-define and alloc func and an initialize method:
+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
+
+To enable Ruby subclassing for wrapped Rust types, the type must:
+
+* Implement the `Default` trait.
+* Define an allocator.
+* Define an initialiser.
 
 ``` rust
 #[derive(Default)]
@@ -177,6 +201,26 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 }
 ```
 
+#### Error Handling
+
+Use `magnus::Error` to propagate errors to Ruby from Rust:
+
+```rust
+#[magnus::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"));
+        }
+    }
+}
+```
+
 ## Getting Started
 
 ### Writing an extension gem (calling Rust from Ruby)
@@ -191,7 +235,7 @@ setting the `crate-type` attribute in your `Cargo.toml`.
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = "0.7"
+magnus = "0.8"
 ```
 
 When Ruby loads your extension it calls an 'init' function defined in your
@@ -246,7 +290,7 @@ require "rb_sys/mkmf"
 create_rust_makefile("my_example_gem/my_example_gem")
 ```
 
-See the [`rust_blank`] example for examples if `extconf.rb` and `Rakefile`.
+See the [`rust_blank`] example for examples of `extconf.rb` and `Rakefile`.
 Running `rake compile` will place the extension at
 `lib/my_example_gem/my_example_gem.so` (or `.bundle` on macOS), which you'd
 load from Ruby like so:
@@ -274,7 +318,7 @@ To call Ruby from a Rust program, enable the `embed` feature:
 
 ```toml
 [dependencies]
-magnus = { version = "0.7", features = ["embed"] }
+magnus = { version = "0.8", features = ["embed"] }
 ```
 
 This enables linking to Ruby and gives access to the `embed` module.
@@ -319,7 +363,7 @@ See `magnus::TryConvert` for more details.
 | `i8`,`i16`,`i32`,`i64`,`isize`, `magnus::Integer`                    | `Integer`, `#to_int`                    |
 | `u8`,`u16`,`u32`,`u64`,`usize`                                       | `Integer`, `#to_int`                    |
 | `f32`,`f64`, `magnus::Float`                                         | `Float`, `Numeric`                      |
-| `String`, `PathBuf`, `char`, `magnus::RString`, `bytes::Bytes`\*\*\* | `String`, `#to_str`                     |
+| `String`, `PathBuf`, `char`, `magnus::RString`, `bytes::Bytes`‡      | `String`, `#to_str`                     |
 | `magnus::Symbol`                                                     | `Symbol`, `#to_sym`                     |
 | `bool`                                                               | any object                              |
 | `magnus::Range`                                                      | `Range`                                 |
@@ -329,17 +373,19 @@ See `magnus::TryConvert` for more details.
 | `[T; N]`                                                             | `[T]`, `#to_ary`                        |
 | `magnus::RArray`                                                     | `Array`, `#to_ary`                      |
 | `magnus::RHash`                                                      | `Hash`, `#to_hash`                      |
-| `std::time::SystemTime`, `magnus::Time`                              | `Time`                                  |
+| `std::time::SystemTime`, `magnus::Time`, `chrono::DateTime<T>`§      | `Time`                                  |
 | `magnus::Value`                                                      | any object                              |
 | `Vec<T>`\*                                                           | `[T]`, `#to_ary`                        |
 | `HashMap<K, V>`\*                                                    | `{K => V}`, `#to_hash`                  |
-| `&T`, `typed_data::Obj<T>` where `T: TypedData`\*\*                  | instance of `<T as TypedData>::class()` |
+| `&T`, `typed_data::Obj<T>` where `T: TypedData`†                     | instance of `<T as TypedData>::class()` |
 
 \* when converting to `Vec` and `HashMap` the types of `T`/`K`,`V` must be native Rust types.
 
-\*\* see the `wrap` macro.
+† see the `wrap` macro.
+
+‡ when the `bytes` feature is enabled
 
-\*\*\* when the `bytes` feature is enabled
+§ when the `chrono` feature is enabled; `T` can be `Utc` or `FixedOffset`.
 
 ### Rust returning / passing values to Ruby
 
@@ -360,9 +406,9 @@ and `magnus::ArgList` for some additional details.
 | `(T, U)`, `(T, U, V)`, etc, `[T; N]`, `Vec<T>`     | `Array`                                 |
 | `HashMap<K, V>`                                    | `Hash`                                  |
 | `std::time::SystemTime`                            | `Time`                                  |
-| `T`, `typed_data::Obj<T>` where `T: TypedData`\*\* | instance of `<T as TypedData>::class()` |
+| `T`, `typed_data::Obj<T>` where `T: TypedData`\*  | instance of `<T as TypedData>::class()` |
 
-\*\* see the `wrap` macro.
+\* see the `wrap` macro.
 
 ### Conversions via Serde
 
@@ -432,7 +478,7 @@ use `unsafe`.
 
 ## Compatibility
 
-Ruby versions 3.0, 3.1, 3.2, and 3.3 are fully supported.
+Ruby versions 3.0, 3.1, 3.2, 3.3 and 3.4 are fully supported.
 
 Magnus currently works with, and is still tested against, Ruby 2.7, but as this
 version of the language is no longer supported by the Ruby developers it is not
@@ -441,7 +487,7 @@ recommended and future support in Magnus is not guaranteed.
 Ruby bindings will be generated at compile time, this may require libclang to
 be installed.
 
-The Minimum supported Rust version is currently Rust 1.61.
+The minimum supported Rust version is currently Rust 1.65.
 
 Support for statically linking Ruby is provided via the lower-level [rb-sys]
 crate, and can be enabled by adding the following to your `Cargo.toml`:
@@ -479,6 +525,10 @@ deserialisation of Rust to Ruby data structures and vice versa.
 
 * [`halton`](https://github.com/matsadler/halton-rb) a Ruby gem providing a
   highly optimised method for generating Halton sequences.
+* [`optify`](https://github.com/juharris/optify) a Ruby gem to
+  simplify using configuration files to manage options for experiments.
+  It has a GitHub action to publish the gem for different architectures to RubyGems
+  with a RBI file for type hints.
 
 Please open a [pull request](https://github.com/matsadler/magnus/pulls) if
 you'd like your project listed here.
@@ -512,4 +562,6 @@ library turns out better for you.
 
 ## License
 
-This project is licensed under the MIT license, see LICENSE.
+This project is licensed under the MIT license, see [LICENSE].
+
+[LICENSE]: https://github.com/matsadler/magnus/blob/main/LICENSE

data/ext/cargo-vendor/magnus-0.8.2/build.rs

@@ -0,0 +1,15 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // add these here to silence warnings until rb_sys_env is updated
+    println!("cargo:rustc-check-cfg=cfg(ruby_use_flonum)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_lt_3_0)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_0)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_1)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_lt_3_2)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_2)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_lt_3_3)");
+    println!("cargo:rustc-check-cfg=cfg(ruby_gte_3_3)");
+
+    let _ = rb_sys_env::activate()?;
+
+    Ok(())
+}

data/ext/cargo-vendor/{magnus-0.7.1 → magnus-0.8.2}/examples/complete_object/test/temperature_test.rb

@@ -31,14 +31,14 @@ class TemperatureTest < Test::Unit::TestCase
 
   def test_dup
     temp = Temperature.new(celsius: 19.5)
-    def temp.singlton_method_example
+    def temp.singleton_method_example
     end
     copy = temp.dup
 
     assert { temp.object_id != copy.object_id }
     assert { temp == copy }
     assert { !copy.frozen? }
-    assert { !copy.respond_to?(:singlton_method_example)}
+    assert { !copy.respond_to?(:singleton_method_example)}
 
     temp2 = Temperature.new(celsius: 19.5)
     temp2.freeze
@@ -48,14 +48,14 @@ class TemperatureTest < Test::Unit::TestCase
 
   def test_clone
     temp = Temperature.new(celsius: 19.5)
-    def temp.singlton_method_example
+    def temp.singleton_method_example
     end
     copy = temp.clone
 
     assert { temp.object_id != copy.object_id }
     assert { temp == copy }
     assert { !copy.frozen? }
-    assert { copy.respond_to?(:singlton_method_example)}
+    assert { copy.respond_to?(:singleton_method_example)}
 
     temp2 = Temperature.new(celsius: 19.5)
     temp2.freeze

data/ext/cargo-vendor/magnus-0.8.2/examples/inheritance.rs

@@ -0,0 +1,66 @@
+use magnus::{function, method, prelude::*};
+
+/// Building on top of `wrap`, we can rely on Rust's enum to dispatch based on enum variants.
+/// Magnus will transform the types between Ruby and Rust.
+#[magnus::wrap(class = "Shape")]
+enum Shape {
+    #[magnus(class = "Circle")]
+    Circle { radius: f64 },
+    #[magnus(class = "Rectangle")]
+    Rectangle { x: f64, y: f64 },
+}
+
+impl Shape {
+    fn new_circle(radius: f64) -> Self {
+        Self::Circle { radius }
+    }
+
+    fn new_rectangle(x: f64, y: f64) -> Self {
+        Self::Rectangle { x, y }
+    }
+
+    fn area(&self) -> f64 {
+        match self {
+            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
+            Shape::Rectangle { x, y } => x * y,
+        }
+    }
+}
+
+fn print_area(s: &Shape) {
+    println!("{}", s.area());
+}
+
+fn main() -> Result<(), String> {
+    // Normal Rust code
+    let a = Shape::Circle { radius: 10.0 };
+    let b = Shape::Rectangle { x: 10.0, y: 2.0 };
+    print_area(&a);
+    print_area(&b);
+
+    // magnus binding running in Ruby
+    magnus::Ruby::init(|ruby| {
+        let shape_class = ruby.define_class("Shape", ruby.class_object())?;
+        shape_class.undef_default_alloc_func();
+
+        // inherit from Shape
+        let circle_class = ruby.define_class("Circle", shape_class)?;
+        circle_class.define_singleton_method("new", function!(Shape::new_circle, 1))?;
+        circle_class.define_method("area", method!(Shape::area, 0))?;
+
+        let rectangle_class = ruby.define_class("Rectangle", shape_class)?;
+        rectangle_class.define_singleton_method("new", function!(Shape::new_rectangle, 2))?;
+        rectangle_class.define_method("area", method!(Shape::area, 0))?;
+
+        let d: f64 = ruby.eval(
+            "a = Circle.new(10.0)
+             b = Rectangle.new(10.0, 2.0)
+             difference = a.area - b.area
+             puts \"The difference of the area between the circle and the rectangle is #{difference}.\"
+             difference",
+        )?;
+
+        println!("{}", d);
+        Ok(())
+    })
+}

data/ext/cargo-vendor/magnus-0.8.2/examples/mut_point.rs

@@ -0,0 +1,116 @@
+use std::cell::RefCell;
+
+use magnus::{function, method, prelude::*, wrap, Error, Ruby};
+
+struct Point {
+    x: isize,
+    y: isize,
+}
+
+// The `wrap` macro wraps a Rust type in a Ruby object, enabling seamless
+// integration.
+//
+// Magnus uses two Ruby API functions to manage the struct:
+// * `rb_data_typed_object_wrap`
+// * `rb_check_typeddata`
+//
+// # Mutability
+//
+// Ruby's garbage collector (GC) manages memory for wrapped objects. This
+// prevents using `&mut` references because Rust requires them to be unique,
+// while Ruby GC may move objects unpredictably. To address this, you can use
+// [`RefCell`](https://doc.rust-lang.org/std/cell/struct.RefCell.html) to
+// enable interior mutability.
+//
+// # Error Handling
+//
+// Use [`magnus::Error`](https://docs.rs/magnus/latest/magnus/struct.Error.html)
+// to propagate errors to Ruby.
+// For example, you can raise a Ruby exception from Rust using Ruby's
+// predefined exception classes.
+//
+// The syntax for methods like `add_x` differs slightly from typical Rust
+// struct methods because it uses the
+// [`method!` macro](https://docs.rs/magnus/latest/magnus/macro.method.html):
+// * The first parameter, `ruby`, gives access to Ruby's runtime.
+// * The second parameter, `rb_self`, is the Ruby object being called.
+//
+// See [`DataTypeFunctions`](https://docs.rs/magnus/latest/magnus/derive.DataTypeFunctions.html)
+// and [`TypedData`](https://docs.rs/magnus/latest/magnus/derive.TypedData.html)
+#[wrap(class = "Point")]
+struct MutPoint(RefCell<Point>);
+
+impl MutPoint {
+    fn new(x: isize, y: isize) -> Self {
+        Self(RefCell::new(Point { x, y }))
+    }
+
+    fn x(&self) -> isize {
+        self.0.borrow().x
+    }
+
+    fn set_x(&self, val: isize) {
+        self.0.borrow_mut().x = val;
+    }
+
+    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 {
+            Err(Error::new(
+                ruby.exception_range_error(),
+                "result out of range",
+            ))
+        }
+    }
+
+    fn y(&self) -> isize {
+        self.0.borrow().y
+    }
+
+    fn set_y(&self, val: isize) {
+        self.0.borrow_mut().y = val;
+    }
+
+    fn add_y(ruby: &Ruby, rb_self: &Self, val: isize) -> Result<isize, Error> {
+        if let Some(sum) = rb_self.0.borrow().y.checked_add(val) {
+            rb_self.0.borrow_mut().y = sum;
+            Ok(sum)
+        } else {
+            Err(Error::new(
+                ruby.exception_range_error(),
+                "result out of range",
+            ))
+        }
+    }
+
+    fn distance(&self, other: &MutPoint) -> f64 {
+        (((other.x() - self.x()).pow(2) + (other.y() - self.y()).pow(2)) as f64).sqrt()
+    }
+}
+
+fn main() -> Result<(), String> {
+    magnus::Ruby::init(|ruby| {
+        let class = ruby.define_class("Point", ruby.class_object())?;
+        class.define_singleton_method("new", function!(MutPoint::new, 2))?;
+        class.define_method("x", method!(MutPoint::x, 0))?;
+        class.define_method("x=", method!(MutPoint::set_x, 1))?;
+        class.define_method("add_x", method!(MutPoint::add_x, 1))?;
+        class.define_method("y", method!(MutPoint::y, 0))?;
+        class.define_method("y=", method!(MutPoint::set_y, 1))?;
+        class.define_method("add_y", method!(MutPoint::add_y, 1))?;
+        class.define_method("distance", method!(MutPoint::distance, 1))?;
+
+        let d: f64 = ruby.eval(
+            "a = Point.new(0, 0)
+             b = Point.new(0, 0)
+             b.x = 5
+             b.y = 10
+             a.distance(b)",
+        )?;
+
+        println!("{}", d);
+        Ok(())
+    })
+}

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

@@ -23,7 +23,7 @@ enum RubyGvlState {
 }
 
 thread_local! {
-    static RUBY_GVL_STATE: RefCell<Option<RubyGvlState>> = RefCell::new(None);
+    static RUBY_GVL_STATE: RefCell<Option<RubyGvlState>> = const { RefCell::new(None) };
 }
 
 impl RubyGvlState {
@@ -68,11 +68,11 @@ impl RubyGvlState {
 
 /// A handle to access Ruby's API.
 ///
-/// Using Ruby's API requires the Ruby VM to be initalised and all access to be
+/// Using Ruby's API requires the Ruby VM to be initialised and all access to be
 /// from a Ruby-created thread.
 ///
 /// This structure allows safe access to Ruby's API as it should only be
-/// possible to aquire an instance in situations where Ruby's API is known to
+/// possible to acquire an instance in situations where Ruby's API is known to
 /// be available.
 ///
 /// Many functions that take Ruby values as arguments are available directly
@@ -107,6 +107,7 @@ impl RubyGvlState {
 /// * [Globals](#globals) - global variables, etc, plus current VM state such
 ///   as calling the current `super` method.
 /// * [`Id`](#id) - low-level Symbol representation
+/// * [`Io`](#io-helper-functions) - IO helper functions
 /// * [`Integer`](#integer)
 /// * [`Mutex`](#mutex)
 /// * [`nil`](#nil)

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

@@ -36,7 +36,7 @@ use crate::{
 /// See the [`Class`] trait for methods available on classes.
 /// See the [`Module`] trait for defining instance methods and nested
 /// classes/modules.
-/// See the [`Object`] trait for defining singlton methods (aka class methods).
+/// See the [`Object`] trait for defining singleton methods (aka class methods).
 ///
 /// See the [`ReprValue`] trait for additional methods available on this type.
 #[derive(Clone, Copy)]
@@ -315,7 +315,7 @@ pub trait Class: Module {
     ///
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let value = ruby.class_hash();
-    ///     // safe as we neve give Ruby a chance to free the string.
+    ///     // safe as we never give Ruby a chance to free the string.
     ///     let s = unsafe { value.name() }.into_owned();
     ///     assert_eq!(s, "Hash");
     ///
@@ -329,7 +329,7 @@ pub trait Class: Module {
     ///
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let value = ruby.exception_standard_error();
-    ///     // safe as we neve give Ruby a chance to free the string.
+    ///     // safe as we never give Ruby a chance to free the string.
     ///     let s = unsafe { value.name() }.into_owned();
     ///     assert_eq!(s, "StandardError");
     ///
@@ -337,7 +337,7 @@ pub trait Class: Module {
     /// }
     /// # Ruby::init(example).unwrap()
     /// ```
-    unsafe fn name(&self) -> Cow<str> {
+    unsafe fn name(&self) -> Cow<'_, str> {
         let ptr = rb_class2name(self.as_rb_value());
         let cstr = CStr::from_ptr(ptr);
         cstr.to_string_lossy()
@@ -504,10 +504,12 @@ pub trait Class: Module {
             });
             RB_CLASS_ALLOCATE_INSTANCE
         };
-
         unsafe {
-            if rb_get_alloc_func(self.as_rb_value()) == rb_class_allocate_instance {
-                rb_undef_alloc_func(self.as_rb_value())
+            let current_alloc = rb_get_alloc_func(self.as_rb_value());
+            if let (Some(actual), Some(default)) = (current_alloc, rb_class_allocate_instance) {
+                if std::ptr::eq(actual as *const (), default as *const ()) {
+                    rb_undef_alloc_func(self.as_rb_value());
+                }
             }
         }
     }

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

@@ -6,10 +6,10 @@
 //! Encoding <-> RbEncoding <-> Index
 //!       |______________________^
 //! ```
-//! Many functions that require an encoding take thier arguments as
+//! Many functions that require an encoding take their arguments as
 //! `Into<RbEncoding>` or `Into<Index>` to ease working with the different
 //! types. The type specified for the `Into` conversion hints at the type the
-//! function nativly works with, and thus will avoid any conversion cost.
+//! function natively works with, and thus will avoid any conversion cost.
 //!
 //! [`Encoding`] and [`RbEncoding`] both implement [`TryConvert`] and
 //! [`IntoValue`] so can be used as parameters and return values in functions
@@ -314,7 +314,7 @@ impl Ruby {
 pub struct RbEncoding(NonNull<rb_encoding>);
 
 impl RbEncoding {
-    fn new(inner: *mut rb_encoding) -> Option<Self> {
+    pub(crate) fn new(inner: *mut rb_encoding) -> Option<Self> {
         NonNull::new(inner).map(Self)
     }
 
@@ -586,7 +586,7 @@ impl RbEncoding {
     /// Returns the number of bytes of the first character in `slice`.
     ///
     /// If the first byte of `slice` is mid way through a character this will
-    /// return the number of bytes until the next character boundry.
+    /// return the number of bytes until the next character boundary.
     ///
     /// If the slice ends before the last byte of the character this will
     /// return the theoretical number of bytes until the end of the character,
@@ -739,7 +739,7 @@ impl RbEncoding {
         if len == 0 {
             panic!("{:?}", slice);
         }
-        (c > -1).then(|| (c as u8, len as usize))
+        (c > -1).then_some((c as u8, len as usize))
     }
 
     /// Returns the codepoint and length in bytes of the first character in

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

@@ -5,8 +5,8 @@
 use std::{any::Any, borrow::Cow, ffi::CString, fmt, mem::transmute, os::raw::c_int};
 
 use rb_sys::{
-    rb_bug, rb_ensure, rb_errinfo, rb_exc_raise, rb_iter_break_value, rb_jump_tag, rb_protect,
-    rb_set_errinfo, rb_warning, ruby_special_consts, VALUE,
+    rb_bug, rb_ensure, rb_errinfo, rb_exc_fatal, rb_exc_raise, rb_iter_break_value, rb_jump_tag,
+    rb_protect, rb_set_errinfo, rb_warning, ruby_special_consts, VALUE,
 };
 
 use crate::{
@@ -19,7 +19,7 @@ use crate::{
 };
 
 /// An error returned to indicate an attempt to interact with the Ruby API from
-/// a non-Ruby thread or without aquiring the GVL.
+/// a non-Ruby thread or without acquiring the GVL.
 #[derive(Debug)]
 pub enum RubyUnavailableError {
     /// GVL is not locked.
@@ -539,6 +539,15 @@ where
 pub(crate) fn raise(e: Error) -> ! {
     match e.0 {
         ErrorType::Jump(tag) => tag.resume(),
+        ErrorType::Error(class, _)
+            if class.as_rb_value()
+                == unsafe { Ruby::get_unchecked().exception_fatal().as_rb_value() } =>
+        {
+            unsafe { rb_exc_fatal(e.exception().as_rb_value()) }
+            // friendly reminder: we really never get here, and as such won't
+            // drop any values still in scope, make sure everything has been
+            // consumed/dropped
+        }
         _ => {
             unsafe { rb_exc_raise(e.exception().as_rb_value()) }
             // friendly reminder: we really never get here, and as such won't

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

@@ -463,11 +463,11 @@ impl Fiber {
     {
         unsafe {
             protect(|| {
-                Value::new(rb_fiber_raise(
-                    self.as_rb_value(),
-                    1,
-                    &e.as_rb_value() as *const VALUE,
-                ))
+                #[cfg(ruby_lte_3_4)]
+                let e = &e.as_rb_value() as *const VALUE;
+                #[cfg(ruby_gt_3_4)]
+                let e = &mut e.as_rb_value() as *mut VALUE;
+                Value::new(rb_fiber_raise(self.as_rb_value(), 1, e))
             })
             .and_then(TryConvert::try_convert)
         }

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

@@ -212,7 +212,7 @@ where
 ///
 /// Prevents Ruby moving or collecting `valref`. This should be used on
 /// `static` items to prevent them being collected instead of relying on Ruby
-/// constants/globals to allways refrence the value.
+/// constants/globals to always reference the value.
 ///
 /// See also [`BoxValue`](crate::value::BoxValue).
 ///
@@ -347,7 +347,7 @@ impl Ruby {
     /// Trigger a "full" GC run.
     ///
     /// This will perform a full mark phase and a complete sweep phase, but may
-    /// not run every single proceess associated with garbage collection.
+    /// not run every single process associated with garbage collection.
     ///
     /// Finalisers will be deferred to run later.
     ///
@@ -552,7 +552,7 @@ pub fn enable() -> bool {
 /// Trigger a "full" GC run.
 ///
 /// This will perform a full mark phase and a complete sweep phase, but may not
-/// run every single proceess associated with garbage collection.
+/// run every single process associated with garbage collection.
 ///
 /// Finalisers will be deferred to run later.
 ///