gir_ffi 0.0.10 → 0.0.11

data/History.txt

@@ -1,3 +1,14 @@
+== 0.0.11 / 2011-08-22
+
+* Change interface to the underlying builder in generated modules and
+  classes.
+* Handle string, enum, union, flags signal arguments.
+* Handle string arguments in GObject.signal_emit.
+* Handle enum signal arguments.
+* Fix finding signals in non-introspectable types.
+* Fix method setup in non-introspectable types.
+* Refactoring.
+
 == 0.0.10 / 2011-05-18
 
 * Handle GObject interfaces properly.

data/README.rdoc

@@ -6,12 +6,12 @@ http://www.github.com/mvz/ruby-gir-ffi
 
 == Description
 
-Ruby-FFI-based binding of the GObject Introspection Repository
+Ruby bindings for GNOME using the GObject Introspection Repository.
 
 == Features/Problems
 
 * Create bindings to GObject-based libraries at runtime
-* Not done yet
+* Almost, but not entirely done yet
 
 == Synopsis
 
@@ -21,26 +21,40 @@ Ruby-FFI-based binding of the GObject Introspection Repository
   Gtk.init
   win = Gtk::Window.new :toplevel
 
+See the `examples/` directory for more, well, examples.
+
 == Requirements
 
 * Ruby-FFI of course
 * gobject-introspection installed with some introspection data
-* The `rr` and `shoulda` gems for testing.
+* The `rr` and `minitest` gems for testing
+
+Depending on the GIR data, GirFFI needs the actual libraries to be
+available under the name ending in plain `.so`. If GirFFI complains that it
+cannot find the library, try installing development packages for those
+libraries.
 
-The current implementation needs the actual libraries to be available under
-the name ending in just `.so`. On Debian and Ubuntu at least, this means
-you have to install the -dev packages of any library you may want to
-access. The following set of packages should do the trick:
-`libgirepository1.0-dev` (at least version 0.10), and either
-`gir1.2-gtk-3.0` and `libgtk-3-dev`, or `gir1.2-gtk-2.0` and
-`libgtk2.0-dev`.
+On Debian and Ubuntu, the following set of packages should be enough to get
+`rake test` working: `libgirepository1.0-dev` (at least version 0.10),
+`gir1.2-gtk-2.0` and `libgtk2.0-dev`.
 
-== Hacking
+== Hacking and contributing
 
 This is still very much a work in progress. You can start exploring by
-running the example programs in the examples/ folder. Some illustrate what
-works, some are a test bed for how things should work. Have a look at
-`rake -T`. Feel free to file bugs or send pull requests.
+running the example programs in the `examples/` folder. Some illustrate
+what works, some are a test bed for how things should work. Have a look at
+the output of `rake notes`. Feel free to file bugs or send pull requests.
+
+If you want to send pull requests or patches, please:
+
+* Make sure `rake test` runs without reporting any failures. If your code
+  breaks existing stuff, it won't get merged in.
+* Add tests for your feature. Otherwise, I can't see if it works or if I
+  break it later.
+* Make sure latest master merges cleanly with your branch. Things might
+  have moved around since you forked.
+* Try not to include changes that are irrelevant to your feature in the
+  same commit.
 
 == Install
 

data/Rakefile

@@ -1,3 +1,3 @@
 load 'tasks/setup.rb'
 
-task :default => 'test:run'
+task :default => 'test'

data/TODO.rdoc

@@ -1,31 +1,10 @@
 = TODO
 
-== Use GIR to bootstrap the GIRepository namespace
+== Separate bindings to GIRepository from dynamic binding generation.
 
-Currently, all the classes used to read the GIR are hand-coded. It should
-be possible to hand-code only part of it and use that to generate the rest.
-This would also integrate that properly with the rest of the GObject type
-system.
+== Remove code for passing generic pointers
 
-Update: This has been tried, but the problem is that the GIRepository
-namespace is not object-oriented: The Info structs are not GObjects, and
-the methods that act upon them are just functions in the GIRepository
-namespace. Perhaps some custom method_missing can be implemented to handle
-this, though.
-
-== Handle passing of generic pointers
-
-Many GObject methods take a pointer to 'user data'. This means we should be
-able to pass any Ruby object. On the other hand, these cases cannot be
-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
-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.
-
-Update: generic pointers have been declared 'not introspectable', so
+Generic pointers have been declared 'not introspectable', so
 handling them can be removed.
 
 == Handle fundamental objects that are not GObject.

