gir_ffi 0.6.6 → 0.6.7

data/lib/gir_ffi/builders/function_builder.rb

@@ -0,0 +1,123 @@
+require 'gir_ffi/builders/argument_builder'
+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'
+
+module GirFFI
+  module Builders
+    # Implements the creation of a Ruby function definition out of a GIR
+    # IFunctionInfo.
+    class FunctionBuilder
+      def initialize info
+        @info = info
+      end
+
+      def generate
+        vargen = GirFFI::VariableNameGenerator.new
+        @argument_builders = @info.args.map {|arg| ArgumentBuilder.new vargen, arg }
+        @return_value_builder = ReturnValueBuilder.new(vargen,
+                                                       @info.return_type,
+                                                       @info.constructor?,
+                                                       @info.skip_return?)
+
+        link_array_length_arguments
+        setup_error_argument vargen
+        return filled_out_template
+      end
+
+      private
+
+      def libmodule
+        Object.const_get(@info.safe_namespace)::Lib
+      end
+
+      def link_array_length_arguments
+        alldata = @argument_builders.dup << @return_value_builder
+
+        alldata.each {|data|
+          idx = data.type_info.array_length
+          if idx > -1
+            other_data = @argument_builders[idx]
+            data.length_arg = other_data
+            other_data.array_arg = data
+          end
+        }
+      end
+
+      def setup_error_argument vargen
+        klass = @info.throws? ? ErrorArgumentBuilder : NullArgumentBuilder
+        @errarg = klass.new vargen, nil, nil, :error
+      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 << cleanup
+        lines << "return #{return_values.join(', ')}" if has_return_values?
+        lines.flatten.join("\n").indent
+      end
+
+      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 preparation
+        pr = @argument_builders.map(&:pre)
+        pr << @errarg.pre
+        pr.flatten
+      end
+
+      def capture
+        if has_capture?
+          "#{@return_value_builder.callarg} = "
+        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}
+        args << @return_value_builder
+        args.unshift @errarg
+
+        args.map {|arg| arg.post}
+      end
+
+      def cleanup
+        @argument_builders.map {|item| item.cleanup}
+      end
+
+      def return_values
+        @return_values ||= ([@return_value_builder.retval] +
+                            @argument_builders.map(&:retval)).compact
+      end
+
+      def has_return_values?
+        !return_values.empty?
+      end
+
+      def has_capture?
+        @return_value_builder.is_relevant?
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/interface_builder.rb

@@ -0,0 +1,29 @@
+require 'gir_ffi/builders/registered_type_builder'
+require 'gir_ffi/builders/with_methods'
+require 'gir_ffi/interface_base'
+
+module GirFFI
+  module Builders
+    # Implements the creation of a module representing an Interface.
+    class InterfaceBuilder < RegisteredTypeBuilder
+      include WithMethods
+
+      private
+
+      # FIXME: The word 'class' is not really correct.
+      def instantiate_class
+        @klass = optionally_define_constant(namespace_module, @classname) do
+          ::Module.new
+        end
+        setup_module unless already_set_up
+      end
+
+      def setup_module
+        @klass.extend InterfaceBase
+        setup_constants
+        stub_methods
+        setup_gtype_getter
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/mapping_method_builder.rb

@@ -0,0 +1,88 @@
+require 'gir_ffi/builders/return_value_builder'
+
+module GirFFI
+  module Builders
+    # Implements the creation mapping method for a callback or signal
+    # 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
+          end
+        end
+
+        def retval
+          if specialized_type_tag == :enum
+            retname
+          else
+            super
+          end
+        end
+      end
+
+      def initialize argument_infos, return_type_info
+        @argument_infos = argument_infos
+        @return_type_info = return_type_info
+      end
+
+      attr_reader :argument_infos
+      attr_reader :return_type_info
+
+      def method_definition
+        code = "def self.call_with_argument_mapping(#{method_arguments.join(', ')})"
+        method_lines.each { |line| code << "\n  #{line}" }
+        code << "\nend\n"
+      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
+      end
+
+      def capture
+        @capture ||= return_value_builder.is_relevant? ?
+          "#{return_value_builder.callarg} = " :
+          ""
+      end
+
+      def call_arguments
+        @call_arguments ||= argument_builders.map(&:retval)
+      end
+
+      def method_arguments
+        @method_arguments ||= argument_builders.map(&:callarg).unshift('_proc')
+      end
+
+      def return_value_builder
+        @return_value_builder ||= ReturnValueBuilder.new(vargen, return_type_info)
+      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
+      end
+
+      def vargen
+        @vargen ||= GirFFI::VariableNameGenerator.new
+      end
+    end
+  end
+end
+

