gobject-introspection 4.2.2 → 4.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c61aee26486f30c6b35b119b1c35201c2685e48c7dd9a98dd5aebd72909be13
-  data.tar.gz: e980ad964b3a3318743e893e0c7a22ba94070f4c4735b023fe7dec75e1dca24e
+  metadata.gz: 56c0dd8e60b55f1e3266c0de7f57f485f85e70e5ade87dccdc59c9197dcfbc0a
+  data.tar.gz: 37d13858c25e07f365468b479e830b9f925920a6991845fbfdde0aaef3330517
 SHA512:
-  metadata.gz: 4e52bda34bc55b6bdd093038cd315e4c7cce19daf165a0e2e72f0848d867786e4120002b456f58c53767c1d82ce6338f82a87ca4516a7a168c85e2bc46c617cc
-  data.tar.gz: 961ff4d28666a403b7c6465e7e8b66f02bcb2e04b38ceea9343d1a16883afc7a78ed77c50cf77ff99a0f7092228ac411ea54338e09f3b00c4a6d89214de41c97
+  metadata.gz: 3e37700bb0c08a31f0df8833a2ca4e8328d029fdcd1dc9bb5849c499f38b666f2c9a7fad8bc05f7cc721df6349658299fe37e613bce0a37c1860026ac9ea5845
+  data.tar.gz: 0af1bbeb5bfc6b56a2072fc6c597829be6516a5975a4dcdaeed966a557080312939158460454d7ff5542f719c0ae067c9f5fda48a794a9d6129b6fb705bb6b2c

data/README.md

@@ -5,7 +5,7 @@ Ruby/GObjectIntrospection is a Ruby binding of GObject Introspect.
 ## Requirements
 
 * Ruby/GLib2 in
