gir_ffi 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22d6bb7bfc0aa7590953b8286894e4d0e814d70c
-  data.tar.gz: 76f360c36de64f4ec95614b1d80fce35620841eb
+  metadata.gz: 1adc3c9b00a49fef5e4ae2dc6674c79c62dc56b6
+  data.tar.gz: 47303f482166c93c612ed7debdf2d2ed95aad752
 SHA512:
-  metadata.gz: b850a1fbc54e68271fbd7928a42cd657743d6e95c28dfecc85851f4ad26247b80c06aacac8a1339e3b6988d2d3fd8a72f32dc4c660ccf9c1cdcac862034d2f47
-  data.tar.gz: 712bd571f53ccf66ef8f26b85b66ccc979a9f65733c2197f0dd982fe0d2d3509c8f0bef48dd2cf289ca85632537e6ebde25828aafc55571e7d01d5f2ce1c72e6
+  metadata.gz: d6983eb6497add24e59e8d8041b815fccd9615e8e9d42895a8e1afbacb44c180a9e6bf63a9a719c6c5bca0552c9fb426391aefe5f668ba44669a3e425554fc2f
+  data.tar.gz: b904270d51f8905733777fb1ad5e9f6c8da61dd44153c078c472befcd0eee83988ebc08d95d9bb0dc3f57866cd4b4638e45046239fac63a0aa5ddc7e23ba6f49

data/Changelog.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.7.4 / 2014-05-03
+
+* Correctly handle closure data arguments originating from C
+* Handle callee-allocated simple types for callbacks and functions
+* Handle callback out parameters that are zero-terminated arrays
+* Handle virtual functions with GError arguments
+* Support the GBytes type
+* Handle virtual functions returning GObjects
+* Avoid overwriting methods with getters for properties with dashes in the name
+
 ## 0.7.3 / 2014-03-23
 
 * Restore proper handling of enums in callback arguments

data/Rakefile

@@ -1,5 +1,13 @@
 require 'rake/clean'
-require 'bundler/gem_tasks'
+require 'bundler/gem_helper'
+
+class MyGemHelper < Bundler::GemHelper
+  def version_tag
+    "version-#{version}"
+  end
+end
+
+MyGemHelper.install_tasks
 
 begin
   require 'repl_rake'

data/TODO.md

@@ -85,6 +85,10 @@ retrieve values from them by hand as well. Ideally, we would have `.from_ruby` a
 require a specifice VariantType to be used consistently. Special logic will have
 to be put in place for that.
 
+## Handle ownership-transfer correctly
+
+For how to handle objects, see https://bugzilla.gnome.org/show_bug.cgi?id=657202#c1
+
 ## See Also
 
   dnote

data/lib/ffi-glib.rb

@@ -5,6 +5,8 @@ GirFFI.setup :GLib
 
 require 'ffi-glib/array'
 require 'ffi-glib/byte_array'
+require 'ffi-glib/bytes'
+require 'ffi-glib/error'
 require 'ffi-glib/hash_table'
 require 'ffi-glib/iconv'
 require 'ffi-glib/list'
@@ -31,6 +33,9 @@ module GLib
     attach_function :g_byte_array_new, [], :pointer
     attach_function :g_byte_array_append, [:pointer, :pointer, :uint], :pointer
 
+    attach_function :g_bytes_get_data, [:pointer, :pointer], :pointer
+    attach_function :g_bytes_new, [:pointer, :size_t], :pointer
+
     attach_function :g_array_new, [:int, :int, :uint], :pointer
     attach_function :g_array_append_vals, [:pointer, :pointer, :uint], :pointer
     attach_function :g_array_get_element_size, [:pointer], :uint

data/lib/ffi-glib/bytes.rb

