code_ownership 2.1.0 → 2.1.1

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

@@ -589,7 +589,7 @@ impl RString {
 
     /// Create a new Ruby string that is a frozen copy of `s`.
     ///
-    /// This can be used to get a copy of a string that is guranteed not to be
+    /// This can be used to get a copy of a string that is guaranteed not to be
     /// modified while you are referencing it.
     ///
     /// # Examples
@@ -622,7 +622,7 @@ impl RString {
     /// 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
     ///
@@ -632,7 +632,7 @@ impl RString {
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let s = ruby.str_new("example");
     ///     // safe as we don't give Ruby the chance to mess with the string while
-    ///     // we hold a refrence to the slice.
+    ///     // we hold a reference to the slice.
     ///     unsafe { assert_eq!(s.as_slice(), [101, 120, 97, 109, 112, 108, 101]) };
     ///
     ///     Ok(())
@@ -680,7 +680,7 @@ impl RString {
     /// }
     /// # Ruby::init(example).unwrap()
     /// ```
-    pub unsafe fn codepoints(&self) -> Codepoints {
+    pub unsafe fn codepoints(&self) -> Codepoints<'_> {
         Codepoints {
             slice: self.as_slice(),
             encoding: self.enc_get().into(),
@@ -724,7 +724,7 @@ impl RString {
     /// }
     /// # Ruby::init(example).unwrap()
     /// ```
-    pub unsafe fn char_bytes(&self) -> CharBytes {
+    pub unsafe fn char_bytes(&self) -> CharBytes<'_> {
         CharBytes {
             slice: self.as_slice(),
             encoding: self.enc_get().into(),
@@ -800,7 +800,7 @@ impl RString {
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let s: RString = eval!(ruby, r#""café".encode("ISO-8859-1")"#)?;
     ///     // safe as we don't give Ruby the chance to mess with the string while
-    ///     // we hold a refrence to the slice.
+    ///     // we hold a reference to the slice.
     ///     unsafe { assert_eq!(s.as_slice(), &[99, 97, 102, 233]) };
     ///     let e = s.conv_enc(ruby.utf8_encoding())?;
     ///     unsafe { assert_eq!(e.as_slice(), &[99, 97, 102, 195, 169]) };
@@ -1034,7 +1034,7 @@ impl RString {
     /// ensure this does not happen.
     ///
     /// Ruby must not be allowed to garbage collect or modify `self` while a
-    /// refrence to the str is held.
+    /// reference to the str is held.
     ///
     /// # Examples
     ///
@@ -1044,7 +1044,7 @@ impl RString {
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let s = ruby.str_new("example");
     ///     // safe as we don't give Ruby the chance to mess with the string while
-    ///     // we hold a refrence to the slice.
+    ///     // we hold a reference to the slice.
     ///     unsafe { assert_eq!(s.test_as_str().unwrap(), "example") };
     ///
     ///     Ok(())
@@ -1067,7 +1067,7 @@ impl RString {
     /// ensure this does not happen.
     ///
     /// Ruby must not be allowed to garbage collect or modify `self` while a
-    /// refrence to the str is held.
+    /// reference to the str is held.
     ///
     /// # Examples
     ///
@@ -1077,7 +1077,7 @@ impl RString {
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let s = ruby.str_new("example");
     ///     // safe as we don't give Ruby the chance to mess with the string while
-    ///     // we hold a refrence to the slice.
+    ///     // we hold a reference to the slice.
     ///     unsafe { assert_eq!(s.as_str()?, "example") };
     ///
     ///     Ok(())
@@ -1100,7 +1100,7 @@ impl RString {
 
     unsafe fn as_str_unconstrained<'a>(self) -> Result<&'a str, Error> {
         self.test_as_str_unconstrained().ok_or_else(|| {
-            let msg: Cow<'static, str> = if self.is_utf8_compatible_encoding() {
+            let msg: Cow<'static, str> = if !self.is_utf8_compatible_encoding() {
                 format!(
                     "expected utf-8, got {}",
                     RbEncoding::from(self.enc_get()).name()
@@ -1124,7 +1124,7 @@ impl RString {
     /// ensure this does not happen.
     ///
     /// Ruby must not be allowed to garbage collect or modify `self` while a
-    /// refrence to the str is held.
+    /// reference to the str is held.
     ///
     /// # Examples
     ///
@@ -1134,7 +1134,7 @@ impl RString {
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
     ///     let s = ruby.str_new("example");
     ///     // safe as we don't give Ruby the chance to mess with the string while
-    ///     // we hold a refrence to the slice.
+    ///     // we hold a reference to the slice.
     ///     unsafe { assert_eq!(s.to_string_lossy(), "example") };
     ///
     ///     Ok(())
@@ -1165,14 +1165,13 @@ impl RString {
     /// ```
     pub fn to_string(self) -> Result<String, Error> {
         let handle = Ruby::get_with(self);
-        let utf8 = if self.is_utf8_compatible_encoding() {
-            self
-        } else {
-            self.conv_enc(handle.utf8_encoding())?
-        };
-        str::from_utf8(unsafe { utf8.as_slice() })
-            .map(ToOwned::to_owned)
-            .map_err(|e| Error::new(handle.exception_encoding_error(), format!("{}", e)))
+        unsafe {
+            if let Some(str) = self.test_as_str() {
+                Ok(str.to_owned())
+            } else {
+                Ok(self.conv_enc(handle.utf8_encoding())?.as_str()?.to_owned())
+            }
+        }
     }
 
     /// Returns `self` as an owned Rust `Bytes`.
@@ -1261,10 +1260,6 @@ impl RString {
     /// are usually string literals with the in files with the
     /// `# frozen_string_literal: true` 'magic comment'.
     ///
-    /// Interned strings won't be garbage collected or modified, so should be
-    /// safe to store on the heap or hold a `&str` refrence to. See
-    /// [`as_interned_str`](RString::as_interned_str).
-    ///
     /// # Examples
     ///
     /// ```
@@ -1303,61 +1298,22 @@ impl RString {
         }
     }
 
-    /// Returns `Some(FString)` if self is interned, `None` otherwise.
-    ///
-    /// Interned strings won't be garbage collected or modified, so should be
-    /// safe to store on the heap or hold a `&str` refrence to. The `FString`
-    /// type returned by this function provides a way to encode this property
-    /// into the type system, and provides safe methods to access the string
-    /// as a `&str` or slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use magnus::{eval, Error, RString, Ruby};
-    ///
-    /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let s: RString = eval!(
-    ///         ruby,
-    ///         r#"
-    ///             ## frozen_string_literal: true
-    ///
-    ///             "example"
-    ///         "#
-    ///     )?;
-    ///     assert!(s.as_interned_str().is_some());
-    ///
-    ///     Ok(())
-    /// }
-    /// # Ruby::init(example).unwrap()
-    /// ```
+    /// Interns `self`, returning an interned string.
     ///
-    /// ```
-    /// use magnus::{eval, Error, RString, Ruby};
+    /// Finds or creates an interned string, modifying `self` so that its
+    /// parent is the returned string.
     ///
-    /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let s: RString = eval!(ruby, r#""example""#)?;
-    ///     assert!(s.as_interned_str().is_none());
-    ///
-    ///     Ok(())
-    /// }
-    /// # Ruby::init(example).unwrap()
-    /// ```
-    pub fn as_interned_str(self) -> Option<FString> {
-        self.is_interned().then(|| FString(self))
-    }
-
-    /// Interns self and returns a [`FString`]. Be aware that once interned a
-    /// string will never be garbage collected.
+    /// Interned strings with the same value will use the same backing memory.
     ///
     /// # Examples
     ///
     /// ```
-    /// use magnus::{Error, Ruby};
+    /// use magnus::{rb_assert, Error, Ruby};
     ///
     /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let fstring = ruby.str_new("example").to_interned_str();
-    ///     assert_eq!(fstring.as_str()?, "example");
+    ///     let example = ruby.str_new("example");
+    ///     let interned = example.to_interned_str();
+    ///     rb_assert!("interned == example", interned, example);
     ///
     ///     Ok(())
     /// }
@@ -1365,12 +1321,8 @@ impl RString {
     /// ```
     #[cfg(any(ruby_gte_3_0, docsrs))]
     #[cfg_attr(docsrs, doc(cfg(ruby_gte_3_0)))]
-    pub fn to_interned_str(self) -> FString {
-        unsafe {
-            FString(RString::from_rb_value_unchecked(rb_str_to_interned_str(
-                self.as_rb_value(),
-            )))
-        }
+    pub fn to_interned_str(self) -> RString {
+        unsafe { RString::from_rb_value_unchecked(rb_str_to_interned_str(self.as_rb_value())) }
     }
 
     /// Mutate `self`, adding `other` to the end. Errors if `self` and
@@ -1981,165 +1933,13 @@ impl TryConvert for RString {
     }
 }
 
-/// FString contains an RString known to be interned.
-///
-/// Interned strings won't be garbage collected or modified, so should be
-/// safe to store on the heap or hold a `&str` refrence to. `FString` provides
-/// a way to encode this property into the type system, and provides safe
-/// methods to access the string as a `&str` or slice.
-#[derive(Clone, Copy)]
-#[repr(transparent)]
-pub struct FString(RString);
-
-impl FString {
-    /// Returns the interned string as a [`RString`].
-    pub fn as_r_string(self) -> RString {
-        self.0
-    }
-
-    /// Returns the interned string as a slice of bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use magnus::{eval, Error, RString, Ruby};
-    ///
-    /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let s: RString = eval!(
-    ///         ruby,
-    ///         r#"
-    ///             ## frozen_string_literal: true
-    ///
-    ///             "example"
-    ///         "#
-    ///     )?;
-    ///     let fstring = s.as_interned_str().unwrap();
-    ///     assert_eq!(fstring.as_slice(), &[101, 120, 97, 109, 112, 108, 101]);
-    ///
-    ///     Ok(())
-    /// }
-    /// # Ruby::init(example).unwrap()
-    /// ```
-    pub fn as_slice(self) -> &'static [u8] {
-        unsafe { self.as_r_string().as_slice_unconstrained() }
-    }
-
-    /// Returns the interned string as a `&str` or `None` string contains
-    /// invliad UTF-8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use magnus::{eval, Error, RString, Ruby};
-    ///
-    /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let s: RString = eval!(
-    ///         ruby,
-    ///         r#"
-    ///             ## frozen_string_literal: true
-    ///
-    ///             "example"
-    ///         "#
-    ///     )?;
-    ///     let fstring = s.as_interned_str().unwrap();
-    ///     assert_eq!(fstring.test_as_str().unwrap(), "example");
-    ///
-    ///     Ok(())
-    /// }
-    /// # Ruby::init(example).unwrap()
-    /// ```
-    pub fn test_as_str(self) -> Option<&'static str> {
-        unsafe { self.as_r_string().test_as_str_unconstrained() }
-    }
-
-    /// Returns the interned string as a `&str`. Errors if the string contains
-    /// invliad UTF-8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use magnus::{eval, Error, RString, Ruby};
-    ///
-    /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let s: RString = eval!(
-    ///         ruby,
-    ///         r#"
-    ///             ## frozen_string_literal: true
-    ///
-    ///             "example"
-    ///         "#
-    ///     )?;
-    ///     let fstring = s.as_interned_str().unwrap();
-    ///     assert_eq!(fstring.as_str()?, "example");
-    ///
-    ///     Ok(())
-    /// }
-    /// # Ruby::init(example).unwrap()
-    /// ```
-    pub fn as_str(self) -> Result<&'static str, Error> {
-        unsafe { self.as_r_string().as_str_unconstrained() }
-    }
-
-    /// Returns interned string as a Rust string, ignoring the Ruby encoding
-    /// and dropping any non-UTF-8 characters. If the string is valid UTF-8
-    /// this will return a `&str` reference.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use magnus::{eval, Error, RString, Ruby};
-    ///
-    /// fn example(ruby: &Ruby) -> Result<(), Error> {
-    ///     let s: RString = eval!(
-    ///         ruby,
-    ///         r#"
-    ///             ## frozen_string_literal: true
-    ///
-    ///             "example"
-    ///         "#
-    ///     )?;
-    ///     let fstring = s.as_interned_str().unwrap();
-    ///     assert_eq!(fstring.to_string_lossy(), "example");
-    ///
-    ///     Ok(())
-    /// }
-    /// # Ruby::init(example).unwrap()
-    /// ```
-    pub fn to_string_lossy(self) -> Cow<'static, str> {
-        String::from_utf8_lossy(self.as_slice())
-    }
-}
-
-impl fmt::Display for FString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", unsafe { self.as_r_string().to_s_infallible() })
-    }
-}
-
-impl fmt::Debug for FString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_r_string().inspect())
-    }
-}
-
-impl IntoValue for FString {
-    #[inline]
-    fn into_value_with(self, handle: &Ruby) -> Value {
-        self.as_r_string().into_value_with(handle)
-    }
-}
-
-unsafe impl private::ReprValue for FString {}
-
-impl ReprValue for FString {}
-
 /// An iterator over a Ruby string's codepoints.
 pub struct Codepoints<'a> {
     slice: &'a [u8],
     encoding: RbEncoding,
 }
 
-impl<'a> Iterator for Codepoints<'a> {
+impl Iterator for Codepoints<'_> {
     type Item = Result<u32, Error>;
 
     fn next(&mut self) -> Option<Self::Item> {

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

@@ -1,6 +1,8 @@
-use std::{fmt, ptr::NonNull};
+use std::fmt;
 
-use rb_sys::{self, rb_check_typeddata, rb_data_typed_object_wrap, ruby_value_type, VALUE};
+use rb_sys::{
+    self, rb_check_typeddata, rb_data_typed_object_wrap, ruby_value_type, RTYPEDDATA_P, VALUE,
+};
 
 use crate::{
     class::RClass,
@@ -196,13 +198,8 @@ impl RTypedData {
     #[inline]
     pub fn from_value(val: Value) -> Option<Self> {
         unsafe {
-            (val.rb_type() == ruby_value_type::RUBY_T_DATA)
-                .then(|| NonNull::new_unchecked(val.as_rb_value() as *mut rb_sys::RTypedData))
-                .and_then(|typed_data| {
-                    let typed_flag = typed_data.as_ref().typed_flag;
-                    (typed_flag != 0 && typed_flag <= 3)
-                        .then(|| Self(NonZeroValue::new_unchecked(val)))
-                })
+            (val.rb_type() == ruby_value_type::RUBY_T_DATA && RTYPEDDATA_P(val.as_rb_value()))
+                .then(|| Self::from_rb_value_unchecked(val.as_rb_value()))
         }
     }
 

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

@@ -22,7 +22,7 @@
 //! # Safety
 //!
 //! The unsafe functions in this module are capable of producing values that
-//! break the saftey guarantees of almost every other function in Magnus. Use
+//! break the safety guarantees of almost every other function in Magnus. Use
 //! them with care.
 use std::panic::UnwindSafe;
 
@@ -68,7 +68,7 @@ pub trait FromRawValue {
     ///
     /// You must only supply a valid [`VALUE`] obtained from [rb-sys](rb_sys)
     /// to this function. Using a invalid [`Value`] produced from this
-    /// function will void all saftey guarantees provided by Magnus.
+    /// function will void all safety guarantees provided by Magnus.
     ///
     /// # Examples
     ///
@@ -135,7 +135,7 @@ pub trait FromRawId {
     ///
     /// You must only supply a valid, non-zero [`ID`] obtained from
     /// [rb-sys](rb_sys) to this function. Using a invalid [`Id`] produced
-    /// from this function will void all saftey guarantees provided by
+    /// from this function will void all safety guarantees provided by
     /// Magnus.
     ///
     /// # Examples
@@ -169,7 +169,7 @@ impl AsRawId for Id {
 
 impl FromRawId for Id {
     unsafe fn from_raw(id: ID) -> Id {
-        Id::from_rb_id(id.into())
+        Id::from_rb_id(id)
     }
 }
 

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

@@ -5,7 +5,7 @@
 //! [`method`](crate::method!) macro, allow defining methods with a fixed
 //! number of positional arguments, or an unbounded collection of arguments as
 //! a slice or Ruby array. The functions in this module allow for more complex
-//! agument handling.
+//! argument handling.
 //!
 //! Ruby arguments can be classified as follows:
 //! ``` text
@@ -440,7 +440,7 @@ impl<T> ScanArgsBlock for T where T: private::ScanArgsBlock {}
 /// signatures, including optional arguments and 'splats'.
 ///
 /// The format of the arguments required is driven by the types in the return
-/// value. The stuct [`Args`] is returned but the types of its fields are
+/// value. The struct [`Args`] is returned but the types of its fields are
 /// determined by type parameters. The type `()` is used as a placeholder when
 /// a set of arguments is not required.
 ///
@@ -645,7 +645,7 @@ pub struct KwArgs<Req, Opt, Splat> {
 /// Extracts `required` and `optional` arguments from the given `kw` hash.
 ///
 /// The format of the arguments required is driven by the types in the return
-/// value. The stuct [`KwArgs`] is returned but the types of its fields are
+/// value. The struct [`KwArgs`] is returned but the types of its fields are
 /// determined by type parameters. The type `()` is used as a placeholder when
 /// a set of arguments is not required.
 ///

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

@@ -1,11 +1,13 @@
 use std::{fmt, mem::size_of, os::raw::c_void, slice, time::Duration};
 
+#[allow(deprecated)]
+use rb_sys::rb_thread_fd_close;
 use rb_sys::{
     rb_data_typed_object_wrap, rb_thread_alone, rb_thread_check_ints, rb_thread_create,
-    rb_thread_current, rb_thread_fd_close, rb_thread_fd_writable, rb_thread_interrupted,
-    rb_thread_kill, rb_thread_local_aref, rb_thread_local_aset, rb_thread_main, rb_thread_run,
-    rb_thread_schedule, rb_thread_sleep_deadly, rb_thread_sleep_forever, rb_thread_wait_fd,
-    rb_thread_wait_for, rb_thread_wakeup, rb_thread_wakeup_alive, timeval, VALUE,
+    rb_thread_current, rb_thread_fd_writable, rb_thread_interrupted, rb_thread_kill,
+    rb_thread_local_aref, rb_thread_local_aset, rb_thread_main, rb_thread_run, rb_thread_schedule,
+    rb_thread_sleep_deadly, rb_thread_sleep_forever, rb_thread_wait_fd, rb_thread_wait_for,
+    rb_thread_wakeup, rb_thread_wakeup_alive, timeval, VALUE,
 };
 
 use crate::{
@@ -265,13 +267,17 @@ impl Ruby {
     /// has been closed.
     ///
     /// Blocks until all threads waiting on `fd` have woken up.
+    #[deprecated(note = "No-op as of Ruby 3.5")]
     pub fn thread_fd_close<T>(&self, fd: &T) -> Result<(), Error>
     where
         T: AsRawFd,
     {
         let fd = fd.as_raw_fd();
         protect(|| {
-            unsafe { rb_thread_fd_close(fd) };
+            unsafe {
+                #[allow(deprecated)]
+                rb_thread_fd_close(fd)
+            };
             self.qnil()
         })?;
         Ok(())
@@ -303,7 +309,7 @@ impl Ruby {
 
     /// Blocks for the given period of time.
     ///
-    /// Returns an error if sleep is intrrupted by a signal.
+    /// Returns an error if sleep is interrupted by a signal.
     ///
     /// # Examples
     ///
@@ -337,7 +343,7 @@ impl Ruby {
 
     /// Blocks indefinitely.
     ///
-    /// Returns an error if sleep is intrrupted by a signal.
+    /// Returns an error if sleep is interrupted by a signal.
     pub fn thread_sleep_forever(&self) -> Result<(), Error> {
         protect(|| {
             unsafe { rb_thread_sleep_forever() };
@@ -352,7 +358,7 @@ impl Ruby {
     /// deadlock checker is triggered.
     /// See also [`thread_sleep_forever`](Ruby::thread_sleep_forever).
     ///
-    /// Returns an error if sleep is intrrupted by a signal.
+    /// Returns an error if sleep is interrupted by a signal.
     pub fn thread_sleep_deadly(&self) -> Result<(), Error> {
         protect(|| {
             unsafe { rb_thread_sleep_deadly() };
@@ -459,7 +465,7 @@ impl Thread {
     ///
     /// See also [`Thread::wakeup`] and [`Thread::wakeup_alive`].
     ///
-    /// There is not gurantee that `self` will be the next thread scheduled.
+    /// There is no guarantee that `self` will be the next thread scheduled.
     ///
     /// Returns an error `self` is dead.
     pub fn run(self) -> Result<(), Error> {
@@ -641,7 +647,7 @@ impl TryConvert for Thread {
 
 /// Wrap a closure in a Ruby object with no class.
 ///
-/// This effectivly makes the closure's lifetime managed by Ruby. It will be
+/// This effectively makes the closure's lifetime managed by Ruby. It will be
 /// dropped when the returned `Value` is garbage collected.
 fn wrap_closure<F, R>(func: F) -> (*mut Option<F>, Value)
 where