glib2 4.3.6 → 4.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8949cf46b34ae921ab43a60165c8f0d887106fa6c51683756abba836dee8c7
-  data.tar.gz: 228cc639dad9178cf9addeb8b4b39f52abc38cdea38cafda2c49765057d44e83
+  metadata.gz: a0c2e2040f0df1627b2664fff3df265629b9b622d34d35f246246d6dde604c84
+  data.tar.gz: b373afa94a243519321eb03866691959d8c2bf6eb63dbce7d59d288cf0df9d4d
 SHA512:
-  metadata.gz: 767513877daa200b92dee690e0f32e19cb1d72832894a0328a37406df3f963edbebfa113caaa911ee687a19d06ed257152f49e075ec6f4cbf1247544b6b58f22
-  data.tar.gz: 78378d1881f14171228ffef6d6b3470eecac9b7bf05f490f943c1d296f96e4a7dfc944baf4687d511c238f7fe040ec8073f2cf8f906573d5913d60726db0a008
+  metadata.gz: ad10988ccbb9f9792195752bb7f39b7aa0b7e7ec31fe41fb332a74879b1dc1a267f78e239e94fd6e25625a90ae88d2c5abb6b8c0c282cb9c8b54cb833ad22a72
+  data.tar.gz: 7098c0bdea81d6cc7c2cb430f9f67fa3166359f3a293f7fbefbb50f0f39a2eca4f3c9a6f6e06a3a32d978e1f2ade9bfe546fcb1a1f04d774714abd9ddb7206de

data/ext/glib2/extconf.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2002-2025  Ruby-GNOME Project Team
+# Copyright (C) 2002-2026  Ruby-GNOME Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -39,6 +39,16 @@ unless required_pkg_config_package([package_id, 2, 56, 0],
   exit(false)
 end
 PKGConfig.have_package('gthread-2.0')
+if ENV["RUBY_GNOME_GLIB2_GIREPOSITORY_ENABLE"] == "yes"
+  have_girepository =
+    required_pkg_config_package(["girepository-2.0", 2, 80, 0],
+                                debian: "libgirepository-2.0-dev")
+else
+  have_girepository = false
+end
+if have_girepository
+  $defs << "-DHAVE_GIREPOSITORY"
+end
 
 have_header("unistd.h")
 have_header("io.h")
@@ -50,17 +60,11 @@ have_func("rb_check_array_type", ruby_header)
 have_func("rb_check_hash_type", ruby_header)
 have_func("rb_exec_recursive", ruby_header)
 have_func("rb_errinfo", ruby_header)
-have_func("rb_thread_call_without_gvl", ruby_header)
-have_func("ruby_native_thread_p", ruby_header)
-have_func("rb_thread_call_with_gvl", ruby_header)
 have_func("rb_gc_register_mark_object", ruby_header)
 have_func("rb_exc_new_str", ruby_header)
 # For Ruby 2.1. TODO: Remove this when we drop Ruby 2.1 support.
 have_func("rb_enc_str_new_static", ruby_header)
 
-have_var("curr_thread", [ruby_header, "node.h"])
-have_var("rb_curr_thread", [ruby_header, "node.h"])
-
 create_pkg_config_file("Ruby/GLib2", package_id)
 
 enum_types_prefix = "glib-enum-types"
@@ -92,6 +96,18 @@ glib_mkenums(enum_types_prefix,
              [],
              preamble: "#include \"rbgprivate.h\"")
 
+if have_girepository
+  girepository_headers = include_paths.split.inject([]) do |result, path|
+    result + Dir.glob(File.join(path.sub(/^-I/, ""), "girepository", "*.h"))
+  end
+  glib_mkenums("gi-enum-types",
+               girepository_headers,
+               "GI_TYPE_",
+               [],
+               id_prefix: "GI",
+               preamble: "#include <girepository/girepository.h>")
+end
+
 $defs << "-DRUBY_GLIB2_COMPILATION"
 
 create_makefile(module_name)

data/ext/glib2/glib2.def

