gir_ffi 0.6.6 → 0.6.7

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

@@ -1,62 +0,0 @@
-require 'gir_ffi/builder/type/base'
-require 'gir_ffi/class_base'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # Base class for type builders building types specified by subtypes
-      # of IRegisteredTypeInfo. These are types whose C representation is
-      # complex, i.e., a struct or a union.
-      class RegisteredType < Base
-        private
-
-        def setup_constants
-          @klass.const_set :GIR_INFO, info
-          @klass.const_set :GIR_FFI_BUILDER, self
-        end
-
-        def already_set_up
-          const_defined_for @klass, :GIR_FFI_BUILDER
-        end
-
-        def target_gtype
-          info.g_type
-        end
-
-        # TODO: Rename the created method, or use a constant.
-        # FIXME: Only used in some of the subclases. Make mixin?
-        def setup_gtype_getter
-          gtype = target_gtype
-          return if gtype.nil?
-          @klass.instance_eval "
-            def self.get_gtype
-              #{gtype}
-            end
-          "
-        end
-
-        # FIXME: Only used in some of the subclases. Make mixin?
-        def provide_constructor
-          return if info.find_method 'new'
-
-          (class << @klass; self; end).class_eval {
-            alias_method :new, :_allocate
-          }
-        end
-
-        def parent
-          nil
-        end
-
-        def fields
-          info.fields
-        end
-
-        def superclass
-          @superclass ||= ClassBase
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'gir_ffi/builder/type/registered_type'
-require 'gir_ffi/builder/type/with_layout'
-require 'gir_ffi/builder/type/with_methods'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # Implements the creation of a class representing a Struct.
-      class Struct < RegisteredType
-        include WithMethods
-        include WithLayout
-
-        private
-
-        def setup_class
-          setup_layout
-          setup_constants
-          stub_methods
-          setup_gtype_getter
-          setup_field_accessors
-          provide_constructor
-        end
-
-        # FIXME: Private method only in subclass
-        def layout_superclass
-          FFI::Struct
-        end
-      end
-    end
-  end
-end
-
-

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

@@ -1,39 +0,0 @@
-require 'gir_ffi/builder/type/object'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # Implements the creation of a class representing an object type for
-      # which no data is found in the GIR. Typically, these are created to
-      # cast objects returned by a function that returns an interface.
-      class Unintrospectable < Object
-        def instantiate_class
-          gtype = target_gtype
-          CACHE[gtype] ||= Class.new(superclass)
-          @klass = CACHE[gtype]
-          @structklass = get_or_define_class @klass, :Struct, layout_superclass
-          setup_class unless already_set_up
-        end
-
-        def setup_class
-          setup_constants
-          setup_layout
-          setup_interfaces
-          setup_gtype_getter
-        end
-
-        def setup_instance_method method
-          false
-        end
-
-        private
-
-        def signal_definers
-          info.interfaces
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,34 +0,0 @@
-require 'gir_ffi/builder/type/registered_type'
-require 'gir_ffi/builder/type/with_layout'
-require 'gir_ffi/builder/type/with_methods'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # Implements the creation of a class representing union type. The
-      # class will have a nested FFI::Union class to represent its C union.
-      class Union < RegisteredType
-        include WithMethods
-        include WithLayout
-
-        private
-
-        def setup_class
-          setup_layout
-          setup_constants
-          stub_methods
-          setup_gtype_getter
-          setup_field_accessors
-          provide_constructor
-        end
-
-        def layout_superclass
-          FFI::Union
-        end
-      end
-    end
-  end
-end
-
-

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