data/examples/05_notification.rb

@@ -0,0 +1,35 @@
+#
+# Simple notification example.
+#
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'gir_ffi'
+
+GirFFI.setup :Gtk
+GirFFI.setup :Notify
+
+# Both Gtk and Notify need to be init'ed.
+Gtk.init
+Notify.init "notification test"
+
+# Basic set up of the notification.
+nf = Notify::Notification.new "Hello!", "Hi there.", "gtk-dialog-info"
+nf.set_timeout 3000
+nf.set_urgency :critical
+
+# Show a button 'Test' in the notification, with a callback function.
+nf.add_action "test", "Test", Proc.new { |obj, action, user_data|
+  puts "Action #{action} clicked."
+}, nil, nil
+
+# In this case, we want the program to end once the notification is gone,
+# but not before.
+GObject.signal_connect(nf, "closed") {
+  puts "Notification closed."
+  Gtk.main_quit
+}
+
+# Show the notification.
+nf.show
+
+# Start a main loop to wait for the notification to be closed.
+Gtk.main

data/lib/gir_ffi/arg_helper.rb

@@ -1,30 +1,16 @@
 require 'gir_ffi/allocation_helper'
+require 'gir_ffi/callback_helper'
 require 'gir_ffi/builder'
-require 'gir_ffi/builder/dynamic_type'
 
 module GirFFI
   module ArgHelper
+    POINTER_SIZE = FFI.type_size(:pointer)
+
     SIMPLE_G_TYPES = [
       :gint8, :gint16, :gint, :gint32, :gint64,
       :guint8, :guint16, :guint32, :guint64,
       :gfloat, :gdouble]
 
-    def self.setup_array_to_inptr_handler_for *types
-      types.flatten.each do |type|
-        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
-        defn =
-          "def self.#{type}_array_to_inptr ary
-            return nil if ary.nil?
-            block = allocate_array_of_type #{ffi_type.inspect}, ary.length
-            block.put_array_of_#{ffi_type} 0, ary
-          end"
-        eval defn
-      end
-    end
-
-    setup_array_to_inptr_handler_for SIMPLE_G_TYPES
-    setup_array_to_inptr_handler_for :pointer
-
     # FIXME: Hideous.
     def self.object_to_inptr obj
       return obj.to_ptr if obj.respond_to? :to_ptr
@@ -33,164 +19,6 @@ module GirFFI
       FFI::Pointer.new(obj.object_id)
     end
 