@@ -160,6 +160,7 @@ EXPORTS
 	rbgutil_protect
 	rbgutil_on_callback_error
 	rbgutil_invoke_callback
+	rbgutil_invoke_callback_async
 	rbgutil_start_callback_dispatch_thread
 	rbgutil_stop_callback_dispatch_thread
 	rbgutil_string_set_utf8_encoding

data/ext/glib2/rbgi-arg-info.c

@@ -0,0 +1,226 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2026  Ruby-GNOME Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#ifdef HAVE_GIREPOSITORY
+#include "rbgi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIArgInfo
+#define SELF(self) (RVAL2GI_ARG_INFO(self))
+
+gboolean
+rbgi_arg_info_is_input_buffer(GIArgInfo *info)
+{
+    if (gi_arg_info_get_direction(info) != GI_DIRECTION_IN) {
+        return FALSE;
+    }
+
+    /* Heuristic */
+    const gchar *name = gi_base_info_get_name(GI_BASE_INFO(info));
+    if (strcmp(name, "buffer") != 0) {
+        return FALSE;
+    }
+
+    GITypeInfo type_info;
+    gi_arg_info_load_type_info(info, &type_info);
+    if (gi_type_info_get_tag(&type_info) != GI_TYPE_TAG_ARRAY) {
+        gi_base_info_clear(&type_info);
+        return FALSE;
+    }
+
+    GIArrayType array_type = gi_type_info_get_array_type(&type_info);
+    if (array_type != GI_ARRAY_TYPE_C) {
+        gi_base_info_clear(&type_info);
+        return FALSE;
+    }
+
+    unsigned int length_index;
+    if (!gi_type_info_get_array_length_index(&type_info, &length_index)) {
+        gi_base_info_clear(&type_info);
+        return FALSE;
+    }
+
+    GITypeInfo *element_type_info = gi_type_info_get_param_type(&type_info, 0);
+    GITypeTag element_type_tag = gi_type_info_get_tag(element_type_info);
+    gi_base_info_unref(element_type_info);
+    gi_base_info_clear(&type_info);
+    return element_type_tag == GI_TYPE_TAG_UINT8;
+}
+
+gboolean
+rbgi_arg_info_is_output_buffer(GIArgInfo *info)
+{
+    if (gi_arg_info_get_direction(info) != GI_DIRECTION_OUT) {
+        return FALSE;
+    }
+
+    if (!gi_arg_info_is_caller_allocates(info)) {
+        return FALSE;
+    }
+
+    GITypeInfo type_info;
+    gi_arg_info_load_type_info(info, &type_info);
+    if (gi_type_info_get_tag(&type_info) != GI_TYPE_TAG_ARRAY) {
+        gi_base_info_clear(&type_info);
+        return FALSE;
+    }
+
+    GITypeInfo *element_type_info = gi_type_info_get_param_type(&type_info, 0);
+    GITypeTag element_type_tag = gi_type_info_get_tag(element_type_info);
+    gi_base_info_unref(element_type_info);
+    gi_base_info_clear(&type_info);
+    return element_type_tag == GI_TYPE_TAG_UINT8;
+}
+
+static VALUE
+rg_direction(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return GI_DIRECTION2RVAL(gi_arg_info_get_direction(info));
+}
+
+static VALUE
+rg_caller_allocates_p(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(gi_arg_info_is_caller_allocates(info));
+}
+
+static VALUE
+rg_return_value_p(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(gi_arg_info_is_return_value(info));
+}
+
+static VALUE
+rg_optional_p(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(gi_arg_info_is_optional(info));
+}
+
+static VALUE
+rg_may_be_null_p(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(gi_arg_info_may_be_null(info));
+}
+
+static VALUE
+rg_ownership_transfer(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return GI_TRANSFER2RVAL(gi_arg_info_get_ownership_transfer(info));
+}
+
+static VALUE
+rg_scope(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return GI_SCOPE_TYPE2RVAL(gi_arg_info_get_scope(info));
+}
+
+static VALUE
+rg_closure_index(VALUE self)
+{
+    GIArgInfo *info = SELF(self);
+    unsigned int closure_index;
+    if (gi_arg_info_get_closure_index(info, &closure_index)) {
+        return UINT2NUM(closure_index);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+rg_destroy_index(VALUE self)
+{
+    GIArgInfo *info = SELF(self);
+    unsigned int destroy_index;
+    if (gi_arg_info_get_destroy_index(info, &destroy_index)) {
+        return UINT2NUM(destroy_index);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+rg_type(VALUE self)
+{
+    GIArgInfo *info;
+
+    info = SELF(self);
+    return GOBJ2RVAL_UNREF(gi_arg_info_get_type_info(info));
+}
+
+static VALUE
+rg_input_buffer_p(VALUE self)
+{
+    GIArgInfo *info = SELF(self);
+    return CBOOL2RVAL(rbgi_arg_info_is_input_buffer(info));
+}
+
+static VALUE
+rg_output_buffer_p(VALUE self)
+{
+    GIArgInfo *info = SELF(self);
+    return CBOOL2RVAL(rbgi_arg_info_is_output_buffer(info));
+}
+
+void
+rbgi_arg_info_init(VALUE rb_mGLib)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GI_TYPE_ARG_INFO, "ArgInfo", rb_mGLib);
+
+    RG_DEF_METHOD(direction, 0);
+    RG_DEF_METHOD_P(caller_allocates, 0);
+    RG_DEF_METHOD_P(return_value, 0);
+    RG_DEF_METHOD_P(optional, 0);
+    RG_DEF_METHOD_P(may_be_null, 0);
+    RG_DEF_METHOD(ownership_transfer, 0);
+    RG_DEF_METHOD(scope, 0);
+    RG_DEF_METHOD(closure_index, 0);
+    RG_DEF_METHOD(destroy_index, 0);
+    RG_DEF_METHOD(type, 0);
+
+    RG_DEF_METHOD_P(input_buffer, 0);
+    RG_DEF_METHOD_P(output_buffer, 0);
+
+    G_DEF_CLASS(GI_TYPE_DIRECTION, "Direction", rb_mGLib);
+    G_DEF_CLASS(GI_TYPE_SCOPE_TYPE, "ScopeType", rb_mGLib);
+    G_DEF_CLASS(GI_TYPE_TRANSFER, "Transfer", rb_mGLib);
+}
+#endif

data/ext/glib2/rbgi-base-info.c

@@ -0,0 +1,223 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2026  Ruby-GNOME Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#ifdef HAVE_GIREPOSITORY
+#include "rbgi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGLibBaseInfo
+static VALUE RG_TARGET_NAMESPACE;
+#define SELF(self) RVAL2GI_BASE_INFO(self)
+
+static void
+rbgi_base_info_free(void *data)
+{
+    GIBaseInfo *info = data;
+    gi_base_info_unref(info);
+}
+
+static const rb_data_type_t rbgi_base_info_type = {
+    "GLib::BaseInfo",
+    {
+        NULL,
+        rbgi_base_info_free,
+        NULL,
+        NULL,
+    },
+    &rbg_glib_instantiatable_type,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY |
+    RUBY_TYPED_WB_PROTECTED |
+    RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+static VALUE
+rbgi_base_info_alloc_func(VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass,
+                                 &rbgi_base_info_type,
+                                 NULL);
+}
+
+static gpointer
+rbgi_base_info_robj2instance(VALUE rb_info, gpointer user_data)
+{
+    GIBaseInfo *info;
+    TypedData_Get_Struct(rb_info,
+                         GIBaseInfo,
+                         &rbgi_base_info_type,
+                         info);
+    return info;
+}
+
+static VALUE
+rbgi_base_info_instance2robj(gpointer instance, gpointer user_data)
+{
+    GIBaseInfo *info = instance;
+    if (!info) {
+        return Qnil;
+    }
+
+    VALUE klass = RG_TARGET_NAMESPACE;
+    GType type = G_TYPE_FROM_INSTANCE(info);
+    if (type == GI_TYPE_ARG_INFO) {
+        ID id_ArgInfo;
+        RUBY_CONST_ID(id_ArgInfo, "ArgInfo");
+        klass = rb_const_get(rbg_mGLib(), id_ArgInfo);
+    } else if (type == GI_TYPE_CALLABLE_INFO) {
+        ID id_CallableInfo;
+        RUBY_CONST_ID(id_CallableInfo, "CallableInfo");
+        klass = rb_const_get(rbg_mGLib(), id_CallableInfo);
+    } else if (type == GI_TYPE_CONSTANT_INFO) {
+        ID id_ConstantInfo;
+        RUBY_CONST_ID(id_ConstantInfo, "ConstantInfo");
+        klass = rb_const_get(rbg_mGLib(), id_ConstantInfo);
+    } else if (type == GI_TYPE_FUNCTION_INFO) {
+        ID id_FunctionInfo;
+        RUBY_CONST_ID(id_FunctionInfo, "FunctionInfo");
+        klass = rb_const_get(rbg_mGLib(), id_FunctionInfo);
+    } else if (type == GI_TYPE_INTERFACE_INFO) {
+        ID id_InterfaceInfo;
+        RUBY_CONST_ID(id_InterfaceInfo, "InterfaceInfo");
+        klass = rb_const_get(rbg_mGLib(), id_InterfaceInfo);
+    } else if (type == GI_TYPE_OBJECT_INFO) {
+        ID id_ObjectInfo;
+        RUBY_CONST_ID(id_ObjectInfo, "ObjectInfo");
+        klass = rb_const_get(rbg_mGLib(), id_ObjectInfo);
+    } else if (type == GI_TYPE_PROPERTY_INFO) {
+        ID id_PropertyInfo;
+        RUBY_CONST_ID(id_PropertyInfo, "PropertyInfo");
+        klass = rb_const_get(rbg_mGLib(), id_PropertyInfo);
+    } else if (type == GI_TYPE_SIGNAL_INFO) {
+        ID id_SignalInfo;
+        RUBY_CONST_ID(id_SignalInfo, "SignalInfo");
+        klass = rb_const_get(rbg_mGLib(), id_SignalInfo);
+    } else if (type == GI_TYPE_STRUCT_INFO) {
+        ID id_StructInfo;
+        RUBY_CONST_ID(id_StructInfo, "StructInfo");
+        klass = rb_const_get(rbg_mGLib(), id_StructInfo);
+    } else if (type == GI_TYPE_TYPE_INFO) {
+        ID id_TypeInfo;
+        RUBY_CONST_ID(id_TypeInfo, "TypeInfo");
+        klass = rb_const_get(rbg_mGLib(), id_TypeInfo);
+    } else if (type == GI_TYPE_VFUNC_INFO) {
+        ID id_VFuncInfo;
+        RUBY_CONST_ID(id_VFuncInfo, "VFuncInfo");
+        klass = rb_const_get(rbg_mGLib(), id_VFuncInfo);
+    }
+
+    gi_base_info_ref(info);
+    return TypedData_Wrap_Struct(klass, &rbgi_base_info_type, info);
+}
+
+static void
+rbgi_base_info_unref(gpointer instance, gpointer user_data)
+{
+    GIBaseInfo *info = instance;
+    if (!info) {
+        return;
+    }
+    gi_base_info_unref(info);
+}
+
+static VALUE
+rg_name(VALUE self)
+{
+    GIBaseInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(gi_base_info_get_name(info));
+}
+
+static VALUE
+rg_namespace(VALUE self)
+{
+    GIBaseInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(gi_base_info_get_namespace(info));
+}
+
+static VALUE
+rg_container(VALUE self)
+{
+    GIBaseInfo *info = SELF(self);
+    return GOBJ2RVAL(gi_base_info_get_container(info));
+}
+
+static VALUE
+rg_operator_aref(VALUE self, VALUE name)
+{
+    GIBaseInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(gi_base_info_get_attribute(info, RVAL2CSTR(name)));
+}
+
+static VALUE
+rg_each(VALUE self)
+{
+    GIAttributeIter iter = {0, };
+    GIBaseInfo *info;
+    const gchar *name, *value;
+
+    RETURN_ENUMERATOR(self, 0, NULL);
+
+    info = SELF(self);
+    while (gi_base_info_iterate_attributes(info, &iter, &name, &value)) {
+	VALUE rb_name, rb_value;
+	rb_name  = CSTR2RVAL(name);
+	rb_value = CSTR2RVAL(value);
+	rb_yield(rb_ary_new3(2, rb_name, rb_value));
+    }
+
+    return Qnil;
+}
+
+void
+rbgi_base_info_init(VALUE rb_mGLib)
+{
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GI_TYPE_BASE_INFO, "BaseInfo", rb_mGLib);
+    rb_define_alloc_func(RG_TARGET_NAMESPACE, rbgi_base_info_alloc_func);
+
+    RGConvertTable table = {
+      .type = GI_TYPE_BASE_INFO,
+      .klass = RG_TARGET_NAMESPACE,
+      .user_data = NULL,
+      .notify = NULL,
+      .get_superclass = NULL,
+      .type_init_hook = NULL,
+      .rvalue2gvalue = NULL,
+      .gvalue2rvalue = NULL,
+      .initialize = NULL,
+      .robj2instance = rbgi_base_info_robj2instance,
+      .instance2robj = rbgi_base_info_instance2robj,
+      .unref = rbgi_base_info_unref,
+    };
+    RG_DEF_CONVERSION(&table);
+
+    rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);
+
+    RG_DEF_METHOD(name, 0);
+    RG_DEF_METHOD(namespace, 0);
+    RG_DEF_METHOD(container, 0);
+    RG_DEF_METHOD_OPERATOR("[]", aref, 1);
+    RG_DEF_METHOD(each, 0);
+}
+#endif

