gobject-introspection 1.1.9 → 1.2.0

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  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
@@ -22,6 +22,8 @@
 
 #define RG_TARGET_NAMESPACE rb_cGILoader
 
+static const gchar *boxed_class_converters_name = "@@boxed_class_converters";
+
 static VALUE
 rg_s_define_class(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
 {
@@ -49,6 +51,93 @@ rg_s_define_interface(G_GNUC_UNUSED VALUE klass,
     return G_DEF_INTERFACE(gtype, RVAL2CSTR(rb_name), rb_module);
 }
 
+static VALUE
+struct_alloc(VALUE klass)
+{
+    VALUE rb_size;
+
+    rb_size = rb_iv_get(klass, "@size");
+    return Data_Wrap_Struct(klass, NULL, xfree, xmalloc(NUM2ULONG(rb_size)));
+}
+
+static VALUE
+rg_s_define_struct(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
+{
+    VALUE rb_size, rb_name, rb_module;
+    VALUE rb_options, rb_parent;
+    VALUE rb_class;
+
+    rb_scan_args(argc, argv, "31", &rb_size, &rb_name, &rb_module, &rb_options);
+    rbg_scan_options(rb_options,
+                     "parent", &rb_parent,
+                     NULL);
+
+    rb_size = rb_to_int(rb_size);
+    if (NIL_P(rb_parent)) {
+        rb_parent = rb_cObject;
+    }
+    rb_class = rb_define_class_under(rb_module, RVAL2CSTR(rb_name), rb_parent);
+    rb_iv_set(rb_class, "@size", rb_size);
+    rb_define_alloc_func(rb_class, struct_alloc);
+    return rb_class;
+}
+
+typedef struct {
+    GType type;
+    VALUE rb_converters;
+    VALUE rb_converter;
+} BoxedInstance2RObjData;
+
+static void
+boxed_class_converter_free(gpointer user_data)
+{
+    BoxedInstance2RObjData *data = user_data;
+    rb_ary_delete(data->rb_converters, data->rb_converter);
+    g_free(data);
+}
+
+static VALUE
+boxed_instance2robj(gpointer instance, gpointer user_data)
+{
+    BoxedInstance2RObjData *data = user_data;
+    VALUE default_rb_instance;
+    VALUE klass;
+    gint flags = 0;
+    ID id_call;
+
+    default_rb_instance = rbgobj_make_boxed_default(instance, data->type);
+    CONST_ID(id_call, "call");
+    klass = rb_funcall(data->rb_converter, id_call, 1, default_rb_instance);
+    return rbgobj_make_boxed_raw(instance, data->type, klass, flags);
+}
+
+static VALUE
+rg_s_register_boxed_class_converter(VALUE klass, VALUE rb_gtype)
+{
+    RGConvertTable table;
+    BoxedInstance2RObjData *data;
+    ID id_to_i;
+    VALUE boxed_class_converters;
+
+    memset(&table, 0, sizeof(RGConvertTable));
+    CONST_ID(id_to_i, "to_i");
+    table.type = NUM2UINT(rb_funcall(rb_gtype, id_to_i, 0));
+    table.klass = Qnil;
+    table.instance2robj = boxed_instance2robj;
+
+    data = g_new(BoxedInstance2RObjData, 1);
+    data->type = table.type;
+    data->rb_converter = rb_block_proc();
+    boxed_class_converters = rb_cv_get(klass, boxed_class_converters_name);
+    rb_ary_push(boxed_class_converters, data->rb_converter);
+    table.user_data = data;
+    table.notify = boxed_class_converter_free;
+
+    rbgobj_convert_define(&table);
+
+    return Qnil;
+}
+
 void
 rb_gi_loader_init(VALUE rb_mGI)
 {
@@ -56,6 +145,10 @@ rb_gi_loader_init(VALUE rb_mGI)
 
     RG_TARGET_NAMESPACE = rb_define_class_under(rb_mGI, "Loader", rb_cObject);
 
+    rb_cv_set(RG_TARGET_NAMESPACE, boxed_class_converters_name, rb_ary_new());
+
     RG_DEF_SMETHOD(define_class, -1);
     RG_DEF_SMETHOD(define_interface, 3);
+    RG_DEF_SMETHOD(define_struct, -1);
+    RG_DEF_SMETHOD(register_boxed_class_converter, 1);
 }

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  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
@@ -35,22 +35,61 @@ gi_method_info_get_type(void)
     return type;
 }
 
+static gboolean
+gobject_based_p(GIFunctionInfo *info)
+{
+    GIBaseInfo *container_info;
+    GIRegisteredTypeInfo *registered_type_info;
+
+    container_info = g_base_info_get_container((GIBaseInfo *)info);
+    if (g_base_info_get_type(container_info) != GI_INFO_TYPE_STRUCT) {
+        return TRUE;
+    }
+
+    registered_type_info = (GIRegisteredTypeInfo *)container_info;
+    if (g_registered_type_info_get_type_init(registered_type_info)) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
 static VALUE
 rg_invoke(int argc, VALUE *argv, VALUE self)
 {
     GIFunctionInfo *info;
     GICallableInfo *callable_info;
+    GIArgument receiver;
     GIArgument return_value;
-    GITypeInfo return_value_info;
+    VALUE rb_out_args;
+    VALUE rb_return_value;
 
     info = SELF(self);
-    callable_info = (GICallableInfo *)info;
 
     /* TODO: check argc >= 1 */
-    rb_gi_function_info_invoke_raw(info, argc, argv, &return_value);
-    g_callable_info_load_return_type(callable_info, &return_value_info);
+    if (gobject_based_p(info)) {
+        receiver.v_pointer = RVAL2GOBJ(argv[0]);
+    } else {
+        receiver.v_pointer = DATA_PTR(argv[0]);
+    }
+    /* TODO: use rb_protect */
+    rb_out_args = rb_gi_function_info_invoke_raw(info, &receiver,
+                                                 argc - 1, argv + 1,
+                                                 &return_value);
 
-    return GI_ARGUMENT2RVAL(&return_value, &return_value_info);
+    callable_info = (GICallableInfo *)info;
+    rb_return_value = GI_RETURN_ARGUMENT2RVAL(&return_value, callable_info);
+
+    if (NIL_P(rb_out_args)) {
+        return rb_return_value;
+    } else {
+        GITypeInfo return_value_info;
+        g_callable_info_load_return_type(callable_info, &return_value_info);
+        if (g_type_info_get_tag(&return_value_info) != GI_TYPE_TAG_VOID) {
+            rb_ary_unshift(rb_out_args, rb_return_value);
+        }
+        return rb_out_args;
+    }
 }
 
 void

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  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
@@ -61,15 +61,22 @@ rg_get_field_value(VALUE self, VALUE rb_struct, VALUE rb_n)
     GIStructInfo *info;
     gint n;
     GIFieldInfo *field_info;
-    GType gtype;
     VALUE rb_value;
+    gpointer instance;
 
     info = SELF(self);
     n = NUM2INT(rb_n);
     field_info = g_struct_info_get_field(info, n);
-    gtype = g_registered_type_info_get_g_type(info);
-    rb_value = rb_gi_field_info_get_field_raw(field_info,
-                                              RVAL2BOXED(rb_struct, gtype));
+    if (rb_respond_to(rb_struct, rb_intern("gtype"))) {
+        VALUE rb_gtype;
+        GType gtype;
+        rb_gtype = rb_funcall(rb_struct, rb_intern("gtype"), 0);
+        gtype = NUM2UINT(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+        instance = RVAL2BOXED(rb_struct, gtype);
+    } else {
+        Data_Get_Struct(rb_struct, void, instance);
+    }
+    rb_value = rb_gi_field_info_get_field_raw(field_info, instance);
     g_base_info_unref(field_info);
 
     return rb_value;

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

@@ -112,7 +112,7 @@ rg_get_method(VALUE self, VALUE rb_n_or_name)
     GIFunctionInfo *function_info;
 
     info = SELF(self);
-    if (RB_TYPE_P(self, T_FIXNUM)) {
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
         gint n;
         n = NUM2INT(rb_n_or_name);
         function_info = g_union_info_get_method(info, n);

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2013  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
@@ -35,6 +35,8 @@ Init_gobject_introspection(void)
                                 INT2FIX(GI_MINOR_VERSION),
                                 INT2FIX(GI_MICRO_VERSION)));
 
+    rb_gi_argument_init();
+
     rb_gi_type_tag_init(RG_TARGET_NAMESPACE);
     rb_gi_base_info_init(RG_TARGET_NAMESPACE);
     rb_gi_repository_init(RG_TARGET_NAMESPACE);

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

@@ -43,6 +43,8 @@
 
 extern void Init_gobject_introspection(void);
 
+void rb_gi_argument_init             (void);
+
 void rb_gi_type_tag_init             (VALUE rb_mGI);
 void rb_gi_base_info_init            (VALUE rb_mGI);
 void rb_gi_callable_info_init        (VALUE rb_mGI,
@@ -92,7 +94,8 @@ void rb_gi_unresolved_info_init      (VALUE rb_mGI,
 void rb_gi_repository_init           (VALUE rb_mGI);
 void rb_gi_loader_init               (VALUE rb_mGI);
 
-void rb_gi_function_info_invoke_raw  (GIFunctionInfo *info,
+VALUE rb_gi_function_info_invoke_raw (GIFunctionInfo *info,
+                                      GIArgument *receiver,
                                       int argc, VALUE *argv,
                                       GIArgument *return_value);
 

data/lib/gobject-introspection.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-2013  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,9 @@ end
 GLib::Log.set_log_domain(GObjectIntrospection::LOG_DOMAIN)
 
 require "gobject-introspection/repository"
+require "gobject-introspection/callable-info"
 require "gobject-introspection/object-info"
+require "gobject-introspection/interface-info"
 require "gobject-introspection/struct-info"
+require "gobject-introspection/union-info"
 require "gobject-introspection/loader"

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

@@ -0,0 +1,55 @@
+# Copyright (C) 2013  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/collection-reader"
+
+module GObjectIntrospection
+  class CallableInfo
+    extend CollectionReader
+
+    collection_reader("args")
+
+    def in_args
+      args.find_all do |arg|
+        case arg.direction
+        when Direction::IN, Direction::INOUT
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def n_in_args
+      in_args.size
+    end
+
+    def out_args
+      args.find_all do |arg|
+        case arg.direction
+        when Direction::OUT, Direction::INOUT
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def n_out_args
+      out_args.size
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# Copyright (C) 2013  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/collection-reader"
+
+module GObjectIntrospection
+  class InterfaceInfo
+    extend CollectionReader
+
+    alias_method :__methods__, :methods
+
+    collection_reader("prerequisites")
+    collection_reader("properties")
+    collection_reader("methods")
+    collection_reader("signals")
+    collection_reader("vfuncs")
+    collection_reader("constants")
+  end
+end

data/lib/gobject-introspection/loader.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-2013  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
@@ -30,12 +30,20 @@ module GObjectIntrospection
     def load(namespace)
       repository = Repository.default
       repository.require(namespace)
+      pre_load(repository, namespace)
       repository.each(namespace) do |info|
         load_info(info)
       end
+      post_load(repository, namespace)
     end
 
     private
+    def pre_load(repository, namespace)
+    end
+
+    def post_load(repository, namespace)
+    end
+
     def load_info(info)
       case info
       when FunctionInfo
@@ -56,23 +64,34 @@ module GObjectIntrospection
     end
 
     def load_function_info(info)
-      @base_module.module_eval do
-        define_method(info.name) do |*arguments|
-          info.invoke(*arguments)
+      define_module_function(@base_module, info.name, info)
+    end
+
+    def define_module_function(target_module, name, function_info)
+      target_module.module_eval do
+        define_method(name) do |*arguments, &block|
+          function_info.invoke(*arguments, &block)
         end
-        module_function(info.name)
+        module_function(name)
       end
     end
 
+    def define_struct(info, options={})
+      if info.gtype == GLib::Type::NONE
+        klass = self.class.define_struct(info.size, info.name, @base_module,
+                                         :parent => options[:parent])
+      else
+        klass = self.class.define_class(info.gtype, info.name, @base_module,
+                                         :parent => options[:parent])
+      end
+      load_fields(info, klass)
+      load_methods(info, klass)
+    end
+
     def load_struct_info(info)
       return if info.gtype_struct?
-      return if info.gtype == GLib::Type::NONE
 
-      klass = self.class.define_class(info.gtype, info.name, @base_module)
-      load_field_infos(info, klass)
-      info.methods.each do |method_info|
-        load_method_info(method_info, klass)
-      end
+      define_struct(info)
     end
 
     def load_enum_info(info)
@@ -81,13 +100,11 @@ module GObjectIntrospection
 
     def load_object_info(info)
       klass = self.class.define_class(info.gtype, info.name, @base_module)
-      load_field_infos(info, klass)
-      info.methods.each do |method_info|
-        load_method_info(method_info, klass)
-      end
+      load_fields(info, klass)
+      load_methods(info, klass)
     end
 
-    def load_field_infos(info, klass)
+    def load_fields(info, klass)
       info.n_fields.times do |i|
         field_info = info.get_field(i)
         name = field_info.name
@@ -107,33 +124,124 @@ module GObjectIntrospection
       end
     end
 
-    def load_method_info(info, klass)
-      name = info.name
-      case info
-      when ConstructorInfo
-        if name == "new"
-          klass.__send__(:define_method, "initialize") do |*arguments|
-            info.invoke(self, *arguments)
-          end
+    def load_methods(info, klass)
+      grouped_methods = info.methods.group_by do |method_info|
+        method_info.class
+      end
+      grouped_methods.each do |method_info_class, method_infos|
+        next if method_infos.empty?
+        case method_infos.first
+        when ConstructorInfo
+          load_constructor_infos(method_infos, klass)
+        when MethodInfo
+          load_method_infos(method_infos, klass)
+        when FunctionInfo
+          load_function_infos(method_infos, klass)
         else
-          # TODO
+          raise "TODO: #{method_info_class}"
         end
-      when MethodInfo
-        klass.__send__(:define_method, name) do |*arguments|
-          info.invoke(self, *arguments)
+      end
+    end
+
+    def load_constructor_infos(infos, klass)
+      return if infos.empty?
+
+      validate = lambda do |info, arguments|
+        validate_arguments(info, arguments)
+      end
+      infos.each do |info|
+        name = "initialize_#{info.name}"
+        klass.__send__(:define_method, name) do |*arguments, &block|
+          validate.call(info, arguments, &block)
+          info.invoke(self, *arguments, &block)
         end
+      end
+
+      find_info = lambda do |arguments|
+        find_suitable_callable_info(infos, arguments)
+      end
+      klass.__send__(:define_method, "initialize") do |*arguments, &block|
+        info = find_info.call(arguments, &block)
+        __send__("initialize_#{info.name}", *arguments, &block)
+      end
+    end
+
+    def validate_arguments(info, arguments)
+      if arguments.size != info.n_in_args
+        details = "#{arguments.size} for #{info.n_in_args}"
+        raise ArgumentError, "wrong number of arguments (#{detail})"
+      end
+    end
+
+    def find_suitable_callable_info(infos, arguments)
+      min_n_args = nil
+      max_n_args = nil
+      infos.each do |info|
+        if arguments.size == info.n_in_args
+          return info
+        end
+        n_in_args = info.n_in_args
+        min_n_args = [min_n_args || n_in_args, n_in_args].min
+        max_n_args = [max_n_args || n_in_args, n_in_args].max
+      end
+      detail = "#{arguments.size} for #{min_n_args}"
+      if min_n_args < max_n_args
+        detail << "..#{max_n_args}"
+      end
+      raise ArgumentError, "wrong number of arguments (#{detail})"
+    end
+
+    def rubyish_method_name(method_info)
+      name = method_info.name
+      return_type = method_info.return_type
+      if return_type.tag == GObjectIntrospection::TypeTag::BOOLEAN
+        case name
+        when /\A(?:is|get_is|get)_/
+          "#{$POSTMATCH}?"
+        when /\A(?:has|use)_/
+          "#{name}?"
+        else
+          name
+        end
+      elsif /\Aget_/ =~ name and method_info.n_in_args.zero?
+        $POSTMATCH
       else
-        return if name == "new"
-        return if name == "alloc"
+        name
+      end
+    end
+
+    def load_method_infos(infos, klass)
+      infos.each do |info|
+        method_name = rubyish_method_name(info)
+        load_method_info(info, klass, method_name)
+        if /\Aset_/ =~ method_name and info.n_args == 1
+          klass.__send__(:alias_method, "#{$POSTMATCH}=", method_name)
+        end
+      end
+    end
+
+    def load_method_info(info, klass, method_name)
+      klass.__send__(:define_method, method_name) do |*arguments, &block|
+        info.invoke(self, *arguments, &block)
+      end
+    end
+
+    def load_function_infos(infos, klass)
+      infos.each do |info|
+        name = info.name
+        next if name == "new"
+        next if name == "alloc"
         singleton_class = (class << klass; self; end)
-        singleton_class.__send__(:define_method, name) do |*arguments|
-          info.invoke(*arguments)
+        singleton_class.__send__(:define_method, name) do |*arguments, &block|
+          info.invoke(*arguments, &block)
         end
       end
     end
 
     def load_interface_info(info)
-      self.class.define_interface(info.gtype, info.name, @base_module)
+      interface_module =
+        self.class.define_interface(info.gtype, info.name, @base_module)
+      load_methods(info, interface_module)
     end
 
     def load_constant_info(info)
@@ -142,7 +250,8 @@ module GObjectIntrospection
 
     def load_union_info(info)
       klass = self.class.define_class(info.gtype, info.name, @base_module)
-      load_field_infos(info, klass)
+      load_fields(info, klass)
+      load_methods(info, klass)
     end
   end
 end