code_ownership 2.1.0 → 2.1.2

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

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

@@ -0,0 +1,230 @@
+//! Types and functions for working with Ruby IO semantics in Rust.
+//!
+//! This module provides safe wrappers and accessors for working with Ruby's IO system,
+//! including file open flags (`OpenFlags`), mode flags (`FMode`), and encoding metadata
+//! (`IoEncoding`).
+
+#[cfg(ruby_lt_3_3)]
+use rb_sys::rb_io_enc_t as rb_io_encoding;
+#[cfg(ruby_gt_3_4)]
+use rb_sys::rb_io_mode;
+#[cfg(ruby_gte_3_3)]
+use rb_sys::{rb_io_encoding, FMODE_EXTERNAL};
+use rb_sys::{
+    rb_io_extract_modeenc, OnigEncodingTypeST, FMODE_APPEND, FMODE_BINMODE, FMODE_CREATE,
+    FMODE_DUPLEX, FMODE_EXCL, FMODE_READABLE, FMODE_READWRITE, FMODE_SETENC_BY_BOM, FMODE_SYNC,
+    FMODE_TEXTMODE, FMODE_TRUNC, FMODE_TTY, FMODE_WRITABLE, VALUE,
+};
+
+use crate::{
+    encoding::{Encoding, RbEncoding},
+    error::{protect, Error},
+    value::{private::ReprValue as _, ReprValue, Value},
+    RHash, Ruby,
+};
+
+/// Wrapper for Ruby's file open flag bits (`O_*`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct OpenFlags(pub i32);
+
+impl OpenFlags {
+    /// Constructs a new set of open flags.
+    pub fn new(bits: i32) -> Self {
+        Self(bits)
+    }
+
+    /// Returns the raw flag bits.
+    pub fn bits(&self) -> i32 {
+        self.0
+    }
+
+    /// Checks if a particular flag is set.
+    pub fn contains(&self, flag: i32) -> bool {
+        self.0 & flag != 0
+    }
+}
+
+/// Ruby IO mode flags (`FMODE_*`), used to describe how a file or stream is opened.
+///
+/// These are internal Ruby VM flags describing the open mode and encoding behavior
+/// of an IO stream.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct FMode(u32);
+
+#[cfg(ruby_lt_3_3)]
+const FMODE_EXTERNAL: u32 = 65536; // this was FMODE_PREP. rb-sys doesn't include this binding.
+
+impl FMode {
+    /// File is opened as readable (`"r"`, `"r+"`, etc.)
+    pub const READ: u32 = FMODE_READABLE;
+    /// File is opened as writable (`"w"`, `"a"`, `"r+"`, etc.)
+    pub const WRITE: u32 = FMODE_WRITABLE;
+    /// File is readable and writable (`"r+"`, `"w+"`, etc.)
+    pub const READ_WRITE: u32 = FMODE_READWRITE;
+    /// File is opened in binary mode (`"b"` modifier)
+    ///
+    /// Disables newline conversions and sets default external encoding to ASCII-8BIT.
+    pub const BINARY_MODE: u32 = FMODE_BINMODE;
+    /// File is opened with sync mode (`IO#sync = true`)
+    pub const SYNC: u32 = FMODE_SYNC;
+    /// The stream is connected to a terminal/TTY
+    pub const TTY: u32 = FMODE_TTY;
+    /// Duplex stream — supports both input and output on a single handle
+    pub const DUPLEX: u32 = FMODE_DUPLEX;
+    /// Append mode — all writes go to the end of the file
+    pub const APPEND: u32 = FMODE_APPEND;
+    /// Create mode — file is created if it doesn't exist
+    pub const CREATE: u32 = FMODE_CREATE;
+    /// Exclusive mode — fail if file exists
+    pub const EXCLUSIVE: u32 = FMODE_EXCL;
+    /// Truncate the file to 0 bytes on open
+    pub const TRUNCATE: u32 = FMODE_TRUNC;
+    /// File is opened in text mode (`"t"` modifier)
+    ///
+    /// Affects encoding and newline translation on some platforms.
+    pub const TEXT_MODE: u32 = FMODE_TEXTMODE;
+    /// External encoding explicitly specified
+    pub const EXTERNAL_ENCODING: u32 = FMODE_EXTERNAL;
+    /// Set encoding by inspecting BOM (Byte Order Mark)
+    pub const BOM_ENCODING: u32 = FMODE_SETENC_BY_BOM;
+
+    /// Constructs a new `FMode` from raw bits.
+    pub fn new(bits: u32) -> Self {
+        Self(bits)
+    }
+
+    /// Check if a given flag is set.
+    pub fn contains(&self, flag: u32) -> bool {
+        self.0 & flag != 0
+    }
+
+    /// Returns the raw flag bits.
+    pub fn bits(&self) -> u32 {
+        self.0
+    }
+}
+
+/// Ruby-owned encoding metadata extracted from IO options.
+///
+/// This struct represents the result of parsing Ruby's file mode string and encoding-related
+/// options (e.g., `:external_encoding`, `:internal_encoding`, or `:encoding`) using the
+/// internal Ruby C API `rb_io_extract_modeenc`.
+///
+/// The data here includes both Ruby-side encodings and flags that affect transcoding behavior,
+/// such as BOM handling or newline modes. The optional `options` hash contains additional
+/// transcoding options as a Ruby `Hash`.
+///
+/// # Example
+///
+/// ```rust
+/// # use magnus::{Ruby, Value, RHash};
+/// # fn parse_encoding(ruby: &Ruby, mode: &mut Value, perm: &mut Value, options: &RHash) {
+/// let (_, _, encoding) = ruby.io_extract_modeenc(mode, perm, options).unwrap();
+///
+/// if let Some(ext) = &encoding.external {
+///     println!("External encoding: {}", ext);
+/// }
+///
+/// if let Some(hash) = &encoding.options {
+///     println!("Encoding options: {:?}", hash);
+/// }
+/// # }
+/// ```
+///
+/// # Safety
+///
+/// This struct should **not be stored beyond the stack frame** in which it was created.
+/// The Ruby VM may deallocate or reuse internal objects such as the `options` hash,
+/// which is **not automatically GC-pinned**. Copying this structure beyond a single
+/// call boundary can lead to undefined behavior or use-after-free.
+///
+/// Always extract the fields you need and clone or persist Ruby values separately if necessary.
+pub struct IoEncoding {
+    /// The external encoding used for reading/writing to the file or stream.
+    pub external: Option<Encoding>,
+    /// The internal encoding used for transcoding, if any.
+    pub internal: Option<Encoding>,
+    /// Encoding flags describing transcoding behavior (e.g., whether to
+    /// use BOM detection, or newline modes).
+    pub flags: i32,
+    /// A Ruby hash of encoding options passed in by the user, if present.
+    pub options: Option<RHash>,
+}
+
+/// # IO helper functions
+///
+/// See also [`IoEncoding`] type and [`FMode`] type.
+impl Ruby {
+    /// Extract open flags and IO encoding metadata from a Ruby method call.
+    ///
+    /// This wraps Ruby's `rb_io_extract_modeenc` function, which parses `mode`, `perm`, and `options`
+    /// into a combination of open flags, mode flags, and encoding metadata.
+    ///
+    /// Can raise:
+    /// - `TypeError` if passed unexpected objects (e.g., `Time`)
+    /// - `ArgError` if conflicting options are provided
+    pub fn io_extract_modeenc(
+        &self,
+        mode: &mut Value,
+        permission: &mut Value,
+        option: &RHash,
+    ) -> Result<(OpenFlags, FMode, IoEncoding), Error> {
+        // `rb_io_extract_modeenc` will fill these variables:
+        let mut oflags: std::os::raw::c_int = 0; // with O_ flags; flags are available in `File::Constants`.
+        #[cfg(ruby_lte_3_4)]
+        let mut fmode: std::os::raw::c_int = 0; // with FMODE_ flags
+        #[cfg(ruby_gt_3_4)]
+        let mut fmode: rb_io_mode = rb_io_mode::RUBY_IO_MODE_EXTERNAL; // arbitrary initialization value
+        let mut io_encoding: rb_io_encoding = unsafe { std::mem::zeroed() }; // with IO encoding options
+
+        // Can raise:
+        // - `TypeError`: Unexpected object (e.g. Time) passed.
+        // - `ArgError`: Contradiction inside of params.
+        protect(|| unsafe {
+            rb_io_extract_modeenc(
+                &mut mode.as_rb_value() as *mut _,
+                &mut permission.as_rb_value() as *mut _,
+                option.as_rb_value(),
+                &mut oflags as *mut _,
+                &mut fmode as *mut _,
+                &mut io_encoding as *mut _,
+            );
+            self.qnil()
+        })?;
+
+        // `rb_io_extract_modeenc` populated the values
+        let open_flags = OpenFlags::new(oflags as i32);
+        let fmode_flags = FMode::new(fmode as u32);
+
+        // extracts and starts to manage objects for better user experience
+        let internal: Option<Encoding> = {
+            let ptr = io_encoding.enc as *mut OnigEncodingTypeST;
+            RbEncoding::new(ptr).map(|r| r.into())
+        };
+
+        let external: Option<Encoding> = {
+            let ptr = io_encoding.enc2 as *mut OnigEncodingTypeST;
+            RbEncoding::new(ptr).map(|r| r.into())
+        };
+
+        let flags = io_encoding.ecflags;
+
+        let options = {
+            let value = Value::new(io_encoding.ecopts as VALUE);
+            if value.is_nil() {
+                None
+            } else {
+                RHash::from_value(value)
+            }
+        };
+
+        let io_encoding = IoEncoding {
+            external,
+            internal,
+            flags,
+            options,
+        };
+
+        Ok((open_flags, fmode_flags, io_encoding))
+    }
+}

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