data/ext/glib2/rbgi-callable-info.c

@@ -0,0 +1,145 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2026  Ruby-GNOME Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#ifdef HAVE_GIREPOSITORY
+#include "rbgi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGICallableInfo
+#define SELF(self) RVAL2GI_CALLABLE_INFO(self)
+
+static VALUE
+rg_set_lock_gvl_default(VALUE self, VALUE rb_boolean)
+{
+    return rb_iv_set(self, "lock_gvl_default", rb_boolean);
+}
+
+static VALUE
+rg_add_lock_gvl_predicate(VALUE self)
+{
+    VALUE rb_predicates;
+    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("lock_gvl_predicates")))) {
+        rb_predicates = rb_ary_new();
+        rb_iv_set(self, "lock_gvl_predicates", rb_predicates);
+    } else {
+        rb_predicates = rb_iv_get(self, "lock_gvl_predicates");
+    }
+    rb_ary_push(rb_predicates, rb_block_lambda());
+    return Qnil;
+}
+
+static VALUE
+rg_lock_gvl_p(int argc, VALUE *argv, VALUE self)
+{
+    VALUE rb_receiver;
+    VALUE rb_lock_gvl_default = Qtrue;
+    rb_scan_args(argc, argv, "01", &rb_receiver);
+    if (RVAL2CBOOL(rb_ivar_defined(self, rb_intern("lock_gvl_default")))) {
+        rb_lock_gvl_default = rb_iv_get(self, "lock_gvl_default");
+    }
+    if (NIL_P(rb_receiver)) {
+        return rb_lock_gvl_default;
+    }
+    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("lock_gvl_predicates")))) {
+        return rb_lock_gvl_default;
+    }
+    VALUE rb_predicates = rb_iv_get(self, "lock_gvl_predicates");
+    long n = RARRAY_LEN(rb_predicates);
+    long i;
+    VALUE rb_args = rb_ary_new_from_args(2,
+                                         self,
+                                         rb_receiver);
+    VALUE rb_lock_gvl = rb_lock_gvl_default;
+    RARRAY_PTR_USE(rb_predicates, rb_predicates_raw, {
+        for (i = 0; i < n; i++) {
+            VALUE rb_predicate = rb_predicates_raw[n - i - 1];
+            VALUE rb_result = rb_proc_call(rb_predicate, rb_args);
+            if (NIL_P(rb_result)) {
+                continue;
+            }
+            rb_lock_gvl = rb_result;
+            break;
+        }
+    });
+    return rb_lock_gvl;
+}
+
+static VALUE
+rg_can_throw_gerror_p(VALUE self)
+{
+    GICallableInfo *info = SELF(self);
+    return CBOOL2RVAL(gi_callable_info_can_throw_gerror(info));
+}
+
+static VALUE
+rg_return_type(VALUE self)
+{
+    GICallableInfo *info = SELF(self);
+    return GOBJ2RVAL_UNREF(gi_callable_info_get_return_type(info));
+}
+
+static VALUE
+rg_caller_owns(VALUE self)
+{
+    GICallableInfo *info = SELF(self);
+    return GI_TRANSFER2RVAL(gi_callable_info_get_caller_owns(info));
+}
+
+static VALUE
+rg_may_return_null_p(VALUE self)
+{
+    GICallableInfo *info = SELF(self);
+    return CBOOL2RVAL(gi_callable_info_may_return_null(info));
+}
+
+static VALUE
+rg_n_args(VALUE self)
+{
+    GICallableInfo *info = SELF(self);
+    return INT2NUM(gi_callable_info_get_n_args(info));
+}
+
+static VALUE
+rg_get_arg(VALUE self, VALUE rb_n)
+{
+    GICallableInfo *info = SELF(self);
+    gint n = NUM2INT(rb_n);
+    return GOBJ2RVAL_UNREF(gi_callable_info_get_arg(info, n));
+}
+
+void
+rbgi_callable_info_init(VALUE rb_mGLib)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+        G_DEF_CLASS(GI_TYPE_CALLABLE_INFO, "CallableInfo", rb_mGLib);
+
+    RG_DEF_METHOD(set_lock_gvl_default, 1);
+    RG_DEF_METHOD(add_lock_gvl_predicate, 0);
+    RG_DEF_METHOD_P(lock_gvl, -1);
+
+    RG_DEF_METHOD_P(can_throw_gerror, 0);
+    RG_DEF_METHOD(return_type, 0);
+    RG_DEF_METHOD(caller_owns, 0);
+    RG_DEF_METHOD_P(may_return_null, 0);
+    RG_DEF_METHOD(n_args, 0);
+    RG_DEF_METHOD(get_arg, 1);
+}
+#endif

