code_ownership 2.1.0 → 2.1.1

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.
 ///

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

@@ -97,6 +97,70 @@ impl Ruby {
             )
         }
     }
+
+    /// Create a new `Integer` from an `i128.`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{rb_assert, Error, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     rb_assert!(ruby, "i == 0", i = ruby.integer_from_i128(0));
+    ///     rb_assert!(
+    ///         ruby,
+    ///         "i == 170141183460469231731687303715884105727",
+    ///         i = ruby.integer_from_i128(170141183460469231731687303715884105727),
+    ///     );
+    ///     rb_assert!(
+    ///         ruby,
+    ///         "i == -170141183460469231731687303715884105728",
+    ///         i = ruby.integer_from_i128(-170141183460469231731687303715884105728),
+    ///     );
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    #[inline]
+    pub fn integer_from_i128(&self, n: i128) -> Integer {
+        if n >= i64::MIN as i128 && n <= i64::MAX as i128 {
+            self.integer_from_i64(n as i64)
+        } else {
+            self.module_kernel()
+                .funcall("Integer", (n.to_string(),))
+                .unwrap()
+        }
+    }
+
+    /// Create a new `Integer` from a `u128.`
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{rb_assert, Error, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     rb_assert!("i == 0", i = ruby.integer_from_u128(0));
+    ///     rb_assert!(
+    ///         "i == 340282366920938463463374607431768211455",
+    ///         i = ruby.integer_from_u128(340282366920938463463374607431768211455),
+    ///     );
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    #[inline]
+    pub fn integer_from_u128(&self, n: u128) -> Integer {
+        if n <= u64::MAX as u128 {
+            self.integer_from_u64(n as u64)
+        } else {
+            self.module_kernel()
+                .funcall("Integer", (n.to_string(),))
+                .unwrap()
+        }
+    }
 }
 
 /// A type wrapping either a [`Fixnum`] or a [`RBignum`].
@@ -330,6 +394,46 @@ impl Integer {
         }
     }
 
+    /// Convert `self` to an `i128`. Returns `Err` if `self` is out of range for
+    /// `i128`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{eval, Integer};
+    /// # let _cleanup = unsafe { magnus::embed::init() };
+    ///
+    /// assert_eq!(
+    ///     eval::<Integer>("170141183460469231731687303715884105727")
+    ///         .unwrap()
+    ///         .to_i128()
+    ///         .unwrap(),
+    ///     170141183460469231731687303715884105727
+    /// );
+    /// assert_eq!(
+    ///     eval::<Integer>("-170141183460469231731687303715884105728")
+    ///         .unwrap()
+    ///         .to_i128()
+    ///         .unwrap(),
+    ///     -170141183460469231731687303715884105728
+    /// );
+    /// assert!(eval::<Integer>("170141183460469231731687303715884105728")
+    ///     .unwrap()
+    ///     .to_i128()
+    ///     .is_err());
+    /// assert!(eval::<Integer>("-170141183460469231731687303715884105729")
+    ///     .unwrap()
+    ///     .to_i128()
+    ///     .is_err());
+    /// ```
+    #[inline]
+    pub fn to_i128(self) -> Result<i128, Error> {
+        match self.integer_type() {
+            IntegerType::Fixnum(fix) => Ok(fix.to_i128()),
+            IntegerType::Bignum(big) => big.to_i128(),
+        }
+    }
+
     /// Convert `self` to an `isize`. Returns `Err` if `self` is out of range
     /// for `isize`.
     ///
@@ -464,6 +568,36 @@ impl Integer {
         }
     }
 
+    /// Convert `self` to a `u128`. Returns `Err` if `self` is negative or out of
+    /// range for `u128`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{eval, Integer};
+    /// # let _cleanup = unsafe { magnus::embed::init() };
+    ///
+    /// assert_eq!(
+    ///     eval::<Integer>("340282366920938463463374607431768211455")
+    ///         .unwrap()
+    ///         .to_u128()
+    ///         .unwrap(),
+    ///     340282366920938463463374607431768211455
+    /// );
+    /// assert!(eval::<Integer>("-1").unwrap().to_u128().is_err());
+    /// assert!(eval::<Integer>("340282366920938463463374607431768211456")
+    ///     .unwrap()
+    ///     .to_u128()
+    ///     .is_err());
+    /// ```
+    #[inline]
+    pub fn to_u128(self) -> Result<u128, Error> {
+        match self.integer_type() {
+            IntegerType::Fixnum(fix) => fix.to_u128(),
+            IntegerType::Bignum(big) => big.to_u128(),
+        }
+    }
+
     /// Convert `self` to a `usize`. Returns `Err` if `self` is negative or out
     /// of range for `usize`.
     ///