gir_ffi 0.14.0 → 0.15.3

data/test/gir_ffi/builders/vfunc_argument_builder_test.rb

@@ -1,101 +1,107 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::Builders::VFuncArgumentBuilder do
   let(:var_gen) { GirFFI::VariableNameGenerator.new }
   let(:builder) { GirFFI::Builders::VFuncArgumentBuilder.new(var_gen, arg_info) }
 
-  describe 'for a plain in argument' do
+  describe "for a plain in argument" do
     let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
+      get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in"
     end
     let(:arg_info) { vfunc_info.args[0] }
 
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = in_']
+    it "has the correct value for #pre_conversion" do
+      _(builder.pre_conversion).must_equal ["_v1 = in_"]
     end
 
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal []
+    it "has the correct value for #post_conversion" do
+      _(builder.post_conversion).must_equal []
     end
   end
 
-  describe 'for a transfer-none in argument' do
+  describe "for a transfer-none in argument" do
     let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_in_object_transfer_none'
+      get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                   "vfunc_in_object_transfer_none"
     end
     let(:arg_info) { vfunc_info.args[0] }
 
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = GObject::Object.wrap(object)', '_v1.ref']
+    it "has the correct value for #pre_conversion" do
+      _(builder.pre_conversion).must_equal ["_v1 = GObject::Object.wrap(object)", "_v1.ref"]
     end
 
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal []
+    it "has the correct value for #post_conversion" do
+      _(builder.post_conversion).must_equal []
     end
   end
 
-  describe 'for a transfer-none outgoing object argument' do
+  describe "for a transfer-none outgoing object argument" do
     let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_out_object_transfer_none'
+      get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                   "vfunc_out_object_transfer_none"
     end
     let(:arg_info) { vfunc_info.args[0] }
 
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = object']
+    it "has the correct value for #pre_conversion" do
+      _(builder.pre_conversion).must_equal ["_v1 = object"]
     end
 
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal ['_v1.put_pointer 0, GObject::Object.from(_v2)']
+    it "has the correct value for #post_conversion" do
+      _(builder.post_conversion).must_equal ["_v1.put_pointer 0, GObject::Object.from(_v2)"]
     end
   end
 
-  describe 'for a full-transfer outgoing object argument' do
+  describe "for a full-transfer outgoing object argument" do
     let(:vfunc_info) do
-      get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_out_object_transfer_full'
+      get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                   "vfunc_out_object_transfer_full"
     end
     let(:arg_info) { vfunc_info.args[0] }
 
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.must_equal ['_v1 = object']
+    it "has the correct value for #pre_conversion" do
+      _(builder.pre_conversion).must_equal ["_v1 = object"]
     end
 
-    it 'has the correct value for #post_conversion' do
+    it "has the correct value for #post_conversion" do
       builder.pre_conversion
-      builder.post_conversion.must_equal ['_v2.ref', '_v1.put_pointer 0, GObject::Object.from(_v2)']
+      _(builder.post_conversion)
+        .must_equal ["_v2.ref", "_v1.put_pointer 0, GObject::Object.from(_v2)"]
     end
   end
 
-  describe 'for a full-transfer outgoing non-object argument' do
+  describe "for a full-transfer outgoing non-object argument" do
     let(:vfunc_info) do
-      get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                   'method_int8_arg_and_out_callee')
+      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 }']
+    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']
+    it "has the correct value for #post_conversion" do
+      _(builder.post_conversion).must_equal ["_v1.put_int8 0, _v2"]
     end
   end
 
-  describe 'for a receiver argument' do
-    let(:object_info) { get_introspection_data('GIMarshallingTests', 'Object') }
+  describe "for a receiver argument" do
+    let(:object_info) { get_introspection_data("GIMarshallingTests", "Object") }
     let(:type_info) { GirFFI::ReceiverTypeInfo.new(object_info) }
     let(:arg_info) { GirFFI::ReceiverArgumentInfo.new(type_info) }
 
