gir_ffi 0.0.3 → 0.0.4

data/lib/gir_ffi/lib_c.rb

@@ -4,7 +4,7 @@ module GirFFI
   module LibC
     extend FFI::Library
     ffi_lib FFI::Library::LIBC
-    
+
     attach_function :malloc, [:size_t], :pointer
     attach_function :free, [:pointer], :void
   end

data/lib/gir_ffi/module_base.rb

@@ -0,0 +1,19 @@
+module GirFFI
+  module ModuleBase
+    def method_missing method, *arguments, &block
+      result = gir_ffi_builder.setup_function method.to_s
+      return super unless result
+      self.send method, *arguments, &block
+    end
+
+    def const_missing classname
+      klass = gir_ffi_builder.build_class classname.to_s
+      return super if klass.nil?
+      klass
+    end
+
+    def gir_ffi_builder
+      self.const_get :GIR_FFI_BUILDER
+    end
+  end
+end

data/lib/gir_ffi/module_builder.rb

@@ -1,9 +1,11 @@
 require 'gir_ffi/builder_helper'
+require 'gir_ffi/module_base'
 
 module GirFFI
   # Builds a module based on information found in the introspection
   # repository.
   class ModuleBuilder
+    include BuilderHelper
 
     def initialize namespace
       @namespace = namespace
@@ -13,47 +15,92 @@ module GirFFI
       build_module
     end
 
+    def setup_function method
+      go = function_introspection_data method.to_s
+
+      return false if go.nil?
+
+      modul = build_module
+      lib = modul.const_get(:Lib)
+
+      Builder.attach_ffi_function lib, go
+
+      meta = (class << modul; self; end)
+      meta.class_eval function_definition(go, lib)
+
+      true
+    end
+
+    def build_class classname
+      Builder.build_class @namespace, classname.to_s
+    end
+
     private
 
     def build_module
-      IRepository.default.require @namespace, nil
-      setup_module
-      setup_lib_for_ffi
-      unless @module.respond_to? :method_missing
-	@module.class_eval module_method_missing_definition
-	@module.class_eval const_missing_definition
+      unless defined? @module
+	instantiate_module
+	setup_lib_for_ffi
+	setup_module unless already_set_up
       end
       @module
     end
 
+    def instantiate_module
+      @module = get_or_define_module ::Object, @namespace.to_s
+    end
+
     def setup_module
-      @module = BuilderHelper.get_or_define_module ::Object, @namespace.to_s
+      @module.extend ModuleBase
+      @module.const_set :GIR_FFI_BUILDER, self
+      begin
+	require "gir_ffi/overrides/#{@namespace.downcase}"
+	@module.class_eval "include GirFFI::Overrides::#{@namespace}"
+      rescue LoadError
+      end
+    end
+
+    def already_set_up
+      @module.respond_to? :method_missing
     end
 
     def setup_lib_for_ffi
-      @lib = BuilderHelper.get_or_define_module @module, :Lib
+      @lib = get_or_define_module @module, :Lib
 
       unless (class << @lib; self.include? FFI::Library; end)
 	@lib.extend FFI::Library
-	libs = IRepository.default.shared_library(@namespace).split(/,/)
+	libs = gir.shared_library(@namespace).split(/,/)
 	@lib.ffi_lib(*libs)
       end
 
-      BuilderHelper.optionally_define_constant(@lib, :CALLBACKS) { [] }
+      optionally_define_constant(@lib, :CALLBACKS) { [] }
     end
 
-    def module_method_missing_definition
-      ModuleMethodMissingDefinitionBuilder.new(@lib, @namespace).generate
+    def function_introspection_data function
+      info = gir.find_by_name @namespace, function.to_s
+
+      if info.type == :function
+	info
+      else
+	nil
+      end
     end
 
-    def const_missing_definition
-      return <<-CODE
-	def self.const_missing classname
-	  info = IRepository.default.find_by_name "#{@namespace}", classname.to_s
-	  return super if info.nil?
-	  return GirFFI::Builder.build_class "#{@namespace}", classname.to_s
-	end
-      CODE
+    def function_definition info, libmodule
+      FunctionDefinitionBuilder.new(info, libmodule).generate
     end
