gir_ffi 0.0.5 → 0.0.6

data/lib/gir_ffi/function_definition_builder.rb

@@ -1,32 +1,9 @@
+require 'gir_ffi/argument_builder'
+
 module GirFFI
   # Implements the creation of a Ruby function definition out of a GIR
   # IFunctionInfo.
   class FunctionDefinitionBuilder
-    ArgData = Struct.new(:arginfo, :inarg, :callarg, :retval, :pre, :post, :postpost,
-			 :name, :retname)
-    class ArgData
-      def initialize arginfo=nil
-	super
-	self.arginfo = arginfo
-	self.inarg = nil
-	self.callarg = nil
-	self.retval = nil
-	self.retname = nil
-	self.name = nil
-	self.pre = []
-	self.post = []
-	self.postpost = []
-      end
-    end
-
-    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"
-    ]
-
     def initialize info, libmodule
       @info = info
       @libmodule = libmodule
@@ -34,10 +11,19 @@ module GirFFI
 
     def generate
       setup_accumulators
-      @data = @info.args.map {|a| ArgData.new a}
-      @data.each {|data| prepare_arg data }
-      @data.each {|data| process_arg data }
-      process_return_value
+      @data = @info.args.map {|arg| ArgumentBuilder.build self, arg, @libmodule}
+      @rvdata = ReturnValueBuilder.new self, @info
+
+      alldata = @data.dup << @rvdata
+
+      alldata.each {|data|
+        data.prepare
+	idx = data.type.array_length
+        data.length_arg = @data[idx] if idx > -1
+      }
+
+      alldata.each {|data| data.process }
+
       adjust_accumulators
       return filled_out_template
     end
@@ -45,266 +31,59 @@ module GirFFI
     private
 
     def setup_accumulators
-      @inargs = []
-      @callargs = []
-      @retvals = []
-
-      @pre = []
-      @post = []
-
-      @data = []
-
-      @capture = ""
-
       @varno = 0
     end
 
-    def prepare_arg data
-      arg = data.arginfo
-      data.name = safe arg.name
-      data.callarg = new_var
-
-      case arg.direction
-      when :inout
-	data.inarg = data.name
-	data.retname = data.retval = new_var
-      when :in
-	data.inarg = data.name
-      when :out
-	data.retname = data.retval = new_var
-      else
-	raise ArgumentError
-      end
-    end
-
-    def process_arg data
-      arg = data.arginfo
-      case arg.direction
-      when :inout
-	process_inout_arg data
-      when :in
-	process_in_arg data
-      when :out
-	process_out_arg data
-      else
-	raise ArgumentError
-      end
+    def adjust_accumulators
+      klass = @info.throws? ? ErrorHandlerBuilder : NullArgumentBuilder
+      @errarg = klass.new(self)
+      @errarg.prepare
+      @errarg.process
     end
 
-    def process_inout_arg data
-      arg = data.arginfo
-
-      raise NotImplementedError unless arg.ownership_transfer == :everything
-
-      tag = arg.type.tag
-
-      case tag
-      when :interface
-	raise NotImplementedError
-      when :array
-	tag = arg.type.param_type(0).tag
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_array_to_inoutptr #{data.inarg}"
-	if arg.type.array_length > -1
-	  idx = arg.type.array_length
-	  lendata = @data[idx]
-	  rv = lendata.retval
-	  lendata.retval = nil
-	  lname = lendata.inarg
-	  lendata.inarg = nil
-	  lendata.pre.unshift "#{lname} = #{data.inarg}.length"
-	  data.post << "#{data.retval} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{data.callarg}, #{rv}"
-	  if tag == :utf8
-	    data.post << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{data.callarg}, #{rv}"
-	  else
-	    data.post << "GirFFI::ArgHelper.cleanup_ptr_ptr #{data.callarg}"
-	  end
-	else
-	  raise NotImplementedError
+    def filled_out_template
+      return <<-CODE
+	def #{@info.name} #{inargs.join(', ')}
+	  #{pre.join("\n")}
+	  #{capture}::#{@libmodule}.#{@info.symbol} #{callargs.join(', ')}
+	  #{post.join("\n")}
 	end
-      else
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_to_inoutptr #{data.inarg}"
-	data.post << "#{data.retval} = GirFFI::ArgHelper.outptr_to_#{tag} #{data.callarg}"
-	data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
-      end
-
-      data
+      CODE
     end
 