data/ext/glib2/rbgi-conversions.h

@@ -0,0 +1,36 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2026  Ruby-GNOME Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#pragma once
+
+#define RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags) \
+    (RVAL2GFLAGS(rb_flags, GI_TYPE_REPOSITORY_LOAD_FLAGS))
+
+#define RVAL2GI_ARG_INFO(rb_info)       GI_ARG_INFO(RVAL2GOBJ(rb_info))
+#define RVAL2GI_BASE_INFO(rb_info)      GI_BASE_INFO(RVAL2GOBJ(rb_info))
+#define RVAL2GI_CALLABLE_INFO(rb_info)  GI_CALLABLE_INFO(RVAL2GOBJ(rb_info))
+#define RVAL2GI_INTERFACE_INFO(rb_info) GI_INTERFACE_INFO(RVAL2GOBJ(rb_info))
+#define RVAL2GI_TYPE_INFO(rb_info)      GI_TYPE_INFO(RVAL2GOBJ(rb_info))
+
+#define GI_ARRAY_TYPE2RVAL(type)     (GENUM2RVAL(type, GI_TYPE_ARRAY_TYPE))
+#define GI_DIRECTION2RVAL(direction) (GENUM2RVAL(direction, GI_TYPE_DIRECTION))
+#define GI_SCOPE_TYPE2RVAL(scope)    (GENUM2RVAL(scope, GI_TYPE_SCOPE_TYPE))
+#define GI_TRANSFER2RVAL(transfer)   (GENUM2RVAL(transfer, GI_TYPE_TRANSFER))
+#define GI_TYPE_TAG2RVAL(tag)        (GENUM2RVAL(tag, GI_TYPE_TYPE_TAG))