data/lib/gir_ffi/builders/module_builder.rb

@@ -0,0 +1,124 @@
+require 'gir_ffi/builder_helper'
+require 'gir_ffi/module_base'
+require 'gir_ffi/builders/function_builder'
+require 'indentation'
+
+module GirFFI
+  module Builders
+    # Builds a module based on information found in the introspection
+    # repository.
+    class ModuleBuilder
+      include BuilderHelper
+
+      def initialize namespace, version=nil
+        @namespace = namespace
+        @version = version
+        # FIXME: Pass safe namespace as an argument
+        @safe_namespace = @namespace.gsub(/^(.)/) { $1.upcase }
+      end
+
+      def generate
+        build_module
+      end
+
+      def setup_method method
+        go = function_introspection_data method.to_s
+
+        return false if go.nil?
+
+        modul = build_module
+
+        Builder.attach_ffi_function libmodule, go
+        definition = function_definition go
+        modul.class_eval definition
+
+        true
+      end
+
+      def build_namespaced_class classname
+        info = gir.find_by_name @namespace, classname.to_s
+        if info.nil?
+          raise NameError.new(
+            "Class #{classname} not found in namespace #{@namespace}")
+        end
+        Builder.build_class info
+      end
+
+      def build_module
+        unless defined? @module
+          build_dependencies
+          instantiate_module
+          setup_lib_for_ffi
+          setup_module unless already_set_up
+        end
+        @module
+      end
+
+      private
+
+      def build_dependencies
+        deps = gir.dependencies @namespace
+        deps.each {|dep|
+          name, version = dep.split '-'
+          Builder.build_module name, version
+        }
+      end
+
+      def instantiate_module
+        @module = get_or_define_module ::Object, @safe_namespace
+      end
+
+      def setup_module
+        @module.extend ModuleBase
+        @module.const_set :GIR_FFI_BUILDER, self
+      end
+
+      def already_set_up
+        @module.respond_to? :method_missing
+      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
+        end
+      end
+
+      def sub_builder info
+        if info.info_type == :function
+          FunctionBuilder.new info
+        else
+          TypeBuilder.builder_for info
+        end
+      end
+
+      def libmodule
+        @module.const_get(:Lib)
+      end
+
+      def function_introspection_data function
+        info = gir.find_by_name @namespace, function.to_s
+        return nil if info.nil?
+        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
+          @gir.require @namespace, @version
+        end
+        @gir
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/null_builder.rb

@@ -0,0 +1,11 @@
+module GirFFI
+  class NullBuilder
+    def find_signal _
+      nil
+    end
+
+    def find_property _
+      nil
+    end
+  end
+end

data/lib/gir_ffi/builders/object_builder.rb

@@ -0,0 +1,123 @@
+require 'gir_ffi/builders/registered_type_builder'
+require 'gir_ffi/builders/with_layout'
+require 'gir_ffi/builders/with_methods'
+require 'gir_ffi/builders/property_builder'
+require 'gir_ffi/object_base'
+
+module GirFFI
+  module Builders
+    # Implements the creation of a class representing a GObject Object.
+    class ObjectBuilder < RegisteredTypeBuilder
+      include WithMethods
+      include WithLayout
+
+      def find_signal signal_name
+        signal_definers.each do |inf|
+          sig = inf.find_signal signal_name
+          return sig if sig
+        end
+        superclass.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
+          raise "Property #{property_name} not found"
+      end
+
+      private
+
+      def setup_class
+        setup_layout
+        setup_constants
+        stub_methods
+        setup_gtype_getter
+        if info.fundamental?
+          setup_field_accessors
+        else
+          setup_property_accessors
+        end
+        setup_vfunc_invokers
+        setup_interfaces
+      end
+
+      # FIXME: Private method only used in subclass
+      def layout_superclass
+        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
+        end
+        @parent
+      end
+
+      def 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
+        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
+        end
+        @klass.class_eval builder.setter_def
+      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|
+          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
+            include iface
+          end
+        end
+      end
+
+      def signal_definers
+        [info] + info.interfaces
+      end
+
+      def interfaces
+        info.interfaces.map do |ifinfo|
+          GirFFI::Builder.build_class ifinfo
+        end
+      end
+    end
+  end
+end