itsi 0.2.21 → 0.2.22

data/gems/server/vendor/rb-sys-build/src/bindings/stable_api.rs

@@ -0,0 +1,247 @@
+use std::vec;
+
+use quote::ToTokens;
+
+use crate::RbConfig;
+
+const OPAQUE_STRUCTS: [&str; 4] = ["RString", "RArray", "RData", "RTypedData"];
+
+const OPAQUE_STRUCTS_RUBY_3_3: [&str; 3] = [
+    "rb_matchext_struct",
+    "rb_internal_thread_event_data",
+    "rb_io_internal_buffer",
+];
+
+/// Generate opaque structs for the given bindings.
+pub fn opaqueify_bindings(
+    rbconfig: &RbConfig,
+    bindings: bindgen::Builder,
+    wrapper_h: &mut String,
+) -> bindgen::Builder {
+    let version_specific_opaque_structs =
+        get_version_specific_opaque_structs(rbconfig.major_minor());
+    let structs_to_opaque = OPAQUE_STRUCTS
+        .iter()
+        .chain(&version_specific_opaque_structs);
+
+    structs_to_opaque.fold(bindings, |bindings, name| {
+        gen_opaque_struct(bindings, name, wrapper_h)
+    })
+}
+
+/// Categorize all bindings into stable, unstable, and internal.
+pub fn categorize_bindings(syntax: &mut syn::File) {
+    let mut normal_items = Vec::new();
+    let mut unstable_items = Vec::new();
+    let mut internal_items = Vec::new();
+    let mut excluded_items = Vec::new();
+    let mut opaque_items = Vec::new();
+    let mut opaque_idents_to_swap = Vec::new();
+
+    for item in syntax.items.iter_mut() {
+        if let syn::Item::Struct(s) = item {
+            if s.ident.to_string().contains("rb_sys__Opaque__") {
+                let new_name = s.ident.to_string().replace("rb_sys__Opaque__", "");
+                s.ident = syn::Ident::new(&new_name, s.ident.span());
+                opaque_idents_to_swap.push(new_name);
+
+                opaque_items.push(item.clone());
+            } else {
+                normal_items.push(item.clone());
+            }
+        } else if let syn::Item::Type(t) = item {
+            if t.ident.to_string().contains("rb_sys__Opaque__") {
+                let new_name = t.ident.to_string().replace("rb_sys__Opaque__", "");
+                t.ident = syn::Ident::new(&new_name, t.ident.span());
+                opaque_idents_to_swap.push(new_name);
+
+                opaque_items.push(item.clone());
+            } else {
+                normal_items.push(item.clone());
+            }
+        } else {
+            if let syn::Item::Fn(ref mut f) = item {
+                if f.sig.ident.to_string().contains("bindgen_test_") {
+                    let body = &mut f.block;
+                    let code = body.clone().to_token_stream().to_string();
+                    let new_code = code.replace("rb_sys__Opaque__", "super::stable::");
+                    let new_code = syn::parse_str::<syn::Block>(&new_code).unwrap();
+
+                    *body = syn::parse_quote! {
+                        {
+                            #[allow(unused)]
+                            use super::internal::*;
+                            #new_code;
+                        }
+                    };
+                }
+            }
+
+            normal_items.push(item.clone());
+        }
+    }
+
+    for item in normal_items.iter_mut() {
+        if let syn::Item::Type(ref mut t) = item {
+            if let Ok(syn::Type::Path(ref mut type_path)) =
+                syn::parse2::<syn::Type>(t.ty.to_token_stream())
+            {
+                if opaque_idents_to_swap.contains(&type_path.path.segments[0].ident.to_string()) {
+                    let new_ident = syn::Ident::new(
+                        &type_path.path.segments[0].ident.to_string(),
+                        type_path.path.segments[0].ident.span(),
+                    );
+                    t.ty = syn::parse_quote! { crate::internal::#new_ident };
+                }
+            }
+        }
+    }
+
+    for mut item in normal_items {
+        if let syn::Item::Struct(s) = &mut item {
+            if opaque_idents_to_swap.contains(&s.ident.to_string()) {
+                internal_items.push(syn::Item::Struct(s.clone()));
+                s.attrs.push(syn::parse_quote! {
+                    #[deprecated(note = "To improve API stability with ruby-head, direct usage of Ruby internal structs has been deprecated. To migrate, please replace the usage of this internal struct with its counterpart in the `rb_sys::stable` module. For example, instead of `use rb_sys::rb_sys__Opaque__ExampleStruct;`, use `use rb_sys::stable::ExampleStruct;`. If you need to access the internals of these items, you can use the provided `rb-sys::macros` instead.")]
+                });
+                unstable_items.push(item);
+            } else {
+                excluded_items.push(item);
+            }
+        } else if let syn::Item::Type(t) = &mut item {
+            if opaque_idents_to_swap.contains(&t.ident.to_string()) {
+                internal_items.push(syn::Item::Type(t.clone()));
+                t.attrs.push(syn::parse_quote! {
+                    #[deprecated(note = "To improve API stability with ruby-head, direct usage of Ruby internal structs has been deprecated. To migrate, please replace the usage of this internal struct with its counterpart in the `rb_sys::stable` module. For example, instead of `use rb_sys::rb_sys__Opaque__ExampleStruct;`, use `use rb_sys::stable::ExampleStruct;`. If you need to access the internals of these items, you can use the provided `rb-sys::macros` instead.")]
+                });
+                unstable_items.push(item);
+            } else {
+                excluded_items.push(item);
+            }
+        } else {
+            excluded_items.push(item);
+        }
+    }
+
+    // Perform a pass on all std::fmt::Debug implementations to fully qualify opaque structs
+    for item in excluded_items.iter_mut() {
+        if let syn::Item::Impl(ref mut impl_item) = item {
+            if let Some((_, syn::Path { segments, .. }, _)) = impl_item.trait_.as_ref() {
+                if segments.iter().any(|segment| segment.ident == "Debug") {
+                    if let syn::Type::Path(ref mut path) = *impl_item.self_ty {
+                        if opaque_idents_to_swap.contains(&path.to_token_stream().to_string()) {
+                            *impl_item.self_ty = syn::parse_quote! { crate::internal::#path };
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    *syntax = syn::parse_quote! {
+        /// Contains all items that are not yet categorized by ABI stability.
+        /// These items are candidates for promotion to `stable` or `unstable`
+        /// in the future.
+        pub mod uncategorized {
+            #(#excluded_items)*
+        }
+
+        /// Contains all items that are considered unstable ABI and should be
+        /// avoided. Any items in this list offer a stable alternative for most
+        /// use cases.
+        pub mod unstable {
+            use super::uncategorized::*;
+
+            #(#unstable_items)*
+        }
+
+        /// Contains all items that are considered stable ABI and are safe to
+        /// use. These items are intentionally opaque to prevent accidental
+        /// compatibility issues.
+        ///
+        /// If you need to access the internals of these items, please open an
+        /// issue.
+        pub mod stable {
+            #(#opaque_items)*
+        }
+
+        /// Unstable items for usage internally in rb_sys to avoid deprecated warnings.
+        #[allow(dead_code)]
+        pub (crate) mod internal {
+            use super::uncategorized::*;
+
+            #(#internal_items)*
+        }
+    };
+}
+
+fn gen_opaque_struct(
+    bindings: bindgen::Builder,
+    name: &str,
+    wrapper_h: &mut String,
+) -> bindgen::Builder {
+    let struct_name = format!("rb_sys__Opaque__{}", name);
+    wrapper_h.push_str(&format!(
+        "struct {} {{ struct {} dummy; }};\n",
+        struct_name, name
+    ));
+
+    bindings
+        .opaque_type(&struct_name)
+        .allowlist_type(struct_name)
+}
+
+fn get_version_specific_opaque_structs(major_minor: Option<(u32, u32)>) -> Vec<&'static str> {
+    let Some(major_minor) = major_minor else {
+        return vec![];
+    };
+    let mut result = vec![];
+    let (major, minor) = major_minor;
+
+    if major > 3 || (major == 3 && minor >= 3) {
+        result.extend(OPAQUE_STRUCTS_RUBY_3_3)
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_version_specific_opaque_structs() {
+        // No version info
+        assert!(get_version_specific_opaque_structs(None).is_empty());
+
+        // Ruby 3.2.x - too old for 3.3 structs
+        assert!(get_version_specific_opaque_structs(Some((3, 2))).is_empty());
+
+        // Ruby 3.3.x - should include 3.3 structs
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((3, 3))),
+            OPAQUE_STRUCTS_RUBY_3_3.to_vec()
+        );
+
+        // Ruby 3.4.x - should include 3.3 structs
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((3, 4))),
+            OPAQUE_STRUCTS_RUBY_3_3.to_vec()
+        );
+
+        // Ruby 4.0.x - should include 3.3 structs (this was the bug!)
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((4, 0))),
+            OPAQUE_STRUCTS_RUBY_3_3.to_vec()
+        );
+
+        // Ruby 4.1.x - should include 3.3 structs
+        assert_eq!(
+            get_version_specific_opaque_structs(Some((4, 1))),
+            OPAQUE_STRUCTS_RUBY_3_3.to_vec()
+        );
+
+        // Ruby 2.7.x - too old
+        assert!(get_version_specific_opaque_structs(Some((2, 7))).is_empty());
+    }
+}

data/gems/server/vendor/rb-sys-build/src/bindings/wrapper.h

@@ -0,0 +1,71 @@
+#include "ruby.h"
+
+#ifdef HAVE_RUBY_DEBUG_H
+#include "ruby/debug.h"
+#endif
+#ifdef HAVE_RUBY_DEFINES_H
+#include "ruby/defines.h"
+#endif
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#endif
+#ifdef HAVE_RUBY_FIBER_SCHEDULER_H
+#include "ruby/fiber/scheduler.h"
+#endif
+#ifdef HAVE_RUBY_INTERN_H
+#include "ruby/intern.h"
+#endif
+#ifdef HAVE_RUBY_IO_H
+#include "ruby/io.h"
+#endif
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+#include "ruby/memory_view.h"
+#endif
+#ifdef HAVE_RUBY_MISSING_H
+#include "ruby/missing.h"
+#endif
+#ifdef HAVE_RUBY_ONIGMO_H
+#include "ruby/onigmo.h"
+#endif
+#ifdef HAVE_RUBY_ONIGURUMA_H
+#include "ruby/oniguruma.h"
+#endif
+#ifdef HAVE_RUBY_RACTOR_H
+#include "ruby/ractor.h"
+#endif
+#ifdef HAVE_RUBY_RANDOM_H
+#include "ruby/random.h"
+#endif
+#ifdef HAVE_RUBY_RE_H
+#include "ruby/re.h"
+#endif
+#ifdef HAVE_RUBY_REGEX_H
+#include "ruby/regex.h"
+#endif
+#ifdef HAVE_RUBY_RUBY_H
+#include "ruby/ruby.h"
+#endif
+#ifdef HAVE_RUBY_ST_H
+#include "ruby/st.h"
+#endif
+#ifdef HAVE_RUBY_THREAD_H
+#include "ruby/thread.h"
+#endif
+#ifdef HAVE_RUBY_THREAD_NATIVE_H
+#include "ruby/thread_native.h"
+#endif
+#ifdef HAVE_RUBY_UTIL_H
+#include "ruby/util.h"
+#endif
+#ifdef HAVE_RUBY_VERSION_H
+#include "ruby/version.h"
+#endif
+#ifdef HAVE_RUBY_VM_H
+#include "ruby/vm.h"
+#endif
+#ifdef HAVE_RUBY_WIN32_H
+#include "ruby/win32.h"
+#endif
+#ifdef HAVE_RUBY_IO_BUFFER_H
+#include "ruby/io/buffer.h"
+#endif

data/gems/server/vendor/rb-sys-build/src/bindings.rs

@@ -0,0 +1,280 @@
+mod sanitizer;
+mod stable_api;
+
+use crate::cc::Build;
+use crate::utils::is_msvc;
+use crate::{debug_log, RbConfig};
+use quote::ToTokens;
+use stable_api::{categorize_bindings, opaqueify_bindings};
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::{env, error::Error};
+use syn::{Expr, ExprLit, ItemConst, Lit};
+
+const WRAPPER_H_CONTENT: &str = include_str!("bindings/wrapper.h");
+
+/// Generate bindings for the Ruby using bindgen.
+pub fn generate(
+    rbconfig: &RbConfig,
+    static_ruby: bool,
+    cfg_out: &mut File,
+) -> Result<PathBuf, Box<dyn Error>> {
+    let out_dir = PathBuf::from(env::var("OUT_DIR")?);
+
+    let mut clang_args = vec![];
+    if let Some(ruby_include_dir) = rbconfig.get("rubyhdrdir") {
+        clang_args.push(format!("-I{}", ruby_include_dir));
+    }
+    if let Some(ruby_arch_include_dir) = rbconfig.get("rubyarchhdrdir") {
+        clang_args.push(format!("-I{}", ruby_arch_include_dir));
+    }
+
+    clang_args.extend(Build::default_cflags());
+    clang_args.extend(rbconfig.cflags.clone());
+    clang_args.extend(rbconfig.cppflags());
+
+    // On Windows x86_64, we need to handle AVX512 FP16 compatibility issues
+    // Clang 20+ includes types like __m512h that aren't compatible with bindgen
+    if cfg!(target_os = "windows") && cfg!(target_arch = "x86_64") {
+        // For MinGW toolchain, disable SSE/AVX only for bindgen
+        // This prevents intrinsics headers from loading but doesn't affect the final binary
+        if !is_msvc() {
+            clang_args.push("-mno-sse".to_string());
+            clang_args.push("-mno-avx".to_string());
+        }
+    }
+
+    debug_log!("INFO: using bindgen with clang args: {:?}", clang_args);
+
+    let mut wrapper_h = WRAPPER_H_CONTENT.to_string();
+
+    if !is_msvc() {
+        wrapper_h.push_str("#ifdef HAVE_RUBY_ATOMIC_H\n");
+        wrapper_h.push_str("#include \"ruby/atomic.h\"\n");
+        wrapper_h.push_str("#endif\n");
+    }
+
+    if rbconfig.have_ruby_header("ruby/io/buffer.h") {
+        clang_args.push("-DHAVE_RUBY_IO_BUFFER_H".to_string());
+    }
+
+    let bindings = default_bindgen(clang_args, rbconfig)
+        .allowlist_file(".*ruby.*")
+        .blocklist_item("ruby_abi_version")
+        .blocklist_function("rb_tr_abi_version")
+        .blocklist_function("^__.*")
+        .blocklist_item("RData")
+        .blocklist_function("rb_tr_rdata")
+        .blocklist_function("rb_tr_rtypeddata")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()));
+
+    let bindings = if cfg!(feature = "bindgen-rbimpls") {
+        bindings
+    } else {
+        bindings
+            .blocklist_item("^rbimpl_.*")
+            .blocklist_item("^RBIMPL_.*")
+    };
+
+    let bindings = if cfg!(feature = "bindgen-deprecated-types") {
+        bindings
+    } else {
+        bindings.blocklist_item("^_bindgen_ty_9.*")
+    };
+
+    let bindings = opaqueify_bindings(rbconfig, bindings, &mut wrapper_h);
+
+    let mut tokens = {
+        write!(std::io::stderr(), "{}", wrapper_h)?;
+        let bindings = bindings.header_contents("wrapper.h", &wrapper_h);
+        let code_string = bindings.generate()?.to_string();
+        syn::parse_file(&code_string)?
+    };
+
+    let slug = rbconfig.ruby_version_slug();
+    let crate_version = env!("CARGO_PKG_VERSION");
+    let out_path = out_dir.join(format!("bindings-{}-{}.rs", crate_version, slug));
+
+    let code = {
+        sanitizer::ensure_backwards_compatible_encoding_pointers(&mut tokens);
+        clean_docs(rbconfig, &mut tokens);
+
+        if is_msvc() {
+            qualify_symbols_for_msvc(&mut tokens, static_ruby, rbconfig);
+        }
+
+        push_cargo_cfg_from_bindings(&tokens, cfg_out)?;
+        categorize_bindings(&mut tokens);
+        tokens.into_token_stream().to_string()
+    };
+
+    let mut out_file = File::create(&out_path)?;
+    std::io::Write::write_all(&mut out_file, code.as_bytes())?;
+    run_rustfmt(&out_path);
+
+    Ok(out_path)
+}
+
+fn run_rustfmt(path: &Path) {
+    let mut cmd = std::process::Command::new("rustfmt");
+    cmd.stderr(std::process::Stdio::inherit());
+    cmd.stdout(std::process::Stdio::inherit());
+
+    cmd.arg(path);
+
+    if let Err(e) = cmd.status() {
+        debug_log!("WARN: failed to run rustfmt: {}", e);
+    }
+}
+
+fn clean_docs(rbconfig: &RbConfig, syntax: &mut syn::File) {
+    if rbconfig.is_cross_compiling() {
+        return;
+    }
+
+    let ver = rbconfig.ruby_version_slug();
+
+    sanitizer::cleanup_docs(syntax, &ver).unwrap_or_else(|e| {
+        debug_log!("WARN: failed to clean up docs, skipping: {}", e);
+    })
+}
+
+fn default_bindgen(clang_args: Vec<String>, _rbconfig: &RbConfig) -> bindgen::Builder {
+    // Disable layout tests and Debug impl on Windows MinGW due to packed struct layout incompatibilities
+    let is_windows_mingw = cfg!(target_os = "windows") && !is_msvc();
+
+    let enable_layout_tests = !is_windows_mingw && cfg!(feature = "bindgen-layout-tests");
+    let impl_debug = !is_windows_mingw && cfg!(feature = "bindgen-impl-debug");
+
+    let mut bindings = bindgen::Builder::default()
+        .rustified_enum(".*")
+        .no_copy("rb_data_type_struct")
+        .derive_eq(true)
+        .derive_debug(true)
+        .clang_args(clang_args)
+        .layout_tests(enable_layout_tests)
+        .blocklist_item("^__darwin_pthread.*")
+        .blocklist_item("^_opaque_pthread.*")
+        .blocklist_item("^__pthread_.*")
+        .blocklist_item("^pthread_.*")
+        .blocklist_item("^rb_native.*")
+        .blocklist_type("INET_PORT_RESERVATION_INSTANCE")
+        .blocklist_type("PINET_PORT_RESERVATION_INSTANCE")
+        .opaque_type("^__sFILE$")
+        .merge_extern_blocks(true)
+        .generate_comments(true)
+        .size_t_is_usize(env::var("CARGO_FEATURE_BINDGEN_SIZE_T_IS_USIZE").is_ok())
+        .impl_debug(impl_debug)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()));
+
+    // Make __mingw_ldbl_type_t opaque on Windows MinGW to avoid conflicting packed/align representation
+    if cfg!(target_os = "windows") && !is_msvc() {
+        bindings = bindings.opaque_type("__mingw_ldbl_type_t");
+    }
+
+    if env::var("CARGO_FEATURE_BINDGEN_ENABLE_FUNCTION_ATTRIBUTE_DETECTION").is_ok() {
+        bindings.enable_function_attribute_detection()
+    } else {
+        bindings
+    }
+}
+
+// This is needed because bindgen doesn't support the `__declspec(dllimport)` on
+// global variables. Without it, symbols are not found.
+// See https://stackoverflow.com/a/66182704/2057700
+fn qualify_symbols_for_msvc(tokens: &mut syn::File, is_static: bool, rbconfig: &RbConfig) {
+    let kind = if is_static { "static" } else { "dylib" };
+
+    let name = if is_static {
+        rbconfig.libruby_static_name()
+    } else {
+        rbconfig.libruby_so_name()
+    };
+
+    sanitizer::add_link_ruby_directives(tokens, &name, kind).unwrap_or_else(|e| {
+        debug_log!("WARN: failed to add link directives: {}", e);
+    });
+}
+
+// Add things like `#[cfg(ruby_use_transient_heap = "true")]` to the bindings config
+fn push_cargo_cfg_from_bindings(
+    syntax: &syn::File,
+    cfg_out: &mut File,
+) -> Result<(), Box<dyn Error>> {
+    fn is_defines(line: &str) -> bool {
+        line.starts_with("HAVE_RUBY")
+            || line.starts_with("HAVE_RB")
+            || line.starts_with("USE")
+            || line.starts_with("RUBY_DEBUG")
+            || line.starts_with("RUBY_NDEBUG")
+    }
+
+    for item in syntax.items.iter() {
+        if let syn::Item::Const(item) = item {
+            let conf = ConfValue::new(item);
+            let conf_name = conf.name();
+
+            if is_defines(&conf_name) {
+                let name = conf_name.to_lowercase();
+                let val = conf.value_bool().to_string();
+                println!(
+                    r#"cargo:rustc-check-cfg=cfg(ruby_{}, values("true", "false"))"#,
+                    name
+                );
+                println!("cargo:rustc-cfg=ruby_{}=\"{}\"", name, val);
+                println!("cargo:defines_{}={}", name, val);
+                writeln!(cfg_out, "cargo:defines_{}={}", name, val)?;
+            }
+
+            if conf_name.starts_with("RUBY_ABI_VERSION") {
+                println!("cargo:ruby_abi_version={}", conf.value_string());
+                writeln!(cfg_out, "cargo:ruby_abi_version={}", conf.value_string())?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// An autoconf constant in the bindings
+struct ConfValue<'a> {
+    item: &'a syn::ItemConst,
+}
+
+impl<'a> ConfValue<'a> {
+    pub fn new(item: &'a ItemConst) -> Self {
+        Self { item }
+    }
+
+    pub fn name(&self) -> String {
+        self.item.ident.to_string()
+    }
+
+    pub fn value_string(&self) -> String {
+        match &*self.item.expr {
+            Expr::Lit(ExprLit { lit, .. }) => lit.to_token_stream().to_string(),
+            _ => panic!(
+                "Could not convert HAVE_* constant to string: {:#?}",
+                self.item
+            ),
+        }
+    }
+
+    pub fn value_bool(&self) -> bool {
+        match &*self.item.expr {
+            Expr::Lit(ExprLit {
+                lit: Lit::Int(ref lit),
+                ..
+            }) => lit.base10_parse::<u8>().unwrap_or(1) != 0,
+            Expr::Lit(ExprLit {
+                lit: Lit::Bool(ref lit),
+                ..
+            }) => lit.value,
+            _ => panic!(
+                "Could not convert HAVE_* constant to bool: {:#?}",
+                self.item
+            ),
+        }
+    }
+}