gir_ffi 0.6.6 → 0.6.7

data/lib/gir_ffi/builders/with_layout.rb

@@ -0,0 +1,55 @@
+require 'gir_ffi/builders/field_builder'
+
+module GirFFI
+  module Builders
+    # Implements the creation of classes representing types with layout,
+    # i.e., :union, :struct, :object.
+    # Note: This module depends on the additional inclusion of
+    # WithMethods.
+    module WithLayout
+      def layout_specification
+        spec = base_layout_specification
+        if spec.empty?
+          dummy_layout_specification
+        else
+          spec
+        end
+      end
+
+      private
+
+      def setup_layout
+        spec = layout_specification
+        @structklass.class_eval { layout(*spec) }
+      end
+
+      def dummy_layout_specification
+        if parent
+          [:parent, superclass.const_get(:Struct), 0]
+        else
+          [:dummy, :char, 0]
+        end
+      end
+
+      def base_layout_specification
+        fields.map { |finfo| finfo.layout_specification }.flatten(1)
+      end
+
+      def setup_accessors_for_field_info finfo
+        FieldBuilder.new(finfo).build
+      end
+
+      def setup_field_accessors
+        fields.each do |finfo|
+          setup_accessors_for_field_info finfo
+        end
+      end
+
+      def instantiate_class
+        @klass = get_or_define_class namespace_module, @classname, superclass
+        @structklass = get_or_define_class @klass, :Struct, layout_superclass
+        setup_class unless already_set_up
+      end
+    end
+  end
+end

data/lib/gir_ffi/builders/with_methods.rb

@@ -0,0 +1,44 @@
+require 'gir_ffi/method_stubber'
+
+module GirFFI
+  module Builders
+    # Implements method creation for types such as, :union, :struct,
+    # :object, :interface.
+    module WithMethods
+      def setup_method method
+        go = info.find_method method
+        attach_and_define_method method, go, meta_class
+      end
+
+      def setup_instance_method method
+        go = info.find_instance_method method
+        attach_and_define_method method, go, build_class
+      end
+
+      private
+
+      def meta_class
+        klass = build_class
+        return (class << klass; self; end)
+      end
+
+      def function_definition go
+        FunctionBuilder.new(go).generate
+      end
+
+      def attach_and_define_method method, go, modul
+        return false if go.nil?
+        Builder.attach_ffi_function lib, go
+        modul.class_eval { remove_method method }
+        build_class.class_eval function_definition(go)
+        true
+      end
+
+      def stub_methods
+        info.get_methods.each do |minfo|
+          @klass.class_eval MethodStubber.new(minfo).method_stub
+        end
+      end
+    end
+  end
+end

data/lib/gir_ffi/callback_base.rb

@@ -0,0 +1,31 @@
+require 'gir_ffi/type_base'
+
+module GirFFI
+  module CallbackBase
+    CALLBACKS = []
+
+    def store_callback prc
+      CALLBACKS << prc
+    end
+
+    def self.store_callback prc
+      CALLBACKS << prc
+    end
+
+    # Create Callback from a Proc. Makes sure arguments are properly wrapped,
+    # and the callback is stored to prevent garbage collection.
+    def from prc
+      wrap_in_callback_args_mapper(prc).tap do |cb|
+        store_callback cb
+      end
+    end
+
+    def wrap_in_callback_args_mapper prc
+      return prc if FFI::Function === prc
+      return nil if prc.nil?
+      return Proc.new do |*args|
+        call_with_argument_mapping(prc, *args)
+      end
+    end
+  end
+end

data/lib/gir_ffi/class_base.rb

@@ -1,13 +1,19 @@
 require 'forwardable'
+require 'gir_ffi/builders/null_builder'
+require 'gir_ffi/type_base'
 
 module GirFFI
   # Base class for all generated classes. Contains code for dealing with
   # the generated Struct classes.
   class ClassBase
+    extend TypeBase
+
     # TODO: Make separate base for :struct, :union, :object.
     extend Forwardable
     def_delegators :@struct, :to_ptr
 
+    GIR_FFI_BUILDER = NullBuilder.new
+
     def setup_and_call method, *arguments, &block
       result = self.class.ancestors.any? do |klass|
         klass.respond_to?(:setup_instance_method) &&
@@ -21,8 +27,16 @@ module GirFFI
       self.send method, *arguments, &block
     end
 
