gobject-introspection 2.2.5-x64-mingw32 → 3.0.0-x64-mingw32

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2014  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2015  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
@@ -205,6 +205,37 @@ rg_s_start_callback_dispatch_thread(G_GNUC_UNUSED VALUE klass)
     return Qnil;
 }
 
+static VALUE
+rg_s_reference_gobject(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
+{
+    VALUE rb_gobject;
+    VALUE rb_options, rb_sink;
+    gpointer gobject;
+    gboolean sink;
+
+    rb_scan_args(argc, argv, "11",
+                 &rb_gobject, &rb_options);
+    rbg_scan_options(rb_options,
+                     "sink", &rb_sink,
+                     NULL);
+
+    gobject = RVAL2GOBJ(rb_gobject);
+
+    if (NIL_P(rb_sink)) {
+        sink = FALSE;
+    } else {
+        sink = RVAL2CBOOL(rb_sink);
+    }
+
+    if (sink) {
+        g_object_ref_sink(gobject);
+    } else {
+        g_object_ref(gobject);
+    }
+
+    return Qnil;
+}
+
 void
 rb_gi_loader_init(VALUE rb_mGI)
 {
@@ -221,4 +252,5 @@ rb_gi_loader_init(VALUE rb_mGI)
     RG_DEF_SMETHOD(register_boxed_class_converter, 1);
     RG_DEF_SMETHOD(register_constant_rename_map, 2);
     RG_DEF_SMETHOD(start_callback_dispatch_thread, 0);
+    RG_DEF_SMETHOD(reference_gobject, -1);
 }

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

@@ -39,8 +39,6 @@ static VALUE
 rg_invoke(VALUE self, VALUE rb_options)
 {
     GIFunctionInfo *info;
-    GICallableInfo *callable_info;
-    GIArgument return_value;
     VALUE rb_out_args;
     VALUE rb_return_value;
 
@@ -49,14 +47,13 @@ rg_invoke(VALUE self, VALUE rb_options)
     /* TODO: use rb_protect */
     rb_out_args = rb_gi_function_info_invoke_raw(info,
                                                  rb_options,
-                                                 &return_value);
-
-    callable_info = (GICallableInfo *)info;
-    rb_return_value = GI_RETURN_ARGUMENT2RVAL(&return_value, callable_info);
+                                                 NULL,
+                                                 &rb_return_value);
 
     if (NIL_P(rb_out_args)) {
         return rb_return_value;
     } else {
+        GICallableInfo *callable_info = (GICallableInfo *)info;
         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) {

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

@@ -94,7 +94,8 @@ void rb_gi_loader_init               (VALUE rb_mGI);
 
 VALUE rb_gi_function_info_invoke_raw (GIFunctionInfo *info,
                                       VALUE rb_options,
-                                      GIArgument *return_value);
+                                      GIArgument *return_value,
+                                      VALUE *rb_return_value);
 
 VALUE rb_gi_field_info_get_field_raw (GIFieldInfo *info,
                                       gpointer     memory);

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2015  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
@@ -51,7 +51,7 @@ rg_s_default(G_GNUC_UNUSED VALUE klass)
  * loaded, this function will search for a ".typelib" file using the repository
  * search path. In addition, a version of namespace may be specified. If version
  * is not specified, the latest will be used.
- * 
+ *
  * @param [String] namespace The namespace to load
  * @param [String, nil] version An optional version
  */
@@ -68,12 +68,12 @@ rg_require(int argc, VALUE *argv, VALUE self)
     namespace_ = RVAL2CSTR(rb_namespace);
     version = RVAL2CSTR_ACCEPT_NIL(rb_version);
     if (!NIL_P(rb_flags)) {
-	flags = RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags);
+        flags = RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags);
     }
 
     g_irepository_require(SELF(self), namespace_, version, flags, &error);
     if (error) {
-	RG_RAISE_ERROR(error);
+        RG_RAISE_ERROR(error);
     }
 
     return Qnil;
@@ -84,9 +84,9 @@ rg_require(int argc, VALUE *argv, VALUE self)
  * Returned strings are of the form "namespace-version".
  * Note: namespace must have already been loaded using a function such as
  * GObjectIntrospection::Repository.require() before calling this method.
- * 
+ *
  * @param [String] namespace The namespace to get the dependencies for.
- * 
+ *
  * @return [Array<String>] The dependencies.
  */
 static VALUE
@@ -112,7 +112,7 @@ rg_get_dependencies(VALUE self, VALUE rb_namespace)
 
 
 /* Return the list of currently loaded namespaces.
- * 
+ *
  * @return [Array<String>] The loaded namespaces.
  */
 static VALUE