-  [Ruby-GNOME2](https://ruby-gnome2.osdn.jp/)
+  [Ruby-GNOME2](https://ruby-gnome.github.io/)
 * [GObject Introspection](http://live.gnome.org/GObjectIntrospection)
 
 ## Install
@@ -21,4 +21,4 @@ under the terms of the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
 
 ## Project Website
 
-https://ruby-gnome2.osdn.jp/
+https://ruby-gnome.github.io/

data/Rakefile

@@ -17,10 +17,10 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 $LOAD_PATH.unshift("./../glib2/lib")
-require "gnome2/rake/package-task"
+require "gnome/rake/package-task"
 
 package_name = File.basename(__dir__)
 spec = Gem::Specification.load("#{package_name}.gemspec")
 
-GNOME2::Rake::PackageTask.define(spec, __dir__) do |package|
+GNOME::Rake::PackageTask.define(spec, __dir__) do |package|
 end

data/ext/gobject-introspection/rb-gi-arguments-out.c

@@ -103,14 +103,20 @@ rb_gi_arguments_out_free_array_c_interface(RBGIArguments *args,
         g_free(*target);
         break;
       case GI_TRANSFER_EVERYTHING:
-      default:
-        rb_raise(rb_eNotImpError,
-                 "TODO: [%s] %s free GIArgument(%s/%s)[%s]",
-                 metadata->name,
-                 rb_gi_direction_to_string(metadata->direction),
-                 g_type_tag_to_string(metadata->type.tag),
-                 rb_gi_array_type_to_string(metadata->array_type),
-                 rb_gi_transfer_to_string(metadata->transfer));
+        if (metadata->element_type.interface_gtype == G_TYPE_NONE) {
+            /* This assumes that this memory was allocated by
+             * g_new0(MyStruct, n). */
+            g_free(*target);
+        } else {
+            rb_raise(rb_eNotImpError,
+                     "TODO: [%s] %s free GIArgument(%s/%s)[%s]",
+                     metadata->name,
+                     rb_gi_direction_to_string(metadata->direction),
+                     g_type_tag_to_string(metadata->type.tag),
+                     rb_gi_array_type_to_string(metadata->array_type),
+                     rb_gi_transfer_to_string(metadata->transfer));
+        }
+        break;
     }
     xfree(target);
 }
@@ -337,6 +343,7 @@ rb_gi_arguments_out_init_arg_array_c(RBGIArguments *args,
         break;
       case GI_TYPE_TAG_UTF8:
         argument->v_pointer = ALLOC(gchar **);
+        *((gchar **)(argument->v_pointer)) = NULL;
         metadata->free_func = rb_gi_arguments_out_free_array_c_string;
         break;
       case GI_TYPE_TAG_FILENAME:
@@ -349,6 +356,7 @@ rb_gi_arguments_out_init_arg_array_c(RBGIArguments *args,
         break;
       case GI_TYPE_TAG_INTERFACE:
         argument->v_pointer = ALLOC(gpointer *);
+        *((gpointer *)(argument->v_pointer)) = NULL;
         metadata->free_func = rb_gi_arguments_out_free_array_c_interface;
         break;
       case GI_TYPE_TAG_GLIST:

data/ext/gobject-introspection/rb-gi-arguments.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2022  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2024  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
@@ -602,6 +602,12 @@ rb_gi_arguments_convert_arg_interface_body(VALUE user_data)
         }
       case GI_INFO_TYPE_OBJECT:
       case GI_INFO_TYPE_INTERFACE:
+        if (!G_IS_OBJECT(data->arg->v_pointer)) {
+            GIObjectInfoRefFunction ref = g_object_info_get_ref_function_pointer(data->arg_metadata->type.interface_info);
+            if (ref) {
+                ref(data->arg->v_pointer);
+            }
+        }
         return GOBJ2RVAL(data->arg->v_pointer);
       case GI_INFO_TYPE_CONSTANT:
         rb_raise(rb_eNotImpError,
@@ -683,10 +689,10 @@ rb_gi_arguments_convert_arg_array_like_ensure(VALUE user_data)
     return Qnil;
 }
 
-static gint64
-rb_gi_arguments_convert_arg_array_body_extract_length(GIArgument *arg,
-                                                      RBGIArgMetadata *metadata,
-                                                      gboolean is_pointer)
+gint64
+rb_gi_argument_out_array_get_length(GIArgument *arg,
+                                    RBGIArgMetadata *metadata,
+                                    gboolean is_pointer)
 {
     switch (metadata->type.tag) {
       case GI_TYPE_TAG_VOID:
@@ -697,49 +703,49 @@ rb_gi_arguments_convert_arg_array_body_extract_length(GIArgument *arg,
         return -1;
       case GI_TYPE_TAG_INT8:
         if (is_pointer) {
-            return *((gint8 *)arg->v_pointer);
+            return *((gint8 *)(arg->v_pointer));
         } else {
             return arg->v_int8;
         }
       case GI_TYPE_TAG_UINT8:
         if (is_pointer) {
-            return *((guint8 *)arg->v_pointer);
+            return *((guint8 *)(arg->v_pointer));
         } else {
             return arg->v_uint8;
         }
       case GI_TYPE_TAG_INT16:
         if (is_pointer) {
-            return *((gint16 *)arg->v_pointer);
+            return *((gint16 *)(arg->v_pointer));
         } else {
             return arg->v_int16;
         }
       case GI_TYPE_TAG_UINT16:
         if (is_pointer) {
-            return *((guint16 *)arg->v_pointer);
+            return *((guint16 *)(arg->v_pointer));
         } else {
             return arg->v_uint16;
         }
       case GI_TYPE_TAG_INT32:
         if (is_pointer) {
-            return *((gint32 *)arg->v_pointer);
+            return *((gint32 *)(arg->v_pointer));
         } else {
             return arg->v_int32;
         }
       case GI_TYPE_TAG_UINT32:
         if (is_pointer) {
-            return *((guint32 *)arg->v_pointer);
+            return *((guint32 *)(arg->v_pointer));
         } else {
             return arg->v_uint32;
         }
       case GI_TYPE_TAG_INT64:
         if (is_pointer) {
-            return *((gint64 *)arg->v_pointer);
+            return *((gint64 *)(arg->v_pointer));
         } else {
             return arg->v_int64;
         }
       case GI_TYPE_TAG_UINT64:
         if (is_pointer) {
-            return *((guint64 *)arg->v_pointer);
+            return *((guint64 *)(arg->v_pointer));
         } else {
             return arg->v_uint64;
         }
@@ -789,10 +795,9 @@ rb_gi_arguments_convert_arg_array_body_get_length(ArrayLikeToRubyData *data)
                                             data->arg_metadata->struct_info,
                                             data->arg_metadata->struct_memory);
         int64_t length =
-            rb_gi_arguments_convert_arg_array_body_extract_length(
-                &value,
-                &length_metadata,
-                FALSE);
+            rb_gi_argument_out_array_get_length(&value,
+                                                &length_metadata,
+                                                FALSE);
         /* TODO: Use ensure */
         rb_gi_arg_metadata_clear(&length_metadata);
         g_base_info_unref(field_info);
@@ -816,20 +821,16 @@ rb_gi_arguments_convert_arg_array_body_get_length(ArrayLikeToRubyData *data)
         gboolean is_pointer =
             !(length_metadata->array_metadata &&
               length_metadata->array_metadata->output_buffer_p);
-        return
-            rb_gi_arguments_convert_arg_array_body_extract_length(
-                length_arg,
-                length_metadata,
-                is_pointer);
+        return rb_gi_argument_out_array_get_length(length_arg,
+                                                   length_metadata,
+                                                   is_pointer);
     } else {
         length_arg = &g_array_index(data->args->in_args,
                                     GIArgument,
                                     length_metadata->in_arg_index);
-        return
-            rb_gi_arguments_convert_arg_array_body_extract_length(
-                length_arg,
-                length_metadata,
-                FALSE);
+        return rb_gi_argument_out_array_get_length(length_arg,
+                                                   length_metadata,
+                                                   FALSE);
     }
 }
 
@@ -1105,26 +1106,116 @@ static VALUE
 rb_gi_arguments_convert_arg_array_body_c_fixed_size(ArrayLikeToRubyData *data,
                                                     gint fixed_size)
 {
-    const char *array_c_type = "[fixed-size]";
+    const char *array_c_type = "fixed-size";
     switch (data->element_type_tag) {
       case GI_TYPE_TAG_VOID:
       case GI_TYPE_TAG_BOOLEAN:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIArgument(array)[c][%s][%s] -> Ruby",
+                 array_c_type,
+                 g_type_tag_to_string(data->element_type_tag));
+        return Qnil;
       case GI_TYPE_TAG_INT8:
+        {
+            gint8 *array = (gint8 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_INT2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_UINT8:
+        {
+            guint8 *array = (guint8 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_UINT2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_INT16:
+        {
+            gint16 *array = (gint16 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_INT2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_UINT16:
+        {
+            guint16 *array = (guint16 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_UINT2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_INT32:
+        {
+            gint32 *array = (gint32 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_INT2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_UINT32:
+        {
+            guint32 *array = (guint32 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_UINT2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_INT64:
+        {
+            gint64 *array = (gint64 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_LL2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_UINT64:
+        {
+            guint64 *array = (guint64 *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, RB_ULL2NUM(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_FLOAT:
+        {
+            float *array = (float *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, rb_float_new(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_DOUBLE:
+        {
+            double *array = (double *)(data->arg->v_pointer);
+            VALUE rb_array = rb_ary_new_capa(fixed_size);
+            gint i;
+            for (i = 0; i < fixed_size; i++) {
+                rb_ary_push(rb_array, rb_float_new(array[i]));
+            }
+            return rb_array;
+        }
       case GI_TYPE_TAG_GTYPE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: GIArgument(array)[c][%s][%s] -> Ruby",
-                 array_c_type,
-                 g_type_tag_to_string(data->element_type_tag));
-        return Qnil;
       case GI_TYPE_TAG_UTF8:
       case GI_TYPE_TAG_FILENAME:
       case GI_TYPE_TAG_ARRAY:
@@ -1764,6 +1855,10 @@ rb_gi_arguments_convert_arg_ghash(RBGIArguments *args,
                                   GIArgument *arg,
                                   RBGIArgMetadata *arg_metadata)
 {
+    if (arg_metadata->may_be_null_p && !arg->v_pointer) {
+        return Qnil;
+    }
+
     GHashToRubyData data;
 
     data.args = args;
@@ -2059,10 +2154,17 @@ rb_gi_arguments_convert_return_value_free_everything_interface(
       case GI_INFO_TYPE_OBJECT:
         {
             GObject *object = data->value->v_pointer;
-            if (g_object_is_floating(object)) {
-                g_object_ref_sink(object);
+            if (G_IS_OBJECT(object)) {
+                if (g_object_is_floating(object)) {
+                    g_object_ref_sink(object);
+                }
+                g_object_unref(object);
+            } else {
+                GIObjectInfoUnrefFunction unref = g_object_info_get_unref_function_pointer(data->metadata->type.interface_info);
+                if (unref) {
+                    unref(object);
+                }
             }
-            g_object_unref(object);
         }
         break;
       case GI_INFO_TYPE_INTERFACE:
@@ -2374,6 +2476,8 @@ rb_gi_arguments_convert_return_value_free_everything(ReturnValueToRubyData *data
       case GI_TYPE_TAG_UINT64:
       case GI_TYPE_TAG_FLOAT:
       case GI_TYPE_TAG_DOUBLE:
+        /* We need to do nothing. */
+        break;
       case GI_TYPE_TAG_GTYPE:
         rb_raise(rb_eNotImpError,
                  "TODO: free GIArgument(%s) everything",
@@ -2858,12 +2962,21 @@ rb_gi_arguments_fill_raw_result(RBGIArguments *args,
                                 gpointer raw_result,
                                 GITypeInfo *type_info,
                                 GITransfer transfer,
+                                gboolean may_return_null,
                                 gboolean is_return_value)
 {
     GIFFIReturnValue *ffi_return_value = raw_result;
-    GITypeTag type_tag;
 
-    type_tag = g_type_info_get_tag(type_info);
+    if (may_return_null && RB_NIL_P(rb_result)) {
+        if (is_return_value) {
+            ffi_return_value->v_pointer = NULL;
+        } else {
+            *((gpointer *)raw_result) = NULL;
+        }
+        return;
+    }
+
+    GITypeTag type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
       case GI_TYPE_TAG_VOID:
         g_assert_not_reached();
@@ -3044,8 +3157,8 @@ rb_gi_arguments_fill_raw_results(RBGIArguments *args,
     return_type_info = g_callable_info_get_return_type(args->info);
     return_type_tag = g_type_info_get_tag(return_type_info);
     if (return_type_tag != GI_TYPE_TAG_VOID) {
-        GITransfer transfer;
-        transfer = g_callable_info_get_caller_owns(args->info);
+        GITransfer transfer = g_callable_info_get_caller_owns(args->info);
+        gboolean may_return_null = g_callable_info_may_return_null(args->info);
         if (args->out_args->len == 0) {
             VALUE rb_return_value = rb_results;
             rb_gi_arguments_fill_raw_result(args,
@@ -3053,6 +3166,7 @@ rb_gi_arguments_fill_raw_results(RBGIArguments *args,
                                             raw_return_value,
                                             return_type_info,
                                             transfer,
+                                            may_return_null,
                                             TRUE);
         } else {
             VALUE rb_return_value;
@@ -3067,6 +3181,7 @@ rb_gi_arguments_fill_raw_results(RBGIArguments *args,
                                             raw_return_value,
                                             return_type_info,
                                             transfer,
+                                            may_return_null,
                                             TRUE);
         }
     }
@@ -3106,6 +3221,7 @@ rb_gi_arguments_fill_raw_results(RBGIArguments *args,
                                         argument->v_pointer,
                                         type_info,
                                         transfer,
+                                        metadata->may_be_null_p,
                                         FALSE);
         g_base_info_unref(type_info);
     }

data/ext/gobject-introspection/rb-gi-constructor-info.c

@@ -56,7 +56,8 @@ initialize_receiver(VALUE receiver,
     switch (interface_type) {
       case GI_INFO_TYPE_OBJECT:
         G_INITIALIZE(receiver, value->v_pointer);
-        {
+        /* GTypeInstance * is also GI_INFO_TYPE_OBJECT. */
+        if (G_IS_OBJECT(value->v_pointer)) {
             gboolean was_floating;
             was_floating = g_object_is_floating(value->v_pointer);
             g_object_ref_sink(value->v_pointer);

data/ext/gobject-introspection/rb-gi-private-arguments.h

@@ -101,6 +101,11 @@ rb_gi_arg_metadata_clear(RBGIArgMetadata *metadata);
 G_GNUC_INTERNAL void
 rb_gi_arg_metadata_free(RBGIArgMetadata *metadata);
 
+G_GNUC_INTERNAL gint64
+rb_gi_argument_out_array_get_length(GIArgument *arg,
+                                    RBGIArgMetadata *metadata,
+                                    gboolean is_pointer);
+
 G_GNUC_INTERNAL void
 rb_gi_arguments_init(RBGIArguments *args,
                      GICallableInfo *info,

data/gobject-introspection.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
     "of any GObject C libraries"
   s.author        = "The Ruby-GNOME Project Team"
   s.email         = "ruby-gnome2-devel-en@lists.sourceforge.net"
-  s.homepage      = "https://ruby-gnome2.osdn.jp/"
+  s.homepage      = "https://ruby-gnome.github.io/"
   s.licenses      = ["LGPL-2.1+"]
   s.version       = ruby_glib2_version
   s.extensions    = ["ext/#{s.name}/extconf.rb"]

data/lib/gobject-introspection/loader.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2023  Ruby-GNOME Project Team
+# Copyright (C) 2012-2024  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
@@ -83,10 +83,12 @@ module GObjectIntrospection
     def load_function_info(info)
       name = rubyish_method_name(info)
       define_singleton_method(info, @base_module, name)
+      define_equal_style_setter(info, @base_module.singleton_class, name)
     end
 
     def load_function_info_singleton_method(info, klass, method_name)
       define_singleton_method(info, klass, method_name)
+      define_equal_style_setter(info, klass.singleton_class, method_name)
     end
 
     def define_module_function(function_info, target_module, name)
@@ -185,8 +187,8 @@ module GObjectIntrospection
       # TODO: Can we do the same things for flags on NONE GType?
       return if info.gtype == GLib::Type::NONE
       klass = self.class.define_class(info.gtype,
-                                     rubyish_class_name(info),
-                                     @base_module)
+                                      rubyish_class_name(info),
+                                      @base_module)
       prepare_class(klass) do
         load_methods(info, klass)
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gobject-introspection
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.2.7
 platform: ruby
 authors:
 - The Ruby-GNOME Project Team
 bindir: bin
 cert_chain: []
-date: 2024-04-02 00:00:00.000000000 Z
+date: 2025-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glib2
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: 4.2.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: 4.2.7
 description: Ruby/GObjectIntrospection provides bindings of GObject Introspection
   and a loader module that can generate dynamically Ruby bindings of any GObject C
   libraries
@@ -129,7 +129,7 @@ files:
 - test/test-value-info.rb
 - test/test-version.rb
 - test/test-vfunc-info.rb
-homepage: https://ruby-gnome2.osdn.jp/
+homepage: https://ruby-gnome.github.io/
 licenses:
 - LGPL-2.1+
 metadata:
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby/GObjectIntrospection is a Ruby binding of GObject Introspection.
 test_files: []