itsi-server 0.2.21 → 0.2.23

data/vendor/rb-sys-build/src/bindings/sanitizer.rs

@@ -0,0 +1,185 @@
+use regex::Regex;
+use std::{
+    borrow::{Borrow, Cow},
+    error::Error,
+};
+use syn::{Attribute, Expr, Item, Lit, LitStr, Meta};
+
+lazy_static::lazy_static! {
+    static ref URL_REGEX: Regex = Regex::new(r#"https?://[^\s'"]+"#).unwrap();
+    static ref DOC_SECTION_REGEX: Regex = Regex::new(r"^@(warning|internal|private|note)\s*").unwrap();
+    static ref PARAM_DIRECTIVE_REGEX: Regex = Regex::new(r"^(@\w+)\[(\S+)\]\s+(.*)$").unwrap();
+    static ref OTHER_DIRECTIVE_REGEX: Regex = Regex::new(r"^(@\w+)\s+(.*)$").unwrap();
+    static ref BARE_CODE_REF_REGEX: Regex = Regex::new(r"(\b)(rb_(\w|_)+)(\(|\))*").unwrap();
+}
+
+/// Append a link directive to each foreign module to the given syntax tree.
+pub fn add_link_ruby_directives(
+    syntax: &mut syn::File,
+    link_name: &str,
+    kind: &str,
+) -> Result<(), Box<dyn Error>> {
+    for item in syntax.items.iter_mut() {
+        if let Item::ForeignMod(fmod) = item {
+            fmod.attrs.push(syn::parse_quote! {
+                #[link(name = #link_name, kind = #kind)]
+            });
+        }
+    }
+
+    Ok(())
+}
+
+/// Converts all `*const rb_encoding` and  `*const OnigEncodingTypeST` to *mut
+/// _` to keep backwards compatibility with bindgen < 0.62.
+pub fn ensure_backwards_compatible_encoding_pointers(syntax: &mut syn::File) {
+    for item in syntax.items.iter_mut() {
+        if let Item::ForeignMod(fmod) = item {
+            for item in fmod.items.iter_mut() {
+                if let syn::ForeignItem::Fn(f) = item {
+                    if let syn::ReturnType::Type(_, ty) = &mut f.sig.output {
+                        if let syn::Type::Ptr(ptr) = &mut **ty {
+                            if let syn::Type::Path(path) = &*ptr.elem {
+                                if path.path.segments.len() == 1
+                                    && path.path.segments[0].ident == "OnigEncodingTypeST"
+                                    || path.path.segments[0].ident == "rb_encoding"
+                                {
+                                    ptr.mutability = Some(syn::token::Mut::default());
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Turn the cruby comments into rustdoc comments.
+pub fn cleanup_docs(syntax: &mut syn::File, ruby_version: &str) -> Result<(), Box<dyn Error>> {
+    let footer = doc_footer(ruby_version);
+
+    for item in syntax.items.iter_mut() {
+        match item {
+            Item::ForeignMod(fmod) => {
+                for item in fmod.items.iter_mut() {
+                    match item {
+                        syn::ForeignItem::Fn(f) => clean_doc_attrs(&mut f.attrs, &footer),
+                        syn::ForeignItem::Static(s) => clean_doc_attrs(&mut s.attrs, &footer),
+                        syn::ForeignItem::Type(s) => clean_doc_attrs(&mut s.attrs, &footer),
+                        _ => {}
+                    }
+                }
+            }
+            Item::Type(t) => clean_doc_attrs(&mut t.attrs, &footer),
+            Item::Struct(s) => {
+                clean_doc_attrs(&mut s.attrs, &footer);
+
+                for f in s.fields.iter_mut() {
+                    clean_doc_attrs(&mut f.attrs, &footer);
+                }
+            }
+            Item::Enum(e) => {
+                clean_doc_attrs(&mut e.attrs, &footer);
+
+                for v in e.variants.iter_mut() {
+                    clean_doc_attrs(&mut v.attrs, &footer);
+                }
+            }
+            Item::Union(u) => {
+                clean_doc_attrs(&mut u.attrs, &footer);
+
+                for u in u.fields.named.iter_mut() {
+                    clean_doc_attrs(&mut u.attrs, &footer);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(())
+}
+
+fn clean_doc_line(attr: &mut Attribute) -> bool {
+    if !attr.path().is_ident("doc") {
+        return false;
+    }
+
+    let mut deprecated: bool = false;
+
+    if let Meta::NameValue(name_value) = &mut attr.meta {
+        if let Expr::Lit(expr_lit) = &mut name_value.value {
+            if let Lit::Str(lit_str) = &mut expr_lit.lit {
+                let cleaned = lit_str.value();
+                let cleaned = cleaned.trim_matches('"').trim();
+                let cleaned = URL_REGEX.replace_all(cleaned, "<${0}>");
+                let cleaned =
+                    DOC_SECTION_REGEX.replace_all(&cleaned, |captures: &regex::Captures| {
+                        if let Some(header) = captures.get(1) {
+                            format!("---\n ### {}\n", capitalize(header.as_str())).into()
+                        } else {
+                            Cow::Borrowed("")
+                        }
+                    });
+                let cleaned = PARAM_DIRECTIVE_REGEX.replace(&cleaned, "- **$1** `$2` $3");
+                let cleaned = OTHER_DIRECTIVE_REGEX.replace(&cleaned, "- **$1** $2");
+                let mut cleaned = BARE_CODE_REF_REGEX.replace_all(&cleaned, "${1}[`${2}`]");
+
+                if cleaned.is_empty() {
+                    cleaned = "\n".into();
+                }
+
+                if cleaned.contains("@deprecated") {
+                    deprecated = true;
+                }
+
+                *lit_str = LitStr::new(cleaned.borrow(), lit_str.span());
+            }
+        }
+    }
+
+    deprecated
+}
+
+fn clean_doc_attrs(attrs: &mut Vec<Attribute>, footer: &str) {
+    let mut deprecated: bool = false;
+
+    for attr in attrs.iter_mut() {
+        if clean_doc_line(attr) {
+            deprecated = true;
+        };
+    }
+
+    attrs.push(syn::parse_quote! {
+        #[doc = #footer]
+    });
+
+    if deprecated {
+        attrs.push(syn::parse_quote! {
+            #[deprecated]
+        })
+    }
+}
+
+fn doc_footer(ruby_version: &str) -> String {
+    format!(
+        "\n---\n\nGenerated by [rb-sys]({}) for Ruby {}",
+        env!("CARGO_PKG_REPOSITORY"),
+        ruby_version
+    )
+}
+
+fn capitalize(input: &str) -> Cow<'_, str> {
+    if let Some(first) = input.chars().next() {
+        if first.is_ascii_uppercase() && input[1..].chars().all(|c| c.is_ascii_lowercase()) {
+            Cow::Borrowed(input)
+        } else {
+            let mut result = String::with_capacity(input.len());
+            result.push(first.to_ascii_uppercase());
+            result.push_str(&input[1..].to_ascii_lowercase());
+            Cow::Owned(result)
+        }
+    } else {
+        Cow::Borrowed(input)
+    }
+}

data/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/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