code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/{rb-sys-0.9.117 → rb-sys-0.9.130}/src/stable_api.rs

@@ -11,7 +11,7 @@
 //!    to ensure Rust extensions don't prevent the Ruby core team from testing
 //!    changes in production.
 
-use crate::VALUE;
+use crate::{ID, VALUE};
 use std::{
     os::raw::{c_char, c_long},
     ptr::NonNull,
@@ -58,6 +58,24 @@ pub trait StableApiDefinition {
     /// is valid.
     unsafe fn rarray_const_ptr(&self, obj: VALUE) -> *const VALUE;
 
+    /// Get element from array by index (akin to `RARRAY_AREF`).
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying Ruby data. The caller must ensure that the pointer
+    /// is valid and that the index is within bounds.
+    unsafe fn rarray_aref(&self, obj: VALUE, idx: isize) -> VALUE;
+
+    /// Set element in array by index (akin to `RARRAY_ASET`).
+    ///
+    /// Includes GC write barrier for safety.
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying Ruby data. The caller must ensure that the pointer
+    /// is valid and that the index is within bounds.
+    unsafe fn rarray_aset(&self, obj: VALUE, idx: isize, val: VALUE);
+
     /// Get the class from a VALUE which contains an RBasic struct.
     ///
     /// `VALUE` is a valid pointer to a non-immediate object.
@@ -195,29 +213,213 @@ pub trait StableApiDefinition {
     /// is valid and points to a T_DATA object.
     unsafe fn rtypeddata_p(&self, obj: VALUE) -> bool;
 
-    /// Checks if the given RTypedData is embedded.
+    /// Gets the data type from an RTypedData object.
     ///
     /// # Safety
     /// This function is unsafe because it dereferences a raw pointer to get
     /// access to underlying Ruby data. The caller must ensure that the pointer
     /// is valid and points to an RTypedData object.
-    unsafe fn rtypeddata_embedded_p(&self, obj: VALUE) -> bool;
+    unsafe fn rtypeddata_type(&self, obj: VALUE) -> *const crate::rb_data_type_t;
 
-    /// Gets the data type from an RTypedData object.
+    /// Gets the data pointer from an RTypedData object.
     ///
     /// # Safety
     /// This function is unsafe because it dereferences a raw pointer to get
     /// access to underlying Ruby data. The caller must ensure that the pointer
     /// is valid and points to an RTypedData object.
-    unsafe fn rtypeddata_type(&self, obj: VALUE) -> *const crate::rb_data_type_t;
+    unsafe fn rtypeddata_get_data(&self, obj: VALUE) -> *mut std::ffi::c_void;
 
-    /// Gets the data pointer from an RTypedData object.
+    /// Get pointer to end of string contents (akin to `RSTRING_END`).
+    ///
+    /// Returns a pointer to the byte after the last character of the string.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid Ruby String object
+    unsafe fn rstring_end(&self, obj: VALUE) -> *const c_char;
+
+    /// Get data pointer from RData/TypedData object (akin to `DATA_PTR`).
+    ///
+    /// Returns the user data pointer stored in an RData or TypedData object.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid RData or TypedData object
+    unsafe fn rdata_ptr(&self, obj: VALUE) -> *mut std::ffi::c_void;
+
+    /// Freeze an object (akin to `RB_OBJ_FREEZE`).
+    ///
+    /// Sets the frozen flag on an object, preventing further modification.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid heap-allocated Ruby object
+    unsafe fn rb_obj_freeze(&self, obj: VALUE);
+
+    /// Check if object is promoted to old GC generation (akin to `RB_OBJ_PROMOTED`).
+    ///
+    /// Returns true if the object has been promoted to the old generation
+    /// in Ruby's generational GC.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid VALUE
+    unsafe fn rb_obj_promoted(&self, obj: VALUE) -> bool;
+
+    /// Raw version assuming FL_ABLE (akin to `RB_OBJ_PROMOTED_RAW`).
+    ///
+    /// # Safety
+    /// - `obj` must be a valid heap-allocated Ruby object (FL_ABLE must be true)
+    unsafe fn rb_obj_promoted_raw(&self, obj: VALUE) -> bool;
+
+    /// Convert Ruby numeric to C double (akin to `NUM2DBL`).
+    ///
+    /// Works for Float (including Flonum), Fixnum, and other numeric types.
+    ///
+    /// # Safety
+    /// This function is unsafe because it may dereference a raw pointer to get
+    /// access to underlying Ruby data. The caller must ensure that the pointer
+    /// is valid.
+    unsafe fn num2dbl(&self, obj: VALUE) -> std::os::raw::c_double;
+
+    /// Convert C double to Ruby Float VALUE (akin to `DBL2NUM`).
+    ///
+    /// May return a Flonum (tagged pointer) for small values on 64-bit platforms,
+    /// or a heap-allocated Float object.
+    fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE;
+
+    /// Get hash size (akin to `RHASH_SIZE`).
+    ///
+    /// Returns the number of entries in the hash.
     ///
     /// # Safety
     /// This function is unsafe because it dereferences a raw pointer to get
     /// access to underlying Ruby data. The caller must ensure that the pointer
-    /// is valid and points to an RTypedData object.
-    unsafe fn rtypeddata_get_data(&self, obj: VALUE) -> *mut std::ffi::c_void;
+    /// is valid and points to a Hash object.
+    unsafe fn rhash_size(&self, obj: VALUE) -> usize;
+
+    /// Check if hash is empty (akin to `RHASH_EMPTY_P`).
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying Ruby data. The caller must ensure that the pointer
+    /// is valid and points to a Hash object.
+    unsafe fn rhash_empty_p(&self, obj: VALUE) -> bool;
+
+    /// Get encoding index from object (akin to `ENCODING_GET`).
+    ///
+    /// Returns the encoding index stored in the object's flags.
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying Ruby data. The caller must ensure that the pointer
+    /// is valid and points to an object with encoding (String, Regexp, Symbol).
+    unsafe fn encoding_get(&self, obj: VALUE) -> std::os::raw::c_int;
+
+    /// Check if an object can have flags (akin to `RB_FL_ABLE`).
+    ///
+    /// Returns false for immediate values (nil, true, false, Fixnum, Symbol, Flonum)
+    /// which don't have flag storage. Returns true for heap-allocated objects.
+    fn fl_able(&self, obj: VALUE) -> bool;
+
+    /// Convert Fixnum to long (akin to `FIX2LONG`).
+    ///
+    /// Extracts the integer value from a Fixnum VALUE.
+    ///
+    /// # Safety assumptions
+    /// - `obj` must be a valid Fixnum VALUE
+    fn fix2long(&self, obj: VALUE) -> std::os::raw::c_long;
+
+    /// Convert Fixnum to unsigned long (akin to `FIX2ULONG`).
+    ///
+    /// Extracts the unsigned integer value from a Fixnum VALUE.
+    ///
+    /// # Safety assumptions
+    /// - `obj` must be a valid positive Fixnum VALUE
+    fn fix2ulong(&self, obj: VALUE) -> std::os::raw::c_ulong;
+
+    /// Convert long to Fixnum (akin to `LONG2FIX`).
+    ///
+    /// Creates a Fixnum VALUE from a long integer.
+    ///
+    /// # Safety assumptions
+    /// - `val` must be in the valid Fixnum range
+    fn long2fix(&self, val: std::os::raw::c_long) -> VALUE;
+
+    /// Check if long value can be represented as Fixnum (akin to `FIXABLE`).
+    ///
+    /// Returns true if the value fits in a Fixnum.
+    fn fixable(&self, val: std::os::raw::c_long) -> bool;
+
+    /// Check if unsigned long value can be represented as positive Fixnum (akin to `POSFIXABLE`).
+    ///
+    /// Returns true if the value fits in a positive Fixnum.
+    fn posfixable(&self, val: std::os::raw::c_ulong) -> bool;
+
+    /// Convert Ruby Integer to long (akin to `NUM2LONG`).
+    ///
+    /// Converts any Ruby Integer (Fixnum or Bignum) to a C long.
+    /// May raise an exception if the value is out of range.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid Integer VALUE
+    /// - May call into Ruby runtime (for Bignum conversion)
+    unsafe fn num2long(&self, obj: VALUE) -> std::os::raw::c_long;
+
+    /// Convert Ruby Integer to unsigned long (akin to `NUM2ULONG`).
+    ///
+    /// Converts any Ruby Integer (Fixnum or Bignum) to a C unsigned long.
+    /// May raise an exception if the value is out of range or negative.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid Integer VALUE
+    /// - May call into Ruby runtime (for Bignum conversion)
+    unsafe fn num2ulong(&self, obj: VALUE) -> std::os::raw::c_ulong;
+
+    /// Convert long to Ruby Integer (akin to `LONG2NUM`).
+    ///
+    /// Creates a Ruby Integer (Fixnum or Bignum) from a C long.
+    /// Uses Fixnum if possible, otherwise allocates a Bignum.
+    fn long2num(&self, val: std::os::raw::c_long) -> VALUE;
+
+    /// Convert unsigned long to Ruby Integer (akin to `ULONG2NUM`).
+    ///
+    /// Creates a Ruby Integer (Fixnum or Bignum) from a C unsigned long.
+    /// Uses Fixnum if possible, otherwise allocates a Bignum.
+    fn ulong2num(&self, val: std::os::raw::c_ulong) -> VALUE;
+
+    /// Convert ID to Symbol (akin to `RB_ID2SYM`).
+    ///
+    /// Converts an internal ID to its corresponding Symbol VALUE.
+    /// This is a safe operation - just bit manipulation for static symbols.
+    fn id2sym(&self, id: ID) -> VALUE;
+
+    /// Convert Symbol to ID (akin to `RB_SYM2ID`).
+    ///
+    /// Converts a Symbol VALUE to its internal ID representation.
+    ///
+    /// # Safety
+    /// - `obj` must be a valid Symbol VALUE
+    /// - For dynamic symbols, this may access the heap
+    unsafe fn sym2id(&self, obj: VALUE) -> ID;
+
+    /// Execute GC write barrier when storing a reference (akin to `RB_OBJ_WRITE`).
+    ///
+    /// Must be called when storing a VALUE reference from one heap object to another.
+    /// This is critical for GC correctness - without it, the GC may collect objects
+    /// that are still referenced.
+    ///
+    /// # Safety
+    /// - `old` must be a valid heap-allocated Ruby object
+    /// - `slot` must be a valid pointer to a VALUE within `old`
+    /// - `young` must be a valid VALUE
+    unsafe fn rb_obj_write(&self, old: VALUE, slot: *mut VALUE, young: VALUE) -> VALUE;
+
+    /// Declare a write barrier without actually writing (akin to `RB_OBJ_WRITTEN`).
+    ///
+    /// Use this when you've already written a reference but need to inform the GC.
+    ///
+    /// # Safety
+    /// - `old` must be a valid heap-allocated Ruby object
+    /// - `oldv` is the previous value (can be any VALUE)
+    /// - `young` must be a valid VALUE that was written
+    unsafe fn rb_obj_written(&self, old: VALUE, oldv: VALUE, young: VALUE) -> VALUE;
 }
 
 #[cfg(stable_api_enable_compiled_mod)]
@@ -226,13 +428,13 @@ mod compiled;
 use compiled as api;
 
 #[cfg(stable_api_include_rust_impl)]
-#[cfg_attr(ruby_eq_2_6, path = "stable_api/ruby_2_6.rs")]
 #[cfg_attr(ruby_eq_2_7, path = "stable_api/ruby_2_7.rs")]
 #[cfg_attr(ruby_eq_3_0, path = "stable_api/ruby_3_0.rs")]
 #[cfg_attr(ruby_eq_3_1, path = "stable_api/ruby_3_1.rs")]
 #[cfg_attr(ruby_eq_3_2, path = "stable_api/ruby_3_2.rs")]
 #[cfg_attr(ruby_eq_3_3, path = "stable_api/ruby_3_3.rs")]
 #[cfg_attr(ruby_eq_3_4, path = "stable_api/ruby_3_4.rs")]
+#[cfg_attr(ruby_eq_4_0, path = "stable_api/ruby_4_0.rs")]
 mod rust;
 #[cfg(not(stable_api_export_compiled_as_api))]
 use rust as api;
@@ -247,6 +449,7 @@ impl std::fmt::Debug for api::Definition {
 }
 
 /// Get the default stable API definition for the current Ruby version.
+#[inline(always)]
 pub const fn get_default() -> &'static api::Definition {
     const API: api::Definition = api::Definition {};
     &API
@@ -254,6 +457,7 @@ pub const fn get_default() -> &'static api::Definition {
 
 /// Get the fallback stable API definition for the current Ruby version, which
 /// is compiled C code that is linked into to this crate.
+#[inline(always)]
 #[cfg(stable_api_enable_compiled_mod)]
 pub const fn get_compiled() -> &'static compiled::Definition {
     const COMPILED_API: compiled::Definition = compiled::Definition {};

data/ext/cargo-vendor/{rb-sys-0.9.117 → rb-sys-0.9.130}/src/utils.rs

@@ -64,19 +64,24 @@ macro_rules! debug_ruby_assert_type {
 mod tests {
     use super::*;
     use rusty_fork::rusty_fork_test;
+    use std::ptr::addr_of_mut;
 
     rusty_fork_test! {
         #[test]
         fn test_is_ruby_vm_started() {
             assert!(!unsafe { is_ruby_vm_started() });
 
-            #[cfg(windows)]
-            {
-                let mut argc = 0;
-                let mut argv: [*mut std::os::raw::c_char; 0] = [];
-                let mut argv = argv.as_mut_ptr();
-                unsafe { rb_sys::rb_w32_sysinit(&mut argc, &mut argv) };
-            }
+            // Call ruby_sysinit which handles platform-specific initialization
+            // (rb_w32_sysinit on Windows) and sets up standard file descriptors
+            let mut argc = 0;
+            let mut argv: [*mut std::os::raw::c_char; 0] = [];
+            let mut argv_ptr = argv.as_mut_ptr();
+            unsafe { crate::ruby_sysinit(&mut argc, &mut argv_ptr) };
+
+            // ruby_init_stack must be called before ruby_setup, especially on
+            // Windows where it's required for proper GC stack scanning
+            let mut stack_marker: crate::VALUE = 0;
+            unsafe { crate::ruby_init_stack(addr_of_mut!(stack_marker) as *mut _) };
 
             match unsafe { crate::ruby_setup() } {
                 0 => {}

data/ext/cargo-vendor/rb-sys-build-0.9.130/.cargo-checksum.json

@@ -0,0 +1 @@
+{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"8b04f813804653ea3643afd0e15c46c7724d0288133b20d619c235a416b2b921","Cargo.lock":"ed24e9ee15dc448eec478537986ad403c6537e44618526c858995fc1b0d865a1","Cargo.toml":"37d4a12082748ca8a9414f15f10249a6095556a0ccbc78ee0505d7a3ef4de394","Cargo.toml.orig":"45c49278819269da8dea4245ecef21c3ad7fc6fd517e6a5afcc06793b7d114be","LICENSE-APACHE":"110a4b771805962e964448aed69e868cc3e9aec91e89c88b8598f8bd726d1d6a","LICENSE-MIT":"3edf6db4f22b0da400397c3ffe917b3330f6cff051753ba02de9b40b4b8ccb24","src/bindings.rs":"b31634b911cfca29c68c7c577d95033dde816d9f37b67c92ae29c4fa6fed36d3","src/bindings/gc_stress.rs":"cf63b1fa7506747d42bf8468abb2cfdb789f77acf750d6e8c6e0b86e01595700","src/bindings/sanitizer.rs":"325e06a06064c015522e1bfb74d3c526562c1aec53d721b3568f91abb77ca050","src/bindings/stable_api.rs":"5e15c45795a60c27e7355f72e12345b26dbde83d84d517b37fa6e8708fe52880","src/bindings/wrapper.h":"12a6ffcbcaa12989925960364929c4a846e1de0d21177f165474b4fb3c5d8357","src/cc.rs":"ca2646b4ce62dbb498810cce1f2a91b5d660429b26bbfc1187299069b9249cdd","src/lib.rs":"9549ca5357591d494dd3c7140216b6c4811907fce4cf3930d13181696ffc8741","src/rb_config.rs":"f3fc5e572206d90881270cd20d6781351ccb829a232e094701330e4e27859c9c","src/rb_config/flags.rs":"b0b96fd416bc21817130db50c62ea5f094d533d323113fa4f95c79c96d358cdd","src/rb_config/library.rs":"ff7977aabc1cd7f295966b6202f5b00eb67daf67dddf9297d069b46a0e445246","src/rb_config/search_path.rs":"04b41bb9efa473a661785003c3ffcc250284fe25e6113a4c2582f5d74f39d046","src/utils.rs":"2d68d093db58c3509980ab680ca67cf134bf875f22800fb6f9e42f5fbac107a8","tests/fixtures/rubyopt_stdout.rb":"050044f1d3d606169f1cb74b589dc54d25e4f087c46cc43d2aade5cbe47f43b6","tests/rubyopt.rs":"dd034689f6ad0281b5223824fb3f75ee9a44af5617bb8f7c8db77d555d9236ac"},"package":"05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"}

data/ext/cargo-vendor/{rb-sys-build-0.9.117 → rb-sys-build-0.9.130}/.cargo_vcs_info.json

@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "99078677bdd36b9e84828518792e13e8e8e5c114"
+    "sha1": "020a6c284516fc56ec171164be70705f7329aadd"
   },
   "path_in_vcs": "crates/rb-sys-build"
 }

data/ext/cargo-vendor/{rb-sys-build-0.9.117 → rb-sys-build-0.9.130}/Cargo.lock

@@ -13,16 +13,14 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.69.4"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
  "itertools",
- "lazy_static",
- "lazycell",
  "proc-macro2",
  "quote",
  "regex",
@@ -90,12 +88,6 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "libc"
 version = "0.2.155"
@@ -136,25 +128,25 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.38"
+version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.117"
+version = "0.9.130"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -167,9 +159,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -179,9 +171,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.8"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -190,21 +182,21 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.5"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "shell-words"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
 
 [[package]]
 name = "shlex"
@@ -214,9 +206,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "syn"
-version = "2.0.104"
+version = "2.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
 dependencies = [
  "proc-macro2",
  "quote",

data/ext/cargo-vendor/{rb-sys-build-0.9.117 → rb-sys-build-0.9.130}/Cargo.toml

@@ -11,9 +11,9 @@
 
 [package]
 edition = "2018"
-rust-version = "1.65"
+rust-version = "1.75"
 name = "rb-sys-build"
-version = "0.9.117"
+version = "0.9.130"
 build = false
 autolib = false
 autobins = false
@@ -35,6 +35,7 @@ bindgen-rbimpls = []
 bindgen-return-const-encoding-pointers = []
 bindgen-sizet-is-usize = []
 default = []
+gc-stress = []
 
 [lib]
 name = "rb_sys_build"
@@ -42,8 +43,12 @@ path = "src/lib.rs"
 doctest = false
 bench = false
 
+[[test]]
+name = "rubyopt"
+path = "tests/rubyopt.rs"
+
 [dependencies.bindgen]
-version = "0.69"
+version = "0.72"
 features = ["runtime"]
 default-features = false
 

data/ext/cargo-vendor/{rb-sys-build-0.9.117 → rb-sys-build-0.9.130}/Cargo.toml.orig

@@ -1,12 +1,12 @@
 [package]
 name = "rb-sys-build"
-version = "0.9.117"
+version = "0.9.130"
 edition = "2018"
 description = "Build system for rb-sys"
 homepage = "https://github.com/oxidize-rb/rb-sys"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/oxidize-rb/rb-sys"
-rust-version = "1.65"
+rust-version = "1.75"
 
 [lib]
 bench = false
@@ -15,7 +15,7 @@ doctest = false
 [dependencies]
 regex = "1"
 shell-words = "1.1"
-bindgen = { version = "0.69", default-features = false, features = ["runtime"] }
+bindgen = { version = "0.72", default-features = false, features = ["runtime"] }
 syn = { version = "2.0", features = ["parsing", "full", "extra-traits"] }
 quote = "1.0"
 lazy_static = "1.4.0"
@@ -30,3 +30,4 @@ bindgen-impl-debug = []
 bindgen-sizet-is-usize = []
 bindgen-return-const-encoding-pointers = []
 bindgen-enable-function-attribute-detection = []
+gc-stress = []