gobject-introspection 3.0.9 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81a3676d6cd2cce80cd376a462f8d0fae34501d3
-  data.tar.gz: 1f7bed61f0b68cb302520d6e53ff5b92c0a3af68
+  metadata.gz: 7ea59f2198f3d8205e9cb2b841a2d46e5b740c43
+  data.tar.gz: d47e0988e95066f8b437f929be7dd436fb7ca7ad
 SHA512:
-  metadata.gz: 3f3c73939a3f73715ae81376e4a9b1716e971c3e50dd8a402067c56b281dbe47a5bacabe4940604fdd222d483e1d7c21a47500cc830683dc7dae2160c4924126
-  data.tar.gz: ed0d4a4340e89ef28baef2be6c87984b9d33a9678d8354eb5a4444ce8f504d1aedb7a4097dc1edaeee0c085f2a050e983c5127759523a43c8dd87db0c69090c3
+  metadata.gz: 1b394a4d695ab3a752a43df3b088ea32798f49cb33c72ba96465c2ccf7e11de2ab84cfbf22f39ea404eec406e4372ed5f4e458f60013286ca2a7a9506f83af45
+  data.tar.gz: a808106e4e8782e6ddb715b9adfe7cfc4b4f6f984352be5af94aef6a315fa8639d2993c917561a2ffb21142598dc1694ff88e7280f5777b9f6340e04cd37630e

data/Rakefile