@@ -0,0 +1,49 @@
+module GLib
+  load_class :Bytes
+
+  # Overrides for GBytes, GLib's immutable array of bytes.
+  class Bytes
+    include Enumerable
+
+    remove_method :get_data if method_defined? :get_data
+
+    # Override for GBytes#get_data, needed due to mis-identification of the
+    # element-type of the resulting sized array.
+    def get_data
+      length_ptr = GirFFI::InOutPointer.for :gsize
+      data_ptr = Lib.g_bytes_get_data self, length_ptr
+      length = length_ptr.to_value
+      GirFFI::SizedArray.wrap(:guint8, length, data_ptr)
+    end
+
+    def each &block
+      data.each(&block)
+    end
+
+    def self.from it
+      case it
+      when self
+        it
+      when FFI::Pointer
+        wrap it
+      else
+        new it
+      end
+    end
+
+    class << self
+      undef new
+    end
+
+    def self.new arr
+      data = GirFFI::SizedArray.from :guint8, arr.size, arr
+      self.wrap Lib.g_bytes_new data.to_ptr, data.size
+    end
+
+    private
+
+    def data
+      @data ||= get_data
+    end
+  end
+end

data/lib/ffi-glib/container_class_methods.rb

@@ -8,10 +8,7 @@ module GLib
       end
     end
 
-    # FIXME: Drop Ruby 1.8.7 support and make first argument optional.
-    def from *args
-      it, typespec = *args.reverse
-      typespec ||= :void
+    def from typespec = :void, it
       case it
       when nil
         nil

data/lib/ffi-glib/error.rb

@@ -0,0 +1,17 @@
+module GLib
+  load_class :Error
+
+  # Overrides for GError, used by GLib for handling non-fatal errors.
+  class Error
+    # TODO: Auto-convert strings and symbols to quarks
+    GIR_FFI_DOMAIN = GLib.quark_from_string("gir_ffi")
+
+    def self.from_exception ex
+      new_literal GIR_FFI_DOMAIN, 0, ex.message
+    end
+
+    def self.from it
+      from_exception it
+    end
+  end
+end

data/lib/ffi-gobject/value.rb

@@ -123,8 +123,11 @@ module GObject
     end
 
     def get_enum_enhanced
-      value = get_enum
-      GirFFI::Builder.build_by_gtype(current_gtype).wrap(value)
+      current_gtype_class.wrap(get_enum)
+    end
+
+    def current_gtype_class
+      GirFFI::Builder.build_by_gtype(current_gtype)
     end
 
     def check_type_compatibility val
@@ -140,7 +143,7 @@ module GObject
       when TYPE_HASH_TABLE
         GLib::HashTable.wrap [:gpointer, :gpointer], boxed
       else
-        boxed.wrap_by_gtype current_gtype
+        current_gtype_class.wrap(boxed) unless boxed.null?
       end
     end
 

data/lib/ffi-gobject_introspection/i_callback_info.rb

@@ -4,4 +4,3 @@ module GObjectIntrospection
   class ICallbackInfo < ICallableInfo
   end
 end
-

data/lib/ffi-gobject_introspection/i_constant_info.rb

@@ -2,16 +2,16 @@ module GObjectIntrospection
   # Wraps a GIConstantInfo struct; represents a constant.
   class IConstantInfo < IBaseInfo
     TYPE_TAG_TO_UNION_MEMBER = {
-      :gint8 => :v_int8,
-      :gint16 => :v_int16,
-      :gint32 => :v_int32,
-      :gint64 => :v_int64,
-      :guint8 => :v_uint8,
-      :guint16 => :v_uint16,
-      :guint32 => :v_uint32,
-      :guint64 => :v_uint64,
-      :gdouble => :v_double,
-      :utf8 => :v_string
+      gint8:   :v_int8,
+      gint16:  :v_int16,
+      gint32:  :v_int32,
+      gint64:  :v_int64,
+      guint8:  :v_uint8,
+      guint16: :v_uint16,
+      guint32: :v_uint32,
+      guint64: :v_uint64,
+      gdouble: :v_double,
+      utf8:    :v_string
     }
 
     def value_union

data/lib/ffi-gobject_introspection/i_repository.rb