-    def process_out_arg data
-      arg = data.arginfo
-      type = arg.type
-      tag = type.tag
-
-      case tag
-      when :interface
-	iface = arg.type.interface
-	if arg.caller_allocates?
-	  data.pre << "#{data.callarg} = #{iface.namespace}::#{iface.name}.allocate"
-	  data.post << "#{data.retval} = #{data.callarg}"
-	else
-	  data.pre << "#{data.callarg} = GirFFI::ArgHelper.pointer_outptr"
-	  tmpvar = new_var
-	  data.post << "#{tmpvar} = GirFFI::ArgHelper.outptr_to_pointer #{data.callarg}"
-	  data.post << "#{data.retval} = #{iface.namespace}::#{iface.name}.wrap #{tmpvar}"
-	end
-      when :array
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.pointer_outptr"
-
-	tag = arg.type.param_type(0).tag
-	size = type.array_fixed_size
-	idx = type.array_length
-
-	if size <= 0
-	  if idx > -1
-	    size = @data[idx].retval
-	    @data[idx].retval = nil
-	  else
-	    raise NotImplementedError
-	  end
-	end
-	data.postpost << "#{data.retval} = GirFFI::ArgHelper.outptr_to_#{tag}_array #{data.callarg}, #{size}"
-	if arg.ownership_transfer == :everything
-	  if tag == :utf8
-	    data.postpost << "GirFFI::ArgHelper.cleanup_ptr_array_ptr #{data.callarg}, #{rv}"
-	  else
-	    data.postpost << "GirFFI::ArgHelper.cleanup_ptr_ptr #{data.callarg}"
-	  end
-	end
-      else
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_outptr"
-	data.post << "#{data.retname} = GirFFI::ArgHelper.outptr_to_#{tag} #{data.callarg}"
-	if arg.ownership_transfer == :everything
-	  data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
-	end
-      end
-
-      data
+    def inargs
+      @data.map(&:inarg).compact
     end
 
-    def process_in_arg data
-      arg = data.arginfo
-
-      type = arg.type
-      tag = type.tag
-
-      case tag
-      when :interface
-	if type.interface.type == :callback
-	  data.pre << "#{data.callarg} = GirFFI::ArgHelper.mapped_callback_args #{data.inarg}"
-	  data.pre << "::#{@libmodule}::CALLBACKS << #{data.callarg}"
-	else
-	  data.pre << "#{data.callarg} = #{data.inarg}"
-	end
-      when :void
-	raise NotImplementedError unless arg.type.pointer?
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.object_to_inptr #{data.inarg}"
-      when :array
-	if type.array_fixed_size > 0
-	  data.pre << "GirFFI::ArgHelper.check_fixed_array_size #{type.array_fixed_size}, #{data.inarg}, \"#{data.inarg}\""
-	elsif type.array_length > -1
-	  idx = type.array_length
-	  lenvar = @data[idx].inarg
-	  @data[idx].inarg = nil
-	  @data[idx].pre.unshift "#{lenvar} = #{data.inarg}.nil? ? 0 : #{data.inarg}.length"
-	end
-
-	tag = arg.type.param_type(0).tag
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.#{tag}_array_to_inptr #{data.inarg}"
-	unless arg.ownership_transfer == :everything
-	  if tag == :utf8
-	    data.post << "GirFFI::ArgHelper.cleanup_ptr_ptr #{data.callarg}"
-	  else
-	    data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
-	  end
-	end
-      when :utf8
-	data.pre << "#{data.callarg} = GirFFI::ArgHelper.utf8_to_inptr #{data.name}"
-	# TODO:
-	#data.post << "GirFFI::ArgHelper.cleanup_ptr #{data.callarg}"
-      else
-	data.pre << "#{data.callarg} = #{data.name}"
-      end
-
-      data
+    def callargs
+      ca = @data.map(&:callarg)
+      ca << @errarg.callarg
+      ca.unshift "self" if @info.method?
+      ca.compact
     end
 
-    def process_return_value
-      @rvdata = ArgData.new
-      type = @info.return_type
-      tag = type.tag
-      return if tag == :void
-      cvar = new_var
-      @capture = "#{cvar} = "
-
-      case tag
-      when :interface
-	interface = type.interface
-	namespace = interface.namespace
-	name = interface.name
-	GirFFI::Builder.build_class namespace, name
-	retval = new_var
-	@rvdata.post << "#{retval} = ::#{namespace}::#{name}.wrap(#{cvar})"
-	if interface.type == :object
-	  @rvdata.post << "GirFFI::ArgHelper.sink_if_floating(#{retval})"
-	end
-	@rvdata.retval = retval
-      when :array
-	tag = type.param_type(0).tag
-	size = type.array_fixed_size
-	idx = type.array_length
+    def pre
+      pr = @data.map(&:pre)
+      pr << @errarg.pre
+      pr.flatten
+    end
 