-    def self.typed_array_to_inptr type, ary
-      return nil if ary.nil?
-      return utf8_array_to_inptr ary if type == :utf8
-      block = allocate_array_of_type type, ary.length
-      block.send "put_array_of_#{type}", 0, 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.utf8_array_to_inptr ary
-      return nil if ary.nil?
-      ptr_ary = ary.map {|str| utf8_to_inptr str}
-      ptr_ary << nil
-      typed_array_to_inptr :pointer, ptr_ary
-    end
-
-    # FIXME: :interface is too generic. implement only GValueArray?
-    def self.interface_array_to_inptr ary
-      return nil if ary.nil?
-      raise NotImplementedError
-    end
-
-    def self.interface_pointer_array_to_inptr ary
-      return nil if ary.nil?
-      ptr_ary = ary.map {|ifc| ifc.to_ptr}
-      ptr_ary << nil
-      pointer_array_to_inptr ptr_ary
-    end
-
-    def self.cleanup_ptr ptr
-      LibC.free ptr
-    end
-
-    def self.cleanup_ptr_ptr ptr
-      LibC.free ptr.read_pointer
-      LibC.free ptr
-    end
-
-    # Takes an outptr to a pointer array, and frees all pointers.
-    def self.cleanup_ptr_array_ptr ptr, size
-      block = ptr.read_pointer
-      unless block.null?
-        block.read_array_of_pointer(size).each { |pt| LibC.free pt }
-        LibC.free block
-      end
-      LibC.free ptr
-    end
-
-    def self.setup_type_to_inoutptr_handler_for *types
-      types.flatten.each do |type|
-        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
-        defn =
-          "def self.#{type}_to_inoutptr val
-            #{type}_pointer.put_#{ffi_type} 0, val
-          end"
-        eval defn
-      end
-    end
-
-    setup_type_to_inoutptr_handler_for SIMPLE_G_TYPES
-    setup_type_to_inoutptr_handler_for :pointer
-
-    def self.gboolean_to_inoutptr val
-      gboolean_pointer.put_int 0, (val ? 1 : 0)
-    end
-
-    def self.utf8_to_inoutptr str
-      sptr = utf8_to_inptr str
-      pointer_pointer.write_pointer sptr
-    end
-
-    def self.int32_array_to_inoutptr ary
-      block = gint32_array_to_inptr ary
-      pointer_pointer.write_pointer block
-    end
-
-    def self.utf8_array_to_inoutptr ary
-      return nil if ary.nil?
-      pointer_pointer.write_pointer utf8_array_to_inptr(ary)
-    end
-
-    class << self
-      alias int_array_to_inoutptr int32_array_to_inoutptr
-      alias gint32_array_to_inoutptr int32_array_to_inoutptr
-    end
-
-    def self.setup_pointer_maker_for *types
-      types.flatten.each do |type|
-        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
-        size = FFI.type_size ffi_type
-        defn =
-          "def self.#{type}_pointer
-            AllocationHelper.safe_malloc #{size}
-          end"
-        eval defn
-      end
-    end
-
-    setup_pointer_maker_for SIMPLE_G_TYPES
-    setup_pointer_maker_for :pointer
-
-    class << self
-      alias gboolean_pointer gint_pointer
-    end
-
-    def self.setup_type_outptr_handler_for *types
-      types.flatten.each do |type|
-        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
-        defn =
-          "def self.#{type}_outptr
-            #{type}_pointer.put_#{ffi_type} 0, 0
-          end"
-        eval defn
-      end
-    end
-
-    setup_type_outptr_handler_for SIMPLE_G_TYPES
-
-    def self.gboolean_outptr
-      gboolean_pointer.put_int 0, 0
-    end
-
-    def self.pointer_outptr
-      pointer_pointer.put_pointer 0, nil
-    end
-
-    def self.utf8_outptr
-      pointer_outptr
-    end
-
-    def self.setup_outptr_to_type_handler_for *types
-      types.flatten.each do |type|
-        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
-        defn =
-          "def self.outptr_to_#{type} ptr
-            ptr.get_#{ffi_type} 0
-          end"
-        eval defn
-      end
-    end
-
-    setup_outptr_to_type_handler_for SIMPLE_G_TYPES
-    setup_outptr_to_type_handler_for :pointer
-
-    # Converts an outptr to a boolean.
-    def self.outptr_to_gboolean ptr
-      (ptr.get_int 0) != 0
-    end
-
-    # Converts an outptr to a string.
-    def self.outptr_to_utf8 ptr
-      ptr_to_utf8 ptr.read_pointer
-    end
-
     # Converts an outptr to a string array.
     def self.outptr_to_utf8_array ptr, size
       block = ptr.read_pointer
@@ -221,7 +49,8 @@ module GirFFI
       if type == :utf8
         ptr_to_utf8_array ptr, size
       else
-        ptr.send "get_array_of_#{type}", 0, size
+        ffi_type = GirFFI::Builder::TAG_TYPE_MAP[type] || type
+        ptr.send "get_array_of_#{ffi_type}", 0, size
       end
     end
 
@@ -245,13 +74,10 @@ module GirFFI
     end
 
     def self.ptr_to_interface_array klass, ptr, size
-      sz = klass.ffi_structure.size
-      arr = []
-      size.times do
-        arr << klass.wrap(ptr)
-        ptr += sz
+      struct_size = klass.ffi_structure.size
+      size.times.map do |idx|
+        klass.wrap(ptr + struct_size * idx)
       end
-      arr
     end
 
     if RUBY_VERSION < "1.9"
@@ -272,10 +98,6 @@ module GirFFI
     class << self
       sz = FFI.type_size(:size_t) * 8
       type = "guint#{sz}"
