glib2 4.3.6 → 4.3.8

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

@@ -0,0 +1,167 @@
+/* -*- 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_cGIInterfaceInfo
+#define SELF(self) (RVAL2GI_INTERFACE_INFO(self))
+
+static VALUE
+rg_n_prerequisites(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return UINT2NUM(gi_interface_info_get_n_prerequisites(info));
+}
+
+static VALUE
+rg_get_prerequisite(VALUE self, VALUE rb_n)
+{
+    GIInterfaceInfo *info = SELF(self);
+    unsigned int n = NUM2UINT(rb_n);
+    return GOBJ2RVAL_UNREF(gi_interface_info_get_prerequisite(info, n));
+}
+
+static VALUE
+rg_n_properties(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return UINT2NUM(gi_interface_info_get_n_properties(info));
+}
+
+static VALUE
+rg_get_property(VALUE self, VALUE rb_n)
+{
+    GIInterfaceInfo *info = SELF(self);
+    unsigned int n = NUM2UINT(rb_n);
+    return GOBJ2RVAL_UNREF(gi_interface_info_get_property(info, n));
+}
+
+static VALUE
+rg_n_methods(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return UINT2NUM(gi_interface_info_get_n_methods(info));
+}
+
+static VALUE
+rg_get_method(VALUE self, VALUE rb_n_or_name)
+{
+    GIInterfaceInfo *info = SELF(self);
+    GIFunctionInfo *function_info;
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
+        unsigned int n = NUM2UINT(rb_n_or_name);
+        function_info = gi_interface_info_get_method(info, n);
+    } else {
+        const char *name = RVAL2CSTR(rb_n_or_name);
+        function_info = gi_interface_info_find_method(info, name);
+    }
+    return GOBJ2RVAL_UNREF(function_info);
+}
+
+static VALUE
+rg_n_signals(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return UINT2NUM(gi_interface_info_get_n_signals(info));
+}
+
+static VALUE
+rg_get_signal(VALUE self, VALUE rb_n_or_name)
+{
+    GIInterfaceInfo *info = SELF(self);
+    GISignalInfo *signal_info;
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
+        unsigned int n = NUM2UINT(rb_n_or_name);
+        signal_info = gi_interface_info_get_signal(info, n);
+    } else {
+        const char *name = RVAL2CSTR(rb_n_or_name);
+        signal_info = gi_interface_info_find_signal(info, name);
+    }
+    return GOBJ2RVAL_UNREF(signal_info);
+}
+
+static VALUE
+rg_n_vfuncs(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return UINT2NUM(gi_interface_info_get_n_vfuncs(info));
+}
+
+static VALUE
+rg_get_vfunc(VALUE self, VALUE rb_n_or_name)
+{
+    GIInterfaceInfo *info = SELF(self);
+    GIVFuncInfo *vfunc_info;
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
+        unsigned int n = NUM2UINT(rb_n_or_name);
+        vfunc_info = gi_interface_info_get_vfunc(info, n);
+    } else {
+        const gchar *name = RVAL2CSTR(rb_n_or_name);
+        vfunc_info = gi_interface_info_find_vfunc(info, name);
+    }
+    return GOBJ2RVAL_UNREF(vfunc_info);
+}
+
+static VALUE
+rg_n_constants(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return UINT2NUM(gi_interface_info_get_n_constants(info));
+}
+
+static VALUE
+rg_get_constant(VALUE self, VALUE rb_n)
+{
+    GIInterfaceInfo *info = SELF(self);
+    unsigned int n = NUM2UINT(rb_n);
+    return GOBJ2RVAL_UNREF(gi_interface_info_get_constant(info, n));
+}
+
+static VALUE
+rg_iface_struct(VALUE self)
+{
+    GIInterfaceInfo *info = SELF(self);
+    return GOBJ2RVAL_UNREF(gi_interface_info_get_iface_struct(info));
+}
+
+void
+rbgi_interface_info_init(VALUE rb_mGLib)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS(GI_TYPE_INTERFACE_INFO, "InterfaceInfo", rb_mGLib);
+
+    RG_DEF_METHOD(n_prerequisites, 0);
+    RG_DEF_METHOD(get_prerequisite, 1);
+    RG_DEF_METHOD(n_properties, 0);
+    RG_DEF_METHOD(get_property, 1);
+    RG_DEF_METHOD(n_methods, 0);
+    RG_DEF_METHOD(get_method, 1);
+    RG_DEF_METHOD(n_signals, 0);
+    RG_DEF_METHOD(get_signal, 1);
+    RG_DEF_METHOD(n_vfuncs, 0);
+    RG_DEF_METHOD(get_vfunc, 1);
+    RG_DEF_METHOD(n_constants, 0);
+    RG_DEF_METHOD(get_constant, 1);
+    RG_DEF_METHOD(iface_struct, 0);
+}
+#endif

data/ext/glib2/rbgi-private.h

@@ -0,0 +1,42 @@
+/* -*- 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
+
+#include "rbgprivate.h"
+#include "rbglib2conversions.h"
+
+#include <girepository/girepository.h>
+#include <girepository/girffi.h>
+
+#include "gi-enum-types.h"
+#include "rbgi-conversions.h"
+
+G_GNUC_INTERNAL void rbgi_arg_info_init(VALUE mGLib);
+G_GNUC_INTERNAL void rbgi_callable_info_init(VALUE mGLib);
+G_GNUC_INTERNAL void rbgi_base_info_init(VALUE mGLib);
+G_GNUC_INTERNAL void rbgi_interface_info_init(VALUE mGLib);
+G_GNUC_INTERNAL void rbgi_repository_init(VALUE mGLib);
+G_GNUC_INTERNAL void rbgi_type_info_init(VALUE mGLib);
+
+G_GNUC_INTERNAL gboolean
+rbgi_arg_info_is_input_buffer(GIArgInfo *info);
+G_GNUC_INTERNAL gboolean
+rbgi_arg_info_is_output_buffer(GIArgInfo *info);

data/ext/glib2/rbgi-repository.c

@@ -0,0 +1,276 @@
+/* -*- 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_cGLibRepository
+static VALUE RG_TARGET_NAMESPACE;
+#define SELF(self) RVAL2GOBJ(self)
+
+#if GLIB_CHECK_VERSION(2, 86, 0)
+/* Returns the singleton process-global default
+ * GLib::Repository. It is not currently supported to have
+ * multiple repositories in a particular process, but this function is provided
+ * in the unlikely eventuality that it would become possible, and as a
+ * convenience for higher level language bindings to conform to the GObject
+ * method call conventions.
+ *
+ * @return [GLib::Repository] The global singleton
+ *         GLib::Repository.
+ */
+static VALUE
+rg_s_default(G_GNUC_UNUSED VALUE klass)
+{
+    return GOBJ2RVAL_UNREF(gi_repository_dup_default());
+}
+#endif
+
+static VALUE
+rg_prepend_search_path(VALUE self, VALUE rb_path)
+{
+    gi_repository_prepend_search_path(SELF(self), RVAL2CSTR(rb_path));
+    return self;
+}
+
+static VALUE
+rg_search_path(VALUE self)
+{
+    GIRepository *repository = SELF(self);
+    size_t n_paths;
+    const gchar *const *paths =
+        gi_repository_get_search_path(repository, &n_paths);
+    VALUE rb_paths = rb_ary_new_capa(n_paths);
+    for (size_t i = 0; i < n_paths; i++) {
+        rb_ary_push(rb_paths, CSTR2RVAL(paths[i]));
+    }
+    return rb_paths;
+}
+
+/* Force the namespace to be loaded if it isn't already. If namespace is not
+ * loaded, this function will search for a ".typelib" file using the repository
+ * search path. In addition, a version of namespace may be specified. If version
+ * is not specified, the latest will be used.
+ *
+ * @param [String] namespace The namespace to load
+ * @param [String, nil] version An optional version
+ */
+static VALUE
+rg_require(int argc, VALUE *argv, VALUE self)
+{
+    VALUE rb_namespace, rb_version, rb_flags;
+    const gchar *namespace_, *version;
+    GIRepositoryLoadFlags flags = 0;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "12", &rb_namespace, &rb_version, &rb_flags);
+
+    namespace_ = RVAL2CSTR(rb_namespace);
+    version = RVAL2CSTR_ACCEPT_NIL(rb_version);
+    if (!NIL_P(rb_flags)) {
+        flags = RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags);
+    }
+
+    gi_repository_require(SELF(self), namespace_, version, flags, &error);
+    if (error) {
+        RG_RAISE_ERROR(error);
+    }
+
+    return Qnil;
+}
+
+
+/* Return an array of all (transitive) versioned dependencies for namespace.
+ * Returned strings are of the form "namespace-version".
+ * Note: namespace must have already been loaded using a function such as
+ * GLib::Repository.require() before calling this method.
+ *
+ * @param [String] namespace The namespace to get the dependencies for.
+ *
+ * @return [Array<String>] The dependencies.
+ */
+static VALUE
+rg_get_dependencies(VALUE self, VALUE rb_namespace)
+{
+    GIRepository *repository = SELF(self);
+    const gchar *namespace_ = RVAL2CSTR(rb_namespace);
+    size_t n_dependencies;
+    gchar **dependencies = gi_repository_get_dependencies(repository, namespace_, &n_dependencies);
+    if (!dependencies) {
+        return Qnil;
+    }
+
+    VALUE rb_dependencies = rb_ary_new_capa(n_dependencies);
+    for (size_t i = 0; dependencies[i]; i++) {
+        rb_ary_push(rb_dependencies, CSTR2RVAL_FREE(dependencies[i]));
+    }
+    g_free(dependencies);
+
+    return rb_dependencies;
+}
+
+
+/* Return the list of currently loaded namespaces.
+ *
+ * @return [Array<String>] The loaded namespaces.
+ */
+static VALUE
+rg_loaded_namespaces(VALUE self)
+{
+    GIRepository *repository = SELF(self);
+    size_t n_namespaces;
+    gchar **namespaces = gi_repository_get_loaded_namespaces(repository, &n_namespaces);
+    if (!namespaces) {
+        return Qnil;
+    }
+    VALUE rb_namespaces = rb_ary_new_capa(n_namespaces);
+    for (size_t i = 0; namespaces[i]; i++) {
+        rb_ary_push(rb_namespaces, CSTR2RVAL_FREE(namespaces[i]));
+    }
+    g_free(namespaces);
+
+    return rb_namespaces;
+}
+
+
+/* This method returns the number of metadata entries in given namespace. The
+ * namespace must have already been loaded before calling this function.
+ *
+ * @param [String] namespace The namespace to fetch the entries from.
+ *
+ * @return [Integer] The number of metadata entries.
+ */
+static VALUE
+rg_get_n_infos(VALUE self, VALUE rb_namespace)
+{
+    const gchar *namespace_;
+    gint n_infos;
+
+    namespace_ = RVAL2CSTR(rb_namespace);
+    n_infos = gi_repository_get_n_infos(SELF(self), namespace_);
+
+    return INT2NUM(n_infos);
+}
+
+
+/* This method returns a particular metadata entry in the given namespace. The
+ *  namespace must have already been loaded before calling this function. See
+ *  GLib::Repository#get_n_infos() to find the maximum number
+ *  of entries.
+ *
+ * @param [String] namespace The namespace to fetch the metadata entry from.
+ * @param [Fixnum] index The index of the entry.
+ *
+ * @return [GLib::BaseInfo] The metadata entry.
+ */
+static VALUE
+rg_get_info(VALUE self, VALUE rb_namespace, VALUE rb_n)
+{
+    GIRepository *repository;
+    const gchar *namespace_;
+    gint n;
+    GIBaseInfo *info;
+
+    repository = SELF(self);
+    namespace_ = RVAL2CSTR(rb_namespace);
+    n = NUM2INT(rb_n);
+    info = gi_repository_get_info(repository, namespace_, n);
+    return GOBJ2RVAL_UNREF(info);
+}
+
+
+/* This method searches for a particular type or name. If only one argument is
+ * given, it is interpreted as a gtype and all loaded namespaces are searched
+ * for it. If two arguments are given the first is a particular namespace and
+ * the second the name of an entry to search for.
+ *
+ * @overload find(type)
+ *
+ * @param [String] type The type to search for.
+ *
+ * @return [GLib::BaseInfo] The metadata entry.
+ *
+ *
+ * @overload find(namespace, type)
+ *
+ * @param [String] namespace The namespace to search in.
+ *
+ * @param [String] type The type to search for.
+ *
+ * @return [GLib::BaseInfo] The metadata entry.
+ */
+static VALUE
+rg_find(int argc, VALUE *argv, VALUE self)
+{
+    GIBaseInfo *info;
+
+    if (argc == 1) {
+        VALUE rb_gtype;
+        GType gtype;
+        rb_gtype = argv[0];
+        gtype = rbgobj_gtype_from_ruby(rb_gtype);
+        info = gi_repository_find_by_gtype(SELF(self), gtype);
+    } else {
+        VALUE rb_namespace, rb_name;
+        const gchar *namespace_, *name;
+
+        rb_scan_args(argc, argv, "2", &rb_namespace, &rb_name);
+        namespace_ = RVAL2CSTR(rb_namespace);
+        name = RVAL2CSTR(rb_name);
+        info = gi_repository_find_by_name(SELF(self), namespace_, name);
+    }
+
+    return GOBJ2RVAL_UNREF(info);
+}
+
+static VALUE
+rg_get_version(VALUE self, VALUE rb_namespace)
+{
+    const gchar *version;
+    version = gi_repository_get_version(SELF(self), RVAL2CSTR(rb_namespace));
+    return CSTR2RVAL(version);
+}
+
+void
+rbgi_repository_init(VALUE rb_mGLib)
+{
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GI_TYPE_REPOSITORY, "Repository", rb_mGLib);
+
+#if GLIB_CHECK_VERSION(2, 86, 0)
+    RG_DEF_SMETHOD(default, 0);
+#endif
+    RG_DEF_METHOD(prepend_search_path, 1);
+    RG_DEF_METHOD(search_path, 0);
+    RG_DEF_METHOD(require, -1);
+    RG_DEF_METHOD(get_dependencies, 1);
+    RG_DEF_METHOD(loaded_namespaces, 0);
+    RG_DEF_METHOD(get_n_infos, 1);
+    RG_DEF_METHOD(get_info, 2);
+    RG_DEF_METHOD(find, -1);
+    RG_DEF_METHOD(get_version, 1);
+
+    G_DEF_CLASS(GI_TYPE_REPOSITORY_LOAD_FLAGS, "RepositoryLoadFlags", rb_mGLib);
+    G_DEF_ERROR(GI_REPOSITORY_ERROR,
+                "RepositoryError",
+                rb_mGLib,
+                rb_eLoadError,
+                GI_TYPE_REPOSITORY_ERROR);
+}
+#endif

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

