gir_ffi 0.15.3 → 0.15.4

data/lib/ffi-gobject/object_class.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-GObject.load_class :ObjectClass
+GObject::Object.object_class
 
 module GObject
   # Overrides for GObjectClass, a struct containing GObject's class data

data/lib/ffi-gobject/value.rb

@@ -5,18 +5,7 @@ GObject.load_class :Value
 module GObject
   # Overrides for GValue, GObject's generic value container structure.
   class Value
-    remove_method :init
-
-    def initialize
-      super
-      struct.owned = true
-      to_ptr.autorelease = nil
-    end
-
-    def init(type)
-      Lib.g_value_init self, type unless [TYPE_NONE, TYPE_INVALID].include? type
-      self
-    end
+    setup_instance_method! :init
 
     def self.make_finalizer(struct)
       proc do
@@ -54,37 +43,6 @@ module GObject
       TYPE_VARIANT   => [:get_variant,        :set_variant]
     }.freeze
 
-    def set_value(val)
-      send set_method, val
-    end
-
-    alias value= set_value
-
-    def current_gtype
-      struct[:g_type]
-    end
-
-    def current_fundamental_type
-      GObject.type_fundamental current_gtype
-    end
-
-    def current_gtype_name
-      GObject.type_name current_gtype
-    end
-
-    def get_value
-      value = get_value_plain
-      if current_fundamental_type == TYPE_BOXED
-        wrap_boxed value
-      else
-        value
-      end
-    end
-
-    def get_value_plain
-      send get_method
-    end
-
     # TODO: Give more generic name
     def self.wrap_ruby_value(val)
       new.tap { |gv| gv.__send__ :set_ruby_value, val }
@@ -119,17 +77,6 @@ module GObject
       Lib.g_value_copy value, target unless value.uninitialized?
     end
 
-    def uninitialized?
-      current_gtype == TYPE_INVALID
-    end
-
-    private
-
-    def set_ruby_value(val)
-      init_for_ruby_value val if uninitialized?
-      set_value val
-    end
-
     CLASS_TO_GTYPE_MAP = {
       NilClass   => TYPE_INVALID,
       TrueClass  => TYPE_BOOLEAN,
@@ -138,78 +85,130 @@ module GObject
       String     => TYPE_STRING
     }.freeze
 
-    def init_for_ruby_value(val)
-      return init val.class.gtype if val.class.respond_to? :gtype
+    # Overrides for existing Value methods
+    module Overrides
+      def set_value(val)
+        send set_method, val
+      end
+
+      alias value= set_value
 
-      CLASS_TO_GTYPE_MAP.each do |klass, type|
-        return init type if val.is_a? klass
+      def current_gtype
+        struct[:g_type]
       end
-      raise "Can't handle #{val.class}"
-    end
 
-    def set_none(_val); end
+      def current_fundamental_type
+        GObject.type_fundamental current_gtype
+      end
 
-    def get_none; end
+      def current_gtype_name
+        GObject.type_name current_gtype
+      end
 
-    def set_instance_enhanced(val)
-      check_type_compatibility val if val
-      set_instance val
-    end
+      def get_value
+        value = get_value_plain
+        if current_fundamental_type == TYPE_BOXED
+          wrap_boxed value
+        else
+          value
+        end
+      end
 
-    def set_enum_enhanced(val)
-      val = current_gtype_class.to_native(val, nil)
-      set_enum val
-    end
+      def get_value_plain
+        send get_method
+      end
 
-    def get_enum_enhanced
-      current_gtype_class.wrap(get_enum)
-    end
+      def uninitialized?
+        current_gtype == TYPE_INVALID
+      end
 
-    def set_flags_enhanced(val)
-      val = current_gtype_class.to_native(val, nil)
-      set_flags val
-    end
+      def init(type)
+        Lib.g_value_init self, type unless [TYPE_NONE, TYPE_INVALID].include? type
+        self
+      end
 
-    def get_flags_enhanced
-      current_gtype_class.wrap(get_flags)
-    end
+      private
 
-    def current_gtype_class
-      GirFFI::Builder.build_by_gtype(current_gtype)
-    end
+      def set_ruby_value(val)
+        init_for_ruby_value val if uninitialized?
+        set_value val
+      end
+
+      def init_for_ruby_value(val)
+        return init val.class.gtype if val.class.respond_to? :gtype
 
-    def check_type_compatibility(val)
-      if GObject::Value.type_compatible(GObject.type_from_instance(val), current_gtype)
-        return
+        CLASS_TO_GTYPE_MAP.each do |klass, type|
+          return init type if val.is_a? klass
+        end
+        raise "Can't handle #{val.class}"
       end
 
-      raise ArgumentError, "#{val.class} is incompatible with #{current_gtype_name}"
-    end
+      def set_none(_val); end
 
