gir_ffi 0.7.5 → 0.7.6

data/lib/gir_ffi/builders/argument_builder.rb

@@ -9,37 +9,39 @@ module GirFFI
     # Implements building pre- and post-processing statements for arguments.
     class ArgumentBuilder < BaseArgumentBuilder
       def method_argument_name
-        if has_input_value? && !is_array_length_parameter?
-          name
-        end
+        name if has_input_value? && !array_length_parameter?
       end
 
       def post_converted_name
         @post_converted_name ||= if has_post_conversion?
                                    new_variable
                                  else
-                                   callarg
+                                   call_argument_name
                                  end
       end
 
       def return_value_name
         if has_output_value?
-          post_converted_name unless is_array_length_parameter?
+          post_converted_name unless array_length_parameter?
         end
       end
 
+      def capture_variable_name
+        nil
+      end
+
       def pre_conversion
         pr = []
         case direction
         when :in
           pr << fixed_array_size_check if needs_size_check?
-          pr << array_length_assignment if is_array_length_parameter?
-          pr << "#{callarg} = #{ingoing_convertor.conversion}"
+          pr << array_length_assignment if array_length_parameter?
+          pr << "#{call_argument_name} = #{ingoing_convertor.conversion}"
         when :inout
           pr << fixed_array_size_check if needs_size_check?
-          pr << array_length_assignment if is_array_length_parameter?
+          pr << array_length_assignment if array_length_parameter?
           pr << out_parameter_preparation
-          pr << "#{callarg}.set_value #{ingoing_convertor.conversion}"
+          pr << "#{call_argument_name}.set_value #{ingoing_convertor.conversion}"
         when :out
           pr << out_parameter_preparation
         end
@@ -58,11 +60,11 @@ module GirFFI
       private
 
       def has_post_conversion?
-        has_output_value? && !is_caller_allocated_object?
+        has_output_value? && !caller_allocated_object?
       end
 
       def output_value
-        base = "#{callarg}.to_value"
+        base = "#{call_argument_name}.to_value"
         if needs_out_conversion?
           CToRubyConvertor.new(@type_info, base, length_argument_name).conversion
         elsif allocated_by_them?
@@ -88,7 +90,7 @@ module GirFFI
         length_arg && length_arg.post_converted_name
       end
 
-      def is_array_length_parameter?
+      def array_length_parameter?
         @array_arg
       end
 
@@ -120,7 +122,7 @@ module GirFFI
       end
 
       def out_parameter_preparation
-        value = if is_caller_allocated_object?
+        value = if caller_allocated_object?
                   if specialized_type_tag == :array
                     "#{argument_class_name}.new #{type_info.element_type.inspect}"
                   else
@@ -129,18 +131,18 @@ module GirFFI
                 else
                   "GirFFI::InOutPointer.for #{type_info.tag_or_class.inspect}"
                 end
-        "#{callarg} = #{value}"
+        "#{call_argument_name} = #{value}"
       end
 
-      def is_caller_allocated_object?
-        [ :struct, :array ].include?(specialized_type_tag) &&
+      def caller_allocated_object?
+        [:struct, :array].include?(specialized_type_tag) &&
           @arginfo.caller_allocates?
       end
 
       def ingoing_convertor
         if skipped?
           NullConvertor.new("0")
-        elsif is_closure
+        elsif closure?
           ClosureToPointerConvertor.new(name)
         elsif @type_info.needs_ruby_to_c_conversion_for_functions?
           RubyToCConvertor.new(@type_info, name)

data/lib/gir_ffi/builders/argument_builder_collection.rb

@@ -5,23 +5,21 @@ module GirFFI
     # and parameter and variable names for use by function builders.
     class ArgumentBuilderCollection
       attr_reader :return_value_builder
-      attr_reader :argument_builders
 
       def initialize return_value_builder, argument_builders, options = {}
         @receiver_builder = options[:receiver_builder]
-        @argument_builders = argument_builders
+        @error_argument_builder = options[:error_argument_builder]
+        @base_argument_builders = argument_builders
         @return_value_builder = return_value_builder
-        self.class.set_up_argument_relations argument_builders
-        @argument_builders.unshift @receiver_builder if @receiver_builder
+        set_up_argument_relations
       end
 
       def parameter_preparation