+
+    def gir
+      unless defined? @gir
+	@gir = IRepository.default
+	@gir.require @namespace, nil
+      end
+      @gir
+    end
+
+    def get_or_define_module parent, name
+      optionally_define_constant(parent, name) { Module.new }
+    end
+
   end
 end

data/lib/gir_ffi/overrides/gobject.rb

@@ -0,0 +1,174 @@
+module GirFFI
+  module Overrides
+    module GObject
+
+      def self.included(base)
+	base.extend ClassMethods
+      end
+
+      module ClassMethods
+	def type_from_instance_pointer inst_ptr
+	  base = ::GObject::TypeInstance.new inst_ptr
+	  kls = ::GObject::TypeClass.new(base[:g_class])
+	  kls[:g_type]
+	end
+
+	def type_from_instance instance
+	  type_from_instance_pointer instance.to_ptr
+	end
+
+	def wrap_in_g_value val
+	  gvalue = ::GObject::Value.new
+	  case val
+	  when true, false
+	    gvalue.init ::GObject.type_from_name("gboolean")
+	    gvalue.set_boolean val
+	  end
+	  gvalue
+	end
+
+	def unwrap_g_value gvalue
+	  gtype = gvalue[:g_type]
+	  gtypename = ::GObject.type_name gtype
+	  case gtypename
+	  when "gboolean"
+	    gvalue.get_boolean
+	  else
+	    nil
+	  end
+	end
+
+	# FIXME: This is a private helper function. Move elsewhere?
+	def signal_callback_args sig, klass, &block
+	  return Proc.new do |*args|
+	    mapped = Helper.cast_back_signal_arguments sig, klass, *args
+	    block.call(*mapped)
+	  end
+	end
+
+	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
+
+	  signal_emitv arr[:values], id, 0, rval
+
+	  if use_ret
+	    rval
+	  else
+	    nil
+	  end
+	end
+
+	def signal_connect object, signal, data=nil, &block
+	  sig = object.class.gir_ffi_builder.find_signal signal
+	  if sig.nil?
+	    raise "Signal #{signal} is invalid for #{object}"
+	  end
+
+	  rettype = GirFFI::Builder.itypeinfo_to_ffitype sig.return_type
+
+	  argtypes = [:pointer] + sig.args.map {|a| :pointer} + [:pointer]
+
+	  callback = FFI::Function.new rettype, argtypes,
+	    &(signal_callback_args(sig, object.class, &block))
+
+	  signal_connect_data object, signal, callback, data, nil, 0
+	end
+      end
+
+      module Helper
+	def self.signal_arguments_to_gvalue_array signal, instance, *rest
+	  sig = instance.class.gir_ffi_builder.find_signal signal
+
+	  arr = ::GObject::ValueArray.new sig.n_args+1
+
+	  val = ::GObject::Value.new
+	  val.init ::GObject.type_from_instance(instance)
+	  val.set_instance instance
+	  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
+
+	    else
+	      raise NotImplementedError
+	    end
+	  end
+
+	  arr
+	end
+
+	def self.cast_back_signal_arguments signalinfo, klass, *args
+	  result = []
+
+	  # Instance
+	  instptr = args.shift
+	  instance = klass.send :_real_new, instptr
+	  result << instance
+
+	  # Extra arguments
+	  signalinfo.args.each do |info|
+	    arg = args.shift
+	    if info.type.tag == :interface
+	      iface = info.type.interface
+	      kls = GirFFI::Builder.build_class(iface.namespace, iface.name)
+	      result << kls.send(:_real_new, arg)
+	    else
+	      result << arg
+	    end
+	  end
+
+	  # User Data
+	  arg = args.shift
+	  arg = if FFI::Pointer === arg
+		  begin
+		    ObjectSpace._id2ref arg.address
+		  rescue RangeError
+		    arg
+		  end
+		else
+		  arg
+		end
+	  result << arg
+
+	  return result
+	end
+      end
+
+    end
+  end
+end