@@ -137,9 +137,9 @@ rg_loaded_namespaces(VALUE self)
 
 /* This method returns the number of metadata entries in given namespace. The
  * namespace must have already been loaded before calling this function.
- * 
+ *
  * @param [String] namespace The namespace to fetch the entries from.
- * 
+ *
  * @return [Integer] The number of metadata entries.
  */
 static VALUE
@@ -159,10 +159,10 @@ rg_get_n_infos(VALUE self, VALUE rb_namespace)
  *  namespace must have already been loaded before calling this function. See
  *  GObjectIntrospection::Repository#get_n_infos() to find the maximum number
  *  of entries.
- * 
+ *
  * @param [String] namespace The namespace to fetch the metadata entry from.
  * @param [Fixnum] index The index of the entry.
- * 
+ *
  * @return [GObjectIntrospection::BaseInfo] The metadata entry.
  */
 static VALUE
@@ -185,20 +185,20 @@ rg_get_info(VALUE self, VALUE rb_namespace, VALUE rb_n)
  * given, it is interpreted as a gtype and all loaded namespaces are searched
  * for it. If two arguments are given the first is a particular namespace and
  * the second the name of an entry to search for.
- * 
+ *
  * @overload find(type)
  *
  * @param [String] type The type to search for.
- * 
+ *
  * @return [GObjectIntrospection::BaseInfo] The metadata entry.
- * 
- * 
+ *
+ *
  * @overload find(namespace, type)
- * 
+ *
  * @param [String] namespace The namespace to search in.
- * 
+ *
  * @param [String] type The type to search for.
- * 
+ *
  * @return [GObjectIntrospection::BaseInfo] The metadata entry.
  */
 
@@ -208,19 +208,19 @@ rg_find(int argc, VALUE *argv, VALUE self)
     GIBaseInfo *info;
 
     if (argc == 1) {
-	VALUE rb_gtype;
-	GType gtype;
-	rb_gtype = argv[0];
-	gtype = NUM2UINT(rb_gtype);
-	info = g_irepository_find_by_gtype(SELF(self), gtype);
+        VALUE rb_gtype;
+        GType gtype;
+        rb_gtype = argv[0];
+        gtype = NUM2UINT(rb_gtype);
+        info = g_irepository_find_by_gtype(SELF(self), gtype);
     } else {
-	VALUE rb_namespace, rb_name;
-	const gchar *namespace_, *name;
+        VALUE rb_namespace, rb_name;
+        const gchar *namespace_, *name;
 
-	rb_scan_args(argc, argv, "2", &rb_namespace, &rb_name);
-	namespace_ = RVAL2CSTR(rb_namespace);
-	name = RVAL2CSTR(rb_name);
-	info = g_irepository_find_by_name(SELF(self), namespace_, name);
+        rb_scan_args(argc, argv, "2", &rb_namespace, &rb_name);
+        namespace_ = RVAL2CSTR(rb_namespace);
+        name = RVAL2CSTR(rb_name);
+        info = g_irepository_find_by_name(SELF(self), namespace_, name);
     }
 
     return GI_BASE_INFO2RVAL(info);

data/lib/gobject-introspection.rb

@@ -44,6 +44,7 @@ end
 GLib::Log.set_log_domain(GObjectIntrospection::LOG_DOMAIN)
 
 require "gobject-introspection/repository"
+require "gobject-introspection/arg-info"
 require "gobject-introspection/callable-info"
 require "gobject-introspection/object-info"
 require "gobject-introspection/interface-info"

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

@@ -0,0 +1,27 @@
+# Copyright (C) 2015  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
+
+module GObjectIntrospection
+  class ArgInfo
+    def gclosure?
+      type_info = type
+      return false if type_info.tag != TypeTag::INTERFACE
+
+      struct_info = type_info.interface
+      struct_info.gtype.name == "GClosure"
+    end
+  end
+end

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

@@ -78,7 +78,9 @@ module GObjectIntrospection
 
     def require_callback?
       args.any? do |arg|
-        arg.direction == Direction::IN and arg.scope != ScopeType::INVALID
+        arg.direction == Direction::IN and
+          arg.scope != ScopeType::INVALID and
+          !arg.may_be_null?
       end
     end
 

data/lib/gobject-introspection/loader.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-2015  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
@@ -14,6 +14,8 @@
 # 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 "English"
+
 module GObjectIntrospection
   class Loader
     class << self
@@ -72,18 +74,20 @@ module GObjectIntrospection
 
     def load_function_info(info)
       name = rubyish_method_name(info)
