gir_ffi 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,17 @@
+== 0.2.0 / 2011-11-19
+
+* Add support for properties, with #get_property and #set_property.
+* Add support for fields.
+  - Create field accessor methods.
+  - Get rid of #[] and #[]=.
+* Explicitely load libgirepository with ABI version 1.
+* Improve implementation of GLib container classes (GList etc.):
+  - Real constructors.
+  - #append and friends are instance methods now.
+  - Conversion methods to cast Ruby containers to GLib containers.
+* Start implementing pretty printing.
+* Various refactorings.
+
 == 0.1.0 / 2011-10-28
 
 * Put bindings for GObjectIntrospection in their own namespace.

data/TODO.rdoc

@@ -1,6 +1,10 @@
 = TODO
 
-== Separate bindings to GIRepository from dynamic binding generation.
+== Fix helper method names
+
+GirFFI adds some methods to all generated modules. For some of these, it
+avoids name clashes by prefixing an underscore. This is ugly and must be
+changed.
 
 == Remove code for passing generic pointers
 
@@ -12,6 +16,9 @@ handling them can be removed.
 This is a big one. See commit 1e9822c7817062a9b853269b9418fd78782090b5 in
 gobject-introspection, and TestFundamentalObject in Regress.
 
+The tests for TestFundamentalObject accidentally pass, but there may be
+hidden issues.
+
 == Check binding of GObject:
 
 (11:37:03 PM) walters: the basic story is that GObject should be manually bound
@@ -21,10 +28,8 @@ gobject-introspection, and TestFundamentalObject in Regress.
 
 == Compatibility with all implementations.
 
-Currently, there are the following incompatibilities:
-
-* JRuby disables ObjectSpace by default, so using _id2ref for handling the
-  passing of generic pointers is not ideal.
+GirFFI is incompatible with Rubinius, but this is due to Rubinius' FFI
+implementation lagging behind the others.
 
 == See Also
 

data/lib/ffi-glib.rb

@@ -5,83 +5,14 @@ require 'ffi-glib/list'
 require 'ffi-glib/hash_table'
 require 'ffi-glib/byte_array'
 require 'ffi-glib/array'
+require 'ffi-glib/ptr_array'
 
 module GLib
-  # FIXME: Turn into real constructor
-  def self.slist_new elmttype
-    ::GLib::List._real_new(FFI::Pointer.new(0)).tap {|it|
-      it.element_type = elmttype}
-  end
-
-  # FIXME: Turn into instance method; Use element type.
-  def self.slist_prepend slist, data
-    ::GLib::SList.wrap(slist.element_type, ::GLib::Lib.g_slist_prepend(slist, data))
-  end
-
-  # FIXME: Turn into real constructor
-  def self.list_new elmttype
-    ::GLib::List._real_new(FFI::Pointer.new(0)).tap {|it|
-      it.element_type = elmttype}
-  end
-
-  # FIXME: Turn into instance method; Use element type.
-  def self.list_append list, data
-    ::GLib::List.wrap(list.element_type, ::GLib::Lib.g_list_append(list, data))
-  end
-
-  # FIXME: Turn into real constructor
-  def self.hash_table_new keytype, valtype
-    hash_fn, eq_fn = case keytype
-                     when :utf8
-                       lib = ::GLib::Lib.ffi_libraries.first
-                       [ FFI::Function.new(:uint, [:pointer], lib.find_function("g_str_hash")),
-                         FFI::Function.new(:int, [:pointer, :pointer], lib.find_function("g_str_equal"))]
-                     else
-                       [nil, nil]
-                     end
-
-    ::GLib::HashTable.wrap(keytype, valtype, ::GLib::Lib.g_hash_table_new(hash_fn, eq_fn))
-  end
-
-  # FIXME: Turn into real constructor
-  def self.byte_array_new
-    ::GLib::ByteArray.wrap(::GLib::Lib.g_byte_array_new)
-  end
-
-  # FIXME: Turn into instance method
-  def self.byte_array_append arr, data
-    bytes = GirFFI::InPointer.from :utf8, data
-    len = data.bytesize
-    ::GLib::ByteArray.wrap(::GLib::Lib.g_byte_array_append arr.to_ptr, bytes, len)
-  end
-
-  # FIXME: Turn into real constructor
-  def self.array_new type
-    ffi_type = type == :utf8 ? :pointer : type
-    arr = ::GLib::Array.wrap(
-      ::GLib::Lib.g_array_new(0, 0, FFI.type_size(ffi_type)))
-      arr.element_type = type
-      arr
-  end
-
-  # FIXME: Turn into instance method
-  def self.array_append_vals arr, data
-    bytes = GirFFI::InPointer.from_array arr.element_type, data
-    len = data.length
-    res = ::GLib::Array.wrap(
-      ::GLib::Lib.g_array_append_vals(arr.to_ptr, bytes, len))
-      res.element_type = arr.element_type
-      res
-  end
-
-  # FIXME: Turn into real constructor?
-  def self.main_loop_new context, is_running
-    ::GLib::MainLoop.wrap(::GLib::Lib.g_main_loop_new context, is_running)
-  end
-
   load_class :HFunc
   load_class :HashFunc
   load_class :EqualFunc