@@ -1,4 +1,4 @@
-//! Magnus is a library for writing Ruby extentions in Rust, or running Ruby
+//! Magnus is a library for writing Ruby extensions in Rust, or running Ruby
 //! code from Rust.
 //!
 //! # Overview
@@ -345,19 +345,19 @@
 //!
 //! ## `rb_c`
 //!
-//! * `rb_call_super`: See [`call_super`].
-//! * `rb_call_super_kw`: [`call_super`].
+//! * `rb_call_super`: See [`Ruby::call_super`].
+//! * `rb_call_super_kw`: [`Ruby::call_super`].
 // * `rb_catch`:
 // * `rb_catch_obj`:
 // * `rb_category_compile_warn`:
 // * `rb_category_warn`:
 // * `rb_category_warning`:
 // * `rb_char_to_option_kcode`:
-//! * `rb_check_arity`: [`scan_args::check_arity`].
+//! * `rb_check_arity`: [`Ruby::check_arity`].
 //! * `rb_check_array_type`:  See [`TryConvert`] and [`Value::try_convert`].
 // * `rb_check_convert_type`:
 // * `rb_check_copyable`:
-// * `rb_check_frozen`:
+//! * `rb_check_frozen`: See [`ReprValue::check_frozen`].
 // * `rb_check_frozen_inline`:
 //! * `rb_check_funcall`: See [`Value::check_funcall`].
 //! * `rb_check_funcall_kw`:  [`Value::check_funcall`].
