avm-tools 0.109.0 → 0.112.0

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/common_constructor_spec.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/common_constructor'
-
-RSpec.describe ::EacRubyUtils::CommonConstructor do
-  ARG_LIST = %i[a b c d].freeze # rubocop:disable RSpec/LeakyConstantDeclaration
-
-  let(:instance) do
-    described_class.new(*ARG_LIST, default: %w[Vcc Vd]) do
-      @z = 'Vz'
-    end
-  end
-
-  let(:a_class) do
-    ::Class.new do
-      attr_reader :z
-    end
-  end
-
-  let(:a_class_instance) { a_class.new('Va', 'Vb', 'Vc') }
-
-  before do
-    instance.setup_class(a_class)
-  end
-
-  it { expect(a_class_instance.z).to eq('Vz') }
-
-  ARG_LIST.each do |attr|
-    expected_value = "V#{attr}"
-    it "attribute \"#{attr}\" equal to \"#{expected_value}\"" do
-      expect(a_class_instance.send(attr)).to eq(expected_value)
-    end
-
-    [false, true].each do |include_all|
-      it "respond_to?('#{attr}', #{include_all}) == #{include_all}" do
-        expect(a_class_instance.respond_to?("#{attr}=", include_all)).to eq(include_all)
-      end
-    end
-  end
-
-  context 'with super class' do
-    let(:super_class) do
-      ::Class.new do
-        attr_reader :super_a, :super_b
-
-        def initialize(a, b) # rubocop:disable Naming/MethodParameterName
-          @super_a = a
-          @super_b = b
-        end
-      end
-    end
-
-    let(:sub_class) do
-      sub_constructor.setup_class(::Class.new(super_class))
-    end
-
-    let(:sub_object) { sub_class.new(1, 2, 3, 4) }
-
-    context 'with super_args parameter' do
-      let(:sub_constructor) do
-        described_class.new(:c, :a, :b, :d, super_args: -> { [c, a] })
-      end
-
-      it { expect(sub_object.a).to eq(2) }
-      it { expect(sub_object.b).to eq(3) }
-      it { expect(sub_object.c).to eq(1) }
-      it { expect(sub_object.d).to eq(4) }
-      it { expect(sub_object.super_a).to eq(1) }
-      it { expect(sub_object.super_b).to eq(2) }
-    end
-
-    context 'without super_args parameter' do
-      let(:sub_constructor) do
-        described_class.new(:c, :a, :b, :d)
-      end
-
-      it { expect(sub_object.a).to eq(2) }
-      it { expect(sub_object.b).to eq(3) }
-      it { expect(sub_object.c).to eq(1) }
-      it { expect(sub_object.d).to eq(4) }
-      it { expect(sub_object.super_a).to eq(2) }
-      it { expect(sub_object.super_b).to eq(3) }
-    end
-
-    context 'with undefined super arguments' do
-      let(:sub_constructor) do
-        described_class.new(:x, :y, :w, :a)
-      end
-
-      it do
-        expect { sub_object }.to raise_error(::ArgumentError)
-      end
-    end
-  end
-
-  context 'with class hierarchy mixed with and without common_constructor' do
-    let(:klass_0) do
-      described_class.new(:a_param).setup_class(::Class.new)
-    end
-
-    let(:klass_1) do
-      ::Class.new(klass_0) do
-        def initialize(a_param)
-          super(a_param)
-        end
-      end
-    end
-
-    let(:klass_2) do
-      ::Class.new(klass_1)
-    end
-
-    let(:klass_3) do
-      described_class.new(:a_param).setup_class(::Class.new(klass_2))
-    end
-
-    4.times.each do |i|
-      context "wit #{i}-th class" do
-        let(:class_instance) { send("klass_#{i}").new(:a) }
-
-        it { expect(class_instance.a_param).to eq(:a) }
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/compact_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/compact'
-
-::RSpec.describe ::EacRubyUtils::Compact do
-  let(:object) { ::OpenStruct.new(a_attr: 'a_value', b_attr: 'b_value') }
-  let(:instance) { described_class.new(object, %w[a_attr b_attr]) }
-
-  describe '#to_a' do
-    it do
-      expect(instance.to_a).to eq(%w[a_value b_value])
-    end
-  end
-
-  describe '#to_h' do
-    it do
-      expect(instance.to_h).to eq(a_attr: 'a_value', b_attr: 'b_value')
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/custom_format_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/custom_format'
-
-class StubObjectData
-  def x_value
-    'X1'
-  end
-
-  def y_value
-    'Y1'
-  end
-end
-
-RSpec.describe ::EacRubyUtils::CustomFormat do
-  let(:instance) { described_class.new(x: :x_value, y: :y_value, z: :unexistent) }
-  let(:ok_format) { instance.format('|%%|%y|%x|%y|') } # rubocop:disable Style/FormatStringToken
-  let(:ok_string_expected) { '|%|Y1|X1|Y1|' }
-  let(:fail_format) { instance.format('|%z|') }
-
-  it do
-    expect(ok_format.sequences).to include(:x, :y)
-  end
-
-  it do
-    expect(fail_format.sequences).to include(:z)
-  end
-
-  context 'when object source is a hash' do
-    let(:object_source) { { x_value: 'X1', y_value: 'Y1' } }
-
-    context 'when hash has all keys' do
-      it do
-        expect(ok_format.with(object_source)).to eq(ok_string_expected)
-      end
-    end
-
-    context 'when hash has not all keys' do
-      it do
-        expect(fail_format.with(object_source)).to eq('||')
-      end
-    end
-  end
-
-  context 'when object source is not a hash' do
-    let(:object_source) { ::StubObjectData.new }
-
-    context 'when object has all methods' do
-      it do
-        expect(ok_format.with(object_source)).to eq(ok_string_expected)
-      end
-    end
-
-    context 'when object has not all methods' do
-      it do
-        expect { fail_format.with(object_source) }.to raise_error(::ArgumentError)
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/executable_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/executable'
-require 'eac_ruby_utils/envs/local_env'
-
-RSpec.describe ::EacRubyUtils::Envs::Executable do
-  let(:env) { ::EacRubyUtils::Envs::LocalEnv.new }
-
-  context 'when program exist' do
-    let(:instance) { described_class.new(env, 'cat', '--version') }
-
-    it { expect(instance.exist?).to eq(true) }
-    it { expect { instance.validate! }.not_to raise_error }
-    it { expect(instance.validate).to be_blank }
-    it { expect(instance.command).to be_a(::EacRubyUtils::Envs::Command) }
-  end
-
-  context 'when program does not exist' do
-    let(:instance) { described_class.new(env, 'this_cannot_exist', '--version') }
-
-    it { expect(instance.exist?).to eq(false) }
-
-    it {
-      expect { instance.validate! }.to raise_error(
-        described_class.const_get('ProgramNotFoundError')
-      )
-    }
-
-    it { expect(instance.validate).to be_present }
-
-    it {
-      expect { instance.command }.to raise_error(
-        described_class.const_get('ProgramNotFoundError')
-      )
-    }
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/ssh_env_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/envs/ssh_env'
-
-RSpec.describe ::EacRubyUtils::Envs::SshEnv do
-  describe '#ssh_command_line' do
-    {
-      'eduardo@localhost' => 'ssh eduardo@localhost',
-      'ssh://eduardo@localhost' => 'ssh eduardo@localhost',
-      'ssh://eduardo@localhost:2222' => 'ssh -p 2222 eduardo@localhost',
-      'localhost' => 'ssh localhost'
-    }.each do |input, expected|
-      it "convert \"#{input}\" to \"#{expected}\"" do
-        env = described_class.new(input)
-        expect(env.send('ssh_command_line')).to eq(expected)
-      end
-    end
-
-    ['my user@hostname', 'http://hostname', 'ssh:/invalid-test', 'Fulano de tal'].each do |input|
-      it "\"#{input}\" raise error" do
-        expect { described_class.new(input) }.to raise_error(StandardError)
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/extname_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/extname'
-
-RSpec.describe ::EacRubyUtils::Fs do
-  describe '#extname' do
-    {
-      'After.Life.S01E01.WEBRip.x264-ION10.mp4' => '.mp4',
-      's01e01.en.srt' => '.en.srt',
-      's01e01.srt' => '.srt',
-      '/path/to/file.tar.gz' => '.tar.gz'
-    }.each do |source, expected|
-      context "when source is \"#{source}\"" do
-        it { expect(described_class.extname(source)).to eq(expected) }
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/temp/temp_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/temp/directory'
-
-RSpec.describe ::EacRubyUtils::Fs::Temp::Directory do
-  describe '#remove!' do
-    let(:instance) { described_class.new }
-
-    it { expect(instance).to be_directory }
-    it { expect { instance.remove! }.not_to raise_error }
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/temp_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/temp'
-
-RSpec.describe ::EacRubyUtils::Fs::Temp do
-  describe '#on_file' do
-    it do
-      temp_path = nil
-      described_class.on_file do |path|
-        temp_path = path
-        expect(temp_path).not_to exist
-        temp_path.write('StubText')
-        expect(temp_path).to exist
-      end
-      expect(temp_path).not_to exist
-    end
-
-    it 'not fail if already removed' do
-      temp_path = nil
-      described_class.on_file do |path|
-        temp_path = path
-        expect(temp_path).not_to exist
-        temp_path.write('StubText')
-        expect(temp_path).to exist
-        temp_path.unlink
-      end
-      expect(temp_path).not_to exist
-    end
-  end
-
-  describe '#on_directory' do
-    it do
-      temp_path = nil
-      described_class.on_directory do |path|
-        temp_path = path
-        expect(temp_path).to be_directory
-      end
-      expect(temp_path).not_to exist
-    end
-
-    it 'not fail if already removed' do
-      temp_path = nil
-      described_class.on_directory do |path|
-        temp_path = path
-        expect(temp_path).to be_directory
-        temp_path.rmtree
-        expect(temp_path).not_to exist
-      end
-      expect(temp_path).not_to exist
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/inflector_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/inflector'
-
-RSpec.describe ::EacRubyUtils::Inflector do
-  describe '#variableize' do
-    {
-      '_A_variableName' => 'a_variablename',
-      'àéíöũ' => 'aeiou'
-    }.each do |source, expected|
-      context "when source is \"#{source}\"" do
-        it { expect(described_class.variableize(source)).to eq(expected) }
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/listable_spec.rb

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/listable'
-
-class Stub
-  include ::EacRubyUtils::Listable
-
-  attr_accessor :inteiro, :code, :cadeia, :type
-
-  lists.add_integer :inteiro, :a, :b, :c
-  lists.add_integer :code, 7 => :a, 13 => :b
-  lists.add_string :cadeia, :a, :b, :c
-  lists.add_string :type, 'Namespace::ClazzA' => :a, 'Namespace::ClazzB' => :b
-  lists.add_symbol :simbolo, :a, :b, :c
-  lists.add_symbol :tipado, :tipo_aaa => :a, 'tipo_bbb' => :b
-end
-
-RSpec.describe ::EacRubyUtils::Listable do
-  context 'attribute values' do
-    it { expect(Stub.lists.inteiro.values).to eq([1, 2, 3]) }
-    it { expect(Stub.lists.code.values).to eq([7, 13]) }
-    it { expect(Stub.lists.cadeia.values).to eq(%w[a b c]) }
-    it { expect(Stub.lists.type.values).to eq(%w[Namespace::ClazzA Namespace::ClazzB]) }
-    it { expect(Stub.lists.simbolo.values).to eq(%i[a b c]) }
-    it { expect(Stub.lists.tipado.values).to eq(%i[tipo_aaa tipo_bbb]) }
-  end
-
-  context 'value instance options' do
-    it {
-      expect(Stub.lists.inteiro.options)
-        .to eq([['Inteiro A', 1], ['Inteiro BB', 2], ['Inteiro CCC', 3]])
-    }
-
-    it {
-      expect(Stub.lists.code.options)
-        .to eq([['Código A', 7], ['Código B', 13]])
-    }
-
-    it {
-      expect(Stub.lists.cadeia.options)
-        .to eq([['Cadeia AAA', 'a'], ['Cadeia BB', 'b'], ['Cadeia C', 'c']])
-    }
-
-    it {
-      expect(Stub.lists.type.options)
-        .to eq([['Tipo A', 'Namespace::ClazzA'], ['Tipo B', 'Namespace::ClazzB']])
-    }
-
-    it {
-      expect(Stub.lists.simbolo.options)
-        .to eq([['Simbolo A', :a], ['Simbolo B', :b], ['Simbolo C', :c]])
-    }
-
-    it {
-      expect(Stub.lists.tipado.options)
-        .to eq([['Tipado A', :tipo_aaa], ['Tipado B', :tipo_bbb]])
-    }
-  end
-
-  context 'constants' do
-    it { expect(Stub::INTEIRO_A).to eq(1) }
-    it { expect(Stub::INTEIRO_B).to eq(2) }
-    it { expect(Stub::INTEIRO_C).to eq(3) }
-    it { expect(Stub::CODE_A).to eq(7) }
-    it { expect(Stub::CODE_B).to eq(13) }
-    it { expect(Stub::CADEIA_A).to eq('a') }
-    it { expect(Stub::CADEIA_C).to eq('c') }
-    it { expect(Stub::TYPE_A).to eq('Namespace::ClazzA') }
-    it { expect(Stub::TYPE_B).to eq('Namespace::ClazzB') }
-    it { expect(Stub::SIMBOLO_A).to eq(:a) }
-    it { expect(Stub::SIMBOLO_B).to eq(:b) }
-    it { expect(Stub::SIMBOLO_C).to eq(:c) }
-    it { expect(Stub::TIPADO_A).to eq(:tipo_aaa) }
-    it { expect(Stub::TIPADO_B).to eq(:tipo_bbb) }
-  end
-
-  context 'values instances' do
-    it { expect(Stub.lists.is_a?(::EacRubyUtils::Listable::Lists)).to eq(true) }
-    it { expect(Stub.lists.inteiro.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.inteiro.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.inteiro.value_c.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.code.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.code.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.cadeia.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.cadeia.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.cadeia.value_c.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.type.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-    it { expect(Stub.lists.type.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
-  end
-
-  context 'value instance label' do
-    it { expect(Stub.lists.inteiro.value_a.label).to eq('Inteiro A') }
-    it { expect(Stub.lists.inteiro.value_b.label).to eq('Inteiro BB') }
-    it { expect(Stub.lists.inteiro.value_c.label).to eq('Inteiro CCC') }
-    it { expect(Stub.lists.code.value_a.label).to eq('Código A') }
-    it { expect(Stub.lists.code.value_b.label).to eq('Código B') }
-    it { expect(Stub.lists.cadeia.value_a.label).to eq('Cadeia AAA') }
-    it { expect(Stub.lists.cadeia.value_b.label).to eq('Cadeia BB') }
-    it { expect(Stub.lists.cadeia.value_c.label).to eq('Cadeia C') }
-    it { expect(Stub.lists.type.value_a.label).to eq('Tipo A') }
-    it { expect(Stub.lists.type.value_b.label).to eq('Tipo B') }
-  end
-
-  context 'value instance description' do
-    it { expect(Stub.lists.inteiro.value_a.description).to eq('Inteiro A Descr.') }
-    it { expect(Stub.lists.inteiro.value_b.description).to eq('Inteiro BB Descr.') }
-    it { expect(Stub.lists.inteiro.value_c.description).to eq('Inteiro CCC Descr.') }
-    it { expect(Stub.lists.code.value_a.description).to eq('Código A Descr.') }
-    it { expect(Stub.lists.code.value_b.description).to eq('Código B Descr.') }
-    it { expect(Stub.lists.cadeia.value_a.description).to eq('Cadeia AAA Descr.') }
-    it { expect(Stub.lists.cadeia.value_b.description).to eq('Cadeia BB Descr.') }
-    it { expect(Stub.lists.cadeia.value_c.description).to eq('Cadeia C Descr.') }
-    it { expect(Stub.lists.type.value_a.description).to eq('Tipo A Descr.') }
-    it { expect(Stub.lists.type.value_b.description).to eq('Tipo B Descr.') }
-  end
-
-  context 'value instance constant name' do
-    it { expect(Stub.lists.inteiro.value_a.constant_name).to eq('INTEIRO_A') }
-    it { expect(Stub.lists.inteiro.value_b.constant_name).to eq('INTEIRO_B') }
-    it { expect(Stub.lists.inteiro.value_c.constant_name).to eq('INTEIRO_C') }
-    it { expect(Stub.lists.code.value_a.constant_name).to eq('CODE_A') }
-    it { expect(Stub.lists.code.value_b.constant_name).to eq('CODE_B') }
-    it { expect(Stub.lists.cadeia.value_a.constant_name).to eq('CADEIA_A') }
-    it { expect(Stub.lists.cadeia.value_b.constant_name).to eq('CADEIA_B') }
-    it { expect(Stub.lists.cadeia.value_c.constant_name).to eq('CADEIA_C') }
-    it { expect(Stub.lists.type.value_a.constant_name).to eq('TYPE_A') }
-    it { expect(Stub.lists.type.value_b.constant_name).to eq('TYPE_B') }
-  end
-
-  context 'instance label and descriptions' do
-    let(:instance) { Stub.new }
-
-    context 'when inteiro value is A' do
-      before { instance.inteiro = Stub::INTEIRO_A }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro A') }
-      it { expect(instance.inteiro_description).to eq('Inteiro A Descr.') }
-    end
-
-    context 'when inteiro value is A' do
-      before { instance.inteiro = Stub::INTEIRO_B }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro BB') }
-      it { expect(instance.inteiro_description).to eq('Inteiro BB Descr.') }
-    end
-
-    context 'when inteiro value is C' do
-      before { instance.inteiro = Stub::INTEIRO_C }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro CCC') }
-      it { expect(instance.inteiro_description).to eq('Inteiro CCC Descr.') }
-    end
-
-    context 'when code value is A' do
-      before { instance.code = Stub::CODE_A }
-
-      it { expect(instance.code_label).to eq('Código A') }
-      it { expect(instance.code_description).to eq('Código A Descr.') }
-    end
-
-    context 'when code value is B' do
-      before { instance.code = Stub::CODE_B }
-
-      it { expect(instance.code_label).to eq('Código B') }
-      it { expect(instance.code_description).to eq('Código B Descr.') }
-    end
-
-    context 'when cadeia value is A' do
-      before { instance.cadeia = Stub::CADEIA_A }
-
-      it { expect(instance.cadeia_label).to eq('Cadeia AAA') }
-      it { expect(instance.cadeia_description).to eq('Cadeia AAA Descr.') }
-    end
-
-    context 'when cadeia value is B' do
-      before { instance.cadeia = Stub::CADEIA_B }
-
-      it { expect(instance.cadeia_label).to eq('Cadeia BB') }
-      it { expect(instance.cadeia_description).to eq('Cadeia BB Descr.') }
-    end
-
-    context 'when cadeia value is C' do
-      before { instance.cadeia = Stub::CADEIA_C }
-
-      it { expect(instance.cadeia_label).to eq('Cadeia C') }
-      it { expect(instance.cadeia_description).to eq('Cadeia C Descr.') }
-    end
-
-    context 'when type value is A' do
-      before { instance.type = Stub::TYPE_A }
-
-      it { expect(instance.type_label).to eq('Tipo A') }
-      it { expect(instance.type_description).to eq('Tipo A Descr.') }
-    end
-
-    context 'when type value is B' do
-      before { instance.type = Stub::TYPE_B }
-
-      it { expect(instance.type_label).to eq('Tipo B') }
-      it { expect(instance.type_description).to eq('Tipo B Descr.') }
-    end
-  end
-
-  describe '#value_validate!' do
-    it { expect { Stub.lists.inteiro.value_validate!(1) }.not_to raise_error }
-    it { expect { Stub.lists.inteiro.value_validate!('1') }.to raise_error }
-    it { expect { Stub.lists.inteiro.value_validate!(10) }.to raise_error(::StandardError) }
-    it { expect { Stub.lists.cadeia.value_validate!(:a) }.to raise_error }
-    it { expect { Stub.lists.cadeia.value_validate!('a') }.not_to raise_error }
-    it { expect { Stub.lists.cadeia.value_validate!(:z) }.to raise_error(::StandardError) }
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/local_time_zone_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/local_time_zone'
-
-RSpec.describe(::EacRubyUtils::LocalTimeZone) do
-  describe '#auto' do
-    context 'when TZ environment variable is set' do
-      let(:expected_time_zone) { 'America/Sao_Paulo' }
-
-      before do
-        ENV['TZ'] = expected_time_zone
-      end
-
-      it { expect(described_class.auto).to eq(expected_time_zone) }
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/options_consumer_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/options_consumer'
-
-RSpec.describe ::EacRubyUtils::OptionsConsumer do
-  context 'instance created with some data' do
-    subject(:instance) { described_class.new(a: 'a_value', b: 'b_value', c: 'c_value') }
-
-    it 'left data should be Hash' do
-      expect(instance.left_data).to be_a(::Hash)
-    end
-
-    it 'left data should be not empty' do
-      expect { instance.validate }.to raise_error(::StandardError)
-    end
-
-    it 'parses args' do
-      expect(instance.left_data).to eq({ a: 'a_value', b: 'b_value', c: 'c_value' }
-          .with_indifferent_access)
-      expect(instance.consume(:a)).to eq('a_value')
-      expect(instance.left_data).to eq({ b: 'b_value', c: 'c_value' }.with_indifferent_access)
-      expect(instance.consume(:c)).to eq('c_value')
-      expect(instance.left_data).to eq({ b: 'b_value' }.with_indifferent_access)
-      expect(instance.consume(:b)).to eq('b_value')
-      expect(instance.left_data).to eq({}.with_indifferent_access)
-      instance.validate
-    end
-
-    it 'raises if validate has left data' do
-      expect(instance.left_data.empty?).to eq(false)
-    end
-  end
-
-  describe '#consume_all' do
-    subject(:instance) { described_class.new(a: 'a_value', b: 'b_value', c: 'c_value') }
-
-    it 'return all options in arguments' do
-      a, b, c, d = instance.consume_all(:a, :b, :c, :d)
-      expect(a).to eq('a_value')
-      expect(b).to eq('b_value')
-      expect(c).to eq('c_value')
-      expect(d).to eq(nil)
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/class/abstract_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/class/abstract'
-
-RSpec.describe ::Class do
-  let(:abstract_class) do
-    described_class.new do
-      enable_abstract_methods
-    end
-  end
-
-  let(:concrect_class) do
-    described_class.new(abstract_class)
-  end
-
-  describe '#abstract' do
-    it do
-      expect(abstract_class).to be_abstract
-    end
-
-    it do
-      expect(concrect_class).not_to be_abstract
-    end
-  end
-end