gir_ffi 0.6.7 → 0.7.0

data/lib/gir_ffi/builders/interface_builder.rb

@@ -8,22 +8,32 @@ module GirFFI
     class InterfaceBuilder < RegisteredTypeBuilder
       include WithMethods
 
+      def interface_struct
+        @interface_struct ||= Builder.build_class iface_struct_info
+      end
+
       private
 
       # FIXME: The word 'class' is not really correct.
       def instantiate_class
-        @klass = optionally_define_constant(namespace_module, @classname) do
-          ::Module.new
-        end
+        klass
         setup_module unless already_set_up
       end
 
+      def klass
+        @klass ||= get_or_define_module namespace_module, @classname
+      end
+
       def setup_module
-        @klass.extend InterfaceBase
+        klass.extend InterfaceBase
         setup_constants
         stub_methods
         setup_gtype_getter
       end
+
+      def iface_struct_info
+        @iface_struct_info ||= info.iface_struct
+      end
     end
   end
 end

data/lib/gir_ffi/builders/mapping_method_builder.rb

@@ -1,4 +1,5 @@
-require 'gir_ffi/builders/return_value_builder'
+require 'gir_ffi/builders/callback_argument_builder'
+require 'gir_ffi/builders/callback_return_value_builder'
 
 module GirFFI
   module Builders
@@ -6,33 +7,71 @@ module GirFFI
     # handler. This method converts arguments from C to Ruby, and the
     # result from Ruby to C.
     class MappingMethodBuilder
-      # TODO: Make CallbackArgumentBuilder accept argument name
-      # TODO: Fix name of #post method
-      class CallbackArgumentBuilder < ReturnValueBuilder
-        def post
-          if specialized_type_tag == :enum
-            ["#{retname} = #{argument_class_name}[#{callarg}]"]
-          else
-            super
+      def self.for_callback argument_infos, return_type_info
+        vargen = VariableNameGenerator.new
+        argument_builders = argument_infos.map {|arg|
+          CallbackArgumentBuilder.new vargen, arg }
+        set_up_argument_relations argument_infos, argument_builders
+        new return_type_info, vargen, argument_builders
+      end
+
+      def self.for_signal receiver_info, argument_infos, user_data_info, return_type_info
+        vargen = VariableNameGenerator.new
+
+        receiver_builder = CallbackArgumentBuilder.new vargen, receiver_info
+        argument_builders = argument_infos.map {|arg|
+          CallbackArgumentBuilder.new vargen, arg }
+        user_data_builder = CallbackArgumentBuilder.new vargen, user_data_info
+
+        set_up_argument_relations argument_infos, argument_builders
+        user_data_builder.is_closure = true
+
+        argument_builders.unshift receiver_builder
+        argument_builders.push user_data_builder
+
+        new return_type_info, vargen, argument_builders
+      end
+
+      def self.for_vfunc receiver_info, argument_infos, return_type_info
+        vargen = VariableNameGenerator.new
+
+        receiver_builder = CallbackArgumentBuilder.new vargen, receiver_info
+        argument_builders = argument_infos.map {|arg|
+          CallbackArgumentBuilder.new vargen, arg }
+
+        set_up_argument_relations argument_infos, argument_builders
+
+        argument_builders.unshift receiver_builder
+
+        new return_type_info, vargen, argument_builders
+      end
+
+      def self.set_up_argument_relations argument_infos, argument_builders
+        argument_infos.each do |arg|
+          if (idx = arg.closure) >= 0
+            argument_builders[idx].is_closure = true
           end
         end
+        argument_builders.each do |bldr|
+          if (idx = bldr.array_length_idx) >= 0
+            other = argument_builders[idx]
 
-        def retval
-          if specialized_type_tag == :enum
-            retname
-          else
-            super
+            bldr.length_arg = other
+            other.array_arg = bldr
           end
         end
       end
 
-      def initialize argument_infos, return_type_info
-        @argument_infos = argument_infos
+      def initialize return_type_info, vargen, argument_builders
+        @vargen = vargen
+        @argument_builders = argument_builders
+
         @return_type_info = return_type_info
       end
 
-      attr_reader :argument_infos
       attr_reader :return_type_info
+      attr_reader :vargen
+      attr_reader :argument_builders
 
       def method_definition
         code = "def self.call_with_argument_mapping(#{method_arguments.join(', ')})"
@@ -41,46 +80,59 @@ module GirFFI
       end
 
       def method_lines
-        lines = argument_builders.map(&:post).flatten +
-          ["#{capture}_proc.call(#{call_arguments.join(', ')})"] +
-          return_value_builder.post
-        lines << "return #{return_value_builder.retval}" if return_value_builder.is_relevant?
-        lines
+        parameter_preparation + call_to_proc + return_value_conversion + return_value
+      end
+
+      def return_value
+        if return_value_builder.is_relevant?
+          ["return #{return_value_builder.return_value_name}"]
+        else
+          []
+        end
+      end
+
+      def return_value_conversion
+        all_builders.map(&:post_conversion).flatten
+      end
+
+      def call_to_proc
+        ["#{capture}_proc.call(#{call_arguments.join(', ')})"]
+      end
+
+      def parameter_preparation
+        argument_builders.sort_by {|arg|
+          arg.type_info.array_length}.map(&:pre_conversion).flatten
       end
 
       def capture