@@ -366,11 +366,11 @@
 //! * `rb_check_id_cstr`: [`Id::check`](value::Id::check).
 // * `rb_check_inheritable`:
 // * `rb_check_safe_str`:
-// * `rb_check_string_type`:
+//! * `rb_check_string_type`: See [`TryConvert`] and [`Value::try_convert`].
 //! * `rb_check_symbol`: Similar to [`StaticSymbol::check`].
 //! * `rb_check_symbol_cstr`: [`StaticSymbol::check`].
-// * `rb_check_to_float`:
-// * `rb_check_to_int`:
+//! * `rb_check_to_float`: See [`TryConvert`] and [`Value::try_convert`].
+//! * `rb_check_to_int`: See [`TryConvert`] and [`Value::try_convert`].
 // * `rb_check_to_integer`:
 // * `rb_check_type`:
 //! * `rb_check_typeddata`: See [`TryConvert`] and [`Value::try_convert`].
@@ -380,7 +380,7 @@
 // * `rb_class_get_superclass`:
 // * `rb_class_inherited_p`: [`Module::is_inherited`].
 // * `rb_class_instance_methods`:
-//! * `rb_class_name`: Simmilar to [`Value::classname`].
+//! * `rb_class_name`: Similar to [`Value::classname`].
 //! * `rb_class_new`: [`RClass::new`].
 //! * `rb_class_new_instance`: See [`RClass::new_instance`].
 //! * `rb_class_new_instance_kw`: [`RClass::new_instance`].
