gir_ffi 0.14.0 → 0.15.3

data/test/gir_ffi/builders/signal_closure_builder_test.rb

@@ -1,187 +1,198 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::Builders::SignalClosureBuilder do
   let(:builder) { GirFFI::Builders::SignalClosureBuilder.new signal_info }
 
-  describe '#build_class' do
+  describe "#build_class" do
     let(:signal_info) do
-      get_signal_introspection_data 'Regress', 'TestObj', 'test'
+      get_signal_introspection_data "Regress", "TestObj", "test"
     end
 
-    it 'builds a descendant of RubyClosure' do
+    it "builds a descendant of RubyClosure" do
       klass = builder.build_class
-      klass.superclass.must_equal GObject::RubyClosure
+      _(klass.superclass).must_equal GObject::RubyClosure
     end
   end
 
-  describe '#marshaller_definition' do
-    describe 'for a signal with no arguments or return value' do
+  describe "#marshaller_definition" do
+    describe "for a signal with no arguments or return value" do
       let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'test'
+        get_signal_introspection_data "Regress", "TestObj", "test"
       end
 
-      it 'returns a valid marshaller converting only the receiver' do
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance = param_values.first.get_value_plain
-          _v1 = _instance
-          wrap(closure.to_ptr).invoke_block(_v1)
-        end
+      it "returns a valid marshaller converting only the receiver" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance = param_values.first.get_value_plain
+            _v1 = _instance
+            wrap(closure.to_ptr).invoke_block(_v1)
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal with an argument and a return value' do
+    describe "for a signal with an argument and a return value" do
       let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'sig-with-int64-prop'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, i = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = i
-          _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
-          return_value.set_value _v3
-        end
+        get_signal_introspection_data "Regress", "TestObj", "sig-with-int64-prop"
+      end
+
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, i = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = i
+            _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
+            return_value.set_value _v3
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal with an enum argument' do
+    describe "for a signal with an enum argument" do
       let(:signal_info) do
-        get_signal_introspection_data 'Gio', 'MountOperation', 'reply'
+        get_signal_introspection_data "Gio", "MountOperation", "reply"
       end
 
-      it 'returns a valid mapping method' do
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, result = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = result
-          wrap(closure.to_ptr).invoke_block(_v1, _v2)
-        end
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, result = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = result
+            wrap(closure.to_ptr).invoke_block(_v1, _v2)
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal with a array plus length arguments' do
+    describe "for a signal with a array plus length arguments" do
       let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'sig-with-array-len-prop'
-      end
-
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, arr, len = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = len
-          _v3 = GirFFI::SizedArray.wrap(:guint32, _v2, arr)
-          wrap(closure.to_ptr).invoke_block(_v1, _v3)
-        end
+        get_signal_introspection_data "Regress", "TestObj", "sig-with-array-len-prop"
+      end
+
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, arr, len = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = len
+            _v3 = GirFFI::SizedArray.wrap(:guint32, _v2, arr)
+            wrap(closure.to_ptr).invoke_block(_v1, _v3)
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal with a struct argument' do
+    describe "for a signal with a struct argument" do
       let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'test-with-static-scope-arg'
+        get_signal_introspection_data "Regress", "TestObj", "test-with-static-scope-arg"
       end
 
-      it 'returns a valid mapping method' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, object = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = Regress::TestSimpleBoxedA.wrap(object)
-          wrap(closure.to_ptr).invoke_block(_v1, _v2)
-        end
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, object = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = Regress::TestSimpleBoxedA.wrap(object)
+            wrap(closure.to_ptr).invoke_block(_v1, _v2)
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal returning an array of integers' do
+    describe "for a signal returning an array of integers" do
       let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'TestObj', 'sig-with-intarray-ret'
-      end
+        get_signal_introspection_data "Regress", "TestObj", "sig-with-intarray-ret"
+      end
+
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, i = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = i
+            _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
+            _v4 = GLib::Array.from(:gint32, _v3)
+            return_value.set_value _v4
+          end
+        CODE
 
-      it 'returns a valid mapping method' do
-        skip unless signal_info
+        _(builder.marshaller_definition).must_equal expected
+      end
+    end
 
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, i = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = i
-          _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
-          _v4 = GLib::Array.from(:gint32, _v3)
-          return_value.set_value _v4
-        end
+    describe "for a signal returning a string" do
+      let(:signal_info) do
+        get_signal_introspection_data "Regress", "AnnotationObject", "attribute-signal"
+      end
+
+      it "returns a mapping method that passes the string result to return_value directly" \
+        do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, arg1, arg2 = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = arg1
+            _v3 = arg2
+            _v4 = wrap(closure.to_ptr).invoke_block(_v1, _v2, _v3)
+            return_value.set_value _v4
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal returning an string' do
+    describe "for a signal with GList argument" do
       let(:signal_info) do
