gir_ffi 0.7.5 → 0.7.6

data/lib/gir_ffi/builders/function_builder.rb

@@ -1,10 +1,10 @@
+require 'gir_ffi/variable_name_generator'
 require 'gir_ffi/builders/argument_builder'
 require 'gir_ffi/return_value_info'
 require 'gir_ffi/error_argument_info'
 require 'gir_ffi/builders/return_value_builder'
 require 'gir_ffi/builders/error_argument_builder'
-require 'gir_ffi/builders/null_argument_builder'
-require 'gir_ffi/variable_name_generator'
+require 'gir_ffi/builders/method_template'
 
 module GirFFI
   module Builders
@@ -13,116 +13,66 @@ module GirFFI
     class FunctionBuilder
       def initialize info
         @info = info
-      end
-
-      def generate
         vargen = GirFFI::VariableNameGenerator.new
-        @argument_builders = @info.args.map {|arg| ArgumentBuilder.new vargen, arg }
+        @argument_builders = @info.args.map { |arg| ArgumentBuilder.new vargen, arg }
+        return_value_info = ReturnValueInfo.new(@info.return_type, @info.skip_return?)
         @return_value_builder = ReturnValueBuilder.new(vargen,
-                                                       ReturnValueInfo.new(@info.return_type, @info.skip_return?),
+                                                       return_value_info,
                                                        @info.constructor?)
-
-        set_up_argument_relations
-        setup_error_argument vargen
-
-        filled_out_template
-      end
-
-      private
-
-      def lib_module_name
-        "#{@info.safe_namespace}::Lib"
-      end
-
-      def set_up_argument_relations
-        alldata = @argument_builders.dup << @return_value_builder
-
-        alldata.each do |data|
-          if (idx = data.array_length_idx) >= 0
-            other_data = @argument_builders[idx]
-            data.length_arg = other_data
-            other_data.array_arg = data
-          end
-        end
-
-        @argument_builders.each do |data|
-          if (idx = data.arginfo.closure) >= 0
-            @argument_builders[idx].is_closure = true
-          end
-        end
+        @argument_builder_collection = ArgumentBuilderCollection.new(
+          @return_value_builder, @argument_builders,
+          error_argument_builder: error_argument(vargen))
+        @template = MethodTemplate.new(self, @argument_builder_collection)
       end
 
-      def setup_error_argument vargen
-        @errarg = if @info.throws?
-                    ErrorArgumentBuilder.new vargen, ErrorArgumentInfo.new
-                  else
-                    NullArgumentBuilder.new
-                  end
-      end
-
-      def filled_out_template
-        meta = @info.method? ? '' : "self."
-
-        code = "def #{meta}#{@info.safe_name} #{method_arguments.join(', ')}\n"
-        code << method_body
-        code << "\nend\n"
-      end
-
-      def method_body
-        lines = preparation << function_call << post_processing
-        lines << "return #{return_values.join(', ')}" if has_return_values?
-        lines.flatten.join("\n").indent
+      def generate
+        @template.method_definition
       end
 
-      def function_call
-        "#{capture}#{lib_module_name}.#{@info.symbol} #{function_call_arguments.join(', ')}"
+      def method_name
+        @info.safe_name
       end
 
       def method_arguments
-        @argument_builders.map(&:method_argument_name).compact
+        @argument_builder_collection.method_argument_names
       end
 
-      def function_call_arguments
-        ca = @argument_builders.map(&:callarg)
-        ca << @errarg.callarg
-        ca.unshift "self" if @info.method?
-        ca.compact
+      def preparation
+        []
       end
 
-      def preparation
-        pr = @argument_builders.map(&:pre_conversion)
-        pr << @errarg.pre
-        pr.flatten
+      def invocation
+        "#{lib_name}.#{@info.symbol} #{function_call_arguments.join(', ')}"
       end
 
-      def capture
-        if has_capture?
-          "#{@return_value_builder.capture_variable_name} = "
+      def result
+        if @argument_builder_collection.has_return_values?
+          ["return #{@argument_builder_collection.return_value_names.join(', ')}"]
         else
-          ""
+          []
         end
       end
 