@@ -1,107 +0,0 @@
-require 'gir_ffi/builder/type/object'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # Implements the creation of GObject subclasses from Ruby.
-      class UserDefined < Object
-        def initialize info
-          @info = info
-        end
-
-        def instantiate_class
-          @klass = @info.described_class
-
-          parent_type = @klass.get_gtype
-          @parent = gir.find_by_gtype(parent_type)
-
-          query_result = GObject.type_query parent_type
-          type_info = GObject::TypeInfo.new
-          type_info.class_size = query_result.class_size
-          type_info.instance_size = query_result.instance_size
-          properties.each do
-            type_info.instance_size += FFI.type_size(:int32)
-          end
-
-          @gtype = GObject.type_register_static(parent_type, @klass.name,
-                                                type_info, 0)
-
-          @structklass = get_or_define_class @klass, :Struct, layout_superclass
-          setup_class unless already_set_up
-          CACHE[@gtype] = @klass
-        end
-
-        def setup_class
-          setup_layout
-          setup_constants
-          #stub_methods
-          setup_gtype_getter
-          setup_property_accessors
-          #setup_vfunc_invokers
-          #setup_interfaces
-          setup_constructor
-        end
-
-        private
-
-        def target_gtype
-          @gtype
-        end
-
-        def parent
-          @parent
-        end
-
-        def properties
-          info.properties
-        end
-
-        def layout_specification
-          parent_spec = [:parent, superclass::Struct, 0]
-          offset = superclass::Struct.size
-          fields_spec = properties.map do |pinfo|
-            spec = [pinfo.name.to_sym, :int32, offset]
-            offset += FFI.type_size(:int32)
-            spec
-          end.flatten(1)
-          parent_spec + fields_spec
-        end
-
-        def setup_property_accessors
-          properties.each do |pinfo|
-            setup_accessors_for_param_info pinfo
-          end
-        end
-
-        def setup_accessors_for_param_info pinfo
-          code = <<-CODE
-          def #{pinfo.name}
-            @struct[:#{pinfo.name}]
-          end
-          def #{pinfo.name}= val
-            @struct[:#{pinfo.name}] = val
-          end
-          CODE
-
-          @klass.class_eval code
-        end
-
-        def method_introspection_data method
-          nil
-        end
-
-        def setup_constructor
-          code = <<-CODE
-          def self.new
-            gptr = GObject::Lib.g_object_newv #{@gtype}, 0, nil
-            self.wrap(gptr)
-          end
-          CODE
-          @klass.class_eval code
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,62 +0,0 @@
-require 'gir_ffi/builder/field'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # 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
-        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 layout_specification
-          spec = base_layout_specification
-          if spec.empty?
-            dummy_layout_specification
-          else
-            spec
-          end
-        end
-
-        def setup_accessors_for_field_info finfo
-          builder = Builder::Field.new(finfo, lib, @structklass)
-          unless has_instance_method finfo.name
-            @klass.class_eval builder.getter_def
-          end
-          @klass.class_eval builder.setter_def if finfo.writable?
-        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
-end

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

@@ -1,64 +0,0 @@
-require 'gir_ffi/method_stubber'
-
-module GirFFI
-  module Builder
-    module Type
-
-      # Implements method creation for types such as, :union, :struct,
-      # :object, :interface.
-      module WithMethods
-        def setup_method method
-          go = method_introspection_data method
-          attach_and_define_method method, go, meta_class
-        end
-
-        def setup_instance_method method
-          go = instance_method_introspection_data method
-          attach_and_define_method method, go, build_class
-        end
-
-        def has_instance_method method
-          !!instance_method_introspection_data(method)
-        end
-
-        private
-
-        def meta_class
-          klass = build_class
-          return (class << klass; self; end)
-        end
-
-        def method_introspection_data method
-          info.find_method method
-        end
-
-        def instance_method_introspection_data method
-          data = method_introspection_data method
-          return data if data && data.method?
-        end
-
-        def function_definition_builder go
-          FunctionBuilder.new(go, lib)
-        end
-
-        def function_definition go
-          function_definition_builder(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
-end

data/lib/gir_ffi/callback.rb

@@ -1,72 +0,0 @@
-module GirFFI
-  # Specialized kind of Proc to be used for callback arguments.
-  # TODO: Create superclass for all actual callback types that does the wrapping for this.
-  class Callback < Proc
-    # Create Callback from a Proc. Makes sure arguments are properly wrapped,
-    # and the callback is stored to prevent garbage collection.
-    def self.from namespace, name, prc
-      wrap_in_callback_args_mapper(namespace, name, prc).tap do |cb|
-        CallbackHelper.store_callback cb
-      end
-    end
-
-    # TODO: Create actual callback class from the callback info, so no lookup
-    # is needed. This class can then also perform the argument mapping.
-    def self.wrap_in_callback_args_mapper namespace, name, prc
-      return prc if FFI::Function === prc
-      return nil if prc.nil?
-      info = GObjectIntrospection::IRepository.default.find_by_name namespace, name
-      return self.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.argument_type }
-    end
-
-    # TODO: Use GirFFI::ReturnValue classes for mapping.
-    def self.map_single_callback_arg arg, type
-      case type.tag
-      when :interface
-        map_interface_callback_arg arg, type
-      when :utf8
-        ArgHelper.ptr_to_utf8 arg
-      when :void
-        map_void_callback_arg arg
-      when :array
-        subtype = type.param_type(0)
-        if subtype.tag == :interface and arg.is_a?(FFI::Pointer)
-          map_interface_callback_arg arg, subtype
-        else
-          raise NotImplementedError
-        end
-      else
-        arg
-      end
-    end
-
-    def self.map_interface_callback_arg arg, type
-      iface = type.interface
-      case iface.info_type
-      when :object, :interface
-        arg.to_object
-      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
-        GirFFI::ArgHelper::OBJECT_STORE[arg.address]
-      end
-    end
-
-  end
-end