-        get_signal_introspection_data 'Gtk', 'Scale', 'format-value'
+        get_signal_introspection_data "Regress", "AnnotationObject", "list-signal"
       end
 
-      it 'returns a mapping method that passes the string result to return_value directly' do
-        skip unless signal_info
-
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, value = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = value
-          _v3 = wrap(closure.to_ptr).invoke_block(_v1, _v2)
-          return_value.set_value _v3
-        end
+      it "returns a valid mapping method" do
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, list = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = GLib::List.wrap(:utf8, list)
+            wrap(closure.to_ptr).invoke_block(_v1, _v2)
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
 
-    describe 'for a signal with GList argument' do
+    describe "for a signal with GError argument" do
       let(:signal_info) do
-        get_signal_introspection_data 'Regress', 'AnnotationObject', 'list-signal'
+        get_signal_introspection_data "Regress", "TestObj", "sig-with-gerror"
       end
 
-      it 'returns a valid mapping method' do
-        skip unless signal_info
+      it "returns a valid mapping method" do
+        skip_below "1.61.1"
 
-        expected = <<-CODE.reset_indentation
-        def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
-          _instance, list = param_values.map(&:get_value_plain)
-          _v1 = _instance
-          _v2 = GLib::List.wrap(:utf8, list)
-          wrap(closure.to_ptr).invoke_block(_v1, _v2)
-        end
+        expected = <<~CODE
+          def self.marshaller(closure, return_value, param_values, _invocation_hint, _marshal_data)
+            _instance, error = param_values.map(&:get_value_plain)
+            _v1 = _instance
+            _v2 = GLib::Error.wrap(error)
+            wrap(closure.to_ptr).invoke_block(_v1, _v2)
+          end
         CODE
 
-        builder.marshaller_definition.must_equal expected
+        _(builder.marshaller_definition).must_equal expected
       end
     end
   end

data/test/gir_ffi/builders/struct_builder_test.rb

@@ -1,45 +1,48 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::Builders::StructBuilder do
-  describe '#layout_specification' do
-    it 'returns the correct layout for Regress::TestStructA' do
-      info = get_introspection_data 'Regress', 'TestStructA'
+  describe "#layout_specification" do
+    it "returns the correct layout for Regress::TestStructA" do
+      info = get_introspection_data "Regress", "TestStructA"
       builder = GirFFI::Builders::StructBuilder.new info
-      builder.layout_specification.must_equal [:some_int, :int32, 0,
-                                               :some_int8, :int8, 4,
-                                               :some_double, :double, 8,
-                                               :some_enum, Regress::TestEnum, 16]
+      _(builder.layout_specification).must_equal [:some_int, :int32, 0,
+                                                  :some_int8, :int8, 4,
+                                                  :some_double, :double, 8,
+                                                  :some_enum, Regress::TestEnum, 16]
     end
 
-    describe 'for a struct with a simple layout' do
+    describe "for a struct with a simple layout" do
       before do
         @field = Object.new
 
         @struct = Object.new
-        allow(@struct).to receive(:namespace).and_return 'Foo'
-        allow(@struct).to receive(:safe_name).and_return 'Bar'
+        allow(@struct).to receive(:namespace).and_return "Foo"
+        allow(@struct).to receive(:safe_name).and_return "Bar"
         allow(@struct).to receive(:fields).and_return [@field]
 
         @builder = GirFFI::Builders::StructBuilder.new @struct
       end
 
-      it 'creates the correct layout specification' do
+      it "creates the correct layout specification" do
         expect(@field).to receive(:layout_specification).and_return [:bar, :int32, 0]
         spec = @builder.layout_specification
         assert_equal [:bar, :int32, 0], spec
       end
     end
 
-    describe 'for a struct with a layout with a complex type' do
-      it 'does not flatten the complex type specification' do
-        expect(simplefield = Object.new).to receive(:layout_specification).and_return [:bar, :foo, 0]
-        expect(complexfield = Object.new).to receive(:layout_specification).and_return [:baz, [:qux, 2], 0]
-        expect(struct = Object.new).to receive(:fields).and_return [simplefield, complexfield]
+    describe "for a struct with a layout with a complex type" do
+      it "does not flatten the complex type specification" do
+        expect(simplefield = Object.new)
+          .to receive(:layout_specification).and_return [:bar, :foo, 0]
+        expect(complexfield = Object.new)
+          .to receive(:layout_specification).and_return [:baz, [:qux, 2], 0]
+        expect(struct = Object.new)
+          .to receive(:fields).and_return [simplefield, complexfield]
 