-      def post_processing
-        # FIXME: Sorting knows too much about internals of ArgumentBuilder.
-        args = @argument_builders.sort_by {|arg| arg.type_info.array_length}
-
-        result = args.map {|arg| arg.post_conversion}
-        result.unshift @errarg.post
-        result << @return_value_builder.post_conversion
+      def singleton_method?
+        !@info.method?
       end
 
-      def return_values
-        @return_values ||= ([@return_value_builder.return_value_name] +
-                            @argument_builders.map(&:return_value_name)).compact
+      private
+
+      def lib_name
+        "#{@info.safe_namespace}::Lib"
       end
 
-      def has_return_values?
-        !return_values.empty?
+      def error_argument vargen
+        if @info.throws?
+          ErrorArgumentBuilder.new vargen, ErrorArgumentInfo.new if @info.throws?
+        end
       end
 
-      def has_capture?
-        @return_value_builder.is_relevant?
+      def function_call_arguments
+        ca = @argument_builder_collection.call_argument_names
+        ca.unshift "self" if @info.method?
+        ca
       end
     end
   end

data/lib/gir_ffi/builders/interface_builder.rb

@@ -11,17 +11,12 @@ module GirFFI
 
       private
 
-      # FIXME: The word 'class' is not really correct.
-      def instantiate_class
-        klass
-        setup_module unless already_set_up
-      end
-
       def klass
         @klass ||= get_or_define_module namespace_module, @classname
       end
 
-      def setup_module
+      # FIXME: The word 'class' is not really correct.
+      def setup_class
         klass.extend InterfaceBase
         setup_constants
         stub_methods

data/lib/gir_ffi/builders/mapping_method_builder.rb

@@ -1,6 +1,8 @@
+require 'gir_ffi/variable_name_generator'
 require 'gir_ffi/builders/callback_argument_builder'
 require 'gir_ffi/builders/callback_return_value_builder'
 require 'gir_ffi/builders/argument_builder_collection'
+require 'gir_ffi/builders/method_template'
 
 module GirFFI
   module Builders
@@ -9,43 +11,47 @@ module GirFFI
     # result from Ruby to C.
     class MappingMethodBuilder
       def self.for_callback argument_infos, return_value_info
-        vargen = VariableNameGenerator.new
-
-        argument_builders = argument_infos.map {|arg| CallbackArgumentBuilder.new vargen, arg }
-        return_value_builder = CallbackReturnValueBuilder.new(vargen, return_value_info)
-
-        new ArgumentBuilderCollection.new(return_value_builder, argument_builders)
+        new argument_infos, return_value_info
       end
 
       def self.for_vfunc receiver_info, argument_infos, return_value_info
-        vargen = VariableNameGenerator.new
+        new receiver_info, argument_infos, return_value_info
+      end
 
-        receiver_builder = CallbackArgumentBuilder.new vargen, receiver_info
-        argument_builders = argument_infos.map {|arg| CallbackArgumentBuilder.new vargen, arg }
-        return_value_builder = CallbackReturnValueBuilder.new(vargen, return_value_info)
+      def initialize receiver_info = nil, argument_infos, return_value_info
+        receiver_builder = make_argument_builder receiver_info if receiver_info
+        argument_builders = argument_infos.map { |info| make_argument_builder info }
+        return_value_builder =
+          CallbackReturnValueBuilder.new(variable_generator, return_value_info)
 
-        new ArgumentBuilderCollection.new(return_value_builder, argument_builders,
-                                          receiver_builder: receiver_builder)
+        @argument_builder_collection =
+          ArgumentBuilderCollection.new(return_value_builder, argument_builders,
+                                        receiver_builder: receiver_builder)
+        @template = MethodTemplate.new(self, @argument_builder_collection)
       end
 
-      def initialize argument_builder_collection
-        @argument_builder_collection = argument_builder_collection
+      def method_definition
+        @template.method_definition
       end
 
-      def method_definition
-        code = "def self.call_with_argument_mapping(#{method_arguments.join(', ')})"
-        method_lines.each { |line| code << "\n  #{line}" }
-        code << "\nend\n"
+      def method_name
+        "call_with_argument_mapping"
+      end
+
+      def method_arguments
+        @method_arguments ||=
+          @argument_builder_collection.method_argument_names.dup.unshift('_proc')
+      end
+
+      def preparation
+        []
       end
 
