gir_ffi 0.6.3 → 0.6.4

data/History.txt

@@ -1,3 +1,14 @@
+== 0.6.4 / 2013-06-30
+
+* Represent enum types by modules wrapping FFI::Enum
+* Support functions on enums
+* Handle zero-terminated arrays of types other than int32
+* Add override for GLib::Variant#get_string
+* Handle non-throwing arguments and return values of type GError
+* Handle arguments and return values of type GPtrArray
+* Handle caller-allocated arguments of type GArray
+* Deprecate GObject::Value#ruby_value, replacing it with #get_value
+
 == 0.6.3 / 2013-06-15
 
 * Make use of enums as element type for GHashTable and other containers

data/README.md

@@ -20,12 +20,18 @@ Ruby bindings for GNOME using the GObject Introspection Repository.
 
     require 'gir_ffi'
 
-    GirFFI.setup :TheNamespace
+    # Set up the namespace you wish to use
+    GirFFI.setup :Gio
 
-    TheNamespace.some_function
+    # Create an object
+    inet_address = Gio::InetAddress.new_from_string "127.0.0.1"
 
-    obj = TheNamespace::SomeClass.new
-    obj.some_method with, some, args
+    # Call some methods on the object
+    inet_address.is_loopback    # => true
+    inet_address.is_multicast   # => false
+
+    # Call a function in the namespace
+    Gio.dbus_is_name "foo"   # => false
 
 ## Install
 
@@ -33,8 +39,8 @@ Ruby bindings for GNOME using the GObject Introspection Repository.
 
 ## Requirements
 
-GirFFI should work on MRI 1.8 and 1.9, and JRuby in both 1.8 and 1.9
-modes. It does not work on Rubinius yet.
+GirFFI should work on MRI 1.8, 1.9 and 2.0, JRuby in both 1.8 and 1.9
+modes, and on Rubinius in both 1.8 and 1.9 modes.
 
 You will also need gobject-introspection installed with some
 introspection data.
@@ -53,6 +59,18 @@ On Debian and Ubuntu, installing `libgirepository1.0-dev` and
 
 GirFFI has not been tested on Mac OS X or Microsoft Windows. YMMV.
 
+## Overrides
+
+Sometimes, the GIR data is incorrect, or not detailed enough, and a
+reasonable binding cannot be created automatically. For these cases,
+overrides can be defined. The following gems with overrides
+already exist:
+
+* `gir_ffi-gtk`: overrides for Gtk+ 2 and 3.
+* `gir_ffi-cairo`: overrides for Cairo
+* `gir_ffi-pango`: overrides for Pango
+* `gir_ffi-tracker`: overrides for Tracker
+
 ## Hacking and contributing
 
 If you want to help out, have a look at TODO.rdoc, and check the notes

data/lib/ffi-glib/ptr_array.rb

@@ -15,10 +15,22 @@ module GLib
     end
 
     def self.new type
