ehbrs-tools 0.16.0 → 0.16.1

data/vendor/aranha-parsers/spec/lib/aranha/parsers/source_address_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/source_address'
+
+RSpec.describe ::Aranha::Parsers::SourceAddress do
+  describe '#detect_sub' do
+    {
+      { method: :post, url: 'http://postdata.net', params: { key1: :value1 } } => {
+        klass: ::Aranha::Parsers::SourceAddress::HashHttpPost,
+        url: 'http://postdata.net',
+        serialization: <<~SERIALIZATION
+          --- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+          method: :post
+          url: http://postdata.net
+          params: !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+            key1: :value1
+        SERIALIZATION
+      },
+      { method: :get, url: 'http://getdata.net', params: { headers: %w[abc] } } => {
+        klass: ::Aranha::Parsers::SourceAddress::HashHttpPost,
+        url: 'http://getdata.net',
+        serialization: <<~SERIALIZATION
+          --- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+          method: :get
+          url: http://getdata.net
+          params: !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+            headers:
+            - abc
+        SERIALIZATION
+      },
+      'http://postdata.net' => {
+        klass: ::Aranha::Parsers::SourceAddress::HttpGet,
+        url: 'http://postdata.net',
+        serialization: 'http://postdata.net'
+      },
+      'https://getdata.com.br' => {
+        klass: ::Aranha::Parsers::SourceAddress::HttpGet,
+        url: 'https://getdata.com.br',
+        serialization: 'https://getdata.com.br'
+      },
+      'file:///postdata.net' => {
+        klass: ::Aranha::Parsers::SourceAddress::File,
+        url: 'file:///postdata.net',
+        serialization: 'file:///postdata.net'
+      },
+      '/postdata.net' => {
+        klass: ::Aranha::Parsers::SourceAddress::File,
+        url: 'file:///postdata.net',
+        serialization: 'file:///postdata.net'
+      }
+    }.each do |source, expected|
+      context "when source is #{source}" do
+        let(:sub) { described_class.detect_sub(source) }
+        let(:deserialized) { described_class.deserialize(sub.serialize).sub }
+
+        it "sub is a #{expected.fetch(:klass)}" do
+          expect(sub).to be_a(expected.fetch(:klass))
+        end
+
+        it "sub #{expected.fetch(:klass)} return properly URL" do
+          expect(sub.url).to eq(expected.fetch(:url))
+        end
+
+        it "sub #{expected.fetch(:klass)} serialize properly" do
+          expect(sub.serialize).to eq(expected.fetch(:serialization))
+        end
+
+        it 'deserialize properly' do
+          expect(deserialized).to eq(sub)
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/spec/lib/aranha/parsers/source_target_fixtures_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/source_target_fixtures'
+
+RSpec.describe ::Aranha::Parsers::SourceTargetFixtures do
+  let(:fixtures_dir) { ::File.join(__dir__, 'source_target_fixtures_spec_files') }
+  let(:instance) { described_class.new(fixtures_dir) }
+
+  describe '#source_target_files' do
+    it { expect(instance.source_target_files.count).to eq(3) }
+
+    (1..3).each do |index|
+      basename = "stub#{index}"
+      let(basename) { instance.source_target_files.find { |stf| stf.basename == basename } }
+
+      it { expect(send(basename)).to be_present }
+      it { expect(send(basename).basename).to eq(basename) }
+    end
+
+    it { expect(stub1.source).to eq(::File.join(fixtures_dir, 'stub1.source.txt')) }
+    it { expect(stub1.target).to eq(::File.join(fixtures_dir, 'stub1.target.html')) }
+    it { expect(stub2.source).to eq(::File.join(fixtures_dir, 'stub2.source.html')) }
+    it { expect(stub2.target).to eq(nil) }
+    it { expect(stub3.source).to eq(nil) }
+    it { expect(stub3.target).to eq(::File.join(fixtures_dir, 'stub3.target.yaml')) }
+  end
+end

data/vendor/aranha-parsers/spec/lib/aranha/parsers/source_target_fixtures_spec_files/stub1.source.txt

@@ -0,0 +1 @@
+

data/vendor/aranha-parsers/spec/lib/aranha/parsers/source_target_fixtures_spec_files/stub1.target.html

@@ -0,0 +1 @@
+

data/vendor/aranha-parsers/spec/lib/aranha/parsers/source_target_fixtures_spec_files/stub2.source.html

@@ -0,0 +1 @@
+

data/vendor/aranha-parsers/spec/lib/aranha/parsers/source_target_fixtures_spec_files/stub3.target.yaml

@@ -0,0 +1 @@
+

