eac_tools 0.108.0 → 0.110.0

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

@@ -1,107 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,91 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,52 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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