gir_ffi 0.14.0 → 0.15.3

data/test/gir_ffi/builders/base_argument_builder_test.rb

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

data/test/gir_ffi/builders/callback_argument_builder_test.rb

@@ -1,71 +1,73 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+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
+  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')
+        get_vfunc_introspection_data("GIMarshallingTests", "Object",
+                                     "vfunc_array_out_parameter")
       end
       let(:arg_info) { vfunc_info.args[0] }
 
-      before { skip unless vfunc_info }
-
-      it 'has the correct value for #pre_conversion' do
-        builder.pre_conversion.must_equal ['_v1 = a']
+      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)']
+      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
+    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')
+        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
   end
 
-  describe 'for an argument with direction :error' do
+  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'
+    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'
+    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
+  describe "for an argument with direction :inout" do
     let(:callback_info) do
-      get_introspection_data('Regress',
-                             'TestCallbackArrayInOut')
+      get_introspection_data("Regress",
+                             "TestCallbackArrayInOut")
     end
     let(:array_arg_info) { callback_info.args[0] }
     let(:array_arg_builder) do
@@ -77,52 +79,51 @@ describe GirFFI::Builders::CallbackArgumentBuilder do
     end
 
     before do
-      skip unless callback_info
       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'
+    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'
+      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))']
+      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
+      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)']
+        _(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
+    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
+      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)']
+      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
+      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']
+        _(length_arg_builder.post_conversion)
+          .must_equal ["_v1.put_int32 0, _v3.length"]
       end
     end
   end

data/test/gir_ffi/builders/callback_builder_test.rb

@@ -1,117 +1,116 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+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.reset_indentation
-        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
+  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
+        _(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.reset_indentation
-        def self.call_with_argument_mapping(_proc)
-          _proc.call()
-        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
+        _(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.reset_indentation
-        def self.call_with_argument_mapping(_proc, user_data)
-          _v1 = GirFFI::ArgHelper::OBJECT_STORE.fetch(user_data)
-          _v2 = _proc.call(_v1)
-          return _v2
-        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
+        _(builder.mapping_method_definition).must_equal expected
       end
     end
 
-    describe 'for a callback with one out argument' do
+    describe "for a callback with one out argument" do
       let(:callback_info) do
-        get_introspection_data('GIMarshallingTests',
-                               'CallbackOneOutParameter')
+        get_introspection_data("GIMarshallingTests",
+                               "CallbackOneOutParameter")
       end
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.call_with_argument_mapping(_proc, a)
-          _v1 = a
-          _v2 = _proc.call()
-          _v1.put_float 0, _v2
-        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
+        _(builder.mapping_method_definition).must_equal expected
       end
     end
 
-    describe 'for a callback with an inout array argument' do
+    describe "for a callback with an inout array argument" do
       let(:callback_info) do
-        get_introspection_data('Regress',
-                               'TestCallbackArrayInOut')
+        get_introspection_data("Regress",
+                               "TestCallbackArrayInOut")
       end
-      it 'returns a valid mapping method' do
-        skip unless callback_info
-        expected = <<-CODE.reset_indentation
-        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
+      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
+        _(builder.mapping_method_definition).must_equal expected
       end
     end
 
-    describe 'for a callback with a value in argument' do
+    describe "for a callback with a value in argument" do
       let(:field_info) do
-        get_field_introspection_data('GObject',
-                                     'ObjectClass', 'get_property')
+        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.reset_indentation
-        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
+      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
+        _(builder.mapping_method_definition).must_equal expected
       end
     end
   end

data/test/gir_ffi/builders/callback_return_value_builder_test.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+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(:return_value_info) do
+    GirFFI::ReturnValueInfo.new(type_info, ownership_transfer, false)
+  end
   let(:type_info) { callback_info.return_type }
   let(:ownership_transfer) { callback_info.caller_owns }
   let(:builder) do
@@ -12,74 +14,71 @@ describe GirFFI::Builders::CallbackReturnValueBuilder do
                                                      return_value_info)
   end
 
-  before do
-    skip unless callback_info
-  end
-
-  describe 'for :gint32' do
-    let(:callback_info) { get_introspection_data('GIMarshallingTests', 'CallbackIntInt') }
+  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 []
+    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'
+    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
+  describe "for :void" do
     let(:callback_info) do
-      get_introspection_data('GIMarshallingTests',
-                             'CallbackMultipleOutParameters')
+      get_introspection_data("GIMarshallingTests",
+                             "CallbackMultipleOutParameters")
     end
 
-    it 'has no statements in #post_conversion' do
-      builder.post_conversion.must_equal []
+    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
+    it "returns nothing" do
+      _(builder.capture_variable_name).must_be_nil
+      _(builder.return_value_name).must_be_nil
     end
   end
 
-  describe 'for :enum' do
+  describe "for :enum" do
     let(:callback_info) do
-      get_vfunc_introspection_data('GIMarshallingTests',
-                                   'Object',
-                                   'vfunc_return_enum')
+      get_vfunc_introspection_data("GIMarshallingTests",
+                                   "Object",
+                                   "vfunc_return_enum")
     end
 
-    it 'converts the result' do
+    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)']
+      _(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'
+    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
+  describe "for :object with full transfer" do
     let(:callback_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 'increases the refcount of the result and converts it to a pointer' do
+    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']
+      _(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'
+    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