gir_ffi 0.9.5 → 0.10.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16ecb2c35535aff890ce4f63d90d9522a697c042
-  data.tar.gz: 54025535f0adadd1b3a1bc940d78ec7acbbdf47b
+  metadata.gz: 35f0c0d049d4d368c306162a75fbc3e2f5d15f7a
+  data.tar.gz: 2bc5789912987309b031c94477290b4988e26f4d
 SHA512:
-  metadata.gz: ae487826ba3c2f6e22ae78717b0f9523eb7d06e57a1892d52e50a950a925ae6cf18477bbf147c730b70e50b6c19373332f9b8409b0414a338e543ff3f7c7eea0
-  data.tar.gz: 16d9cf79dc31a6d5b591e4b835c1f3649414e9179a45e393c869bc8c5750b32573938b4817638b8d0355700a617951f828c3f11c435d1c7797aa0e63780dd9fc
+  metadata.gz: cfe43dd9795cc18eb70b096306a7bb7413d581b7df91fbcbe0339788a379f73c4357b5d997db6064fd907563ae23f8943df3cf2b16153de10e3d7f0761f51427
+  data.tar.gz: 667648adf9dc0ccfb8371af90fce175c4d28d3c450f2500a7b7715a05c07431d878a508ff4362a77307697554cabccb9f9051462ac840e9b8c8b91c57c633fe1

data/Changelog.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.10.0.pre1 / 2016-03-22
+
+* Rework generated method code to use less indirection.
+* Remove unused classes and methods
+* Clearly distinguish boxed types from other structs
+* Take ownership transfer into account in generated methods
+* Properly free unions, structs and boxed types owned by gir_ffi
+* Block access to fields that have disguised types
+
 ## 0.9.5 / 2016-03-05
 
 * Abort if modules were defined earlier, e.g., through the gems from the ruby-gnome family.

data/lib/ffi-glib/byte_array.rb

@@ -9,7 +9,7 @@ module GLib
     end
 
     def append(data)
-      bytes = GirFFI::InPointer.from :utf8, data
+      bytes = GirFFI::InPointer.from_utf8 data
       len = data.bytesize
       self.class.wrap Lib.g_byte_array_append(to_ptr, bytes, len)
     end

data/lib/ffi-glib/bytes.rb

@@ -9,12 +9,12 @@ module GLib
     remove_method :get_data if method_defined? :get_data
 
     # @override
+    # NOTE: Needed due to mis-identification of the element-type of the
+    # resulting sized array for the default binding.
     def get_data
-      length_ptr = GirFFI::InOutPointer.for :gsize
+      length_ptr = FFI::MemoryPointer.new :size_t
       data_ptr = Lib.g_bytes_get_data self, length_ptr
-      length = length_ptr.to_value
-      # NOTE: Needed due to mis-identification of the element-type of the
-      # resulting sized array for the default binding.
+      length = length_ptr.get_size_t(0)
       GirFFI::SizedArray.wrap(:guint8, length, data_ptr)
     end
 

data/lib/ffi-glib/container_class_methods.rb

@@ -10,6 +10,8 @@ module GLib
               nil
             when FFI::Pointer
               ptr
+            when self
+              ptr.to_ptr
             when GirFFI::BoxedBase
               ptr.to_ptr
             end

data/lib/ffi-glib/iconv.rb

@@ -5,8 +5,8 @@ module GLib
   # Overrides for IConv
   class IConv
     def self.open(to_codeset, from_codeset)
-      to_ptr = GirFFI::InPointer.from(:utf8, to_codeset)
-      from_ptr = GirFFI::InPointer.from(:utf8, from_codeset)
+      to_ptr = GirFFI::InPointer.from_utf8 to_codeset
+      from_ptr = GirFFI::InPointer.from_utf8 from_codeset
       result_ptr = Lib.g_iconv_open(to_ptr, from_ptr)
       wrap(result_ptr)
     end

data/lib/ffi-glib/variant.rb

@@ -10,18 +10,26 @@ module GLib
       get_string_without_override.first
     end
 