-        argument_builders.sort_by.with_index {|arg, i|
-          [arg.type_info.array_length, i] }.map(&:pre_conversion).flatten
+        builders_for_pre_conversion.map(&:pre_conversion).flatten
       end
 
       def return_value_conversion
-        all_builders.map(&:post_conversion).flatten
+        builders_for_post_conversion.map(&:post_conversion).flatten
       end
 
       def capture_variable_names
@@ -34,22 +32,39 @@ module GirFFI
       end
 
       def method_argument_names
-        @method_argument_names ||= argument_builders.map(&:method_argument_name)
+        @method_argument_names ||= argument_builders.map(&:method_argument_name).compact
       end
 
       def return_value_name
-        return_value_builder.return_value_name if return_value_builder.is_relevant?
+        return_value_builder.return_value_name if return_value_builder.relevant?
       end
 
-      def self.set_up_argument_relations argument_builders
-        argument_builders.each do |arg|
+      def return_value_names
+        @return_value_names ||= all_builders.map(&:return_value_name).compact
+      end
+
+      def has_return_values?
+        return_value_names.any?
+      end
+
+      private
+
+      def argument_builders
+        @argument_builders ||= @base_argument_builders.dup.tap do |builders|
+          builders.unshift @receiver_builder if @receiver_builder
+          builders.push @error_argument_builder if @error_argument_builder
+        end
+      end
+
+      def set_up_argument_relations
+        @base_argument_builders.each do |arg|
           if (idx = arg.arginfo.closure) >= 0
-            argument_builders[idx].is_closure = true
+            @base_argument_builders[idx].closure = true
           end
         end
-        argument_builders.each do |bldr|
+        all_builders.each do |bldr|
           if (idx = bldr.array_length_idx) >= 0
-            other = argument_builders[idx]
+            other = @base_argument_builders[idx]
 
             bldr.length_arg = other
             other.array_arg = bldr
@@ -57,11 +72,31 @@ module GirFFI
         end
       end
 
-      private
-
       def all_builders
         @all_builders ||= [return_value_builder] + argument_builders
       end
+
+      def builders_for_pre_conversion
+        @builders_for_pre_conversion ||=
+          sorted_base_argument_builders.dup.tap do |builders|
+            builders.unshift @receiver_builder if @receiver_builder
+            builders.push @error_argument_builder if @error_argument_builder
+          end
+      end
+
+      def builders_for_post_conversion
+        @builders_for_post_conversion ||=
+          sorted_base_argument_builders.dup.tap do |builders|
+            builders.unshift @receiver_builder if @receiver_builder
+            builders.unshift @error_argument_builder if @error_argument_builder
+            builders.push return_value_builder
+          end
+      end
+
+      def sorted_base_argument_builders
+        @sorted_base_argument_builders ||= @base_argument_builders.
+          sort_by.with_index { |arg, i| [arg.array_length_idx, i] }
+      end
     end
   end
 end

data/lib/gir_ffi/builders/base_argument_builder.rb

@@ -4,17 +4,27 @@ module GirFFI
     # classes are used by FunctionBuilder to create the code that
     # processes each argument before and after the actual function call.
     class BaseArgumentBuilder
-      KEYWORDS = [
-        "alias", "and", "begin", "break", "case", "class", "def", "do",
-        "else", "elsif", "end", "ensure", "false", "for", "if", "in",
-        "module", "next", "nil", "not", "or", "redo", "rescue", "retry",
-        "return", "self", "super", "then", "true", "undef", "unless",
-        "until", "when", "while", "yield"
-      ]
+      KEYWORDS = %w(
+        alias and begin break case class def do
+        else elsif end ensure false for if in
+        module next nil not or redo rescue retry
+        return self super then true undef unless
+        until when while yield
+      )
 
       attr_reader :arginfo
       attr_accessor :length_arg, :array_arg
-      attr_accessor :is_closure
+
+      # TODO: closure unfortunately means two things in GLib: a closure
+      # argument (user_data), and the Closure class (a callable object). Make
+      # the distinction more explicit in GirFFI.
+      def closure?
+        @is_closure
+      end
+
+      def closure= arg
+        @is_closure = arg
+      end
 
       def initialize var_gen, arginfo
         @var_gen = var_gen
@@ -58,8 +68,8 @@ module GirFFI
         end
       end
 
