gobject-introspection 3.3.0 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5e708d02e27a80e2c6f6c93ed0c283011b264547f8523575d8b2038bf08039e
-  data.tar.gz: 1cb3f367205cf4ff8b826f755354c134071740e09211cbb2377f4907714e1cab
+  metadata.gz: 4c6caefd72069125350637fc2a07a444c90ae74ba5175b1e5031e84e5a4349ae
+  data.tar.gz: 9f1ed91b438bd00f424f283c797af9834c85f2ddc88441019b1781ab40145c6e
 SHA512:
-  metadata.gz: c38badd7944d4278121ec7085b0f6bbeb1ded582941c1347babe6f21535ebc67bd7897bda77ad89d31d2df27abf50a18fee497150942d67e5c56f6bbf32513e2
-  data.tar.gz: c917b854af7ebec5cd473dc3b6b3f948c14e591ad41111a0a8d9df431011e5d91bdce2d01d91ec9d17083e790120433eb211ab27b4cbe3390f34bc269dca9625
+  metadata.gz: 3f4bb16322d279941ac6ed04b236291d457b1e086dfbefdb0e9fdd343441eaa9df553cc497c771d377231ad8dda2ea80bea1709c46f4e101d7636761f7de0239
+  data.tar.gz: c710f5412c54f621502f45fcc70f6ea4a9ad7d901bc5b1acebd72aee45aae2d7a31e7319e8c660297db1e8f2bb01afb83bbc082a8f57a62d6d0ad0cbd174953d

data/Rakefile

@@ -22,77 +22,5 @@ require "gnome2/rake/package-task"
 package_name = File.basename(__dir__)
 spec = Gem::Specification.load("#{package_name}.gemspec")
 
-package_task = GNOME2::Rake::PackageTask.new(spec, __dir__) do |package|
-  package.windows.packages = []
-  package.windows.dependencies = []
-  package.windows.build_dependencies = ["glib2"]
-  package.external_packages = [
-    {
-      :name => "glib",
-      :download_site => :gnome,
-      :label => "GLib",
-      :version => "2.58.1",
-      :compression_method => "xz",
-      :windows => {
-        :build => false,
-      },
-      :native => {
-        :build => true,
-        :need_autoreconf => true,
-        :built_file => "lib/libglib-2.0.so",
-      },
-    },
-    {
-      :name => "gobject-introspection",
-      :download_site => :gnome,
-      :label => "gobject-introspection",
-      :version => "1.58.0",
-      :compression_method => "xz",
-      :windows => {
-        :configure_args => [
-          "--with-g-ir-scanner=#{package.native.absolute_binary_dir}/bin/g-ir-scanner",
-          "--disable-tests",
-        ],
-        :patches => [
-          "support-external-g-ir-scanner.diff",
-        ],
-        :need_autoreconf => true,
-        :build_concurrently => false,
-        :built_file => "bin/libgirepository-1.0-1.dll",
-      },
-      :native => {
-        :build => true,
-        :patches => [
-        ],
-        :built_file => "bin/g-ir-scanner",
-      }
-    },
-  ]
-end
-package_task.define
-
-namespace :native do
-  namespace :"gobject-introspection" do
-    patched_paths = []
-
-    g_ir_scanner_dir = package_task.native.absolute_binary_dir
-    g_ir_scanner_dir += "lib/gobject-introspection/giscanner"
-    g_ir_scanner_patched_path = g_ir_scanner_dir + "patched"
-    patched_paths << g_ir_scanner_patched_path
-    file g_ir_scanner_patched_path.to_s do
-      Dir.chdir(g_ir_scanner_dir.to_s) do
-        patch = "#{package_task.package.patches_dir}/cross-g-ir-scanner.diff"
-        sh("patch -p2 < #{patch}")
-        rm_f(Dir.glob("*.{pyc,pyo}"))
-      end
-      touch(g_ir_scanner_patched_path)
-    end
-
-    desc "Make g-ir-scanner workable for Windows on non Windows"
-    task :cross => patched_paths
-  end
-
-  namespace :builder do
-    task :after => "native:gobject-introspection:cross"
-  end
+GNOME2::Rake::PackageTask.define(spec, __dir__) do |package|
 end

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

