code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/rb-sys-0.9.130/src/stable_api.rs

@@ -0,0 +1,465 @@
+//! Stable ABI functions which provide access to Ruby internals that
+//! is compatible across Ruby versions, and are guaranteed to be not break due
+//! to Ruby binary changes.
+//!
+//! ### Goals
+//!
+//! 1. To provide access to Ruby internals that are not exposed by the libruby
+//!    (i.e. C macros and inline functions).
+//! 2. Provide support for Ruby development versions, which can make breaking
+//!    changes without semantic versioning. We want to support these versions
+//!    to ensure Rust extensions don't prevent the Ruby core team from testing
+//!    changes in production.
+
+use crate::{ID, VALUE};
+use std::{
+    os::raw::{c_char, c_long},
+    ptr::NonNull,
+    time::Duration,
+};
+
+pub trait StableApiDefinition {
+    const VERSION_MAJOR: u32;
+    const VERSION_MINOR: u32;
+
+    fn version(&self) -> (u32, u32) {
+        (Self::VERSION_MAJOR, Self::VERSION_MINOR)
+    }
+
+    /// Get the length of a Ruby string (akin to `RSTRING_LEN`).
+    ///
+    /// # 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.
+    unsafe fn rstring_len(&self, obj: VALUE) -> c_long;
+
+    /// Get a pointer to the bytes of a Ruby string (akin to `RSTRING_PTR`).
+    ///
+    /// # 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.
+    unsafe fn rstring_ptr(&self, obj: VALUE) -> *const c_char;
+
+    /// Get the length of a Ruby array (akin to `RARRAY_LEN`).
+    ///
+    /// # 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.
+    unsafe fn rarray_len(&self, obj: VALUE) -> c_long;
+
+    /// Get a pointer to the elements of a Ruby array (akin to `RARRAY_CONST_PTR`).
+    ///
+    /// # 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.
+    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.
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying RBasic struct. The caller must ensure that the
+    /// `VALUE` is a valid pointer to an RBasic struct.
+    unsafe fn rbasic_class(&self, obj: VALUE) -> Option<NonNull<VALUE>>;
+
+    /// Checks if the given object is frozen.
+    ///
+    /// `VALUE` is a valid pointer to a non-immediate object.
+    ///
+    /// # Safety
+    /// This function is unsafe because it may dereference a raw pointer to get
+    /// access to underlying RBasic struct. The caller must ensure that the
+    /// `VALUE` is a valid pointer to an RBasic struct.
+    unsafe fn frozen_p(&self, obj: VALUE) -> bool;
+
+    /// Tests if a bignum is positive.
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying RBasic struct. The caller must ensure that the
+    /// `VALUE` is a valid pointer to a bignum.
+    unsafe fn bignum_positive_p(&self, obj: VALUE) -> bool;
+
+    /// Tests if a bignum is negative.
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying RBasic struct. The caller must ensure that the
+    /// `VALUE` is a valid pointer to a bignum.
+    #[inline]
+    unsafe fn bignum_negative_p(&self, obj: VALUE) -> bool {
+        !self.bignum_positive_p(obj)
+    }
+
+    /// Tests if the given value is a special constant.
+    fn special_const_p(&self, value: VALUE) -> bool;
+
+    /// Queries the type of the object.
+    ///
+    /// # Note
+    /// The input `obj` must not be a special constant.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn builtin_type(&self, obj: VALUE) -> crate::ruby_value_type;
+
+    /// Tests if the object's type is the given type.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn type_p(&self, obj: VALUE, ty: crate::ruby_value_type) -> bool;
+
+    /// Checks if the given object is nil.
+    fn nil_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is a so-called Fixnum.
+    fn fixnum_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is a dynamic symbol.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn dynamic_sym_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is a static symbol.
+    fn static_sym_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is a symbol.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn symbol_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is a so-called Flonum.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn float_type_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is an integer type
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn integer_type_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given object is a so-called Flonum.
+    fn flonum_p(&self, obj: VALUE) -> bool;
+
+    /// Checks if the given  object is  an immediate  i.e. an  object which  has
+    /// no corresponding storage inside of the object space.
+    fn immediate_p(&self, obj: VALUE) -> bool;
+
+    /// Emulates Ruby's "if" statement by testing if the given `obj` is neither `Qnil` or `Qfalse`.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    fn rb_test(&self, ob: VALUE) -> bool;
+
+    /// Queries the type of the object. Identical to `StableApi.builtin_type`,
+    /// except it can also accept special constants.
+    ///
+    /// # Safety
+    /// This function is unsafe because it could dereference a raw pointer when
+    /// attemping to access the underlying [`RBasic`] struct.
+    unsafe fn rb_type(&self, obj: VALUE) -> crate::ruby_value_type;
+
+    /// Check if a Ruby string is interned (akin to `RSTRING_FSTR`).
+    ///
+    /// # Safety
+    /// This function is unsafe because it dereferences a raw pointer to get
+    /// access to underlying flags of the RString. The caller must ensure that
+    /// the `VALUE` is a valid pointer to an RString.
+    unsafe fn rstring_interned_p(&self, obj: VALUE) -> bool;
+
+    /// Blocks the current thread until the given duration has passed.
+    fn thread_sleep(&self, duration: Duration);
+
+    /// Checks if the given object is an RTypedData.
+    ///
+    /// # 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 T_DATA object.
+    unsafe fn rtypeddata_p(&self, obj: VALUE) -> bool;
+
+    /// 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_type(&self, obj: VALUE) -> *const crate::rb_data_type_t;
+
+    /// 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_get_data(&self, obj: VALUE) -> *mut std::ffi::c_void;
+
+    /// 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 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)]
+mod compiled;
+#[cfg(stable_api_export_compiled_as_api)]
+use compiled as api;
+
+#[cfg(stable_api_include_rust_impl)]
+#[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;
+
+impl std::fmt::Debug for api::Definition {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StableApiDefinition")
+            .field("VERSION_MAJOR", &api::Definition::VERSION_MAJOR)
+            .field("VERSION_MINOR", &api::Definition::VERSION_MINOR)
+            .finish()
+    }
+}
+
+/// 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
+}
+
+/// 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 {};
+    &COMPILED_API
+}