-      def callarg
-        @callarg ||= new_variable
+      def call_argument_name
+        @call_argument_name ||= new_variable
       end
 
       def new_variable

data/lib/gir_ffi/builders/base_type_builder.rb

@@ -1,7 +1,6 @@
 require 'gir_ffi/builder_helper'
 
 module GirFFI
-
   # Base class for type builders.
   class BaseTypeBuilder
     include BuilderHelper
@@ -13,12 +12,14 @@ module GirFFI
     end
 
     def build_class
-      unless defined? @klass
-        instantiate_class
-      end
+      instantiate_class unless defined? @klass
       @klass
     end
 
+    def instantiate_class
+      setup_class unless already_set_up
+    end
+
     attr_reader :info
 
     private
@@ -28,7 +29,7 @@ module GirFFI
     end
 
     def lib
-      @lib ||= namespace_module.const_get :Lib
+      @lib ||= namespace_module::Lib
     end
 
     def setup_constants

data/lib/gir_ffi/builders/callback_argument_builder.rb

@@ -29,9 +29,9 @@ module GirFFI
       def pre_conversion
         case direction
         when :in
-          [ "#{pre_converted_name} = #{pre_convertor.conversion}" ]
+          ["#{pre_converted_name} = #{pre_convertor.conversion}"]
         when :out
