gir_ffi 0.2.2 → 0.2.3

data/lib/gir_ffi/builder/type/with_methods.rb

@@ -1,3 +1,5 @@
+require 'gir_ffi/method_stubber'
+
 module GirFFI
   module Builder
     module Type
@@ -15,6 +17,10 @@ module GirFFI
           attach_and_define_method method, go, build_class
         end
 
+        def has_instance_method method
+          !!instance_method_introspection_data(method)
+        end
+
         private
 
         def meta_class
@@ -28,7 +34,7 @@ module GirFFI
 
         def instance_method_introspection_data method
           data = method_introspection_data method
-          return !data.nil? && data.method? ? data : nil
+          return data if data && data.method?
         end
 
         def function_definition_builder go
@@ -43,24 +49,16 @@ module GirFFI
           return false if go.nil?
           Builder.attach_ffi_function lib, go
           modul.class_eval { remove_method method }
-          modul.class_eval function_definition(go)
+          build_class.class_eval function_definition(go)
           true
         end
 
         def stub_methods
           info.get_methods.each do |minfo|
-            @klass.class_eval method_stub(minfo.name, minfo.method?)
+            @klass.class_eval MethodStubber.new(minfo).method_stub
           end
         end
 
-        def method_stub symbol, is_instance_method
-          "
-            def #{is_instance_method ? '' : 'self.'}#{symbol} *args, &block
-              setup_and_call :#{symbol}, *args, &block
-            end
-          "
-        end
-
         def pretty_print_methods
           info.get_methods.map do |minfo|
             function_definition_builder(minfo).pretty_print.indent + "\n"

data/lib/gir_ffi/class_base.rb

@@ -1,4 +1,6 @@
 require 'forwardable'
+require 'gir_ffi/ffi_ext/pointer'
+
 module GirFFI
   # Base class for all generated classes. Contains code for dealing with
   # the generated Struct classes.
@@ -20,16 +22,28 @@ module GirFFI
     end
 
     def setup_and_call method, *arguments, &block
-      unless _builder.setup_instance_method method.to_s
+      result = self.class.ancestors.any? do |klass|
+        klass.respond_to?(:_setup_instance_method) &&
+          klass._setup_instance_method(method.to_s)
+      end
+
+      unless result
         raise RuntimeError, "Unable to set up instance method #{method} in #{self}"
       end
+
       self.send method, *arguments, &block
     end
 
     def self.setup_and_call method, *arguments, &block
-      unless _builder.setup_method method.to_s
+      result = self.ancestors.any? do |klass|
+        klass.respond_to?(:_setup_method) &&
+          klass._setup_method(method.to_s)
+      end
+
+      unless result
         raise RuntimeError, "Unable to set up method #{method} in #{self}"
       end
+
       self.send method, *arguments, &block
     end
 
@@ -67,10 +81,7 @@ module GirFFI
 
       def wrap ptr
 	return nil if ptr.nil? or ptr.null?
-        unless ptr.is_a? FFI::Pointer
-          ptr = ptr.to_ptr
-        end
-	_real_new ptr
+	_real_new ptr.to_ptr
       end
 
       # TODO: Only makes sense for :objects.
@@ -81,6 +92,13 @@ module GirFFI
       def allocate
 	_real_new
       end
+
+      # Pass-through casting method. This may become a type checking
+      # method. It is overridden by GValue to implement wrapping of plain
+      # Ruby objects.
+      def from val
+        val
+      end
     end
   end
 end

data/lib/gir_ffi/ffi_ext/pointer.rb

@@ -0,0 +1,15 @@
+module GirFFI
+  module FFIExt
+    module Pointer
+      def to_ptr
+        self
+      end
+
+      def to_value
+        self
+      end
+    end
+  end
+end
+
+FFI::Pointer.send :include, GirFFI::FFIExt::Pointer

data/lib/gir_ffi/in_pointer.rb

@@ -8,11 +8,7 @@ module GirFFI
       return from_utf8_array ary if type == :utf8
       return from_interface_pointer_array ary if type == :interface_pointer
 
-      ffi_type = TypeMap.map_basic_type type
-      block = ArgHelper.allocate_array_of_type ffi_type, ary.length
-      block.send "put_array_of_#{ffi_type}", 0, ary
-
-      self.new block
+      return from_basic_type_array type, ary
     end
 
     def self.from type, val
@@ -48,6 +44,15 @@ module GirFFI
         ptr = AllocationHelper.safe_malloc(len + 1).write_string(str).put_char(len, 0)
         self.new ptr
       end
+
+      def from_basic_type_array type, ary
+        ffi_type = TypeMap.map_basic_type type
+        block = ArgHelper.allocate_array_of_type ffi_type, ary.length
+        block.send "put_array_of_#{ffi_type}", 0, ary
+
+        self.new block
+      end
+
     end
   end
 end

data/lib/gir_ffi/info_ext/i_field_info.rb

