ehbrs-tools 0.3.0

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/version.rb

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

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/yaml.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module EacRubyUtils
+  class Yaml
+    class << self
+      def load_common(string)
+        ::YAML.safe_load(string, [::Symbol, ::Date])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/arguments_consumer'
+
+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 eq(nil) }
+  it { expect(result.fetch(:d)).to eq('d_value') }
+  it { expect(result.fetch(:e)).to eq('e_value') }
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor'
+
+RSpec.describe ::EacRubyUtils::CommonConstructor do
+  ARG_LIST = %i[a b c d].freeze
+  let(:instance) do
+    described_class.new(*ARG_LIST, default: %w[Vcc Vd]) do
+      @z = 'Vz'
+    end
+  end
+
+  class MyClass
+    attr_reader :z
+  end
+
+  let(:subject) { MyClass.new('Va', 'Vb', 'Vc') }
+
+  before do
+    instance.setup_class(::MyClass)
+  end
+
+  it { expect(subject.z).to eq('Vz') }
+
+  ARG_LIST.each do |attr|
+    expected_value = "V#{attr}"
+    it "attribute \"#{attr}\" equal to \"#{expected_value}\"" do
+      expect(subject.send(attr)).to eq(expected_value)
+    end
+    [false, true].each do |include_all|
+      it "respond_to?('#{attr}', #{include_all}) == #{include_all}" do
+        expect(subject.respond_to?("#{attr}=", include_all)).to eq(include_all)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'eac_ruby_utils/configs'
+
+RSpec.describe ::EacRubyUtils::Configs do
+  let(:configs_key) { 'configsspec' }
+  let(:storage_path) do
+    file = ::Tempfile.new(configs_key)
+    path = file.path
+    file.close
+    file.unlink
+    path
+  end
+  let(:instance) { described_class.new(configs_key, storage_path: storage_path) }
+
+  describe '#storage_path' do
+    it { expect(instance.storage_path).to eq(storage_path) }
+  end
+
+  describe '#write' do
+    let(:entry_key) { 'parent.child' }
+
+    before do
+      instance[entry_key] = 'value1'
+      instance.save
+    end
+
+    it { expect(::YAML.load_file(storage_path)).to eq(parent: { child: 'value1' }) }
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/console/configs_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/configs'
+
+RSpec.describe ::EacRubyUtils::Console::Configs do
+  describe '#entry_key_to_envvar_name' do
+    {
+      'a.entry.value' => 'A_ENTRY_VALUE',
+      'appli-cation_0.var_one' => 'APPLICATION_0_VAR_ONE'
+    }.each do |input, expected_result|
+      it { expect(described_class.entry_key_to_envvar_name(input)).to eq(expected_result) }
+    end
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/console/docopt_runner_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/docopt_runner'
+
+RSpec.describe ::EacRubyUtils::Console::DocoptRunner do
+  context 'runner without DOC constant' do
+    class RunnerWithoutDocConstant < ::EacRubyUtils::Console::DocoptRunner
+      def run
+        # Do nothing
+      end
+    end
+
+    let(:options) { { argv: [] } }
+
+    it 'raises exception if doc argument is not supplied' do
+      expect { RunnerWithoutDocConstant.new(options) }.to raise_error(::StandardError)
+    end
+
+    context 'doc argument is supplied' do
+      let(:doc) do
+        <<~DOCUMENT
+          Runner without doc constant.
+
+          Usage:
+            __PROGRAM__
+        DOCUMENT
+      end
+
+      let(:options_with_doc) { options.merge(doc: doc) }
+
+      it 'reads doc from arguments' do
+        expect { RunnerWithoutDocConstant.new(options_with_doc) }.not_to raise_error
+      end
+    end
+  end
+
+  context 'doc with subcommands' do
+    class RunnerWithSubcommands < ::EacRubyUtils::Console::DocoptRunner
+      attr_accessor :subarg_value, :suboption_value
+
+      DOC = <<~DOCUMENT
+        A root runner with subcommands.
+
+        Usage:
+          __PROGRAM__ <parent-arg> __SUBCOMMANDS__
+      DOCUMENT
+
+      def parent_arg
+        options.fetch('<parent-arg>')
+      end
+
+      class MySubCommand < ::EacRubyUtils::Console::DocoptRunner
+        DOC = <<~DOCUMENT
+          A root runner with subcommands.
+
+          Usage:
+            __PROGRAM__ [--suboption=<suboption-value] <subarg-value>
+        DOCUMENT
+
+        def run
+          parent.suboption_value = options.fetch('--suboption')
+          parent.subarg_value = options.fetch('<subarg-value>')
+        end
+      end
+    end
+
+    let(:instance) { RunnerWithSubcommands.new }
+
+    context '#subcommands?' do
+      it 'returns true' do
+        expect(instance.subcommands?).to eq(true)
+      end
+    end
+
+    context 'when subcommand is valid' do
+      let(:instance) do
+        RunnerWithSubcommands.new(argv: %w[value0 my-sub-command value1 --suboption value2])
+      end
+
+      describe '#subcommand_arg_as_list?' do
+        it { expect(instance.subcommand_arg_as_list?).to eq(false) }
+      end
+
+      describe '#target_doc' do
+        it { expect(instance.target_doc).to include('Subcommands:') }
+      end
+
+      context '#subcommand' do
+        it 'is of subcommand class' do
+          expect(instance.subcommand).to be_a(RunnerWithSubcommands::MySubCommand)
+        end
+      end
+
+      context '#context' do
+        it 'accesses instance methods by subcommand' do
+          expect(instance.subcommand.context(:parent_arg)).to eq('value0')
+        end
+      end
+
+      context '#run' do
+        it 'calls subcommand' do
+          instance.run
+          expect(instance.subarg_value).to eq('value1')
+          expect(instance.suboption_value).to eq('value2')
+        end
+      end
+    end
+
+    context 'when subcommand is invalid' do
+      let(:instance) { RunnerWithSubcommands.new(argv: %w[value0 invalid-subcommand]) }
+
+      context '#run' do
+        it 'raises Docopt::Exit' do
+          expect { instance.run }.to raise_error(::Docopt::Exit)
+        end
+      end
+    end
+
+    context 'when subcommand as arg list is enabled' do
+      let(:argv) { %w[value0 my-sub-command value1 --suboption value2] }
+      let(:instance) { RunnerWithSubcommands.new(argv: argv, subcommand_arg_as_list: true) }
+
+      describe '#subcommand_arg_as_list?' do
+        it { expect(instance.subcommand_arg_as_list?).to eq(true) }
+      end
+
+      describe '#target_doc' do
+        it { expect(instance.target_doc).to include('(my-sub-command)') }
+      end
+
+      describe '#subcommand_name' do
+        it { expect(instance.subcommand_name).to eq('my-sub-command') }
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/console/speaker_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/speaker'
+
+RSpec.describe ::EacRubyUtils::Console::Speaker do
+  let(:instance) do
+    r = ::Object.new
+    r.extend(described_class)
+    r
+  end
+
+  context '#request_input' do
+    it 'recover value from hash list' do
+      allow(instance).to receive(:request_string).and_return('opt1')
+      list = { opt1: 'value1', opt2: 'value2' }
+      expect(instance.request_input('Question', list: list)).to eq('value1')
+    end
+
+    it 'recover value from array list' do
+      allow(instance).to receive(:request_string).and_return('OPT1')
+      list = %w[opt1 opt2]
+      expect(instance.request_input('Question', list: list)).to eq('opt1')
+    end
+
+    {
+      'yes' => true, 'y' => true, 'Y' => true, 'NO' => false, 'no' => false, 'n' => false
+    }.each do |input, expected|
+      context "when bool: true and input is \"#{input}\"" do
+        it "return #{expected}" do
+          allow(instance).to receive(:request_string).and_return(input)
+          expect(instance.request_input('Question', bool: true)).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/executable_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/executable'
+require 'eac_ruby_utils/envs/local_env'
+
+RSpec.describe ::EacRubyUtils::Envs::Executable do
+  let(:env) { ::EacRubyUtils::Envs::LocalEnv.new }
+  context 'when program exist' do
+    let(:instance) { described_class.new(env, 'cat', '--version') }
+
+    it { expect(instance.exist?).to eq(true) }
+    it { expect { instance.validate! }.not_to raise_error }
+    it { expect(instance.validate).to be_blank }
+    it { expect(instance.command).to be_a(::EacRubyUtils::Envs::Command) }
+  end
+
+  context 'when program does not exist' do
+    let(:instance) { described_class.new(env, 'this_cannot_exist', '--version') }
+
+    it { expect(instance.exist?).to eq(false) }
+    it {
+      expect { instance.validate! }.to raise_error(
+        described_class.const_get('ProgramNotFoundError')
+      )
+    }
+    it { expect(instance.validate).to be_present }
+    it {
+      expect { instance.command }.to raise_error(
+        described_class.const_get('ProgramNotFoundError')
+      )
+    }
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/ssh_env_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/ssh_env'
+
+RSpec.describe ::EacRubyUtils::Envs::SshEnv do
+  describe '#ssh_command_line' do
+    {
+      'eduardo@localhost' => 'ssh eduardo@localhost',
+      'ssh://eduardo@localhost' => 'ssh eduardo@localhost',
+      'ssh://eduardo@localhost:2222' => 'ssh -p 2222 eduardo@localhost',
+      'localhost' => 'ssh localhost'
+    }.each do |input, expected|
+      it "convert \"#{input}\" to \"#{expected}\"" do
+        env = described_class.new(input)
+        expect(env.send('ssh_command_line')).to eq(expected)
+      end
+    end
+
+    ['my user@hostname', 'http://hostname', 'ssh:/invalid-test', 'Fulano de tal'].each do |input|
+      it "\"#{input}\" raise error" do
+        expect { described_class.new(input) }.to raise_error(StandardError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_ruby_utils/filesystem_cache'
+
+RSpec.describe ::EacRubyUtils::FilesystemCache do
+  let(:tmpdir) { ::Dir.mktmpdir }
+  let(:instance) { described_class.new(tmpdir, 'instance') }
+
+  it { expect(instance.read).to be_blank }
+  it { expect(instance.cached?).to eq(false) }
+
+  context 'when instance is writed' do
+    before { instance.write('STUB') }
+
+    it { expect(instance.read).to eq('STUB') }
+    it { expect(instance.cached?).to eq(true) }
+
+    context 'when instance is cleared' do
+      before { instance.clear }
+
+      it { expect(instance.read).to be_blank }
+      it { expect(instance.cached?).to eq(false) }
+    end
+  end
+
+  describe '#child' do
+    let(:child) { instance.child('child') }
+
+    it { expect(child.path).to match(/\A#{::Regexp.quote(instance.path)}/) }
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/listable'
+
+class Stub
+  include ::EacRubyUtils::Listable
+
+  attr_accessor :inteiro, :code, :cadeia, :type
+
+  lists.add_integer :inteiro, :a, :b, :c
+  lists.add_integer :code, 7 => :a, 13 => :b
+  lists.add_string :cadeia, :a, :b, :c
+  lists.add_string :type, 'Namespace::ClazzA' => :a, 'Namespace::ClazzB' => :b
+end
+
+RSpec.describe ::EacRubyUtils::Listable do
+  context 'attribute values' do
+    it { expect(Stub.lists.inteiro.values).to eq([1, 2, 3]) }
+    it { expect(Stub.lists.code.values).to eq([7, 13]) }
+    it { expect(Stub.lists.cadeia.values).to eq(%w[a b c]) }
+    it { expect(Stub.lists.type.values).to eq(%w[Namespace::ClazzA Namespace::ClazzB]) }
+  end
+
+  context 'value instance options' do
+    it {
+      expect(Stub.lists.inteiro.options)
+        .to eq([['Inteiro A', 1], ['Inteiro BB', 2], ['Inteiro CCC', 3]])
+    }
+    it {
+      expect(Stub.lists.code.options)
+        .to eq([['Código A', 7], ['Código B', 13]])
+    }
+    it {
+      expect(Stub.lists.cadeia.options)
+        .to eq([['Cadeia AAA', 'a'], ['Cadeia BB', 'b'], ['Cadeia C', 'c']])
+    }
+    it {
+      expect(Stub.lists.type.options)
+        .to eq([['Tipo A', 'Namespace::ClazzA'], ['Tipo B', 'Namespace::ClazzB']])
+    }
+  end
+
+  context 'constants' do
+    it { expect(Stub::INTEIRO_A).to eq(1) }
+    it { expect(Stub::INTEIRO_B).to eq(2) }
+    it { expect(Stub::INTEIRO_C).to eq(3) }
+    it { expect(Stub::CODE_A).to eq(7) }
+    it { expect(Stub::CODE_B).to eq(13) }
+    it { expect(Stub::CADEIA_A).to eq('a') }
+    it { expect(Stub::CADEIA_C).to eq('c') }
+    it { expect(Stub::TYPE_A).to eq('Namespace::ClazzA') }
+    it { expect(Stub::TYPE_B).to eq('Namespace::ClazzB') }
+  end
+
+  context 'values instances' do
+    it { expect(Stub.lists.is_a?(::EacRubyUtils::Listable::Lists)).to eq(true) }
+    it { expect(Stub.lists.inteiro.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.inteiro.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.inteiro.value_c.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.code.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.code.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.cadeia.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.cadeia.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.cadeia.value_c.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.type.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.type.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+  end
+
+  context 'value instance label' do
+    it { expect(Stub.lists.inteiro.value_a.label).to eq('Inteiro A') }
+    it { expect(Stub.lists.inteiro.value_b.label).to eq('Inteiro BB') }
+    it { expect(Stub.lists.inteiro.value_c.label).to eq('Inteiro CCC') }
+    it { expect(Stub.lists.code.value_a.label).to eq('Código A') }
+    it { expect(Stub.lists.code.value_b.label).to eq('Código B') }
+    it { expect(Stub.lists.cadeia.value_a.label).to eq('Cadeia AAA') }
+    it { expect(Stub.lists.cadeia.value_b.label).to eq('Cadeia BB') }
+    it { expect(Stub.lists.cadeia.value_c.label).to eq('Cadeia C') }
+    it { expect(Stub.lists.type.value_a.label).to eq('Tipo A') }
+    it { expect(Stub.lists.type.value_b.label).to eq('Tipo B') }
+  end
+
+  context 'value instance description' do
+    it { expect(Stub.lists.inteiro.value_a.description).to eq('Inteiro A Descr.') }
+    it { expect(Stub.lists.inteiro.value_b.description).to eq('Inteiro BB Descr.') }
+    it { expect(Stub.lists.inteiro.value_c.description).to eq('Inteiro CCC Descr.') }
+    it { expect(Stub.lists.code.value_a.description).to eq('Código A Descr.') }
+    it { expect(Stub.lists.code.value_b.description).to eq('Código B Descr.') }
+    it { expect(Stub.lists.cadeia.value_a.description).to eq('Cadeia AAA Descr.') }
+    it { expect(Stub.lists.cadeia.value_b.description).to eq('Cadeia BB Descr.') }
+    it { expect(Stub.lists.cadeia.value_c.description).to eq('Cadeia C Descr.') }
+    it { expect(Stub.lists.type.value_a.description).to eq('Tipo A Descr.') }
+    it { expect(Stub.lists.type.value_b.description).to eq('Tipo B Descr.') }
+  end
+
+  context 'value instance constant name' do
+    it { expect(Stub.lists.inteiro.value_a.constant_name).to eq('INTEIRO_A') }
+    it { expect(Stub.lists.inteiro.value_b.constant_name).to eq('INTEIRO_B') }
+    it { expect(Stub.lists.inteiro.value_c.constant_name).to eq('INTEIRO_C') }
+    it { expect(Stub.lists.code.value_a.constant_name).to eq('CODE_A') }
+    it { expect(Stub.lists.code.value_b.constant_name).to eq('CODE_B') }
+    it { expect(Stub.lists.cadeia.value_a.constant_name).to eq('CADEIA_A') }
+    it { expect(Stub.lists.cadeia.value_b.constant_name).to eq('CADEIA_B') }
+    it { expect(Stub.lists.cadeia.value_c.constant_name).to eq('CADEIA_C') }
+    it { expect(Stub.lists.type.value_a.constant_name).to eq('TYPE_A') }
+    it { expect(Stub.lists.type.value_b.constant_name).to eq('TYPE_B') }
+  end
+
+  context 'instance label and descriptions' do
+    let(:instance) { Stub.new }
+
+    context 'when inteiro value is A' do
+      before { instance.inteiro = Stub::INTEIRO_A }
+      it { expect(instance.inteiro_label).to eq('Inteiro A') }
+      it { expect(instance.inteiro_description).to eq('Inteiro A Descr.') }
+    end
+
+    context 'when inteiro value is A' do
+      before { instance.inteiro = Stub::INTEIRO_B }
+      it { expect(instance.inteiro_label).to eq('Inteiro BB') }
+      it { expect(instance.inteiro_description).to eq('Inteiro BB Descr.') }
+    end
+
+    context 'when inteiro value is C' do
+      before { instance.inteiro = Stub::INTEIRO_C }
+      it { expect(instance.inteiro_label).to eq('Inteiro CCC') }
+      it { expect(instance.inteiro_description).to eq('Inteiro CCC Descr.') }
+    end
+
+    context 'when code value is A' do
+      before { instance.code = Stub::CODE_A }
+      it { expect(instance.code_label).to eq('Código A') }
+      it { expect(instance.code_description).to eq('Código A Descr.') }
+    end
+
+    context 'when code value is B' do
+      before { instance.code = Stub::CODE_B }
+      it { expect(instance.code_label).to eq('Código B') }
+      it { expect(instance.code_description).to eq('Código B Descr.') }
+    end
+
+    context 'when cadeia value is A' do
+      before { instance.cadeia = Stub::CADEIA_A }
+      it { expect(instance.cadeia_label).to eq('Cadeia AAA') }
+      it { expect(instance.cadeia_description).to eq('Cadeia AAA Descr.') }
+    end
+
+    context 'when cadeia value is B' do
+      before { instance.cadeia = Stub::CADEIA_B }
+      it { expect(instance.cadeia_label).to eq('Cadeia BB') }
+      it { expect(instance.cadeia_description).to eq('Cadeia BB Descr.') }
+    end
+
+    context 'when cadeia value is C' do
+      before { instance.cadeia = Stub::CADEIA_C }
+      it { expect(instance.cadeia_label).to eq('Cadeia C') }
+      it { expect(instance.cadeia_description).to eq('Cadeia C Descr.') }
+    end
+
+    context 'when type value is A' do
+      before { instance.type = Stub::TYPE_A }
+      it { expect(instance.type_label).to eq('Tipo A') }
+      it { expect(instance.type_description).to eq('Tipo A Descr.') }
+    end
+
+    context 'when type value is B' do
+      before { instance.type = Stub::TYPE_B }
+      it { expect(instance.type_label).to eq('Tipo B') }
+      it { expect(instance.type_description).to eq('Tipo B Descr.') }
+    end
+  end
+
+  describe '#value_validate!' do
+    it { expect { Stub.lists.inteiro.value_validate!(1) }.not_to raise_error }
+    it { expect { Stub.lists.inteiro.value_validate!('1') }.to raise_error }
+    it { expect { Stub.lists.inteiro.value_validate!(10) }.to raise_error(::StandardError) }
+    it { expect { Stub.lists.cadeia.value_validate!(:a) }.to raise_error }
+    it { expect { Stub.lists.cadeia.value_validate!('a') }.not_to raise_error }
+    it { expect { Stub.lists.cadeia.value_validate!(:z) }.to raise_error(::StandardError) }
+  end
+end