data/lib/gir_ffi/overrides/gtk.rb

@@ -1,12 +1,29 @@
-GirFFI::Builder.setup_function "Gtk", "init"
-module Gtk
-  class << self
-    alias _base_init init
-    def init
-      (my_len, my_args) = _base_init ARGV.length + 1, [$0, *ARGV]
-      my_args.shift
-      ARGV.replace my_args
+module GirFFI
+  module Overrides
+    module Gtk
+
+      def self.included(base)
+	base.gir_ffi_builder.setup_function "init"
+	base.extend ClassMethods
+	base.class_eval do
+
+	  class << self
+	    alias init_without_auto_argv init
+	    alias init init_with_auto_argv
+	  end
+
+	end
+      end
+
+      module ClassMethods
+
+	def init_with_auto_argv
+	  (my_len, my_args) = init_without_auto_argv ARGV.length + 1, [$0, *ARGV]
+	  my_args.shift
+	  ARGV.replace my_args
+	end
+
+      end
     end
-    private :_base_init
   end
 end

data/test/builder_test.rb

@@ -10,11 +10,6 @@ class BuilderTest < Test::Unit::TestCase
 	GirFFI::Builder.build_class 'GObject', 'Object'
       end
 
-      should "create a method_missing method for the class" do
-	ms = GObject::Object.instance_methods(false).map(&:to_sym)
-	assert_contains ms, :method_missing
-      end
-
       should "create a Lib module in the parent namespace ready to attach functions from gobject-2.0" do
 	gir = GirFFI::IRepository.default
 	expected = gir.shared_library 'GObject'
@@ -115,14 +110,6 @@ class BuilderTest < Test::Unit::TestCase
 	assert_equal go2, @go
       end
 
-      should "build correct definition of Gtk.main" do
-	code = GirFFI::Builder.send :function_definition, @go, Lib
-
-	expected = "def main\nLib.gtk_main\nend"
-
-	assert_equal cws(expected), cws(code)
-      end
-
       should "attach function to Whatever::Lib" do
 	mod = Module.new
 	mod.const_set :Lib, libmod = Module.new
@@ -142,12 +129,6 @@ class BuilderTest < Test::Unit::TestCase
 	@go = get_function_introspection_data 'Gtk', 'init'
       end
 
-      should "delegate definition to FunctionDefinitionBuilder" do
-	code = GirFFI::Builder.send :function_definition, @go, Lib
-	expected = GirFFI::FunctionDefinitionBuilder.new(@go, Lib).generate
-	assert_equal cws(expected), cws(code)
-      end
-
       should "have :pointer, :pointer as types of the arguments for the attached function" do
 	# FIXME: Ideally, we attach the function and test that it requires
 	# the correct argument types.
@@ -164,12 +145,6 @@ class BuilderTest < Test::Unit::TestCase
 	@go = get_method_introspection_data 'Gtk', 'Widget', 'show'
       end
 
-      should "delegate definition to FunctionDefinitionBuilder" do
-	code = GirFFI::Builder.send :function_definition, @go, Lib
-	expected = GirFFI::FunctionDefinitionBuilder.new(@go, Lib).generate
-	assert_equal cws(expected), cws(code)
-      end
-
       should "have :pointer as types of the arguments for the attached function" do
 	assert_equal [:pointer], GirFFI::Builder.send(:ffi_function_argument_types, @go)
       end
@@ -183,19 +158,14 @@ class BuilderTest < Test::Unit::TestCase
 	@go = get_function_introspection_data 'GObject', 'signal_connect_data'
       end
 
-      should "delegate definition to FunctionDefinitionBuilder" do
-	code = GirFFI::Builder.send :function_definition, @go, Lib
-	expected = GirFFI::FunctionDefinitionBuilder.new(@go, Lib).generate
-	assert_equal cws(expected), cws(code)
-      end
-
       should "have the correct types of the arguments for the attached function" do