@@ -1128,47 +1128,25 @@ rb_gi_argument_to_ruby_gslist(GIArgument *argument, GITypeInfo *type_info)
     return rb_argument;
 }
 
-static void
-rb_gi_argument_to_ruby_ghash_utf8_utf8_body(gpointer key,
-                                            gpointer value,
-                                            gpointer user_data)
-{
-    VALUE rb_table = (VALUE)user_data;
-    VALUE rb_key;
-    VALUE rb_value;
-
-    rb_key = CSTR2RVAL(key);
-    rb_value = CSTR2RVAL(value);
-    rb_hash_aset(rb_table, rb_key, rb_value);
-}
-
-static VALUE
-rb_gi_argument_to_ruby_ghash_utf8_utf8(GHashTable *table)
-{
+typedef struct {
+    GIArgument *argument;
     VALUE rb_table;
-
-    rb_table = rb_hash_new();
-    g_hash_table_foreach(table,
-                         rb_gi_argument_to_ruby_ghash_utf8_utf8_body,
-                         (gpointer)(rb_table));
-    return rb_table;
-}
-
-static VALUE
-rb_gi_argument_to_ruby_ghash(GIArgument *argument, GITypeInfo *type_info)
-{
-    VALUE rb_argument;
     GITypeInfo *key_type_info;
     GITypeTag key_type_tag;
     GITypeInfo *value_type_info;
     GITypeTag value_type_tag;
+} GHashToRubyData;
 
-    key_type_info = g_type_info_get_param_type(type_info, 0);
-    key_type_tag = g_type_info_get_tag(key_type_info);
-    value_type_info = g_type_info_get_param_type(type_info, 1);
-    value_type_tag = g_type_info_get_tag(value_type_info);
+static void
+rb_gi_argument_to_ruby_ghash_foreach_body(gpointer key,
+                                          gpointer value,
+                                          gpointer user_data)
+{
+    GHashToRubyData *data = user_data;
+    VALUE rb_key;
+    VALUE rb_value;
 
-    switch (key_type_tag) {
+    switch (data->key_type_tag) {
       case GI_TYPE_TAG_VOID:
       case GI_TYPE_TAG_BOOLEAN:
       case GI_TYPE_TAG_INT8:
@@ -1182,51 +1160,140 @@ rb_gi_argument_to_ruby_ghash(GIArgument *argument, GITypeInfo *type_info)
       case GI_TYPE_TAG_FLOAT:
       case GI_TYPE_TAG_DOUBLE:
       case GI_TYPE_TAG_GTYPE:
-        g_base_info_unref(key_type_info);
-        g_base_info_unref(value_type_info);
         rb_raise(rb_eNotImpError,
                  "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
-                 g_type_tag_to_string(key_type_tag),
-                 g_type_tag_to_string(value_type_tag));
+                 g_type_tag_to_string(data->key_type_tag),
+                 g_type_tag_to_string(data->value_type_tag));
         break;
       case GI_TYPE_TAG_UTF8:
-        if (value_type_tag == GI_TYPE_TAG_UTF8) {
-            g_base_info_unref(key_type_info);
-            g_base_info_unref(value_type_info);
-            rb_argument =
-                rb_gi_argument_to_ruby_ghash_utf8_utf8(argument->v_pointer);
-        } else {
-            g_base_info_unref(key_type_info);
-            g_base_info_unref(value_type_info);
-            rb_raise(rb_eNotImpError,
-                     "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
-                     g_type_tag_to_string(key_type_tag),
-                     g_type_tag_to_string(value_type_tag));
+        rb_key = CSTR2RVAL(key);
+        break;
+      case GI_TYPE_TAG_FILENAME:
+      case GI_TYPE_TAG_ARRAY:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
+                 g_type_tag_to_string(data->key_type_tag),
+                 g_type_tag_to_string(data->value_type_tag));
+        break;
+      case GI_TYPE_TAG_INTERFACE:
+        {
+            GIArgument key_argument;
+            key_argument.v_pointer = key;
+            rb_key = rb_gi_argument_to_ruby_interface(&key_argument,
+                                                      FALSE,
+                                                      data->key_type_info);
         }
         break;
+      case GI_TYPE_TAG_GLIST:
+      case GI_TYPE_TAG_GSLIST:
+      case GI_TYPE_TAG_GHASH:
+      case GI_TYPE_TAG_ERROR:
+      case GI_TYPE_TAG_UNICHAR:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
+                 g_type_tag_to_string(data->key_type_tag),
+                 g_type_tag_to_string(data->value_type_tag));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+
+    switch (data->value_type_tag) {
+      case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_BOOLEAN:
+      case GI_TYPE_TAG_INT8:
+      case GI_TYPE_TAG_UINT8:
+      case GI_TYPE_TAG_INT16:
+      case GI_TYPE_TAG_UINT16:
+      case GI_TYPE_TAG_INT32:
+      case GI_TYPE_TAG_UINT32:
+      case GI_TYPE_TAG_INT64:
+      case GI_TYPE_TAG_UINT64:
+      case GI_TYPE_TAG_FLOAT:
+      case GI_TYPE_TAG_DOUBLE:
+      case GI_TYPE_TAG_GTYPE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
+                 g_type_tag_to_string(data->key_type_tag),
+                 g_type_tag_to_string(data->value_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+        rb_value = CSTR2RVAL(value);
+        break;
       case GI_TYPE_TAG_FILENAME:
       case GI_TYPE_TAG_ARRAY:
+        rb_raise(rb_eNotImpError,
+                 "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
+                 g_type_tag_to_string(data->key_type_tag),
+                 g_type_tag_to_string(data->value_type_tag));
+        break;
       case GI_TYPE_TAG_INTERFACE:
+        {
+            GIArgument value_argument;
+            value_argument.v_pointer = value;
+            rb_value = rb_gi_argument_to_ruby_interface(&value_argument,
+                                                        FALSE,
+                                                        data->value_type_info);
+        }
+        break;
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
       case GI_TYPE_TAG_ERROR:
       case GI_TYPE_TAG_UNICHAR:
-        g_base_info_unref(key_type_info);
-        g_base_info_unref(value_type_info);
         rb_raise(rb_eNotImpError,
                  "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
-                 g_type_tag_to_string(key_type_tag),
-                 g_type_tag_to_string(value_type_tag));
+                 g_type_tag_to_string(data->key_type_tag),
+                 g_type_tag_to_string(data->value_type_tag));
         break;
       default:
-        g_base_info_unref(key_type_info);
-        g_base_info_unref(value_type_info);
         g_assert_not_reached();
         break;
     }
 
-    return rb_argument;
+    rb_hash_aset(data->rb_table, rb_key, rb_value);
+}
+
+static VALUE
+rb_gi_argument_to_ruby_ghash_body(VALUE user_data)
+{
+    GHashToRubyData *data = (GHashToRubyData *)user_data;
+
+    g_hash_table_foreach(data->argument->v_pointer,
+                         rb_gi_argument_to_ruby_ghash_foreach_body,
+                         data);
+
+    return data->rb_table;
+}
+
+static VALUE
+rb_gi_argument_to_ruby_ghash_ensure(VALUE user_data)
+{
+    GHashToRubyData *data = (GHashToRubyData *)user_data;
+
+    g_base_info_unref(data->key_type_info);
+    g_base_info_unref(data->value_type_info);
+
+    return Qnil;
+}
+
+static VALUE
+rb_gi_argument_to_ruby_ghash(GIArgument *argument, GITypeInfo *type_info)
+{
+    GHashToRubyData data;
+
+    data.argument = argument;
+    data.rb_table = rb_hash_new();
+
+    data.key_type_info = g_type_info_get_param_type(type_info, 0);
+    data.key_type_tag = g_type_info_get_tag(data.key_type_info);
+
+    data.value_type_info = g_type_info_get_param_type(type_info, 1);
+    data.value_type_tag = g_type_info_get_tag(data.value_type_info);
+
+    return rb_ensure(rb_gi_argument_to_ruby_ghash_body, (VALUE)&data,
+                     rb_gi_argument_to_ruby_ghash_ensure, (VALUE)&data);
 }
 
 static VALUE
@@ -2293,15 +2360,13 @@ rb_gi_return_argument_free_everything_array_c(GIArgument *argument,
 
     switch (element_type_tag) {
     case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
         rb_raise(rb_eNotImpError,
                  "TODO: free GIArgument(array)[c][%s] everything",
                  g_type_tag_to_string(element_type_tag));
         break;
+    case GI_TYPE_TAG_BOOLEAN:
+    case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
-        g_free(argument->v_pointer);
-        break;
     case GI_TYPE_TAG_INT16:
     case GI_TYPE_TAG_UINT16:
     case GI_TYPE_TAG_INT32:
@@ -2310,6 +2375,8 @@ rb_gi_return_argument_free_everything_array_c(GIArgument *argument,
     case GI_TYPE_TAG_UINT64:
     case GI_TYPE_TAG_FLOAT:
     case GI_TYPE_TAG_DOUBLE:
+        g_free(argument->v_pointer);
+        break;
     case GI_TYPE_TAG_GTYPE:
         rb_raise(rb_eNotImpError,
                  "TODO: free GIArgument(array)[c][%s] everything",
@@ -2788,50 +2855,52 @@ rb_gi_return_argument_free_everything(GIArgument *argument,
 
     type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
+      case GI_TYPE_TAG_VOID:
         break;
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
+      case GI_TYPE_TAG_BOOLEAN:
+      case GI_TYPE_TAG_INT8:
+      case GI_TYPE_TAG_UINT8:
+      case GI_TYPE_TAG_INT16:
+      case GI_TYPE_TAG_UINT16:
+      case GI_TYPE_TAG_INT32:
+      case GI_TYPE_TAG_UINT32:
+      case GI_TYPE_TAG_INT64:
+      case GI_TYPE_TAG_UINT64:
+      case GI_TYPE_TAG_FLOAT:
+      case GI_TYPE_TAG_DOUBLE:
+      case GI_TYPE_TAG_GTYPE:
         rb_raise(rb_eNotImpError,
                  "TODO: free GIArgument(%s) everything",
                  g_type_tag_to_string(type_tag));
         break;
-    case GI_TYPE_TAG_UTF8:
+      case GI_TYPE_TAG_UTF8:
         g_free(argument->v_string);
         break;
-    case GI_TYPE_TAG_FILENAME:
+      case GI_TYPE_TAG_FILENAME:
         g_free(argument->v_string);
         break;
-    case GI_TYPE_TAG_ARRAY:
+      case GI_TYPE_TAG_ARRAY:
         rb_gi_return_argument_free_everything_array(argument, type_info);
         break;
-    case GI_TYPE_TAG_INTERFACE:
+      case GI_TYPE_TAG_INTERFACE:
         rb_gi_return_argument_free_everything_interface(argument, type_info);
         break;
-    case GI_TYPE_TAG_GLIST:
+      case GI_TYPE_TAG_GLIST:
         rb_gi_return_argument_free_everything_glist(argument, type_info);
         break;
-    case GI_TYPE_TAG_GSLIST:
+      case GI_TYPE_TAG_GSLIST:
         rb_gi_return_argument_free_everything_gslist(argument, type_info);
         break;
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
+      case GI_TYPE_TAG_GHASH:
+        g_hash_table_unref(argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_ERROR:
+      case GI_TYPE_TAG_UNICHAR:
         rb_raise(rb_eNotImpError,
                  "TODO: free GIArgument(%s) everything",
                  g_type_tag_to_string(type_tag));
         break;
-    default:
+      default:
         g_assert_not_reached();
         break;
     }
@@ -2957,7 +3026,16 @@ rb_gi_value_argument_from_ruby_interface(GIArgument *argument,
         break;
     case GI_INFO_TYPE_OBJECT:
     case GI_INFO_TYPE_INTERFACE:
+        gtype = g_registered_type_info_get_g_type(interface_info);
         argument->v_pointer = RVAL2GOBJ(rb_argument);
+        if (argument->v_pointer &&
+            gtype != G_TYPE_NONE &&
+            !G_TYPE_CHECK_INSTANCE_TYPE(argument->v_pointer, gtype)) {
+            rb_raise(rb_eArgError,
+                     "must be <%s> object: <%" PRIsVALUE ">",
+                     g_type_name(gtype),
+                     rb_argument);
+        }
         break;
     case GI_INFO_TYPE_CONSTANT:
         rb_raise(rb_eNotImpError,
@@ -3007,9 +3085,16 @@ rb_gi_value_argument_from_ruby_glist(GIArgument *argument,
 {
     GITypeInfo *element_type_info;
     GITypeTag element_type_tag;
+    GType gtype = G_TYPE_NONE;
 
     element_type_info = g_type_info_get_param_type(type_info, 0);
     element_type_tag = g_type_info_get_tag(element_type_info);
+    if (element_type_tag == GI_TYPE_TAG_INTERFACE) {
+        GIBaseInfo *interface_info;
+        interface_info = g_type_info_get_interface(element_type_info);
+        gtype = g_registered_type_info_get_g_type(interface_info);
+        g_base_info_unref(interface_info);
+    }
     g_base_info_unref(element_type_info);
 
     switch (element_type_tag) {
@@ -3035,6 +3120,19 @@ rb_gi_value_argument_from_ruby_glist(GIArgument *argument,
         break;
     case GI_TYPE_TAG_INTERFACE:
         argument->v_pointer = RVAL2GOBJGLIST(rb_argument);
+        if (gtype != G_TYPE_NONE) {
+            GList *node;
+            for (node = argument->v_pointer; node; node = g_list_next(node)) {
+                GObject *object = node->data;
+                if (!G_TYPE_CHECK_INSTANCE_TYPE(object, gtype)) {
+                    g_list_free(argument->v_pointer);
+                    rb_raise(rb_eArgError,
+                             "must be <%s> objects: <%" PRIsVALUE ">",
+                             g_type_name(gtype),
+                             rb_argument);
+                }
+            }
+        }
         break;
     case GI_TYPE_TAG_GLIST:
     case GI_TYPE_TAG_GSLIST:
@@ -3059,9 +3157,16 @@ rb_gi_value_argument_from_ruby_gslist(GIArgument *argument,
 {
     GITypeInfo *element_type_info;
     GITypeTag element_type_tag;
+    GType gtype = G_TYPE_NONE;
 
     element_type_info = g_type_info_get_param_type(type_info, 0);
     element_type_tag = g_type_info_get_tag(element_type_info);
+    if (element_type_tag == GI_TYPE_TAG_INTERFACE) {
+        GIBaseInfo *interface_info;
+        interface_info = g_type_info_get_interface(element_type_info);
+        gtype = g_registered_type_info_get_g_type(interface_info);
+        g_base_info_unref(interface_info);
+    }
     g_base_info_unref(element_type_info);
 
     switch (element_type_tag) {
@@ -3087,6 +3192,19 @@ rb_gi_value_argument_from_ruby_gslist(GIArgument *argument,
         break;
     case GI_TYPE_TAG_INTERFACE:
         argument->v_pointer = RVAL2GOBJGSLIST(rb_argument);
+        if (gtype != G_TYPE_NONE) {
+            GSList *node;
+            for (node = argument->v_pointer; node; node = g_slist_next(node)) {
+                GObject *object = node->data;
+                if (!G_TYPE_CHECK_INSTANCE_TYPE(object, gtype)) {
+                    g_slist_free(argument->v_pointer);
+                    rb_raise(rb_eArgError,
+                             "must be <%s> objects: <%" PRIsVALUE ">",
+                             g_type_name(gtype),
+                             rb_argument);
+                }
+            }
+        }
         break;
     case GI_TYPE_TAG_GLIST:
     case GI_TYPE_TAG_GSLIST:
@@ -3766,7 +3884,6 @@ set_in_array_gtype_arguments_from_ruby(GIArgument *array_argument,
 }
 
 typedef struct {
-    GType element_gtype;
     GIStructInfo *struct_info;
     VALUE rb_argument;
     gint n_args;
@@ -3828,6 +3945,58 @@ set_in_array_interface_struct_arguments_from_ruby(GIArgument *array_argument,
     array_argument->v_pointer = data.values;
 }
 
+typedef struct {
+    VALUE rb_argument;
+    gint n_args;
+    gpointer *values;
+} ArrayInterfaceObjectFromRubyData;
+
+static VALUE
+set_in_array_interface_object_arguments_from_ruby_body(VALUE value)
+{
+    ArrayInterfaceObjectFromRubyData *data;
+    gint i;
+
+    data = (ArrayInterfaceObjectFromRubyData *)value;
+    data->values = xmalloc(sizeof(gpointer) * data->n_args);
+
+    for (i = 0; i < data->n_args; i++) {
+        VALUE rb_element;
+
+        rb_element = RARRAY_AREF(data->rb_argument, i);
+        data->values[i] = RVAL2GOBJ(rb_element);
+    }
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+set_in_array_interface_object_arguments_from_ruby_rescue(VALUE value)
+{
+    ArrayInterfaceObjectFromRubyData *data;
+
+    data = (ArrayInterfaceObjectFromRubyData *)value;
+    xfree(data->values);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static void
+set_in_array_interface_object_arguments_from_ruby(GIArgument *array_argument,
+                                                  VALUE rb_argument)
+{
+    ArrayInterfaceObjectFromRubyData data;
+
+    data.rb_argument = rb_argument;
+    data.n_args = RARRAY_LEN(rb_argument);
+    data.values = NULL;
+    rb_rescue(set_in_array_interface_object_arguments_from_ruby_body,
+              (VALUE)&data,
+              set_in_array_interface_object_arguments_from_ruby_rescue,
+              (VALUE)&data);
+    array_argument->v_pointer = data.values;
+}
+
 static void
 set_in_array_interface_arguments_from_ruby(GIArgument *array_argument,
                                            GITypeInfo *element_type_info,
@@ -3864,7 +4033,17 @@ set_in_array_interface_arguments_from_ruby(GIArgument *array_argument,
     case GI_INFO_TYPE_BOXED:
     case GI_INFO_TYPE_ENUM:
     case GI_INFO_TYPE_FLAGS:
+        interface_name = g_info_type_to_string(interface_type);
+        g_base_info_unref(interface_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: Ruby -> GIArgument(array)[interface(%s)](%s)",
+                 interface_name,
+                 g_type_name(gtype));
+        break;
     case GI_INFO_TYPE_OBJECT:
+        set_in_array_interface_object_arguments_from_ruby(array_argument,
+                                                          rb_argument);
+        break;
     case GI_INFO_TYPE_INTERFACE:
     case GI_INFO_TYPE_CONSTANT:
     case GI_INFO_TYPE_INVALID_0:

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

@@ -47,6 +47,7 @@ struct RBGICallbackData_ {
     RBGIArgMetadata *metadata;
     VALUE rb_callback;
     GObject *owner;
+    VALUE rb_owner;
 };
 
 static VALUE RG_TARGET_NAMESPACE;
@@ -338,6 +339,11 @@ rb_gi_callback_data_free(RBGICallbackData *callback_data)
             rbgobj_object_remove_relative(rb_owner, callback_data->rb_callback);
         }
     }
+    if (callback_data->rb_owner) {
+        rbgobj_remove_relative(callback_data->rb_owner,
+                               (ID)0,
+                               callback_data->rb_callback);
+    }
     xfree(callback_data->metadata);
     xfree(callback_data);
 }
@@ -1149,35 +1155,42 @@ in_callback_argument_from_ruby(RBGIArgMetadata *metadata,
 
     if (closure_argument) {
         RBGICallbackData *callback_data;
-        VALUE rb_owner;
+        VALUE rb_owner = self;
+        static VALUE mGLibObject = Qnil;
 
         callback_data = ALLOC(RBGICallbackData);
         callback_data->callback = callback;
         callback_data->metadata = metadata;
         callback_data->rb_callback = rb_block_proc();
-        if (NIL_P(self)) {
-            rb_owner = rb_ary_entry(rb_arguments, 0);
-        } else {
-            rb_owner = self;
+        if (NIL_P(mGLibObject)) {
+            mGLibObject = rb_const_get(mGLib, rb_intern("Object"));
         }
-        {
-            static VALUE mGLibObject = Qnil;
-            if (NIL_P(mGLibObject)) {
-                mGLibObject = rb_const_get(mGLib, rb_intern("Object"));
-            }
-            if (rb_obj_is_kind_of(rb_owner, mGLibObject)) {
-                rbgobj_object_add_relative(rb_owner, callback_data->rb_callback);
-                callback_data->owner = RVAL2GOBJ(rb_owner);
-                g_object_weak_ref(callback_data->owner,
-                                  rb_gi_callback_data_weak_notify,
-                                  callback_data);
+        if (rb_obj_is_kind_of(rb_owner, mGLibObject)) {
+            rbgobj_object_add_relative(rb_owner, callback_data->rb_callback);
+            callback_data->owner = RVAL2GOBJ(rb_owner);
+            g_object_weak_ref(callback_data->owner,
+                              rb_gi_callback_data_weak_notify,
+                              callback_data);
+            callback_data->rb_owner = Qnil;
+        } else {
+            /* Callback is GC-ed only when callback is invalidated. */
+            if (NIL_P(rb_owner)) {
+                /* Module function case. */
+                static VALUE rb_mGI = Qnil;
+                if (NIL_P(rb_mGI)) {
+                    rb_mGI = rb_const_get(rb_cObject,
+                                          rb_intern("GObjectIntrospection"));
+                }
+                rbgobj_add_relative(rb_mGI, callback_data->rb_callback);
+                callback_data->rb_owner = rb_mGI;
             } else {
-                /* Class method case. Callback is never GC-ed. (OK?) */
+                /* Class method case. */
                 rbgobj_add_relative(rb_owner, callback_data->rb_callback);
-                callback_data->owner = NULL;
+                callback_data->rb_owner = rb_owner;
             }
-            closure_argument->v_pointer = callback_data;
+            callback_data->owner = NULL;
         }
+        closure_argument->v_pointer = callback_data;
     }
 
     if (destroy_argument) {

data/lib/gobject-introspection.rb

@@ -31,19 +31,7 @@ module GObjectIntrospection
   end
 end
 
-base_dir = Pathname.new(__FILE__).dirname.dirname.expand_path
-vendor_dir = base_dir + "vendor" + "local"
-vendor_bin_dir = vendor_dir + "bin"
-GLib.prepend_dll_path(vendor_bin_dir)
-begin
-  major, minor, _ = RUBY_VERSION.split(/\./)
-  require "#{major}.#{minor}/gobject_introspection.so"
-rescue LoadError
-  require "gobject_introspection.so"
-end
-
-vendor_girepository_dir = vendor_dir + "lib" + "girepository-1.0"
-GObjectIntrospection.prepend_typelib_path(vendor_girepository_dir)
+require "gobject_introspection.so"
 
 module GObjectIntrospection
   LOG_DOMAIN = "GObjectIntrospection"

data/lib/gobject-introspection/loader.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2017  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-2018  Ruby-GNOME2 Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -365,13 +365,10 @@ module GObjectIntrospection
       raise ArgumentError, "wrong number of arguments (#{detail})"
     end
 
-    def match_argument?(arg_info, argument)
-      return true if argument.nil? and arg_info.may_be_null?
-
-      type = arg_info.type
-      case type.tag
+    def match_type?(type_info, value)
+      case type_info.tag
       when TypeTag::BOOLEAN
-        argument == true or argument == false
+        value == true or value == false
       when TypeTag::INT8,
            TypeTag::UINT8,
            TypeTag::INT16,
@@ -382,39 +379,41 @@ module GObjectIntrospection
            TypeTag::UINT64,
            TypeTag::FLOAT,
            TypeTag::DOUBLE
-        argument.is_a?(Numeric)
+        value.is_a?(Numeric)
       when TypeTag::GTYPE
-        argument.is_a?(GLib::Type)
+        value.is_a?(GLib::Type)
       when TypeTag::UTF8
-        argument.is_a?(String)
+        value.is_a?(String)
       when TypeTag::FILENAME
-        argument.is_a?(String)
+        value.is_a?(String)
       when TypeTag::ARRAY
-        argument.is_a?(Array)
+        element_type_info = type_info.get_param_type(0)
+        value.is_a?(Array) and value.all? {|v| match_type?(element_type_info, v)}
       when TypeTag::INTERFACE
-        interface = type.interface
+        interface = type_info.interface
         case interface.type
         when InfoType::STRUCT
-          match_argument_interface_struct?(arg_info, interface, argument)
+          match_type_interface_struct?(interface, value)
         when InfoType::OBJECT,
              InfoType::INTERFACE,
              InfoType::FLAGS,
              InfoType::ENUM
-          argument.is_a?(interface.gtype.to_class)
+          value.is_a?(interface.gtype.to_class)
         else
           # TODO
           false
         end
       when TypeTag::GLIST,
            TypeTag::GSLIST
-        argument.is_a?(Array)
+        element_type_info = type_info.get_param_type(0)
+        value.is_a?(Array) and value.all? {|v| match_type?(element_type_info, v)}
       else
         # TODO
         false
       end
     end
 
-    def match_argument_interface_struct?(arg_info, interface, argument)
+    def match_type_interface_struct?(interface, value)
       gtype = interface.gtype
       case gtype.name
       when "void"
@@ -422,15 +421,21 @@ module GObjectIntrospection
         false
       when "CairoSurface"
         if Object.const_defined?(:Cairo)
-          argument.is_a?(Cairo::Surface)
+          value.is_a?(Cairo::Surface)
         else
           false
         end
       else
-        argument.is_a?(gtype.to_class)
+      value.is_a?(gtype.to_class)
       end
     end
 
+    def match_argument?(arg_info, argument)
+      return true if argument.nil? and arg_info.may_be_null?
+
+      match_type?(arg_info.type, argument)
+    end
+
     def rubyish_method_name(function_info, options={})
       name = function_info.name
       if options[:prefix]
@@ -463,6 +468,36 @@ module GObjectIntrospection
           else
             name
           end
+        when "not_equal"
+          if n_in_args == 1
+            "!="
+          else
+            name
+          end
+        when "less_than"
+          if n_in_args == 1
+            "<"
+          else
+            name
+          end
+        when "less_than_or_equal"
+          if n_in_args == 1
+            "<="
+          else
+            name
+          end
+        when "greater_than"
+          if n_in_args == 1
+            ">"
+          else
+            name
+          end
+        when "greater_than_or_equal"
+          if n_in_args == 1
+            ">="
+          else
+            name
+          end
         when /\A(?:is|get_is|can_be)_/
           "#{$POSTMATCH}?"
         when /\Aget_/

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gobject-introspection
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.3.1
 platform: ruby
 authors:
 - The Ruby-GNOME2 Project Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-31 00:00:00.000000000 Z
+date: 2019-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glib2
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 3.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.3.0
+        version: 3.3.1
 description: Ruby/GObjectIntrospection provides bindings of GObject Introspection
   and a loader module that can generate dynamically Ruby bindings of any GObject C
   libraries
@@ -135,8 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 3.0.0.beta1
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Ruby/GObjectIntrospection is a Ruby binding of GObject Introspection.