gir_ffi 0.0.4 → 0.0.5

data/History.txt

@@ -1,3 +1,12 @@
+== 0.0.5 / 2010-12-30
+
+* Don't create instance methods out of functions and vice versa.
+* Find signals on interfaces, too.
+* Implement tests for most of Everything.
+* Correctly handle array + size arguments.
+* Handle most other argument types.
+* Various internal changes and other fixes.
+
 == 0.0.4 / 2010-12-14
 
 * Lots of changes to the internals.

data/Rakefile

@@ -1,21 +1,3 @@
-# Look in the tasks/setup.rb file for the various options that can be
-# configured in this Rakefile. The .rake files in the tasks directory
-# are where the options are used.
-
 load 'tasks/setup.rb'
 
-ensure_in_path 'lib'
-require 'gir_ffi'
-
 task :default => 'test:run'
-
-PROJ.name = 'gir_ffi'
-PROJ.authors = 'Matijs van Zuijlen'
-PROJ.email = 'matijs@matijs.net'
-PROJ.url = 'http://www.github.com/mvz/ruby-gir-ffi'
-PROJ.version = GirFFI::VERSION
-PROJ.readme_file = 'README.rdoc'
-
-PROJ.exclude << ["^tmp/", "\\.swp$", "^\\.gitignore$", "^\\.autotest$"]
-
-# EOF

data/TODO.rdoc

@@ -21,7 +21,7 @@ distinguished, based on the GIR data, from methods that take a pointer to
 any GObject.
 
 I'm currently passing the object id as the value of the 'gpointer'. Special
-overrided will have to be used for the cases where the 'gpointer' actually
+overrides will have to be used for the cases where the 'gpointer' actually
 needs to be a GObject. I consider it an omission in GIRepository that these
 two cases are not distinguished.
 

data/lib/gir_ffi/arg_helper.rb

@@ -8,68 +8,179 @@ module GirFFI
       FFI::Pointer.new(obj.object_id)
     end
 
+    def self.typed_array_to_inptr type, ary
+      return nil if ary.nil?
+      block = allocate_array_of_type type, ary.length
+      block.send "put_array_of_#{type}", 0, ary
+    end
+
+    def self.int32_array_to_inptr ary
+      typed_array_to_inptr :int32, ary
+    end
+
+    # TODO: Use alias.
+    def self.int_array_to_inptr ary
+      int32_array_to_inptr ary
+    end
+
+    def self.int16_array_to_inptr ary
+      typed_array_to_inptr :int16, ary
+    end
+
+    def self.int64_array_to_inptr ary
+      typed_array_to_inptr :int64, ary
+    end
+
+    def self.int8_array_to_inptr ary
+      typed_array_to_inptr :int8, ary
+    end
+
+    def self.utf8_to_inptr str
+      return nil if str.nil?
+      len = str.bytesize
+      AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
+    end
+
+    def self.GType_array_to_inptr ary
+      case FFI.type_size(:size_t)
+      when 4
+	int32_array_to_inptr ary
+      when 8
+	int64_array_to_inptr ary
+      else
+	raise RuntimeError, "Unexpected size of :size_t"
+      end
+    end
+
+    def self.cleanup_ptr ptr
+      LibC.free ptr
+    end
+
+    def self.cleanup_ptr_ptr ptr
+      block = ptr.read_pointer
+      LibC.free ptr
+      LibC.free block
+    end
+
+    # Takes an outptr to a pointer array, and frees all pointers.
+    def self.cleanup_ptr_array_ptr ptr, size
+      return if ptr.nil?
+
+      block = ptr.read_pointer
+      LibC.free ptr
+
+      return if block.null?
+
+      ptrs = block.read_array_of_pointer(size)
+      LibC.free block
+
+      ptrs.map do |p|
+	LibC.free p unless p.null?
+      end
+    end
+
     def self.int_to_inoutptr val
