ehbrs-tools 0.28.3 → 0.31.0

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/recursive_builder_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/recursive_builder'
-
-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/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub_spec/stubbed_module_a.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-class RequireSubStubClass
-  module StubbedModuleA
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub_spec/stubbed_not_module.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-class RequireSubStubClass
-  class StubbedNotModule
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/require_sub_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-
-RSpec.describe ::EacRubyUtils::RequireSub do
-  class RequireSubStubClass
-  end
-
-  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/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/ruby_spec.rb

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

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/settings_provider'
-
-RSpec.describe ::EacRubyUtils::SettingsProvider do
-  class MyStubSettingsProvided
-    include ::EacRubyUtils::SettingsProvider
-
-    KEY_A = 'constant_a'
-    KEY_D = 'constant_d'
-
-    def key_a
-      'method_a'
-    end
-
-    def key_b
-      'method_b'
-    end
-
-    def settings
-      { 'key_b' => 'setting_b', key_c: 'setting_c' }
-    end
-  end
-
-  let(:stub) { MyStubSettingsProvided.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'
-    }.each do |args, expected_value|
-      it { expect(stub.setting_value(*args)).to eq(expected_value) }
-    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 eq(nil)
-    end
-
-    it do
-      expect(stub.setting_value('key_e', default: nil)).to eq(nil)
-    end
-
-    it do
-      expect(stub.setting_value('key_e', default: 'default_e')).to eq('default_e')
-    end
-  end
-end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/simple_cache_spec.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/simple_cache'
-
-class CacheableObject
-  include ::EacRubyUtils::SimpleCache
-
-  def my_method_uncached
-    @counter ||= 0
-    @counter += 1
-  end
-
-  def method_with_question_uncached?
-    '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)
-    end
-
-    it 'is able to call private uncached as cached' do
-      expect(instance.private_method).to eq(instance.private_method)
-    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'))
-    end
-
-    it do
-      expect(instance.method_with_args('456')).to eq(instance.method_with_args('456'))
-    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/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/struct_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/struct'
-
-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 eq(true) }
-    it { expect(instance['a?']).to eq(true) }
-    it { expect(instance[:b]).to eq('') }
-    it { expect(instance['b']).to eq('') }
-    it { expect(instance[:b?]).to eq(false) }
-    it { expect(instance['b?']).to eq(false) }
-    it { expect(instance[:c]).to eq(nil) }
-    it { expect(instance['c']).to eq(nil) }
-    it { expect(instance[:c?]).to eq(false) }
-    it { expect(instance['c?']).to eq(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 eq(true) }
-    it { expect(instance.fetch('a?')).to eq(true) }
-    it { expect(instance.fetch(:b)).to eq('') }
-    it { expect(instance.fetch('b')).to eq('') }
-    it { expect(instance.fetch(:b?)).to eq(false) }
-    it { expect(instance.fetch('b?')).to eq(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 eq(true) }
-    it { expect(instance.b).to eq('') }
-    it { expect(instance.b?).to eq(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/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/yaml_spec.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'eac_ruby_utils/yaml'
-
-RSpec.describe ::EacRubyUtils::Yaml do
-  let(:unpermitted_class) do
-    Class.new do
-      def initialize(value)
-        @value = value
-      end
-
-      def to_s
-        @value.to_s
-      end
-    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
-    }.each do |source, result|
-      it "return #{result} to source \"#{source}\"" do
-        expect(described_class.yaml?(source)).to eq(result)
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-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.
-        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/vendor/eac_ruby_utils/spec/rubocop_check_spec.rb

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

data/vendor/eac_ruby_utils/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('../lib', __dir__)
-require 'tmpdir'
-
-require 'i18n'
-::I18n.load_path << ::File.join(__dir__, 'locales/pt-BR.yml')
-::I18n.locale = 'pt-BR'
-
-RSpec.configure do |config|
-  config.example_status_persistence_file_path = ::File.join(::Dir.tmpdir, 'eac_ruby_utils_rspec')
-
-  require 'eac_ruby_utils/rspec/default_setup'
-  ::EacRubyUtils::Rspec.default_setup_create(::File.expand_path('..', __dir__), config)
-end

data/vendor/eac_templates/Gemfile

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gemspec

data/vendor/eac_templates/eac_templates.gemspec

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('lib', __dir__)
-
-require 'eac_templates/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'eac_templates'
-  s.version     = EacTemplates::VERSION
-  s.authors     = ['Put here the authors']
-  s.summary     = 'Put here de description.'
-
-  s.files = Dir['{lib}/**/*']
-
-  s.add_dependency 'eac_config', '~> 0.5'
-  s.add_dependency 'eac_ruby_utils', '~> 0.64'
-
-  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
-end

data/vendor/eac_templates/lib/eac_templates/directory.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_templates/file'
-
-module EacTemplates
-  class Directory
-    TEMPLATE_EXTNAME = '.template'
-
-    attr_reader :path
-
-    def initialize(path)
-      @path = path.is_a?(::Pathname) ? path : ::Pathname.new(path.to_s)
-    end
-
-    def apply(variables_source, directory)
-      TemplateNode.new(self, '.', directory, variables_source).apply
-    end
-
-    def child(subpath)
-      child_path = ::File.join(path, subpath)
-      return ::EacTemplates::File.new(child_path) if ::File.file?(child_path)
-      return ::EacTemplates::Directory.new(child_path) if ::File.directory?(child_path)
-
-      raise "Child \"#{subpath}\" from \"#{path}\" not found"
-    end
-
-    def children
-      path.children.map do |path_child|
-        child(path_child.basename.to_path)
-      end
-    end
-
-    private
-
-    def apply_fs_object(source_relative, target)
-      if ::File.directory?(source_absolute(source_relative))
-        apply_directory(source_relative, target)
-      elsif ::File.file?(source_absolute(source_relative))
-      end
-    end
-
-    def source_absolute(source_relative)
-      ::File.expand_path(source_relative, path)
-    end
-
-    class TemplateNode
-      attr_reader :source_directory, :source_relative, :target_root_directory, :variables_source
-
-      def initialize(source_directory, source_relative, target_root_directory, variables_source)
-        @source_directory = source_directory
-        @source_relative = source_relative
-        @target_root_directory = target_root_directory
-        @variables_source = variables_source
-      end
-
-      def apply
-        if file?
-          apply_file
-        elsif directory?
-          apply_directory
-        else
-          raise "Unknown filesystem type: #{source_absolute}"
-        end
-      end
-
-      private
-
-      def apply_directory
-        ::FileUtils.mkdir_p(target_absolute)
-        Dir.entries(source_absolute).each do |entry|
-          child(entry).apply unless %w[. ..].include?(entry)
-        end
-      end
-
-      def apply_file
-        if ::File.extname(source_absolute) == TEMPLATE_EXTNAME
-          ::EacTemplates::File.new(source_absolute).apply_to_file(
-            variables_source, target_absolute
-          )
-        else
-          ::FileUtils.cp(source_absolute, target_absolute)
-        end
-      end
-
-      def child(entry)
-        TemplateNode.new(source_directory, ::File.join(source_relative, entry),
-                         target_root_directory, variables_source)
-      end
-
-      def file?
-        ::File.file?(source_absolute)
-      end
-
-      def directory?
-        ::File.directory?(source_absolute)
-      end
-
-      def source_absolute
-        ::File.expand_path(source_relative, source_directory.path)
-      end
-
-      def target_absolute
-        ::File.expand_path(source_relative, target_root_directory)
-              .gsub(/#{::Regexp.quote(TEMPLATE_EXTNAME)}\z/, '')
-      end
-    end
-  end
-end