-        allow(struct).to receive(:safe_name).and_return 'Bar'
-        allow(struct).to receive(:namespace).and_return 'Foo'
+        allow(struct).to receive(:safe_name).and_return "Bar"
+        allow(struct).to receive(:namespace).and_return "Foo"
 
         builder = GirFFI::Builders::StructBuilder.new struct
         spec = builder.layout_specification
@@ -48,39 +51,39 @@ describe GirFFI::Builders::StructBuilder do
     end
   end
 
-  describe '#superclass' do
-    it 'returns StructBase for a normal struct' do
-      info = get_introspection_data 'Regress', 'TestStructA'
+  describe "#superclass" do
+    it "returns StructBase for a normal struct" do
+      info = get_introspection_data "Regress", "TestStructA"
       builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GirFFI::StructBase
+      _(builder.superclass).must_equal GirFFI::StructBase
     end
 
-    it 'returns BoxedBase for a boxed type' do
-      info = get_introspection_data 'Regress', 'TestSimpleBoxedB'
+    it "returns BoxedBase for a boxed type" do
+      info = get_introspection_data "Regress", "TestSimpleBoxedB"
       builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GirFFI::BoxedBase
+      _(builder.superclass).must_equal GirFFI::BoxedBase
     end
 
-    it 'returns the GObject parent class for a type class' do
-      info = get_introspection_data 'GIMarshallingTests', 'SubSubObjectClass'
+    it "returns the GObject parent class for a type class" do
+      info = get_introspection_data "GIMarshallingTests", "SubSubObjectClass"
       builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GIMarshallingTests::SubObjectClass
+      _(builder.superclass).must_equal GIMarshallingTests::SubObjectClass
     end
 
-    it 'returns ObjectClass for InitiallyUnownedClass' do
-      info = get_introspection_data 'GObject', 'InitiallyUnownedClass'
+    it "returns ObjectClass for InitiallyUnownedClass" do
+      info = get_introspection_data "GObject", "InitiallyUnownedClass"
       builder = GirFFI::Builders::StructBuilder.new info
-      builder.superclass.must_equal GObject::ObjectClass
+      _(builder.superclass).must_equal GObject::ObjectClass
     end
   end
 
-  describe '#setup_class' do
+  describe "#setup_class" do
     before do
       save_module :Regress
     end
 
-    it 'stubs the structs methods' do
-      info = get_introspection_data 'Regress', 'TestStructA'
+    it "stubs the structs methods" do
+      info = get_introspection_data "Regress", "TestStructA"
       builder = GirFFI::Builders::StructBuilder.new info
       builder.setup_class
       assert_defines_instance_method Regress::TestStructA, :clone

data/test/gir_ffi/builders/unintrospectable_boxed_builder_test.rb

@@ -1,35 +1,29 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::Builders::UnintrospectableBoxedBuilder do
   let(:instance) { GIMarshallingTests::PropertiesObject.new }
-  let(:property) { instance.object_class.find_property 'some-boxed-glist' }
+  let(:property) { instance.object_class.find_property "some-boxed-glist" }
   let(:gtype) { property.value_type }
   let(:info) { GirFFI::UnintrospectableBoxedInfo.new(gtype) }
   let(:bldr) { GirFFI::Builders::UnintrospectableBoxedBuilder.new(info) }
   let(:boxed_class) { bldr.build_class }
 
-  before do
-    skip unless get_property_introspection_data('GIMarshallingTests',
-                                                'PropertiesObject',
-                                                'some-boxed-glist')
+  it "builds a class" do
+    _(boxed_class).must_be_instance_of Class
   end
 
-  it 'builds a class' do
-    boxed_class.must_be_instance_of Class
+  it "builds a class derived from GirFFI::BoxedBase" do
+    _(boxed_class.superclass).must_equal GirFFI::BoxedBase
   end
 
-  it 'builds a class derived from GirFFI::BoxedBase' do
-    boxed_class.superclass.must_equal GirFFI::BoxedBase
-  end
-
-  it 'returns the same class when built again' do
+  it "returns the same class when built again" do
     other_bldr = GirFFI::Builders::UnintrospectableBoxedBuilder.new(info)
     other_class = other_bldr.build_class
 
-    other_class.must_equal boxed_class
+    _(other_class).must_equal boxed_class
   end
 end