-      define_module_function(@base_module, name, info)
+      define_singleton_method(@base_module, name, info)
     end
 
     def define_module_function(target_module, name, function_info)
       unlock_gvl = should_unlock_gvl?(function_info, target_module)
-      validate = lambda do |arguments|
+      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
       target_module.module_eval do
         define_method(name) do |*arguments, &block|
-          validate.call(arguments, &block)
+          arguments, block = prepare.call(arguments, &block)
           function_info.invoke({
                                  :arguments => arguments,
                                  :unlock_gvl => unlock_gvl,
@@ -96,14 +100,16 @@ module GObjectIntrospection
 
     def define_singleton_method(klass, name, info)
       unlock_gvl = should_unlock_gvl?(info, klass)
-      validate = lambda do |arguments|
+      prepare = lambda do |arguments|
+        arguments, block = build_arguments(info, arguments, &block)
         validate_arguments(info, "#{klass}.#{name}", arguments)
+        [arguments, block]
       end
       singleton_class = (class << klass; self; end)
       singleton_class.__send__(:define_method, name) do |*arguments, &block|
-        validate.call(arguments, &block)
+        arguments, block = prepare.call(arguments, &block)
         if block.nil? and info.require_callback?
-          Enumerator.new(self, name, *arguments)
+          to_enum(name, *arguments)
         else
           info.invoke({
                         :arguments => arguments,
@@ -128,9 +134,21 @@ module GObjectIntrospection
     end
 
     def load_struct_info(info)
-      return if info.gtype_struct?
+      case info.name
+      when /Class\z/
+        base_class_name = $PREMATCH
+        method_infos = info.methods.find_all do |method_info|
+          method_info.is_a?(MethodInfo)
+        end
+        unless methods.empty?
+          base_class = @base_module.const_get(base_class_name)
+          load_method_infos(method_infos, base_class.singleton_class)
+        end
+      else
+        return if info.gtype_struct?
 
-      define_struct(info)
+        define_struct(info)
+      end
     end
 
     def define_boxed(info)
@@ -203,10 +221,14 @@ module GObjectIntrospection
         end
         @base_module.const_set(info.name, flags_module)
       else
-        self.class.define_class(info.gtype, info.name, @base_module)
+        self.class.define_class(info.gtype, flags_class_name(info), @base_module)
       end
     end
 
+    def flags_class_name(info)
+      info.name
+    end
+
     def load_object_info(info)
       klass = self.class.define_class(info.gtype, info.name, @base_module)
       load_fields(info, klass)
@@ -220,8 +242,12 @@ module GObjectIntrospection
       end
     end
 
+    def field_name(field_info, klass)
+      field_info.name
+    end
+
     def load_field(info, i, field_info, klass)
-      name = field_info.name
+      name = field_name(field_info, klass)
       flags = field_info.flags
 
       if flags.readable?
@@ -230,6 +256,7 @@ module GObjectIntrospection
         else
           reader_method_name = name
         end
+        remove_existing_method(klass, reader_method_name)
         klass.__send__(:define_method, reader_method_name) do ||
           info.get_field_value(self, i)
         end
@@ -264,20 +291,26 @@ module GObjectIntrospection
     def load_constructor_infos(infos, klass)
       return if infos.empty?
 
-      validate = lambda do |info, method_name, arguments|
+      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)
         klass.__send__(:define_method, name) do |*arguments, &block|
-          validate.call(info, name, arguments, &block)
+          arguments, block = prepare.call(info, name, arguments, &block)
           info.invoke({
                         :receiver  => self,
                         :arguments => arguments,
                         :unlock_gvl => unlock_gvl,
                       },
                       &block)
+          call_initialize_post.call(self)
         end
         klass.__send__(:private, name)
       end
@@ -291,6 +324,18 @@ module GObjectIntrospection
       end
     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
@@ -340,40 +385,115 @@ module GObjectIntrospection
     end
 
     def match_argument?(arg_info, argument)
-      case arg_info.type.tag
+      type = arg_info.type
+      case type.tag
+      when TypeTag::BOOLEAN
+        argument == true or argument == false
+      when TypeTag::INT8,
+           TypeTag::UINT8,
+           TypeTag::INT16,
+           TypeTag::UINT16,
+           TypeTag::INT32,
+           TypeTag::UINT32,
+           TypeTag::INT64,
+           TypeTag::UINT64,
+           TypeTag::FLOAT,
+           TypeTag::DOUBLE
+        argument.is_a?(Numeric)
+      when TypeTag::GTYPE
+        argument.is_a?(GLib::Type)
       when TypeTag::UTF8
         argument.is_a?(String)
+      when TypeTag::FILENAME
+        argument.is_a?(String)
+      when TypeTag::ARRAY
+        argument.is_a?(Array)
+      when TypeTag::INTERFACE
+        interface = type.interface
+        case interface.type
+        when InfoType::STRUCT
+          match_argument_interface_struct?(arg_info, interface, argument)
+        when InfoType::OBJECT,
+             InfoType::INTERFACE
+          argument.is_a?(interface.gtype.to_class)
+        else
+          # TODO
+          false
+        end
+      when TypeTag::GLIST,
+           TypeTag::GSLIST
+        argument.is_a?(Array)
       else
         # TODO
         false
       end
     end
 
+    def match_argument_interface_struct?(arg_info, interface, argument)
+      gtype = interface.gtype
+      case gtype.name
+      when "void"
+        # TODO
+        false
+      when "CairoSurface"
+        if Object.const_defined?(:Cairo)
+          argument.is_a?(Cairo::Surface)
+        else
+          false
+        end
+      else
+        argument.is_a?(gtype.to_class)
+      end
+    end
+
     def rubyish_method_name(function_info, options={})
       name = function_info.name
       if options[:prefix]
         name = name.gsub(/\A#{Regexp.escape(options[:prefix])}/, "")
       end
       return_type = function_info.return_type
-      if return_type.tag == GObjectIntrospection::TypeTag::BOOLEAN
+      return_type_tag = return_type.tag
+      case return_type_tag
+      when TypeTag::BOOLEAN
         case name
         when /\A(?:is|get_is)_/
           "#{$POSTMATCH}?"
         when /\Aget_/
           if function_info.n_in_args.zero?
-            "#{$POSTMATCH}?"
+            if function_info.n_out_args.zero?
+              "#{$POSTMATCH}?"
+            else
+              $POSTMATCH
+            end
           else
             name
           end
-        when /\A(?:has|use)_/
+        when /\A(?:has|use|can|in|.*_is)_/
           "#{name}?"
+        when "exists"
+          "exist?"
+        else
+          name
+        end
+      when TypeTag::GLIST, TypeTag::GSLIST
+        case name
+        when /\A(?:list|get)_/
+          if function_info.n_in_args.zero?
+            $POSTMATCH
+          else
+            name
+          end
         else
           name
         end
-      elsif /\Aget_/ =~ name and function_info.n_in_args.zero?
-        $POSTMATCH
       else
         case name
+        when /\Aget_/
+          if function_info.n_in_args.zero?
+            $POSTMATCH
+          else
+            name
+          end
         when "to_string"
           "to_s"
         when "foreach"
@@ -400,19 +520,26 @@ module GObjectIntrospection
       define_equal_style_setter(info, klass, method_name)
     end
 
+    def remove_existing_method(klass, method_name)
+      return unless klass.method_defined?(method_name)
+      return unless klass.instance_method(method_name).owner == klass
+      klass.__send__(:remove_method, method_name)
+    end
+
     def define_method(info, klass, method_name)
       unlock_gvl = should_unlock_gvl?(info, klass)
-      validate = lambda do |arguments|
+      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
-      if klass.method_defined?(method_name) and
-          klass.instance_method(method_name).owner == klass
-        klass.__send__(:remove_method, method_name)
-      end
-      function_info_p = (info.class == FunctionInfo)
       klass.__send__(:define_method, method_name) do |*arguments, &block|
         arguments = [self] + arguments if function_info_p
-        validate.call(arguments, &block)
+        arguments, block = prepare.call(arguments, &block)
         if block.nil? and info.require_callback?
           to_enum(method_name, *arguments)
         else
@@ -421,7 +548,12 @@ module GObjectIntrospection
             :unlock_gvl => unlock_gvl,
           }
           options[:receiver] = self unless function_info_p
-          info.invoke(options, &block)
+          return_value = info.invoke(options, &block)
+          if no_return_value_p
+            self
+          else
+            return_value
+          end
         end
       end
     end
@@ -429,10 +561,7 @@ module GObjectIntrospection
     def define_equal_style_setter(info, klass, method_name)
       if /\Aset_/ =~ method_name and info.n_args == 1
         setter_method_name = "#{$POSTMATCH}="
-        if klass.method_defined?(setter_method_name) and
-            klass.instance_method(setter_method_name).owner == klass
-          klass.__send__(:remove_method, setter_method_name)
-        end
+        remove_existing_method(klass, setter_method_name)
         klass.__send__(:alias_method, setter_method_name, method_name)
       end
     end