eac_tools 0.66.0 → 0.67.1

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

@@ -1,28 +1,94 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/acts_as_abstract'
+require 'eac_ruby_utils/unimplemented_method_error'
 
-RSpec.describe(::EacRubyUtils::ActsAsAbstract) do
+::RSpec.describe(::EacRubyUtils::ActsAsAbstract) do
   let(:base_class) do
     the_module = described_class
     ::Class.new do
       include the_module
 
       abstract_methods :method1, :method2
+
+      def method3
+        'base result'
+      end
     end
   end
-  let(:base_instance) { base_class.new }
   let(:sub_class) do
     ::Class.new(base_class) do
       def method1
         'a result'
       end
+
+      def method4
+        'sub result'
+      end
     end
   end
-  let(:sub_instance) { sub_class.new }
 
-  it { expect { base_instance.method1 }.to raise_error(::NoMethodError) }
-  it { expect { base_instance.method2 }.to raise_error(::NoMethodError) }
-  it { expect(sub_instance.method1).to eq('a result') }
-  it { expect { sub_instance.method2 }.to raise_error(::NoMethodError) }
+  class << self
+    def specs_for_target(test_target, instances_hash)
+      describe "\##{test_target}" do # rubocop:disable RSpec/EmptyExampleGroup
+        specs_for_instances(test_target, instances_hash)
+      end
+    end
+
+    def specs_for_instances(test_target, instances_hash)
+      instances_hash.each do |instance_name, expected_values|
+        context "when instance is \"#{instance_name}\"" do # rubocop:disable RSpec/EmptyExampleGroup
+          let(:instance) { send("#{instance_name}_class").new }
+
+          specs_for_methods_values(test_target, expected_values)
+        end
+      end
+    end
+
+    def specs_for_methods_values(test_target, expected_values)
+      expected_values.each_with_index do |expected_value, method_index|
+        method_name = "method#{method_index + 1}"
+        context "when method is \"#{method_name}\"" do # rubocop:disable RSpec/EmptyExampleGroup
+          send("specs_for_#{test_target}", method_name, expected_value)
+        end
+      end
+    end
+
+    def specs_for_abstract_method(method_name, expected_value)
+      it { expect(instance.abstract_method?(method_name)).to eq(expected_value) }
+    end
+
+    def specs_for_method_missing(method_name, expected_value)
+      if expected_value.is_a?(::Class) && expected_value < ::Exception
+        it do
+          expect { instance.send(method_name) }.to raise_error(expected_value)
+        end
+      else
+        it do
+          expect(instance.send(method_name)).to eq(expected_value)
+        end
+      end
+    end
+
+    def specs_for_respond_to_missing(method_name, expected_value)
+      it { expect(instance.respond_to?(method_name)).to eq(expected_value) }
+    end
+  end
+  {
+    abstract_method: {
+      base: [true, true, false, false],
+      sub: [false, true, false, false]
+    },
+    method_missing: {
+      base: [::EacRubyUtils::UnimplementedMethodError, ::EacRubyUtils::UnimplementedMethodError,
+             'base result', ::NoMethodError],
+      sub: ['a result', ::EacRubyUtils::UnimplementedMethodError, 'base result', 'sub result']
+    },
+    respond_to_missing: {
+      base: [true, true, true, false],
+      sub: [true, true, true, true]
+    }
+  }.each do |test_target, instances_hash|
+    specs_for_target(test_target, instances_hash)
+  end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/{immutable → acts_as_immutable}/array_accessor_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable'
+require 'eac_ruby_utils/acts_as_immutable'
 
-::RSpec.describe ::EacRubyUtils::Immutable::ArrayAccessor do
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::ArrayAccessor do
   let(:stub_class) do
     ::Class.new do
-      include ::EacRubyUtils::Immutable
+      include ::EacRubyUtils::ActsAsImmutable
 
       immutable_accessor :array_attr, type: :array
     end
@@ -31,5 +31,13 @@ require 'eac_ruby_utils/immutable'
       it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
       it { expect(change2_instance.array_attrs).to eq(%w[B]) }
     end
