gir_ffi 0.15.1 → 0.15.6

data/test/gir_ffi/builders/base_argument_builder_test.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::BaseArgumentBuilder do
-end

data/test/gir_ffi/builders/callback_argument_builder_test.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::CallbackArgumentBuilder do
-  let(:var_gen) { GirFFI::VariableNameGenerator.new }
-  let(:builder) { GirFFI::Builders::CallbackArgumentBuilder.new(var_gen, arg_info) }
-
-  describe "for an argument with direction :out" do
-    describe "for :zero_terminated" do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data("GIMarshallingTests", "Object",
-                                     "vfunc_array_out_parameter")
-      end
-      let(:arg_info) { vfunc_info.args[0] }
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = a"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v1.put_pointer 0, GirFFI::ZeroTerminated.from(:gfloat, _v2)"]
-      end
-    end
-
-    describe "when the argument is allocated by us, the callee" do
-      let(:vfunc_info) do
-        get_vfunc_introspection_data("GIMarshallingTests", "Object",
-                                     "method_int8_arg_and_out_callee")
-      end
-
-      let(:arg_info) { vfunc_info.args[1] }
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new(:int8).tap { |ptr| out.put_pointer 0, ptr }"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v1.put_int8 0, _v2"]
-      end
-    end
-  end
-
-  describe "for an argument with direction :error" do
-    let(:arg_info) { GirFFI::ErrorArgumentInfo.new }
-
-    it "sets up a rescueing block in #pre_conversion" do
-      _(builder.pre_conversion).must_equal [
-        "_v1 = _error",
-        "begin"
-      ]
-    end
-
-    it "converts any exceptions to GLib::Error in #post_conversion" do
-      _(builder.post_conversion).must_equal [
-        "rescue => _v1",
-        "_v2.put_pointer 0, GLib::Error.from(_v1)",
-        "end"
-      ]
-    end
-  end
-
-  describe "for an argument with direction :inout" do
-    let(:callback_info) do
-      get_introspection_data("Regress",
-                             "TestCallbackArrayInOut")
-    end
-    let(:array_arg_info) { callback_info.args[0] }
-    let(:array_arg_builder) do
-      GirFFI::Builders::CallbackArgumentBuilder.new(var_gen, array_arg_info)
-    end
-    let(:length_arg_info) { callback_info.args[1] }
-    let(:length_arg_builder) do
-      GirFFI::Builders::CallbackArgumentBuilder.new(var_gen, length_arg_info)
-    end
-
-    before do
-      length_arg_builder.array_arg = array_arg_builder
-      array_arg_builder.length_arg = length_arg_builder
-    end
-
-    describe "for arrays with a length argument" do
-      it "provides a call argument name" do
-        _(array_arg_builder.call_argument_name).must_equal "_v1"
-      end
-
-      it "provides a capture variable name" do
-        _(array_arg_builder.capture_variable_name).must_equal "_v1"
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(array_arg_builder.pre_conversion)
-          .must_equal ["_v1 = ints",
-                       "_v2 = GirFFI::SizedArray.wrap(:gint32, _v3, _v1.get_pointer(0))"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        array_arg_builder.pre_conversion
-        _(array_arg_builder.post_conversion)
-          .must_equal ["_v1.put_pointer 0, GirFFI::SizedArray.from(:gint32, -1, _v4)"]
-      end
-    end
-
-    describe "for an array length argument" do
-      it "does not provide a call argument name" do
-        _(length_arg_builder.call_argument_name).must_be_nil
-      end
-
-      it "does not provide a capture variable name" do
-        _(length_arg_builder.capture_variable_name).must_be_nil
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(length_arg_builder.pre_conversion)
-          .must_equal ["_v1 = length",
-                       "_v2 = _v1.get_int32(0)"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        length_arg_builder.pre_conversion
-        _(length_arg_builder.post_conversion)
-          .must_equal ["_v1.put_int32 0, _v3.length"]
-      end
-    end
-  end
-end

data/test/gir_ffi/builders/callback_builder_test.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::CallbackBuilder do
-  let(:builder) { GirFFI::Builders::CallbackBuilder.new callback_info }
-
-  describe "#mapping_method_definition" do
-    describe "for a callback with arguments and return value" do
-      let(:callback_info) { get_introspection_data "Regress", "TestCallbackFull" }
-      it "returns a valid mapping method" do
-        expected = <<~CODE
-          def self.call_with_argument_mapping(_proc, foo, bar, path)
-            _v1 = foo
-            _v2 = bar
-            _v3 = path.to_utf8
-            _v4 = _proc.call(_v1, _v2, _v3)
-            return _v4
-          end
-        CODE
-
-        _(builder.mapping_method_definition).must_equal expected
-      end
-    end
-
-    describe "for a callback with no arguments or return value" do
-      let(:callback_info) { get_introspection_data "Regress", "TestSimpleCallback" }
-      it "returns a valid mapping method" do
-        expected = <<~CODE
-          def self.call_with_argument_mapping(_proc)
-            _proc.call()
-          end
-        CODE
-
-        _(builder.mapping_method_definition).must_equal expected
-      end
-    end
-
-    describe "for a callback with a closure argument" do
-      let(:callback_info) { get_introspection_data "Regress", "TestCallbackUserData" }
-      it "returns a valid mapping method" do
-        expected = <<~CODE
-          def self.call_with_argument_mapping(_proc, user_data)
-            _v1 = GirFFI::ArgHelper::OBJECT_STORE.fetch(user_data)
-            _v2 = _proc.call(_v1)
-            return _v2
-          end
-        CODE
-
-        _(builder.mapping_method_definition).must_equal expected
-      end
-    end
-
-    describe "for a callback with one out argument" do
-      let(:callback_info) do
-        get_introspection_data("GIMarshallingTests",
-                               "CallbackOneOutParameter")
-      end
-      it "returns a valid mapping method" do
-        expected = <<~CODE
-          def self.call_with_argument_mapping(_proc, a)
-            _v1 = a
-            _v2 = _proc.call()
-            _v1.put_float 0, _v2
-          end
-        CODE
-
-        _(builder.mapping_method_definition).must_equal expected
-      end
-    end
-
-    describe "for a callback with an inout array argument" do
-      let(:callback_info) do
-        get_introspection_data("Regress",
-                               "TestCallbackArrayInOut")
-      end
-      it "returns a valid mapping method" do
-        expected = <<~CODE
-          def self.call_with_argument_mapping(_proc, ints, length)
-            _v1 = length
-            _v2 = _v1.get_int32(0)
-            _v3 = ints
-            _v4 = GirFFI::SizedArray.wrap(:gint32, _v2, _v3.get_pointer(0))
-            _v5 = _proc.call(_v4)
-            _v1.put_int32 0, _v5.length
-            _v3.put_pointer 0, GirFFI::SizedArray.from(:gint32, -1, _v5)
-          end
-        CODE
-
-        _(builder.mapping_method_definition).must_equal expected
-      end
-    end
-
-    describe "for a callback with a value in argument" do
-      let(:field_info) do
-        get_field_introspection_data("GObject",
-                                     "ObjectClass", "get_property")
-      end
-      let(:callback_info) do
-        field_info.field_type.interface
-      end
-      it "returns a valid mapping method" do
-        expected = <<~CODE
-          def self.call_with_argument_mapping(_proc, object, property_id, value, pspec)
-            _v1 = GObject::Object.wrap(object)
-            _v2 = property_id
-            _v3 = GObject::Value.wrap(value)
-            _v4 = GObject::ParamSpec.wrap(pspec)
-            _proc.call(_v1, _v2, _v3, _v4)
-          end
-        CODE
-
-        _(builder.mapping_method_definition).must_equal expected
-      end
-    end
-  end
-end

data/test/gir_ffi/builders/callback_return_value_builder_test.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::CallbackReturnValueBuilder do
-  let(:var_gen) { GirFFI::VariableNameGenerator.new }
-  let(:return_value_info) { GirFFI::ReturnValueInfo.new(type_info, ownership_transfer, false) }
-  let(:type_info) { callback_info.return_type }
-  let(:ownership_transfer) { callback_info.caller_owns }
-  let(:builder) do
-    GirFFI::Builders::CallbackReturnValueBuilder.new(var_gen,
-                                                     return_value_info)
-  end
-
-  describe "for :gint32" do
-    let(:callback_info) { get_introspection_data("GIMarshallingTests", "CallbackIntInt") }
-
-    it "has no statements in #post_conversion" do
-      _(builder.post_conversion).must_equal []
-    end
-
-    it "returns the result of the callback directly" do
-      _(builder.capture_variable_name).must_equal "_v1"
-      _(builder.return_value_name).must_equal "_v1"
-    end
-  end
-
-  describe "for :void" do
-    let(:callback_info) do
-      get_introspection_data("GIMarshallingTests",
-                             "CallbackMultipleOutParameters")
-    end
-
-    it "has no statements in #post_conversion" do
-      _(builder.post_conversion).must_equal []
-    end
-
-    it "returns nothing" do
-      _(builder.capture_variable_name).must_be_nil
-      _(builder.return_value_name).must_be_nil
-    end
-  end
-
-  describe "for :enum" do
-    let(:callback_info) do
-      get_vfunc_introspection_data("GIMarshallingTests",
-                                   "Object",
-                                   "vfunc_return_enum")
-    end
-
-    it "converts the result" do
-      # Ensure variable names are generated in order
-      _(builder.capture_variable_name).must_equal "_v1"
-      _(builder.post_conversion).must_equal ["_v2 = GIMarshallingTests::Enum.to_int(_v1)"]
-    end
-
-    it "returns the result of the conversion" do
-      _(builder.capture_variable_name).must_equal "_v1"
-      _(builder.return_value_name).must_equal "_v2"
-    end
-  end
-
-  describe "for :object with full transfer" do
-    let(:callback_info) do
-      get_vfunc_introspection_data("GIMarshallingTests",
-                                   "Object",
-                                   "vfunc_return_object_transfer_full")
-    end
-
-    it "increases the refcount of the result and converts it to a pointer" do
-      # Ensure variable names are generated in order
-      _(builder.capture_variable_name).must_equal "_v1"
-      _(builder.post_conversion).must_equal ["_v1.ref", "_v2 = GObject::Object.from(_v1).to_ptr"]
-    end
-
-    it "returns the result of the conversion" do
-      _(builder.capture_variable_name).must_equal "_v1"
-      _(builder.return_value_name).must_equal "_v2"
-    end
-  end
-end

data/test/gir_ffi/builders/constant_builder_test.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::ConstantBuilder do
-end

data/test/gir_ffi/builders/constructor_builder_test.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::ConstructorBuilder do
-  describe "#method_definition" do
-    let(:builder) { GirFFI::Builders::ConstructorBuilder.new function_info }
-    let(:code) { builder.method_definition }
-
-    describe "for constructors with the default name" do
-      let(:function_info) { get_method_introspection_data "Regress", "TestObj", "new" }
-      it "builds a constructor" do
-        _(code).must_equal <<~CODE
-          def self.new(*args, &block)
-            obj = allocate
-            obj.__send__ :initialize, *args, &block
-            obj
-          end
-        CODE
-      end
-    end
-
-    describe "for constructors with a custom name" do
-      let(:function_info) { get_method_introspection_data "Regress", "TestObj", "new_from_file" }
-      it "builds a custom constructor" do
-        _(code).must_equal <<~CODE
-          def self.new_from_file(*args, &block)
-            raise NoMethodError unless self == Regress::TestObj
-            obj = allocate
-            obj.__send__ :initialize_from_file, *args, &block
-            obj
-          end
-        CODE
-      end
-    end
-  end
-end

data/test/gir_ffi/builders/enum_builder_test.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::EnumBuilder do
-  describe "#build_class" do
-    let(:info) { get_introspection_data "Regress", "TestEnum" }
-    let(:builder) { GirFFI::Builders::EnumBuilder.new info }
-
-    it "makes the created type know its proper name" do
-      enum = builder.build_class
-      _(enum.inspect).must_equal "Regress::TestEnum"
-    end
-
-    it "adds constants for the values" do
-      enum = builder.build_class
-      _(enum::VALUE1).must_equal enum[:value1]
-      _(enum::VALUE2).must_equal enum[:value2]
-      _(enum::VALUE3).must_equal enum[:value3]
-      _(enum::VALUE4).must_equal enum[:value4]
-    end
-  end
-end

data/test/gir_ffi/builders/field_builder_test.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::FieldBuilder do
-  let(:target_class) { "dummy" }
-  let(:instance) { GirFFI::Builders::FieldBuilder.new field_info, target_class }
-
-  describe "for a field of type :gint8 with an offset" do
-    let(:field_info) { get_field_introspection_data "Regress", "TestSimpleBoxedA", "some_int8" }
-    it "creates the right getter method" do
-      expected = <<~CODE
-        def some_int8
-          _v1 = @struct.to_ptr
-          _v2 = _v1.get_int8(#{field_info.offset})
-          _v2
-        end
-      CODE
-      _(instance.getter_def).must_equal expected
-    end
-
-    it "creates the right setter method" do
-      expected = <<~CODE
-        def some_int8= value
-          _v1 = @struct.to_ptr
-          _v2 = value
-          _v1.put_int8 #{field_info.offset}, _v2
-        end
-      CODE
-      _(instance.setter_def).must_equal expected
-    end
-  end
-
-  describe "for a field of type :struct" do
-    let(:field_info) { get_field_introspection_data "Regress", "TestBoxed", "nested_a" }
-    it "creates the right getter method" do
-      expected = <<~CODE
-        def nested_a
-          _v1 = @struct.to_ptr
-          _v2 = Regress::TestSimpleBoxedA.get_value_from_pointer(_v1, #{field_info.offset})
-          _v3 = Regress::TestSimpleBoxedA.wrap(_v2)
-          _v3
-        end
-      CODE
-      _(instance.getter_def).must_equal expected
-    end
-
-    it "creates the right setter method" do
-      expected = <<~CODE
-        def nested_a= value
-          _v1 = @struct.to_ptr
-          _v2 = Regress::TestSimpleBoxedA.copy_from(value)
-          Regress::TestSimpleBoxedA.copy_value_to_pointer(_v2, _v1, #{field_info.offset})
-        end
-      CODE
-      _(instance.setter_def).must_equal expected
-    end
-  end
-
-  describe "for a field of type :enum" do
-    let(:field_info) { get_field_introspection_data "Regress", "TestStructA", "some_enum" }
-    it "creates the right getter method" do
-      expected = <<~CODE
-        def some_enum
-          _v1 = @struct.to_ptr
-          _v2 = Regress::TestEnum.get_value_from_pointer(_v1, #{field_info.offset})
-          _v2
-        end
-      CODE
-      _(instance.getter_def).must_equal expected
-    end
-  end
-
-  describe "for an inline fixed-size array field" do
-    let(:field_info) { get_field_introspection_data "Regress", "TestStructE", "some_union" }
-    it "creates the right getter method" do
-      expected = <<~CODE
-        def some_union
-          _v1 = @struct.to_ptr
-          _v2 = GirFFI::SizedArray.get_value_from_pointer(_v1, #{field_info.offset})
-          _v3 = GirFFI::SizedArray.wrap(Regress::TestStructE__some_union__union, 2, _v2)
-          _v3
-        end
-      CODE
-      _(instance.getter_def).must_equal expected
-    end
-
-    it "creates the right setter method" do
-      expected = <<~CODE
-        def some_union= value
-          _v1 = @struct.to_ptr
-          GirFFI::ArgHelper.check_fixed_array_size 2, value, \"value\"
-          _v2 = GirFFI::SizedArray.copy_from(Regress::TestStructE__some_union__union, 2, value)
-          GirFFI::SizedArray.copy_value_to_pointer(_v2, _v1, #{field_info.offset})
-        end
-      CODE
-      _(instance.setter_def).must_equal expected
-    end
-  end
-
-  describe "for a field of type :callback" do
-    let(:field_info) { get_field_introspection_data "GObject", "TypeInfo", "class_init" }
-    it "creates the right setter method" do
-      expected = <<~CODE
-        def class_init= value
-          _v1 = @struct.to_ptr
-          _v2 = GObject::ClassInitFunc.from(value)
-          GObject::ClassInitFunc.copy_value_to_pointer(_v2, _v1, #{field_info.offset})
-        end
-      CODE
-      _(instance.setter_def).must_equal expected
-    end
-  end
-
-  describe "for a field with a related array length field" do
-    let(:field_info) { get_field_introspection_data "GObject", "SignalQuery", "param_types" }
-    let(:n_params_field_info) { get_field_introspection_data "GObject", "SignalQuery", "n_params" }
-
-    it "creates the right getter method" do
-      skip if field_info.field_type.array_length < 0
-      expected = <<~CODE
-        def param_types
-          _v1 = @struct.to_ptr
-          _v2 = _v1.get_uint32(#{n_params_field_info.offset})
-          _v3 = @struct.to_ptr
-          _v4 = _v3.get_pointer(#{field_info.offset})
-          _v5 = GirFFI::SizedArray.wrap(:GType, _v2, _v4)
-          _v5
-        end
-      CODE
-      _(instance.getter_def).must_equal expected
-    end
-  end
-end