gir_ffi 0.15.1 → 0.15.6

data/Gemfile

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# The gem's dependencies are specified in gir_ffi.gemspec
-gemspec
-
-gem "pry", "~> 0.12.0"
-gem "ruby-prof", platform: :mri
-gem "test-prof", platform: :mri
-
-if ENV["CI"]
-  gem "coveralls", group: :development if ENV["TRAVIS_RUBY_VERSION"] == "2.4"
-end

data/Rakefile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/clean"
-require "bundler/gem_tasks"
-
-load "tasks/test.rake"
-
-task default: "test:all"
-task default: "test:features"

data/tasks/test.rake

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require 'rake/testtask'
-require 'cucumber/rake/task'
-
-require 'rexml/document'
-require 'rexml/streamlistener'
-
-# Listener class used to process GIR xml data, for creating test stubs.
-class Listener
-  include REXML::StreamListener
-
-  def initialize
-    @inside_class = false
-    @stack = []
-    @skip_state = []
-  end
-
-  attr_accessor :result
-  attr_accessor :namespace
-
-  def tag_start(name, attrs)
-    @stack.push [name, attrs]
-    if @skip_state.last || skippable?(attrs)
-      @skip_state.push true
-      return
-    else
-      @skip_state.push false
-    end
-
-    obj_name = attrs['name']
-    case name
-    when 'constant'
-      result.puts "  it 'has the constant #{obj_name}' do"
-    when 'record', 'class', 'enumeration', 'bitfield', 'interface', 'union'
-      result.puts "  describe '#{namespace}::#{obj_name}' do"
-      @inside_class = name
-    when 'constructor'
-      result.puts "    it 'creates an instance using ##{obj_name}' do"
-    when 'field'
-      if @inside_class != 'class'
-        if attrs['private'] == '1'
-          result.puts "    it 'has a private field #{obj_name}' do"
-        elsif attrs['writable'] == '1'
-          result.puts "    it 'has a writable field #{obj_name}' do"
-        else
-          result.puts "    it 'has a read-only field #{obj_name}' do"
-        end
-      end
-    when 'function', 'method'
-      spaces = @inside_class ? '  ' : ''
-      result.puts "  #{spaces}it 'has a working #{name} ##{obj_name}' do"
-    when 'member'
-      result.puts "    it 'has the member :#{obj_name}' do"
-    when 'namespace'
-      result.puts "describe #{obj_name} do"
-    when 'property'
-      accessor_name = obj_name.tr('-', '_')
-      result.puts "    describe \"its '#{obj_name}' property\" do"
-      result.puts "      it 'can be retrieved with #get_property' do"
-      result.puts '      end'
-      result.puts "      it 'can be retrieved with ##{accessor_name}' do"
-      result.puts '      end'
-      if attrs['writable'] == '1'
-        result.puts "      it 'can be set with #set_property' do"
-        result.puts '      end'
-        result.puts "      it 'can be set with ##{accessor_name}=' do"
-        result.puts '      end'
-      end
-    when 'glib:signal'
-      result.puts "    it \"handles the '#{obj_name}' signal\" do"
-    when 'type', 'alias', 'return-value', 'parameters',
-      'instance-parameter', 'parameter', 'doc', 'array',
-      'repository', 'include', 'package', 'source-position'
-      # Not printed"
-    else
-      puts "Skipping #{name}: #{attrs}"
-    end
-  end
-
-  def tag_end(name)
-    org_name, = *@stack.pop
-    skipping = @skip_state.pop
-    raise "Expected #{org_name}, got #{name}" if org_name != name
-    return if skipping
-
-    case name
-    when 'constant'
-      result.puts '  end'
-    when 'record', 'class', 'enumeration', 'bitfield',
-      'interface', 'union'
-      result.puts '  end'
-      @inside_class = false
-    when 'function', 'method'
-      if @inside_class
-        result.puts '    end'
-      else
-        result.puts '  end'
-      end
-    when 'constructor', 'member', 'property', 'glib:signal'
-      result.puts '    end'
-    when 'field'
-      result.puts '    end' if @inside_class != 'class'
-    when 'namespace'
-      result.puts 'end'
-    end
-  end
-
-  def skippable?(attrs)
-    return true if attrs['disguised'] == '1'
-    return true if attrs['introspectable'] == '0'
-    return true if attrs['glib:is-gtype-struct-for']
-
-    false
-  end
-end
-
-namespace :test do
-  def define_test_task(name)
-    Rake::TestTask.new(name) do |t|
-      t.libs = ['lib']
-      t.ruby_opts += ['-w -Itest']
-      yield t
-    end
-  end
-
-  define_test_task(:base) do |t|
-    t.test_files = FileList['test/gir_ffi-base/**/*_test.rb']
-  end
-
-  define_test_task(:introspection) do |t|
-    t.test_files = FileList['test/ffi-gobject_introspection/**/*_test.rb']
-  end
-
-  define_test_task(:main) do |t|
-    t.test_files = FileList['test/gir_ffi/**/*_test.rb']
-  end
-
-  define_test_task(:overrides) do |t|
-    t.test_files = FileList['test/ffi-gobject_test.rb',
-                            'test/ffi-glib/**/*_test.rb',
-                            'test/ffi-gobject/**/*_test.rb']
-  end
-
-  define_test_task(:integration) do |t|
-    t.test_files = FileList['test/integration/**/*_test.rb']
-  end
-
-  desc 'Build test libraries and typelibs'
-  task lib: 'test/lib/Makefile' do
-    sh %(cd test/lib && make)
-  end
-
-  task introspection: :lib
-  task main: :lib
-  task overrides: :lib
-  task integration: :lib
-
-  desc 'Run the entire test suite as one with simplecov activated'
-  define_test_task(:all) do |t|
-    t.test_files = FileList['test/**/*_test.rb']
-    t.ruby_opts += ['-rbundler/setup -rsimplecov -w -Itest']
-  end
-
-  task all: :lib
-
-  desc 'Run all individual test suites separately'
-  task suites: [:base,
-                :introspection,
-                :main,
-                :overrides,
-                :integration]
-
-  def make_stub_file(libname)
-    file = File.new "test/lib/#{libname}-1.0.gir"
-    listener = Listener.new
-    listener.result = File.open("tmp/#{libname.downcase}_lines.rb", 'w')
-    listener.namespace = libname
-    REXML::Document.parse_stream file, listener
-  end
-
-  desc 'Create stubs for integration tests'
-  task stub: :lib do
-    make_stub_file 'Everything'
-    make_stub_file 'GIMarshallingTests'
-    make_stub_file 'Regress'
-    make_stub_file 'Utility'
-    make_stub_file 'WarnLib'
-  end
-
-  Cucumber::Rake::Task.new(:features) do |t|
-    t.cucumber_opts = 'features --format pretty'
-  end
-end
-
-file 'test/lib/Makefile' => 'test/lib/configure' do
-  sh %(cd test/lib && ./configure --enable-maintainer-mode)
-end
-
-file 'test/lib/configure' => ['test/lib/autogen.sh', 'test/lib/configure.ac'] do
-  sh %(cd test/lib && ./autogen.sh)
-end
-
-task test: 'test:all'