-	retval = new_var
-	if size > 0
-	  @rvdata.post << "#{retval} = GirFFI::ArgHelper.ptr_to_#{tag}_array #{cvar}, #{size}"
-	elsif idx > -1
-	  lendata = @data[idx]
-	  rv = lendata.retval
-	  lendata.retval = nil
-	  @rvdata.post << "#{retval} = GirFFI::ArgHelper.ptr_to_#{tag}_array #{cvar}, #{rv}"
-	end
-	@rvdata.retval = retval
+    def capture
+      if (cv = @rvdata.cvar)
+        "#{cv} = "
       else
-	@rvdata.retval = cvar
+        ""
       end
     end
 
-    def adjust_accumulators
-      @retvals << @rvdata.retval
-      @data.each do |data|
-	@inargs << data.inarg
-	@callargs << data.callarg
-	@retvals << data.retval
-	@pre += data.pre
-	@post += data.post
-      end
-      @data.each do |data|
-	@post += data.postpost
-      end
-      @post += @rvdata.post
+    def post
+      po = (@data.map(&:post) + @data.map(&:postpost) + @rvdata.post)
+      po.unshift @errarg.post
 
-      if @info.throws?
-	errvar = new_var
-	@pre << "#{errvar} = FFI::MemoryPointer.new(:pointer).write_pointer nil"
-	@post.unshift "GirFFI::ArgHelper.check_error(#{errvar})"
-	@callargs << errvar
-      end
-
-      @retvals = @retvals.compact
-      @post << "return #{@retvals.compact.join(', ')}" unless @retvals.empty?
+      retvals = ([@rvdata.retval] + @data.map(&:retval)).compact
+      po << "return #{retvals.join(', ')}" unless retvals.empty?
 
-      if @info.method?
-	@callargs.unshift "self"
-      end
-    end
-
-    def filled_out_template
-      return <<-CODE
-	def #{@info.name} #{@inargs.compact.join(', ')}
-	  #{@pre.join("\n")}
-	  #{@capture}::#{@libmodule}.#{@info.symbol} #{@callargs.compact.join(', ')}
-	  #{@post.join("\n")}
-	end
-      CODE
+      po.flatten
     end
 
     def new_var
@@ -312,12 +91,6 @@ module GirFFI
       "_v#{@varno}"
     end
 
-    def safe name
-      if KEYWORDS.include? name
-	"#{name}_"
-      else
-	name
-      end
-    end
+    public :new_var
   end
 end

data/lib/gir_ffi/g_object.rb

@@ -1,25 +1,26 @@
 require 'ffi'
 
 module GirFFI
+  # TODO: Rename to avoid constant lookup issues (and confusion).
   module GObject
     def self.type_init
       Lib::g_type_init
     end
 
-    def self.object_ref o
-      Lib::g_object_ref o.to_ptr
+    def self.object_ref obj
+      Lib::g_object_ref obj.to_ptr
     end
 
-    def self.object_ref_sink o
-      Lib::g_object_ref_sink o.to_ptr
+    def self.object_ref_sink obj
+      Lib::g_object_ref_sink obj.to_ptr
     end
 
-    def self.object_unref o
-      Lib::g_object_unref o.to_ptr
+    def self.object_unref obj
+      Lib::g_object_unref obj.to_ptr
     end
 
-    def self.object_is_floating o
-      Lib::g_object_is_floating o.to_ptr
+    def self.object_is_floating obj
+      Lib::g_object_is_floating obj.to_ptr
     end
 
     module Lib

data/lib/gir_ffi/i_repository.rb

@@ -86,8 +86,8 @@ module GirFFI
 
     # Utility method
     def infos namespace
-      (0..(n_infos(namespace) - 1)).map do |i|
-	info namespace, i
+      (0..(n_infos(namespace) - 1)).map do |idx|
+	info namespace, idx
       end
     end
 

data/lib/gir_ffi/lib.rb