@@ -0,0 +1,15 @@
+require 'gir_ffi/info_ext/i_type_info'
+
+module GirFFI
+  module InfoExt
+    module IFieldInfo
+      def layout_specification
+        [ name.to_sym,
+          field_type.layout_specification_type,
+          offset ]
+      end
+    end
+  end
+end
+
+GObjectIntrospection::IFieldInfo.send :include, GirFFI::InfoExt::IFieldInfo

data/lib/gir_ffi/info_ext/i_type_info.rb

@@ -0,0 +1,26 @@
+require 'gir_ffi/builder_helper'
+
+module GirFFI
+  module InfoExt
+    module ITypeInfo
+      include BuilderHelper
+
+      def layout_specification_type
+        ffitype = GirFFI::Builder.itypeinfo_to_ffitype self
+        case ffitype
+        when Class
+          ffitype.const_get :Struct
+        when :bool
+          :int
+        when :array
+          subtype = param_type(0).layout_specification_type
+          [subtype, array_fixed_size]
+        else
+          ffitype
+        end
+      end
+    end
+  end
+end
+
+GObjectIntrospection::ITypeInfo.send :include, GirFFI::InfoExt::ITypeInfo

data/lib/gir_ffi/method_stubber.rb

@@ -0,0 +1,18 @@
+module GirFFI
+  # Generates method stubs that will replace themselves with the real
+  # method upon being called.
+  class MethodStubber
+    def initialize method_info
+      @info = method_info
+    end
+
+    def method_stub
+      symbol = @info.name
+      "
+        def #{@info.method? ? '' : 'self.'}#{symbol} *args, &block
+          setup_and_call :#{symbol}, *args, &block
+        end
+      "
+    end
+  end
+end

data/lib/gir_ffi/type_map.rb