-    it 'has the correct value for #pre_conversion' do
-      builder.pre_conversion.
-        must_equal ['_v1 = GIMarshallingTests::Object.wrap(_instance)']
+    it "has the correct value for #pre_conversion" do
+      _(builder.pre_conversion)
+        .must_equal ["_v1 = GIMarshallingTests::Object.wrap(_instance)"]
     end
 
-    it 'has the correct value for #post_conversion' do
-      builder.post_conversion.must_equal []
+    it "has the correct value for #post_conversion" do
+      _(builder.post_conversion).must_equal []
     end
   end
 end

data/test/gir_ffi/builders/vfunc_builder_test.rb

@@ -1,252 +1,244 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::Builders::VFuncBuilder do
   let(:builder) { GirFFI::Builders::VFuncBuilder.new vfunc_info }
 
-  describe '#mapping_method_definition' do
+  describe "#mapping_method_definition" do
     let(:result) { builder.mapping_method_definition }
 
-    before do
-      skip unless vfunc_info
-    end
-
-    describe 'for a vfunc with only one argument' do
+    describe "for a vfunc with only one argument" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in"
       end
 
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, in_)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = in_
-          _proc.call(_v1, _v2)
-        end
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, in_)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = in_
+            _proc.call(_v1, _v2)
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc returning an enum' do
+    describe "for a vfunc returning an enum" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_return_enum'
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_return_enum"
       end
 
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = _proc.call(_v1)
-          _v3 = GIMarshallingTests::Enum.to_int(_v2)
-          return _v3
-        end
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = _proc.call(_v1)
+            _v3 = GIMarshallingTests::Enum.to_int(_v2)
+            return _v3
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with a callback argument' do
+    describe "for a vfunc with a callback argument" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_with_callback'
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "vfunc_with_callback"
       end
 
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, callback, callback_data)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = GIMarshallingTests::CallbackIntInt.wrap(callback)
-          _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(callback_data)
-          _proc.call(_v1, _v2, _v3)
-        end
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, callback, callback_data)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = GIMarshallingTests::CallbackIntInt.wrap(callback)
+            _v3 = GirFFI::ArgHelper::OBJECT_STORE.fetch(callback_data)
+            _proc.call(_v1, _v2, _v3)
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with an out argument allocated by them, the caller' do
+    describe "for a vfunc with an out argument allocated by them, the caller" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'method_int8_arg_and_out_caller')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, arg, out)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = arg
-          _v3 = out
-          _v4 = _proc.call(_v1, _v2)
-          _v3.put_int8 0, _v4
-        end
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "method_int8_arg_and_out_caller")
+      end
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, arg, out)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = arg
+            _v3 = out
+            _v4 = _proc.call(_v1, _v2)
+            _v3.put_int8 0, _v4
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with an out argument allocated by us, the callee' do
+    describe "for a vfunc with an out argument allocated by the callee" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'method_int8_arg_and_out_callee')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, arg, out)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = arg
-          _v3 = FFI::MemoryPointer.new(:int8).tap { |ptr| out.put_pointer 0, ptr }
-          _v4 = _proc.call(_v1, _v2)
-          _v3.put_int8 0, _v4
-        end
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "method_int8_arg_and_out_callee")
+      end
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, arg, out)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = arg
+            _v3 = FFI::MemoryPointer.new(:int8).tap { |ptr| out.put_pointer 0, ptr }
+            _v4 = _proc.call(_v1, _v2)
+            _v3.put_int8 0, _v4
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with a GObject::Value out argument allocated by them, the caller' do
+    describe "for a vfunc with a GObject::Value out argument allocated by the caller" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'vfunc_caller_allocated_out_parameter')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, a)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = a
-          _v3 = _proc.call(_v1)
-          GObject::Value.copy_value_to_pointer(GObject::Value.from(_v3), _v2)
-        end
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "vfunc_caller_allocated_out_parameter")
+      end
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, a)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = a
+            _v3 = _proc.call(_v1)
+            GObject::Value.copy_value_to_pointer(GObject::Value.from(_v3), _v2)
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with an error argument' do
+    describe "for a vfunc with an error argument" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data('GIMarshallingTests', 'Object',
-                                     'vfunc_meth_with_err')
-      end
-
-      it 'returns a valid mapping method including receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, x, _error)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = x
-          _v3 = _error
-          begin
-          _v4 = _proc.call(_v1, _v2)
-          rescue => _v5
-          _v3.put_pointer 0, GLib::Error.from(_v5)
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "vfunc_meth_with_err")
+      end
+
+      it "returns a valid mapping method including receiver" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, x, _error)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = x
+            _v3 = _error
+            begin
+            _v4 = _proc.call(_v1, _v2)
+            rescue => _v5
+            _v3.put_pointer 0, GLib::Error.from(_v5)
+            end
+            return _v4
           end