@@ -31,27 +31,27 @@ module GObjectIntrospection
   class IRepository
     # Map info type to class. Default is IBaseInfo.
     TYPEMAP = {
-      :invalid => IBaseInfo,
-      :function => IFunctionInfo,
-      :callback => ICallbackInfo,
-      :struct => IStructInfo,
+      invalid:                  IBaseInfo,
+      function:                 IFunctionInfo,
+      callback:                 ICallbackInfo,
+      struct:                   IStructInfo,
       # TODO: There's no GIBoxedInfo, so what does :boxed mean?
-      :boxed => IBaseInfo,
-      :enum => IEnumInfo,
-      :flags => IFlagsInfo,
-      :object => IObjectInfo,
-      :interface => IInterfaceInfo,
-      :constant => IConstantInfo,
-      :invalid_was_error_domain => IBaseInfo,
-      :union => IUnionInfo,
-      :value => IValueInfo,
-      :signal => ISignalInfo,
-      :vfunc => IVFuncInfo,
-      :property => IPropertyInfo,
-      :field => IFieldInfo,
-      :arg => IArgInfo,
-      :type => ITypeInfo,
-      :unresolved => IBaseInfo
+      boxed:                    IBaseInfo,
+      enum:                     IEnumInfo,
+      flags:                    IFlagsInfo,
+      object:                   IObjectInfo,
+      interface:                IInterfaceInfo,
+      constant:                 IConstantInfo,
+      invalid_was_error_domain: IBaseInfo,
+      union:                    IUnionInfo,
+      value:                    IValueInfo,
+      signal:                   ISignalInfo,
+      vfunc:                    IVFuncInfo,
+      property:                 IPropertyInfo,
+      field:                    IFieldInfo,
+      arg:                      IArgInfo,
+      type:                     ITypeInfo,
+      unresolved:               IBaseInfo
     }
 
     def initialize

data/lib/ffi-gobject_introspection/i_vfunc_info.rb

@@ -5,12 +5,19 @@ module GObjectIntrospection
     def flags
       Lib.g_vfunc_info_get_flags @gobj
     end
+
+    def throws?
+      flags & 8 != 0
+    end
+
     def offset
       Lib.g_vfunc_info_get_offset @gobj
     end
+
     def signal
       ISignalInfo.wrap(Lib.g_vfunc_info_get_signal @gobj)
     end
+
     def invoker
       IFunctionInfo.wrap(Lib.g_vfunc_info_get_invoker @gobj)
     end

data/lib/ffi-gobject_introspection/lib.rb

@@ -210,13 +210,7 @@ module GObjectIntrospection
 
     # IVFuncInfo
 
-    enum :IVFuncInfoFlags, [
-      :must_chain_up, (1 << 0),
-      :must_override, (1 << 1),
-      :must_not_override, (1 << 2)
-    ]
-
-    attach_function :g_vfunc_info_get_flags, [:pointer], :IVFuncInfoFlags
+    attach_function :g_vfunc_info_get_flags, [:pointer], :int
     attach_function :g_vfunc_info_get_offset, [:pointer], :int
     attach_function :g_vfunc_info_get_signal, [:pointer], :pointer
     attach_function :g_vfunc_info_get_invoker, [:pointer], :pointer

data/lib/gir_ffi/arg_helper.rb

@@ -1,9 +1,30 @@
 require 'gir_ffi/allocation_helper'
 require 'gir_ffi/builder'
+require 'gir_ffi/glib_error'
 
 module GirFFI
   module ArgHelper
-    OBJECT_STORE = {}
+    class ObjectStore
+      def initialize
+        @store = {}
+      end
+
+      def store(ptr, obj)
+        @store[ptr.address] = obj
+      end
+
+      def fetch(ptr)
+        return if ptr.null?
+        key = ptr.address
+        if @store.has_key? key
+          @store[key]
+        else
+          ptr
+        end
+      end
+    end
+
+    OBJECT_STORE = ObjectStore.new
 
     def self.ptr_to_utf8_length ptr, len
       ptr.null? ? nil : ptr.read_string(len)
@@ -11,7 +32,7 @@ module GirFFI
 
     def self.check_error errpp
       err = GLib::Error.wrap(errpp.read_pointer)
-      raise err.message if err
+      raise GLibError, err if err
     end
 
     def self.check_fixed_array_size size, arr, name

data/lib/gir_ffi/builders/argument_builder.rb

@@ -63,13 +63,27 @@ module GirFFI
 
       def output_value
         base = "#{callarg}.to_value"
