avm-tools 0.111.0 → 0.113.2

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 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 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 eq(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 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/options_consumer_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/hash/options_consumer'
+
+RSpec.describe ::Hash 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 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,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/compare_by'
+
+RSpec.describe ::Module 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) }
+  let(:o2) { klass.new(2, 1) }
+  let(:o3) { klass.new(1, 1) }
+
+  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,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/listable'
+
+RSpec.describe ::Module do
+  class StubClass
+    enable_listable
+  end
+
+  describe '#enable_listable' do
+    it { expect(StubClass.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,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/simple_cache'
+
+RSpec.describe ::Module do
+  class StubClass
+    enable_simple_cache
+  end
+
+  describe '#enable_simple_cache' do
+    it { expect(StubClass.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,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/speaker'
+
+RSpec.describe ::Module do
+  class StubClass # rubocop:disable RSpec/LeakyConstantDeclaration
+    enable_speaker
+  end
+
+  describe '#enable_speaker' do
+    it { expect(StubClass.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 do
+  describe '#call_if_proc' do
+    it { expect(nil.call_if_proc).to eq(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 do
+  let(:instance) { ::OpenStruct.new(a_attr: 'a_value', b_attr: '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

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/object/if_present'
+
+RSpec.describe ::Object do
+  describe '#if_present' do
+    it { expect(nil.if_present).to eq(nil) }
+    it { expect(nil.if_present('default')) .to eq('default') }
+    it { expect(nil.if_present('default') { |_v| 'calculated' }).to eq('default') }
+    it { expect('present'.if_present('default')).to eq('present') }
+    it { expect('present'.if_present { |v| v + '_calculated' }) .to eq('present_calculated') }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/object/template_spec_files/path/my_stub_with_template

@@ -0,0 +1 @@
+

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/basename_sub_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/pathname/basename_sub'
+
+RSpec.describe ::Pathname do
+  it do
+    expect(described_class.new('/absolute/path/to/file').basename_sub { |_b| 'other_file' }).to eq(
+      described_class.new('/absolute/path/to/other_file')
+    )
+  end
+
+  it do
+    expect(described_class.new('file').basename_sub { |b| b.to_s + '_appended' }).to eq(
+      described_class.new('file_appended')
+    )
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/pathname/parent_n_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/pathname/parent_n'
+
+RSpec.describe ::Pathname do
+  [
+    ['/absolute/path/to/file', 0, '/absolute/path/to/file'],
+    ['/absolute/path/to/file', 1, '/absolute/path/to'],
+    ['/absolute/path/to/file', 2, '/absolute/path'],
+    ['/absolute/path/to/file', 3, '/absolute'],
+    ['/absolute/path/to/file', 4, '/'],
+    ['/absolute/path/to/file', 5, '/'],
+    ['relative/path/to/file', 0, 'relative/path/to/file'],
+    ['relative/path/to/file', 1, 'relative/path/to'],
+    ['relative/path/to/file', 2, 'relative/path'],
+    ['relative/path/to/file', 3, 'relative'],
+    ['relative/path/to/file', 4, '.'],
+    ['relative/path/to/file', 5, '..'],
+    ['relative/path/to/file', 6, '../..']
+  ].each do |test_data|
+    input_path = test_data[0]
+    context "when path is \"#{input_path}\"" do
+      let(:n) { test_data[1] }
+      let(:expected_path) { test_data[2] }
+
+      it do
+        expect(described_class.new(input_path).parent_n(n)).to(
+          eq(described_class.new(expected_path))
+        )
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/string/delimited_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/string/delimited'
+
+::RSpec.describe ::String do
+  let(:instance) { 'A text with <b>content between</b> tags.' }
+
+  {
+    ['<b>', '</b>'] => {
+      'inner' => 'content between',
+      'without_inner' => 'A text with <b></b> tags.',
+      'outer' => '<b>content between</b>',
+      'without_outer' => 'A text with  tags.'
+    },
+    ['<b>', '</br>'] => {
+      'inner' => '',
+      'without_inner' => 'A text with <b>content between</b> tags.',
+      'outer' => '',
+      'without_outer' => 'A text with <b>content between</b> tags.'
+    }
+  }.each do |delimiters, expected_values|
+    context "when delimiters are #{delimiters}" do
+      let(:bdel) { delimiters[0] }
+      let(:edel) { delimiters[1] }
+
+      expected_values.each do |method_suffix, expected_value|
+        method_name = "delimited_#{method_suffix}"
+        it "#{method_name} should return \"#{expected_value}\"" do
+          expect(instance.send(method_name, bdel, edel)).to eq(expected_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/recursive_builder'
+
+RSpec.describe ::EacRubyUtils::RecursiveBuilder do
+  let(:item_class) do
+    ::Class.new do
+      class << self
+        def create(label, dependencies_keys)
+          item = new(label, dependencies_keys)
+          registry[item.label] = item
+          item
+        end
+
+        def registry
+          @registry ||= {}
+        end
+      end
+
+      attr_reader :label, :dependencies_keys
+
+      def initialize(label, dependencies_keys)
+        @label = label
+        @dependencies_keys = dependencies_keys.freeze
+      end
+
+      def dependencies
+        dependencies_keys.map { |key| self.class.registry.fetch(key) }
+      end
+
+      def to_s
+        label
+      end
+    end
+  end
+
+  items = [
+    [:a, %w[c], %w[a c]],
+    [:b, %w[a], %w[b a c]],
+    [:c, [], %w[c]],
+    [:d, %w[a b c e], %w[d a b c e]],
+    [:e, %w[c b], %w[e c b a]]
+  ]
+
+  items.each do |item|
+    let(item[0]) { item_class.create(item[0].to_s, item[1]) }
+    before { send(item[0]) }
+  end
+
+  describe '#result' do
+    items.each do |item|
+      context "when root is \"#{item[0]}\"" do
+        let(:root) { send(item[0]) }
+        let(:dependencies) { item[2].map { |d| send(d) } }
+        let(:builder) do
+          described_class.new(root, &:dependencies)
+        end
+
+        it "is #{item[2]}" do
+          expect(builder.result).to eq(dependencies)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class RequireSubStubClass
+  module StubbedModuleA
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class RequireSubStubClass
+  class StubbedNotModule
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+RSpec.describe ::EacRubyUtils::RequireSub do
+  class RequireSubStubClass
+  end
+
+  let(:instance) { described_class.new(__FILE__, base: RequireSubStubClass, include_modules: true) }
+
+  before do
+    instance.apply
+  end
+
+  it do
+    expect(RequireSubStubClass.included_modules)
+      .to include(RequireSubStubClass::StubbedModuleA)
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/ruby'
+
+RSpec.describe ::EacRubyUtils::Ruby do
+  describe '#on_clean_environment' do
+    let(:envvar_name) { 'BUNDLE_NOT_EXISTENT_ENV_VAR' }
+    let(:envvar_value) { 'any value' }
+
+    before do
+      ENV[envvar_name] = envvar_value
+    end
+
+    it do # rubocop:disable RSpec/MultipleExpectations
+      expect(ENV[envvar_name]).to eq(envvar_value)
+      described_class.on_clean_environment do
+        expect(ENV[envvar_name]).to eq(nil)
+      end
+      expect(ENV[envvar_name]).to eq(envvar_value)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+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
+  end
+
+  let(:stub) { MyStubSettingsProvided.new }
+
+  describe '#setting_value' do
+    {
+      ['key_a'] => 'method_a',
+      [:key_b] => 'setting_b',
+      ['key_b', { order: %w[constant method settings_object] }] => 'method_b',
+      ['key_c'] => 'setting_c',
+      ['key_d'] => 'constant_d'
+    }.each do |args, expected_value|
+      it { expect(stub.setting_value(*args)).to eq(expected_value) }
+    end
+
+    it do
+      expect { stub.setting_value('key_e') }.to raise_error(::StandardError)
+    end
+
+    it do
+      expect(stub.setting_value('key_e', required: false)).to eq(nil)
+    end
+
+    it do
+      expect(stub.setting_value('key_e', default: nil)).to eq(nil)
+    end
+
+    it do
+      expect(stub.setting_value('key_e', default: 'default_e')).to eq('default_e')
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+
+class CacheableObject
+  include ::EacRubyUtils::SimpleCache
+
+  def my_method_uncached
+    @counter ||= 0
+    @counter += 1
+  end
+
+  def method_with_question_uncached?
+    'question'
+  end
+
+  def method_with_exclamation_uncached!
+    'exclamation'
+  end
+
+  def method_with_args_uncached(arg1)
+    @counter2 ||= 0
+    @counter2 += 1
+    "#{arg1}/#{@counter2}"
+  end
+
+  def method_with_reset_uncached
+    reset_cache
+    'result'
+  end
+
+  private
+
+  def private_method_uncached
+    @counter3 ||= 0
+    @counter3 += 1
+  end
+end
+
+RSpec.describe ::EacRubyUtils::SimpleCache do
+  let(:instance) { CacheableObject.new }
+
+  describe 'cached value' do
+    it 'uncached method return value should update at each call' do
+      expect(instance.my_method_uncached).not_to eq(instance.my_method_uncached)
+    end
+
+    it 'cached method should return same values at each call' do
+      expect(instance.my_method).to eq(instance.my_method)
+    end
+
+    it 'is able to call private uncached as cached' do
+      expect(instance.private_method).to eq(instance.private_method)
+    end
+
+    it 'return value even if reset cache' do
+      expect(instance.method_with_reset).to eq('result')
+    end
+  end
+
+  describe 'cache value with args' do
+    it do
+      expect(instance.method_with_args_uncached('123'))
+        .not_to eq(instance.method_with_args_uncached('123'))
+    end
+
+    it do
+      expect(instance.method_with_args_uncached('456'))
+        .not_to eq(instance.method_with_args_uncached('456'))
+    end
+
+    it do
+      expect(instance.method_with_args('123')).to eq(instance.method_with_args('123'))
+    end
+
+    it do
+      expect(instance.method_with_args('456')).to eq(instance.method_with_args('456'))
+    end
+
+    it do
+      expect(instance.method_with_args('456')).not_to eq(instance.method_with_args('123'))
+    end
+  end
+
+  describe 'method with marks' do
+    it 'found uncached method with exclamation mark' do
+      expect(instance.method_with_exclamation!).to eq('exclamation')
+    end
+
+    it 'found uncached method with question mark' do
+      expect(instance.method_with_question?).to eq('question')
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'responds to cached method without args' do
+      expect(instance.respond_to?(:my_method)).to be(true)
+    end
+
+    it 'responds to cached method with args' do
+      expect(instance.respond_to?(:method_with_args)).to be(true)
+    end
+
+    it 'responds to cached method of uncached private method' do
+      expect(instance.respond_to?(:private_method)).to be(true)
+    end
+
+    it 'not respond to not existent method' do
+      expect(instance.respond_to?(:not_exist)).to be(false)
+    end
+  end
+
+  describe '#reset_cache' do
+    let(:instance) { CacheableObject.new }
+    let(:cached_value) { instance.my_method }
+
+    it 'cached method return should return cached value' do
+      expect(instance.my_method).to eq(cached_value)
+    end
+
+    context 'when reset_cache method is called' do
+      it 'cached method return should return new cached value' do
+        cached_value
+        instance.reset_cache
+        expect(instance.my_method).not_to eq(cached_value)
+      end
+    end
+  end
+end