eac_tools 0.105.1 → 0.105.2

data/sub/eac_ruby_utils/lib/eac_ruby_utils/string_delimited.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class StringDelimited
+    attr_reader :string, :begin_delimiter, :end_delimiter
+
+    def initialize(string, begin_delimiter, end_delimiter)
+      @string = string
+      @begin_delimiter = begin_delimiter
+      @end_delimiter = end_delimiter
+    end
+
+    def inner
+      between_indexes(content_index, end_index).to_s
+    end
+
+    def outer
+      between_indexes(begin_index, after_end_index).to_s
+    end
+
+    def without_inner
+      without_join(
+        between_indexes(sos_index, content_index), between_indexes(end_index, eos_index)
+      )
+    end
+
+    def without_outer
+      without_join(
+        between_indexes(sos_index, begin_index),
+        between_indexes(after_end_index, eos_index)
+      )
+    end
+
+    private
+
+    def after_end_index
+      end_index.if_present { |v| v + end_delimiter.length }
+    end
+
+    def begin_index
+      string.index(begin_delimiter)
+    end
+
+    def between_indexes(a_begin_index, a_end_index)
+      a_begin_index && a_end_index ? string[a_begin_index, a_end_index - a_begin_index] : nil
+    end
+
+    def content_index
+      begin_index.if_present { |v| v + begin_delimiter.length }
+    end
+
+    def without_join(*strings)
+      return string if strings.any?(&:nil?)
+
+      strings.join
+    end
+
+    def end_index
+      content_index.if_present { |_v| string.index(end_delimiter, content_index) }
+    end
+
+    def sos_index
+      0
+    end
+
+    def eos_index
+      string.length
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/struct.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+
+module EacRubyUtils
+  class Struct
+    def initialize(initial_data = {})
+      self.data = initial_data.symbolize_keys
+    end
+
+    def [](key)
+      key, bool = parse_key(key)
+      bool ? self[key].present? : data[key]
+    end
+
+    def fetch(key)
+      key, bool = parse_key(key)
+      bool ? fetch(key).present? : data.fetch(key)
+    end
+
+    def merge(other)
+      other = self.class.new(other) unless other.is_a?(self.class)
+      self.class.new(to_h.merge(other.to_h))
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      property_method?(method_name) ? fetch(method_name) : super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      property_method?(method_name) || super
+    end
+
+    def slice_fetch(*keys)
+      self.class.new(keys.index_with { |key| fetch(key) })
+    end
+
+    def to_h
+      data.dup
+    end
+
+    delegate :to_s, to: :data
+
+    private
+
+    attr_accessor :data
+
+    def parse_key(key)
+      m = /\A(.+)\?\z/.match(key.to_s)
+      [(m ? m[1] : key.to_s).to_sym, m ? true : false]
+    end
+
+    def property_method?(key)
+      property_methods.include?(key.to_sym)
+    end
+
+    def property_methods
+      data.keys.flat_map { |k| [k.to_sym, :"#{k}?"] }
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/unimplemented_method_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class UnimplementedMethodError < ::StandardError
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  VERSION = '0.128.6'
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/wildcards.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  # The `Wildcards` class provides pattern matching with wildcards using regular expressions.
+  class Wildcards
+    # Initializes a new instance of the `Wildcards` class with the specified pattern.
+    #
+    # @param pattern [String] The pattern to match against.
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    # Matches the given string against the pattern.
+    #
+    # @param string [String] The string to match.
+    # @return [Boolean] Returns `true` if the string matches the pattern, otherwise `false`.
+    delegate :match?, to: :regex
+
+    private
+
+    # @return [Regexp]
+    def regex
+      ::Regexp.new("^#{::Regexp.escape(@pattern).gsub('\*', '.*').gsub('\?', '.?')}$")
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/yaml.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'active_support/time_with_zone'
+require 'date'
+require 'yaml'
+
+module EacRubyUtils
+  # A safe YAML loader/dumper with common types included.
+  class Yaml
+    class << self
+      DEFAULT_PERMITTED_CLASSES = [ActiveSupport::TimeWithZone, ActiveSupport::TimeZone,
+                                   ::Array, ::Date, ::DateTime, ::FalseClass, ::Hash, ::NilClass,
+                                   ::Numeric, ::String, ::Symbol, ::Time, ::TrueClass].freeze
+
+      def dump(object)
+        ::YAML.dump(sanitize(object))
+      end
+
+      def dump_file(path, object)
+        ::File.write(path.to_s, dump(object))
+      end
+
+      def load(string)
+        ::YAML.safe_load(string, permitted_classes: permitted_classes)
+      end
+
+      def load_file(path)
+        load(::File.read(path.to_s))
+      end
+
+      def permitted_classes
+        DEFAULT_PERMITTED_CLASSES
+      end
+
+      def sanitize(object)
+        Sanitizer.new(object).result
+      end
+
+      def yaml?(object)
+        return false unless object.is_a?(::String)
+        return false unless object.start_with?('---')
+
+        load(object)
+        true
+      rescue ::Psych::Exception
+        false
+      end
+
+      class Sanitizer
+        attr_reader :source
+
+        RESULT_TYPES = %w[permitted enumerableable hashable].freeze
+
+        def initialize(source)
+          @source = source
+        end
+
+        def result
+          RESULT_TYPES.each do |type|
+            return send("result_#{type}") if send("result_#{type}?")
+          end
+
+          source.to_s
+        end
+
+        private
+
+        def result_enumerableable?
+          source.respond_to?(:to_a) && !source.is_a?(::Hash)
+        end
+
+        def result_enumerableable
+          source.to_a.map { |child| sanitize_value(child) }
+        end
+
+        def result_hashable?
+          source.respond_to?(:to_h)
+        end
+
+        def result_hashable
+          source.to_h.to_h { |k, v| [k.to_sym, sanitize_value(v)] }
+        end
+
+        def result_nil?
+          source.nil?
+        end
+
+        def result_nil
+          nil
+        end
+
+        def result_permitted?
+          (::EacRubyUtils::Yaml.permitted_classes - [::Array, ::Hash])
+            .any? { |klass| source.is_a?(klass) }
+        end
+
+        def result_permitted
+          source
+        end
+
+        def sanitize_value(value)
+          self.class.new(value).result
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/root_module_setup'
+EacRubyUtils::RootModuleSetup.perform __FILE__ do
+  ignore 'core_ext'
+  ignore 'locales/from_all_gems'
+  ignore 'patches'
+  ignore 'ruby/on_clean_environment'
+end
+
+module EacRubyUtils
+  include ::EacRubyUtils::PatchModule
+end
+
+require 'eac_ruby_utils/core_ext'

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