@@ -32,7 +32,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.48.1",
+      :version => "2.50.2",
       :compression_method => "xz",
       :windows => {
         :build => false,
@@ -47,7 +47,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "gobject-introspection",
       :download_site => :gnome,
       :label => "gobject-introspection",
-      :version => "1.48.0",
+      :version => "1.50.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

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

@@ -537,27 +537,6 @@ rb_gi_array_argument_to_ruby(GIArgument *array_argument,
     return rb_array;
 }
 
-static VALUE
-interface_variant_to_ruby(GVariant *variant)
-{
-    VALUE rb_value = Qnil;
-    const GVariantType *type;
-
-    type = g_variant_get_type(variant);
-    if (g_variant_type_equal(type, G_VARIANT_TYPE_STRING)) {
-        const char *value;
-        g_variant_get(variant, "s", &value);
-        rb_value = CSTR2RVAL(value);
-    } else {
-        rb_raise(rb_eNotImpError,
-                 "TODO: GIArgument(interface)[GVariant][%.*s] -> Ruby",
-                 (int)g_variant_type_get_string_length(type),
-                 g_variant_type_peek_string(type));
-    }
-
-    return rb_value;
-}
-
 static VALUE
 rb_gi_argument_to_ruby_interface(GIArgument *argument,
                                  gboolean duplicate,
@@ -599,7 +578,7 @@ rb_gi_argument_to_ruby_interface(GIArgument *argument,
             rb_interface = rb_enc_str_new(data, size, rb_ascii8bit_encoding());
         } else if (gtype == G_TYPE_VARIANT) {
             GVariant *variant = argument->v_pointer;
-            rb_interface = interface_variant_to_ruby(variant);
+            rb_interface = rbg_variant_to_ruby(variant);
         } else {
             rb_interface = BOXED2RVAL(argument->v_pointer, gtype);
         }
@@ -1214,6 +1193,58 @@ rb_gi_argument_to_ruby(GIArgument *argument,
     return rb_argument;
 }
 
+static void
+rb_gi_out_argument_init_array_c(GIArgument *argument,
+                                G_GNUC_UNUSED GIArgInfo *arg_info,
+                                G_GNUC_UNUSED GITypeInfo *array_type_info,
+                                GITypeInfo *element_type_info)
+{
+    GITypeTag element_type_tag;
+
+    element_type_tag = g_type_info_get_tag(element_type_info);
+
+    switch (element_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:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: allocates GIArgument(array)[c][%s] for output",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+        argument->v_pointer = xmalloc(sizeof(gchar **));
+        break;
+      case GI_TYPE_TAG_FILENAME:
+      case GI_TYPE_TAG_ARRAY:
+      case GI_TYPE_TAG_INTERFACE:
+      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(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: allocates GIArgument(array)[c][%s] for output",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      default:
+        g_base_info_unref(element_type_info);
+        g_assert_not_reached();
+        break;
+    }
+}
+
 static void
 rb_gi_out_argument_init_array_array_interface(GIArgument *argument,
                                               G_GNUC_UNUSED GIArgInfo *arg_info,
@@ -1348,16 +1379,18 @@ rb_gi_out_argument_init_array(GIArgument *argument, GIArgInfo *arg_info,
 {
     GIArrayType array_type;
     GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
 
     array_type = g_type_info_get_array_type(array_type_info);
     element_type_info = g_type_info_get_param_type(array_type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
 
     switch (array_type) {
     case GI_ARRAY_TYPE_C:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[c][%s] for output",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+        rb_gi_out_argument_init_array_c(argument,
+                                        arg_info,
+                                        array_type_info,
+                                        element_type_info);
         break;
     case GI_ARRAY_TYPE_ARRAY:
         rb_gi_out_argument_init_array_array(argument,
@@ -1369,13 +1402,13 @@ rb_gi_out_argument_init_array(GIArgument *argument, GIArgInfo *arg_info,
         g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
                  "TODO: allocates GIArgument(array)[ptr-array][%s] for output",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+                 g_type_tag_to_string(element_type_tag));
         break;
     case GI_ARRAY_TYPE_BYTE_ARRAY:
         g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
                  "TODO: allocates GIArgument(array)[byte-array][%s] for output",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
+                 g_type_tag_to_string(element_type_tag));
         break;
     default:
         g_base_info_unref(element_type_info);
@@ -1709,35 +1742,101 @@ rb_gi_out_argument_to_ruby(GIArgument *argument,
                                   args_metadata);
 }
 
+
+static void
+rb_gi_out_argument_fin_array_c(GIArgument *argument,
+                               G_GNUC_UNUSED GIArgInfo *arg_info,
+                               G_GNUC_UNUSED GITypeInfo *array_type_info,
+                               GITypeInfo *element_type_info)
+{
+    GITypeTag element_type_tag;
+
+    element_type_tag = g_type_info_get_tag(element_type_info);
+
+    switch (element_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:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free out GIArgument(array)[c][%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      case GI_TYPE_TAG_UTF8:
+        xfree(argument->v_pointer);
+        break;
+      case GI_TYPE_TAG_FILENAME:
+      case GI_TYPE_TAG_ARRAY:
+      case GI_TYPE_TAG_INTERFACE:
+      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(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free out GIArgument(array)[c][%s]",
+                 g_type_tag_to_string(element_type_tag));
+        break;
+      default:
+        g_base_info_unref(element_type_info);
+        g_assert_not_reached();
+        break;
+    }
+}
+
 static void
 rb_gi_out_argument_fin_array(GIArgument *argument,
-                             G_GNUC_UNUSED GIArgInfo *arg_info,
+                             GIArgInfo *arg_info,
                              GITypeInfo *array_type_info)
 {
     GIArrayType array_type;
+    GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
 
     array_type = g_type_info_get_array_type(array_type_info);
+    element_type_info = g_type_info_get_param_type(array_type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
 
     switch (array_type) {
     case GI_ARRAY_TYPE_C:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[c]");
+        rb_gi_out_argument_fin_array_c(argument,
+                                       arg_info,
+                                       array_type_info,
+                                       element_type_info);
         break;
     case GI_ARRAY_TYPE_ARRAY:
         g_array_free(argument->v_pointer, TRUE);
         break;
     case GI_ARRAY_TYPE_PTR_ARRAY:
+        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[ptr-array]");
+                 "TODO: free out GIArgument(array)[ptr-array][%s]",
+                 g_type_tag_to_string(element_type_tag));
         break;
     case GI_ARRAY_TYPE_BYTE_ARRAY:
+        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[byte-array]");
+                 "TODO: free out GIArgument(array)[byte-array][%s]",
+                 g_type_tag_to_string(element_type_tag));
         break;
     default:
+        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
+
+    g_base_info_unref(element_type_info);
 }
 
 void
@@ -2265,6 +2364,7 @@ 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:
+        break;
     case GI_TYPE_TAG_BOOLEAN:
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
@@ -2633,16 +2733,16 @@ rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
         argument->v_boolean = RVAL2CBOOL(rb_argument);
         break;
     case GI_TYPE_TAG_INT8:
-        argument->v_int8 = NUM2INT(rb_argument);
+        argument->v_int8 = NUM2CHR(rb_argument);
         break;
     case GI_TYPE_TAG_UINT8:
-        argument->v_uint8 = NUM2UINT(rb_argument);
+        argument->v_uint8 = (guint8)NUM2CHR(rb_argument);
         break;
     case GI_TYPE_TAG_INT16:
-        argument->v_int16 = NUM2INT(rb_argument);
+        argument->v_int16 = NUM2SHORT(rb_argument);
         break;
     case GI_TYPE_TAG_UINT16:
-        argument->v_uint16 = NUM2UINT(rb_argument);
+        argument->v_uint16 = NUM2USHORT(rb_argument);
         break;
     case GI_TYPE_TAG_INT32:
         argument->v_int32 = NUM2INT(rb_argument);
@@ -3005,6 +3105,38 @@ set_in_array_length_argument(GIArgument *argument,
     }
 }
 
+static void
+set_in_array_int8_arguments_from_ruby(GIArgument *array_argument,
+                                      VALUE rb_number_array)
+{
+    gint8 *numbers;
+    gint i, n_args;
+
+    n_args = RARRAY_LEN(rb_number_array);
+    numbers = ALLOC_N(gint8, n_args);
+    for (i = 0; i < n_args; i++) {
+        numbers[i] = NUM2CHR(RARRAY_PTR(rb_number_array)[i]);
+    }
+
+    array_argument->v_pointer = numbers;
+}
+
+static void
+set_in_array_uint8_arguments_from_ruby(GIArgument *array_argument,
+                                       VALUE rb_number_array)
+{
+    guint8 *numbers;
+    gint i, n_args;
+
+    n_args = RARRAY_LEN(rb_number_array);
+    numbers = ALLOC_N(guint8, n_args);
+    for (i = 0; i < n_args; i++) {
+        numbers[i] = (guint8)NUM2CHR(RARRAY_PTR(rb_number_array)[i]);
+    }
+
+    array_argument->v_pointer = numbers;
+}
+
 static void
 set_in_array_int16_arguments_from_ruby(GIArgument *array_argument,
                                        VALUE rb_number_array)
@@ -3015,7 +3147,7 @@ set_in_array_int16_arguments_from_ruby(GIArgument *array_argument,
     n_args = RARRAY_LEN(rb_number_array);
     numbers = ALLOC_N(gint16, n_args);
     for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2INT(RARRAY_PTR(rb_number_array)[i]);
+        numbers[i] = NUM2SHORT(RARRAY_PTR(rb_number_array)[i]);
     }
 
     array_argument->v_pointer = numbers;
@@ -3031,7 +3163,7 @@ set_in_array_uint16_arguments_from_ruby(GIArgument *array_argument,
     n_args = RARRAY_LEN(rb_number_array);
     numbers = ALLOC_N(guint16, n_args);
     for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2UINT(RARRAY_PTR(rb_number_array)[i]);
+        numbers[i] = NUM2USHORT(RARRAY_PTR(rb_number_array)[i]);
     }
 
     array_argument->v_pointer = numbers;
@@ -3296,10 +3428,28 @@ in_array_c_argument_from_ruby(GIArgument *array_argument,
                  g_type_tag_to_string(element_type_tag));
         break;
     case GI_TYPE_TAG_INT8:
+        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+            array_argument->v_pointer = RSTRING_PTR(rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RSTRING_LEN(rb_argument));
+        } else {
+            rb_argument = rbg_to_array(rb_argument);
+            set_in_array_int8_arguments_from_ruby(array_argument, rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RARRAY_LEN(rb_argument));
+        }
+        break;
     case GI_TYPE_TAG_UINT8:
-        array_argument->v_pointer = RSTRING_PTR(rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RSTRING_LEN(rb_argument));
+        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+            array_argument->v_pointer = RSTRING_PTR(rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RSTRING_LEN(rb_argument));
+        } else {
+            rb_argument = rbg_to_array(rb_argument);
+            set_in_array_uint8_arguments_from_ruby(array_argument, rb_argument);
+            set_in_array_length_argument(length_argument, length_type_info,
+                                         RARRAY_LEN(rb_argument));
+        }
         break;
     case GI_TYPE_TAG_INT16:
         rb_argument = rbg_to_array(rb_argument);
@@ -3571,7 +3721,8 @@ rb_gi_in_array_argument_from_ruby(GIArgument *array_argument,
 }
 
 static void
-rb_gi_value_argument_free_array_c(GIArgument *argument,
+rb_gi_value_argument_free_array_c(VALUE rb_argument,
+                                  GIArgument *argument,
                                   G_GNUC_UNUSED GITypeInfo *type_info,
                                   GITypeInfo *element_type_info)
 {
@@ -3587,7 +3738,11 @@ rb_gi_value_argument_free_array_c(GIArgument *argument,
         break;
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
-        /* Do nothing */
+        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
+            /* Do nothing */
+        } else {
+            xfree(argument->v_pointer);
+        }
         break;
     case GI_TYPE_TAG_INT16:
     case GI_TYPE_TAG_UINT16:
@@ -3627,7 +3782,9 @@ rb_gi_value_argument_free_array_c(GIArgument *argument,
 }
 
 static void
-rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
+rb_gi_value_argument_free_array(VALUE rb_argument,
+                                GIArgument *argument,
+                                GITypeInfo *type_info)
 {
     GIArrayType array_type;
     GITypeInfo *element_type_info;
@@ -3636,7 +3793,8 @@ rb_gi_value_argument_free_array(GIArgument *argument, GITypeInfo *type_info)
     element_type_info = g_type_info_get_param_type(type_info, 0);
     switch (array_type) {
     case GI_ARRAY_TYPE_C:
-        rb_gi_value_argument_free_array_c(argument,
+        rb_gi_value_argument_free_array_c(rb_argument,
+                                          argument,
                                           type_info,
                                           element_type_info);
         break;
@@ -3706,7 +3864,7 @@ rb_gi_value_argument_free(VALUE rb_argument,
     case GI_TYPE_TAG_FILENAME:
         break;
     case GI_TYPE_TAG_ARRAY:
-        rb_gi_value_argument_free_array(argument, type_info);
+        rb_gi_value_argument_free_array(rb_argument, argument, type_info);
         break;
     case GI_TYPE_TAG_INTERFACE:
         rb_gi_value_argument_free_interface(rb_argument, argument, type_info);

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

@@ -86,37 +86,31 @@ initialize_receiver(VALUE receiver, GITypeInfo *info, GIArgument *value)
 }
 
 static VALUE
-rg_invoke(VALUE self, VALUE rb_options)
+rg_invoke(VALUE self, VALUE rb_receiver, VALUE rb_arguments)
 {
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
-    VALUE receiver;
     GIArgument return_value;
     GITypeInfo return_value_info;
 
     info = SELF(self);
     callable_info = (GICallableInfo *)info;
 
-    rb_options = rbg_to_hash(rb_options);
-    receiver = rb_hash_delete(rb_options, ID2SYM(rb_intern("receiver")));
-    if (NIL_P(receiver)) {
-        receiver = rb_hash_delete(rb_options, rb_str_new_cstr("receiver"));
-    }
-    if (NIL_P(receiver)) {
-        rb_raise(rb_eArgError,
-                 "receiver is missing: %s",
-                 RBG_INSPECT(rb_options));
+    if (NIL_P(rb_receiver)) {
+        rb_raise(rb_eArgError, "receiver is missing");
     }
     /* TODO: use rb_protect */
     rb_gi_function_info_invoke_raw(info,
-                                   rb_options,
+                                   self,
+                                   Qnil,
+                                   rb_arguments,
                                    &return_value,
                                    NULL);
 
     g_callable_info_load_return_type(callable_info, &return_value_info);
-    initialize_receiver(receiver, &return_value_info, &return_value);
+    initialize_receiver(rb_receiver, &return_value_info, &return_value);
 
-    return receiver;
+    return rb_receiver;
 }
 
 void
@@ -129,5 +123,5 @@ rb_gi_constructor_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
                                 "ConstructorInfo", rb_mGI,
 				rb_cGIFunctionInfo);
 
-    RG_DEF_METHOD(invoke, 1);
+    RG_DEF_METHOD(invoke, 2);
 }

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

@@ -59,6 +59,21 @@ gi_function_info_get_type(void)
     return type;
 }
 
+static VALUE
+rg_set_unlock_gvl(VALUE self, VALUE rb_boolean)
+{
+    return rb_iv_set(self, "unlock_gvl", rb_boolean);
+}
+
+static VALUE
+rg_unlock_gvl_p(VALUE self)
+{
+    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("unlock_gvl")))) {
+        rb_iv_set(self, "unlock_gvl", Qfalse);
+    }
+    return rb_iv_get(self, "unlock_gvl");
+}
+
 static VALUE
 rg_symbol(VALUE self)
 {
@@ -665,10 +680,12 @@ out_argument_to_raw_data_interface(GICallableInfo *callable_info,
                                    GIArgument *argument,
                                    gpointer result,
                                    GITypeInfo *type_info,
-                                   G_GNUC_UNUSED GITransfer transfer /* TODO */)
+                                   G_GNUC_UNUSED GITransfer transfer /* TODO */,
+                                   gboolean is_return_value)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
+    GIFFIReturnValue *ffi_return_value = result;
 
     interface_info = g_type_info_get_interface(type_info);
     interface_type = g_base_info_get_type(interface_info);
@@ -687,7 +704,11 @@ out_argument_to_raw_data_interface(GICallableInfo *callable_info,
                  g_base_info_get_name(interface_info));
         break;
     case GI_INFO_TYPE_ENUM:
-      *((gint *)result) = argument->v_int;
+      if (is_return_value) {
+          ffi_return_value->v_ulong = argument->v_int;
+      } else {
+          *((gint *)result) = argument->v_int;
+      }
       break;
     case GI_INFO_TYPE_FLAGS:
     case GI_INFO_TYPE_OBJECT:
@@ -725,15 +746,50 @@ out_argument_to_raw_data_interface(GICallableInfo *callable_info,
     g_base_info_unref(interface_info);
 }
 
+/*
+  We need to cast from different type for return value. (We don't
+  need it for out arguments.) Because of libffi specification:
+
+  https://github.com/libffi/libffi/blob/master/doc/libffi.texi#L190
+
+  @var{rvalue} is a pointer to a chunk of memory that will hold the
+  result of the function call.  This must be large enough to hold the
+  result, no smaller than the system register size (generally 32 or 64
+  bits), and must be suitably aligned; it is the caller's responsibility
+  to ensure this.  If @var{cif} declares that the function returns
+  @code{void} (using @code{ffi_type_void}), then @var{rvalue} is
+  ignored.
+
+  https://github.com/libffi/libffi/blob/master/doc/libffi.texi#L198
+
+  In most situations, @samp{libffi} will handle promotion according to
+  the ABI.  However, for historical reasons, there is a special case
+  with return values that must be handled by your code.  In particular,
+  for integral (not @code{struct}) types that are narrower than the
+  system register size, the return value will be widened by
+  @samp{libffi}.  @samp{libffi} provides a type, @code{ffi_arg}, that
+  can be used as the return type.  For example, if the CIF was defined
+  with a return type of @code{char}, @samp{libffi} will try to store a
+  full @code{ffi_arg} into the return value.
+
+  See also:
+    * https://github.com/ruby-gnome2/ruby-gnome2/issues/758#issuecomment-243149237
+    * https://github.com/libffi/libffi/pull/216
+
+  This ffi_return_value case implementation is based on
+  gi_type_info_extract_ffi_return_value().
+*/
 static void
 out_argument_to_raw_data(GICallableInfo *callable_info,
                          VALUE rb_result,
                          gpointer result,
                          GITypeInfo *type_info,
-                         GITransfer transfer)
+                         GITransfer transfer,
+                         gboolean is_return_value)
 {
     GIArgument argument;
     GITypeTag type_tag;
+    GIFFIReturnValue *ffi_return_value = result;
 
     rb_gi_value_argument_from_ruby(&argument,
                                    type_info,
@@ -745,25 +801,53 @@ out_argument_to_raw_data(GICallableInfo *callable_info,
         g_assert_not_reached();
         break;
       case GI_TYPE_TAG_BOOLEAN:
-        *((gboolean *)result) = argument.v_boolean;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_boolean;
+        } else {
+            *((gboolean *)result) = argument.v_boolean;
+        }
         break;
       case GI_TYPE_TAG_INT8:
-        *((gint8 *)result) = argument.v_int8;
+        if (is_return_value) {
+            ffi_return_value->v_long = argument.v_int8;
+        } else {
+            *((gint8 *)result) = argument.v_int8;
+        }
         break;
       case GI_TYPE_TAG_UINT8:
-        *((guint8 *)result) = argument.v_uint8;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint8;
+        } else {
+            *((guint8 *)result) = argument.v_uint8;
+        }
         break;
       case GI_TYPE_TAG_INT16:
-        *((gint16 *)result) = argument.v_int16;
+        if (is_return_value) {
+            ffi_return_value->v_long = argument.v_int16;
+        } else {
+            *((gint16 *)result) = argument.v_int16;
+        }
         break;
       case GI_TYPE_TAG_UINT16:
-        *((guint16 *)result) = argument.v_uint16;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint16;
+        } else {
+            *((guint16 *)result) = argument.v_uint16;
+        }
         break;
       case GI_TYPE_TAG_INT32:
-        *((gint32 *)result) = argument.v_int32;
+        if (is_return_value) {
+            ffi_return_value->v_long = argument.v_int32;
+        } else {
+            *((gint32 *)result) = argument.v_int32;
+        }
         break;
       case GI_TYPE_TAG_UINT32:
-        *((guint32 *)result) = argument.v_uint32;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint32;
+        } else {
+            *((guint32 *)result) = argument.v_uint32;
+        }
         break;
       case GI_TYPE_TAG_INT64:
         *((gint64 *)result) = argument.v_int64;
@@ -778,32 +862,57 @@ out_argument_to_raw_data(GICallableInfo *callable_info,
         *((gdouble *)result) = argument.v_double;
         break;
       case GI_TYPE_TAG_GTYPE:
-        *((gsize *)result) = argument.v_size;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_size;
+        } else {
+            *((gsize *)result) = argument.v_size;
+        }
         break;
       case GI_TYPE_TAG_UTF8:
       case GI_TYPE_TAG_FILENAME:
-        *((gchar **)result) = argument.v_string;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_string);
+        } else {
+            *((gchar **)result) = argument.v_string;
+        }
         break;
       case GI_TYPE_TAG_ARRAY:
-        *((gpointer *)result) = argument.v_pointer;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_pointer);
+        } else {
+            *((gpointer *)result) = argument.v_pointer;
+        }
         break;
       case GI_TYPE_TAG_INTERFACE:
         out_argument_to_raw_data_interface(callable_info,
                                            &argument,
                                            result,
                                            type_info,
-                                           transfer);
+                                           transfer,
+                                           is_return_value);
         break;
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
-        *((gpointer *)result) = argument.v_pointer;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_pointer);
+        } else {
+            *((gpointer *)result) = argument.v_pointer;
+        }
         break;
       case GI_TYPE_TAG_ERROR:
-        *((GError **)result) = argument.v_pointer;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = (gulong)(argument.v_pointer);
+        } else {
+            *((GError **)result) = argument.v_pointer;
+        }
         break;
       case GI_TYPE_TAG_UNICHAR:
-        *((gunichar *)result) = argument.v_uint32;
+        if (is_return_value) {
+            ffi_return_value->v_ulong = argument.v_uint32;
+        } else {
+            *((gunichar *)result) = argument.v_uint32;
+        }
         break;
       default:
         g_assert_not_reached();
@@ -834,13 +943,15 @@ out_arguments_to_raw_data(GICallableInfo *callable_info,
                                      rb_return_value,
                                      result,
                                      return_type_info,
-                                     transfer);
+                                     transfer,
+                                     TRUE);
         } else {
             out_argument_to_raw_data(callable_info,
                                      RARRAY_AREF(rb_results, i_rb_result),
                                      result,
                                      return_type_info,
-                                     transfer);
+                                     transfer,
+                                     TRUE);
             i_rb_result++;
         }
     }