-    def wrap_boxed(boxed)
-      case current_gtype
-      when TYPE_STRV
-        GLib::Strv.wrap boxed
-      when TYPE_HASH_TABLE
-        GLib::HashTable.wrap [:gpointer, :gpointer], boxed
-      when TYPE_ARRAY
-        GLib::Array.wrap nil, boxed
-      else
-        current_gtype_class.wrap(boxed) unless boxed.null?
+      def get_none; end
+
+      def set_instance_enhanced(val)
+        check_type_compatibility val if val
+        set_instance val
       end
-    end
 
-    def get_method
-      method_map_entry.first
-    end
+      def set_enum_enhanced(val)
+        val = current_gtype_class.to_native(val, nil)
+        set_enum val
+      end
 
-    def set_method
-      method_map_entry.last
-    end
+      def get_enum_enhanced
+        current_gtype_class.wrap(get_enum)
+      end
+
+      def set_flags_enhanced(val)
+        val = current_gtype_class.to_native(val, nil)
+        set_flags val
+      end
 
-    def method_map_entry
-      METHOD_MAP[current_gtype] || METHOD_MAP[current_fundamental_type] ||
-        raise("No method map entry for '#{current_gtype_name}'")
+      def get_flags_enhanced
+        current_gtype_class.wrap(get_flags)
+      end
+
+      def current_gtype_class
+        GirFFI::Builder.build_by_gtype(current_gtype)
+      end
+
+      def check_type_compatibility(val)
+        if GObject::Value.type_compatible(GObject.type_from_instance(val), current_gtype)
+          return
+        end
+
+        raise ArgumentError, "#{val.class} is incompatible with #{current_gtype_name}"
+      end
+
+      def wrap_boxed(boxed)
+        case current_gtype
+        when TYPE_STRV
+          GLib::Strv.wrap boxed
+        when TYPE_HASH_TABLE
+          GLib::HashTable.wrap [:gpointer, :gpointer], boxed
+        when TYPE_ARRAY
+          GLib::Array.wrap nil, boxed
+        else
+          current_gtype_class.wrap(boxed) unless boxed.null?
+        end
+      end
+
+      def get_method
+        method_map_entry.first
+      end
+
+      def set_method
+        method_map_entry.last
+      end
+
+      def method_map_entry
+        METHOD_MAP[current_gtype] || METHOD_MAP[current_fundamental_type] ||
+          raise("No method map entry for '#{current_gtype_name}'")
+      end
     end
+
+    prepend Overrides
   end
 end

data/lib/ffi-gobject_introspection/i_base_info.rb

@@ -35,7 +35,7 @@ module GObjectIntrospection
     # Examples:
     #
     #   build_array_method :fields
-    #   build_array_mehtod :properties, :property
+    #   build_array_method :properties, :property
     #   build_array_method :get_methods
     #
     def self.build_array_method(method, single = nil)
@@ -44,12 +44,12 @@ module GObjectIntrospection
       single ||= method[0..-2]
       count = method.sub(/^(get_)?/, '\\1n_')
       class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{method}