@@ -0,0 +1,113 @@
+/* -*- 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_cGITypeInfo
+#define SELF(self) (RVAL2GI_TYPE_INFO(self))
+
+static VALUE
+rg_pointer_p(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    return CBOOL2RVAL(gi_type_info_is_pointer(info));
+}
+
+static VALUE
+rg_tag(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    return GI_TYPE_TAG2RVAL(gi_type_info_get_tag(info));
+}
+
+static VALUE
+rg_get_param_type(VALUE self, VALUE rb_n)
+{
+    GITypeInfo *info = SELF(self);
+    gint n = NUM2INT(rb_n);
+    return GOBJ2RVAL_UNREF(gi_type_info_get_param_type(info, n));
+}
+
+static VALUE
+rg_interface(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    return GOBJ2RVAL_UNREF(gi_type_info_get_interface(info));
+}
+
+static VALUE
+rg_array_length_index(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    unsigned int length;
+    if (gi_type_info_get_array_length_index(info, &length)) {
+        return INT2NUM(length);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+rg_array_fixed_size(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    size_t size;
+    if (gi_type_info_get_array_fixed_size(info, &size)) {
+        return SIZET2NUM(size);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+rg_zero_terminated_p(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    return CBOOL2RVAL(gi_type_info_is_zero_terminated(info));
+}
+
+static VALUE
+rg_array_type(VALUE self)
+{
+    GITypeInfo *info = SELF(self);
+    return GI_ARRAY_TYPE2RVAL(gi_type_info_get_array_type(info));
+}
+
+void
+rbgi_type_info_init(VALUE rb_mGLib)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS(GI_TYPE_TYPE_INFO, "TypeInfo", rb_mGLib);
+
+    RG_DEF_METHOD_P(pointer, 0);
+    RG_DEF_METHOD(tag, 0);
+    RG_DEF_METHOD(get_param_type, 1);
+    RG_DEF_METHOD(interface, 0);
+    RG_DEF_METHOD(array_length_index, 0);
+    RG_DEF_METHOD(array_fixed_size, 0);
+    RG_DEF_METHOD_P(zero_terminated, 0);
+    RG_DEF_METHOD(array_type, 0);
+
+    rb_undef_method(RG_TARGET_NAMESPACE, "name");
+}
+#endif

data/ext/glib2/rbglib.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2025  Ruby-GNOME Project Team
+ *  Copyright (C) 2011-2026  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -22,6 +22,9 @@
 #include <locale.h>
 #include "rbgprivate.h"
 #include "rbglib.h"
+#ifdef HAVE_GIREPOSITORY
+#  include "rbgi-private.h"
+#endif
 
 #define RG_TARGET_NAMESPACE rbg_mGLib()
 
@@ -1294,4 +1297,43 @@ union       GDoubleIEEE754;
     Init_glib_time_zone();
     Init_glib_bytes();
     Init_glib_option();
+
+#ifdef HAVE_GIREPOSITORY
+    rbgi_base_info_init(rbg_mGLib());
+
+    rbgi_arg_info_init(rbg_mGLib());
+    rbgi_callable_info_init(rbg_mGLib());
+    /* TODO */
+    /* rbgi_constant_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_CONSTANT_INFO, "ConstantInfo", rbg_mGLib());
+    /* TODO */
+    /* rbgi_function_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_FUNCTION_INFO, "FunctionInfo", rbg_mGLib());
+    rbgi_interface_info_init(rbg_mGLib());
+    /* TODO */
+    /* rbgi_object_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_OBJECT_INFO, "ObjectInfo", rbg_mGLib());
+    /* TODO */
+    /* rbgi_property_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_PROPERTY_INFO, "PropertyInfo", rbg_mGLib());
+    /* TODO */
+    /* rbgi_signal_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_SIGNAL_INFO, "SignalInfo", rbg_mGLib());
+    /* TODO */
+    /* rbgi_struct_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_STRUCT_INFO, "StructInfo", rbg_mGLib());
+    rbgi_type_info_init(rbg_mGLib());
+    /* TODO */
+    /* rbgi_vfunc_info_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_VFUNC_INFO, "VFuncInfo", rbg_mGLib());
+
+    /* TODO */
+    /* rbgi_array_type_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_ARRAY_TYPE, "ArrayType", rbg_mGLib());
+    /* TODO */
+    /* rbgi_type_tag_init(rbg_mGLib()); */
+    G_DEF_CLASS(GI_TYPE_TYPE_TAG, "TypeTag", rbg_mGLib());
+
+    rbgi_repository_init(rbg_mGLib());
+#endif
 }

data/ext/glib2/rbglib.h

@@ -33,7 +33,7 @@ G_BEGIN_DECLS
 
 #define RBGLIB_MAJOR_VERSION 4
 #define RBGLIB_MINOR_VERSION 3
-#define RBGLIB_MICRO_VERSION 6
+#define RBGLIB_MICRO_VERSION 8
 
 /* For Ruby < 3.0 */
 #ifndef RB_LL2NUM