@@ -866,7 +977,8 @@ out_arguments_to_raw_data(GICallableInfo *callable_info,
                                  RARRAY_AREF(rb_results, i_rb_result),
                                  argument->v_pointer,
                                  type_info,
-                                 transfer);
+                                 transfer,
+                                 FALSE);
         i_rb_result++;
         g_base_info_unref(type_info);
     }
@@ -1194,7 +1306,7 @@ arguments_free(VALUE rb_arguments,
                 GIArgument *argument;
 
                 rb_arg_index = metadata->rb_arg_index;
-                if (rb_arg_index > 0) {
+                if (RARRAY_LEN(rb_arguments) > rb_arg_index) {
                     rb_argument = RARRAY_PTR(rb_arguments)[rb_arg_index];
                 }
                 argument = &(g_array_index(in_args, GIArgument, in_arg_index));
@@ -1267,8 +1379,12 @@ gobject_based_p(GIBaseInfo *info)
 }
 
 VALUE
-rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
-                               GIArgument *return_value, VALUE *rb_return_value)
+rb_gi_function_info_invoke_raw(GIFunctionInfo *info,
+                               VALUE rb_info,
+                               VALUE rb_receiver,
+                               VALUE rb_arguments,
+                               GIArgument *return_value,
+                               VALUE *rb_return_value)
 {
     GICallableInfo *callable_info;
     GIArgument receiver;
@@ -1278,26 +1394,9 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
     gboolean succeeded;
     GError *error = NULL;
     gboolean unlock_gvl = FALSE;
-    VALUE rb_receiver, rb_arguments, rb_unlock_gvl;
     gboolean rb_receiver_is_class = FALSE;
 
-    if (RB_TYPE_P(rb_options, RUBY_T_ARRAY)) {
-        rb_receiver = Qnil;
-        rb_arguments = rb_options;
-        rb_unlock_gvl = Qnil;
-    } else if (NIL_P(rb_options)) {
-        rb_receiver = Qnil;
-        rb_arguments = rb_ary_new();
-        rb_unlock_gvl = Qnil;
-    } else {
-        rb_options = rbg_check_hash_type(rb_options);
-        rbg_scan_options(rb_options,
-                         "receiver", &rb_receiver,
-                         "arguments", &rb_arguments,
-                         "unlock_gvl", &rb_unlock_gvl,
-                         NULL);
-    }
-
+    unlock_gvl = RVAL2CBOOL(rb_funcall(rb_info, rb_intern("unlock_gvl?"), 0));
     if (NIL_P(rb_receiver)) {
         receiver.v_pointer = NULL;
     } else {
@@ -1314,9 +1413,6 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
         }
     }
     rb_arguments = rbg_to_array(rb_arguments);