-          #{cache_ivar} ||=
-            (0..(#{count} - 1)).map do |i|
-              #{single} i
-            end
-        end
+        def #{method}                       # def fields
+          #{cache_ivar} ||=                 #   @fields_cache ||=
+            (0..(#{count} - 1)).map do |i|  #     (0..(n_fields - 1)).map do |i|
+              #{single} i                   #       field i
+            end                             #     end
+        end                                 # end
       CODE
     end
 
@@ -76,18 +76,18 @@ module GObjectIntrospection
       counter ||= "n_#{single}s"
       fetcher ||= single
       class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{method}(name)
-          #{cache_ivar} ||= begin
-              hash = {}
-              #{counter}.times do |i|
-                it = #{fetcher}(i)
-                hash[it.name] = it
-              end
-              hash
-            end
-          name = name.to_s
-          #{cache_ivar}[name]
-        end
+        def #{method}(name)           # def find_field(name)
+          #{cache_ivar} ||= begin     #   @find_field_cache ||= begin
+              hash = {}               #       hash = {}
+              #{counter}.times do |i| #       n_fields.times do |i|
+                it = #{fetcher}(i)    #         it = field(i)
+                hash[it.name] = it    #         hash[it.name] = it
+              end                     #       end
+              hash                    #       hash
+            end                       #     end
+          name = name.to_s            #   name = name.to_s
+          #{cache_ivar}[name]         #   @find_field_cache[name]
+        end                           # end
       CODE
     end
 
@@ -111,6 +111,7 @@ module GObjectIntrospection
       @container ||= begin
                        ptr = Lib.g_base_info_get_container self
                        return if ptr.null?
+
                        Lib.g_base_info_ref ptr
                        IRepository.wrap_ibaseinfo_pointer ptr
                      end

data/lib/gir_ffi-base/gobject/lib.rb

@@ -7,9 +7,13 @@ module GObject
   module Lib
     extend FFI::Library
     extend FFI::BitMasks
+
     ffi_lib "gobject-2.0"
+
     attach_function :g_type_from_name, [:string], :size_t
     attach_function :g_type_fundamental, [:size_t], :size_t
+    attach_function :g_type_class_ref, [:size_t], :pointer
+
     attach_function :g_array_get_type, [], :size_t
     attach_function :g_byte_array_get_type, [], :size_t
     attach_function :g_error_get_type, [], :size_t

data/lib/gir_ffi/array_element_convertor.rb

@@ -4,8 +4,7 @@ module GirFFI
   # The ArrayElementConvertor class handles conversion from C array elements to
   # ruby values
   class ArrayElementConvertor
-    attr_reader :value_type
-    attr_reader :pointer
+    attr_reader :value_type, :pointer
 
     def initialize(type, ptr)
       @value_type = type

data/lib/gir_ffi/boxed_base.rb

@@ -4,11 +4,7 @@ require "gir_ffi/class_base"
 
 module GirFFI
   # Base class for generated classes representing boxed types.
-  class BoxedBase < StructBase
-    def initialize
-      store_pointer(nil)
-    end
-
+  class BoxedBase < StructLikeBase
     def self.make_finalizer(struct)
       proc do
         if struct.owned?

data/lib/gir_ffi/builder.rb

@@ -47,7 +47,7 @@ module GirFFI
       end
       Builders::ModuleBuilder.new(module_name,
                                   namespace: namespace,
-                                  version: version).generate
+                                  version:   version).generate
     end
 
     # TODO: Move elsewhere, perhaps to FunctionBuilder.

data/lib/gir_ffi/builder_helper.rb

@@ -11,10 +11,13 @@ module GirFFI
       end
     end
 
-    def get_or_define_class(namespace, name, parent)
-      klass = optionally_define_constant(namespace, name) { Class.new parent }
-      unless klass.superclass == parent
-        raise "Expected superclass #{parent}, found #{klass.superclass}"
+    def get_or_define_class(namespace, name, parent = nil)
+      klass = optionally_define_constant(namespace, name) do
+        parent ||= yield
+        Class.new parent
+      end
+      if parent && klass.superclass != parent
+        raise "Expected #{klass} to have superclass #{parent}, found #{klass.superclass}"
       end
 
       klass

data/lib/gir_ffi/builders/base_argument_builder.rb

@@ -14,8 +14,8 @@ module GirFFI
         until when while yield
       ).freeze
 
-      attr_reader :arginfo
-      attr_reader :related_callback_builder
+      attr_reader :arginfo, :related_callback_builder
+
       attr_accessor :length_arg, :array_arg
 
       def initialize(var_gen, arginfo)

data/lib/gir_ffi/builders/base_method_builder.rb

@@ -59,7 +59,7 @@ module GirFFI
         @argument_builder_collection ||=
           ArgumentBuilderCollection.new(return_value_builder, argument_builders,
                                         error_argument_builder: error_argument,
-                                        receiver_builder: receiver_builder)
+                                        receiver_builder:       receiver_builder)
       end
 
       def error_argument

data/lib/gir_ffi/builders/base_type_builder.rb

@@ -35,7 +35,7 @@ module GirFFI
     end
 
     def setup_constants
-      klass.const_set :GIR_INFO, info
+      optionally_define_constant(klass, :GIR_INFO) { info }
       klass.const_set :GIR_FFI_BUILDER, self
     end
 

data/lib/gir_ffi/builders/callback_argument_builder.rb

@@ -19,6 +19,8 @@ module GirFFI
         false
       end
 
+      # All arguments to the argument mapper must always be provided. They may
+      # be nil, though.
       def allow_none?
         false
       end

data/lib/gir_ffi/builders/callback_builder.rb

@@ -16,6 +16,20 @@ module GirFFI
         klass.class_eval mapping_method_definition, __FILE__, __LINE__
       end
 
+      def mapping_method_definition
+        MappingMethodBuilder.for_callback(info).method_definition
+      end
+
+      def argument_ffi_types
+        @argument_ffi_types ||= @info.argument_ffi_types
+      end
+
+      def return_ffi_type
+        @return_ffi_type ||= @info.return_ffi_type
+      end
+
+      private
+
       def setup_callback
         optionally_define_constant klass, :Callback do
           lib.callback callback_sym, argument_ffi_types, return_ffi_type
@@ -38,21 +52,9 @@ module GirFFI
           end
       end
 
-      def mapping_method_definition
-        MappingMethodBuilder.for_callback(info).method_definition
-      end
-
       def callback_sym
         @classname.to_sym
       end
-
-      def argument_ffi_types
-        @argument_ffi_types ||= @info.argument_ffi_types
-      end
-
-      def return_ffi_type
-        @return_ffi_type ||= @info.return_ffi_type
-      end
     end
   end
 end