data/test/base_test_helper.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-old_verbose = $VERBOSE
-$VERBOSE = false
-begin
-  require "test-prof"
-
-  TestProf::RubyProf.configure do |config|
-    config.min_percent = 0.5
-  end
-rescue LoadError
-  warn "test-prof not available"
-end
-$VERBOSE = old_verbose
-
-if ENV["CI"]
-  begin
-    require "coveralls"
-    Coveralls.wear!
-  rescue LoadError
-    nil
-  end
-end
-
-require "minitest/autorun"
-require "rspec/mocks/minitest_integration"
-
-Thread.abort_on_exception = true
-
-module BaseTestExtensions
-  def assert_defines_singleton_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.singleton_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} to define singleton method #{mu_pp(method)}, " \
-        "but only found #{mu_pp(methods)}"
-    end
-    assert_includes methods, method, msg
-  end
-
-  def refute_defines_singleton_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.singleton_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} not to define singleton method #{mu_pp(method)}"
-    end
-    refute_includes methods, method, msg
-  end
-
-  def assert_defines_instance_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.instance_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} to define instance method #{mu_pp(method)}, " \
-        "but only found #{mu_pp(methods)}"
-    end
-    assert_includes methods, method, msg
-  end
-
-  def refute_defines_instance_method(klass, method, msg = nil)
-    method = method.to_sym
-    methods = klass.instance_methods(false).map(&:to_sym)
-    msg = message(msg) do
-      "Expected #{mu_pp(klass)} not to define instance method #{mu_pp(method)}"
-    end
-    refute_includes methods, method, msg
-  end
-end
-
-Minitest::Test.include BaseTestExtensions

