avm-tools 0.116.1 → 0.117.1

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

@@ -2,199 +2,262 @@
 
 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]) }
+  let(:stub_class) do
+    the_described_class = described_class
+    ::Class.new do
+      class << self
+        def name
+          'Stub'
+        end
+      end
+
+      include the_described_class
+
+      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
   end
 
-  context 'value instance options' do
+  describe 'attribute values' do
+    it { expect(stub_class.lists.inteiro.values).to eq([1, 2, 3]) }
+    it { expect(stub_class.lists.code.values).to eq([7, 13]) }
+    it { expect(stub_class.lists.cadeia.values).to eq(%w[a b c]) }
+    it { expect(stub_class.lists.type.values).to eq(%w[Namespace::ClazzA Namespace::ClazzB]) }
+    it { expect(stub_class.lists.simbolo.values).to eq(%i[a b c]) }
+    it { expect(stub_class.lists.tipado.values).to eq(%i[tipo_aaa tipo_bbb]) }
+  end
+
+  describe 'value instance options' do
     it {
-      expect(Stub.lists.inteiro.options)
+      expect(stub_class.lists.inteiro.options)
         .to eq([['Inteiro A', 1], ['Inteiro BB', 2], ['Inteiro CCC', 3]])
     }
 
     it {
-      expect(Stub.lists.code.options)
+      expect(stub_class.lists.code.options)
         .to eq([['Código A', 7], ['Código B', 13]])
     }
 
     it {
-      expect(Stub.lists.cadeia.options)
+      expect(stub_class.lists.cadeia.options)
         .to eq([['Cadeia AAA', 'a'], ['Cadeia BB', 'b'], ['Cadeia C', 'c']])
     }
 
     it {
-      expect(Stub.lists.type.options)
+      expect(stub_class.lists.type.options)
         .to eq([['Tipo A', 'Namespace::ClazzA'], ['Tipo B', 'Namespace::ClazzB']])
     }
 
     it {
-      expect(Stub.lists.simbolo.options)
+      expect(stub_class.lists.simbolo.options)
         .to eq([['Simbolo A', :a], ['Simbolo B', :b], ['Simbolo C', :c]])
     }
 
     it {
-      expect(Stub.lists.tipado.options)
+      expect(stub_class.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) }
+  describe 'constants' do
+    it { expect(stub_class::INTEIRO_A).to eq(1) }
+    it { expect(stub_class::INTEIRO_B).to eq(2) }
+    it { expect(stub_class::INTEIRO_C).to eq(3) }
+    it { expect(stub_class::CODE_A).to eq(7) }
+    it { expect(stub_class::CODE_B).to eq(13) }
+    it { expect(stub_class::CADEIA_A).to eq('a') }
+    it { expect(stub_class::CADEIA_C).to eq('c') }
+    it { expect(stub_class::TYPE_A).to eq('Namespace::ClazzA') }
+    it { expect(stub_class::TYPE_B).to eq('Namespace::ClazzB') }
+    it { expect(stub_class::SIMBOLO_A).to eq(:a) }
+    it { expect(stub_class::SIMBOLO_B).to eq(:b) }
+    it { expect(stub_class::SIMBOLO_C).to eq(:c) }
+    it { expect(stub_class::TIPADO_A).to eq(:tipo_aaa) }
+    it { expect(stub_class::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) }
+  describe 'values instances' do
+    it { expect(stub_class.lists.is_a?(::EacRubyUtils::Listable::Lists)).to eq(true) }
+
+    it {
+      expect(stub_class.lists.inteiro.value_a.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.inteiro.value_b.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.inteiro.value_c.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.code.value_a.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.code.value_b.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.cadeia.value_a.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.cadeia.value_b.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.cadeia.value_c.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.lists.type.value_a.is_a?(::EacRubyUtils::Listable::Value))
+        .to eq(true)
+    }
+
+    it {
+      expect(stub_class.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') }
+  describe 'value instance label' do
+    it { expect(stub_class.lists.inteiro.value_a.label).to eq('Inteiro A') }
+    it { expect(stub_class.lists.inteiro.value_b.label).to eq('Inteiro BB') }
+    it { expect(stub_class.lists.inteiro.value_c.label).to eq('Inteiro CCC') }
+    it { expect(stub_class.lists.code.value_a.label).to eq('Código A') }
+    it { expect(stub_class.lists.code.value_b.label).to eq('Código B') }
+    it { expect(stub_class.lists.cadeia.value_a.label).to eq('Cadeia AAA') }
+    it { expect(stub_class.lists.cadeia.value_b.label).to eq('Cadeia BB') }
+    it { expect(stub_class.lists.cadeia.value_c.label).to eq('Cadeia C') }
+    it { expect(stub_class.lists.type.value_a.label).to eq('Tipo A') }
+    it { expect(stub_class.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.') }
+  describe 'value instance description' do
+    it { expect(stub_class.lists.inteiro.value_a.description).to eq('Inteiro A Descr.') }
+    it { expect(stub_class.lists.inteiro.value_b.description).to eq('Inteiro BB Descr.') }
+    it { expect(stub_class.lists.inteiro.value_c.description).to eq('Inteiro CCC Descr.') }
+    it { expect(stub_class.lists.code.value_a.description).to eq('Código A Descr.') }
+    it { expect(stub_class.lists.code.value_b.description).to eq('Código B Descr.') }
+    it { expect(stub_class.lists.cadeia.value_a.description).to eq('Cadeia AAA Descr.') }
+    it { expect(stub_class.lists.cadeia.value_b.description).to eq('Cadeia BB Descr.') }
+    it { expect(stub_class.lists.cadeia.value_c.description).to eq('Cadeia C Descr.') }
+    it { expect(stub_class.lists.type.value_a.description).to eq('Tipo A Descr.') }
+    it { expect(stub_class.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') }
+  describe 'value instance constant name' do
+    it { expect(stub_class.lists.inteiro.value_a.constant_name).to eq('INTEIRO_A') }
+    it { expect(stub_class.lists.inteiro.value_b.constant_name).to eq('INTEIRO_B') }
+    it { expect(stub_class.lists.inteiro.value_c.constant_name).to eq('INTEIRO_C') }
+    it { expect(stub_class.lists.code.value_a.constant_name).to eq('CODE_A') }
+    it { expect(stub_class.lists.code.value_b.constant_name).to eq('CODE_B') }
+    it { expect(stub_class.lists.cadeia.value_a.constant_name).to eq('CADEIA_A') }
+    it { expect(stub_class.lists.cadeia.value_b.constant_name).to eq('CADEIA_B') }
+    it { expect(stub_class.lists.cadeia.value_c.constant_name).to eq('CADEIA_C') }
+    it { expect(stub_class.lists.type.value_a.constant_name).to eq('TYPE_A') }
+    it { expect(stub_class.lists.type.value_b.constant_name).to eq('TYPE_B') }
   end
 
-  context 'instance label and descriptions' do
-    let(:instance) { Stub.new }
+  describe 'instance label and descriptions' do
+    let(:instance) { stub_class.new }
 
     context 'when inteiro value is A' do
-      before { instance.inteiro = Stub::INTEIRO_A }
+      before { instance.inteiro = stub_class::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 }
+    context 'when inteiro value is B' do
+      before { instance.inteiro = stub_class::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 }
+      before { instance.inteiro = stub_class::INTEIRO_C }
 
       it { expect(instance.inteiro_label).to eq('Inteiro CCC') }
       it { expect(instance.inteiro_description).to eq('Inteiro CCC Descr.') }
     end
 
+    context 'when inteiro value is blank' do
+      before { instance.inteiro = nil }
+
+      it { expect(instance.inteiro_label).to eq('Inteiro em branco') }
+      it { expect(instance.inteiro_description).to eq('Inteiro em branco Descr.') }
+    end
+
     context 'when code value is A' do
-      before { instance.code = Stub::CODE_A }
+      before { instance.code = stub_class::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 }
+      before { instance.code = stub_class::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 code value is blank' do
+      before { instance.code = nil }
+
+      it { expect(instance.code_label).to eq('') }
+      it { expect(instance.code_description).to eq('') }
+    end
+
     context 'when cadeia value is A' do
-      before { instance.cadeia = Stub::CADEIA_A }
+      before { instance.cadeia = stub_class::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 }
+      before { instance.cadeia = stub_class::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 }
+      before { instance.cadeia = stub_class::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 }
+      before { instance.type = stub_class::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 }
+      before { instance.type = stub_class::TYPE_B }
 
       it { expect(instance.type_label).to eq('Tipo B') }
       it { expect(instance.type_description).to eq('Tipo B Descr.') }
@@ -202,11 +265,11 @@ RSpec.describe ::EacRubyUtils::Listable do
   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) }
+    it { expect { stub_class.lists.inteiro.value_validate!(1) }.not_to raise_error }
+    it { expect { stub_class.lists.inteiro.value_validate!('1') }.to raise_error(::StandardError) }
+    it { expect { stub_class.lists.inteiro.value_validate!(10) }.to raise_error(::StandardError) }
+    it { expect { stub_class.lists.cadeia.value_validate!(:a) }.to raise_error(::StandardError)  }
+    it { expect { stub_class.lists.cadeia.value_validate!('a') }.not_to raise_error }
+    it { expect { stub_class.lists.cadeia.value_validate!(:z) }.to raise_error(::StandardError) }
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/method_class_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/method_class'
+
+::RSpec.describe ::EacRubyUtils::MethodClass do
+  let(:sender_class) do
+    ::Class.new do
+      attr_accessor :sender_value
+
+      def initialize(sender_value)
+        self.sender_value = sender_value
+      end
+    end
+  end
+
+  let(:method_class) do
+    the_described_class = described_class
+    ::Class.new do
+      def self.name
+        'TheSender::PerformX'
+      end
+
+      include the_described_class
+      attr_accessor :sender, :method_param
+
+      def initialize(sender, method_param)
+        self.sender = sender
+        self.method_param = method_param
+      end
+
+      def result
+        "#{sender.sender_value},#{method_param}"
+      end
+    end
+  end
+
+  let(:sender_instance) { sender_class.new('AAA') }
+
+  before do
+    ::Object.const_set('TheSender', sender_class)
+    sender_class.const_set('PerformX', method_class)
+  end
+
+  it { expect(sender_instance).to respond_to(:perform_x) }
+  it { expect(sender_instance.perform_x('BBB')).to eq('AAA,BBB') }
+end

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

@@ -3,9 +3,13 @@
 require 'eac_ruby_utils/options_consumer'
 
 RSpec.describe ::EacRubyUtils::OptionsConsumer do
-  context 'instance created with some data' do
+  context 'with instance created with some data' do
     subject(:instance) { described_class.new(a: 'a_value', b: 'b_value', c: 'c_value') }
 
+    let(:consumed_a) { instance.consume(:a) }
+    let(:consumed_b) { instance.consume(:b) }
+    let(:consumed_c) { instance.consume(:c) }
+
     it 'left data should be Hash' do
       expect(instance.left_data).to be_a(::Hash)
     end
@@ -14,16 +18,48 @@ RSpec.describe ::EacRubyUtils::OptionsConsumer 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' }
+    context 'when no data is consumed' do
+      it 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 { expect(consumed_a).to eq('a_value') }
+    end
+
+    context 'when A value is consumed' do
+      before { consumed_a }
+
+      it do
+        expect(instance.left_data).to eq({ b: 'b_value', c: 'c_value' }.with_indifferent_access)
+      end
+
+      it { expect(instance.consume(:c)).to eq('c_value') }
+    end
+
+    context 'when A and C values are consumed' do
+      before do
+        consumed_a
+        consumed_c
+      end
+
+      it { expect(instance.left_data).to eq({ b: 'b_value' }.with_indifferent_access) }
+
+      it { expect(consumed_b).to eq('b_value') }
+    end
+
+    context 'when all values are consumed' do
+      before do
+        consumed_a
+        consumed_b
+        consumed_c
+      end
+
+      it { expect(instance.left_data).to eq({}.with_indifferent_access) }
+
+      it do
+        expect { instance.validate }.not_to raise_error
+      end
     end
 
     it 'raises if validate has left data' do
@@ -34,12 +70,11 @@ RSpec.describe ::EacRubyUtils::OptionsConsumer do
   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
+    let(:all_consumed) { instance.consume_all(:a, :b, :c, :d) }
+
+    it { expect(all_consumed[0]).to eq('a_value') }
+    it { expect(all_consumed[1]).to eq('b_value') }
+    it { expect(all_consumed[2]).to eq('c_value') }
+    it { expect(all_consumed[3]).to eq(nil) }
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/listable_spec.rb

@@ -3,11 +3,13 @@
 require 'eac_ruby_utils/patches/module/listable'
 
 RSpec.describe ::Module do
-  class StubClass
-    enable_listable
+  let(:stub_class) do
+    ::Class.new do
+      enable_listable
+    end
   end
 
   describe '#enable_listable' do
-    it { expect(StubClass.included_modules).to include(::EacRubyUtils::Listable) }
+    it { expect(stub_class.included_modules).to include(::EacRubyUtils::Listable) }
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/method_class_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/method_class'
+require 'eac_ruby_utils/patches/module/method_class'
+
+RSpec.describe ::Class do
+  let(:stub_method_class) do
+    described_class.new do
+      def self.name
+        'StubMethodClass'
+      end
+
+      enable_method_class
+    end
+  end
+
+  describe '#enable_simple_cache' do
+    it { expect(stub_method_class.included_modules).to include(::EacRubyUtils::MethodClass) }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/simple_cache_spec.rb

@@ -3,11 +3,13 @@
 require 'eac_ruby_utils/patches/module/simple_cache'
 
 RSpec.describe ::Module do
-  class StubClass
-    enable_simple_cache
+  let(:stub_class) do
+    ::Class.new do
+      enable_simple_cache
+    end
   end
 
   describe '#enable_simple_cache' do
-    it { expect(StubClass.included_modules).to include(::EacRubyUtils::SimpleCache) }
+    it { expect(stub_class.included_modules).to include(::EacRubyUtils::SimpleCache) }
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub_spec.rb

@@ -2,10 +2,10 @@
 
 require 'eac_ruby_utils/require_sub'
 
-RSpec.describe ::EacRubyUtils::RequireSub do
-  class RequireSubStubClass
-  end
+class RequireSubStubClass
+end
 
+RSpec.describe ::EacRubyUtils::RequireSub do
   let(:instance) { described_class.new(__FILE__, base: RequireSubStubClass, include_modules: true) }
 
   before do

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/settings_provider_spec.rb

@@ -3,26 +3,29 @@
 require 'eac_ruby_utils/settings_provider'
 
 RSpec.describe ::EacRubyUtils::SettingsProvider do
-  class MyStubSettingsProvided
-    include ::EacRubyUtils::SettingsProvider
-
-    KEY_A = 'constant_a'
-    KEY_D = 'constant_d'
-
-    def key_a
-      'method_a'
-    end
-
-    def key_b
-      'method_b'
-    end
-
-    def settings
-      { 'key_b' => 'setting_b', key_c: 'setting_c' }
-    end
+  let(:stub_class) do
+    the_described_class = described_class
+    r = ::Class.new do
+      include the_described_class
+
+      def key_a
+        'method_a'
+      end
+
+      def key_b
+        'method_b'
+      end
+
+      def settings
+        { 'key_b' => 'setting_b', key_c: 'setting_c' }
+      end
+    end
+    r.const_set(:KEY_A, 'constant_a')
+    r.const_set(:KEY_D, 'constant_d')
+    r
   end
 
-  let(:stub) { MyStubSettingsProvided.new }
+  let(:stub) { stub_class.new }
 
   describe '#setting_value' do
     {

data/sub/eac_ruby_utils/spec/locales/pt-BR.yml

@@ -12,6 +12,9 @@ pt-BR:
           c:
             label: Inteiro CCC
             description: Inteiro CCC Descr.
+          __blank:
+            label: Inteiro em branco
+            description: Inteiro em branco Descr.
         cadeia:
           a:
             label: Cadeia AAA

data/sub/eac_templates/eac_templates.gemspec

@@ -15,5 +15,5 @@ Gem::Specification.new do |s|
   s.add_dependency 'eac_config', '~> 0.5'
   s.add_dependency 'eac_ruby_utils', '~> 0.64'
 
-  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5.1'
 end