+
+    context 'when array_attrs sets for a non array' do
+      let(:change2_instance) { initial_instance.array_attrs('B') }
+
+      it { expect(change2_instance).to be_a(initial_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.array_attrs).to eq(%w[B]) }
+    end
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/acts_as_immutable/common_accessor_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable'
+
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::CommonAccessor do
+  let(:stub_class) do
+    ::Class.new do
+      include ::EacRubyUtils::ActsAsImmutable
+
+      immutable_accessor :attr1, :attr2, :attr3
+
+      def attr1_get_filter(value)
+        value || 'DEFAULT'
+      end
+
+      def attr2_set_filter(value)
+        "#{value}_FILTERED"
+      end
+    end
+  end
+
+  let(:initial_instance) { stub_class.new }
+
+  it { expect(initial_instance.attr1).to eq('DEFAULT') }
+  it { expect(initial_instance.attr2).to eq(nil) }
+  it { expect(initial_instance.attr3).to eq(nil) }
+
+  context 'when attr1 is set' do
+    let(:change1_instance) { initial_instance.attr1('A') }
+
+    it { expect(change1_instance).to be_a(initial_instance.class) }
+    it { expect(change1_instance.object_id).not_to eq(initial_instance.object_id) }
+    it { expect(change1_instance.attr1).to eq('A') }
+    it { expect(change1_instance.attr2).to eq(nil) }
+    it { expect(change1_instance.attr3).to eq(nil) }
+
+    context 'when attr2 is set' do
+      let(:change2_instance) { change1_instance.attr2('B') }
+
+      it { expect(change2_instance).to be_a(change1_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.attr1).to eq('A') }
+      it { expect(change2_instance.attr2).to eq('B_FILTERED') }
+      it { expect(change2_instance.attr3).to eq(nil) }
+    end
+
+    context 'when attr3 is set' do
+      let(:change2_instance) { change1_instance.attr3('C') }
+
+      it { expect(change2_instance).to be_a(change1_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.attr1).to eq('A') }
+      it { expect(change2_instance.attr2).to eq(nil) }
+      it { expect(change2_instance.attr3).to eq('C') }
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/{immutable → acts_as_immutable}/hash_accessor_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable'
+require 'eac_ruby_utils/acts_as_immutable'
 
-::RSpec.describe ::EacRubyUtils::Immutable::HashAccessor do
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::HashAccessor do
   let(:stub_class) do
     ::Class.new do
-      include ::EacRubyUtils::Immutable
+      include ::EacRubyUtils::ActsAsImmutable
 
       immutable_accessor :the_hash, type: :hash
     end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/acts_as_immutable/set_accessor_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable'
+
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::SetAccessor do
+  let(:stub_class) do
+    ::Class.new do
+      include ::EacRubyUtils::ActsAsImmutable
+
+      immutable_accessor :array_attr, type: :set
+    end
+  end
+
+  let(:initial_instance) { stub_class.new }
+
+  it do
+    expect(initial_instance.array_attrs).to eq(::Set.new)
+  end
+
+  context 'when array_attr pushs for' do
+    let(:change1_instance) { initial_instance.array_attr('A') }
+
+    it { expect(change1_instance).to be_a(initial_instance.class) }
+    it { expect(change1_instance.object_id).not_to eq(initial_instance.object_id) }
+    it { expect(change1_instance.array_attrs).to eq(::Set.new(%w[A])) }
+
+    context 'when array_attrs sets for' do
+      let(:change2_instance) { initial_instance.array_attrs(%w[B]) }
+
+      it { expect(change2_instance).to be_a(initial_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.array_attrs).to eq(::Set.new(%w[B])) }
+    end
+
+    context 'when array_attrs push for a repetead value' do
+      let(:change2_instance) { initial_instance.array_attr('A') }
+
+      it { expect(change2_instance).to be_a(initial_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.array_attrs).to eq(::Set.new(%w[A])) }
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/enumerables_methods'
+
+::RSpec.describe ::EacRubyUtils::EnumerablesMethods do
+  describe '#write_method?' do
+    it do
+      expect(described_class).to be_write_method(:'[]=')
+    end
+
+    it do
+      expect(described_class).not_to be_write_method(:'!=')
+    end
+  end
+
+  [
+    [:enumerable, %i[drop lazy sort], []],
+    [:hash, %i[\[\] <= compact slice to_h values],
+     %i[\[\]= compact! delete default= keep_if shift]],
+    [:set, %i[<= include?], %i[<< add clear collect! divide delete keep_if merge reset subtract]]
+  ].each do |test_values|
+    klass_underscore, read_methods, write_methods = test_values
+
+    context "when class/module is #{klass_underscore}" do
+      let(:const_prefix) { klass_underscore.to_s.upcase }
+      let(:const_all) { "#{const_prefix}_METHODS" }
+      let(:const_read) { "#{const_prefix}_READ_METHODS" }
+      let(:const_write) { "#{const_prefix}_WRITE_METHODS" }
+      let(:actual_all) { described_class.const_get(const_all) }
+      let(:actual_read) { described_class.const_get(const_read) }
+      let(:actual_write) { described_class.const_get(const_write) }
+
+      read_methods.each do |method_name|
+        context "when method is \"#{method_name}\"" do
+          it { expect(actual_all).to include(method_name) }
+          it { expect(actual_read).to include(method_name) }
+          it { expect(actual_write).not_to include(method_name) }
+        end
+      end
+
+      write_methods.each do |method_name|
+        context "when method is \"#{method_name}\"" do
+          it { expect(actual_all).to include(method_name) }
+          it { expect(actual_read).not_to include(method_name) }
+          it { expect(actual_write).to include(method_name) }
+        end
+      end
+    end
+  end
+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 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(::Hash.new) }
+  it { expect(super_class.hash_variable.ancestors_variable).to eq(::Hash.new) }
+  it { expect(super_class.hash_variable.to_h).to eq(::Hash.new) }
+
+  it { expect(sub_class.hash_variable).to be_a(described_class) }
+  it { expect(sub_class.hash_variable.self_variable).to eq(::Hash.new) }
+  it { expect(sub_class.hash_variable.ancestors_variable).to eq(::Hash.new) }
+  it { expect(sub_class.hash_variable.to_h).to eq(::Hash.new) }
+
+  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 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