+    alias_method :get_string_without_override, :get_string
+    alias_method :get_string, :get_string_with_override
+
     # Initializing method used in constructors. For Variant, this needs to sink
     # the variant's floating reference.
     #
     # NOTE: This is very hard to test since it is not possible to get the
     # variant's ref count directely. However, there is an error when running
     # the tests on 32-bit systems.
+    # TODO: Move this logic elsewhere
     def store_pointer(ptr)
       super
+
+      # TODO: Ensure ptr is not autorelease
       ::GLib::Lib.g_variant_ref_sink ptr
     end
 
-    alias_method :get_string_without_override, :get_string
-    alias_method :get_string, :get_string_with_override
+    # TODO: Update ref?
+    def self.wrap_copy(val)
+      wrap(val)
+    end
   end
 end

data/lib/ffi-gobject.rb

@@ -4,13 +4,12 @@ require 'gir_ffi/core'
 # Bypass check for existing modules
 GirFFI::Builders::ModuleBuilder.new('GObject').generate
 
-require 'ffi-gobject/base'
-
 require 'ffi-gobject/value'
 require 'ffi-gobject/initially_unowned'
 require 'ffi-gobject/closure'
 require 'ffi-gobject/object'
 require 'ffi-gobject/object_class'
+require 'ffi-gobject/param_spec'
 require 'ffi-gobject/ruby_closure'
 require 'gir_ffi/signal_not_found_error'
 
@@ -19,7 +18,7 @@ module GObject
   def self.type_from_instance_pointer(inst_ptr)
     return nil if inst_ptr.null?
     klsptr = inst_ptr.get_pointer 0
-    GirFFI::InOutPointer.new(:GType, klsptr).to_value
+    klsptr.get_gtype 0
   end
 
   def self.type_from_instance(instance)
@@ -76,14 +75,6 @@ module GObject
     signal_connect object, detailed_signal, data, true, &block
   end
 
-  # Smells of :reek:LongParameterList: due to the C interface.
-  # rubocop:disable Metrics/ParameterLists
-  def self.param_spec_int(name, nick, blurb, minimum, maximum, default_value, flags)
-    ptr = Lib.g_param_spec_int(name, nick, blurb, minimum, maximum,
-                               default_value, flags)
-    ParamSpecInt.wrap(ptr)
-  end
-
   load_class :Callback
   load_class :ClosureNotify
   load_class :ConnectFlags
@@ -96,6 +87,8 @@ module GObject
     attach_function :g_object_ref, [:pointer], :pointer
     attach_function :g_object_unref, [:pointer], :pointer
 
+    attach_function :g_value_copy, [:pointer, :pointer], :void
+    attach_function :g_value_init, [:pointer, :size_t], :pointer
     attach_function :g_value_unset, [:pointer], :pointer
 
     attach_function :g_array_get_type, [], :size_t
@@ -109,9 +102,8 @@ module GObject
     attach_function :g_closure_set_marshal,
                     [:pointer, ClosureMarshal], :void
 
-    attach_function :g_param_spec_int,
-                    [:string, :string, :string, :int32, :int32, :int32, ParamFlags],
-                    :pointer
+    attach_function :g_param_spec_ref, [:pointer], :pointer
+    attach_function :g_param_spec_sink, [:pointer], :pointer
   end
 
   TYPE_ARRAY = Lib.g_array_get_type

data/lib/ffi-gobject/object.rb

@@ -26,6 +26,13 @@ module GObject
 
     private :base_initialize
 
+    remove_method :ref
+
+    def ref
+      Lib.g_object_ref self
+      self
+    end
+
     def store_pointer(ptr)
       super
       klass = self.class

data/lib/ffi-gobject/object_class.rb

@@ -13,7 +13,7 @@ module GObject
     end
 
     def gtype
-      GirFFI::InOutPointer.new(:GType, to_ptr).to_value
+      to_ptr.get_gtype 0
     end
   end
 end