-      def method_lines
-        @argument_builder_collection.parameter_preparation +
-          call_to_proc +
-          @argument_builder_collection.return_value_conversion +
-          return_value
+      def invocation
+        "_proc.call(#{call_argument_list})"
       end
 
-      def return_value
+      def result
         if (name = @argument_builder_collection.return_value_name)
           ["return #{name}"]
         else
@@ -53,19 +59,22 @@ module GirFFI
         end
       end
 
-      def call_to_proc
-        ["#{capture}_proc.call(#{@argument_builder_collection.call_argument_names.join(', ')})"]
+      def singleton_method?
+        true
       end
 
-      def capture
-        @capture ||= begin
-                       names = @argument_builder_collection.capture_variable_names
-                       names.any? ? "#{names.join(", ")} = " : ""
-                     end
+      private
+
+      def call_argument_list
+        @argument_builder_collection.call_argument_names.join(', ')
       end
 
-      def method_arguments
-        @method_arguments ||= @argument_builder_collection.method_argument_names.dup.unshift('_proc')
+      def variable_generator
+        @variable_generator ||= VariableNameGenerator.new
+      end
+
+      def make_argument_builder argument_info
+        CallbackArgumentBuilder.new variable_generator, argument_info
       end
     end
   end

data/lib/gir_ffi/builders/marshalling_method_builder.rb

@@ -1,6 +1,8 @@
+require 'gir_ffi/variable_name_generator'
 require 'gir_ffi/builders/closure_argument_builder'
 require 'gir_ffi/builders/callback_return_value_builder'
 require 'gir_ffi/builders/argument_builder_collection'
+require 'gir_ffi/builders/method_template'
 
 module GirFFI
   module Builders
@@ -9,35 +11,46 @@ module GirFFI
     # result from Ruby to C.
     class MarshallingMethodBuilder
       def self.for_signal receiver_info, argument_infos, return_value_info
-        vargen = VariableNameGenerator.new
+        new receiver_info, argument_infos, return_value_info
+      end
 
-        receiver_builder = ClosureArgumentBuilder.new vargen, receiver_info
-        argument_builders = argument_infos.map {|arg| ClosureArgumentBuilder.new vargen, arg }
-        return_value_builder = CallbackReturnValueBuilder.new(vargen, return_value_info)
+      def initialize receiver_info, argument_infos, return_value_info
+        receiver_builder = make_argument_builder receiver_info
+        argument_builders = argument_infos.map { |arg| make_argument_builder arg }
+        return_value_builder =
+          CallbackReturnValueBuilder.new(variable_generator, return_value_info)
 
-        new ArgumentBuilderCollection.new(return_value_builder, argument_builders,
-                                          receiver_builder: receiver_builder)
+        @argument_builder_collection =
+          ArgumentBuilderCollection.new(return_value_builder, argument_builders,
+                                        receiver_builder: receiver_builder)
+        @template = MethodTemplate.new(self, @argument_builder_collection)
       end
 
-      def initialize argument_builder_collection
-        @argument_builder_collection = argument_builder_collection
+      def method_definition
+        @template.method_definition
       end
 
-      def method_definition
-        code = "def self.marshaller(#{marshaller_arguments.join(', ')})"
-        method_lines.each { |line| code << "\n  #{line}" }
-        code << "\nend\n"
+      def method_name
+        "marshaller"
+      end
+
+      def method_arguments
+        %w(closure return_value param_values _invocation_hint _marshal_data)
       end
 
-      def method_lines
-        param_values_unpack +
-          @argument_builder_collection.parameter_preparation +
-          call_to_closure +
-          @argument_builder_collection.return_value_conversion +
-          return_value
+      def preparation
+        if param_names.size == 1
+          ["#{param_names.first} = param_values.first.get_value_plain"]
+        else
+          ["#{param_names.join(", ")} = param_values.map(&:get_value_plain)"]
+        end
+      end
+
+      def invocation
+        "wrap(closure.to_ptr).invoke_block(#{call_argument_list})"
       end
 
-      def return_value
+      def result
         if (name = @argument_builder_collection.return_value_name)
           ["return_value.set_value #{name}"]
         else
@@ -45,28 +58,26 @@ module GirFFI
         end
       end
 
-      def call_to_closure
-        ["#{capture}wrap(closure.to_ptr).invoke_block(#{@argument_builder_collection.call_argument_names.join(', ')})"]
+      def singleton_method?
+        true
       end
 