-      alias_method :gtype_array_to_inptr, "#{type}_array_to_inptr"
-      alias_method :gtype_outptr, "#{type}_outptr"
-      alias_method :gtype_to_inoutptr, "#{type}_to_inoutptr"
-      alias_method :outptr_to_gtype, "outptr_to_#{type}"
       alias_method :ptr_to_gtype_array, "ptr_to_#{type}_array"
     end
 
@@ -285,13 +107,10 @@ module GirFFI
 
     def self.strv_to_utf8_array strv
       return [] if strv.null?
-      arr = []
-      i = 0
-      loop do
-        ptr = strv.get_pointer i * FFI.type_size(:pointer)
-        break if ptr.null?
+      arr, offset = [], 0
+      until (ptr = strv.get_pointer offset).null? do
         arr << ptr.read_string
-        i += 1
+        offset += POINTER_SIZE
       end
       return arr
     end
@@ -299,7 +118,7 @@ module GirFFI
     def self.utf8_array_to_glist arr
       return nil if arr.nil?
       arr.inject(GLib.list_new :utf8) { |lst, str|
-        GLib.list_append lst, utf8_to_inptr(str) }
+        GLib.list_append lst, InPointer.from(:utf8, str) }
     end
 
     def self.gint32_array_to_glist arr
@@ -311,7 +130,7 @@ module GirFFI
     def self.utf8_array_to_gslist arr
       return nil if arr.nil?
       arr.reverse.inject(GLib.slist_new :utf8) { |lst, str|
-        GLib.slist_prepend lst, utf8_to_inptr(str) }
+        GLib.slist_prepend lst, InPointer.from(:utf8, str) }
     end
 
     def self.gint32_array_to_gslist arr
@@ -335,80 +154,6 @@ module GirFFI
       raise NotImplementedError
     end
 
-    def self.glist_to_utf8_array ptr
-      return [] if ptr.null?
-      # FIXME: Quasi-circular dependency on generated module
-      list = GLib::List.wrap(ptr)
-      str = ptr_to_utf8(list[:data])
-      [str] + glist_to_utf8_array(list[:next])
-    end
-
-    def self.gslist_to_utf8_array ptr
-      return [] if ptr.null?
-      # FIXME: Quasi-circular dependency on generated module
-      list = GLib::SList.wrap(ptr)
-      str = ptr_to_utf8(list[:data])
-      [str] + gslist_to_utf8_array(list[:next])
-    end
-
-    def self.outgslist_to_utf8_array ptr
-      gslist_to_utf8_array ptr.read_pointer
-    end
-
-    def self.wrap_in_callback_args_mapper namespace, name, prc
-      return prc if FFI::Function === prc
-      return nil if prc.nil?
-      info = gir.find_by_name namespace, name
-      return Proc.new do |*args|
-	prc.call(*map_callback_args(args, info))
-      end
-    end
-
-    def self.map_callback_args args, info
-      args.zip(info.args).map { |arg, inf|
-	map_single_callback_arg arg, inf }
-    end
-
-    # TODO: Use GirFFI::ReturnValue classes for mapping.
-    def self.map_single_callback_arg arg, info
-      case info.argument_type.tag
-      when :interface
-        map_interface_callback_arg arg, info
-      when :utf8
-	ptr_to_utf8 arg
-      when :void
-        map_void_callback_arg arg
-      else
-	arg
-      end
-    end
-
-    def self.map_interface_callback_arg arg, info
-      iface = info.argument_type.interface
-      case iface.info_type
-      when :object
-        object_pointer_to_object arg
-      when :struct
-        klass = GirFFI::Builder.build_class iface
-        klass.wrap arg
-      else
-        arg
-      end
-    end
-
-    def self.map_void_callback_arg arg
-      if arg.null?
-        nil
-      else
-        begin
-          # TODO: Use custom object store.
-          ObjectSpace._id2ref arg.address
-        rescue RangeError
-          arg
-        end
-      end
-    end
-
     def self.check_error errpp
       errp = errpp.read_pointer
       raise GError.new(errp)[:message] unless errp.null?