data/vendor/aranha-parsers/spec/lib/rubocop_check_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_gem_support/spec/examples/rubocop_check'
+
+RSpec.describe ::RuboCop do
+  include_examples 'rubocop_check', ::File.expand_path('../..', __dir__)
+end

data/vendor/aranha-parsers/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __dir__)
+require 'tmpdir'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ::File.join(::Dir.tmpdir, 'aranha-parsers_rspec')
+end

data/vendor/eac_cli/lib/eac_cli/definition.rb

@@ -45,6 +45,10 @@ module EacCli
       self.description = description
     end
 
+    def help_formatter
+      @help_formatter ||= ::EacCli::Definition::HelpFormatter.new(self)
+    end
+
     def options_arg(options_argument)
       self.options_argument = options_argument
     end
@@ -54,17 +58,23 @@ module EacCli
     end
 
     def pos_arg(name, arg_options = {})
-      raise 'Positional arguments are blocked' if positional_arguments_blocked?
+      new_pos_arg = ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+      raise 'Positional arguments are blocked' if positional_arguments_blocked?(new_pos_arg)
 
-      pos_set << ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+      pos_set << new_pos_arg
     end
 
     def positional
       pos_set.to_a
     end
 
-    def positional_arguments_blocked?
-      pos_set.any? { |e| e.optional? || e.repeat? }
+    def positional_arguments_blocked?(new_pos_arg)
+      last = pos_set.last
+      return false unless last
+      return true if last.repeat?
+      return true if last.optional? && new_pos_arg.required?
+
+      false
     end
 
     def subcommands

data/vendor/eac_cli/lib/eac_cli/definition/help_formatter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Definition
+    class HelpFormatter
+      SEP = ' '
+      IDENT = SEP * 2
+      OPTION_DESC_SEP = IDENT * 2
+
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=VALUE' if option.argument?
+          b
+        end
+
+        def option_short(option)
+          b = option.short
+          b += 'VALUE' if option.argument?
+          b
+        end
+      end
+
+      common_constructor :definition
+
+      def positional_argument(positional)
+        if positional.subcommand?
+          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+        else
+          r = "<#{positional.name}>"
+          r += '...' if positional.repeat?
+          r = "[#{r}]" if positional.optional?
+          r
+        end
+      end
+
+      def section(header, include_header = true)
+        b = include_header ? "#{header.humanize}:\n" : ''
+        b += send("self_#{header}") + "\n"
+        # TO-DO: implement alternatives
+        b
+      end
+
+      def self_options
+        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
+      end
+
+      def self_usage
+        IDENT + self_usage_arguments.join(SEP)
+      end
+
+      def self_usage_arguments
+        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
+          self_usage_arguments_options +
+          self_usage_arguments_positional
+      end
+
+      def self_usage_arguments_options
+        definition.options.select(&:show_on_usage?).map do |option|
+          self.class.option_long(option)
+        end
+      end
+
+      def self_usage_arguments_positional
+        definition.positional.map { |p| positional_argument(p) }
+      end
+
+      def to_banner
+        "#{definition.description}\n\n#{section('usage')}"
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/definition/positional_argument.rb

@@ -5,8 +5,10 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class PositionalArgument
+      DEFAULT_REQUIRED = true
+
       enable_listable
-      lists.add_symbol :option, :optional, :repeat, :subcommand
+      lists.add_symbol :option, :optional, :repeat, :required, :subcommand
       common_constructor :name, :options, default: [{}] do
         options.assert_valid_keys(self.class.lists.option.values)
       end
@@ -16,16 +18,27 @@ module EacCli
       end
 
       def optional?
-        options[OPTION_OPTIONAL]
+        !required?
       end
 
       def repeat?
         options[OPTION_REPEAT]
       end
 
+      def required?
+        return true if options.key?(OPTION_REQUIRED) && options.fetch(OPTION_REQUIRED)
+        return false if options.key?(OPTION_OPTIONAL) && options.fetch(OPTION_OPTIONAL)
+
+        DEFAULT_REQUIRED
+      end
+
       def subcommand?
         options[OPTION_SUBCOMMAND]
       end
+
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
+      end
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/parser/options_collection.rb

@@ -6,10 +6,6 @@ require 'optparse'
 module EacCli
   class Parser
     class OptionsCollection
-      SEP = ' '
-      IDENT = SEP * 2
-      OPTION_DESC_SEP = IDENT * 2
-
       enable_simple_cache
       common_constructor(:definition, :argv, :collector) { collect }
       attr_reader :arguments
@@ -49,7 +45,7 @@ module EacCli
       end
 
       def build_banner