@@ -4,6 +4,7 @@ module GirFFI
     gtype_type = "uint#{sz}".to_sym
 
     TAG_TYPE_MAP = {
+      #FIXME: Pick one: GType or gtype.
       :GType => :size_t,
       :gtype => gtype_type,
       :gboolean => :bool,

data/lib/gir_ffi/variable_name_generator.rb

@@ -1,4 +1,6 @@
 module GirFFI
+  # Generates a sequence of unique variable names used in generating
+  # function definitions.
   class VariableNameGenerator
     def initialize
       @varno = 0

data/lib/gir_ffi/version.rb

@@ -1,4 +1,4 @@
 module GirFFI
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end
 

data/test/builder_test.rb

@@ -64,7 +64,7 @@ class BuilderTest < MiniTest::Spec
       end
 
       should "create a Gtk::Window#to_ptr method" do
-	assert Gtk::Window.instance_methods.map(&:to_sym).include? :to_ptr
+	assert Gtk::Window.public_method_defined? :to_ptr
       end
 
       after do
@@ -126,7 +126,7 @@ class BuilderTest < MiniTest::Spec
 	end
 
 	GirFFI::Builder.send :attach_ffi_function, libmod, @go
-	assert libmod.public_methods.map(&:to_sym).include? :gtk_main
+        assert_defines_singleton_method libmod, :gtk_main
       end
     end
 
@@ -269,9 +269,10 @@ class BuilderTest < MiniTest::Spec
 	GirFFI::Builder.build_module 'Regress'
       end
 
-      should "have a method_missing method" do
-	ms = (Regress.public_methods - Module.public_methods).map(&:to_sym)
-	assert ms.include? :method_missing
+      should "autocreate singleton methods" do
+        refute_defines_singleton_method Regress, :test_uint
+        Regress.test_uint 31
+        assert_defines_singleton_method Regress, :test_uint
       end
 
       should "autocreate the TestObj class" do

data/test/ffi-glib/array_test.rb

@@ -32,12 +32,22 @@ describe GLib::Array do
 
       assert_equal [1, 2, 3], a
     end
+  end
+
+  describe "::wrap" do
+    it "wraps a pointer, taking the element type as the first argument" do
+      arr = GLib::Array.new :gint32
+      arr.append_vals [1, 2, 3]
+      arr2 = GLib::Array.wrap :gint32, arr.to_ptr
+      assert_equal arr.to_a, arr2.to_a
+    end
 
-    it "returns an enumerator if no block is given" do
-      en = @arr.each
-      assert_equal 1, en.next
-      assert_equal 2, en.next
-      assert_equal 3, en.next
+    it "raises an error if the element sizes don't match" do
+      arr = GLib::Array.new :gint32
+      arr.append_vals [1, 2, 3]
+      assert_raises RuntimeError do
+        GLib::Array.wrap :gint8, arr.to_ptr
+      end
     end
   end
 
@@ -50,5 +60,30 @@ describe GLib::Array do
     arr.append_vals [1, 2, 3]
     assert_equal [1, 2, 3], arr.to_a
   end
+
+  describe "::from" do
+    it "creates a GArray from a Ruby array" do
+      arr = GLib::Array.from :gint32, [3, 2, 1]
+      assert_equal [3, 2, 1], arr.to_a
+    end
+
+    it "return its argument if given a GArray" do
+      arr = GLib::Array.new :gint32
+      arr.append_vals [3, 2, 1]
+      arr2 = GLib::Array.from :foo, arr
+      assert_equal arr, arr2
+    end
+
+    it "wraps its argument if given a pointer" do
+      arr = GLib::Array.new :gint32
+      arr.append_vals [3, 2, 1]
+      pointer = arr.to_ptr
+      assert_instance_of FFI::Pointer, pointer
+      arr2 = GLib::Array.from :gint32, pointer
+      assert_instance_of GLib::Array, arr2
+      refute_equal arr, arr2
+      assert_equal arr.to_a, arr2.to_a
+    end
+  end
 end
 

data/test/ffi-glib/hash_table_test.rb

@@ -9,16 +9,40 @@ describe GLib::HashTable do
 
   describe "::from_hash" do
     it "creates a GHashTable from a Ruby array" do
-      hsh = GLib::HashTable.from_hash :utf8, :gint32,
+      hsh = GLib::HashTable.from_hash [:utf8, :gint32],
         {"foo" => 23, "bar" => 32}
       assert_equal({"foo" => 23, "bar" => 32}, hsh.to_hash)
     end
 
     it "return its argument if given a GHashTable" do
-      hsh = GLib::HashTable.from_hash :utf8, :gint32, {"foo" => 23, "bar" => 32}
-      hsh2 = GLib::HashTable.from_hash :utf8, :gint32, hsh
+      hsh = GLib::HashTable.from_hash [:utf8, :gint32], {"foo" => 23, "bar" => 32}
+      hsh2 = GLib::HashTable.from_hash [:utf8, :gint32], hsh
       assert_equal hsh, hsh2
     end
   end
+
+  describe "::from" do
+    it "creates a GHashTable from a Ruby array" do
+      hsh = GLib::HashTable.from [:utf8, :gint32],
+        {"foo" => 23, "bar" => 32}
+      assert_equal({"foo" => 23, "bar" => 32}, hsh.to_hash)
+    end
+
+    it "return its argument if given a GHashTable" do
+      hsh = GLib::HashTable.from [:utf8, :gint32], {"foo" => 23, "bar" => 32}
+      hsh2 = GLib::HashTable.from [:utf8, :gint32], hsh
+      assert_equal hsh, hsh2
+    end
+
+    it "wraps its argument if given a pointer" do
+      hsh = GLib::HashTable.from [:utf8, :gint32], {"foo" => 23, "bar" => 32}
+      pointer = hsh.to_ptr
+      assert_instance_of FFI::Pointer, pointer
+      hsh2 = GLib::HashTable.from [:utf8, :gint32], pointer
+      assert_instance_of GLib::HashTable, hsh2
+      refute_equal hsh, hsh2
+      assert_equal hsh.to_hash, hsh2.to_hash
+    end
+  end
 end
 

data/test/ffi-glib/list_test.rb

@@ -43,4 +43,27 @@ describe GLib::List do
       assert_equal lst, lst2
     end
   end
+
+  describe "::from" do
+    it "creates a GList from a Ruby array" do
+      lst = GLib::List.from :gint32, [3, 2, 1]
+      assert_equal [3, 2, 1], lst.to_a
+    end
+
+    it "return its argument if given a GList" do
+      lst = GLib::List.from :gint32, [3, 2, 1]
+      lst2 = GLib::List.from :gint32, lst
+      assert_equal lst, lst2
+    end
+
+    it "wraps its argument if given a pointer" do
+      lst = GLib::List.from :gint32, [3, 2, 1]
+      pointer = lst.to_ptr
+      assert_instance_of FFI::Pointer, pointer
+      lst2 = GLib::List.from :gint32, pointer
+      assert_instance_of GLib::List, lst2
+      refute_equal lst, lst2
+      assert_equal lst.to_a, lst2.to_a
+    end
+  end
 end

data/test/ffi-glib/strv_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../gir_ffi_test_helper.rb', File.dirname(__FILE__))
+
+require 'ffi-glib/strv'
+
+describe GLib::Strv do
+  it "wraps a pointer" do
+    strv = GLib::Strv.new :some_pointer
+    assert_equal :some_pointer, strv.to_ptr
+  end
+
+  describe "::wrap" do
+    it "takes a pointer and returns a GLib::Strv wrapping it" do
+      strv = GLib::Strv.wrap :some_pointer
+      assert_instance_of GLib::Strv, strv
+      assert_equal :some_pointer, strv.to_ptr
+    end
+  end
+
+  describe "#each" do
+    it "yields each string element" do
+      ptr = GirFFI::InPointer.from_array :utf8, ["one", "two", "three"]
+      strv = GLib::Strv.new ptr
+      arr = []
+      strv.each do |str|
+        arr << str
+      end
+      assert_equal ["one", "two", "three"], arr
+    end
+
+    it "yields zero times for a Strv wrapping a null pointer" do
+      strv = GLib::Strv.new FFI::Pointer.new(0)
+      strv.each do |str|
+        flunk
+      end
+    end
+  end
+
+  it "includes Enumerable" do
+    GLib::Strv.must_include Enumerable
+  end
+end