@@ -427,20 +172,11 @@ module GirFFI
     # FIXME: Quasi-circular dependency on generated module
     def self.object_pointer_to_object optr
       return nil if optr.null?
-      tp = ::GObject.type_from_instance_pointer optr
-      info = gir.find_by_gtype tp
-      if info.nil?
-        klass = GirFFI::Builder::DynamicType.new(tp).build_class
-      else
-        klass = GirFFI::Builder.build_class info
-      end
+      gtype = ::GObject.type_from_instance_pointer optr
+      klass = GirFFI::Builder.build_by_gtype gtype
       klass.wrap optr
     end
 
-    def self.gir
-      gir = GirFFI::IRepository.default
-    end
-
     def self.cast_from_pointer type, it
       case type
       when :utf8, :filename

data/lib/gir_ffi/builder/argument/base.rb

@@ -0,0 +1,110 @@
+module GirFFI
+  module Builder
+    module Argument
+      # Abstract parent class of the argument building classes. These
+      # classes are used by Builder::Function to create the code that
+      # processes each argument before and after the actual function call.
+      class Base
+        KEYWORDS = [
+          "alias", "and", "begin", "break", "case", "class", "def", "do",
+          "else", "elsif", "end", "ensure", "false", "for", "if", "in",
+          "module", "next", "nil", "not", "or", "redo", "rescue", "retry",
+          "return", "self", "super", "then", "true", "undef", "unless",
+          "until", "when", "while", "yield"
+        ]
+
+        attr_reader :callarg, :name, :retname
+
+        attr_accessor :length_arg, :array_arg
+
+        def initialize function_builder, arginfo=nil, libmodule=nil
+          @arginfo = arginfo
+          @inarg = nil
+          @callarg = nil
+          @retname = nil
+          @name = nil
+          @function_builder = function_builder
+          @libmodule = libmodule
+          @length_arg = nil
+          @array_arg = nil
+        end
+
+        def prepare; end
+
+        def type_info
+          @arginfo.argument_type
+        end
+
+        def type_tag
+          tag = type_info.tag
+          tag == :GType ? :gtype : tag
+        end
+
+        def subtype_tag index=0
+          st = type_info.param_type(index)
+          t = st.tag
+          case t
+          when :GType
+            return :gtype
+          when :interface
+            return :interface_pointer if st.pointer?
+            return :interface
+          else
+            return t
+          end
+        end
+
+        def argument_class_name
+          iface = type_info.interface
+          "::#{iface.safe_namespace}::#{iface.name}"
+        end
+
+        def subtype_class_name index=0
+          iface = type_info.param_type(index).interface
+          "::#{iface.safe_namespace}::#{iface.name}"
+        end
+
+        def array_size
+          if @length_arg
+            @length_arg.retname
+          else
+            type_info.array_fixed_size
+          end
+        end
+
+        def safe name
+          if KEYWORDS.include? name
+            "#{name}_"
+          else
+            name
+          end
+        end
+
+        def inarg
+          @array_arg.nil? ? @inarg : nil
+        end
+
+        def retval
+          @array_arg.nil? ? @retname : nil
+        end
+
+        def pre
+          []
+        end
+
+        def post
+          []
+        end
+
+        def postpost
+          []
+        end
+
+        def cleanup
+          []
+        end
+      end
+    end
+  end
+end
+

data/lib/gir_ffi/builder/argument/hash_table_base.rb

@@ -0,0 +1,20 @@
+module GirFFI
+  module Builder
+    module Argument
+      # Module implementing helper methods needed by HashTable arguments.
+      module HashTableBase
+        private
+
+        def key_t
+          subtype_tag(0).inspect
+        end
+
+        def val_t
+          val_t = subtype_tag(1).inspect
+        end
+      end
+    end
+  end
+end
+
+

data/lib/gir_ffi/builder/argument/in_base.rb

@@ -0,0 +1,19 @@
+module GirFFI
+  module Builder
+    module Argument
+      # Abstract base class implementing argument processing for arguments
+      # with direction :in.
+      class InBase < Base
+        def prepare
+          @name = safe(@arginfo.name)
+          @inarg = @name
+        end
+
+        def callarg
+          @callarg ||= @function_builder.new_var
+        end
+      end
+    end
+  end
+end
+