-        @capture ||= return_value_builder.is_relevant? ?
-          "#{return_value_builder.callarg} = " :
+        @capture ||= capture_variable_names.any? ?
+          "#{capture_variable_names.join(", ")} = " :
           ""
       end
 
-      def call_arguments
-        @call_arguments ||= argument_builders.map(&:retval)
+      def capture_variable_names
+        @capture_variable_names ||=
+          all_builders.map(&:capture_variable_name).compact
       end
 
-      def method_arguments
-        @method_arguments ||= argument_builders.map(&:callarg).unshift('_proc')
+      def all_builders
+        @all_builders ||= [return_value_builder] + argument_builders
       end
 
-      def return_value_builder
-        @return_value_builder ||= ReturnValueBuilder.new(vargen, return_type_info)
+      def call_arguments
+        @call_arguments ||= argument_builders.map(&:call_argument_name).compact
       end
 
-      def argument_builders
-        unless defined?(@argument_builders)
-          @argument_builders = argument_infos.map {|arg|
-            CallbackArgumentBuilder.new vargen, arg.argument_type }
-          argument_infos.each do |arg|
-            if (idx = arg.closure) >= 0
-              @argument_builders[idx].is_closure = true
-            end
-          end
-        end
-        @argument_builders
+      def method_arguments
+        @method_arguments ||= argument_builders.map(&:method_argument_name).unshift('_proc')
+      end
+
+      def return_value_info
+        @return_value_info ||= ReturnValueInfo.new(return_type_info)
       end
 
-      def vargen
-        @vargen ||= GirFFI::VariableNameGenerator.new
+      def return_value_builder
+        @return_value_builder ||= CallbackReturnValueBuilder.new(vargen, return_value_info)
       end
     end
   end

data/lib/gir_ffi/builders/module_builder.rb

@@ -18,44 +18,40 @@ module GirFFI
       end
 
       def generate
-        build_module
+        modul
       end
 
       def setup_method method
         go = function_introspection_data method.to_s
+        return false unless go
 
-        return false if go.nil?
-
-        modul = build_module
-
-        Builder.attach_ffi_function libmodule, go
-        definition = function_definition go
-        modul.class_eval definition
+        Builder.attach_ffi_function lib, go
+        modul.class_eval FunctionBuilder.new(go).generate
 
         true
       end
 
       def build_namespaced_class classname
         info = gir.find_by_name @namespace, classname.to_s
-        if info.nil?
+        unless info
           raise NameError.new(
             "Class #{classname} not found in namespace #{@namespace}")
         end
         Builder.build_class info
       end
 
-      def build_module
+      private
+
+      def modul
         unless defined? @module
           build_dependencies
           instantiate_module
-          setup_lib_for_ffi
+          setup_lib_for_ffi unless lib_already_set_up
           setup_module unless already_set_up
         end
         @module
       end
 