-      wrap(Lib.g_ptr_array_new).tap {|it|
+      wrap(type, Lib.g_ptr_array_new)
+    end
+
+    def self.wrap type, ptr
+      super(ptr).tap {|it|
         it.element_type = type}
     end
 
+    def self.from type, it
+      case it
+      when self then it
+      when FFI::Pointer then wrap type, it
+      else self.new(type).tap {|arr| arr.add_array it}
+      end
+    end
+
     def self.add array, data
       array.add data
     end
@@ -28,6 +40,10 @@ module GLib
       Lib.g_ptr_array_add self, ptr
     end
 
+    def add_array ary
+      ary.each {|item| add item}
+    end
+
     # Re-implementation of the g_ptr_array_index macro
     def index idx
       sz = FFI.type_size :pointer

data/lib/ffi-glib/variant.rb

@@ -0,0 +1,15 @@
+module GLib
+  load_class :Variant
+
+  # Overrides for GVariant, GLib's variant data type.
+  class Variant
+    setup_instance_method "get_string"
+
+    def get_string_with_override
+      get_string_without_override.first
+    end
+
+    alias get_string_without_override get_string
+    alias get_string get_string_with_override
+  end
+end

data/lib/ffi-glib.rb

@@ -11,6 +11,7 @@ require 'ffi-glib/ptr_array'
 require 'ffi-glib/s_list'
 require 'ffi-glib/sized_array'
 require 'ffi-glib/strv'
+require 'ffi-glib/variant'
 
 module GLib
   load_class :HFunc

data/lib/ffi-gobject/object.rb

@@ -18,7 +18,7 @@ module GObject
 
       get_property_without_override property_name, gvalue
 
-      adjust_value_to_type gvalue.ruby_value, type
+      adjust_value_to_type gvalue.get_value, type
     end
 
     def set_property_with_override property_name, value

data/lib/ffi-gobject/ruby_closure.rb

@@ -43,7 +43,7 @@ module GObject
       rclosure = wrap(closure.to_ptr)
 
       args = n_param_values.times.map {|idx|
-        Value.wrap(param_values.to_ptr + idx * Value::Struct.size).ruby_value
+        Value.wrap(param_values.to_ptr + idx * Value::Struct.size).get_value
       }
 
       result = rclosure.invoke_block(*args)

data/lib/ffi-gobject/value.rb

@@ -15,6 +15,7 @@ module GObject
     TYPE_TO_SET_METHOD_MAP = {
       TYPE_BOOLEAN => :set_boolean,
       TYPE_INT => :set_int,
+      TYPE_INT64 => :set_int64,
       TYPE_STRING => :set_string,
       TYPE_FLOAT => :set_float,
       TYPE_DOUBLE => :set_double,
@@ -25,6 +26,10 @@ module GObject
       TYPE_ENUM => :set_enum
     }
 
+    def value= val
+      set_value val
+    end
+
     def set_value val
       send set_method, val
       self
@@ -62,6 +67,7 @@ module GObject
     TYPE_TO_GET_METHOD_MAP = {
       TYPE_BOOLEAN => :get_boolean,
       TYPE_INT => :get_int,
+      TYPE_INT64 => :get_int64,
       TYPE_STRING => :get_string,
       TYPE_FLOAT => :get_float,
       TYPE_DOUBLE => :get_double,
@@ -70,11 +76,15 @@ module GObject
       TYPE_POINTER => :get_pointer
     }
 
-    # TODO: Rename to get_value
-    def ruby_value
+    def get_value
       send get_method
     end
 
+    # @deprecated Compatibility function. Remove in 0.7.0.
+    def ruby_value
+      get_value
+    end
+
     class << self
       # TODO: Give more generic name
       def wrap_ruby_value val
@@ -94,7 +104,7 @@ module GObject
 
       def for_g_type g_type
         return nil if g_type == TYPE_NONE
-        self.new.tap {|it| it.init g_type }
+        self.new.init g_type
       end
     end
 

data/lib/ffi-gobject.rb

@@ -109,8 +109,7 @@ module GObject
     attach_function :g_hash_table_get_type, [], :size_t
 
     attach_function :g_signal_connect_data,
-      [:pointer, :string, Callback, :pointer, ClosureNotify,
-        ConnectFlags],
+      [:pointer, :string, Callback, :pointer, ClosureNotify, ConnectFlags],
         :ulong
     attach_function :g_closure_set_marshal,
       [:pointer, ClosureMarshal], :void

data/lib/ffi-gobject_introspection/i_enum_info.rb

@@ -11,6 +11,20 @@ module GObjectIntrospection
     ##
     build_array_method :values
 
+    def get_n_methods
+      Lib.g_enum_info_get_n_methods @gobj
+    end
+    def get_method(index)
+      IFunctionInfo.wrap(Lib.g_enum_info_get_method @gobj, index)
+    end
+
+    ##
+    build_array_method :get_methods
+
+    def find_method name
+      get_methods.find {|m| m.name == name}
+    end
+
     def storage_type
       Lib.g_enum_info_get_storage_type @gobj
     end

data/lib/ffi-gobject_introspection/lib.rb

@@ -178,6 +178,8 @@ module GObjectIntrospection
     attach_function :g_enum_info_get_storage_type, [:pointer], :ITypeTag
     attach_function :g_enum_info_get_n_values, [:pointer], :int
     attach_function :g_enum_info_get_value, [:pointer, :int], :pointer
+    attach_function :g_enum_info_get_n_methods, [:pointer], :int
+    attach_function :g_enum_info_get_method, [:pointer, :int], :pointer
 
     # IObjectInfo
     attach_function :g_object_info_get_type_name, [:pointer], :string

data/lib/gir_ffi/arg_helper.rb

@@ -29,6 +29,8 @@ module GirFFI
       case type
       when Class
         ptr_to_interface_array type, ptr, size
+      when Module
+        ptr_to_enum_array type, ptr, size
       when Array
         ptr_to_interface_pointer_array type[1], ptr, size
       when FFI::Enum

data/lib/gir_ffi/argument_builder.rb

@@ -53,8 +53,6 @@ module GirFFI
         else
           "#{argument_class_name}.wrap(#{output_conversion_arguments})"
         end
-      elsif is_fixed_length_array?
-        "GLib::SizedArray.wrap(#{subtype_tag_or_class_name}, #{array_size}, #{callarg}.to_value)"
       else
         "#{callarg}.to_value"
       end
@@ -68,10 +66,6 @@ module GirFFI
       specialized_type_tag == :c && type_info.array_fixed_size > -1
     end
 
-    def is_fixed_length_array?
-      specialized_type_tag == :c
-    end
-
     def fixed_array_size_check
       size = type_info.array_fixed_size
       "GirFFI::ArgHelper.check_fixed_array_size #{size}, #{@name}, \"#{@name}\""
@@ -93,7 +87,11 @@ module GirFFI
     def set_function_call_argument
       value = if @direction == :out
                 if is_caller_allocated_object?
-                  "#{argument_class_name}._allocate"
+                  if specialized_type_tag == :array
+                    "#{argument_class_name}.new #{elm_t}"
+                  else
+                    "#{argument_class_name}.new"
+                  end
                 else
                   "GirFFI::InOutPointer.for #{specialized_type_tag.inspect}"
                 end
@@ -108,42 +106,45 @@ module GirFFI
     end
 
     def is_caller_allocated_object?
-      [:object, :struct].include?(specialized_type_tag) &&
+      [ :struct, :array ].include?(specialized_type_tag) &&
         @arginfo.caller_allocates?
     end
 
     def needs_outgoing_parameter_conversion?
-      [ :array, :enum, :flags, :ghash, :glist, :gslist, :object, :struct,
-        :strv, :utf8 ].include?(specialized_type_tag)
+      [ :array, :c, :enum, :error, :flags, :ghash, :glist, :gslist, :object,
+        :ptr_array, :struct, :strv, :utf8 ].include?(specialized_type_tag)
     end
 
     def needs_ingoing_parameter_conversion?
       @direction == :inout ||
-        [ :object, :struct, :callback, :utf8, :void, :glist, :gslist, :ghash,
-          :array, :c, :zero_terminated, :strv ].include?(specialized_type_tag)
+        [ :array, :c, :callback, :ghash, :glist, :gslist, :object, :ptr_array,
+          :struct, :strv, :utf8, :void, :zero_terminated ].include?(specialized_type_tag)
     end
 
     def ingoing_parameter_conversion
       case specialized_type_tag
       when :enum, :flags
         base = "#{argument_class_name}[#{parameter_conversion_arguments}]"
-        "GirFFI::InOutPointer.from #{specialized_type_tag.inspect}, #{base}"
-      when :object, :struct, :void, :glist, :gslist, :ghash, :array,
-        :zero_terminated, :strv, :callback, :utf8, :c
+      when :array, :c, :callback, :ghash, :glist, :gslist, :object, :ptr_array,
+        :struct, :strv, :utf8, :void, :zero_terminated
         base = "#{argument_class_name}.from(#{parameter_conversion_arguments})"
-        if has_output_value?
-          "GirFFI::InOutPointer.from :pointer, #{base}"
-        else
-          base
-        end
       else
         base = "#{parameter_conversion_arguments}"
+      end
+
+      if has_output_value?
         "GirFFI::InOutPointer.from #{specialized_type_tag.inspect}, #{base}"
+      else
+        base
       end
     end
 
     def output_conversion_arguments
-      conversion_arguments "#{callarg}.to_value"
+      if specialized_type_tag == :c
+        "#{subtype_tag_or_class_name}, #{array_size}, #{callarg}.to_value"
+      else
+        conversion_arguments "#{callarg}.to_value"
+      end
     end
 
     def parameter_conversion_arguments

data/lib/gir_ffi/base_argument_builder.rb

@@ -42,6 +42,7 @@ module GirFFI
       :byte_array => 'GLib::ByteArray',
       :c => 'GLib::SizedArray',
       :callback => 'GirFFI::Callback',
+      :error => 'GLib::Error',
       :ghash => 'GLib::HashTable',
       :glist => 'GLib::List',
       :gslist => 'GLib::SList',
@@ -118,7 +119,7 @@ module GirFFI
         "#{specialized_type_tag.inspect}, #{name}"
       when :c
         "#{subtype_tag_or_class_name}, #{type_info.array_fixed_size}, #{name}"
-      when :glist, :gslist, :ghash, :array, :zero_terminated
+      when :array, :ghash, :glist, :gslist, :ptr_array, :zero_terminated
         "#{elm_t}, #{name}"
       when :callback
         iface = type_info.interface

data/lib/gir_ffi/builder/module.rb

@@ -80,8 +80,8 @@ module GirFFI
     def setup_lib_for_ffi
       @lib = get_or_define_module @module, :Lib
 
-      unless (class << @lib; self.include? FFI::Library; end)
-        @lib.extend FFI::Library
+      unless (class << @lib; self.include? GirFFI::Library; end)
+        @lib.extend GirFFI::Library
         @lib.ffi_lib_flags :global, :lazy
         libspec = gir.shared_library(@namespace)
         unless libspec.nil?
@@ -123,6 +123,5 @@ module GirFFI
     def get_or_define_module parent, name
       optionally_define_constant(parent, name) { Module.new }
     end
-
   end
 end

data/lib/gir_ffi/builder/type/enum.rb

@@ -1,4 +1,6 @@
 require 'gir_ffi/builder/type/registered_type'
+require 'gir_ffi/builder/type/with_methods'
+require 'gir_ffi/enum_base'
 
 module GirFFI
   module Builder
@@ -8,6 +10,8 @@ module GirFFI
       # attached to the appropriate namespace module, and will be defined
       # as an enum for FFI.
       class Enum < RegisteredType
+        include WithMethods
+
         private
 
         def enum_sym
@@ -22,11 +26,15 @@ module GirFFI
         end
 
         def instantiate_class
-          @klass = optionally_define_constant namespace_module, @classname do
+          @klass = get_or_define_module namespace_module, @classname
+          @enum = optionally_define_constant @klass, :Enum do
             lib.enum(enum_sym, value_spec)
           end
           unless already_set_up
+            @klass.extend superclass
+            setup_constants
             setup_gtype_getter
+            stub_methods
             setup_inspect
           end
         end
@@ -42,6 +50,15 @@ module GirFFI
         def already_set_up
           @klass.respond_to? :get_gtype
         end
+
+        def superclass
+          @superclass ||= EnumBase
+        end
+
+        # FIXME: Remove duplication with Builder::Module
+        def get_or_define_module parent, name
+          optionally_define_constant(parent, name) { ::Module.new }
+        end
       end
     end
   end

data/lib/gir_ffi/builder/type/object.rb

@@ -51,7 +51,7 @@ module GirFFI
           setup_interfaces
         end
 
-        # FIXME: Private method only in subclass
+        # FIXME: Private method only used in subclass
         def layout_superclass
           FFI::Struct
         end
@@ -69,16 +69,14 @@ module GirFFI
         end
 
         def superclass
-          unless defined? @superclass
-            if parent
-              @superclass = Builder.build_class parent
-            else
-              @superclass = ObjectBase
-            end
-          end
-          @superclass
+          @superclass ||= if parent
+                            Builder.build_class parent
+                          else
+                            ObjectBase
+                          end
         end
 
+        # TODO: Unify with field accessor setup.
         def setup_property_accessors
           info.properties.each do |prop|
             setup_accessors_for_property_info prop
@@ -94,20 +92,24 @@ module GirFFI
         end
 
         # TODO: Guard agains accidental invocation of undefined vfuncs.
+        # TODO: Create object responsible for creating these invokers
         def setup_vfunc_invokers
           info.vfuncs.each do |vfinfo|
-            invoker = vfinfo.invoker
-            next if invoker.nil?
-            next if invoker.name == vfinfo.name
-
-            @klass.class_eval "
-              def #{vfinfo.name} *args, &block
-                #{invoker.name}(*args, &block)
-              end
-            "
+            if (invoker = vfinfo.invoker)
+              define_vfunc_invoker vfinfo.name, invoker.name
+            end
           end
         end
 
+        def define_vfunc_invoker vfunc_name, invoker_name
+          return if vfunc_name == invoker_name
+          @klass.class_eval "
+            def #{vfunc_name} *args, &block
+              #{invoker_name}(*args, &block)
+            end
+          "
+        end
+
         def setup_interfaces
           interfaces.each do |iface|
             @klass.class_eval do

data/lib/gir_ffi/class_base.rb

@@ -1,5 +1,4 @@
 require 'forwardable'
-require 'gir_ffi/ffi_ext/pointer'
 
 module GirFFI
   # Base class for all generated classes. Contains code for dealing with

data/lib/gir_ffi/enum_base.rb

@@ -0,0 +1,25 @@
+module GirFFI
+  module EnumBase
+    def [](arg)
+      self::Enum[arg]
+    end
+
+    def setup_and_call method, *arguments, &block
+      result = setup_method method.to_s
+
+      unless result
+        raise RuntimeError, "Unable to set up method #{method} in #{self}"
+      end
+
+      self.send method, *arguments, &block
+    end
+
+    def gir_ffi_builder
+      self.const_get :GIR_FFI_BUILDER
+    end
+
+    def setup_method name
+      gir_ffi_builder.setup_method name
+    end
+  end
+end

data/lib/gir_ffi/ffi_ext.rb

@@ -0,0 +1 @@
+require 'gir_ffi/ffi_ext/pointer'

data/lib/gir_ffi/function_builder.rb

@@ -15,81 +15,98 @@ module GirFFI
 
     def generate
       vargen = GirFFI::VariableNameGenerator.new
-      @data = @info.args.map {|arg| ArgumentBuilder.new vargen, arg }
-      @rvdata = ReturnValueBuilder.new(vargen, @info.return_type,
-                                       @info.constructor?)
+      @argument_builders = @info.args.map {|arg| ArgumentBuilder.new vargen, arg }
+      @return_value_builder = ReturnValueBuilder.new(vargen, @info.return_type,
+                                                     @info.constructor?)
 
-      alldata = @data.dup << @rvdata
+      link_array_length_arguments
+      setup_error_argument vargen
+      return filled_out_template
+    end
+
+    private
+
+    def link_array_length_arguments
+      alldata = @argument_builders.dup << @return_value_builder
 
       alldata.each {|data|
         idx = data.type_info.array_length
         if idx > -1
-          data.length_arg = @data[idx]
-          @data[idx].array_arg = data
+          other_data = @argument_builders[idx]
+          data.length_arg = other_data
+          other_data.array_arg = data
         end
       }
-
-      setup_error_argument vargen
-      return filled_out_template
     end
 
-    private
-
     def setup_error_argument vargen
       klass = @info.throws? ? ErrorArgumentBuilder : NullArgumentBuilder
       @errarg = klass.new vargen, nil, nil, :error
     end
 
     def filled_out_template
-      lines = pre
-      lines << "#{capture}#{@libmodule}.#{@info.symbol} #{callargs.join(', ')}"
-      lines << post
-
       meta = @info.method? ? '' : "self."
 
-      code = "def #{meta}#{@info.safe_name} #{inargs.join(', ')}\n"
-      code << lines.join("\n").indent
+      code = "def #{meta}#{@info.safe_name} #{method_arguments.join(', ')}\n"
+      code << method_body
       code << "\nend\n"
     end
 
-    def inargs
-      @data.map(&:inarg).compact
+    def method_body
+      lines = preparation << function_call << post_processing << cleanup
+      lines << "return #{return_values.join(', ')}" if has_return_values?
+      lines.flatten.join("\n").indent
     end
 
-    def callargs
-      ca = @data.map(&:callarg)
+    def function_call
+      "#{capture}#{@libmodule}.#{@info.symbol} #{function_call_arguments.join(', ')}"
+    end
+
+    def method_arguments
+      @argument_builders.map(&:inarg).compact
+    end
+
+    def function_call_arguments
+      ca = @argument_builders.map(&:callarg)
       ca << @errarg.callarg
       ca.unshift "self" if @info.method?
       ca.compact
     end
 
-    def pre
-      pr = @data.map(&:pre)
+    def preparation
+      pr = @argument_builders.map(&:pre)
       pr << @errarg.pre
       pr.flatten
     end
 
     def capture
-      if (cv = @rvdata.cvar)
+      if (cv = @return_value_builder.cvar)
         "#{cv} = "
       else
         ""
       end
     end
 
-    def post
-      args = @data.sort_by {|arg| arg.type_info.array_length}
+    def post_processing
+      # FIXME: Sorting knows too much about internals of ArgumentBuilder.
+      args = @argument_builders.sort_by {|arg| arg.type_info.array_length}
+      args << @return_value_builder
+      args.unshift @errarg
 
-      po = args.map {|arg|arg.post} +
-        @rvdata.post
-      po.unshift @errarg.post
+      args.map {|arg| arg.post}
+    end
 
-      po += @data.map {|item| item.cleanup}
+    def cleanup
+      @argument_builders.map {|item| item.cleanup}
+    end
 
-      retvals = ([@rvdata.retval] + @data.map(&:retval)).compact
-      po << "return #{retvals.join(', ')}" unless retvals.empty?
+    def return_values
+      @return_values ||= ([@return_value_builder.retval] +
+                          @argument_builders.map(&:retval)).compact
+    end
 
-      po.flatten
+    def has_return_values?
+      !return_values.empty?
     end
   end
 end