data/ext/cargo-vendor/rb-sys-0.9.130/src/utils.rs

@@ -0,0 +1,94 @@
+//! Internal utility functions.
+
+/// Check if the Ruby VM is globally available.
+///
+/// Unfortunately there is no public API for this check, but there's a hidden
+/// `ruby_current_vm_ptr` symbol in libruby 2.5 - 3.2 which we can use to
+/// determine if the VM has been initialized, or shut down.
+///
+/// # Notes
+///
+/// Ruby 2.4 and below don't have a global VM pointer, so we can't check if it's
+/// null. Ruby 2.4 is EOL, and support will be dropped soon anyway.
+//
+/// In Ruby 3.3, the global VM pointer is no longer exported, so there's no
+/// simple way to check the global VM pointer, so instead we check if known
+/// static value is non-zero.
+///
+/// On Ruby < 3.3, we also need to check if the global VM pointer is null to
+/// ensure the VM hasn't stopped, which makes the function name a bit of a
+/// misnomer... but in actuality this function can only guarantee that the
+/// VM is started, not that it's still running.
+#[allow(dead_code)]
+pub(crate) unsafe fn is_ruby_vm_started() -> bool {
+    #[cfg(ruby_engine = "mri")]
+    let ret = {
+        #[cfg(all(ruby_gt_2_4, ruby_lte_3_2))]
+        let ret = !crate::hidden::ruby_current_vm_ptr.is_null();
+
+        #[cfg(any(ruby_lte_2_4, ruby_gt_3_2))]
+        let ret = crate::rb_cBasicObject != 0;
+
+        ret
+    };
+
+    #[cfg(ruby_engine = "truffleruby")]
+    let ret = crate::rb_cBasicObject != 0;
+
+    ret
+}
+
+/// Macro for conditionally asserting type checks in Ruby, only active when RUBY_DEBUG is enabled.
+/// This matches Ruby's behavior of only checking types in debug mode.
+#[macro_export]
+macro_rules! debug_ruby_assert_type {
+    ($obj:expr, $type:expr, $message:expr) => {
+        #[cfg(ruby_ruby_debug = "true")]
+        {
+            #[allow(clippy::macro_metavars_in_unsafe)]
+            unsafe {
+                assert!(
+                    !$crate::SPECIAL_CONST_P($obj) && $crate::RB_BUILTIN_TYPE($obj) == $type,
+                    $message
+                );
+            }
+        }
+        #[cfg(not(ruby_ruby_debug = "true"))]
+        {
+            let _ = ($obj, $type, $message); // Prevent unused variable warnings
+        }
+    };
+}
+
+#[cfg(test)]
+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() });
+
+            // 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 => {}
+                code => panic!("Failed to setup Ruby (error code: {})", code),
+            };
+
+            assert!(unsafe { is_ruby_vm_started() });
+        }
+    }
+}

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.130/.cargo_vcs_info.json

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