+  load_class :Func
+
   module Lib
     attach_function :g_slist_prepend, [:pointer, :pointer], :pointer
 
@@ -102,6 +33,9 @@ module GLib
     attach_function :g_array_append_vals,
       [:pointer, :pointer, :uint], :pointer
 
-    attach_function :g_main_loop_new, [:pointer, :bool], :pointer
+    attach_function :g_ptr_array_new, [], :pointer
+    attach_function :g_ptr_array_add, [:pointer, :pointer], :void
+    attach_function :g_ptr_array_foreach, [:pointer, Func, :pointer],
+      :pointer
   end
 end

data/lib/ffi-glib/array.rb

@@ -1,14 +1,39 @@
 module GLib
   load_class :Array
 
+  # Overrides for GArray, GLib's automatically growing array. It should not
+  # be necessary to create objects of this class from Ruby directly.
   class Array
+    include Enumerable
+
     attr_accessor :element_type
 
-    def to_a
+    class << self
+      undef :new
+      def new type
+        ffi_type = GirFFI::TypeMap.map_basic_type_or_string(type)
+        wrap(Lib.g_array_new(0, 0, FFI.type_size(ffi_type))).tap {|it|
+          it.element_type = type}
+      end
+    end
+
+    def append_vals data
+      bytes = GirFFI::InPointer.from_array element_type, data
+      len = data.length
+      Lib.g_array_append_vals(self, bytes, len)
+      self
+    end
+
+    # FIXME: Make GirFII::InPointer support #each and use that.
+    def each &block
+      to_typed_array.each(&block)
+    end
+
+    private
+
+    def to_typed_array
       GirFFI::ArgHelper.ptr_to_typed_array(self.element_type,
-                                           self[:data], self[:len])
+                                           @struct[:data], @struct[:len])
     end
   end
 end
-
-

data/lib/ffi-glib/byte_array.rb

@@ -1,9 +1,23 @@
 module GLib
   load_class :ByteArray
 
+  # Overrides for GByteArray, GLib's automatically growing array of bytes.
   class ByteArray
     def to_string
-      GirFFI::ArgHelper.ptr_to_utf8_length self[:data], self[:len]
+      GirFFI::ArgHelper.ptr_to_utf8_length @struct[:data], @struct[:len]
+    end
+
+    def append data
+      bytes = GirFFI::InPointer.from :utf8, data
+      len = data.bytesize
+      self.class.wrap(Lib.g_byte_array_append self.to_ptr, bytes, len)
+    end
+
+    class << self
+      undef :new
+      def new
+        wrap(Lib.g_byte_array_new)
+      end
     end
   end
 end

data/lib/ffi-glib/hash_table.rb

@@ -1,6 +1,7 @@
 module GLib
   load_class :HashTable
 
+  # Overrides for GHashTable, GLib's hash table implementation.
   class HashTable
     include Enumerable
     attr_accessor :key_type
@@ -8,8 +9,8 @@ module GLib
 
     def each
       prc = Proc.new {|keyptr, valptr, userdata|
-        key = cast_from_pointer key_type, keyptr
-        val = cast_from_pointer value_type, valptr
+        key = GirFFI::ArgHelper.cast_from_pointer key_type, keyptr
+        val = GirFFI::ArgHelper.cast_from_pointer value_type, valptr
         yield key, val
       }
       ::GLib::Lib.g_hash_table_foreach self.to_ptr, prc, nil
@@ -20,35 +21,41 @@ module GLib
     end
 
     def insert key, value
-      keyptr = cast_to_pointer key_type, key
-      valptr = cast_to_pointer value_type, value
+      keyptr = GirFFI::InPointer.from key_type, key
+      valptr = GirFFI::InPointer.from value_type, value
       ::GLib::Lib.g_hash_table_insert self.to_ptr, keyptr, valptr
     end
 
-    def cast_to_pointer type, it
-      if type == :utf8
-        GirFFI::InPointer.from :utf8, it
-      else
-        FFI::Pointer.new(it)
+    class << self
+      undef :new
+      def new  keytype, valtype
+        hash_fn, eq_fn = case keytype
+                         when :utf8
+                           lib = ::GLib::Lib.ffi_libraries.first
+                           [ FFI::Function.new(:uint, [:pointer], lib.find_function("g_str_hash")),
+                             FFI::Function.new(:int, [:pointer, :pointer], lib.find_function("g_str_equal"))]
+                         else
+                           [nil, nil]
+                         end
+        wrap(keytype, valtype, Lib.g_hash_table_new(hash_fn, eq_fn))
       end
