gir_ffi 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,7 @@
-== 0.0.1 / 2009-11-09
+== 0.0.2 / 2010-11-14
 
-* Nothing to see yet, move along.
+* Several fixes to method creation.
+
+== 0.0.1 / 2010-10-25
+
+* Initial release.

data/lib/gir_ffi/arg_helper.rb

@@ -37,7 +37,7 @@ module GirFFI
       value
     end
 
-    # Converts an outptr to a string array, then frees the outptr.
+    # Converts an outptr to a string array, then frees pointers.
     def self.outptr_to_string_array ptr, size
       return nil if ptr.nil?
 
@@ -49,7 +49,13 @@ module GirFFI
       ptrs = block.read_array_of_pointer(size)
       LibC.free block
 
-      ptrs.map { |p| p.null? ? nil : (str = p.read_string; LibC.free p; str) }
+      ptrs.map do |p|
+	if p.null?
+	  nil
+	else
+	  p.read_string.tap { LibC.free p }
+	end
+      end
     end
 
     def self.mapped_callback_args prc=nil, &block

data/lib/gir_ffi/base.rb

@@ -1,23 +1,35 @@
 require 'forwardable'
 module GirFFI
+  # Base class for all generated classes. Contains code for dealing with
+  # the generated Struct classes.
   class Base
     extend Forwardable
     def_delegators :@struct, :[], :[]=, :to_ptr
 
-    def initialize(ptr=nil)
-      @struct = ptr.nil? ?
-	self.ffi_structure.new :
-	self.ffi_structure.new(ptr)
+    def initialize(*args)
+      @struct = ffi_structure.new(*args)
     end
 
     def ffi_structure
       self.class.ffi_structure
     end
 