data/lib/ffi-gobject/param_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+GObject.load_class :ParamSpec
+
+module GObject
+  # Overrides for GParamSpec, GObject's base class for parameter specifications.
+  class ParamSpec
+    def ref
+      Lib.g_param_spec_ref self
+      self
+    end
+  end
+end

data/lib/ffi-gobject/value.rb

@@ -4,17 +4,13 @@ GObject.load_class :Value
 module GObject
   # Overrides for GValue, GObject's generic value container structure.
   class Value
-    setup_instance_method 'init'
+    remove_method :init
 
-    def init_with_finalizer(type)
-      return self if [TYPE_NONE, TYPE_INVALID].include? type
-      init_without_finalizer(type)
+    def init(type)
+      Lib.g_value_init self, type unless [TYPE_NONE, TYPE_INVALID].include? type
       self
     end
 
-    alias_method :init_without_finalizer, :init
-    alias_method :init, :init_with_finalizer
-
     def self.make_finalizer(struct, gtype)
       proc do
         ptr = struct.to_ptr
@@ -115,10 +111,22 @@ module GObject
 
     def self.copy_value_to_pointer(value, pointer, offset = 0)
       super(value, pointer, offset).tap do
+        # FIXME: Check if this is still needed.
         value.to_ptr.autorelease = false if value
       end
     end
 
+    def self.copy(val)
+      return unless val
+      result = for_gtype(val.current_gtype)
+      Lib.g_value_copy val, result unless val.uninitialized?
+      result
+    end
+
+    def uninitialized?
+      current_gtype == TYPE_INVALID
+    end
+
     private
 
     def set_ruby_value(val)
@@ -150,10 +158,6 @@ module GObject
     def get_none
     end
 
-    def uninitialized?
-      current_gtype == TYPE_INVALID
-    end
-
     def set_instance_enhanced(val)
       check_type_compatibility val if val
       set_instance val
@@ -203,5 +207,10 @@ module GObject
       METHOD_MAP[current_gtype] || METHOD_MAP[current_fundamental_type] ||
         raise("No method map entry for #{current_gtype_name}")
     end
+
+    def make_finalizer
+      gtype = self.class.gtype
+      ObjectSpace.define_finalizer self, self.class.make_finalizer(@struct, gtype)
+    end
   end
 end

data/lib/gir_ffi-base/gobject.rb

@@ -1,13 +1,45 @@
 # frozen_string_literal: true
 
-# Ensure GLib is defined by GirFFI itself
+# Ensure GObject is defined by GirFFI itself
 raise 'The module GObject was already defined elsewhere' if Kernel.const_defined? :GObject
 
+require 'gir_ffi-base/gobject/lib'
+
 # The part of the GObject namespace that is needed by GObjectIntrospection.
 module GObject
   def self.type_init
     Lib.g_type_init
   end
-end
 
-require 'gir_ffi-base/gobject/lib'
+  def self.type_from_name(name)
+    Lib.g_type_from_name name
+  end
+
+  def self.type_fundamental(gtype)
+    Lib.g_type_fundamental gtype
+  end
+
+  TYPE_INVALID = type_from_name('invalid')
+  TYPE_NONE = type_from_name('void')
+  TYPE_INTERFACE = type_from_name('GInterface')
+  TYPE_CHAR = type_from_name('gchar')
+  TYPE_UCHAR = type_from_name('guchar')
+  TYPE_BOOLEAN = type_from_name('gboolean')
+  TYPE_INT = type_from_name('gint')
+  TYPE_UINT = type_from_name('guint')
+  TYPE_LONG = type_from_name('glong')
+  TYPE_ULONG = type_from_name('gulong')
+  TYPE_INT64 = type_from_name('gint64')
+  TYPE_UINT64 = type_from_name('guint64')
+  TYPE_ENUM = type_from_name('GEnum')
+  TYPE_FLAGS = type_from_name('GFlags')
+  TYPE_FLOAT = type_from_name('gfloat')
+  TYPE_DOUBLE = type_from_name('gdouble')
+  TYPE_STRING = type_from_name('gchararray')
+  TYPE_POINTER = type_from_name('gpointer')
+  TYPE_BOXED = type_from_name('GBoxed')
+  TYPE_PARAM = type_from_name('GParam')
+  TYPE_OBJECT = type_from_name('GObject')
+  TYPE_GTYPE = type_from_name('GType')
+  TYPE_VARIANT = type_from_name('GVariant')
+end

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