-    if (!NIL_P(rb_unlock_gvl) && RVAL2CBOOL(rb_unlock_gvl)) {
-        unlock_gvl = TRUE;
-    }
 
     callable_info = (GICallableInfo *)info;
     arguments_init(&in_args, &out_args, &args_metadata);
@@ -1382,7 +1478,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
 }
 
 static VALUE
-rg_invoke(VALUE self, VALUE rb_options)
+rg_invoke(VALUE self, VALUE rb_arguments)
 {
     GIFunctionInfo *info;
     VALUE rb_out_args;
@@ -1391,7 +1487,9 @@ rg_invoke(VALUE self, VALUE rb_options)
     info = SELF(self);
     /* TODO: use rb_protect() */
     rb_out_args = rb_gi_function_info_invoke_raw(info,
-                                                 rb_options,
+                                                 self,
+                                                 Qnil,
+                                                 rb_arguments,
                                                  NULL,
                                                  &rb_return_value);
 
@@ -1426,6 +1524,9 @@ rb_gi_function_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
     callback_finders = g_ptr_array_new();
     rb_gi_callback_register_finder(source_func_callback_finder);
 
+    RG_DEF_METHOD(set_unlock_gvl, 1);
+    RG_DEF_METHOD_P(unlock_gvl, 0);
+
     RG_DEF_METHOD(symbol, 0);
     RG_DEF_METHOD(flags, 0);
     RG_DEF_METHOD(property, 0);

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

@@ -36,7 +36,7 @@ gi_method_info_get_type(void)
 }
 
 static VALUE