-          return _v4
-        end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with a full-transfer return value' do
+    describe "for a vfunc with a full-transfer return value" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_return_object_transfer_full'
-      end
-
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = _proc.call(_v1)
-          _v2.ref
-          _v3 = GObject::Object.from(_v2).to_ptr
-          return _v3
-        end
+        get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                     "vfunc_return_object_transfer_full"
+      end
+
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = _proc.call(_v1)
+            _v2.ref
+            _v3 = GObject::Object.from(_v2).to_ptr
+            return _v3
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with a transfer-none in argument' do
+    describe "for a vfunc with a transfer-none in argument" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_in_object_transfer_none'
+        get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                     "vfunc_in_object_transfer_none"
       end
 
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, object)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = GObject::Object.wrap(object)
-          _v2.ref
-          _proc.call(_v1, _v2)
-        end
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, object)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = GObject::Object.wrap(object)
+            _v2.ref
+            _proc.call(_v1, _v2)
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
 
-    describe 'for a vfunc with a full-transfer outgoing argument' do
+    describe "for a vfunc with a full-transfer outgoing argument" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_out_object_transfer_full'
-      end
-
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, _instance, object)
-          _v1 = GIMarshallingTests::Object.wrap(_instance)
-          _v2 = object
-          _v3 = _proc.call(_v1)
-          _v3.ref
-          _v2.put_pointer 0, GObject::Object.from(_v3)
-        end
+        get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                     "vfunc_out_object_transfer_full"
+      end
+
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.call_with_argument_mapping(_proc, _instance, object)
+            _v1 = GIMarshallingTests::Object.wrap(_instance)
+            _v2 = object
+            _v3 = _proc.call(_v1)
+            _v3.ref
+            _v2.put_pointer 0, GObject::Object.from(_v3)
+          end
         CODE
 
-        result.must_equal expected
+        _(result).must_equal expected
       end
     end
   end
 
-  describe '#argument_ffi_types' do
+  describe "#argument_ffi_types" do
     let(:result) { builder.argument_ffi_types }
 
-    before do
-      skip unless vfunc_info
-    end
-
-    describe 'for a vfunc with only one argument' do
+    describe "for a vfunc with only one argument" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
+        get_vfunc_introspection_data "GIMarshallingTests", "Object", "method_int8_in"
       end
 
-      it 'returns the correct FFI types including :pointer for the receiver' do
-        result.must_equal [:pointer, :int8]
+      it "returns the correct FFI types including :pointer for the receiver" do
+        _(result).must_equal [:pointer, :int8]
       end
     end
   end
 
-  describe '#return_ffi_type' do
+  describe "#return_ffi_type" do
     let(:result) { builder.return_ffi_type }
 
-    before do
-      skip unless vfunc_info
-    end
-
-    describe 'for a vfunc returning an object' do
+    describe "for a vfunc returning an object" do
       let(:vfunc_info) do
-        get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_return_object_transfer_full'
+        get_vfunc_introspection_data "GIMarshallingTests", "Object",
+                                     "vfunc_return_object_transfer_full"
       end
 
-      it 'returns :pointer' do
-        result.must_equal :pointer
+      it "returns :pointer" do
+        _(result).must_equal :pointer
       end
     end
   end