gobject-introspection 3.0.7 → 3.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2d4b8a44f2004e015823a4f85c49cc09bacd3bf
-  data.tar.gz: 523e5cfffcc11754ac602f6d3a2644acf11457f8
+  metadata.gz: 56a8444d735e61e928d73a46737489b01d4e8729
+  data.tar.gz: 67cb7addc35ba3b342333351a3209f6d9a22e6cf
 SHA512:
-  metadata.gz: c810be418e039c065348695af8723513e9125d39480aa61afa21c489b1f358661360d064e16690d2da193aec27e0ee15445261d82f3344a62284c28895ee303e
-  data.tar.gz: 27d0aff69def4664d7a837d3e02eb91ba30d0e573d5eb124fdfeb925330629a0de548649989fa714ead876ac4f00007af3edf15e9e6e3e7ce7ea3da75df50bc1
+  metadata.gz: 9e885d7aafc2c2a88d3bd80913ae8242e93255f4b96969f120c1683bf5c0821a73cfda070dacdad95865606a5a528c538e46e7658191ad907180dd7d7e3a4ec1
+  data.tar.gz: f53172284ded58b0299d435c728bbd7b401b6214bde64f870c51fb22918166a789d0ba3bd88f5a7387322a2497f14b41b5957c010ee7a8f1277da79b2af60691

data/Rakefile

@@ -32,7 +32,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.44.1",
+      :version => "2.48.0",
       :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.44.0",
+      :version => "1.48.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

data/ext/gobject-introspection/extconf.rb

@@ -57,6 +57,7 @@ end
 setup_windows(module_name, base_dir)
 
 unless required_pkg_config_package(package_id,
+                                   :altlinux => "gobject-introspection-devel",
                                    :debian => "libgirepository1.0-dev",
                                    :redhat => "gobject-introspection-devel",
                                    :homebrew => "gobject-introspection",

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

@@ -559,9 +559,9 @@ interface_variant_to_ruby(GVariant *variant)
 }
 
 static VALUE