-      private
-
       def build_dependencies
         deps = gir.dependencies @namespace
         deps.each {|dep|
@@ -78,40 +74,31 @@ module GirFFI
       end
 
       def setup_lib_for_ffi
-        @lib = get_or_define_module @module, :Lib
-
-        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?
-            @lib.ffi_lib(*libspec.split(/,/))
-          end
+        lib.extend FFI::Library
+        lib.ffi_lib_flags :global, :lazy
+        if shared_library_specification
+          lib.ffi_lib(*shared_library_specification.split(/,/))
         end
       end
 
-      def sub_builder info
-        if info.info_type == :function
-          FunctionBuilder.new info
-        else
-          TypeBuilder.builder_for info
-        end
+      def shared_library_specification
+        @shared_library_specification ||= gir.shared_library(@namespace)
+      end
+
+      def lib_already_set_up
+        (class << lib; self; end).include? FFI::Library
       end
 
-      def libmodule
-        @module.const_get(:Lib)
+      def lib
+        @lib ||= get_or_define_module modul, :Lib
       end
 
       def function_introspection_data function
         info = gir.find_by_name @namespace, function.to_s
-        return nil if info.nil?
+        return unless info
         info.info_type == :function ? info : nil
       end
 
-      def function_definition info
-        FunctionBuilder.new(info).generate
-      end
-
       def gir
         unless defined? @gir
           @gir = GObjectIntrospection::IRepository.default

data/lib/gir_ffi/builders/null_convertor.rb

@@ -0,0 +1,9 @@
+class GirFFI::Builders::NullConvertor
+  def initialize argument_name
+    @argument_name = argument_name
+  end
+
+  def conversion
+    @argument_name
+  end
+end

data/lib/gir_ffi/builders/object_builder.rb

@@ -26,6 +26,10 @@ module GirFFI
           raise "Property #{property_name} not found"
       end
 
+      def object_class_struct
+        @object_class_struct ||= Builder.build_class object_class_struct_info
+      end
+
       private
 
       def setup_class
@@ -67,19 +71,10 @@ module GirFFI
                         end
       end
 
-      # TODO: Unify with field accessor setup.
       def setup_property_accessors
         info.properties.each do |prop|
-          setup_accessors_for_property_info prop
-        end
-      end
-
-      def setup_accessors_for_property_info prop
-        builder = Builder::Property.new prop
-        unless info.find_instance_method prop.getter_name
-          @klass.class_eval builder.getter_def
+          PropertyBuilder.new(prop).build
         end
-        @klass.class_eval builder.setter_def
       end
 
       # TODO: Guard agains accidental invocation of undefined vfuncs.
@@ -94,7 +89,7 @@ module GirFFI
 
       def define_vfunc_invoker vfunc_name, invoker_name
         return if vfunc_name == invoker_name
-        @klass.class_eval "
+        klass.class_eval "
           def #{vfunc_name} *args, &block
             #{invoker_name}(*args, &block)
           end
@@ -103,9 +98,7 @@ module GirFFI
 
       def setup_interfaces
         interfaces.each do |iface|
-          @klass.class_eval do
-            include iface
-          end
+          klass.send :include, iface
         end
       end
 
@@ -118,6 +111,10 @@ module GirFFI
           GirFFI::Builder.build_class ifinfo
         end
       end
+
+      def object_class_struct_info
+        @object_class_struct_info ||= info.class_struct
+      end
     end
   end
 end

data/lib/gir_ffi/builders/property_builder.rb

@@ -1,26 +1,124 @@
 module GirFFI
-  module Builder
+  module Builders
     # Creates property getter and setter code for a given IPropertyInfo.
-    class Property
+    class PropertyBuilder
       def initialize property_info
         @info = property_info
       end
 
+      def build
+        setup_getter
+        setup_setter
+      end
+
+      def setup_getter
+        container_class.class_eval getter_def unless container_defines_getter_method?
+      end
+
+      def container_defines_getter_method?
+        container_info.find_instance_method @info.name
+      end
+
+      def setup_setter
+        container_class.class_eval setter_def
+      end
+
       def getter_def
-        return <<-CODE
-        def #{@info.getter_name}
-          get_property "#{@info.name}"
+        case type_info.tag
+        when :glist, :ghash
+          converting_getter_def
+        else
+          simple_getter_def
         end
-        CODE
       end
 
       def setter_def
-        return <<-CODE
-        def #{@info.getter_name}= value
-          set_property "#{@info.name}", value
+        case type_info.flattened_tag
+        when :glist, :ghash, :strv
+          converting_setter_def
+        else
+          simple_setter_def
+        end
+      end
+
+      private
+
+      def converting_getter_def
+        return <<-CODE.reset_indentation
+        def #{getter_name}
+          #{getter_builder.capture_variable_name} = get_property("#{property_name}").get_value_plain
+          #{getter_builder.post_conversion.join("\n")}
+          #{getter_builder.return_value_name}
+        end
+        CODE
+      end
+
+      def simple_getter_def
+        return <<-CODE.reset_indentation
+        def #{getter_name}
+          get_property("#{property_name}").get_value
+        end
+        CODE
+      end
+
+      def getter_builder
+        @getter_builder ||= ReturnValueBuilder.new(VariableNameGenerator.new,
+                                                   argument_info)
+      end
+
+      def converting_setter_def
+        return <<-CODE.reset_indentation
+        def #{setter_name} value
+          #{setter_builder.pre_conversion.join("\n")}
+          set_property("#{property_name}", #{setter_builder.callarg})
         end
         CODE
       end
+
+      def simple_setter_def
+        return <<-CODE.reset_indentation
+        def #{setter_name} value
+          set_property("#{property_name}", value)
+        end
+        CODE
+      end
+
+      def setter_builder
+        @setter_builder ||= ArgumentBuilder.new(VariableNameGenerator.new,
+                                                argument_info)
+      end
+
+      def property_name
+        @info.name
+      end
+
+      def getter_name
+        @info.getter_name
+      end
+
+      def setter_name
+        @info.setter_name
+      end
+
+      def type_info
+        @type_info ||= @info.property_type
+      end
+
+      def argument_info
+        @argument_info ||= FieldArgumentInfo.new("value", type_info)
+      end
+
+      def container_class
+        @container_class ||= container_module.const_get(container_info.safe_name)
+      end
+
+      def container_module
+        @container_module ||= Object.const_get(container_info.safe_namespace)
+      end
+
+      def container_info
+        @container_info ||= @info.container
+      end
     end
   end
 end