+    def _fake_missing *args, &block
+      method_missing method_name.to_sym, *args, &block
+    end
+
+    private
+
+    def method_name
+      caller[0].gsub(/.*`(.*)'/, '\1')
+    end
+
     class << self
       def ffi_structure
 	self.const_get(:Struct)
       end
+      alias_method :_real_new, :new
+      undef new
     end
   end
 end

data/lib/gir_ffi/builder.rb

@@ -1,4 +1,3 @@
-require 'gir_ffi/class_base'
 require 'gir_ffi/arg_helper'
 require 'gir_ffi/function_definition_builder'
 require 'gir_ffi/constructor_definition_builder'
@@ -13,26 +12,65 @@ module GirFFI
   # introspection repository. Call its build_module and build_class methods
   # to create the modules and classes used in your program.
   module Builder
-    def self.build_class namespace, classname, box=nil
-      ClassBuilder.new(namespace, classname, box).generate
+    def self.build_class namespace, classname
+      ClassBuilder.new(namespace, classname).generate
     end
 
-    def self.build_module namespace, box=nil
-      ModuleBuilder.new(namespace, box).generate
+    def self.build_module namespace
+      ModuleBuilder.new(namespace).generate
     end
 
-    # TODO: Make better interface
-    def self.setup_method namespace, classname, lib, modul, klass, method
+    def self.setup_method namespace, classname, method
       go = method_introspection_data namespace, classname, method.to_s
 
-      setup_function_or_method klass, modul, lib, go
+      return false if go.nil?
+      return false if go.type != :function
+
+      klass = build_class namespace, classname
+      modul = build_module namespace
+      lib = modul.const_get(:Lib)
+
+      attach_ffi_function lib, go
+
+      meta = (class << klass; self; end)
+      meta.class_eval function_definition(go, lib)
+
+      true
     end
 
-    # TODO: Make better interface
-    def self.setup_function namespace, lib, modul, method
+    def self.setup_function namespace, method
       go = function_introspection_data namespace, method.to_s
 
-      setup_function_or_method modul, modul, lib, go
+      return false if go.nil?
+      return false if go.type != :function
+
+      modul = build_module namespace
+      lib = modul.const_get(:Lib)
+
+      attach_ffi_function lib, go
+
+      meta = (class << modul; self; end)
+      meta.class_eval function_definition(go, lib)
+
+      true
+    end
+
+    def self.setup_instance_method namespace, classname, method
+      go = method_introspection_data namespace, classname, method.to_s
+
+      return false if go.nil?
+      return false if go.type != :function
+
+      klass = build_class namespace, classname
+      modul = build_module namespace
+      lib = modul.const_get(:Lib)
+
+      attach_ffi_function lib, go
+
+      klass.class_eval "undef #{method}"
+      klass.class_eval function_definition(go, lib)
+
+      true
     end
 
     # All methods below will be made private at the end.
@@ -57,17 +95,17 @@ module GirFFI
       return objectinfo.find_method method
     end
 
-    def self.attach_ffi_function modul, lib, info, box
+    def self.attach_ffi_function lib, info
       sym = info.symbol
-      argtypes = ffi_function_argument_types modul, lib, info, box
-      rt = ffi_function_return_type modul, lib, info, box
+      argtypes = ffi_function_argument_types info
+      rt = ffi_function_return_type info
 
       lib.attach_function sym, argtypes, rt
     end
 
-    def self.ffi_function_argument_types modul, lib, info, box
+    def self.ffi_function_argument_types info
       types = info.args.map do |a|
-	iarginfo_to_ffitype modul, lib, a, box
+	iarginfo_to_ffitype a
       end
       if info.type == :function
 	types.unshift :pointer if info.method?
@@ -75,17 +113,11 @@ module GirFFI
       types
     end
 
-    def self.ffi_function_return_type modul, lib, info, box
-      itypeinfo_to_ffitype modul, lib, info.return_type, box
-    end
-
-    def self.define_ffi_types modul, lib, info, box
-      info.args.each do |arg|
-	type = iarginfo_to_ffitype modul, lib, arg, box
-      end
+    def self.ffi_function_return_type info
+      itypeinfo_to_ffitype info.return_type
     end
 
-    def self.itypeinfo_to_ffitype modul, lib, info, box
+    def self.itypeinfo_to_ffitype info
       if info.pointer?
 	return :string if info.tag == :utf8
 	return :pointer
@@ -95,65 +127,48 @@ module GirFFI
 	interface = info.interface
 	case interface.type
 	when :object, :struct, :flags, :enum
-	  return build_class interface.namespace, interface.name, box
+	  return build_class interface.namespace, interface.name
 	when :callback
-	  return build_callback modul, lib, interface, box
+	  return build_callback interface
 	else
 	  raise NotImplementedError
 	end
       when :boolean
 	return :bool
+      when :GType
+	return :int32
       else
 	return info.tag
       end
     end
 
-    def self.iarginfo_to_ffitype modul, lib, info, box
+    def self.iarginfo_to_ffitype info
       return :pointer if info.direction == :inout
-      return itypeinfo_to_ffitype modul, lib, info.type, box
+      return itypeinfo_to_ffitype info.type
     end
 
-    def self.build_callback modul, lib, interface, box
+    def self.build_callback interface
+      modul = build_module interface.namespace
+      lib = modul.const_get(:Lib)
+
       sym = interface.name.to_sym
 
       # FIXME: Rescue is ugly here.
       ft = lib.find_type sym rescue nil
       if ft.nil?
-	args = ffi_function_argument_types modul, lib, interface, box
-	ret = ffi_function_return_type modul, lib, interface, box
+	args = ffi_function_argument_types interface
+	ret = ffi_function_return_type interface
 	lib.callback sym, args, ret
       end
       sym
     end
 
-    def self.setup_function_or_method klass, modul, lib, go
-      return false if go.nil?
-      return false if go.type != :function
-
-      box = get_box modul
-
-      define_ffi_types modul, lib, go, box
-      attach_ffi_function modul, lib, go, box
-
-      (class << klass; self; end).class_eval function_definition(go, lib)
-      true
-    end
-
-    # TODO: This is a weird way to get back the box.
-    def self.get_box modul
-      name = modul.to_s
-      if name =~ /::/
-	return Kernel.const_get(name.split('::')[0])
-      else
-	return nil
-      end
-    end
-
     # Set up method access.
     (self.public_methods - Module.public_methods).each do |m|
       private_class_method m.to_sym
     end
-    public_class_method :build_module, :build_class, :setup_method, :setup_function, :setup_function_or_method
+    public_class_method :build_module, :build_class
+    public_class_method :setup_method, :setup_function, :setup_instance_method
     public_class_method :itypeinfo_to_ffitype
   end
 end

data/lib/gir_ffi/class_builder.rb

@@ -2,10 +2,9 @@ module GirFFI
   # Builds a class based on information found in the introspection
   # repository.
   class ClassBuilder
-    def initialize namespace, classname, box
+    def initialize namespace, classname
       @namespace = namespace
       @classname = classname
-      @box = box
     end
 
     def generate
@@ -41,14 +40,14 @@ module GirFFI
     def get_superclass
       @parent = @info.type == :object ? @info.parent : nil
       if @parent
-	@superclass = Builder.build_class @parent.namespace, @parent.name, @box
+	@superclass = Builder.build_class @parent.namespace, @parent.name
       else
 	@superclass = GirFFI::Base
       end
     end
 
     def instantiate_module
-      @module = Builder.build_module @namespace, @box
+      @module = Builder.build_module @namespace
       @lib = @module.const_get :Lib
     end
 
@@ -60,23 +59,8 @@ module GirFFI
 
     def setup_class
       setup_method_missing
-      setup_base
       setup_layout
-      setup_constructor
-    end
-
-    def setup_base
-      return if @parent
-      class << @klass
-	self.class_eval { alias_method :_real_new, :new }
-      end
-    end
-
-    def setup_constructor
-      ctor = @info.find_method 'new'
-      if not ctor.nil? and ctor.constructor?
-	Builder.setup_function_or_method @klass, @module, @lib, ctor
-      end
+      alias_instance_methods
     end
 
     def setup_method_missing
@@ -89,7 +73,7 @@ module GirFFI
       @info.fields.each do |f|
 	layoutspec << f.name.to_sym
 
-	ffitype = Builder.itypeinfo_to_ffitype @module, @lib, f.type, @box
+	ffitype = Builder.itypeinfo_to_ffitype f.type
 	if ffitype.kind_of?(Class) and BuilderHelper.const_defined_for ffitype, :Struct
 	  ffitype = ffitype.const_get :Struct
 	end
@@ -101,6 +85,14 @@ module GirFFI
       @structklass.class_eval { layout(*layoutspec) }
     end
 
+    def alias_instance_methods
+      @info.methods.each do |m|
+	@klass.class_eval do
+	  alias_method m.name.to_sym, :_fake_missing
+	end
+      end
+    end
+
     def instance_method_missing_definition
       InstanceMethodMissingDefinitionBuilder.new(@lib, @module, @namespace, @classname).generate
     end

data/lib/gir_ffi/function_definition_builder.rb

@@ -108,6 +108,7 @@ module GirFFI
 
       if tag == :interface
 	interface = type.interface
+	GirFFI::Builder.build_class interface.namespace, interface.name
 	@retvals << "#{interface.namespace}::#{interface.name}._real_new(#{retval})"
       else
 	@retvals << retval

data/lib/gir_ffi/i_base_info.rb

@@ -1,10 +1,14 @@
-require 'gir_ffi/class_base'
-
 module GirFFI
   # Wraps GIBaseInfo struct, the base \type for all info types.
   # Decendant types will be implemented as needed.
   class IBaseInfo
-    include ClassBase
+    def initialize ptr
+      @gobj = ptr
+    end
+
+    def to_ptr
+      @gobj
+    end
 
     # This is a helper method to construct a method returning an array, out
     # of the methods returning their number and the individual elements.

data/lib/gir_ffi/method_missing_definition_builder.rb

@@ -11,13 +11,9 @@ module GirFFI
 
       return <<-CODE
 	def #{slf}method_missing method, *arguments, &block
-	  result = GirFFI::Builder.#{fn} #{args.join ', '}, #{libs.join ', '}, self, method.to_s
+	  result = GirFFI::Builder.#{fn} #{args.join ', '}, method.to_s
 	  return super unless result
-	  if block.nil?
-	    self.send method, *arguments
-	  else
-	    self.send method, *arguments, &block
-	  end
+	  self.send method, *arguments, &block
 	end
       CODE
     end
@@ -46,7 +42,7 @@ module GirFFI
     private
 
     def slf; ""; end
-    def fn; "setup_method"; end
+    def fn; "setup_instance_method"; end
     def arguments; [@namespace, @classname]; end
     def libs; [@lib, @module]; end
   end
@@ -56,6 +52,7 @@ module GirFFI
     private
 
     def slf; "self."; end
+    def fn; "setup_method"; end
   end
 
 end

data/lib/gir_ffi/module_builder.rb

@@ -5,9 +5,8 @@ module GirFFI
   # repository.
   class ModuleBuilder
 
-    def initialize namespace, box
+    def initialize namespace
       @namespace = namespace
-      @box = box
     end
 
     def generate
@@ -28,12 +27,7 @@ module GirFFI
     end
 
     def setup_module
-      if @box.nil?
-	boxm = ::Object
-      else
-	boxm = BuilderHelper.get_or_define_module ::Object, @box.to_s
-      end
-      @module = BuilderHelper.get_or_define_module boxm, @namespace.to_s
+      @module = BuilderHelper.get_or_define_module ::Object, @namespace.to_s
     end
 
     def setup_lib_for_ffi
@@ -53,12 +47,11 @@ module GirFFI
     end
 
     def const_missing_definition
-      box = @box.nil? ? "nil" : "\"#{@box}\""
       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, #{box}
+	  return GirFFI::Builder.build_class "#{@namespace}", classname.to_s
 	end
       CODE
     end

data/lib/gir_ffi/overrides/gtk.rb

@@ -1,4 +1,4 @@
-GirFFI::Builder.setup_function "Gtk", Gtk::Lib, Gtk, "init"
+GirFFI::Builder.setup_function "Gtk", "init"
 module Gtk
   class << self
     alias _base_init init

data/test/base_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+require 'gir_ffi/base'
+
+class BaseTest < Test::Unit::TestCase
+  context "A class derived from GirFFI::Base" do
+    setup do
+      @klass = Class.new(GirFFI::Base) do
+	# Boilerplate to make regular #new work again.
+	def initialize; end
+	def self.new; self._real_new; end
+      end
+    end
+
+    should "be able to use method_name to get the names of its methods" do
+      @klass.class_eval do
+	def this_is_my_name
+	  method_name
+	end
+      end
+      assert_equal "this_is_my_name", @klass.new.this_is_my_name
+    end
+
+    context "its #_fake_missing method" do
+      should "not be missing" do
+	assert @klass.new.respond_to? :_fake_missing
+      end
+
+      should "call method_missing" do
+	@klass.class_eval do
+	  def method_missing method, *args
+	    method
+	  end
+	end
+	assert_equal :_fake_missing, @klass.new._fake_missing
+      end
+
+      should "pass on its arguments" do
+	@klass.class_eval do
+	  def method_missing method, *args
+	    args.join(', ')
+	  end
+	end
+	assert_equal "a, b", @klass.new._fake_missing("a", "b")
+      end
+
+      should "pass on a given block" do
+	@klass.class_eval do
+	  def method_missing method, *args
+	    yield if block_given?
+	  end
+	end
+	assert_equal :called, @klass.new._fake_missing { :called }
+      end
+    end
+
+    should "be able to use alias_method to create a self-defining method" do
+      @klass.class_eval do
+	def method_missing method, *args
+	  self.class.class_eval "
+	    undef #{method}
+	    def #{method}
+	      :redefined
+	    end
+	  "
+	  self.send method
+	end
+	alias_method :new_method, :_fake_missing
+      end
+      assert_equal :redefined, @klass.new.new_method
+    end
+  end
+end

data/test/builder_test.rb

@@ -1,105 +1,105 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-require 'gir_ffi/builder'
+require 'gir_ffi'
 
 class BuilderTest < Test::Unit::TestCase
   context "The GirFFI::Builder module" do
     # TODO: Use gir's sample Everything library for testing instead.
     context "building GObject::Object" do
       setup do
-	GirFFI::Builder.build_class 'GObject', 'Object', 'NS1'
+	cleanup_module :GObject
+	GirFFI::Builder.build_class 'GObject', 'Object'
       end
 
       should "create a method_missing method for the class" do
-	ms = NS1::GObject::Object.instance_methods(false).map(&:to_sym)
+	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'
-	assert_same_elements [*expected], NS1::GObject::Lib.ffi_libraries.map(&:name)
+	assert_same_elements [*expected], GObject::Lib.ffi_libraries.map(&:name)
       end
 
       should "create an array CALLBACKS inside the GObject::Lib module" do
-	assert_equal [], NS1::GObject::Lib::CALLBACKS
+	assert_equal [], GObject::Lib::CALLBACKS
       end
 
       should "not replace existing classes" do
-	oldclass = NS1::GObject::Object
-	GirFFI::Builder.build_class 'GObject', 'Object', 'NS1'
-	assert_equal oldclass, NS1::GObject::Object
+	oldclass = GObject::Object
+	GirFFI::Builder.build_class 'GObject', 'Object'
+	assert_equal oldclass, GObject::Object
       end
     end
 
     context "building Gtk::Window" do
       setup do
-	GirFFI::Builder.build_class 'Gtk', 'Window', 'NS3'
+	cleanup_module :Gtk
+	cleanup_module :GObject
+	GirFFI::Builder.build_class 'Gtk', 'Window'
       end
 
       should "build Gtk namespace" do
-	assert NS3::Gtk.const_defined? :Lib
-	assert NS3::Gtk.respond_to? :method_missing
+	assert Gtk.const_defined? :Lib
+	assert Gtk.respond_to? :method_missing
       end
 
       should "build parent classes also" do
-	assert NS3::Gtk.const_defined? :Widget
-	assert NS3::Gtk.const_defined? :Object
-	assert NS3.const_defined? :GObject
-	assert NS3::GObject.const_defined? :InitiallyUnowned
-	assert NS3::GObject.const_defined? :Object
+	assert Gtk.const_defined? :Widget
+	assert Gtk.const_defined? :Object
+	assert Object.const_defined? :GObject
+	assert GObject.const_defined? :InitiallyUnowned
+	assert GObject.const_defined? :Object
       end
 
       should "set up inheritence chain" do
 	assert_equal [
-	  NS3::Gtk::Window,
-	  NS3::Gtk::Bin,
-	  NS3::Gtk::Container,
-	  NS3::Gtk::Widget,
-	  NS3::Gtk::Object,
-	  NS3::GObject::InitiallyUnowned,
-	  NS3::GObject::Object
-	], NS3::Gtk::Window.ancestors[0..6]
+	  Gtk::Window,
+	  Gtk::Bin,
+	  Gtk::Container,
+	  Gtk::Widget,
+	  Gtk::Object,
+	  GObject::InitiallyUnowned,
+	  GObject::Object
+	], Gtk::Window.ancestors[0..6]
       end
 
       should "create a Gtk::Window#to_ptr method" do
-	assert_contains NS3::Gtk::Window.instance_methods.map(&:to_sym), :to_ptr
-      end
-
-      should "attach gtk_window_new to Gtk::Lib" do
-	assert NS3::Gtk::Lib.respond_to? :gtk_window_new
+	assert_contains Gtk::Window.instance_methods.map(&:to_sym), :to_ptr
       end
 
       should "result in Gtk::Window.new to succeed" do
-	assert_nothing_raised {NS3::Gtk::Window.new(:toplevel)}
+	assert_nothing_raised {Gtk::Window.new(:toplevel)}
       end
     end
 
     context "building Gtk" do
       setup do
-	GirFFI::Builder.build_module 'Gtk', 'NS2'
+	cleanup_module :Gtk
+	GirFFI::Builder.build_module 'Gtk'
       end
 
       should "create a Lib module ready to attach functions from gtk-x11-2.0" do
 	# The Gtk module has more than one library on my current machine.
 	gir = GirFFI::IRepository.default
 	expected = (gir.shared_library 'Gtk').split(',')
-	assert_same_elements expected, NS2::Gtk::Lib.ffi_libraries.map(&:name)
+	assert_same_elements expected, Gtk::Lib.ffi_libraries.map(&:name)
       end
 
       should "create an array CALLBACKS inside the Gtk::Lib module" do
-	assert_equal [], NS2::Gtk::Lib::CALLBACKS
+	assert_equal [], Gtk::Lib::CALLBACKS
       end
 
       should "not replace existing module" do
-	oldmodule = NS2::Gtk
-	GirFFI::Builder.build_module 'Gtk', 'NS2'
-	assert_equal oldmodule, NS2::Gtk
+	oldmodule = Gtk
+	GirFFI::Builder.build_module 'Gtk'
+	assert_equal oldmodule, Gtk
       end
 
       should "not replace existing Lib module" do
-	oldmodule = NS2::Gtk::Lib
-	GirFFI::Builder.build_module 'Gtk', 'NS2'
-	assert_equal oldmodule, NS2::Gtk::Lib
+	oldmodule = Gtk::Lib
+	GirFFI::Builder.build_module 'Gtk'
+	assert_equal oldmodule, Gtk::Lib
       end
     end
 
@@ -131,7 +131,7 @@ class BuilderTest < Test::Unit::TestCase
 	  ffi_lib "gtk-x11-2.0"
 	end
 
-	GirFFI::Builder.send :attach_ffi_function, mod, libmod, @go, nil
+	GirFFI::Builder.send :attach_ffi_function, libmod, @go
 	assert_contains libmod.public_methods.map(&:to_sym), :gtk_main
       end
     end
@@ -151,11 +151,11 @@ class BuilderTest < Test::Unit::TestCase
       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.
-	assert_equal [:pointer, :pointer], GirFFI::Builder.send(:ffi_function_argument_types, Gtk, Gtk::Lib, @go, nil)
+	assert_equal [:pointer, :pointer], GirFFI::Builder.send(:ffi_function_argument_types, @go)
       end
 
       should "have :void as return type for the attached function" do
-	assert_equal :void, GirFFI::Builder.send(:ffi_function_return_type, Gtk, Gtk::Lib, @go, nil)
+	assert_equal :void, GirFFI::Builder.send(:ffi_function_return_type, @go)
       end
     end
 
@@ -171,14 +171,15 @@ class BuilderTest < Test::Unit::TestCase
       end
 
       should "have :pointer as types of the arguments for the attached function" do
-	assert_equal [:pointer], GirFFI::Builder.send(:ffi_function_argument_types, Gtk, Gtk::Lib, @go, nil)
+	assert_equal [:pointer], GirFFI::Builder.send(:ffi_function_argument_types, @go)
       end
 
     end
 
     context "looking at GObject.signal_connect_data" do
       setup do
-	GirFFI::Builder.build_module 'GObject', 'NS5'
+	cleanup_module :GObject
+	GirFFI::Builder.build_module 'GObject'
 	@go = get_function_introspection_data 'GObject', 'signal_connect_data'
       end
 
@@ -189,14 +190,14 @@ class BuilderTest < Test::Unit::TestCase
       end
 
       should "have the correct types of the arguments for the attached function" do
-	assert_equal [:pointer, :string, :Callback, :pointer, :ClosureNotify, NS5::GObject::ConnectFlags],
-	  GirFFI::Builder.send(:ffi_function_argument_types, NS5::GObject, NS5::GObject::Lib, @go, 'NS5')
+	assert_equal [:pointer, :string, :Callback, :pointer, :ClosureNotify, GObject::ConnectFlags],
+	  GirFFI::Builder.send(:ffi_function_argument_types, @go)
       end
 
       should "define ffi callback types :Callback and :ClosureNotify" do
-	GirFFI::Builder.setup_function 'GObject', NS5::GObject::Lib, NS5::GObject, 'signal_connect_data'
-	cb = NS5::GObject::Lib.find_type :Callback
-	cn = NS5::GObject::Lib.find_type :ClosureNotify
+	GirFFI::Builder.setup_function 'GObject', 'signal_connect_data'
+	cb = GObject::Lib.find_type :Callback
+	cn = GObject::Lib.find_type :ClosureNotify
 
 	assert_equal FFI.find_type(:void), cb.result_type
 	assert_equal FFI.find_type(:void), cn.result_type
@@ -205,7 +206,7 @@ class BuilderTest < Test::Unit::TestCase
       end
 
       should "define ffi enum type ConnectFlags" do
-	assert_equal({:after => 1, :swapped => 2}, NS5::GObject::ConnectFlags.to_h)
+	assert_equal({:after => 1, :swapped => 2}, GObject::ConnectFlags.to_h)
       end
     end
 
@@ -240,88 +241,81 @@ class BuilderTest < Test::Unit::TestCase
       should "set up #_real_new as an alias to #new" do
 	assert Everything::TestBoxed.respond_to? "_real_new"
       end
+    end
 
-      should "allow creation using #new" do
-	tb = Everything::TestBoxed.new
-	assert_instance_of Everything::TestBoxed, tb
-      end
-
-      should "allow creation using alternative constructors" do
-	tb = Everything::TestBoxed.new_alternative_constructor1 1
-	assert_instance_of Everything::TestBoxed, tb
-	assert_equal 1, tb[:some_int8]
-
-	tb = Everything::TestBoxed.new_alternative_constructor2 1, 2
-	assert_instance_of Everything::TestBoxed, tb
-	assert_equal 1 + 2, tb[:some_int8]
+    # TODO: Should not allow functions to be called as methods, etc.
 
-	tb = Everything::TestBoxed.new_alternative_constructor3 "54"
-	assert_instance_of Everything::TestBoxed, tb
-	assert_equal 54, tb[:some_int8]
+    context "building the Everything module" do
+      setup do
+	cleanup_module :Everything
+	GirFFI::Builder.build_module 'Everything'
       end
 
-      should "make the equals method work" do
-	tb = Everything::TestBoxed.new_alternative_constructor1 123
-	tb2 = Everything::TestBoxed.new_alternative_constructor2 120, 3
-	assert_equal true, tb.equals(tb2)
+      should "create a method_missing method for the module" do
+	ms = (Everything.public_methods - Module.public_methods).map(&:to_sym)
+	assert_contains ms, :method_missing
       end
 
-      should "make the copy method work" do
-	tb = Everything::TestBoxed.new_alternative_constructor1 123
-	tb2 = tb.copy
-	assert_instance_of Everything::TestBoxed, tb2
-	assert_equal 123, tb2[:some_int8], "fields copied"
-	tb2[:some_int8] = 89
-	assert_equal 123, tb[:some_int8], "is a true copy"
+      should "cause the TestObj class to be autocreated" do
+	assert !Everything.const_defined?(:TestObj)
+	assert_nothing_raised {Everything::TestObj}
+	assert Everything.const_defined? :TestObj
       end
     end
 
-    context "building Everything::TestEnum" do
+    # TODO: Turn this into full test of instance method creation, including
+    # inheritance issues.
+    context "built Everything::TestObj" do
       setup do
-	GirFFI::Builder.build_class 'Everything', 'TestEnum'
+	cleanup_module :Everything
+	GirFFI::Builder.build_class 'Everything', 'TestObj'
       end
-      should "create an object of type FFI::Enum" do
-	assert_instance_of FFI::Enum, Everything::TestEnum
-      end
-    end
-
-    # TODO: Should not allow functions to be called as methods, etc.
 
-    context "looking at Everything's functions" do
-      setup do
-	GirFFI::Builder.build_module 'Everything'
+      should "make autocreated instance method available to all instances" do
+	o1 = Everything::TestObj.new_from_file("foo")
+	o2 = Everything::TestObj.new_from_file("foo")
+	o1.instance_method
+	Everything::TestObj.class_eval do
+	  undef method_missing
+	end
+	assert_nothing_raised { o2.instance_method }
       end
 
-      should "correctly handle test_boolean" do
-	assert_equal false, Everything.test_boolean(false)
-	assert_equal true, Everything.test_boolean(true)
+      should "attach C functions to Everything::Lib" do
+	o = Everything::TestObj.new_from_file("foo")
+	o.instance_method
+	assert Everything::Lib.respond_to? :test_obj_instance_method
       end
 
-      should "correctly handle test_callback_user_data" do
-	a = :foo
-	result = Everything.test_callback_user_data Proc.new {|u|
-	  a = u
-	  5
-	}, :bar
-	assert_equal :bar, a
-	assert_equal 5, result
+      should "not have regular #new as a constructor" do
+	assert_raises(NoMethodError) { Everything::TestObj.new }
       end
     end
 
-    context "building the Everything module" do
+    context "built Everything::TestSubObj" do
       setup do
-	GirFFI::Builder.build_module 'Everything', 'NS4'
+	cleanup_module :Everything
+	GirFFI::Builder.build_class 'Everything', 'TestSubObj'
       end
 
-      should "create a method_missing method for the module" do
-	ms = (NS4::Everything.public_methods - Module.public_methods).map(&:to_sym)
-	assert_contains ms, :method_missing
+      should "autocreate parent class' set_bare inside the parent class" do
+	o1 = Everything::TestSubObj.new
+	o2 = Everything::TestObj.new_from_file("foo")
+
+	assert_nothing_raised {o1.set_bare(nil)}
+
+	Everything::TestObj.class_eval do
+	  undef method_missing
+	end
+
+	assert_nothing_raised {o2.set_bare(nil)}
       end
 
-      should "cause the TestObj class to be autocreated" do
-	assert !NS4::Everything.const_defined?(:TestObj)
-	assert_nothing_raised {NS4::Everything::TestObj}
-	assert NS4::Everything.const_defined? :TestObj
+      should "use its own version of instance_method when parent's version has been created" do
+	obj = Everything::TestObj.new_from_file("foo")
+	assert_equal(-1, obj.instance_method)
+	subobj = Everything::TestSubObj.new
+	assert_equal 0, subobj.instance_method
       end
     end
   end

data/test/constructor_definition_builder_test.rb

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

data/test/everything_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('test_helper.rb', File.dirname(__FILE__))
+require 'gir_ffi'
+
+GirFFI.setup :Everything
+
+# Tests generated methods and functions in the Everything namespace.
+class EverythingTest < Test::Unit::TestCase
+  context "The generated Everything module" do
+    should "have correct test_boolean" do
+      assert_equal false, Everything.test_boolean(false)
+      assert_equal true, Everything.test_boolean(true)
+    end
+
+    should "have correct test_callback_user_data" do
+      a = :foo
+      result = Everything.test_callback_user_data Proc.new {|u|
+	a = u
+	5
+      }, :bar
+      assert_equal :bar, a
+      assert_equal 5, result
+    end
+
+    should "have correct test_gtype" do
+      result = Everything.test_gtype 23
+      assert_equal 23, result
+    end
+
+    should "have correct test_value_return" do
+      result = Everything.test_value_return 3423
+      assert_equal 3423, result.get_int
+    end
+
+    context "the Everything::TestBoxed class" do
+      should "create an instance using #new" do
+	tb = Everything::TestBoxed.new
+	assert_instance_of Everything::TestBoxed, tb
+      end
+
+      should "allow creating an instance using alternative constructors" do
+	tb = Everything::TestBoxed.new_alternative_constructor1 1
+	assert_instance_of Everything::TestBoxed, tb
+	assert_equal 1, tb[:some_int8]
+
+	tb = Everything::TestBoxed.new_alternative_constructor2 1, 2
+	assert_instance_of Everything::TestBoxed, tb
+	assert_equal 1 + 2, tb[:some_int8]
+
+	tb = Everything::TestBoxed.new_alternative_constructor3 "54"
+	assert_instance_of Everything::TestBoxed, tb
+	assert_equal 54, tb[:some_int8]
+      end
+
+      should "have a working equals method" do
+	tb = Everything::TestBoxed.new_alternative_constructor1 123
+	tb2 = Everything::TestBoxed.new_alternative_constructor2 120, 3
+	assert_equal true, tb.equals(tb2)
+      end
+
+      should "have a working copy method" do
+	tb = Everything::TestBoxed.new_alternative_constructor1 123
+	tb2 = tb.copy
+	assert_instance_of Everything::TestBoxed, tb2
+	assert_equal 123, tb2[:some_int8], "fields copied"
+	tb2[:some_int8] = 89
+	assert_equal 123, tb[:some_int8], "is a true copy"
+      end
+    end
+
+    context "the Everything::TestEnum type" do
+      should "be of type FFI::Enum" do
+	assert_instance_of FFI::Enum, Everything::TestEnum
+      end
+    end
+
+  end
+
+end

data/test/function_definition_builder_test.rb

@@ -1,6 +1,5 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-require 'gir_ffi/builder'
-require 'gir_ffi/function_definition_builder'
+require 'gir_ffi'
 
 class FunctionDefinitionBuilderTest < Test::Unit::TestCase
   context "The FunctionDefinition builder" do

data/test/gtk_overrides_test.rb

@@ -1,13 +1,18 @@
 require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 require 'gir_ffi'
-GirFFI.setup :Gtk
 
 class GtkOverridesTest < Test::Unit::TestCase
   context "The Gtk.init function" do
+    setup do
+      cleanup_module :Gtk
+      GirFFI.setup :Gtk
+    end
+
     should "not take any arguments" do
       assert_raises(ArgumentError) { Gtk.init 1, ["foo"] }
       assert_nothing_raised { Gtk.init }
     end
+
     # FIXME: The following test doesn't actually work.
     # In practice however, the Gtk.init function does exactly this.
     if false

data/test/test_helper.rb

@@ -36,4 +36,10 @@ class Test::Unit::TestCase
     GirFFI::IRepository.default.require namespace, nil
     GirFFI::Builder.send :method_introspection_data, namespace, klass, function
   end
+
+  def cleanup_module name
+    if Object.const_defined? name
+      Object.send(:remove_const, name)
+    end
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gir_ffi
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Matijs van Zuijlen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-25 00:00:00 +02:00
+date: 2010-11-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -84,7 +84,6 @@ files:
 - lib/gir_ffi/i_repository.rb
 - lib/gir_ffi/i_vfunc_info.rb
 - lib/gir_ffi/i_constant_info.rb
-- lib/gir_ffi/class_base.rb
 - lib/gir_ffi/i_struct_info.rb
 - lib/gir_ffi/i_callable_info.rb
 - lib/gir_ffi/function_definition_builder.rb
@@ -108,6 +107,8 @@ files:
 - test/test_helper.rb
 - test/girffi_test.rb
 - test/constructor_definition_builder_test.rb
+- test/base_test.rb
+- test/everything_test.rb
 - test/builder_test.rb
 - test/gtk_overrides_test.rb
 - tasks/bones.rake
@@ -164,8 +165,10 @@ specification_version: 3
 summary: Ruby-FFI-based binding of the GObject Introspection Repository
 test_files: 
 - test/arg_helper_test.rb
+- test/base_test.rb
 - test/builder_test.rb
 - test/constructor_definition_builder_test.rb
+- test/everything_test.rb
 - test/function_definition_builder_test.rb
 - test/g_type_test.rb
 - test/girffi_test.rb

data/lib/gir_ffi/class_base.rb

@@ -1,11 +0,0 @@
-module GirFFI
-  # Provides methods needed by all generated classes
-  module ClassBase
-    def initialize ptr
-      @gobj = ptr
-    end
-    def to_ptr
-      @gobj
-    end
-  end
-end