eac_tools 0.119.0 → 0.120.0

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+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(:sub_class) do
+    Class.new(base_class) do
+      def method1
+        'a result'
+      end
+
+      def method4
+        'sub result'
+      end
+    end
+  end
+
+  class << self
+    def specs_for_target(test_target, instances_hash)
+      describe "##{test_target}" do
+        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
+          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
+          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/acts_as_immutable/array_accessor_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::ActsAsImmutable::ArrayAccessor do
+  let(:stub_class) do
+    Class.new do
+      include EacRubyUtils::ActsAsImmutable
+
+      immutable_accessor :array_attr, type: :array
+    end
+  end
+
+  let(:initial_instance) { stub_class.new }
+
+  it do
+    expect(initial_instance.array_attrs).to eq([])
+  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(%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(%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,55 @@
+# frozen_string_literal: true
+
+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 be_nil }
+  it { expect(initial_instance.attr3).to be_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 be_nil }
+    it { expect(change1_instance.attr3).to be_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 be_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 be_nil }
+      it { expect(change2_instance.attr3).to eq('C') }
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::ActsAsImmutable::HashAccessor do
+  let(:stub_class) do
+    Class.new do
+      include EacRubyUtils::ActsAsImmutable
+
+      immutable_accessor :the_hash, type: :hash
+    end
+  end
+
+  let(:initial_instance) { stub_class.new }
+
+  it { expect(initial_instance.the_hashes).to eq({}) }
+  it { expect(initial_instance.the_hash('key_a')).to be_nil }
+
+  context 'when a single value is set' do
+    let(:change1_instance) { initial_instance.the_hash('key_a', 'A') }
+
+    before { change1_instance }
+
+    it { expect(initial_instance.the_hashes).to eq({}) }
+    it { expect(initial_instance.the_hash('key_a')).to be_nil }
+    it { expect(change1_instance.the_hashes).to eq({ 'key_a' => 'A' }) }
+    it { expect(change1_instance.the_hash('key_a')).to eq('A') }
+
+    context 'when all valuesare set' do
+      let(:change2_instance) { initial_instance.the_hashes('key_b' => 'B') }
+
+      before { change2_instance }
+
+      it { expect(change1_instance.the_hashes).to eq({ 'key_a' => 'A' }) }
+      it { expect(change1_instance.the_hash('key_a')).to eq('A') }
+      it { expect(change1_instance.the_hash('key_b')).to be_nil }
+      it { expect(change2_instance.the_hashes).to eq({ 'key_b' => 'B' }) }
+      it { expect(change2_instance.the_hash('key_a')).to be_nil }
+      it { expect(change2_instance.the_hash('key_b')).to eq('B') }
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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/arguments_consumer_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::ArgumentsConsumer do
+  let(:instance) { described_class.new(%i[a b c d], d: 'd_value') }
+  let(:args) { ['a_value', 'b_value', { e: 'e_value' }] }
+  let(:result) { instance.parse(args) }
+
+  it { expect(result).to be_a(Hash) }
+  it { expect(result.count).to eq(5) }
+  it { expect(result.fetch(:a)).to eq('a_value') }
+  it { expect(result.fetch(:b)).to eq('b_value') }
+  it { expect(result.fetch(:c)).to be_nil }
+  it { expect(result.fetch(:d)).to eq('d_value') }
+  it { expect(result.fetch(:e)).to eq('e_value') }
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::BitArray do
+  describe '#to_byte_array' do
+    let(:instance) { described_class.new([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1]) }
+
+    {
+      false => [0xF0, 0xDC],
+      true => [0x0F, 0x3B]
+    }.each do |big_endian, expected_bytes|
+      context "when big-endian is #{big_endian}" do
+        let(:expected_value) { EacRubyUtils::ByteArray.new(expected_bytes) }
+
+        it do
+          expect(instance.to_byte_array(big_endian)).to eq(expected_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::BlankNotBlank do
+  let(:instance) { described_class.instance }
+
+  it do
+    expect { described_class.new }.to raise_error(NoMethodError)
+  end
+
+  it { expect(instance).to be_present }
+  it { expect(instance).not_to be_blank }
+  it { expect(instance).to be_truthy }
+  it { expect(instance).to eq('') }
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::Byte do
+  describe '#[]' do
+    let(:instance) { described_class.new(0xDC) }
+
+    [0, 0, 1, 1, 1, 0, 1, 1].each_with_index do |bit_value, bit_index|
+      context "when bit index is #{bit_index}" do
+        it { expect(instance[bit_index].value).to eq(bit_value) }
+      end
+    end
+  end
+
+  describe '#bit_set' do
+    let(:instance) { described_class.new(0b11011100) }
+
+    {
+      0 => [0b11011100, 0b11011100, 0b11011000, 0b11010100,
+            0b11001100, 0b11011100, 0b10011100, 0b01011100],
+      1 => [0b11011101, 0b11011110, 0b11011100, 0b11011100,
+            0b11011100, 0b11111100, 0b11011100, 0b11011100]
+    }.each do |bit_value, expected_values|
+      expected_values.each_with_index do |expected_value, bit_index|
+        context "when bit index is #{bit_index} and bit value is #{bit_value}" do
+          it do
+            expect(instance.bit_set(bit_index, bit_value))
+              .to eq(described_class.new(expected_value))
+          end
+        end
+      end
+    end
+  end
+
+  describe '#from_bit_array' do
+    let(:bit_array) { [0, 0, 1, 1, 1, 0, 1, 1] }
+
+    { false => 0b11011100, true => 0b00111011 }.each do |big_endian, expected_integer|
+      context "when big-endian is #{big_endian}" do
+        let(:expected_value) { described_class.new(expected_integer) }
+
+        it do
+          expect(described_class.from_bit_array(bit_array, big_endian)).to eq(expected_value)
+        end
+      end
+    end
+
+    it do
+      expect { described_class.from_bit_array([0, 0, 1, 1, 1, 0, 1]) }
+        .to raise_error(ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::CommonConcern do
+  let(:instance) do
+    described_class.new do
+      self.valor = 'changed'
+    end
+  end
+
+  let(:stub_module) do
+    Module.new do
+      module ClassMethods # rubocop:disable Lint/ConstantDefinitionInBlock,RSpec/LeakyConstantDeclaration
+        def my_class_method
+          'class'
+        end
+      end
+
+      module InstanceMethods # rubocop:disable Lint/ConstantDefinitionInBlock,RSpec/LeakyConstantDeclaration
+        def my_instance_method
+          'from_module'
+        end
+      end
+    end
+  end
+
+  let(:stub_class) do
+    Class.new do
+      class << self
+        attr_accessor :valor
+      end
+
+      def my_instance_method
+        'from_class'
+      end
+    end
+  end
+
+  let(:stub_class_instance) { stub_class.new }
+
+  before do
+    instance.setup(stub_module)
+  end
+
+  context 'when included' do
+    before do
+      stub_class.include stub_module
+    end
+
+    it { expect(stub_class_instance.my_instance_method).to eq('from_class') }
+    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
+    it { expect(stub_class_instance.class.valor).to eq('changed') }
+  end
+
+  context 'when prepended' do
+    before do
+      stub_class.prepend stub_module
+    end
+
+    it { expect(stub_class_instance.my_instance_method).to eq('from_module') }
+    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
+    it { expect(stub_class_instance.class.valor).to eq('changed') }
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::CommonConstructor do
+  ARG_LIST = %i[a b c d].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, 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}" # rubocop:disable RSpec/LeakyLocalVariable
+    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 block argument' do
+    let(:instance) do
+      described_class.new(:first, :second, :last, block_arg: true, default: ['second'])
+    end
+
+    let(:block) do
+      proc { first + second }
+    end
+
+    let(:a_class) do
+      Class.new do
+        def result
+          last.run
+        end
+      end
+    end
+
+    let(:a_class_instance) { a_class.new('first') { 'last' } }
+
+    it { expect(a_class_instance.last).to be_a(Proc) }
+    it { expect(a_class_instance.last.call).to eq('last') }
+
+    it { expect(a_class_instance.first).to eq('first') }
+    it { expect(a_class_instance.second).to eq('second') }
+  end
+
+  context 'with class hierarchy mixed with and without common_constructor' do
+    let(:klass_0) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      described_class.new(:a_param).setup_class(Class.new)
+    end
+
+    let(:klass_1) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      Class.new(klass_0) do
+        def initialize(a_param) # rubocop:disable Lint/UselessMethodDefinition
+          super
+        end
+      end
+    end
+
+    let(:klass_2) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      Class.new(klass_1)
+    end
+
+    let(:klass_3) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      described_class.new(:a_param).setup_class(Class.new(klass_2))
+    end
+
+    4.times.each do |i|
+      context "with #{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/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/compact_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::Compact do
+  let(:sub_object) { Struct.new(:c_attr).new('c_value') }
+  let(:object) { Struct.new(:a_attr, :b_attr, :sub).new('a_value', 'b_value', sub_object) }
+  let(:instance) { described_class.new(object, %w[a_attr b_attr sub.c_attr]) }
+
+  describe '#to_a' do
+    it do
+      expect(instance.to_a).to eq(%w[a_value b_value c_value])
+    end
+  end
+
+  describe '#to_h' do
+    it do
+      expect(instance.to_h).to eq(a_attr: 'a_value', b_attr: 'b_value', 'sub.c_attr': 'c_value')
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::CompareBy do
+  let(:instance) { described_class.new(%i[field1 field2]) }
+  let(:klass) do
+    Class.new do
+      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
+
+  before { instance.apply(klass) }
+
+  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