@@ -15,5 +15,7 @@ module GObject
     extend FFI::BitMasks
     ffi_lib 'gobject-2.0'
     attach_function :g_type_init, [], :void
+    attach_function :g_type_from_name, [:string], :size_t
+    attach_function :g_type_fundamental, [:size_t], :size_t
   end
 end

data/lib/gir_ffi/allocation_helper.rb

@@ -5,10 +5,21 @@ module GirFFI
   # Helper module providing a safe allocation method that raises an exception
   # if memory cannot be allocated.
   module AllocationHelper
+    # NOTE: It would be preferable to use FFI::MemoryPointer.new(size), but
+    # there is a bug in FFI which means this gives a problem:
+    #   # let ptr be a pointer not allocated by FFI.
+    #   ptr2 = FFI::MemoryPointer.new(1)
+    #   ptr.put_pointer ptr2 # This raises an out-of-bounds error.
+    # This occurs in method_int8_arg_and_out_callee
     def self.safe_malloc(size)
       ptr = LibC.malloc size
       raise NoMemoryError if ptr.null?
       ptr
     end
+
+    def self.allocate(type)
+      type_size = FFI.type_size type
+      safe_malloc(type_size)
+    end
   end
 end

data/lib/gir_ffi/arg_helper.rb

@@ -63,5 +63,9 @@ module GirFFI
     def self.cast_pointer_to_int32(ptr)
       cast_uint32_to_int32(ptr.address & 0xffffffff)
     end
+
+    def self.store(obj)
+      OBJECT_STORE.store(obj)
+    end
   end
 end

data/lib/gir_ffi/boxed_base.rb

@@ -3,50 +3,46 @@ require 'gir_ffi/class_base'
 
 module GirFFI
   # Base class for generated classes representing boxed types.
-  class BoxedBase < ClassBase
-    extend FFI::DataConverter
-
-    def self.native_type
-      FFI::Type::Struct.new(self::Struct)
+  class BoxedBase < StructBase
+    def initialize
+      store_pointer(self.class::Struct.new.to_ptr)
     end
 
-    def self.to_ffi_type
-      self
+    def self.make_finalizer(ptr, gtype)
+      proc do
+        if ptr.autorelease?
+          ptr.autorelease = false
+          GObject.boxed_free gtype, ptr
+        end
+      end
     end
 
-    # NOTE: Needed for JRuby's FFI
-    def self.to_native(value, _context)
-      value.struct
+    # Create an unowned copy of the struct represented by val
+    def self.copy_from(val)
+      copy from(val)
     end
 
-    def self.get_value_from_pointer(pointer, offset)
-      pointer + offset
+    # Wrap an owned copy of the struct represented by val
+    def self.wrap_copy(val)
+      copy(wrap(val)).tap { |it| it && it.to_ptr.autorelease = true }
     end
 
-    def self.copy_value_to_pointer(value, pointer, offset = 0)
-      size = self::Struct.size
-      bytes = if value
-                value.to_ptr.read_bytes(size)
-              else
-                "\x00" * size
-              end
-      pointer.put_bytes offset, bytes, 0, size
+    def self.copy(val)
+      return unless val
+      ptr = GObject.boxed_copy(gtype, val)
+      wrap(ptr)
     end
 
-    def initialize
-      @struct = self.class::Struct.new
-      gtype = self.class.gtype
-      if GObject.type_fundamental(gtype) == GObject::TYPE_BOXED
-        ObjectSpace.define_finalizer self, self.class.make_finalizer(@struct, gtype)
-      end
+    private
+
+    def store_pointer(ptr)
+      super
+      make_finalizer
     end
 