data/test/ffi-glib/array_test.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GLib::Array do
-  it "knows its element type" do
-    arr = GLib::Array.new :gint32
-    assert_equal :gint32, arr.element_type
-  end
-
-  describe "#append_vals" do
-    before do
-      @arr = GLib::Array.new :gint32
-      @result = @arr.append_vals [1, 2, 3]
-    end
-
-    it "appends values" do
-      assert_equal 3, @arr.len
-    end
-
-    it "returns self" do
-      assert_equal @result, @arr
-    end
-  end
-
-  describe "#each" do
-    before do
-      @arr = GLib::Array.new(:gint32).append_vals [1, 2, 3]
-    end
-
-    it "iterates over the values" do
-      a = []
-      @arr.each { |v| a << v }
-
-      assert_equal [1, 2, 3], a
-    end
-  end
-
-  describe "::wrap" do
-    it "wraps a pointer, taking the element type as the first argument" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [1, 2, 3]
-      arr2 = GLib::Array.wrap :gint32, arr.to_ptr
-      assert_equal arr.to_a, arr2.to_a
-    end
-
-    it "warns the element sizes don't match" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [1, 2, 3]
-      _(proc { GLib::Array.wrap :gint8, arr.to_ptr }).must_output nil, /sizes do not match/
-    end
-
-    it "handles a struct as the element type" do
-      vals = [1, 2, 3].map { |i| GObject::EnumValue.new.tap { |ev| ev.value = i } }
-      arr = GLib::Array.new GObject::EnumValue
-      arr.append_vals vals
-      arr2 = GLib::Array.wrap GObject::EnumValue, arr.to_ptr
-      _(arr2.to_a).must_equal arr.to_a
-    end
-  end
-
-  it "includes Enumerable" do
-    _(GLib::Array).must_include Enumerable
-  end
-
-  it "has a working #to_a method" do
-    arr = GLib::Array.new :gint32
-    arr.append_vals [1, 2, 3]
-    assert_equal [1, 2, 3], arr.to_a
-  end
-
-  describe ".from" do
-    it "creates a GArray from an array of :gint32" do
-      arr = GLib::Array.from :gint32, [3, 2, 1]
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a).must_equal [3, 2, 1]
-    end
-
-    it "creates a GArray from an array of :gboolean" do
-      arr = GLib::Array.from :gboolean, [true, false, true]
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a).must_equal [true, false, true]
-    end
-
-    it "creates a GArray from an array of :utf8 values" do
-      arr = GLib::Array.from :utf8, %w(hello there)
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a).must_equal %w(hello there)
-    end
-
-    it "creates a GArray from an array of struct values" do
-      values = [1, 2, 3].map do |val|
-        GObject::EnumValue.new.tap { |it| it.value = val }
-      end
-      arr = GLib::Array.from GObject::EnumValue, values
-      _(arr).must_be_instance_of GLib::Array
-      _(arr.to_a.map(&:value)).must_equal [1, 2, 3]
-    end
-
-    it "return its argument if given a GArray" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [3, 2, 1]
-      arr2 = GLib::Array.from :gint32, arr
-      assert arr2.equal? arr
-    end
-
-    it "wraps its argument if given a pointer" do
-      arr = GLib::Array.new :gint32
-      arr.append_vals [3, 2, 1]
-      pointer = arr.to_ptr
-      assert_instance_of FFI::Pointer, pointer
-      arr2 = GLib::Array.from :gint32, pointer
-      assert_instance_of GLib::Array, arr2
-      refute arr2.equal? arr
-      _(arr2.to_a).must_equal arr.to_a
-    end
-  end
-
-  describe "#==" do
-    it "returns true when comparing to an array with the same elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-
-      _(arr).must_be :==, [1, 2, 3]
-    end
-
-    it "returns false when comparing to an array with different elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-
-      _(arr).wont_be :==, [1, 2]
-    end
-
-    it "returns true when comparing to a GArray with the same elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      other = GLib::Array.from :gint32, [1, 2, 3]
-
-      _(arr).must_be :==, other
-    end
-
-    it "returns false when comparing to a GArray with different elements" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      other = GLib::Array.from :gint32, [1, 2]
-
-      _(arr).wont_be :==, other
-    end
-  end
-
-  describe "#index" do
-    it "returns the proper element for an array of :gint32" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      _(arr.index(2)).must_equal 3
-    end
-
-    it "returns the proper element for an array of :utf8" do
-      arr = GLib::Array.from :utf8, %w(a b c)
-      _(arr.index(1)).must_equal "b"
-    end
-
-    it "returns the proper element for an array of :gboolean" do
-      arr = GLib::Array.from :gboolean, [true, false, true]
-      _(arr.index(1)).must_equal false
-    end
-
-    it "returns the proper element for an array of struct" do
-      vals = [1, 2, 3].map { |i| GObject::EnumValue.new.tap { |ev| ev.value = i } }
-      arr = GLib::Array.from GObject::EnumValue, vals
-      _(arr.index(1).value).must_equal 2
-    end
-
-    it "raises an error if the index is out of bounds" do
-      arr = GLib::Array.from :gint32, [1, 2, 3]
-      _(proc { arr.index(16) }).must_raise IndexError
-      _(proc { arr.index(-1) }).must_raise IndexError
-    end
-  end
-
-  describe "#reset_typespec" do
-    describe "when it needs to guess the type" do
-      it "guesses :uint8 for size 1" do
-        arr = GLib::Array.from :int8, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint8
-      end
-
-      it "guesses :uint16 for size 2" do
-        arr = GLib::Array.from :int16, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint16
-      end
-
-      it "guesses :uint32 for size 4" do
-        arr = GLib::Array.from :int32, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint32
-      end
-
-      it "guesses :uint64 for size 8" do
-        arr = GLib::Array.from :int64, [1, 2, 3]
-        arr.reset_typespec
-        _(arr.element_type).must_equal :uint64
-      end
-    end
-  end
-end