-interface_to_ruby(GIArgument *argument,
-                  gboolean duplicate,
-                  GITypeInfo *type_info)
+rb_gi_argument_to_ruby_interface(GIArgument *argument,
+                                 gboolean duplicate,
+                                 GITypeInfo *type_info)
 {
     VALUE rb_interface;
     GIBaseInfo *interface_info;
@@ -1098,7 +1098,9 @@ rb_gi_argument_to_ruby(GIArgument *argument,
                                                    args_metadata);
         break;
     case GI_TYPE_TAG_INTERFACE:
-        rb_argument = interface_to_ruby(argument, duplicate, type_info);
+        rb_argument = rb_gi_argument_to_ruby_interface(argument,
+                                                       duplicate,
+                                                       type_info);
         break;
     case GI_TYPE_TAG_GLIST:
         rb_argument = rb_gi_argument_to_ruby_glist(argument, type_info);
@@ -1298,16 +1300,20 @@ rb_gi_out_argument_init_array(GIArgument *argument, GIArgInfo *arg_info,
 }
 
 static void
-rb_gi_out_argument_init_interface(GIArgument *argument, GIArgInfo *arg_info,
+rb_gi_out_argument_init_interface(GIArgument *argument,
+                                  G_GNUC_UNUSED GIArgInfo *arg_info,
                                   GITypeInfo *type_info)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
 
+    /* TODO: Can we use the following code? */
+    /*
     if (!g_arg_info_is_caller_allocates(arg_info)) {
         argument->v_pointer = ALLOC(gpointer);
         return;
     }
+    */
 
     interface_info = g_type_info_get_interface(type_info);
     interface_type = g_base_info_get_type(interface_info);
@@ -1330,10 +1336,32 @@ rb_gi_out_argument_init_interface(GIArgument *argument, GIArgInfo *arg_info,
     }
     break;
     case GI_INFO_TYPE_BOXED:
+      rb_raise(rb_eNotImpError,
+               "TODO: allocates GIArgument(interface)[%s] for output",
+               g_info_type_to_string(interface_type));
+      break;
     case GI_INFO_TYPE_ENUM:
+      {
+          gint *pointer = ALLOC(gint);
+          *pointer = 0;
+          argument->v_pointer = pointer;
+      }
+      break;
     case GI_INFO_TYPE_FLAGS:
+      {
+          guint *pointer = ALLOC(guint);
+          *pointer = 0;
+          argument->v_pointer = pointer;
+      }
+      break;
     case GI_INFO_TYPE_OBJECT:
     case GI_INFO_TYPE_INTERFACE:
+      {
+          gpointer *pointer = ALLOC(gpointer);
+          *pointer = NULL;
+          argument->v_pointer = pointer;
+      }
+      break;
     case GI_INFO_TYPE_CONSTANT:
     case GI_INFO_TYPE_INVALID_0:
     case GI_INFO_TYPE_UNION:
@@ -1370,48 +1398,102 @@ rb_gi_out_argument_init(GIArgument *argument, GIArgInfo *arg_info)
     switch (type_tag) {
       case GI_TYPE_TAG_VOID:
         if (g_type_info_is_pointer(&type_info)) {
-            argument->v_pointer = ALLOC(gpointer);
+            gpointer *pointer = ALLOC(gpointer);
+            *pointer = NULL;
+            argument->v_pointer = pointer;
         }
         break;
       case GI_TYPE_TAG_BOOLEAN:
-        argument->v_pointer = ALLOC(gboolean);
+        {
+            gboolean *pointer = ALLOC(gboolean);
+            *pointer = FALSE;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_INT8:
-        argument->v_pointer = ALLOC(gint8);
+        {
+            gint8 *pointer = ALLOC(gint8);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_UINT8:
-        argument->v_pointer = ALLOC(guint8);
+        {
+            guint8 *pointer = ALLOC(guint8);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_INT16:
-        argument->v_pointer = ALLOC(gint16);
+        {
+            gint16 *pointer = ALLOC(gint16);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_UINT16:
-        argument->v_pointer = ALLOC(guint16);
+        {
+            guint16 *pointer = ALLOC(guint16);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_INT32:
-        argument->v_pointer = ALLOC(gint32);
+        {
+            gint32 *pointer = ALLOC(gint32);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_UINT32:
-        argument->v_pointer = ALLOC(guint32);
+        {
+            guint32 *pointer = ALLOC(guint32);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_INT64:
-        argument->v_pointer = ALLOC(gint64);
+        {
+            gint64 *pointer = ALLOC(gint64);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_UINT64:
-        argument->v_pointer = ALLOC(guint64);
+        {
+            guint64 *pointer = ALLOC(guint64);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_FLOAT:
-        argument->v_pointer = ALLOC(gfloat);
+        {
+            gfloat *pointer = ALLOC(gfloat);
+            *pointer = 0.0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_DOUBLE:
-        argument->v_pointer = ALLOC(gdouble);
+        {
+            gdouble *pointer = ALLOC(gdouble);
+            *pointer = 0.0;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_GTYPE:
-        argument->v_pointer = ALLOC(GType);
+        {
+            GType *pointer = ALLOC(GType);
+            *pointer = G_TYPE_INVALID;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_UTF8:
       case GI_TYPE_TAG_FILENAME:
-        argument->v_pointer = ALLOC(gchar *);
+        {
+            gchar **pointer = ALLOC(gchar *);
+            *pointer = NULL;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_ARRAY:
         rb_gi_out_argument_init_array(argument, arg_info, &type_info);
@@ -1422,14 +1504,25 @@ rb_gi_out_argument_init(GIArgument *argument, GIArgInfo *arg_info)
       case GI_TYPE_TAG_GLIST:
       case GI_TYPE_TAG_GSLIST:
       case GI_TYPE_TAG_GHASH:
-        argument->v_pointer = ALLOC(gpointer);
+        {
+            gpointer *pointer = ALLOC(gpointer);
+            *pointer = NULL;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_ERROR:
-        argument->v_pointer = ALLOC(GError *);
-        memset(argument->v_pointer, 0, sizeof(GError *));
+        {
+            GError **pointer = ALLOC(GError *);
+            *pointer = NULL;
+            argument->v_pointer = pointer;
+        }
         break;
       case GI_TYPE_TAG_UNICHAR:
-        argument->v_pointer = ALLOC(gunichar);
+        {
+            gunichar *pointer = ALLOC(gunichar);
+            *pointer = 0;
+            argument->v_pointer = pointer;
+        }
         break;
       default:
         g_assert_not_reached();
@@ -1824,9 +1917,13 @@ rb_gi_return_argument_free_everything_interface(GIArgument *argument,
         g_assert_not_reached();
         break;
     case GI_INFO_TYPE_UNION:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[union] everything");
-        break;
+      if (gtype == G_TYPE_NONE) {
+          rb_raise(rb_eNotImpError,
+                   "TODO: free GIArgument(interface)[union] everything");
+      } else {
+          g_boxed_free(gtype, argument->v_pointer);
+      }
+      break;
     case GI_INFO_TYPE_VALUE:
         rb_raise(rb_eNotImpError,
                  "TODO: free GIArgument(interface)[value] everything");

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2015  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-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
@@ -34,6 +34,14 @@
 #define RG_TARGET_NAMESPACE rb_cGIFunctionInfo
 #define SELF(self) RVAL2GI_FUNCTION_INFO(self)
 
+typedef struct _RBGICallback {
+    GIArgInfo *arg_info;
+    GITypeInfo *type_info;
+    GICallbackInfo *callback_info;
+    ffi_cif cif;
+    ffi_closure *closure;
+} RBGICallback;
+
 static VALUE RG_TARGET_NAMESPACE;
 static VALUE rb_cGLibError;
 static const char *callbacks_key = "gi_callbacks";
@@ -148,9 +156,6 @@ fill_metadata_callback(GPtrArray *args_metadata)
         gint destroy_index;
 
         metadata = g_ptr_array_index(args_metadata, i);
-        if (!metadata->callback_p) {
-            continue;
-        }
 
         arg_info = &(metadata->arg_info);
         closure_index = g_arg_info_get_closure(arg_info);
@@ -274,9 +279,22 @@ callback_data_unguard_from_gc(RBGICallbackData *callback_data)
     rb_hash_delete(rb_callbacks, callback_data->rb_gc_guard_key);
 }
 
+static void
+rb_gi_callback_free(RBGICallback *callback)
+{
+    g_callable_info_free_closure(callback->callback_info,
+                                 callback->closure);
+    g_base_info_unref(callback->callback_info);
+    g_base_info_unref(callback->type_info);
+    xfree(callback);
+}
+
 void
 rb_gi_callback_data_free(RBGICallbackData *callback_data)
 {
+    if (callback_data->callback) {
+        rb_gi_callback_free(callback_data->callback);
+    }
     callback_data_unguard_from_gc(callback_data);
     xfree(callback_data->metadata);
     xfree(callback_data);
@@ -380,14 +398,535 @@ source_func_callback_finder(GIArgInfo *arg_info)
     return source_func_callback;
 }
 
+static void arguments_init(GArray **in_args,
+                           GArray **out_args,
+                           GPtrArray **args_metadata);
+static void arguments_free(VALUE rb_arguments,
+                           GArray *in_args,
+                           GArray *out_args,
+                           GPtrArray *args_metadata);
+
+static void
+argument_from_raw_data_interface(GICallableInfo *callable_info,
+                                 void *raw_arg,
+                                 GIArgument *argument,
+                                 GITypeInfo *type_info)
+{
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+
+    interface_info = g_type_info_get_interface(type_info);
+    interface_type = g_base_info_get_type(interface_info);
+
+    switch (interface_type) {
+    case GI_INFO_TYPE_INVALID:
+    case GI_INFO_TYPE_FUNCTION:
+    case GI_INFO_TYPE_CALLBACK:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: raw data -> GIArgument(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    case GI_INFO_TYPE_STRUCT:
+      argument->v_pointer = *((gpointer *)(raw_arg));
+      break;
+    case GI_INFO_TYPE_BOXED:
+    case GI_INFO_TYPE_ENUM:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: raw data -> GIArgument(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    case GI_INFO_TYPE_FLAGS:
+      argument->v_int32= *((gint32 *)(raw_arg));
+      break;
+    case GI_INFO_TYPE_OBJECT:
+    case GI_INFO_TYPE_INTERFACE:
+      argument->v_pointer = *((gpointer *)(raw_arg));
+      break;
+    case GI_INFO_TYPE_CONSTANT:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: raw data -> GIArgument(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    case GI_INFO_TYPE_INVALID_0:
+        g_assert_not_reached();
+        break;
+    case GI_INFO_TYPE_UNION:
+    case GI_INFO_TYPE_VALUE:
+    case GI_INFO_TYPE_SIGNAL:
+    case GI_INFO_TYPE_VFUNC:
+    case GI_INFO_TYPE_PROPERTY:
+    case GI_INFO_TYPE_FIELD:
+    case GI_INFO_TYPE_ARG:
+    case GI_INFO_TYPE_TYPE:
+    case GI_INFO_TYPE_UNRESOLVED:
+    default:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: raw data -> GIArgument(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    }
+
+    g_base_info_unref(interface_info);
+}
+
+static void
+argument_from_raw_data(GICallableInfo *callable_info,
+                       void **raw_args,
+                       GArray *in_args,
+                       GArray *out_args,
+                       GPtrArray *args_metadata,
+                       guint i)
+{
+    RBGIArgMetadata *metadata;
+    GIArgument *argument;
+    GITypeInfo *type_info;
+    GITypeTag type_tag;
+
+    metadata = g_ptr_array_index(args_metadata, i);
+
+    if (metadata->direction == GI_DIRECTION_INOUT) {
+        argument = &g_array_index(in_args, GIArgument, metadata->in_arg_index);
+        argument->v_pointer = *((gpointer *)(raw_args[i]));
+        return;
+    } else if (metadata->direction == GI_DIRECTION_OUT) {
+        argument = &g_array_index(out_args, GIArgument, metadata->out_arg_index);
+        argument->v_pointer = *((gpointer *)(raw_args[i]));
+        return;
+    }
+
+    argument = &g_array_index(in_args, GIArgument, metadata->in_arg_index);
+    type_info = g_arg_info_get_type(&(metadata->arg_info));
+    type_tag = g_type_info_get_tag(type_info);
+
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+        argument->v_pointer = *((gpointer *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_BOOLEAN:
+        argument->v_boolean = *((gboolean *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_INT8:
+        argument->v_int8 = *((gint8 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_UINT8:
+        argument->v_uint8 = *((guint8 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_INT16:
+        argument->v_int16 = *((gint16 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_UINT16:
+        argument->v_uint16 = *((guint16 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_INT32:
+        argument->v_int32 = *((gint32 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_UINT32:
+        argument->v_uint32 = *((guint32 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_INT64:
+        argument->v_int64 = *((gint64 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_UINT64:
+        argument->v_uint64 = *((guint64 *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_FLOAT:
+        argument->v_float = *((gfloat *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_DOUBLE:
+        argument->v_double = *((gdouble *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_GTYPE:
+        argument->v_size = *((gsize *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_UTF8:
+      case GI_TYPE_TAG_FILENAME:
+        argument->v_string = *((gchar **)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_ARRAY:
+        argument->v_pointer = *((gpointer *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_INTERFACE:
+        argument_from_raw_data_interface(callable_info,
+                                         raw_args[i],
+                                         argument,
+                                         type_info);
+        break;
+      case GI_TYPE_TAG_GLIST:
+      case GI_TYPE_TAG_GSLIST:
+      case GI_TYPE_TAG_GHASH:
+        argument->v_pointer = *((gpointer *)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_ERROR:
+        argument->v_pointer = *((GError **)(raw_args[i]));
+        break;
+      case GI_TYPE_TAG_UNICHAR:
+        argument->v_uint32 = *((gunichar *)(raw_args[i]));
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+
+    g_base_info_unref(type_info);
+}
+
+static void
+arguments_from_raw_data(GICallableInfo *callable_info,
+                        void **args,
+                        GArray *in_args,
+                        GArray *out_args,
+                        GPtrArray *args_metadata)
+{
+    guint i;
+
+    for (i = 0; i < args_metadata->len; i++) {
+        argument_from_raw_data(callable_info,
+                               args,
+                               in_args,
+                               out_args,
+                               args_metadata,
+                               i);
+    }
+}
+
+static void
+in_arguments_to_ruby(GArray *in_args,
+                     GArray *out_args,
+                     GPtrArray *args_metadata,
+                     GArray *rb_args)
+{
+    guint i;
+
+    for (i = 0; i < args_metadata->len; i++) {
+        RBGIArgMetadata *metadata;
+        GIArgument *argument;
+        GITypeInfo *type_info;
+        VALUE rb_arg;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+
+        if (metadata->direction == GI_DIRECTION_OUT) {
+            continue;
+        }
+        if (metadata->closure_p) {
+            continue;
+        }
+
+        argument = &g_array_index(in_args, GIArgument, metadata->in_arg_index);
+        type_info = g_arg_info_get_type(&(metadata->arg_info));
+        rb_arg = GI_ARGUMENT2RVAL(argument,
+                                  FALSE,
+                                  type_info,
+                                  in_args,
+                                  out_args,
+                                  args_metadata);
+        g_array_append_val(rb_args, rb_arg);
+    }
+}
+
+static void
+out_argument_to_raw_data_interface(GICallableInfo *callable_info,
+                                   GIArgument *argument,
+                                   gpointer result,
+                                   GITypeInfo *type_info,
+                                   G_GNUC_UNUSED GITransfer transfer /* TODO */)
+{
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+
+    interface_info = g_type_info_get_interface(type_info);
+    interface_type = g_base_info_get_type(interface_info);
+
+    switch (interface_type) {
+    case GI_INFO_TYPE_INVALID:
+    case GI_INFO_TYPE_FUNCTION:
+    case GI_INFO_TYPE_CALLBACK:
+    case GI_INFO_TYPE_STRUCT:
+    case GI_INFO_TYPE_BOXED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: out raw data(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    case GI_INFO_TYPE_ENUM:
+      *((gint *)result) = argument->v_int;
+      break;
+    case GI_INFO_TYPE_FLAGS:
+    case GI_INFO_TYPE_OBJECT:
+    case GI_INFO_TYPE_INTERFACE:
+    case GI_INFO_TYPE_CONSTANT:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: out raw data(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    case GI_INFO_TYPE_INVALID_0:
+        g_assert_not_reached();
+        break;
+    case GI_INFO_TYPE_UNION:
+    case GI_INFO_TYPE_VALUE:
+    case GI_INFO_TYPE_SIGNAL:
+    case GI_INFO_TYPE_VFUNC:
+    case GI_INFO_TYPE_PROPERTY:
+    case GI_INFO_TYPE_FIELD:
+    case GI_INFO_TYPE_ARG:
+    case GI_INFO_TYPE_TYPE:
+    case GI_INFO_TYPE_UNRESOLVED:
+    default:
+        rb_raise(rb_eNotImpError,
+                 "TODO: %s::%s: out raw data(interface)[%s]: <%s>",
+                 g_base_info_get_namespace(callable_info),
+                 g_base_info_get_name(callable_info),
+                 g_info_type_to_string(interface_type),
+                 g_base_info_get_name(interface_info));
+        break;
+    }
+
+    g_base_info_unref(interface_info);
+}
+
+static void
+out_argument_to_raw_data(GICallableInfo *callable_info,
+                         VALUE rb_result,
+                         gpointer result,
+                         GITypeInfo *type_info,
+                         GITransfer transfer)
+{
+    GIArgument argument;
+    GITypeTag type_tag;
+
+    rb_gi_value_argument_from_ruby(&argument,
+                                   type_info,
+                                   rb_result,
+                                   rb_result);
+    type_tag = g_type_info_get_tag(type_info);
+    switch (type_tag) {
+      case GI_TYPE_TAG_VOID:
+        g_assert_not_reached();
+        break;
+      case GI_TYPE_TAG_BOOLEAN:
+        *((gboolean *)result) = argument.v_boolean;
+        break;
+      case GI_TYPE_TAG_INT8:
+        *((gint8 *)result) = argument.v_int8;
+        break;
+      case GI_TYPE_TAG_UINT8:
+        *((guint8 *)result) = argument.v_uint8;
+        break;
+      case GI_TYPE_TAG_INT16:
+        *((gint16 *)result) = argument.v_int16;
+        break;
+      case GI_TYPE_TAG_UINT16:
+        *((guint16 *)result) = argument.v_uint16;
+        break;
+      case GI_TYPE_TAG_INT32:
+        *((gint32 *)result) = argument.v_int32;
+        break;
+      case GI_TYPE_TAG_UINT32:
+        *((guint32 *)result) = argument.v_uint32;
+        break;
+      case GI_TYPE_TAG_INT64:
+        *((gint64 *)result) = argument.v_int64;
+        break;
+      case GI_TYPE_TAG_UINT64:
+        *((guint64 *)result) = argument.v_uint64;
+        break;
+      case GI_TYPE_TAG_FLOAT:
+        *((gfloat *)result) = argument.v_float;
+        break;
+      case GI_TYPE_TAG_DOUBLE:
+        *((gdouble *)result) = argument.v_double;
+        break;
+      case GI_TYPE_TAG_GTYPE:
+        *((gsize *)result) = argument.v_size;
+        break;
+      case GI_TYPE_TAG_UTF8:
+      case GI_TYPE_TAG_FILENAME:
+        *((gchar **)result) = argument.v_string;
+        break;
+      case GI_TYPE_TAG_ARRAY:
+        *((gpointer *)result) = argument.v_pointer;
+        break;
+      case GI_TYPE_TAG_INTERFACE:
+        out_argument_to_raw_data_interface(callable_info,
+                                           &argument,
+                                           result,
+                                           type_info,
+                                           transfer);
+        break;
+      case GI_TYPE_TAG_GLIST:
+      case GI_TYPE_TAG_GSLIST:
+      case GI_TYPE_TAG_GHASH:
+        *((gpointer *)result) = argument.v_pointer;
+        break;
+      case GI_TYPE_TAG_ERROR:
+        *((GError **)result) = argument.v_pointer;
+        break;
+      case GI_TYPE_TAG_UNICHAR:
+        *((gunichar *)result) = argument.v_uint32;
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+static void
+out_arguments_to_raw_data(GICallableInfo *callable_info,
+                          VALUE rb_results,
+                          void *result,
+                          GArray *out_args,
+                          GPtrArray *args_metadata)
+{
+    int i_rb_result = 0;
+    guint i;
+    GITypeInfo *return_type_info;
+    GITypeTag return_type_tag;
+
+    return_type_info = g_callable_info_get_return_type(callable_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(callable_info);
+        if (out_args->len == 0) {
+            VALUE rb_return_value = rb_results;
+            out_argument_to_raw_data(callable_info,
+                                     rb_return_value,
+                                     result,
+                                     return_type_info,
+                                     transfer);
+        } else {
+            out_argument_to_raw_data(callable_info,
+                                     RARRAY_AREF(rb_results, i_rb_result),
+                                     result,
+                                     return_type_info,
+                                     transfer);
+            i_rb_result++;
+        }
+    }
+    g_base_info_unref(return_type_info);
+
+    for (i = 0; i < args_metadata->len; i++) {
+        RBGIArgMetadata *metadata;
+        GIArgument *argument;
+        GITypeInfo *type_info;
+        GITransfer transfer;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+
+        /* TODO: support GI_DIRECTION_INOUT */
+        if (metadata->direction != GI_DIRECTION_OUT) {
+            continue;
+        }
+
+        argument = &g_array_index(out_args, GIArgument, metadata->out_arg_index);
+        type_info = g_arg_info_get_type(&(metadata->arg_info));
+        transfer = g_arg_info_get_ownership_transfer(&(metadata->arg_info));
+        out_argument_to_raw_data(callable_info,
+                                 RARRAY_AREF(rb_results, i_rb_result),
+                                 argument->v_pointer,
+                                 type_info,
+                                 transfer);
+        i_rb_result++;
+        g_base_info_unref(type_info);
+    }
+}
+
+static void
+ffi_closure_callback(G_GNUC_UNUSED ffi_cif *cif,
+                     void *result,
+                     void **raw_args,
+                     void *data)
+{
+    RBGICallback *callback = data;
+    RBGICallbackData *callback_data = NULL;
+    GArray *in_args;
+    GArray *out_args;
+    GPtrArray *args_metadata;
+    VALUE rb_results;
+
+    arguments_init(&in_args, &out_args, &args_metadata);
+    allocate_arguments(callback->callback_info,
+                       in_args,
+                       out_args,
+                       args_metadata);
+    fill_metadata(args_metadata);
+    arguments_from_raw_data(callback->callback_info,
+                            raw_args,
+                            in_args,
+                            out_args,
+                            args_metadata);
+
+    {
+        guint i;
+
+        for (i = 0; i < args_metadata->len; i++) {
+            RBGIArgMetadata *metadata;
+
+            metadata = g_ptr_array_index(args_metadata, i);
+            if (!metadata->closure_p) {
+                continue;
+            }
+
+            callback_data = *((RBGICallbackData **)(raw_args[i]));
+            break;
+        }
+    }
+
+    {
+        ID id_call;
+        GArray *rb_args;
+
+        rb_args = g_array_new(FALSE, FALSE, sizeof(VALUE));
+        in_arguments_to_ruby(in_args,
+                             out_args,
+                             args_metadata,
+                             rb_args);
+        CONST_ID(id_call, "call");
+        /* TODO: use rb_protect() */
+        rb_results = rb_funcallv(callback_data->rb_callback,
+                                 id_call,
+                                 rb_args->len,
+                                 (VALUE *)(rb_args->data));
+        g_array_free(rb_args, TRUE);
+    }
+
+    out_arguments_to_raw_data(callback->callback_info,
+                              rb_results,
+                              result,
+                              out_args,
+                              args_metadata);
+
+    if (callback_data->metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
+        rb_gi_callback_data_free(callback_data);
+    }
+}
+
 static void
 in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args)
 {
-    gpointer callback;
+    gpointer callback_function;
     GIArgInfo *arg_info;
     GIArgument *callback_argument;
     GIArgument *closure_argument = NULL;
     GIArgument *destroy_argument = NULL;
+    RBGICallback *callback = NULL;
 
     arg_info = &(metadata->arg_info);
 
@@ -416,26 +955,26 @@ in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args)
         return;
     }
 
-    callback = find_callback_function(arg_info);
-    if (!callback) {
-        GITypeInfo type_info;
-        GIBaseInfo *interface_info;
-        VALUE rb_type_name;
-        g_arg_info_load_type(arg_info, &type_info);
-        interface_info = g_type_info_get_interface(&type_info);
-        rb_type_name = CSTR2RVAL(g_base_info_get_name(interface_info));
-        g_base_info_unref(interface_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: <%s>(%s) callback is not supported yet.",
-                 RVAL2CSTR(rb_type_name),
-                 g_base_info_get_name(arg_info));
+    callback_function = find_callback_function(arg_info);
+    if (callback_function) {
+        callback_argument->v_pointer = callback_function;
+    } else {
+        callback = RB_ZALLOC(RBGICallback);
+        callback->type_info = g_arg_info_get_type(arg_info);
+        callback->callback_info = g_type_info_get_interface(callback->type_info);
+        callback->closure =
+            g_callable_info_prepare_closure(callback->callback_info,
+                                            &(callback->cif),
+                                            ffi_closure_callback,
+                                            callback);
+        callback_argument->v_pointer = callback->closure;
     }
-    callback_argument->v_pointer = callback;
 
     if (closure_argument) {
         RBGICallbackData *callback_data;
 
         callback_data = ALLOC(RBGICallbackData);
+        callback_data->callback = callback;
         callback_data->metadata = metadata;
         callback_data->rb_callback = rb_block_proc();
         callback_data_guard_from_gc(callback_data);

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

@@ -243,6 +243,14 @@ rg_find(int argc, VALUE *argv, VALUE self)
     return GI_BASE_INFO2RVAL(info);
 }
 
+static VALUE
+rg_get_version(VALUE self, VALUE rb_namespace)
+{
+    const gchar *version;
+    version = g_irepository_get_version(SELF(self), RVAL2CSTR(rb_namespace));
+    return CSTR2RVAL(version);
+}
+
 void
 rb_gi_repository_init(VALUE rb_mGI)
 {
@@ -259,6 +267,7 @@ rb_gi_repository_init(VALUE rb_mGI)
     RG_DEF_METHOD(get_n_infos, 1);
     RG_DEF_METHOD(get_info, 2);
     RG_DEF_METHOD(find, -1);
+    RG_DEF_METHOD(get_version, 1);
 
     G_DEF_CLASS(G_TYPE_I_REPOSITORY_LOAD_FLAGS, "RepositoryLoadFlags", rb_mGI);
     G_DEF_CLASS(G_TYPE_I_REPOSITORY_ERROR, "RepositoryError", rb_mGI);

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

@@ -28,6 +28,8 @@
 
 typedef gpointer (*RBGICallbackFinderFunc)(GIArgInfo *info);
 
+typedef struct _RBGICallback RBGICallback;
+
 typedef struct
 {
     GIArgInfo arg_info;
@@ -49,6 +51,7 @@ typedef struct
 } RBGIArgMetadata;
 
 typedef struct {
+    RBGICallback *callback;
     RBGIArgMetadata *metadata;
     VALUE rb_gc_guard_key;
     VALUE rb_callback;

data/lib/gobject-introspection/loader.rb

@@ -100,7 +100,7 @@ module GObjectIntrospection
 
     def define_singleton_method(klass, name, info)
       unlock_gvl = should_unlock_gvl?(info, klass)
-      prepare = lambda do |arguments|
+      prepare = lambda do |arguments, &block|
         arguments, block = build_arguments(info, arguments, &block)
         validate_arguments(info, "#{klass}.#{name}", arguments)
         [arguments, block]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gobject-introspection
 version: !ruby/object:Gem::Version
-  version: 3.0.7
+  version: 3.0.8
 platform: ruby
 authors:
 - The Ruby-GNOME2 Project Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-06 00:00:00.000000000 Z
+date: 2016-04-03 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.7
+        version: 3.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.7
+        version: 3.0.8
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -125,7 +125,7 @@ files:
 - test/test-vfunc-info.rb
 homepage: http://ruby-gnome2.sourceforge.jp/
 licenses:
-- LGPLv2.1 or later
+- LGPLv2.1+
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -143,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby/GObjectIntrospection is a Ruby binding of GObjectIntrospection.