-    end
 
-    def cast_from_pointer type, it
-      case type
-      when :utf8
-        GirFFI::ArgHelper.ptr_to_utf8 it
-      when :gint32
-        GirFFI::ArgHelper.cast_pointer_to_int32 it
-      else
-        it.address
+      def wrap keytype, valtype, ptr
+        super(ptr).tap do |it|
+          break if it.nil?
+          it.key_type = keytype
+          it.value_type = valtype
+        end
       end
-    end
 
-    def self.wrap keytype, valtype, ptr
-      super(ptr).tap do |it|
-        break if it.nil?
-        it.key_type = keytype
-        it.value_type = valtype
+      def from_hash keytype, valtype, hash
+        return nil if hash.nil?
+        return hash if hash.is_a? self
+        ghash = self.new keytype, valtype
+        hash.each do |key, val|
+          ghash.insert key, val
+        end
+        ghash
       end
     end
   end

data/lib/ffi-glib/list.rb

@@ -3,7 +3,35 @@ require 'ffi-glib/list_methods'
 module GLib
   load_class :List
 
+  # Overrides for GList, GLib's doubly linked list implementation.
   class List
     include ListMethods
+
+    # Override default field accessors.
+    undef :next
+    undef :data
+
+    alias :next :tail
+    alias :data :head
+
+    class << self
+      undef :new
+      def new type
+        _real_new(FFI::Pointer.new(0)).tap {|it|
+          it.element_type = type}
+      end
+
+      def from_array type, arr
+        return nil if arr.nil?
+        return arr if arr.is_a? self
+        arr.inject(self.new type) { |lst, val|
+          lst.append val }
+      end
+    end
+
+    def append data
+      data_ptr = GirFFI::InPointer.from(element_type, data)
+      self.class.wrap(element_type, Lib.g_list_append(self, data_ptr))
+    end
   end
 end

data/lib/ffi-glib/list_methods.rb

@@ -11,12 +11,20 @@ module GLib
       list = self
       rval = nil
       until list.nil?
-        rval = yield GirFFI::ArgHelper.cast_from_pointer(element_type, list[:data])
-        list = self.class.wrap(element_type, list[:next])
+        rval = yield list.head
+        list = list.tail
       end
       rval
     end
 
+    def tail
+      self.class.wrap(element_type, @struct[:next])
+    end
+
+    def head
+      GirFFI::ArgHelper.cast_from_pointer(element_type, @struct[:data])
+    end
+
     module ClassMethods
       def wrap elmttype, ptr
         super(ptr).tap do |it|

data/lib/ffi-glib/ptr_array.rb

@@ -0,0 +1,39 @@
+module GLib
+  load_class :PtrArray
+
+  # Overrides for GPtrArray, GLib's automatically growing array of
+  # pointers.
+  class PtrArray
+    include Enumerable
+
+    attr_accessor :element_type
+
+    class << self
+      undef :new
+      def new type
+        wrap(Lib.g_ptr_array_new).tap {|it|
+          it.element_type = type}
+      end
+
+      # Remove stub generated by builder.
+      undef :add
+
+      def add array, data
+        array.add data
+      end
+    end
+
+    def add data
+      ptr = GirFFI::InPointer.from element_type, data
+      Lib.g_ptr_array_add self, ptr
+    end
+
+    def each
+      prc = Proc.new {|valptr, userdata|
+        val = GirFFI::ArgHelper.cast_from_pointer element_type, valptr
+        yield val
+      }
+      Lib.g_ptr_array_foreach self.to_ptr, prc, nil
+    end
+  end
+end

data/lib/ffi-glib/s_list.rb

@@ -3,7 +3,36 @@ require 'ffi-glib/list_methods'
 module GLib
   load_class :SList
 
+  # Overrides for GSList, GLib's singly linked list implementation.
   class SList
     include ListMethods
+
+    # Override default field accessors.
+    undef :next
+    undef :data
+
+    alias :next :tail
+    alias :data :head
+
+    class << self
+      undef :new
+      def new type
+        _real_new(FFI::Pointer.new(0)).tap {|it|
+          it.element_type = type}
+      end
+
+      def from_array type, arr
+        return nil if arr.nil?
+        return arr if arr.is_a? self
+        arr.reverse.inject(self.new type) { |lst, val|
+          lst.prepend val }
+      end
+    end
+
+    def prepend data
+      data_ptr = GirFFI::InPointer.from(element_type, data)
+      self.class.wrap(element_type, Lib.g_slist_prepend(self, data_ptr))
+    end
+
   end
 end