-	assert_equal [:pointer, :string, :Callback, :pointer, :ClosureNotify, GObject::ConnectFlags],
-	  GirFFI::Builder.send(:ffi_function_argument_types, @go)
+	argtypes = GirFFI::Builder.send(:ffi_function_argument_types, @go)
+	assert_equal [:pointer, :string, GObject::Callback, :pointer, GObject::ClosureNotify, GObject::ConnectFlags],
+	  argtypes
       end
 
       should "define ffi callback types :Callback and :ClosureNotify" do
-	GirFFI::Builder.setup_function 'GObject', 'signal_connect_data'
+	GObject.gir_ffi_builder.setup_function 'signal_connect_data'
 	cb = GObject::Lib.find_type :Callback
 	cn = GObject::Lib.find_type :ClosureNotify
 
@@ -233,6 +203,35 @@ class BuilderTest < Test::Unit::TestCase
       end
     end
 
+    context "building GObject::TypeCValue" do
+      setup do
+	GirFFI::Builder.build_class 'GObject', 'TypeCValue'
+      end
+
+      should "set up the correct union members" do
+	assert_equal [:v_int, :v_long, :v_int64, :v_double, :v_pointer],
+	  GObject::TypeCValue::Struct.members
+      end
+
+      should "set up union members with the correct offset" do
+	assert_equal [0, 0, 0, 0, 0],
+	  GObject::TypeCValue::Struct.layout.fields.map(&:offset)
+      end
+
+      should "set up the inner class as derived from FFI::Union" do
+	assert_equal FFI::Union, GObject::TypeCValue::Struct.superclass
+      end
+    end
+
+    context "building GObject::ValueArray" do
+      should "use provided constructor if present" do
+	GirFFI::Builder.build_class 'GObject', 'ValueArray'
+	assert_nothing_raised {
+	  GObject::ValueArray.new 2
+	}
+      end
+    end
+
     context "building Everything::TestBoxed" do
       setup do
 	GirFFI::Builder.build_class 'Everything', 'TestBoxed'
@@ -245,22 +244,26 @@ class BuilderTest < Test::Unit::TestCase
 
     # TODO: Should not allow functions to be called as methods, etc.
 
-    context "building the Everything module" do
+    context "built Everything module" do
       setup do
 	cleanup_module :Everything
 	GirFFI::Builder.build_module 'Everything'
       end
 
-      should "create a method_missing method for the module" do
+      should "have a method_missing method" do
 	ms = (Everything.public_methods - Module.public_methods).map(&:to_sym)
 	assert_contains ms, :method_missing
       end
 
-      should "cause the TestObj class to be autocreated" do
+      should "autocreate the TestObj class" do
 	assert !Everything.const_defined?(:TestObj)
 	assert_nothing_raised {Everything::TestObj}
 	assert Everything.const_defined? :TestObj
       end
+
+      should "know its own module builder" do
+	assert GirFFI::ModuleBuilder === Everything.gir_ffi_builder
+      end
     end
 
     # TODO: Turn this into full test of instance method creation, including
@@ -290,6 +293,23 @@ class BuilderTest < Test::Unit::TestCase
       should "not have regular #new as a constructor" do
 	assert_raises(NoMethodError) { Everything::TestObj.new }
       end
+
+      should "know its own GIR info" do
+	assert_equal 'TestObj', Everything::TestObj.gir_info.name
+      end
+
+      should "know its own class builder" do
+	assert GirFFI::ClassBuilder === Everything::TestObj.gir_ffi_builder
+      end
+
+      context "its #torture_signature_0 method" do
+	should "have the correct types of the arguments for the attached function" do
+	  info = get_method_introspection_data 'Everything', 'TestObj',
+	    'torture_signature_0'
+	  assert_equal [:pointer, :int, :pointer, :pointer, :string, :pointer, :uint],
+	    GirFFI::Builder.send(:ffi_function_argument_types, info)
+	end
+      end
     end
 
     context "built Everything::TestSubObj" do