-rg_invoke(VALUE self, VALUE rb_options)
+rg_invoke(VALUE self, VALUE rb_receiver, VALUE rb_arguments)
 {
     GIFunctionInfo *info;
     VALUE rb_out_args;
@@ -46,7 +46,9 @@ rg_invoke(VALUE self, VALUE rb_options)
 
     /* TODO: use rb_protect */
     rb_out_args = rb_gi_function_info_invoke_raw(info,
-                                                 rb_options,
+                                                 self,
+                                                 rb_receiver,
+                                                 rb_arguments,
                                                  NULL,
                                                  &rb_return_value);
 
@@ -76,5 +78,5 @@ rb_gi_method_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
 	G_DEF_CLASS_WITH_PARENT(GI_TYPE_METHOD_INFO, "MethodInfo", rb_mGI,
 				rb_cGIFunctionInfo);
 
-    RG_DEF_METHOD(invoke, 1);
+    RG_DEF_METHOD(invoke, 2);
 }

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

@@ -93,7 +93,9 @@ void rb_gi_repository_init           (VALUE rb_mGI);
 void rb_gi_loader_init               (VALUE rb_mGI);
 
 VALUE rb_gi_function_info_invoke_raw (GIFunctionInfo *info,
-                                      VALUE rb_options,
+                                      VALUE rb_info,
+                                      VALUE rb_receiver,
+                                      VALUE rb_arguments,
                                       GIArgument *return_value,
                                       VALUE *rb_return_value);
 

data/lib/gi.rb

@@ -0,0 +1,19 @@
+# Copyright (C) 2016  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
+# 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
+
+require "gobject-introspection"
+
+GI = GObjectIntrospection

data/lib/gobject-introspection.rb

@@ -47,6 +47,16 @@ GObjectIntrospection.prepend_typelib_path(vendor_girepository_dir)
 
 module GObjectIntrospection
   LOG_DOMAIN = "GObjectIntrospection"
+
+  class << self
+    def load(namespace, options={})
+      base_module = Module.new
+      loader = Loader.new(base_module)
+      loader.version = options[:version]
+      loader.load(namespace)
+      base_module
+    end
+  end
 end
 GLib::Log.set_log_domain(GObjectIntrospection::LOG_DOMAIN)
 

data/lib/gobject-introspection/callable-info.rb

@@ -41,11 +41,7 @@ module GObjectIntrospection
     end
 
     def require_callback?