-    def ==(other)
-      other.is_a?(self.class) && self.to_ptr == other.to_ptr
+    if RUBY_PLATFORM == 'java'
+      # FIXME: JRuby should fix FFI::MemoryPointer#== to return true for
+      # equivalent FFI::Pointer.
+      def ==(other)
+        other.class == self.class && self.to_ptr.address == other.to_ptr.address
+      end
+    else
+      def ==(other)
+        other.class == self.class && self.to_ptr == other.to_ptr
+      end
     end
 
     def self.setup_and_call method, *arguments, &block
@@ -39,14 +53,6 @@ module GirFFI
     end
 
     class << self
-      def gir_info
-        self.const_get :GIR_INFO
-      end
-
-      def gir_ffi_builder
-        self.const_get :GIR_FFI_BUILDER
-      end
-
       def to_ffitype
         self::Struct
       end

data/lib/gir_ffi/enum_base.rb

@@ -1,9 +1,17 @@
+require 'gir_ffi/type_base'
+
 module GirFFI
   module EnumBase
+    include TypeBase
+    # TODO: Make this a DataConverter
     def [](arg)
       self::Enum[arg]
     end
 
+    def wrap arg
+      self[arg]
+    end
+
     def to_native *args
       self::Enum.to_native(*args)
     end
@@ -18,10 +26,6 @@ module GirFFI
       self.send method, *arguments, &block
     end
 
-    def gir_ffi_builder
-      self.const_get :GIR_FFI_BUILDER
-    end
-
     def to_ffitype
       self::Enum
     end

data/lib/gir_ffi/ffi_ext/pointer.rb

@@ -10,11 +10,28 @@ module GirFFI
       end
 
       def to_object
-        # TODO: Move implementation here.
-        ArgHelper.object_pointer_to_object self
+        gtype = GObject.type_from_instance_pointer self
+        wrap_by_gtype gtype
+      end
+
+      def wrap_by_gtype gtype
+        return nil if self.null?
+        klass = Builder.build_by_gtype gtype
+        klass.direct_wrap self
+      end
+
+      if RUBY_VERSION < "1.9"
+        def to_utf8
+          null? ? nil : read_string
+        end
+      else
+        def to_utf8
+          null? ? nil : read_string.force_encoding("utf-8")
+        end
       end
     end
   end
 end
 
+# TODO: Move use to InPointer and InOutPointer?
 FFI::Pointer.send :include, GirFFI::FFIExt::Pointer

data/lib/gir_ffi/in_out_pointer.rb

@@ -15,52 +15,61 @@ module GirFFI
 
     private :initialize
 
-    # TODO: Rename to get_value
+    # TODO: Create type classes that extract values from pointers.
     def to_value
       case value_ffi_type
       when Class
-        to_ptr
+        value_ffi_type.get_value_from_pointer(self)
+      # FIXME: This is a hack, since :c is not really a FFI type. Make
+      # SizedArray a type FFI understands instead.
+      when :c
+        self
       when Symbol
-        adjust_value_out self.send("get_#{value_ffi_type}", 0)
+        self.send("get_#{value_ffi_type}", 0)
+      when FFI::Enum
+        value_ffi_type[self.get_int32(0)]
       else
         raise NotImplementedError
       end
     end
 
+    # Convert more fully to a ruby value than #to_value
+    def to_ruby_value
+      bare_value = to_value
+      case value_type
+      when :utf8
+        bare_value.to_utf8
+      when Array
+        value_type[1].wrap bare_value
+      when Class
+        value_type.wrap bare_value
+      else
+        bare_value
+      end
+    end
+
     def set_value value
-      value = adjust_value_in value
       case value_ffi_type
       when Class
-        self.put_bytes 0, value.to_ptr.read_bytes(value_type_size), 0, value_type_size
+        value_ffi_type.copy_value_to_pointer(value, self)
+      # FIXME: Make SizedArray an FFI DataConverter so it conflates with the code above.
+      when :c
+        GLib::SizedArray.copy_value_to_pointer(value, self)
       when Symbol
         self.send "put_#{value_ffi_type}", 0, value
+      when FFI::Enum
+        self.send "put_int32", 0, value_ffi_type.to_native(value, nil)
       else
-        raise NotImplementedError
+        raise NotImplementedError, value_ffi_type
       end
     end
 