-        option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
+        option_parser.banner = definition.help_formatter.to_banner
       end
 
       def build_options
@@ -60,68 +56,13 @@ module EacCli
 
       def build_option(option)
         option_parser.on(
-          *[option_short(option), option_long(option), option.description].reject(&:blank?)
+          *[::EacCli::Definition::HelpFormatter.option_short(option),
+            ::EacCli::Definition::HelpFormatter.option_long(option),
+            option.description].reject(&:blank?)
         ) do |value|
           collector.collect(option, value)
         end
       end
-
-      def positional_argument(positional)
-        if positional.subcommand?
-          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
-        else
-          r = "<#{positional.name}>"
-          r += '...' if positional.repeat?
-          r = "[#{r}]" if positional.optional?
-          r
-        end
-      end
-
-      def option_argument(option)
-        option_long(option)
-      end
-
-      def option_long(option)
-        b = option.long
-        b += '=VALUE' if option.argument?
-        b
-      end
-
-      def option_short(option)
-        b = option.short
-        b += 'VALUE' if option.argument?
-        b
-      end
-
-      def section(header, include_header = true)
-        b = include_header ? "#{header.humanize}:\n" : ''
-        b += send("self_#{header}") + "\n"
-        # TO-DO: implement alternatives
-        b
-      end
-
-      def self_options
-        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
-      end
-
-      def self_usage
-        IDENT + self_usage_arguments.join(SEP)
-      end
-
-      def self_usage_arguments
-        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
-          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
-          self_usage_arguments_options +
-          self_usage_arguments_positional
-      end
-
-      def self_usage_arguments_options
-        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
-      end
-
-      def self_usage_arguments_positional
-        definition.positional.map { |p| positional_argument(p) }
-      end
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.10.0'
+  VERSION = '0.11.1'
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs.rb

@@ -11,18 +11,10 @@ module EacRubyUtils
 
       class << self
         def entry_key_to_envvar_name(entry_key)
-          path = if entry_key.is_a?(::Array)
-                   entry_key
-                 else
-                   ::EacRubyUtils::PathsHash.parse_entry_key(entry_key)
-                 end
-          path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-              .gsub(/_{2,}/, '_').upcase
+          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
         end
       end
 
-      STORE_PASSWORDS_KEY = 'core.store_passwords'
-
       attr_reader :configs
 
       def initialize(configs_key, options = {})
@@ -31,72 +23,15 @@ module EacRubyUtils
       end
 
       def read_password(entry_key, options = {})
-        options = ReadEntryOptions.new(options.merge(noecho: true))
-        if store_passwords?
-          read_entry(entry_key, options)
-        else
-          looped_entry_value_from_input(entry_key, options)
-        end
+        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
       end
 
       def read_entry(entry_key, options = {})
-        options = ReadEntryOptions.new(options)
-        unless options[:noenv]
-          envvar_value = envvar_read_entry(entry_key)
-          return envvar_value if envvar_value.present?
-        end
-        stored_value = configs.read_entry(entry_key)
-        return stored_value if stored_value
-        return read_entry_from_console(entry_key, options) unless options[:noinput]
-
-        raise "No value found for entry \"#{entry_key}\"" if options[:required]
+        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
       end
 
       def store_passwords?
-        read_entry(
-          STORE_PASSWORDS_KEY,
-          before_input: -> { store_password_banner },
-          validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-        ) == 'yes'
-      end
-
-      protected
-
-      def envvar_read_entry(entry_key)
-        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-        return nil unless ENV.key?(env_entry_key)
-
-        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-      end
-
-      def read_entry_from_console(entry_key, options)
-        options[:before_input].call if options[:before_input].present?
-        entry_value = looped_entry_value_from_input(entry_key, options)
-        configs.write_entry(entry_key, entry_value)
-        entry_value
-      end
-
-      def store_password_banner
-        infom 'Do you wanna to store passwords?'
-        infom "Warning: the passwords will be store in clear text in \"#{configs.storage_path}\""
-        infom 'Enter "yes" or "no"'
-      end
-
-      def looped_entry_value_from_input(entry_key, options)
-        loop do
-          entry_value = entry_value_from_input(entry_key, options)
-          next if entry_value.blank?
-          next if options[:validator] && !options[:validator].call(entry_value)
-
-          return entry_value
-        end
-      end
-
-      def entry_value_from_input(entry_key, options)
-        entry_value = request_input("Value for entry \"#{entry_key}\"",
-                                    options.request_input_options)
-        warn('Entered value is blank') if entry_value.blank?
-        entry_value
+        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
       end
     end
   end