@@ -447,7 +447,7 @@
 // * `rb_cstr2inum`:
 // * `rb_cstr_to_dbl`:
 // * `rb_cstr_to_inum`:
-//! * `rb_current_receiver`: [`current_receiver`].
+//! * `rb_current_receiver`: [`Ruby::current_receiver`].
 // * `rb_cvar_defined`:
 // * `rb_cvar_find`:
 // * `rb_cvar_get`:
@@ -481,8 +481,8 @@
 //! * `rb_define_alias`: [`Module::define_alias`].
 // * `rb_define_alloc_func`:
 //! * `rb_define_attr`: See [`Module::define_attr`].
-//! * `rb_define_class`: [`define_class`].
-//! * `rb_define_class_id`: Simmilar to [`define_class`].
+//! * `rb_define_class`: [`Ruby::define_class`].
+//! * `rb_define_class_id`: Similar to [`Ruby::define_class`].
 //! * `rb_define_class_id_under`: [`Module::define_class`].
 //! * `rb_define_class_under`: See [`Module::define_class`].
 // * `rb_define_class_variable`:
@@ -490,20 +490,20 @@
 // * `rb_define_dummy_encoding`:
 // * `rb_define_finalizer`:
 // * `rb_define_global_const`:
-//! * `rb_define_global_function`: [`define_global_function`].
+//! * `rb_define_global_function`: [`Ruby::define_global_function`].
 // * `rb_define_hooked_variable`:
 //! * `rb_define_method`: See [`Module::define_method`].
 //! * `rb_define_method_id`: [`Module::define_method`].
-//! * `rb_define_module`: [`define_module`].
+//! * `rb_define_module`: [`Ruby::define_module`].
 //! * `rb_define_module_function`: [`RModule::define_module_function`].
-//! * `rb_define_module_id`: See [`define_module`].
+//! * `rb_define_module_id`: See [`Ruby::define_module`].
 //! * `rb_define_module_id_under`: [`Module::define_module`].
 //! * `rb_define_module_under`: See [`Module::define_module`].
 //! * `rb_define_private_method`: [`Module::define_private_method`].
 //! * `rb_define_protected_method`: [`Module::define_protected_method`].
 // * `rb_define_readonly_variable`:
 //! * `rb_define_singleton_method`: [`Object::define_singleton_method`].
-//! * `rb_define_variable`: [`define_variable`].
+//! * `rb_define_variable`: [`Ruby::define_variable`].
 // * `rb_define_virtual_variable`:
 // * `rb_deprecate_constant`:
 // * `rb_detach_process`:
@@ -658,7 +658,7 @@
 //! * `rb_eval_string`: See [`eval()`] or [`eval!`].
 //! * `rb_eval_string_protect`: [`eval()`] or [`eval!`].
 // * `rb_eval_string_wrap`:
-// * `rb_exc_fatal`:
+//! * `rb_exc_fatal`: Return an [`Error`] constructed from [`Ruby::exception_fatal`].
 // * `rb_exc_new`:
 // * `rb_exc_new_cstr`:
 // * `rb_exc_new_str`:
@@ -812,13 +812,13 @@
 //!
 //! ## `rb_g`
 //!
-//! * `rb_gc`: [`gc::start`].
-//! * `rb_gc_adjust_memory_usage`: [`gc::adjust_memory_usage`].
+//! * `rb_gc`: [`Ruby::gc_start`].
+//! * `rb_gc_adjust_memory_usage`: [`Ruby::gc_adjust_memory_usage`].
 // * `rb_gc_call_finalizer_at_exit`:
 // * `rb_gc_copy_finalizer`:
-//! * `rb_gc_count`: [`gc::count`].
-//! * `rb_gc_disable`: [`gc::disable`].
-//! * `rb_gc_enable`: [`gc::enable`].
+//! * `rb_gc_count`: [`Ruby::gc_count`].
+//! * `rb_gc_disable`: [`Ruby::gc_disable`].
+//! * `rb_gc_enable`: [`Ruby::gc_enable`].
 // * `RB_GC_GUARD`:
 // * `rb_gc_latest_gc_info`:
 //! * `rb_gc_location`: [`gc::Compactor::location`].
@@ -829,12 +829,12 @@
 //! * `rb_gc_register_address`: [`gc::register_address`] or
 //!   [`BoxValue`](value::BoxValue).
 //! * `rb_gc_register_mark_object`: [`gc::register_mark_object`].