-    def value_ffi_type
-      @value_ffi_type ||= case value_type
-                          when :gboolean
-                            :int
-                          else
-                            TypeMap.type_specification_to_ffitype value_type
-                          end
-    end
-
-    def value_type_size
-      @value_type_size ||= case value_ffi_type
-                           when Class
-                             value_ffi_type.size
-                           when Symbol
-                             FFI.type_size value_ffi_type
-                           else
-                             raise NotImplementedError
-                           end
+    def clear
+      set_value nil_value
     end
 
     def self.for type
-      self.new(type).tap {|ptr| ptr.set_value nil}
+      self.new(type).tap {|ptr| ptr.clear}
     end
 
     def self.from type, value
@@ -69,22 +78,12 @@ module GirFFI
 
     private
 
-    def adjust_value_in value
-      case @value_type
-      when :gboolean
-        value ? 1 : 0
-      else
-        value || nil_value
-      end
+    def value_ffi_type
+      @value_ffi_type ||= TypeMap.type_specification_to_ffitype value_type
     end
 
-    def adjust_value_out value
-      case value_type
-      when :gboolean
-        value != 0
-      else
-        value
-      end
+    def value_type_size
+      @value_type_size ||= FFI.type_size value_ffi_type
     end
 
     def nil_value

data/lib/gir_ffi/in_pointer.rb

@@ -13,7 +13,11 @@ module GirFFI
       when Symbol
         from_basic_type_array type, ary
       when Class
-        from_struct_array type, ary
+        if type == GObject::Value
+          from_gvalue_array type, ary
+        else
+          from_struct_array type, ary
+        end
       when Module
         from_enum_array type, ary
       when Array
@@ -33,20 +37,26 @@ module GirFFI
       when Module
         self.new type[val]
       when :void
-        ArgHelper.object_to_inptr val
+        from_object val
       else
         raise NotImplementedError, type
       end
     end
 
     class << self
+      # FIXME: Hideous
+      def from_object obj
+        return nil if obj.nil?
+        return obj.to_ptr if obj.respond_to? :to_ptr
+
+        FFI::Pointer.new(obj.object_id).tap {|ptr|
+          ArgHelper::OBJECT_STORE[ptr.address] = obj }
+      end
 
       private
 
       def from_utf8_array ary
-        ptr_ary = ary.map {|str| from_utf8 str}
-        ptr_ary << nil
-        from_basic_type_array :pointer, ptr_ary
+        from_basic_type_array :pointer, ary.map {|str| from_utf8 str}
       end
 
       def from_boolean_array ary
@@ -54,24 +64,28 @@ module GirFFI
       end
 
       def from_interface_pointer_array ary
-        ptr_ary = ary.map {|ifc| ifc.to_ptr}
-        ptr_ary << nil
-        from_basic_type_array :pointer, ptr_ary
+        from_basic_type_array :pointer, ary.map {|ifc| ifc.to_ptr}
+      end
+
+      def from_gvalue_array type, ary
+        ary = ary.map do |it|
+          if it.is_a? GObject::Value
+            it
+          else
+            GObject::Value.wrap_ruby_value it
+          end
+        end
+        from_struct_array type, ary
       end
 
       def from_struct_array type, ary
         type_size = type::Struct.size
         length = ary.length
 
-        # TODO: Find method to directly copy bytes, rather than reading and
-        # putting them.
         ptr = AllocationHelper.safe_malloc length * type_size
-        ary.each_with_index { |item, idx|
-          ptr.put_bytes(idx * type_size,
-                        item.to_ptr.read_bytes(type_size),
-                        0,
-                        type_size)
-        }
+        ary.each_with_index do |item, idx|
+          type.copy_value_to_pointer item, ptr, idx * type_size
+        end
         new ptr
       end
 
@@ -88,11 +102,12 @@ module GirFFI
       def from_basic_type_array type, ary
         ffi_type = TypeMap.map_basic_type type
         length = ary.length
+        size = FFI.type_size ffi_type
 
-        block = ArgHelper.allocate_array_of_type ffi_type, length + 1
+        block = AllocationHelper.safe_malloc size * (length + 1)
         block.send "put_array_of_#{ffi_type}", 0, ary
         block.send("put_#{ffi_type}",
-                   length * FFI.type_size(ffi_type),
+                   length * size,
                    (ffi_type == :pointer ? nil : 0))
 
         new block