-      def param_values_unpack
-        ["#{method_arguments.join(", ")} = param_values.map(&:get_value_plain)" ]
+      private
+
+      def call_argument_list
+        @argument_builder_collection.call_argument_names.join(', ')
       end
 
-      def capture
-        @capture ||= begin
-                       names = @argument_builder_collection.capture_variable_names
-                       names.any? ? "#{names.join(", ")} = " : ""
-                     end
+      def param_names
+        @param_names ||= @argument_builder_collection.method_argument_names
       end
 
-      def method_arguments
-        # FIXME: Don't add _ if method_argument_names has more than one element
-        @method_arguments ||= @argument_builder_collection.method_argument_names.dup.push('_')
+      def variable_generator
+        @variable_generator ||= VariableNameGenerator.new
       end
 
-      def marshaller_arguments
-        %w(closure return_value param_values _invocation_hint _marshal_data)
+      def make_argument_builder argument_info
+        ClosureArgumentBuilder.new variable_generator, argument_info
       end
     end
   end

data/lib/gir_ffi/builders/method_template.rb

@@ -0,0 +1,81 @@
+module GirFFI
+  module Builders
+    # Encapsulates the general structure of generated methods, consisting of a
+    # preparation phase where arguments are converted to the form needed by the
+    # main call of the method, the main call itself, a post-processing phase
+    # where the return values and any 'out' arguments of the main call are
+    # converted into a form suitable for returning, and finally the returning
+    # of said values to the caller.
+    #
+    # The different method builders collaborate with MethodTemplate to build
+    # the desired method.
+    class MethodTemplate
+      def initialize builder, argument_builder_collection
+        @builder = builder
+        @argument_builder_collection = argument_builder_collection
+      end
+
+      def method_definition
+        code = "def #{qualified_method_name}"
+        code << "(#{method_arguments.join(', ')})" if method_arguments.any?
+        method_lines.each { |line| code << "\n  #{line}" }
+        code << "\nend\n"
+      end
+
+      private
+
+      def qualified_method_name
+        "#{@builder.singleton_method? ? 'self.' : ''}#{@builder.method_name}"
+      end
+
+      def method_arguments
+        @builder.method_arguments
+      end
+
+      def method_lines
+        method_preparation +
+          parameter_preparation +
+          invocation +
+          return_value_conversion +
+          result
+      end
+
+      def method_preparation
+        @builder.preparation
+      end
+
+      def parameter_preparation
+        @argument_builder_collection.parameter_preparation
+      end
+
+      def invocation
+        if result_name_list.empty?
+          plain_invocation
+        else
+          capturing_invocation
+        end
+      end
+
+      def return_value_conversion
+        @argument_builder_collection.return_value_conversion
+      end
+
+      def result
+        @builder.result
+      end
+
+      def result_name_list
+        @result_name_list ||=
+          @argument_builder_collection.capture_variable_names.join(", ")
+      end
+
+      def capturing_invocation
+        ["#{result_name_list} = #{@builder.invocation}"]
+      end
+
+      def plain_invocation
+        [@builder.invocation]
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/module_builder.rb

@@ -10,11 +10,11 @@ module GirFFI
     class ModuleBuilder
       include BuilderHelper
 
-      def initialize namespace, version=nil
+      def initialize namespace, version = nil
         @namespace = namespace
         @version = version
         # FIXME: Pass safe namespace as an argument
-        @safe_namespace = @namespace.gsub(/^(.)/) { $1.upcase }
+        @safe_namespace = @namespace.gsub(/^./, &:upcase)
       end
 
       def generate
@@ -34,8 +34,8 @@ module GirFFI
       def build_namespaced_class classname
         info = gir.find_by_name @namespace, classname.to_s
         unless info
-          raise NameError.new(
-            "Class #{classname} not found in namespace #{@namespace}")
+          raise NameError,
+            "Class #{classname} not found in namespace #{@namespace}"
         end
         Builder.build_class info
       end
@@ -70,7 +70,7 @@ module GirFFI
       end
 
       def already_set_up
-        @module.respond_to? :method_missing
+        @module.const_defined? :GIR_FFI_BUILDER
       end
 
       def setup_lib_for_ffi

data/lib/gir_ffi/builders/object_builder.rb

