eac_tools 0.89.0 → 0.90.0

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

@@ -0,0 +1,17 @@
+# 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/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/module_ancestors_variable/hash_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/module_ancestors_variable/hash'
+
+RSpec.describe(EacRubyUtils::ModuleAncestorsVariable::Hash) do
+  let(:included_module) do
+    Module.new do
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+        def hash_variable
+          @hash_variable ||= ::EacRubyUtils::ModuleAncestorsVariable::Hash.new(self, __method__)
+        end
+      end
+    end
+  end
+
+  let(:super_class) do
+    r = Class.new
+    r.include included_module
+    r
+  end
+
+  let(:sub_class) do
+    Class.new(super_class)
+  end
+
+  it { expect(super_class.hash_variable).to be_a(described_class) }
+  it { expect(super_class.hash_variable.self_variable).to eq({}) }
+  it { expect(super_class.hash_variable.ancestors_variable).to eq({}) }
+  it { expect(super_class.hash_variable.to_h).to eq({}) }
+
+  it { expect(sub_class.hash_variable).to be_a(described_class) }
+  it { expect(sub_class.hash_variable.self_variable).to eq({}) }
+  it { expect(sub_class.hash_variable.ancestors_variable).to eq({}) }
+  it { expect(sub_class.hash_variable.to_h).to eq({}) }
+
+  context 'when super class is changed' do
+    before do
+      super_class.hash_variable[:by_super] = 1
+    end
+
+    it { expect(super_class.hash_variable.to_h).to eq({ by_super: 1 }) }
+    it { expect(sub_class.hash_variable.to_h).to eq({ by_super: 1 }) }
+
+    context 'when sub class is changed' do
+      before do
+        sub_class.hash_variable[:by_sub] = 2
+      end
+
+      it { expect(super_class.hash_variable.to_h).to eq({ by_super: 1 }) }
+      it { expect(sub_class.hash_variable.to_h).to eq({ by_super: 1, by_sub: 2 }) }
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/module_ancestors_variable/set_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/module_ancestors_variable/set'
+
+RSpec.describe(EacRubyUtils::ModuleAncestorsVariable::Set) do
+  let(:included_module) do
+    Module.new do
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+        def set_variable
+          @set_variable ||= ::EacRubyUtils::ModuleAncestorsVariable::Set.new(self, __method__)
+        end
+      end
+    end
+  end
+
+  let(:super_class) do
+    r = Class.new
+    r.include included_module
+    r
+  end
+
+  let(:sub_class) do
+    Class.new(super_class)
+  end
+
+  it { expect(super_class.set_variable).to be_a(described_class) }
+  it { expect(super_class.set_variable.self_variable).to eq(Set.new) }
+  it { expect(super_class.set_variable.ancestors_variable).to eq(Set.new) }
+  it { expect(super_class.set_variable.to_set).to eq(Set.new) }
+
+  it { expect(sub_class.set_variable).to be_a(described_class) }
+  it { expect(sub_class.set_variable.self_variable).to eq(Set.new) }
+  it { expect(sub_class.set_variable.ancestors_variable).to eq(Set.new) }
+  it { expect(sub_class.set_variable.to_set).to eq(Set.new) }
+
+  context 'when super class is changed' do
+    before do
+      super_class.set_variable << 1
+    end
+
+    it { expect(super_class.set_variable.to_set).to eq(Set.new([1])) }
+    it { expect(sub_class.set_variable.to_set).to eq(Set.new([1])) }
+
+    context 'when sub class is changed' do
+      before do
+        sub_class.set_variable << 2
+      end
+
+      it { expect(super_class.set_variable.to_set).to eq(Set.new([1])) }
+      it { expect(sub_class.set_variable.to_set).to eq(Set.new([1, 2])) }
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/options_consumer'
+
+RSpec.describe EacRubyUtils::OptionsConsumer 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
+
+    it 'left data should be not empty' do
+      expect { instance.validate }.to raise_error(StandardError)
+    end
+
+    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)
+      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
+      expect(instance.left_data.empty?).to be(false)
+    end
+  end
+
+  describe '#consume_all' do
+    subject(:instance) { described_class.new(a: 'a_value', b: 'b_value', c: 'c_value') }
+
+    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 be_nil }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/addressable/uri/query_value_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/addressable/uri/query_value'
+
+RSpec.describe Addressable::URI, '#query_value' do
+  subject(:instance) { described_class.parse('http://example.net') }
+
+  it { expect(instance.query_values).to be_nil }
+  it { expect(instance.hash_query_values).to eq({}) }
+
+  it { expect(instance.query_value('param1')).to be_nil }
+  it { expect(instance.query_value(:param1)).to be_nil }
+
+  context 'when param is set' do
+    let(:set_result) { instance.query_value(:param1, :value1) }
+
+    before { set_result }
+
+    it { expect(set_result).to eq(instance) }
+    it { expect(instance.query_values).to eq({ 'param1' => 'value1' }) }
+    it { expect(instance.hash_query_values).to eq({ 'param1' => 'value1' }) }
+    it { expect(instance.query_value('param1')).to eq('value1') }
+    it { expect(instance.query_value(:param1)).to eq('value1') }
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/abstract'
+
+RSpec.describe Class, '#abstract' do
+  let(:abstract_class) do
+    described_class.new do
+      acts_as_abstract
+    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

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/class/acts_as_abstract_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_abstract'
+require 'eac_ruby_utils/patches/module/acts_as_abstract'
+
+RSpec.describe Class, '#acts_as_abstract' do
+  let(:stub_class) do
+    described_class.new { acts_as_abstract }
+  end
+
+  describe '#acts_as_abstract' do
+    it { expect(stub_class.included_modules).to include(EacRubyUtils::ActsAsAbstract) }
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/method_class'
+require 'eac_ruby_utils/patches/class/method_class'
+
+RSpec.describe Class, '#method_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/class/self_included_modules_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/self_included_modules'
+
+RSpec.describe Class, '#self_included_modules' do
+  let(:includeable_module) do
+    Module.new
+  end
+
+  let(:parent_class) do
+    module_to_include = includeable_module
+    described_class.new do
+      include module_to_include
+    end
+  end
+
+  let(:child_class) do
+    described_class.new(parent_class)
+  end
+
+  describe '#self_included_modules' do
+    it do
+      expect(parent_class.self_included_modules).to include(includeable_module)
+    end
+
+    it do
+      expect(child_class.self_included_modules).not_to include(includeable_module)
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/class/static_method_class_spec.rb

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

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerable/boolean_combinations_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerable/boolean_combinations'
+
+RSpec.describe Enumerable, '#boolean_combinations' do
+  let(:empty_instance) { [].to_enum }
+  let(:a_instance) { [:a].to_enum }
+  let(:ab_instance) { %i[a b].to_enum }
+
+  describe '#bool_hash_combs' do
+    it do
+      expect(empty_instance.bool_hash_combs).to eq([])
+    end
+
+    it do
+      expect(a_instance.bool_hash_combs).to eq([{ a: false }, { a: true }])
+    end
+
+    it do
+      expect(ab_instance.bool_hash_combs)
+        .to eq([{ a: false, b: false }, { a: false, b: true }, { a: true, b: false },
+                { a: true, b: true }])
+    end
+  end
+
+  describe '#bool_array_combs' do
+    it do
+      expect(empty_instance.bool_array_combs).to eq([])
+    end
+
+    it do
+      expect(a_instance.bool_array_combs).to eq([[], [:a]])
+    end
+
+    it do
+      expect(ab_instance.bool_array_combs).to eq([[], [:a], [:b], %i[a b]])
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/current_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/current'
+
+RSpec.describe Enumerator, '#current' do
+  let(:list) { %w[a b] }
+  let(:instance) { list.each }
+
+  it { expect(instance).to be_a(described_class) }
+  it { expect(instance.current).to eq('a') }
+
+  context 'with first next' do
+    before { instance.next }
+
+    it { expect(instance.current).to eq('b') }
+  end
+
+  context 'with last next' do
+    before do
+      instance.next
+      instance.next
+    end
+
+    it { expect(instance.current).to be_nil }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/stopped_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/stopped'
+
+RSpec.describe Enumerator, '#stopped' do
+  let(:list) { %w[a b] }
+  let(:instance) { list.each }
+
+  it { expect(instance).to be_a(described_class) }
+  it { expect(instance.peek).to eq('a') }
+  it { expect(instance).to be_ongoing }
+  it { expect(instance).not_to be_stopped }
+
+  context 'with first next' do
+    before { instance.next }
+
+    it { expect(instance.peek).to eq('b') }
+    it { expect(instance).to be_ongoing }
+    it { expect(instance).not_to be_stopped }
+  end
+
+  context 'with last next' do
+    before do
+      instance.next
+      instance.next
+    end
+
+    it { expect { instance.peek }.to raise_error(StopIteration) }
+    it { expect(instance).not_to be_ongoing }
+    it { expect(instance).to be_stopped }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/if_key_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/hash/if_key'
+
+RSpec.describe Hash, '#if_key' do
+  subject(:instance) { { a: 'a_value' } }
+
+  it do
+    expect(instance.if_key(:a)).to eq('a_value')
+  end
+
+  it do
+    expect(instance.if_key(:a) { |v| "_#{v}_" }).to eq('_a_value_')
+  end
+
+  it do
+    expect(instance.if_key(:b)).to be_nil
+  end
+
+  it do
+    expect(instance.if_key(:b, 'default_value')).to eq('default_value')
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/hash/options_consumer'
+
+RSpec.describe Hash, '#options_consumer' do
+  let(:a_hash) { { a: 'a_value', b: 'b_value', c: 'c_value' } }
+  let(:instance) { a_hash.to_options_consumer }
+
+  it 'returns a OptionsConsumer' do
+    expect(instance).to be_a(EacRubyUtils::OptionsConsumer)
+  end
+
+  it do
+    expect(instance.left_data).to eq({ a: 'a_value', b: 'b_value', c: 'c_value' }
+      .with_indifferent_access)
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/sym_keys_hash_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/hash/sym_keys_hash'
+
+RSpec.describe Hash, '#sym_keys_hash' do
+  let(:a_hash) { { 'a' => 'a_value', 1 => '1_value', s: 's_value' } }
+
+  describe '#to_sym_keys_hash' do
+    it 'converts all keys to symbols' do
+      expect(a_hash.to_sym_keys_hash).to eq(a: 'a_value', '1': '1_value', s: 's_value')
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/compare_by'
+
+RSpec.describe Module, '#compare_by' do
+  let(:klass) do
+    Class.new do
+      compare_by :field1, :field2
+      attr_reader :field1, :field2
+
+      def initialize(field1, field2)
+        @field1 = field1
+        @field2 = field2
+      end
+    end
+  end
+  let(:o1) { klass.new(1, 2) } # rubocop:disable RSpec/IndexedLet
+  let(:o2) { klass.new(2, 1) } # rubocop:disable RSpec/IndexedLet
+  let(:o3) { klass.new(1, 1) } # rubocop:disable RSpec/IndexedLet
+
+  describe '#comparable' do
+    it { expect(o1).to be < o2 }
+    it { expect(o1).to be > o3 }
+    it { expect(o2).to be > o3 }
+    it { expect([o1, o2, o3].sort).to eq([o3, o1, o2]) }
+  end
+
+  describe '#equality' do
+    it { expect(o1).not_to eq(o2) }
+    it { expect(o1).not_to eq(o3) }
+    it { expect(o2).not_to eq(o3) }
+
+    it { expect(o1).to eq(klass.new(1, 2)) }
+    it { expect(o2).to eq(klass.new(2, 1)) }
+    it { expect(o3).to eq(klass.new(1, 1)) }
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/listable'
+
+RSpec.describe Module, '#listable' do
+  let(:stub_class) do
+    Class.new do
+      enable_listable
+    end
+  end
+
+  describe '#enable_listable' do
+    it { expect(stub_class.included_modules).to include(EacRubyUtils::Listable) }
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/simple_cache'
+
+RSpec.describe Module, '#simple_cache' do
+  let(:stub_class) do
+    Class.new do
+      enable_simple_cache
+    end
+  end
+
+  describe '#enable_simple_cache' do
+    it { expect(stub_class.included_modules).to include(EacRubyUtils::SimpleCache) }
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/speaker'
+
+RSpec.describe Module, '#speaker' do
+  let(:stub_class) do
+    Class.new do
+      enable_speaker
+    end
+  end
+
+  describe '#enable_speaker' do
+    it { expect(stub_class.included_modules).to include(EacRubyUtils::Speaker::Sender) }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/call_if_proc_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/object/call_if_proc'
+
+RSpec.describe Object, '#call_if_proc' do
+  describe '#call_if_proc' do
+    it { expect(nil.call_if_proc).to be_nil }
+    it { expect('a string'.call_if_proc).to eq('a string') }
+    it { expect(-> { 'a returned value' }.call_if_proc).to eq('a returned value') }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/compact_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/object/compact'
+
+RSpec.describe Object, '#compact' do
+  let(:instance) { Struct.new(:a_attr, :b_attr).new('a_value', 'b_value') }
+  let(:attributes) { %w[a_attr b_attr] }
+
+  describe '#compact' do
+    it do
+      expect(instance.compact_to_a(*attributes)).to eq(%w[a_value b_value])
+    end
+  end
+
+  describe '#to_h' do
+    it do
+      expect(instance.compact_to_h(*attributes)).to eq(a_attr: 'a_value', b_attr: 'b_value')
+    end
+  end
+end