-    def self.make_finalizer(struct, gtype)
-      proc do
-        ptr = struct.to_ptr
-        ptr.autorelease = false
-        GObject.boxed_free gtype, struct.to_ptr
-      end
+    def make_finalizer
+      gtype = self.class.gtype
+      ObjectSpace.define_finalizer self, self.class.make_finalizer(to_ptr, gtype)
     end
   end
 end

data/lib/gir_ffi/builders/argument_builder.rb

@@ -3,6 +3,7 @@ require 'gir_ffi/builders/base_argument_builder'
 require 'gir_ffi/builders/closure_to_pointer_convertor'
 require 'gir_ffi/builders/full_c_to_ruby_convertor'
 require 'gir_ffi/builders/ruby_to_c_convertor'
+require 'gir_ffi/builders/pointer_value_convertor'
 require 'gir_ffi/builders/null_convertor'
 
 module GirFFI
@@ -51,7 +52,7 @@ module GirFFI
           pr << "#{call_argument_name} = #{ingoing_convertor.conversion}"
         when :inout
           pr << out_parameter_preparation
-          pr << "#{call_argument_name}.set_value #{ingoing_convertor.conversion}"
+          pr << ingoing_value_storage
         when :out
           pr << out_parameter_preparation
         when :error
@@ -73,6 +74,11 @@ module GirFFI
 
       private
 
+      def ingoing_value_storage
+        PointerValueConvertor.new(type_spec).
+          value_to_pointer(call_argument_name, ingoing_convertor.conversion)
+      end
+
       def has_post_conversion?
         has_output_value? && (!caller_allocated_object? || gvalue?)
       end
@@ -81,16 +87,29 @@ module GirFFI
         if caller_allocated_object? && gvalue?
           return "#{call_argument_name}.get_value"
         end
-        base = "#{call_argument_name}.to_value"
+        base = pointer_to_value_method_call call_argument_name, type_spec
         if needs_out_conversion?
-          FullCToRubyConvertor.new(@type_info, base, length_argument_name).conversion
+          outgoing_convertor(base).conversion
         elsif allocated_by_them?
-          "GirFFI::InOutPointer.new(#{type_info.tag_or_class[1].inspect}, #{base}).to_value"
+          pointer_to_value_method_call base, sub_type_spec
         else
           base
         end
       end
 
+      def outgoing_convertor(base)
+        FullCToRubyConvertor.new(@type_info, base, length_argument_name,
+                                 ownership_transfer: @arginfo.ownership_transfer)
+      end
+
+      def sub_type_spec
+        type_spec[1]
+      end
+
+      def pointer_to_value_method_call(ptr_exp, spec)
+        PointerValueConvertor.new(spec).pointer_to_value(ptr_exp)
+      end
+
       def needs_out_conversion?
         @type_info.needs_c_to_ruby_conversion_for_functions?
       end
@@ -154,11 +173,16 @@ module GirFFI
                     "#{argument_class_name}.new"
                   end
                 else
-                  "GirFFI::InOutPointer.for #{type_info.tag_or_class.inspect}"
+                  ffi_type_spec = TypeMap.type_specification_to_ffi_type type_spec
+                  "FFI::MemoryPointer.new #{ffi_type_spec.inspect}"
                 end
         "#{call_argument_name} = #{value}"
       end
 
+      def type_spec
+        type_info.tag_or_class
+      end
+
       def caller_allocated_object?
         [:struct, :array].include?(specialized_type_tag) &&
           @arginfo.caller_allocates?
@@ -174,7 +198,8 @@ module GirFFI
         elsif closure?
           ClosureToPointerConvertor.new(pre_convertor_argument, @is_closure)
         elsif @type_info.needs_ruby_to_c_conversion_for_functions?
-          RubyToCConvertor.new(@type_info, pre_convertor_argument)
+          RubyToCConvertor.new(@type_info, pre_convertor_argument,
+                               ownership_transfer: ownership_transfer)
         else
           NullConvertor.new(pre_convertor_argument)
         end