-      ptr = AllocationHelper.safe_malloc FFI.type_size(:int)
-      ptr.write_int val
-      return ptr
+      int_pointer.write_int val
+    end
+
+    def self.utf8_to_inoutptr str
+      sptr = utf8_to_inptr str
+      pointer_pointer.write_pointer sptr
     end
 
-    def self.string_array_to_inoutptr ary
+    def self.int_array_to_inoutptr ary
+      block = int_array_to_inptr ary
+      pointer_pointer.write_pointer block
+    end
+
+    def self.utf8_array_to_inoutptr ary
       return nil if ary.nil?
 
-      ptrs = ary.map {|str|
-	len = str.bytesize
-	AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
-      }
+      ptrs = ary.map {|str| utf8_to_inptr str}
 
-      ptr_size = FFI.type_size(:pointer)
-      block = AllocationHelper.safe_malloc ptr_size * ptrs.length
+      block = AllocationHelper.safe_malloc FFI.type_size(:pointer) * ptrs.length
       block.write_array_of_pointer ptrs
 
-      argv = AllocationHelper.safe_malloc ptr_size
-      argv.write_pointer block
-      argv
+      pointer_pointer.write_pointer block
     end
 
     def self.double_to_inoutptr val
-      ptr = AllocationHelper.safe_malloc FFI.type_size(:double)
-      ptr.put_double 0, val
-      return ptr
+      double_pointer.put_double 0, val
+    end
+
+    def self.int_pointer
+      AllocationHelper.safe_malloc FFI.type_size(:int)
+    end
+
+    def self.double_pointer
+      AllocationHelper.safe_malloc FFI.type_size(:double)
+    end
+
+    def self.pointer_pointer
+      AllocationHelper.safe_malloc FFI.type_size(:pointer)
+    end
+
+    def self.int_outptr
+      int_pointer.write_int 0
     end
 
-    # Converts an outptr to an int, then frees the outptr.
+    def self.double_outptr
+      double_pointer.write_double 0.0
+    end
+
+    def self.pointer_outptr
+      pointer_pointer.write_pointer nil
+    end
+
+    def self.utf8_outptr
+      pointer_outptr
+    end
+
+    # Converts an outptr to a pointer.
+    def self.outptr_to_pointer ptr
+      ptr.read_pointer
+    end
+
+    # Converts an outptr to an int.
     def self.outptr_to_int ptr
-      value = ptr.read_int
-      LibC.free ptr
-      value
+      ptr.read_int
     end
 
-    # Converts an outptr to a string array, then frees pointers.
-    def self.outptr_to_string_array ptr, size
+    # Converts an outptr to a string.
+    def self.outptr_to_utf8 ptr
       return nil if ptr.nil?
+      sptr = ptr.read_pointer
 
-      block = ptr.read_pointer
-      LibC.free ptr
+      sptr.null? ? nil : sptr.read_string
+    end
 
+    # Converts an outptr to a string array.
+    def self.outptr_to_utf8_array ptr, size
+      return nil if ptr.nil?
+      block = ptr.read_pointer
       return nil if block.null?
-
       ptrs = block.read_array_of_pointer(size)
-      LibC.free block
 
       ptrs.map do |p|
-	if p.null?
-	  nil
-	else
-	  p.read_string.tap { LibC.free p }
-	end
+	p.null? ? nil : p.read_string
       end
     end
 
-    # Converts an outptr to a double, then frees the outptr.
+    # Converts an outptr to a double.
     def self.outptr_to_double ptr
-      value = ptr.get_double 0
-      LibC.free ptr
-      value
+      ptr.get_double 0
+    end
+
+    # Converts an outptr to an array of int.
+    def self.outptr_to_int_array ptr, size
+      return nil if ptr.null?
+      block = ptr.read_pointer
+      return nil if block.null?
+      ptr_to_int_array block, size
+    end
+
+    def self.ptr_to_int_array ptr, size
+      ptr.read_array_of_int(size)
     end
 
     def self.mapped_callback_args prc=nil, &block