data/lib/ffi-gobject.rb

@@ -3,6 +3,7 @@ GirFFI.setup :GObject
 require 'ffi-gobject/value'
 require 'ffi-gobject/initially_unowned'
 require 'ffi-gobject/closure'
+require 'ffi-gobject/object'
 require 'ffi-gobject/ruby_closure'
 require 'ffi-gobject/helper'
 
@@ -28,6 +29,7 @@ module GObject
   end
 
   def self.type_from_instance_pointer inst_ptr
+    return nil if inst_ptr.null?
     klsptr = inst_ptr.get_pointer 0
     klsptr.send "get_#{GirFFI::TypeMap::TAG_TYPE_MAP[:gtype]}", 0
   end
@@ -38,38 +40,27 @@ module GObject
 
   _setup_method :signal_emitv
 
-  def self.signal_emit object, signal, *args
-    type = type_from_instance object
-    id = signal_lookup signal, type
+  def self.signal_lookup_from_instance signal, object
+    signal_lookup signal, type_from_instance(object)
+  end
 
+  def self.signal_emit object, signal, *args
+    id = signal_lookup_from_instance signal, object
     arr = Helper.signal_arguments_to_gvalue_array signal, object, *args
     rval = Helper.gvalue_for_signal_return_value signal, object
 
-    ::GObject::Lib.g_signal_emitv arr[:values], id, 0, rval
+    Lib.g_signal_emitv arr.values, id, 0, rval
 
-    rval
+    return rval
   end
 
   def self.signal_connect object, signal, data=nil, &block
-    sig = object.class._find_signal signal
-    if sig.nil?
-      raise "Signal #{signal} is invalid for #{object}"
-    end
-    if block.nil?
-      raise ArgumentError, "Block needed"
-    end
-
-    rettype = GirFFI::Builder.itypeinfo_to_ffitype sig.return_type
-
-    argtypes = GirFFI::Builder.ffi_argument_types_for_signal sig
-
-    callback = FFI::Function.new rettype, argtypes,
-      &(Helper.signal_callback_args(sig, object.class, &block))
-    ::GObject::Lib::CALLBACKS << callback
-
+    callback = Helper.signal_callback object.class, signal, &block
     data_ptr = GirFFI::ArgHelper.object_to_inptr data
 
-    ::GObject::Lib.g_signal_connect_data object, signal, callback, data_ptr, nil, 0
+    Lib::CALLBACKS << callback
+
+    Lib.g_signal_connect_data object, signal, callback, data_ptr, nil, 0
   end
 
   load_class :Callback
@@ -91,4 +82,40 @@ module GObject
     attach_function :g_closure_set_marshal,
       [:pointer, ClosureMarshal], :void
   end
+
+  TYPE_INVALID = type_from_name("invalid")
+  TYPE_NONE = type_from_name("void")
+  TYPE_INTERFACE = type_from_name("GInterface")
+  TYPE_CHAR = type_from_name("gchar")
+  TYPE_UCHAR = type_from_name("guchar")
+  TYPE_BOOLEAN = type_from_name("gboolean")
+  TYPE_INT = type_from_name("gint")
+  TYPE_UINT = type_from_name("guint")
+  TYPE_LONG = type_from_name("glong")
+  TYPE_ULONG = type_from_name("gulong")
+  TYPE_INT64 = type_from_name("gint64")
+  TYPE_UINT64 = type_from_name("guint64")
+  TYPE_ENUM = type_from_name("GEnum")
+  TYPE_FLAGS = type_from_name("GFlags")
+  TYPE_FLOAT = type_from_name("gfloat")
+  TYPE_DOUBLE = type_from_name("gdouble")
+  TYPE_STRING = type_from_name("gchararray")
+  TYPE_POINTER = type_from_name("gpointer")
+  TYPE_BOXED = type_from_name("GBoxed")
+  TYPE_PARAM = type_from_name("GParam")
+  TYPE_OBJECT = type_from_name("GObject")
+  TYPE_GTYPE = type_from_name("GType")
+  TYPE_VARIANT = type_from_name("GVariant")
+  TYPE_HASH_TABLE = type_from_name("GHashTable")
+
+  TYPE_TAG_TO_GTYPE = {
+    :void => TYPE_NONE,
+    :gboolean => TYPE_BOOLEAN,
+    :gint32 => TYPE_INT,
+    :gfloat => TYPE_FLOAT,
+    :gdouble => TYPE_DOUBLE,
+    :utf8 => TYPE_STRING,
+    :ghash => TYPE_HASH_TABLE,
+    :glist => TYPE_POINTER
+  }
 end