-//! * `rb_gc_start`: [`gc::start`].
-//! * `rb_gc_stat`: [`gc::stat`] or [`gc::all_stats`].
+//! * `rb_gc_start`: [`Ruby::gc_start`].
+//! * `rb_gc_stat`: [`Ruby::gc_stat`] or [`Ruby::gc_all_stats`].
 //! * `rb_gc_unregister_address`: [`gc::unregister_address`].
 // * `rb_gc_update_tbl_refs`:
-// * `rb_gc_writebarrier`:
-// * `rb_gc_writebarrier_unprotect`:
+//! * `rb_gc_writebarrier`: [`typed_data::Writebarrier::writebarrier`].
+//! * `rb_gc_writebarrier_unprotect`: [`typed_data::Writebarrier::writebarrier_unprotect`].
 // * `rb_generic_ivar_table`:
 // * `rb_genrand_int32`:
 // * `rb_genrand_real`:
@@ -932,7 +932,7 @@
 // * `rb_io_descriptor`:
 // * `rb_io_eof`:
 // * `rb_io_extract_encoding_option`:
-// * `rb_io_extract_modeenc`:
+//! * `rb_io_extract_modeenc`: [`Ruby::io_extract_modeenc`].
 // * `rb_io_fdopen`:
 // * `rb_io_flush`:
 // * `rb_io_fptr_finalize`:
@@ -1114,10 +1114,6 @@
 // * `rb_native_mutex_unlock`:
 // * `rb_need_block`:
 // * `RB_NEGFIXABLE`:
-// * `RB_NEWOBJ`:
-// * `rb_newobj`:
-// * `RB_NEWOBJ_OF`:
-// * `rb_newobj_of`:
 // * `RB_NIL_P`:
 // * `rb_nogvl`:
 // * `rb_notimplement`:
@@ -1253,7 +1249,7 @@
 // * `rb_ractor_stdin_set`:
 // * `rb_ractor_stdout`:
 // * `rb_ractor_stdout_set`:
-//! * `rb_raise`: Simmilar to returning [`Error`].
+//! * `rb_raise`: Similar to returning [`Error`].
 // * `rb_random_base_init`:
 // * `rb_random_bytes`:
 // * `RB_RANDOM_DATA_INIT_PARENT`:
@@ -1311,8 +1307,8 @@
 // * `rb_remove_event_hook_with_data`:
 // * `rb_remove_method`:
 // * `rb_remove_method_id`:
-//! * `rb_require`: [`require`].
-//! * `rb_require_string`: [`require`].
+//! * `rb_require`: [`Ruby::require`].
+//! * `rb_require_string`: [`Ruby::require`].
 // * `rb_rescue`:
 // * `rb_rescue2`:
 // * `RB_RESERVED_FD_P`:
@@ -1413,10 +1409,10 @@
 //! * `rb_str_new`: [`RString::from_slice`].
 // * `rb_str_new_cstr`:
 //! * `rb_str_new_frozen`: [`RString::new_frozen`].
-//! * `rb_str_new_lit`: Simmilar to [`r_string!`].
-//! * `rb_str_new_literal`: Simmilar to [`r_string!`].
+//! * `rb_str_new_lit`: Similar to [`r_string!`].
+//! * `rb_str_new_literal`: Similar to [`r_string!`].
 //! * `rb_str_new_shared`: [`RString::new_shared`].
-// * `rb_str_new_static`: Simmilar to [`r_string!`].
+// * `rb_str_new_static`: Similar to [`r_string!`].
 // * `rb_str_new_with_class`:
 //! * `rb_str_offset`: [`RString::offset`].
 //! * `rb_str_plus`: [`RString::plus`].
@@ -1540,13 +1536,13 @@
 // * `rb_throw_obj`:
 // * `rb_timespec_now`:
 // * `rb_time_interval`:
-// * `rb_time_nano_new`:
+//! * `rb_time_nano_new`: [`Ruby::time_nano_new`].
 //! * `rb_time_new`: [`Ruby::time_new`].
 // * `rb_time_num_new`:
-// * `rb_time_timespec`:
+//! * `rb_time_timespec`: See [`Time::timespec`].
 // * `rb_time_timespec_interval`:
-// * `rb_time_timespec_new`:
-//! * `rb_time_timeval`: [`TryConvert`].
+//! * `rb_time_timespec_new`: [`Ruby::time_timespec_new`].
+// * `rb_time_timeval`:
 //! * `rb_time_utc_offset`: [`Time::utc_offset`].
 // * `rb_tolower`:
 // * `rb_toupper`:
@@ -1610,8 +1606,8 @@
 //! * `rb_utf8_encoding`: [`RbEncoding::utf8`](encoding::RbEncoding::utf8).
 //! * `rb_utf8_str_new`: [`RString::new`].
 //! * `rb_utf8_str_new_cstr`: See [`RString::new`].
-//! * `rb_utf8_str_new_lit`: Simmilar to [`r_string!`].
-//! * `rb_utf8_str_new_literal`: Simmilar to [`r_string!`].
+//! * `rb_utf8_str_new_lit`: Similar to [`r_string!`].
+//! * `rb_utf8_str_new_literal`: Similar to [`r_string!`].
 //! * `rb_utf8_str_new_static`: [`r_string!`].
 // * `rb_uv_to_utf8`:
 //!
@@ -1622,19 +1618,19 @@
 // * `rb_w32_fd_dup`:
 //! * `rb_waitpid`: [`Ruby::waitpid`].
 // * `rb_warn`:
-//! * `rb_warning`: [`error::warning`].
+//! * `rb_warning`: [`Ruby::warning`].
 // * `rb_write_error`:
 // * `rb_write_error2`:
-//! * `rb_yield`: [`block::yield_value`] / return [`block::Yield`].
+//! * `rb_yield`: [`Ruby::yield_value`] / return [`block::Yield`].
 // * `rb_yield_block`:
-//! * `rb_yield_splat`: [`block::yield_splat`] / return [`block::YieldSplat`].
+//! * `rb_yield_splat`: [`Ruby::yield_splat`] / return [`block::YieldSplat`].
 // * `rb_yield_splat_kw`:
 //! * `rb_yield_values`:
-//!   See [`block::yield_values`] / return [`block::YieldValues`].
+//!   See [`Ruby::yield_values`] / return [`block::YieldValues`].
 //! * `rb_yield_values2`:
-//!   See [`block::yield_values`] / return [`block::YieldValues`].
+//!   See [`Ruby::yield_values`] / return [`block::YieldValues`].
 //! * `rb_yield_values_kw`:
-//!   [`block::yield_values`] / return [`block::YieldValues`].
+//!   [`Ruby::yield_values`] / return [`block::YieldValues`].
 // * `RB_ZALLOC`:
 // * `RB_ZALLOC_N`:
 //!
@@ -1740,11 +1736,11 @@
 // * `ruby_scan_digits`:
 // * `ruby_scan_hex`:
 // * `ruby_scan_oct`:
-//! * `ruby_script`: Similar to [`embed::ruby_script`].
+//! * `ruby_script`: Similar to [`Ruby::script`].
 // * `ruby_setenv`:
 //! * `ruby_setup`: [`embed::setup`].
 // * `ruby_set_argv`:
-//! * `ruby_set_script_name`: [`embed::ruby_script`].
+//! * `ruby_set_script_name`: [`Ruby::script`].
 // * `ruby_show_copyright`:
 // * `ruby_show_version`:
 // * `ruby_signal_name`:
@@ -1808,6 +1804,9 @@ mod float;
 pub mod gc;
 mod integer;
 mod into_value;
+#[cfg(feature = "io")]
+#[cfg_attr(docsrs, doc(cfg(feature = "io")))]
+pub mod io;
 pub mod method;
 pub mod module;
 mod mutex;
@@ -1842,7 +1841,7 @@ pub mod rb_sys;
 pub mod scan_args;
 pub mod symbol;
 mod thread;
-mod time;
+pub mod time;
 pub mod try_convert;
 pub mod typed_data;
 pub mod value;
@@ -2183,9 +2182,9 @@ impl Ruby {
 
     /// Alias the global variable `src` as `dst`.
     ///
-    /// Unlike [`define_variable`](Ruby::define_variable), the preceeding `$`
+    /// Unlike [`define_variable`](Ruby::define_variable), the preceding `$`
     /// of the global variable's name is required, otherwise the alias will not
-    /// be accessable from Ruby.
+    /// be accessible from Ruby.
     ///
     /// # Examples
     ///