-      args.any? do |arg|
-        arg.direction == Direction::IN and
-          arg.scope != ScopeType::INVALID and
-          !arg.may_be_null?
-      end
+      (@require_callback ||= compute_require_callback) == :required
     end
 
     def out_args
@@ -63,6 +59,12 @@ module GObjectIntrospection
       out_args.size
     end
 
+    def have_return_value?
+      return true if return_type.tag != TypeTag::VOID
+      return true if return_type.pointer?
+      not n_out_args.zero?
+    end
+
     private
     def compute_in_args
       array_length_indexes = []
@@ -103,5 +105,17 @@ module GObjectIntrospection
         end
       end
     end
+
+    def compute_require_callback
+      args.each do |arg|
+        if arg.direction == Direction::IN and
+            arg.scope != ScopeType::INVALID and
+            !arg.may_be_null?
+          return :required
+        end
+      end
+
+      :not_required
+    end
   end
 end

data/lib/gobject-introspection/loader.rb

@@ -78,44 +78,33 @@ module GObjectIntrospection
     end
 
     def define_module_function(target_module, name, function_info)
-      unlock_gvl = should_unlock_gvl?(function_info, target_module)
-      prepare = lambda do |arguments, &block|
-        arguments, block = build_arguments(function_info, arguments, &block)
-        method_name = "#{target_module}\#.#{name}"
-        validate_arguments(function_info, method_name, arguments)
-        [arguments, block]
-      end
+      function_info.unlock_gvl = should_unlock_gvl?(function_info, target_module)
+      method_name = "#{target_module}\#.#{name}"
+      arguments_builder = ArgumentsBuilder.new(function_info, method_name)
       target_module.module_eval do
         define_method(name) do |*arguments, &block|
-          arguments, block = prepare.call(arguments, &block)
-          function_info.invoke({
-                                 :arguments => arguments,
-                                 :unlock_gvl => unlock_gvl,
-                               },
-                               &block)
+          arguments_builder.build(arguments, block)
+          arguments = arguments_builder.arguments
+          block = arguments_builder.block
+          function_info.invoke(arguments, &block)
         end
         module_function(name)
       end
     end
 
     def define_singleton_method(klass, name, info)
-      unlock_gvl = should_unlock_gvl?(info, klass)
-      prepare = lambda do |arguments, &block|
-        arguments, block = build_arguments(info, arguments, &block)
-        validate_arguments(info, "#{klass}.#{name}", arguments)
-        [arguments, block]
-      end
+      info.unlock_gvl = should_unlock_gvl?(info, klass)
+      arguments_builder = ArgumentsBuilder.new(info, "#{klass}.#{name}")
+      require_callback_p = info.require_callback?
       singleton_class = (class << klass; self; end)
       singleton_class.__send__(:define_method, name) do |*arguments, &block|
-        arguments, block = prepare.call(arguments, &block)
-        if block.nil? and info.require_callback?
+        arguments_builder.build(arguments, block)
+        arguments = arguments_builder.arguments
+        block = arguments_builder.block
+        if block.nil? and require_callback_p
           to_enum(name, *arguments)
         else
-          info.invoke({
-                        :arguments => arguments,
-                        :unlock_gvl => unlock_gvl,
-                      },
-                      &block)
+          info.invoke(arguments, &block)
         end
       end
     end
@@ -286,25 +275,18 @@ module GObjectIntrospection
     def load_constructor_infos(infos, klass)
       return if infos.empty?
 
-      prepare = lambda do |info, method_name, arguments, &block|
-        arguments, block = build_arguments(info, arguments, &block)
-        validate_arguments(info, "#{klass}\##{method_name}", arguments)
-        [arguments, block]
-      end
       call_initialize_post = lambda do |object|
         initialize_post(object)
       end
       infos.each do |info|
         name = "initialize_#{info.name}"
-        unlock_gvl = should_unlock_gvl?(info, klass)
+        info.unlock_gvl = should_unlock_gvl?(info, klass)
+        arguments_builder = ArgumentsBuilder.new(info, "#{klass}\##{name}")
         klass.__send__(:define_method, name) do |*arguments, &block|
-          arguments, block = prepare.call(info, name, arguments, &block)
-          info.invoke({
-                        :receiver  => self,
-                        :arguments => arguments,
-                        :unlock_gvl => unlock_gvl,
-                      },
-                      &block)
+          arguments_builder.build(arguments, block)
+          arguments = arguments_builder.arguments
+          block = arguments_builder.block
+          info.invoke(self, arguments, &block)
           call_initialize_post.call(self)
         end
         klass.__send__(:private, name)
@@ -320,30 +302,8 @@ module GObjectIntrospection
     end
 
     def initialize_post(object)
-    end
-
-    def build_arguments(info, arguments, &block)
-      last_in_arg = info.in_args.last
-      if block and last_in_arg and last_in_arg.gclosure?
-        [arguments + [block], nil]
-      else
-        [arguments, block]
-      end
-    end
-
-    def validate_arguments(info, method_name, arguments)
-      n_in_args = info.n_in_args
-      n_required_in_args = info.n_required_in_args
-      return if (n_required_in_args..n_in_args).cover?(arguments.size)
-
-      detail = "#{arguments.size} for "
-      if n_in_args == n_required_in_args
-        detail << "#{n_in_args}"
-      else
-        detail << "#{n_required_in_args}..#{n_in_args}"
-      end
-      message = "#{method_name}: wrong number of arguments (#{detail})"
-      raise ArgumentError, message
+      return unless object.is_a?(GLib::Object)
+      self.class.reference_gobject(object, :sink => true)
     end
 
     def find_suitable_callable_info(infos, arguments)