-          [ "#{pre_converted_name} = #{out_parameter_preparation}" ]
+          ["#{pre_converted_name} = #{out_parameter_preparation}"]
         when :error
           [
             "#{pre_converted_name} = #{out_parameter_preparation}",
@@ -43,7 +43,7 @@ module GirFFI
       def post_conversion
         case direction
         when :out
-          [ outgoing_post_conversion ]
+          [outgoing_post_conversion]
         when :error
           [
             "rescue => #{result_name}",
@@ -62,7 +62,7 @@ module GirFFI
       end
 
       def pre_convertor
-        @pre_convertor ||= if is_closure
+        @pre_convertor ||= if closure?
                              ClosureConvertor.new(method_argument_name)
                            elsif needs_c_to_ruby_conversion?
                              CToRubyConvertor.new(type_info,
@@ -92,7 +92,7 @@ module GirFFI
       def out_parameter_preparation
         type_spec = type_info.tag_or_class
         if allocated_by_us?
-          "GirFFI::InOutPointer.new(#{type_spec[1].inspect})" +
+          "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})"

data/lib/gir_ffi/builders/callback_builder.rb

@@ -8,10 +8,6 @@ module GirFFI
     # attached to the appropriate namespace module, and will be defined
     # as a callback for FFI.
     class CallbackBuilder < BaseTypeBuilder
-      def instantiate_class
-        setup_class unless already_set_up
-      end
-
       def setup_class
         setup_callback
         setup_constants

data/lib/gir_ffi/builders/callback_return_value_builder.rb

@@ -6,14 +6,12 @@ module GirFFI
     # Implements building post-processing statements for return values of
     # callbacks.
     class CallbackReturnValueBuilder < BaseArgumentBuilder
-      def is_relevant?
-        !is_void_return_value? && !arginfo.skip?
+      def relevant?
+        !void_return_value? && !arginfo.skip?
       end
 
       def capture_variable_name
-        if is_relevant?
-          @capture_variable_name ||= new_variable
-        end
+        @capture_variable_name ||= new_variable if relevant?
       end
 
       def post_converted_name
@@ -25,17 +23,15 @@ module GirFFI
       end
 
       def return_value_name
-        if is_relevant?
-          post_converted_name unless array_arg
-        end
+        post_converted_name if has_return_value_name?
       end
 
       def post_conversion
         if has_post_conversion?
           if type_info.flattened_tag == :object
-            [ "#{post_converted_name} = #{post_convertor.conversion}.to_ptr" ]
+            ["#{post_converted_name} = #{post_convertor.conversion}.to_ptr"]
           else
-            [ "#{post_converted_name} = #{post_convertor.conversion}" ]
+            ["#{post_converted_name} = #{post_convertor.conversion}"]
           end
         else
           []
@@ -52,9 +48,13 @@ module GirFFI
         @post_convertor ||= RubyToCConvertor.new(type_info, capture_variable_name)
       end
 
-      def is_void_return_value?
+      def void_return_value?
         specialized_type_tag == :void && !type_info.pointer?
       end
+
+      def has_return_value_name?
+        relevant? && !array_arg
+      end
     end
   end
 end

data/lib/gir_ffi/builders/constant_builder.rb

@@ -6,10 +6,8 @@ module GirFFI
     # triggered by a missing constant in the parent namespace.  The
     # constant will be attached to the appropriate namespace module.
     class ConstantBuilder < BaseTypeBuilder
-      private
-
-      def instantiate_class
-        @klass = optionally_define_constant namespace_module, @classname do
+      def build_class
+        @klass ||= optionally_define_constant namespace_module, @classname do
           info.value
         end
       end

data/lib/gir_ffi/builders/enum_builder.rb

@@ -20,14 +20,8 @@ module GirFFI
         }.flatten
       end
 
-      def instantiate_class
-        @enum = optionally_define_constant klass, :Enum do
-          lib.enum(enum_sym, value_spec)
-        end
-        setup_class unless already_set_up
-      end
-
       def setup_class
+        setup_ffi_enum
         klass.extend superclass
         setup_constants
         stub_methods
@@ -38,6 +32,12 @@ module GirFFI
         @klass ||= get_or_define_module namespace_module, @classname
       end
 
+      def setup_ffi_enum
+        @enum = optionally_define_constant klass, :Enum do
+          lib.enum(enum_sym, value_spec)
+        end
+      end
+
       def setup_inspect
         klass.instance_eval <<-EOS
           def self.inspect

data/lib/gir_ffi/builders/error_argument_builder.rb

@@ -6,12 +6,24 @@ module GirFFI
     # arguments are not part of the introspected signature, but their
     # presence is indicated by the 'throws' attribute of the function.
     class ErrorArgumentBuilder < BaseArgumentBuilder
-      def pre
-        [ "#{callarg} = FFI::MemoryPointer.new(:pointer).write_pointer nil" ]
+      def method_argument_name
+        nil
       end
 
-      def post
-        [ "GirFFI::ArgHelper.check_error(#{callarg})" ]
+      def return_value_name
+        nil
+      end
+
+      def capture_variable_name
+        nil
+      end
+
+      def pre_conversion
+        ["#{call_argument_name} = FFI::MemoryPointer.new(:pointer).write_pointer nil"]
+      end
+
+      def post_conversion
+        ["GirFFI::ArgHelper.check_error(#{call_argument_name})"]
       end
     end
   end

data/lib/gir_ffi/builders/field_builder.rb

@@ -27,11 +27,7 @@ module GirFFI
       end
 
       def setup_setter
-        container_class.class_eval setter_def if is_writable_field?
-      end
-
-      def is_writable_field?
-        info.writable?
+        container_class.class_eval setter_def if info.writable?
       end
 
       def getter_def
@@ -43,7 +39,7 @@ module GirFFI
         <<-CODE.reset_indentation
         def #{info.name}
           #{field_ptr} = @struct.to_ptr + #{info.offset}
-          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag_or_class.inspect}, #{field_ptr})
+          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag_or_class}, #{field_ptr})
           #{builder.capture_variable_name} = #{typed_ptr}.to_value
           #{builder.post_conversion.join("\n")}
           #{builder.return_value_name}
@@ -60,21 +56,17 @@ module GirFFI
         <<-CODE.reset_indentation
         def #{info.name}= #{builder.method_argument_name}
           #{field_ptr} = @struct.to_ptr + #{info.offset}
-          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag_or_class.inspect}, #{field_ptr})
+          #{typed_ptr} = GirFFI::InOutPointer.new(#{field_type_tag_or_class}, #{field_ptr})
           #{builder.pre_conversion.join("\n          ")}
-          #{typed_ptr}.set_value #{builder.callarg}
+          #{typed_ptr}.set_value #{builder.call_argument_name}
         end
         CODE
       end
 
       private
 
-      def struct_class
-        container_class::Struct
-      end
-
       def field_type_tag_or_class
-        @field_type_tag_or_class ||= info.field_type.tag_or_class
+        @field_type_tag_or_class ||= info.field_type.tag_or_class.inspect
       end
 
       def container_class
@@ -89,10 +81,6 @@ module GirFFI
         @container_info ||= info.container
       end
 
-      def field_symbol
-        @info.name.to_sym
-      end
-
       def field_type
         @field_type ||= @info.field_type
       end