@@ -99,8 +99,10 @@ module GirFFI
     # gobject-introspection version 0.9.0 and 0.9.1. Therefore, we need to
     # retrieve the correct values before declaring the ITypeTag enum.
     attach_function :tmp_type_tag_to_string, :g_type_tag_to_string, [:int], :string
-    arr = (0..31).map { |i| [tmp_type_tag_to_string(i).to_sym, i] }.flatten
-    enum :ITypeTag, arr
+    type_tag_map = (0..31).map { |id|
+      [tmp_type_tag_to_string(id).to_sym, id]
+    }.flatten
+    enum :ITypeTag, type_tag_map
 
     # Now, attach g_type_tag_to_string again under its own name with an
     # improved signature.

data/lib/gir_ffi/overrides/gobject.rb

@@ -24,6 +24,8 @@ module GirFFI
 	  when true, false
 	    gvalue.init ::GObject.type_from_name("gboolean")
 	    gvalue.set_boolean val
+	  else
+	    nil
 	  end
 	  gvalue
 	end
@@ -41,31 +43,14 @@ module GirFFI
 
 	def signal_emit object, signal, *args
 	  type = type_from_instance object
-
 	  id = signal_lookup signal, type
 
-	  val = ::GObject::Value.new
-	  val.init type
-	  val.set_instance object
-
-	  q = ::GObject::SignalQuery.new
-	  signal_query id, q
-
-	  use_ret = (q[:return_type] != ::GObject.type_from_name("void"))
-	  if use_ret
-	    rval = ::GObject::Value.new
-	    rval.init q[:return_type]
-	  end
-
 	  arr = Helper.signal_arguments_to_gvalue_array signal, object, *args
+	  rval = Helper.gvalue_for_signal_return_value signal, object
 
 	  signal_emitv arr[:values], id, 0, rval
 
-	  if use_ret
-	    rval
-	  else
-	    nil
-	  end
+	  rval
 	end
 
 	def signal_connect object, signal, data=nil, &block
@@ -79,7 +64,7 @@ module GirFFI
 
 	  rettype = GirFFI::Builder.itypeinfo_to_ffitype sig.return_type
 
-	  argtypes = [:pointer] + sig.args.map {|a| :pointer} + [:pointer]
+	  argtypes = [:pointer] + sig.args.map {|arg| :pointer} + [:pointer]
 
 	  callback = FFI::Function.new rettype, argtypes,
 	    &(Helper.signal_callback_args(sig, object.class, &block))
@@ -107,32 +92,49 @@ module GirFFI
 	  arr.append val
 	  val.unset
 
-	  sig.args.zip(rest).each do |a|
-	    info, arg = *a
-	    if info.type.tag == :interface
-	      interface = info.type.interface
-
-	      val = ::GObject::Value.new
-	      val.init info.type.interface.g_type
-	      case interface.type
-	      when :struct
-		val.set_boxed arg
-	      when :object
-		val.set_instance arg
-	      else
-		raise NotImplementedError, interface.type
-	      end
-
-	      arr.append val
-
-	      val.unset
+	  sig.args.zip(rest).each do |info, arg|
+	    arr.append signal_argument_to_gvalue info, arg
+	  end
 
+	  arr
+	end
+	
+	def self.signal_argument_to_gvalue info, arg
+	  if info.type.tag == :interface
+	    interface = info.type.interface
+
+	    val = ::GObject::Value.new
+	    val.init info.type.interface.g_type
+	    case interface.type
+	    when :struct
+	      val.set_boxed arg
+	    when :object
+	      val.set_instance arg
 	    else
-	      raise NotImplementedError
+	      raise NotImplementedError, interface.type
 	    end
+
+	    return val
+	  else
+	    raise NotImplementedError
 	  end
+	end
 
-	  arr
+	def self.gvalue_for_signal_return_value signal, object
+	  type = ::GObject.type_from_instance object
+
+	  # TODO: Use same signal info as signal_arguments_to_gvalue_array
+	  id = ::GObject.signal_lookup signal, type
+
+	  query = ::GObject::SignalQuery.new
+	  ::GObject.signal_query id, query
+
+	  use_ret = (query[:return_type] != ::GObject.type_from_name("void"))
+	  if use_ret
+	    rval = ::GObject::Value.new
+	    rval.init query[:return_type]
+	  end
+	  rval
 	end
 
 	def self.cast_back_signal_arguments signalinfo, klass, *args

data/lib/gir_ffi.rb