@@ -453,7 +413,7 @@ module GObjectIntrospection
       case return_type_tag
       when TypeTag::BOOLEAN
         case name
-        when /\A(?:is|get_is)_/
+        when /\A(?:is|get_is|can_be)_/
           "#{$POSTMATCH}?"
         when /\Aget_/
           if function_info.n_in_args.zero?
@@ -539,33 +499,29 @@ module GObjectIntrospection
     end
 
     def define_method(info, klass, method_name)
-      unlock_gvl = should_unlock_gvl?(info, klass)
+      info.unlock_gvl = should_unlock_gvl?(info, klass)
       remove_existing_method(klass, method_name)
       function_info_p = (info.class == FunctionInfo)
-      no_return_value_p =
-        (info.return_type.tag == TypeTag::VOID and info.n_out_args.zero?)
-      prepare = lambda do |arguments, &block|
-        arguments, block = build_arguments(info, arguments, &block)
-        validate_arguments(info, "#{klass}\##{method_name}", arguments)
-        [arguments, block]
-      end
+      have_return_value_p = info.have_return_value?
+      arguments_builder = ArgumentsBuilder.new(info, "#{klass}\##{method_name}")
       require_callback_p = info.require_callback?
       klass.__send__(:define_method, method_name) do |*arguments, &block|
-        arguments = [self] + arguments if function_info_p
-        arguments, block = prepare.call(arguments, &block)
+        arguments.unshift(self) if function_info_p
+        arguments_builder.build(arguments, block)
+        arguments = arguments_builder.arguments
+        block = arguments_builder.block
         if block.nil? and require_callback_p
           to_enum(method_name, *arguments)
         else
-          options = {
-            :arguments => arguments,
-            :unlock_gvl => unlock_gvl,
-          }
-          options[:receiver] = self unless function_info_p
-          return_value = info.invoke(options, &block)
-          if no_return_value_p
-            self
+          if function_info_p
+            return_value = info.invoke(arguments, &block)
           else
+            return_value = info.invoke(self, arguments, &block)
+          end
+          if have_return_value_p
             return_value
+          else
+            self
           end
         end
       end
@@ -609,5 +565,80 @@ module GObjectIntrospection
       load_fields(info, klass)
       load_methods(info, klass)
     end
+
+    class ArgumentsBuilder
+      attr_reader :arguments
+      attr_reader :block
+      def initialize(info, method_name)
+        @info = info
+        @method_name = method_name
+
+        @prepared = false
+
+        @arguments = nil
+        @block = nil
+      end
+
+      def build(arguments, block)
+        prepare
+
+        @arguments = arguments
+        @block = block
+
+        build_arguments
+        validate_arguments
+      end
+
+      private
+      def prepare
+        return if @prepared
+
+        @in_args = @info.in_args
+        @n_in_args = @in_args.size
+        @n_required_in_args = @info.n_required_in_args
+        @last_in_arg = @in_args.last
+        if @last_in_arg
+          @last_in_arg_is_gclosure = @last_in_arg.gclosure?
+        else
+          @last_in_arg_is_gclosure = false
+        end
+        @valid_n_args_range = (@n_required_in_args..@n_in_args)
+
+        @prepared = true
+      end
+
+      def build_arguments
+        if @block and @last_in_arg_is_gclosure
+          @arguments << @block
+          @block = nil
+        end
+
+        n_missing_arguments = @n_in_args - @arguments.size
+        if n_missing_arguments > 0
+          nil_indexes = []
+          @in_args.each_with_index do |arg, i|
+            nil_indexes << i if arg.may_be_null?
+          end
+          return if nil_indexes.size < n_missing_arguments
+          nil_indexes.each_with_index do |nil_index, i|
+            next if i <= n_missing_arguments
+            @arguments.insert(nil_index, nil)
+          end
+        end
+      end
+
+      def validate_arguments
+        return if @valid_n_args_range.cover?(@arguments.size)
+
+        detail = "#{@arguments.size} for "
+        if @n_in_args == @n_required_in_args
+          detail << "#{@n_in_args}"
+        else
+          detail << "#{@n_required_in_args}..#{@n_in_args}"
+        end
+        message = "#{@method_name}: wrong number of arguments (#{detail})"
+        raise ArgumentError, message
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gobject-introspection
 version: !ruby/object:Gem::Version
-  version: 3.0.9
+  version: 3.1.0
 platform: ruby
 authors:
 - The Ruby-GNOME2 Project Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-12 00:00:00.000000000 Z
+date: 2016-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: glib2
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.9
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.9
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -85,6 +85,7 @@ files:
 - ext/gobject-introspection/rb-gobject-introspection.h
 - ext/gobject-introspection/rbgiversion.h
 - extconf.rb
+- lib/gi.rb
 - lib/gobject-introspection.rb
 - lib/gobject-introspection/arg-info.rb
 - lib/gobject-introspection/boxed-info.rb