-        if @type_info.needs_conversion_for_functions?
+        if needs_out_conversion?
           CToRubyConvertor.new(@type_info, base, length_argument_name).conversion
+        elsif allocated_by_them?
+          "GirFFI::InOutPointer.new(#{type_info.tag_or_class[1].inspect}, #{base}).to_value"
         else
           base
         end
       end
 
+      def needs_out_conversion?
+        @type_info.needs_c_to_ruby_conversion_for_functions?
+      end
+
+      # Check if an out argument needs to be allocated by them, the callee. Since
+      # caller_allocates is false by default, we must also check that the type
+      # is a pointer. For example, an out parameter of type gint8* will always
+      # be allocated by the caller (that's us).
+      def allocated_by_them?
+        !@arginfo.caller_allocates? && @type_info.pointer?
+      end
+
       def length_argument_name
         length_arg && length_arg.post_converted_name
       end

data/lib/gir_ffi/builders/base_argument_builder.rb

@@ -37,6 +37,7 @@ module GirFFI
       end
 
       def specialized_type_tag
+        # SMELL: Law of Demeter, due to this being arginfo.argument_type.flattened_tag
         type_info.flattened_tag
       end
 

data/lib/gir_ffi/builders/callback_argument_builder.rb

@@ -21,9 +21,7 @@ module GirFFI
       end
 
       def capture_variable_name
-        if direction == :out
-          @capture_variable_name ||= new_variable
-        end
+        result_name if direction == :out
       end
 
       def pre_conversion
@@ -32,12 +30,24 @@ module GirFFI
           [ "#{pre_converted_name} = #{pre_convertor.conversion}" ]
         when :out
           [ "#{pre_converted_name} = #{out_parameter_preparation}" ]
+        when :error
+          [
+            "#{pre_converted_name} = #{out_parameter_preparation}",
+            "begin"
+          ]
         end
       end
 
       def post_conversion
-        if direction == :out
-          [ "#{pre_converted_name}.set_value #{capture_variable_name}" ]
+        case direction
+        when :out
+          [ outgoing_post_conversion ]
+        when :error
+          [
+            "rescue => #{result_name}",
+            outgoing_post_conversion,
+            "end"
+          ]
         else
           []
         end
@@ -45,10 +55,14 @@ module GirFFI
 
       private
 
+      def result_name
+        @result_name ||= new_variable
+      end
+
       def pre_convertor
         @pre_convertor ||= if is_closure
                              ClosureConvertor.new(method_argument_name)
-                           elsif type_info.needs_conversion_for_callbacks?
+                           elsif type_info.needs_c_to_ruby_conversion_for_callbacks?
                              CToRubyConvertor.new(type_info,
                                                   method_argument_name,
                                                   length_argument_name)
@@ -57,8 +71,36 @@ module GirFFI
                            end
       end
 
+      def outgoing_post_conversion
+        "#{pre_converted_name}.set_value #{outgoing_convertor.conversion}"
+      end
+
+      def outgoing_convertor
+        @outgoing_convertor ||= if type_info.needs_ruby_to_c_conversion_for_callbacks?
+                                  RubyToCConvertor.new(type_info, result_name)
+                                else
+                                  NullConvertor.new(result_name)
+                                end
+      end
+
       def out_parameter_preparation
-        "GirFFI::InOutPointer.new(#{type_info.tag_or_class.inspect}, #{method_argument_name})"
+        type_spec = type_info.tag_or_class
+        if allocated_by_us?
+          "GirFFI::InOutPointer.new(#{type_spec[1].inspect})" +
+            ".tap { |ptr| #{method_argument_name}.put_pointer 0, ptr }"
+        else
+          "GirFFI::InOutPointer.new(#{type_spec.inspect}, #{method_argument_name})"
+        end
+      end
+
+      # Check if an out argument needs to be allocated by us, the callee. Since
+      # caller_allocates is false by default, we must also check that the type
+      # is a pointer. For example, an out parameter of type gint8* will always
+      # be allocate by the caller.
+      def allocated_by_us?
+        !@arginfo.caller_allocates? &&
+          type_info.pointer? &&
+          ![:object, :zero_terminated].include?(specialized_type_tag)
       end
 
       def length_argument_name