@@ -1,36 +1,3 @@
-
-module GirFFI
-
-  # :stopdoc:
-  VERSION = '0.0.1'
-  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
-  # :startdoc:
-
-  # Returns the version string for the library.
-  #
-  def self.version
-    VERSION
-  end
-
-  # Returns the library path for the module. If any arguments are given,
-  # they will be joined to the end of the libray path using
-  # <tt>File.join</tt>.
-  #
-  def self.libpath( *args )
-    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
-  end
-
-  # Returns the lpath for the module. If any arguments are given,
-  # they will be joined to the end of the path using
-  # <tt>File.join</tt>.
-  #
-  def self.path( *args )
-    args.empty? ? PATH : ::File.join(PATH, args.flatten)
-  end
-
-end
-
 require 'gir_ffi/i_repository'
 require 'gir_ffi/builder'
 
@@ -40,4 +7,3 @@ module GirFFI
     GirFFI::Builder.build_module module_name
   end
 end
-# EOF

data/test/arg_helper_test.rb

@@ -1,5 +1,4 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-require 'gir_ffi/arg_helper'
 
 class ArgHelperTest < Test::Unit::TestCase
   context "The int_to_inoutptr method's return value" do
@@ -7,8 +6,8 @@ class ArgHelperTest < Test::Unit::TestCase
       @result = GirFFI::ArgHelper.int_to_inoutptr 24
     end
 
-    should "be a FFI::Pointer" do
-      assert_equal "FFI::Pointer", @result.class.to_s
+    should "be an FFI::Pointer" do
+      assert_instance_of FFI::Pointer, @result
     end
 
     should "hold a pointer to the correct input value" do
@@ -22,8 +21,8 @@ class ArgHelperTest < Test::Unit::TestCase
 	@result = GirFFI::ArgHelper.utf8_array_to_inoutptr ["foo", "bar", "baz"]
       end
 
-      should "return a FFI::Pointer" do
-	assert_equal "FFI::Pointer", @result.class.to_s
+      should "return an FFI::Pointer" do
+	assert_instance_of FFI::Pointer, @result
       end
 
       should "return a pointer to an array of pointers to strings" do
@@ -81,15 +80,16 @@ class ArgHelperTest < Test::Unit::TestCase
 	@ptr.write_pointer p
       end
 
-      should "return render the null pointer as nil" do
+      should "render the null pointer as nil" do
 	assert_equal ["one", "two", nil],
 	  GirFFI::ArgHelper.outptr_to_utf8_array(@ptr, 3)
       end
     end
 
-    context "when called with nil" do
+    context "when called with a pointer to null" do
       should "return nil" do
-	assert_nil GirFFI::ArgHelper.outptr_to_utf8_array(nil, 0)
+	ptr = GirFFI::ArgHelper.pointer_pointer.write_pointer nil
+	assert_nil GirFFI::ArgHelper.outptr_to_utf8_array(ptr, 0)
       end
     end
   end
@@ -119,12 +119,18 @@ class ArgHelperTest < Test::Unit::TestCase
   end
 
   context "The object_pointer_to_object method" do
-    should "return an object of the correct class" do
+    setup do
       GirFFI.setup :Everything
-      o = Everything::TestSubObj.new
-      o2 = GirFFI::ArgHelper.object_pointer_to_object o.to_ptr
-      assert_instance_of Everything::TestSubObj, o2
-      assert_equal o.to_ptr, o2.to_ptr
+      @o = Everything::TestSubObj.new
+      @o2 = GirFFI::ArgHelper.object_pointer_to_object @o.to_ptr
+    end
+
+    should "return an object of the correct class" do
+      assert_instance_of Everything::TestSubObj, @o2
+    end
+
+    should "return an object pointing to the original struct" do
+      assert_equal @o.to_ptr, @o2.to_ptr
     end
   end
 end

data/test/builder_test.rb

@@ -1,5 +1,4 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-require 'gir_ffi'
 
 class BuilderTest < Test::Unit::TestCase
   context "The GirFFI::Builder module" do

data/test/class_base_test.rb

@@ -1,5 +1,4 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-require 'gir_ffi/class_base'
 
 class ClassBaseTest < Test::Unit::TestCase
   context "A class derived from GirFFI::Base" do

data/test/class_builder_test.rb

@@ -1,5 +1,4 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-require 'gir_ffi'
 
 class ClassBuilderTest < Test::Unit::TestCase
   context "The ClassBuilder" do