ehbrs-tools 0.17.0 → 0.22.0

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/console/docopt_runner'
-
-module EacCli
-  module Docopt
-    class DocBuilder
-      require_sub __FILE__
-      common_constructor :definition
-
-      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
-      end
-
-      def option_definition(option)
-        option.short + SEP + self.class.option_long(option) + OPTION_DESC_SEP + option.description
-      end
-
-      def section(header, include_header = true)
-        b = include_header ? "#{header.humanize}:\n" : ''
-        b += send("self_#{header}") + "\n"
-        definition.alternatives.each do |alternative|
-          b += IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
-        end
-        b
-      end
-
-      def options_section
-        "Options:\n" +
-          definition.alternatives.flat_map(&:options)
-                    .map { |option| IDENT + option_definition(option) + "\n" }.join
-      end
-
-      def usage_section
-        "Usage:\n" +
-          definition.alternatives.map do |alternative|
-            IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
-          end.join
-      end
-
-      def to_s
-        "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder/alternative.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/console/docopt_runner'
-
-module EacCli
-  module Docopt
-    class DocBuilder
-      class Alternative
-        common_constructor :alternative
-
-        def to_s
-          (
-            [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
-              alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
-              options +
-              positionals
-          ).join(::EacCli::Docopt::DocBuilder::SEP)
-        end
-
-        def options
-          alternative.options.select(&:show_on_usage?).map do |option|
-            ::EacCli::Docopt::DocBuilder.option_long(option)
-          end
-        end
-
-        def option_argument(option)
-          b = option.long
-          b += '=<value>' if option.argument?
-          b
-        end
-
-        def positionals
-          alternative.positional.map { |p| positional(p) }
-        end
-
-        def positional(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
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt/runner_extension.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/docopt/doc_builder'
-require 'eac_cli/runner'
-require 'eac_ruby_utils/console/docopt_runner'
-
-module EacCli
-  module Docopt
-    module RunnerExtension
-      extend ::ActiveSupport::Concern
-
-      included do
-        prepend InstanceMethods
-      end
-
-      class << self
-        def check(klass)
-          return unless klass < ::EacRubyUtils::Console::DocoptRunner
-
-          ::EacCli::Runner.alias_runner_class_methods(klass, '', 'eac_cli')
-          ::EacCli::Runner.alias_runner_class_methods(klass, 'original', '')
-
-          klass.include(self)
-        end
-      end
-
-      module InstanceMethods
-        def doc
-          ::EacCli::Docopt::DocBuilder.new(self.class.runner_definition).to_s
-        end
-
-        def docopt_options
-          super.merge(options_first: self.class.runner_definition.options_first?)
-        end
-      end
-
-      def extra_available_subcommands
-        self.class.constants
-            .map { |name| self.class.const_get(name) }
-            .select { |c| c.instance_of? Class }
-            .select { |c| c.included_modules.include?(::EacCli::Runner) }
-            .map { |c| c.name.demodulize.underscore.dasherize }
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/runner_with/output_file.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/runner'
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/abstract_methods'
-
-module EacCli
-  module RunnerWith
-    module OutputFile
-      common_concern do
-        include ::EacCli::Runner
-        include ::EacRubyUtils::AbstractMethods
-
-        abstract_methods :output_content
-
-        runner_definition do
-          arg_opt '-o', '--output-file', 'Output to file.'
-        end
-      end
-
-      def run_output
-        if parsed.output_file.present?
-          ::File.write(parsed.output_file, output_content)
-        else
-          $stdout.write(output_content)
-        end
-      end
-    end
-  end
-end

data/vendor/eac_cli/spec/lib/eac_cli/docopt/runner_extension_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/docopt/runner_extension'
-
-RSpec.describe ::EacCli::Docopt::RunnerExtension do
-  let(:stub_runner) do
-    r = Class.new(::EacRubyUtils::Console::DocoptRunner) do
-      def run; end
-    end
-    r.include ::EacCli::Runner
-    r.runner_definition do
-      desc 'A stub runner.'
-      arg_opt '-o', '--opt1', 'A argument option'
-      pos_arg 'pos1'
-    end
-    r
-  end
-
-  let(:instance) { stub_runner.new(argv: %w[-o aaa bbb]) }
-
-  before { instance.run }
-
-  it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
-  it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
-  it { expect(instance.doc).to eq(<<~EXPECTED) }
-    A stub runner.
-
-    Usage:
-      __PROGRAM__ [options] <pos1>
-
-    Options:
-      -o --opt1=<value>    A argument option
-
-  EXPECTED
-end

data/vendor/eac_cli/spec/lib/eac_cli/runner_with/output_file_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/runner_with/output_file'
-require 'eac_ruby_utils/fs/temp'
-
-RSpec.describe ::EacCli::RunnerWith::OutputFile do
-  let(:runner) do
-    the_module = described_class
-    Class.new do
-      include the_module
-
-      runner_definition do
-        desc 'A stub root runner.'
-        pos_arg :input_text
-      end
-
-      def run
-        run_output
-      end
-
-      def output_content
-        parsed.input_text
-      end
-    end
-  end
-
-  let(:stub_text) { 'STUB_TEXT' }
-  let(:instance) { runner.create(argv: runner_argv) }
-
-  context 'without --output-file option' do
-    let(:runner_argv) { [stub_text] }
-
-    it do
-      expect { instance.run }.to output(stub_text).to_stdout_from_any_process
-    end
-  end
-
-  context 'with --output-file option' do
-    let(:output_file) { ::EacRubyUtils::Fs::Temp.file }
-    let(:runner_argv) { ['--output-file', output_file.to_path, stub_text] }
-
-    before do
-      instance.run
-    end
-
-    after do
-      output_file.remove
-    end
-
-    it { expect(output_file).to exist }
-    it { expect(output_file.read).to eq(stub_text) }
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs'
-require 'eac_ruby_utils/console/docopt_runner'
-require 'eac_ruby_utils/console/speaker'

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      require_sub __FILE__
-      enable_console_speaker
-
-      class << self
-        def entry_key_to_envvar_name(entry_key)
-          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
-        end
-      end
-
-      attr_reader :configs
-
-      def initialize(configs_key, options = {})
-        options.assert_argument(::Hash, 'options')
-        @configs = ::EacRubyUtils::Configs.new(configs_key, options.merge(autosave: true))
-      end
-
-      def read_password(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
-      end
-
-      def read_entry(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
-      end
-
-      def store_passwords?
-        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/read_entry_options'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class EntryReader
-        enable_console_speaker
-
-        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
-          end
-        end
-
-        common_constructor :console_configs, :entry_key, :options do
-          self.options = ::EacRubyUtils::Console::Configs::ReadEntryOptions.new(options)
-        end
-
-        def read
-          %w[envvars storage console].each do |suffix|
-            value = send("read_from_#{suffix}")
-            return value if value.present?
-          end
-          return nil unless options[:required]
-
-          raise "No value found for entry \"#{entry_key}\""
-        end
-
-        def read_from_storage
-          console_configs.configs.read_entry(entry_key)
-        end
-
-        def read_from_envvars
-          return if options[:noenv]
-
-          env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-          return unless ENV.key?(env_entry_key)
-
-          ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-        end
-
-        def read_from_console
-          return if options[:noinput]
-
-          options[:before_input].if_present(&:call)
-          entry_value = looped_entry_value_from_input
-          console_configs.configs.write_entry(entry_key, entry_value) if options[:store]
-          entry_value
-        end
-
-        private
-
-        def looped_entry_value_from_input
-          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
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/entry_reader'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class PasswordEntryReader < ::EacRubyUtils::Console::Configs::EntryReader
-        ENTRY_KEY = 'core.store_passwords'
-
-        def initialize(console_configs, entry_key, options = {})
-          super(console_configs, entry_key, options.merge(noecho: true,
-                                                          store: console_configs.store_passwords?))
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/entry_reader'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class StorePasswordsEntryReader < ::EacRubyUtils::Console::Configs::EntryReader
-        ENTRY_KEY = 'core.store_passwords'
-
-        def initialize(console_configs)
-          super(console_configs, ENTRY_KEY,
-            before_input: -> { banner },
-            validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-          )
-        end
-
-        def banner
-          infom 'Do you wanna to store passwords?'
-          infom 'Warning: the passwords will be store in clear text in ' \
-            "\"#{console_configs.configs.storage_path}\""
-          infom 'Enter "yes" or "no"'
-        end
-      end
-    end
-  end
-end