@@ -9,18 +9,24 @@ module GirFFI
     class ObjectBuilder < RegisteredTypeBuilder
       include WithLayout
 
-      def find_signal signal_name
-        signal_definers.each do |inf|
-          sig = inf.find_signal signal_name
-          return sig if sig
+      # Dummy builder for the ObjectBase class
+      class ObjectBaseBuilder
+        def build_class
+          ObjectBase
+        end
+
+        def ancestor_infos
+          []
         end
-        superclass.find_signal signal_name or
+      end
+
+      def find_signal signal_name
+        seek_in_ancestor_infos { |info| info.find_signal signal_name } or
           raise "Signal #{signal_name} not found"
       end
 
       def find_property property_name
-        info.find_property property_name or
-          superclass.find_property property_name or
+        seek_in_ancestor_infos { |info| info.find_property property_name } or
           raise "Property #{property_name} not found"
       end
 
@@ -28,6 +34,10 @@ module GirFFI
         @object_class_struct ||= Builder.build_class object_class_struct_info
       end
 
+      def ancestor_infos
+        @ancestor_infos ||= [info] + info.interfaces + parent_ancestor_infos
+      end
+
       private
 
       def setup_class
@@ -48,24 +58,29 @@ module GirFFI
         FFI::Struct
       end
 
-      def parent
-        unless defined? @parent
-          pr = info.parent
-          if pr.nil? or (pr.safe_name == @classname and pr.namespace == @namespace)
-            @parent = nil
-          else
-            @parent = pr
-          end
+      def parent_info
+        unless defined? @parent_info
+          @parent_info = if (parent = info.parent) && parent != info
+                           parent
+                         end
         end
-        @parent
+        @parent_info
       end
 
       def superclass
-        @superclass ||= if parent
-                          Builder.build_class parent
-                        else
-                          ObjectBase
-                        end
+        @superclass ||= parent_builder.build_class
+      end
+
+      def parent_builder
+        @parent_builder ||= if parent_info
+                              Builders::TypeBuilder.builder_for(parent_info)
+                            else
+                              ObjectBaseBuilder.new
+                            end
+      end
+
+      def parent_ancestor_infos
+        @parent_ancestor_infos ||= parent_builder.ancestor_infos
       end
 
       def setup_property_accessors
@@ -99,10 +114,6 @@ module GirFFI
         end
       end
 
-      def signal_definers
-        [info] + info.interfaces
-      end
-
       def interfaces
         info.interfaces.map do |ifinfo|
           GirFFI::Builder.build_class ifinfo
@@ -112,6 +123,14 @@ module GirFFI
       def object_class_struct_info
         @object_class_struct_info ||= info.class_struct
       end
+
+      def seek_in_ancestor_infos
+        ancestor_infos.each do |info|
+          item = yield info
+          return item if item
+        end
+        nil
+      end
     end
   end
 end

data/lib/gir_ffi/builders/property_builder.rb

@@ -23,6 +23,7 @@ module GirFFI
         container_class.class_eval setter_def
       end
 
+      # TODO: Fix argument builders so converting_getter_def can always be used.
       def getter_def
         case type_info.tag
         when :glist, :ghash
@@ -32,6 +33,7 @@ module GirFFI
         end
       end
 
+      # TODO: Fix argument builders so converting_setter_def can always be used.
       def setter_def
         case type_info.flattened_tag
         when :glist, :ghash, :strv
@@ -43,10 +45,12 @@ module GirFFI
 
       private
 
+      # TODO: Use a builder like MarshallingMethodBuilder
       def converting_getter_def
+        capture = getter_builder.capture_variable_name
         <<-CODE.reset_indentation
         def #{getter_name}
-          #{getter_builder.capture_variable_name} = get_property("#{property_name}").get_value_plain
+          #{capture} = get_property("#{property_name}").get_value_plain
           #{getter_builder.post_conversion.join("\n")}
           #{getter_builder.return_value_name}
         end
@@ -70,7 +74,7 @@ module GirFFI
         <<-CODE.reset_indentation
         def #{setter_name} value
           #{setter_builder.pre_conversion.join("\n")}
-          set_property("#{property_name}", #{setter_builder.callarg})
+          set_property("#{property_name}", #{setter_builder.call_argument_name})
         end
         CODE
       end