code_ownership 2.1.0 → 2.1.1

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

@@ -66,7 +66,7 @@ mod private {
         }
     }
 
-    seq!(N in 0..=16 {
+    seq!(N in 0..=15 {
         impl_method!(N);
     });
 
@@ -222,7 +222,7 @@ mod private {
     }
 }
 
-/// Trait implemented for function pointers that can be registed as Ruby
+/// Trait implemented for function pointers that can be registered as Ruby
 /// methods.
 ///
 /// While it is possible to directly write functions that will automatically
@@ -242,9 +242,9 @@ mod private {
 /// |     1 | `unsafe extern "C" fn(Value, Value) -> Value;`               |
 /// |     2 | `unsafe extern "C" fn(Value, Value, Value) -> Value;`        |
 /// |   ... | ...                                                          |
-/// |    16 | ...                                                          |
+/// |    15 | ...                                                          |
 ///
-/// note: for arity 0..=16 the number of arguments is 1 greater than the arity,
+/// note: for arity 0..=15 the number of arguments is 1 greater than the arity,
 /// due to the initial `self` argument.
 pub trait Method: private::Method {}
 
@@ -265,7 +265,7 @@ impl<T> Method for T where T: private::Method {}
 ///
 /// where `I` implements `Iterator<Item = T>` and `T` implements [`IntoValue`].
 ///
-/// When is `Err(magnus::Error)` returned to Ruby it will be conveted to and
+/// When is `Err(magnus::Error)` returned to Ruby it will be converted to and
 /// raised as a Ruby exception.
 ///
 /// [`Yield`], [`YieldValues`], and [`YieldSplat`] allow returning a Rust
@@ -286,7 +286,7 @@ impl<T> ReturnValue for T where T: private::ReturnValue {}
 /// * `()`
 /// * `Result<(), magnus::Error>`
 ///
-/// When is `Err(magnus::Error)` returned to Ruby it will be conveted to and
+/// When is `Err(magnus::Error)` returned to Ruby it will be converted to and
 /// raised as a Ruby exception.
 ///
 /// Note: functions without a specified return value will return `()`. `()`
@@ -304,7 +304,7 @@ impl<T> InitReturn for T where T: private::InitReturn {}
 ///
 /// where `T` implements [`IntoValue`].
 ///
-/// When is `Err(magnus::Error)` returned to Ruby it will be conveted to and
+/// When is `Err(magnus::Error)` returned to Ruby it will be converted to and
 /// raised as a Ruby exception.
 ///
 /// Note: functions without a specified return value will return `()`. `()`
@@ -771,7 +771,7 @@ macro_rules! method_n {
     }
 }
 
-seq!(N in 0..=16 {
+seq!(N in 0..=15 {
     method_n!(Method~N, RubyMethod~N, N);
 });
 
@@ -783,8 +783,8 @@ seq!(N in 0..=16 {
 /// [`define_method`](crate::module::Module::define_method).
 ///
 /// Ruby code implicitly always has a `self` parameter available. In the
-/// extention API this is passed explicitly. As a result there is always an
-/// extra `self` argument before the arguments explitly passed in Ruby, and the
+/// extension API this is passed explicitly. As a result there is always an
+/// extra `self` argument before the arguments explicitly passed in Ruby, and the
 /// number of Rust argument will be one more than the Ruby arity.
 ///
 /// The values `-2` and `-1` for `arity` have special meaning. Both indicate
@@ -1257,51 +1257,8 @@ macro_rules! method {
             $crate::Value,
         ) -> $crate::Value
     }};
-    ($name:expr, 16) => {{
-        unsafe extern "C" fn anon(
-            rb_self: $crate::Value,
-            a: $crate::Value,
-            b: $crate::Value,
-            c: $crate::Value,
-            d: $crate::Value,
-            e: $crate::Value,
-            f: $crate::Value,
-            g: $crate::Value,
-            h: $crate::Value,
-            i: $crate::Value,
-            j: $crate::Value,
-            k: $crate::Value,
-            l: $crate::Value,
-            m: $crate::Value,
-            n: $crate::Value,
-            o: $crate::Value,
-            p: $crate::Value,
-        ) -> $crate::Value {
-            use $crate::method::{Method16, RubyMethod16};
-            $name.call_handle_error(rb_self, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
-        }
-        anon as unsafe extern "C" fn(
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-        ) -> $crate::Value
-    }};
     ($name:expr, $arity:expr) => {
-        compile_error!("arity must be an integer literal between -2..=16")
+        compile_error!("arity must be an integer literal between -2..=15")
     };
 }
 
@@ -1554,7 +1511,7 @@ macro_rules! function_n {
     }
 }
 
-seq!(N in 0..=16 {
+seq!(N in 0..=15 {
     function_n!(Function~N, RubyFunction~N, N);
 });
 
@@ -1567,7 +1524,7 @@ seq!(N in 0..=16 {
 /// [`define_method`](crate::module::Module::define_method).
 ///
 /// Ruby code implicitly always has a `self` parameter available. In the
-/// extention API this is passed explicitly. The wrapper this macro generates
+/// extension API this is passed explicitly. The wrapper this macro generates
 /// ignores that argument, and does not pass it to the wrapped function.
 ///
 /// The values `-2` and `-1` for `arity` have special meaning. Both indicate
@@ -2036,50 +1993,7 @@ macro_rules! function {
             $crate::Value,
         ) -> $crate::Value
     }};
-    ($name:expr, 16) => {{
-        unsafe extern "C" fn anon(
-            rb_self: $crate::Value,
-            a: $crate::Value,
-            b: $crate::Value,
-            c: $crate::Value,
-            d: $crate::Value,
-            e: $crate::Value,
-            f: $crate::Value,
-            g: $crate::Value,
-            h: $crate::Value,
-            i: $crate::Value,
-            j: $crate::Value,
-            k: $crate::Value,
-            l: $crate::Value,
-            m: $crate::Value,
-            n: $crate::Value,
-            o: $crate::Value,
-            p: $crate::Value,
-        ) -> $crate::Value {
-            use $crate::method::{Function16, RubyFunction16};
-            $name.call_handle_error(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
-        }
-        anon as unsafe extern "C" fn(
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-            $crate::Value,
-        ) -> $crate::Value
-    }};
     ($name:expr, $arity:expr) => {
-        compile_error!("arity must be an integer literal between -2..=16")
+        compile_error!("arity must be an integer literal between -2..=15")
     };
 }

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

@@ -60,7 +60,7 @@ impl Ruby {
 ///
 /// 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.
 /// See [`Ruby`](Ruby#rmodule) for methods to create an `RModule`.

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

@@ -107,7 +107,7 @@ impl Mutex {
         unsafe { Value::new(rb_mutex_locked_p(self.as_rb_value())).to_bool() }
     }
 
-    /// Attempts to aquire the lock.
+    /// Attempts to acquire the lock.
     ///
     /// This method does not block. Returns true if the lock can be acquired,
     /// false otherwise.

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

@@ -1087,7 +1087,7 @@ impl RArray {
     /// ensure this does not happen.
     ///
     /// Ruby must not be allowed to garbage collect or modify `self` while a
-    /// refrence to the slice is held.
+    /// reference to the slice is held.
     ///
     /// # Examples
     ///
@@ -1097,7 +1097,7 @@ impl RArray {
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let ary: RArray = ruby.eval("[1, 2, 3, 4, 5]")?;
     ///     // must not call any Ruby api that may modify ary while we have a
-    ///     // refrence to the return value of ::from_slice()
+    ///     // reference to the return value of ::from_slice()
     ///     unsafe {
     ///         let middle = ruby.ary_new_from_values(&ary.as_slice()[1..4]);
     ///         rb_assert!(ruby, "middle == [2, 3, 4]", middle);

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

@@ -4,8 +4,8 @@ use std::{
 };
 
 use rb_sys::{
-    rb_ll2inum, rb_num2ll, rb_num2long, rb_num2ull, rb_num2ulong, rb_ull2inum, ruby_fl_type,
-    ruby_value_type, VALUE,
+    rb_big2str, rb_ll2inum, rb_num2ll, rb_num2long, rb_num2ull, rb_num2ulong, rb_ull2inum,
+    ruby_fl_type, ruby_value_type, VALUE,
 };
 
 use crate::{
@@ -18,7 +18,7 @@ use crate::{
         private::{self, ReprValue as _},
         Fixnum, NonZeroValue, ReprValue, Value,
     },
-    Ruby,
+    RString, Ruby,
 };
 
 /// # `RBignum`
@@ -250,6 +250,57 @@ impl RBignum {
         Ok(res)
     }
 
+    /// Convert `self` to an `i128`. Returns `Err` if `self` is out of range for
+    /// `i128`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{eval, RBignum};
+    /// # let _cleanup = unsafe { magnus::embed::init() };
+    ///
+    /// assert_eq!(
+    ///     eval::<RBignum>("170141183460469231731687303715884105727")
+    ///         .unwrap()
+    ///         .to_i128()
+    ///         .unwrap(),
+    ///     170141183460469231731687303715884105727
+    /// );
+    /// assert_eq!(
+    ///     eval::<RBignum>("-170141183460469231731687303715884105728")
+    ///         .unwrap()
+    ///         .to_i128()
+    ///         .unwrap(),
+    ///     -170141183460469231731687303715884105728
+    /// );
+    /// assert!(eval::<RBignum>("170141183460469231731687303715884105728")
+    ///     .unwrap()
+    ///     .to_i128()
+    ///     .is_err());
+    /// assert!(eval::<RBignum>("-170141183460469231731687303715884105729")
+    ///     .unwrap()
+    ///     .to_i128()
+    ///     .is_err());
+    /// ```
+    pub fn to_i128(self) -> Result<i128, Error> {
+        debug_assert_value!(self);
+        let handle = Ruby::get_with(self);
+        let mut res = 0;
+        protect(|| {
+            unsafe { res = rb_big2str(self.as_rb_value(), 10) };
+            handle.qnil()
+        })?;
+        unsafe { RString::from_rb_value_unchecked(res).as_str() }
+            .unwrap()
+            .parse::<i128>()
+            .map_err(|_| {
+                Error::new(
+                    handle.exception_range_error(),
+                    "bignum too big to convert into `i128`",
+                )
+            })
+    }
+
     /// Convert `self` to an `isize`. Returns `Err` if `self` is out of range
     /// for `isize`.
     ///
@@ -357,6 +408,52 @@ impl RBignum {
         Ok(res)
     }
 
+    /// Convert `self` to a `u128`. Returns `Err` if `self` is negative or out
+    /// of range for `u128`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use magnus::{eval, RBignum};
+    /// # let _cleanup = unsafe { magnus::embed::init() };
+    ///
+    /// assert_eq!(
+    ///     eval::<RBignum>("340282366920938463463374607431768211455")
+    ///         .unwrap()
+    ///         .to_u128()
+    ///         .unwrap(),
+    ///     340282366920938463463374607431768211455
+    /// );
+    /// assert!(eval::<RBignum>("340282366920938463463374607431768211456")
+    ///     .unwrap()
+    ///     .to_u128()
+    ///     .is_err());
+    /// ```
+    pub fn to_u128(self) -> Result<u128, Error> {
+        debug_assert_value!(self);
+        let handle = Ruby::get_with(self);
+        if self.is_negative() {
+            return Err(Error::new(
+                handle.exception_range_error(),
+                "can't convert negative integer to unsigned",
+            ));
+        }
+        let mut res = 0;
+        protect(|| {
+            unsafe { res = rb_big2str(self.as_rb_value(), 10) };
+            handle.qnil()
+        })?;
+        unsafe { RString::from_rb_value_unchecked(res).as_str() }
+            .unwrap()
+            .parse::<u128>()
+            .map_err(|_| {
+                Error::new(
+                    handle.exception_range_error(),
+                    "bignum too big to convert into `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}/src/r_hash.rs

@@ -1,6 +1,7 @@
 //! Types and functions for working with Ruby’s Hash class.
 
 use std::{
+    collections::BTreeMap,
     collections::HashMap,
     convert::Infallible,
     fmt,
@@ -612,7 +613,7 @@ impl RHash {
             ))
         })
         .ok()
-        .and_then(|v| (!v.is_undef()).then(|| v))
+        .and_then(|v| (!v.is_undef()).then_some(v))
     }
 
     /// Return the value for `key`, converting it to `U`.
@@ -804,6 +805,46 @@ impl RHash {
         Ok(map)
     }
 
+    /// Return `self` converted to a Rust [`BTreeMap`].
+    ///
+    /// This will only convert to a map of 'owned' Rust native types. The types
+    /// representing Ruby objects can not be stored in a heap-allocated
+    /// datastructure like a [`BTreeMap`] as they are hidden from the mark phase
+    /// of Ruby's garbage collector, and thus may be prematurely garbage
+    /// collected in the following sweep phase.
+    ///
+    /// Errors if the conversion of any key or value fails.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::BTreeMap;
+    ///
+    /// use magnus::{Error, RHash, Ruby};
+    ///
+    /// fn example(ruby: &Ruby) -> Result<(), Error> {
+    ///     let r_hash: RHash = ruby.eval(r#"{"answer" => 42}"#)?;
+    ///     let mut hash_map = BTreeMap::new();
+    ///     hash_map.insert(String::from("answer"), 42);
+    ///     assert_eq!(r_hash.to_btree_map()?, hash_map);
+    ///
+    ///     Ok(())
+    /// }
+    /// # Ruby::init(example).unwrap()
+    /// ```
+    pub fn to_btree_map<K, V>(self) -> Result<BTreeMap<K, V>, Error>
+    where
+        K: TryConvertOwned + Eq + Hash + Ord,
+        V: TryConvertOwned,
+    {
+        let mut map = BTreeMap::new();
+        self.foreach(|key, value| {
+            map.insert(key, value);
+            Ok(ForEach::Continue)
+        })?;
+        Ok(map)
+    }
+
     /// Convert `self` to a Rust vector of key/value pairs.
     ///
     /// This will only convert to a map of 'owned' Rust native types. The types
@@ -940,6 +981,27 @@ where
 {
 }
 
+impl<K, V> IntoValue for BTreeMap<K, V>
+where
+    K: IntoValueFromNative,
+    V: IntoValueFromNative,
+{
+    fn into_value_with(self, handle: &Ruby) -> Value {
+        let hash = handle.hash_new();
+        for (k, v) in self {
+            let _ = hash.aset(k, v);
+        }
+        hash.into_value_with(handle)
+    }
+}
+
+unsafe impl<K, V> IntoValueFromNative for BTreeMap<K, V>
+where
+    K: IntoValueFromNative,
+    V: IntoValueFromNative,
+{
+}
+
 #[cfg(feature = "old-api")]
 impl<K, V> FromIterator<(K, V)> for RHash
 where