@@ -104,5 +215,24 @@ module GirFFI
 	GirFFI::GObject.object_ref_sink(gobject)
       end
     end
+
+    def self.check_fixed_array_size size, arr, name
+      unless arr.size == size
+	raise ArgumentError, "#{name} should have size #{size}"
+      end
+    end
+
+    def self.allocate_array_of_type type, length
+      AllocationHelper.safe_malloc FFI.type_size(type) * length
+    end
+
+    # FIXME: Quasi-circular dependency on generated module
+    def self.object_pointer_to_object optr
+      tp = ::GObject.type_from_instance_pointer optr
+      gir = GirFFI::IRepository.default
+      info = gir.find_by_gtype tp
+      klass = GirFFI::Builder.build_class info.namespace, info.name
+      klass.wrap optr
+    end
   end
 end

data/lib/gir_ffi/builder.rb

@@ -31,7 +31,8 @@ module GirFFI
 
     def self.ffi_function_argument_types info
       types = info.args.map do |a|
-	iarginfo_to_ffitype a
+	tp = iarginfo_to_ffitype a
+	tp == :string ? :pointer : tp
       end
       if info.type == :function
 	types.unshift :pointer if info.method?
@@ -65,8 +66,8 @@ module GirFFI
 	end
       when :boolean
 	return :bool
-      when :GType
-	return :int32
+      when :GType, :size
+	return :size_t
       else
 	return tag
       end

data/lib/gir_ffi/class_base.rb

@@ -7,7 +7,6 @@ module GirFFI
     def_delegators :@struct, :[], :[]=, :to_ptr
 
     def initialize(*args)
-      # TODO: Handle NULL pointer.
       @struct = ffi_structure.new(*args)
     end
 
@@ -19,13 +18,13 @@ module GirFFI
       self.class.gir_ffi_builder
     end
 
-    def method_missing method, *arguments, &block
+    def setup_and_call method, *arguments, &block
       result = gir_ffi_builder.setup_instance_method method.to_s
       return super unless result
       self.send method, *arguments, &block
     end
 
-    def self.method_missing method, *arguments, &block
+    def self.setup_and_call method, *arguments, &block
       result = gir_ffi_builder.setup_method method.to_s
       return super unless result
       self.send method, *arguments, &block
@@ -46,6 +45,15 @@ module GirFFI
 
       alias_method :_real_new, :new
       undef new
+
+      def wrap ptr
+	return nil if ptr.nil? or ptr.null?
+	_real_new ptr
+      end
+
+      def allocate
+	_real_new
+      end
     end
   end
 end

data/lib/gir_ffi/class_builder.rb

@@ -14,21 +14,18 @@ module GirFFI
     end
 
     def setup_method method
-      definition = prepare_method method.to_s
-
-      return false if definition.nil?
-
       klass = build_class
       meta = (class << klass; self; end)
-      meta.class_eval definition
 
-      true
+      go = method_introspection_data method
+      return attach_and_define_method method, go, meta
     end
 
     def setup_instance_method method
-      definition = prepare_method method.to_s
+      go = instance_method_introspection_data method
+      result = attach_and_define_method method, go, build_class
 
-      if definition.nil?
+      unless result
 	if parent
 	  return superclass.gir_ffi_builder.setup_instance_method method
 	else
@@ -36,10 +33,6 @@ module GirFFI
 	end
       end
 
-      klass = build_class
-      klass.class_eval "undef #{method}"
-      klass.class_eval definition
-
       true
     end
 
@@ -47,6 +40,13 @@ module GirFFI
       info.signals.each do |s|
 	return s if s.name == signal_name
       end
+      if info.type == :object
+	info.interfaces.each do |i|
+	  i.signals.each do |s|
+	    return s if s.name == signal_name
+	  end
+	end
+      end
       if info.parent
 	return superclass.gir_ffi_builder.find_signal signal_name
       end
