eac_tools 0.117.3 → 0.117.5

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe String, '#delimeted' do # rubocop:disable RSpec/SpecFilePathFormat
+  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}" # rubocop:disable RSpec/LeakyLocalVariable
+        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,63 @@
+# frozen_string_literal: true
+
+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/base_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/base_spec/stubbed_not_module.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class RequireSubStubClass
+  class StubbedNotModule # rubocop:disable Lint/EmptyClass
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub/base_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class RequireSubStubClass # rubocop:disable Lint/EmptyClass
+end
+
+RSpec.describe EacRubyUtils::RequireSub::Base do
+  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/rspec/setup/setup_manager_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe(EacRubyUtils::Rspec::Setup::SetupManager) do
+  describe '#setup_manager' do
+    it do
+      expect(setup_manager).to be_a(EacRubyUtils::Rspec::SetupManager)
+    end
+  end
+
+  describe '#app_root_path' do
+    it { expect(app_root_path).to be_a(Pathname) }
+    it { expect(app_root_path).to be_directory }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/ruby/on_clean_environment_spec.rb

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

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/ruby/on_replace_objects_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::Ruby, '#on_replace_objects' do
+  let(:stub_class) do
+    Class.new do
+      def self.my_class_method
+        'Original'
+      end
+
+      def my_instance_method
+        'Original'
+      end
+    end
+  end
+
+  let(:stub_instance) { stub_class.new }
+
+  let(:replace_block) do
+    proc { 'Replaced' }
+  end
+
+  describe '#my_instance_method' do
+    let(:before) { stub_instance.my_instance_method }
+    let(:inside) do
+      described_class.on_replace_objects do |replacer|
+        replacer.replace_instance_method(stub_class, :my_instance_method, &replace_block)
+        stub_instance.my_instance_method
+      end
+    end
+    let(:after) { stub_instance.my_instance_method }
+
+    before do
+      before
+      inside
+      after
+    end
+
+    it { expect(before).to eq('Original') }
+    it { expect(inside).to eq('Replaced') }
+    it { expect(after).to eq('Original') }
+  end
+
+  describe '#replace_self_method' do
+    let(:before) { stub_class.my_class_method }
+    let(:inside) do
+      described_class.on_replace_objects do |replacer|
+        replacer.replace_self_method(stub_class, :my_class_method, &replace_block)
+        stub_class.my_class_method
+      end
+    end
+    let(:after) { stub_class.my_class_method }
+
+    before do
+      before
+      inside
+      after
+    end
+
+    it { expect(before).to eq('Original') }
+    it { expect(inside).to eq('Replaced') }
+    it { expect(after).to eq('Original') }
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::SettingsProvider do
+  let(:stub_class) do
+    the_described_class = described_class
+    r = Class.new do
+      include the_described_class
+
+      def key_a
+        'method_a'
+      end
+
+      def key_b
+        'method_b'
+      end
+
+      def key_f
+        nil
+      end
+
+      def settings
+        { 'key_b' => 'setting_b', key_c: 'setting_c' }
+      end
+    end
+    r.const_set(:KEY_A, 'constant_a')
+    r.const_set(:KEY_D, 'constant_d')
+    r
+  end
+
+  let(:stub) { stub_class.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',
+      ['key_f'] => nil
+    }.each do |args, expected_value|
+      context "when args are \"#{args}\"" do
+        it { expect(stub.setting_value(*args)).to eq(expected_value) }
+      end
+    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 be_nil
+    end
+
+    it do
+      expect(stub.setting_value('key_e', default: nil)).to be_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,127 @@
+# frozen_string_literal: true
+
+class CacheableObject
+  include ::EacRubyUtils::SimpleCache
+
+  def my_method_uncached
+    @counter ||= 0
+    @counter += 1
+  end
+
+  def method_with_question_uncached? # rubocop:disable Naming/PredicateMethod
+    '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) # rubocop:disable RSpec/IdenticalEqualityAssertion
+    end
+
+    it 'is able to call private uncached as cached' do
+      expect(instance.private_method).to eq(instance.private_method) # rubocop:disable RSpec/IdenticalEqualityAssertion
+    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')) # rubocop:disable RSpec/IdenticalEqualityAssertion
+    end
+
+    it do
+      expect(instance.method_with_args('456')).to eq(instance.method_with_args('456')) # rubocop:disable RSpec/IdenticalEqualityAssertion
+    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

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::StaticMethodClass do
+  let(:sender_class) do
+    Class.new do
+      class << self
+        def sender_value
+          'AAA'
+        end
+      end
+    end
+  end
+
+  let(:method_class) do
+    the_described_class = described_class
+    Class.new do
+      def self.name
+        'TheSender::PerformX'
+      end
+
+      include the_described_class
+
+      attr_accessor :sender, :method_param
+
+      def initialize(sender, method_param)
+        self.sender = sender
+        self.method_param = method_param
+      end
+
+      def result
+        "#{sender.sender_value},#{method_param}"
+      end
+    end
+  end
+
+  before do
+    Object.const_set('TheSender', sender_class)
+    sender_class.const_set('PerformX', method_class)
+  end
+
+  it { expect(sender_class).to respond_to(:perform_x) }
+  it { expect(sender_class.perform_x('BBB')).to eq('AAA,BBB') }
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::Struct do
+  let(:instance) { described_class.new('a' => 1, b: '') }
+  let(:other) { described_class.new('a' => 'm1', c: 'm2') }
+
+  describe '#[]' do
+    it { expect(instance[:a]).to eq(1) }
+    it { expect(instance['a']).to eq(1) }
+    it { expect(instance[:a?]).to be(true) }
+    it { expect(instance['a?']).to be(true) }
+    it { expect(instance[:b]).to eq('') }
+    it { expect(instance['b']).to eq('') }
+    it { expect(instance[:b?]).to be(false) }
+    it { expect(instance['b?']).to be(false) }
+    it { expect(instance[:c]).to be_nil }
+    it { expect(instance['c']).to be_nil }
+    it { expect(instance[:c?]).to be(false) }
+    it { expect(instance['c?']).to be(false) }
+  end
+
+  describe '#fetch' do
+    it { expect(instance.fetch(:a)).to eq(1) }
+    it { expect(instance.fetch('a')).to eq(1) }
+    it { expect(instance.fetch(:a?)).to be(true) }
+    it { expect(instance.fetch('a?')).to be(true) }
+    it { expect(instance.fetch(:b)).to eq('') }
+    it { expect(instance.fetch('b')).to eq('') }
+    it { expect(instance.fetch(:b?)).to be(false) }
+    it { expect(instance.fetch('b?')).to be(false) }
+    it { expect { instance.fetch(:c) }.to raise_error(KeyError) }
+    it { expect { instance.fetch('c') }.to raise_error(KeyError) }
+    it { expect { instance.fetch(:c?) }.to raise_error(KeyError) }
+    it { expect { instance.fetch('c?') }.to raise_error(KeyError) }
+  end
+
+  describe '#merge' do
+    let(:merged) { instance.merge(other) }
+
+    it { expect(merged.to_h).to eq(a: 'm1', b: '', c: 'm2') }
+  end
+
+  describe '#property_method' do
+    it { expect(instance.a).to eq(1) }
+    it { expect(instance.a?).to be(true) }
+    it { expect(instance.b).to eq('') }
+    it { expect(instance.b?).to be(false) }
+    it { expect { instance.c }.to raise_error(NoMethodError) }
+    it { expect { instance.c? }.to raise_error(NoMethodError) }
+  end
+
+  describe '#to_h' do
+    it { expect(instance.to_h).to eq(a: 1, b: '') }
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe EacRubyUtils::Wildcards do
+  describe '#match' do
+    {
+      'h*llo' => { 'hello' => true, 'hallo' => true, 'hxllo' => true, 'hillo' => true },
+      'w?rld' => { 'world' => true, 'warld' => true, 'wzzrld' => false },
+      'h*l?o' => { 'hello' => true, 'hallo' => true, 'hxxllo' => true, 'hilbbo' => false },
+      '' => { '' => true, 'hello' => false },
+      'hello' => { '' => false, 'hello' => true }
+    }.each do |pattern, examples|
+      context "when pattern is '#{pattern}'" do
+        let(:instance) { described_class.new(pattern) }
+
+        examples.each do |string, expected_result|
+          context "when string is \"#{string}\"" do
+            it do
+              expect(instance.match?(string)).to eq(expected_result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+
+RSpec.describe EacRubyUtils::Yaml do
+  let(:unpermitted_class) do
+    Class.new do
+      def initialize(value)
+        @value = value
+      end
+
+      delegate :to_s, to: :@value
+    end
+  end
+
+  let(:arrayliable_class) do
+    Class.new do
+      def initialize(value)
+        @value = value
+      end
+
+      def to_a
+        [@value]
+      end
+    end
+  end
+
+  let(:source) do
+    {
+      a: 'a', b: :b, c: false, d: true, e: nil,
+      f: [
+        'f',
+        {
+          g: 'g',
+          h: ActiveSupport::HashWithIndifferentAccess.new(
+            'i' => ['i', unpermitted_class.new('j')],
+            k: arrayliable_class.new('k')
+          )
+        }
+      ]
+    }
+  end
+
+  let(:target) do
+    {
+      a: 'a', b: :b, c: false, d: true, e: nil,
+      f: ['f', { g: 'g', h: { i: %w[i j], k: ['k'] } }]
+    }
+  end
+
+  describe '#dump' do
+    it { expect(described_class.load(described_class.dump(source))).to eq(target) }
+  end
+
+  describe '#sanitize' do
+    it { expect(described_class.sanitize(target)).to eq(target) }
+  end
+
+  describe '#yaml' do
+    {
+      ['text'] => false,
+      'text' => false,
+      "--- Text\n\n" => true,
+      "---\n:index: 0\n:codec_name: h264\n:codec_type: video\n" => true,
+      '--- - \n bla bla bla' => false,
+      "---\n*STRING" => false
+    }.each do |source, result|
+      it "return #{result} to source \"#{source}\"" do
+        expect(described_class.yaml?(source)).to eq(result)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/locales/pt-BR.yml

@@ -0,0 +1,58 @@
+pt-BR:
+  eac_ruby_utils:
+    listable:
+      stub:
+        inteiro:
+          a:
+            label: Inteiro A
+            description: Inteiro A Descr.
+          b:
+            label: Inteiro BB
+            description: Inteiro BB Descr.
+          c:
+            label: Inteiro CCC
+            description: Inteiro CCC Descr.
+          __blank:
+            label: Inteiro em branco
+            description: Inteiro em branco Descr.
+        cadeia:
+          a:
+            label: Cadeia AAA
+            description: Cadeia AAA Descr.
+          b:
+            label: Cadeia BB
+            description: Cadeia BB Descr.
+          c:
+            label: Cadeia C
+            description: Cadeia C Descr.
+        code:
+          a:
+            label: Código A
+            description: Código A Descr.
+          b:
+            label: Código B
+            description: Código B Descr.
+        type:
+          a:
+            label: Tipo A
+            description: Tipo A Descr.
+          b:
+            label: Tipo B
+            description: Tipo B Descr.
+        simbolo:
+          a:
+            label: Simbolo A
+            description: Simbolo A Descr.
+          b:
+            label: Simbolo B
+            description: Simbolo B Descr.
+          c:
+            label: Simbolo C
+            description: Simbolo C Descr.
+        tipado:
+          a:
+            label: Tipado A
+            description: Tipado A Descr.
+          b:
+            label: Tipado B
+            description: Tipado B Descr.

data/sub/eac_ruby_utils/spec/meta/rubocop_check_spec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+EacRubyUtils::Rspec.default_setup.describe_rubocop