@@ -58,16 +58,11 @@ module GirFFI
       unless defined? @klass
 	case info.type
 	  when :object, :struct
-	    instantiate_class
-	    setup_class unless already_set_up
+	    instantiate_struct_class
 	  when :union
 	    instantiate_union_class
-	    setup_class unless already_set_up
 	  when :enum, :flags
-	    @klass = optionally_define_constant namespace_module, @classname do
-	      vals = info.values.map {|v| [v.name.to_sym, v.value]}.flatten
-	      lib.enum(@classname.to_sym, vals)
-	    end
+	    instantiate_enum_class
 	  else
 	    raise NotImplementedError, "Cannot build classes of type #{info.type}"
 	end
@@ -109,20 +104,29 @@ module GirFFI
       @lib ||= namespace_module.const_get :Lib
     end
 
-    def instantiate_class
+    def instantiate_struct_class
       @klass = get_or_define_class namespace_module, @classname, superclass
       @structklass = get_or_define_class @klass, :Struct, FFI::Struct
+      setup_class unless already_set_up
     end
 
     def instantiate_union_class
       @klass = get_or_define_class namespace_module, @classname, superclass
       @structklass = get_or_define_class @klass, :Struct, FFI::Union
+      setup_class unless already_set_up
+    end
+
+    def instantiate_enum_class
+      @klass = optionally_define_constant namespace_module, @classname do
+	vals = info.values.map {|v| [v.name.to_sym, v.value]}.flatten
+	lib.enum(@classname.to_sym, vals)
+      end
     end
 
     def setup_class
       setup_layout
       setup_constants
-      setup_instance_methods
+      stub_methods
       setup_gtype_getter
 
       setup_vfunc_invokers if info.type == :object
@@ -140,6 +144,8 @@ module GirFFI
       if fields.empty?
 	if parent
 	  return [:parent, superclass.const_get(:Struct), 0]
+	else
+	  return [:dummy, :char, 0]
 	end
       end
 
@@ -161,20 +167,24 @@ module GirFFI
       ffitype
     end
 
-    def setup_instance_methods
+    def stub_methods
       info.methods.each do |m|
-	@klass.class_eval "
-	  def #{m.name} *args, &block
-	    method_missing :#{m.name}, *args, &block
-	  end
-	"
+	@klass.class_eval method_stub(m.method? ? m.name : "self.#{m.name}", m.name)
       end
     end
 
+    def method_stub name, symbol
+      "
+	def #{name} *args, &block
+	  setup_and_call :#{symbol}, *args, &block
+	end
+      "
+    end
+
     def setup_gtype_getter
       getter = info.type_init
       return if getter.nil? or getter == "intern"
-      lib.attach_function getter.to_sym, [], :int
+      lib.attach_function getter.to_sym, [], :size_t
       @klass.class_eval "
 	def self.get_gtype
 	  ::#{lib}.#{getter}
@@ -200,7 +210,7 @@ module GirFFI
       return if info.find_method 'new'
 
       (class << @klass; self; end).class_eval {
-	alias_method :new, :_real_new
+	alias_method :new, :allocate
       }
     end
 
@@ -217,17 +227,21 @@ module GirFFI
       info.find_method method
     end
 
+    def instance_method_introspection_data method
+      m = method_introspection_data method
+      return !m.nil? && m.method? ? m : nil
+    end
+
     def function_definition go
       FunctionDefinitionBuilder.new(go, lib).generate
     end
 
-    def prepare_method method
-      go = method_introspection_data method
-
-      return nil if go.nil?
-
+    def attach_and_define_method method, go, modul
+      return false if go.nil?
       Builder.attach_ffi_function lib, go
-      function_definition go
+      modul.class_eval { remove_method method }
+      modul.class_eval function_definition(go)
+      true
     end
 
     def gir