ehbrs-tools 0.21.0 → 0.24.0

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module Docopt
-    class RunnerContextReplacement
-      common_constructor :runner
-
-      def argv
-        runner.settings[:argv] || ARGV
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/docopt/doc_builder'
-require 'eac_cli/docopt/runner_context_replacement'
-require 'eac_cli/runner'
-require 'eac_cli/docopt_runner'
-
-module EacCli
-  module Docopt
-    module RunnerExtension
-      extend ::ActiveSupport::Concern
-
-      included do
-        prepend InstanceMethods
-      end
-
-      class << self
-        def check(klass)
-          return unless klass < ::EacCli::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
-
-        def runner_context
-          @runner_context ||= ::EacCli::Docopt::RunnerContextReplacement.new(self)
-        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/docopt_runner.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/hash/slice'
-require 'docopt'
-require 'eac_ruby_utils/contextualizable'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-Dir["#{__dir__}/#{::File.basename(__FILE__, '.*')}/_*.rb"].sort.each do |partial|
-  require partial
-end
-
-module EacCli
-  class DocoptRunner
-    include ::EacRubyUtils::Contextualizable
-
-    class << self
-      def create(settings = {})
-        new(settings)
-      end
-    end
-
-    attr_reader :settings
-
-    def initialize(settings = {})
-      @settings = settings.with_indifferent_access.freeze
-      check_subcommands
-    end
-
-    def options
-      @options ||= ::Docopt.docopt(target_doc, docopt_options)
-    end
-
-    def parent
-      settings[:parent]
-    end
-
-    protected
-
-    def docopt_options
-      settings.slice(:version, :argv, :help, :options_first).to_sym_keys_hash
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_class_methods.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class DocoptRunner
-    DOCOPT_ERROR_EXIT_CODE = 0xC0
-
-    class << self
-      def run(options = {})
-        create(options).send(:run)
-      rescue Docopt::Exit => e
-        STDERR.write(e.message + "\n")
-        ::Kernel.exit(DOCOPT_ERROR_EXIT_CODE)
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_doc.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class DocoptRunner
-    PROGRAM_MACRO = '__PROGRAM__'
-
-    def source_doc
-      setting_value(:doc)
-    end
-
-    def target_doc
-      source_doc.gsub(PROGRAM_MACRO, target_program_name).strip + "\n"
-    end
-
-    def source_program_name
-      setting_value(:program_name, false)
-    end
-
-    def target_program_name
-      [source_program_name, ENV['PROGRAM_NAME'], $PROGRAM_NAME].find(&:present?)
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_settings.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/settings_provider'
-
-module EacCli
-  class DocoptRunner
-    include ::EacRubyUtils::SettingsProvider
-
-    attr_reader :settings
-
-    private
-
-    def setting_value(key, required = true)
-      super(key, required: required, order: %w[method settings_object constant])
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_subcommands.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'shellwords'
-
-module EacCli
-  class DocoptRunner
-    SUBCOMMAND_ARG = '<subcommand>'
-    SUBCOMMAND_ARGS_ARG = '<subcommand-args>'
-    SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
-
-    def subcommands?
-      source_doc.include?(SUBCOMMANDS_MACRO)
-    end
-
-    def check_subcommands
-      return unless subcommands?
-
-      singleton_class.include(SubcommandsSupport)
-      check_subcommands_arg
-      return if singleton_class.method_defined?(:run)
-
-      singleton_class.send(:alias_method, :run, :run_with_subcommand)
-    end
-
-    module SubcommandsSupport
-      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
-
-      def check_subcommands_arg
-        if subcommand_arg_as_list?
-          singleton_class.include(SubcommandsSupport::SubcommandArgAsList)
-        else
-          singleton_class.include(SubcommandsSupport::SubcommandArgAsArg)
-        end
-      end
-
-      def run_with_subcommand
-        if subcommand_name
-          check_valid_subcommand
-          subcommand_run
-        else
-          run_without_subcommand
-        end
-      end
-
-      def subcommand
-        @subcommand ||= subcommand_class_name(subcommand_name).constantize.create(
-          argv: subcommand_args,
-          program_name: subcommand_program,
-          parent: self
-        )
-      end
-
-      def subcommand_run
-        if !subcommand.is_a?(::EacCli::DocoptRunner) &&
-           subcommand.respond_to?(:run_run)
-          subcommand.run_run
-        else
-          subcommand.run
-        end
-      end
-
-      def target_doc
-        super.gsub(SUBCOMMANDS_MACRO,
-                   "#{target_doc_subcommand_arg} [#{SUBCOMMAND_ARGS_ARG}...]") +
-          "\n" + subcommands_target_doc
-      end
-
-      def docopt_options
-        super.merge(options_first: true)
-      end
-
-      def subcommand_class_name(subcommand)
-        "#{self.class.name}::#{subcommand.underscore.camelize}"
-      end
-
-      def subcommand_arg_as_list?
-        setting_value(:subcommand_arg_as_list, false) || false
-      end
-
-      def subcommand_args
-        options.fetch(SUBCOMMAND_ARGS_ARG)
-      end
-
-      def subcommand_program
-        subcommand_name
-      end
-
-      def available_subcommands
-        r = ::Set.new(setting_value(:subcommands, false) || auto_available_subcommands)
-        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
-          r += send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
-        end
-        r.sort
-      end
-
-      def auto_available_subcommands
-        self.class.constants
-            .map { |name| self.class.const_get(name) }
-            .select { |c| c.instance_of? Class }
-            .select { |c| c < ::EacCli::DocoptRunner }
-            .map { |c| c.name.demodulize.underscore.dasherize }
-      end
-
-      def run_without_subcommand
-        "Method #{__method__} should be overrided in #{self.class.name}"
-      end
-
-      protected
-
-      def check_valid_subcommand
-        return if available_subcommands.include?(subcommand_name)
-
-        raise ::Docopt::Exit, "\"#{subcommand_name}\" is not a valid subcommand" \
-          " (Valid: #{available_subcommands.join(', ')})"
-      end
-
-      module SubcommandArgAsArg
-        def target_doc_subcommand_arg
-          SUBCOMMAND_ARG
-        end
-
-        def subcommand_name
-          options.fetch(SUBCOMMAND_ARG)
-        end
-
-        def subcommands_target_doc
-          available_subcommands.inject("Subcommands:\n") do |a, e|
-            a + "  #{e}\n"
-          end
-        end
-      end
-
-      module SubcommandArgAsList
-        def target_doc_subcommand_arg
-          '(' + available_subcommands.join('|') + ')'
-        end
-
-        def subcommand_name
-          available_subcommands.each do |subcommand|
-            return subcommand if options.fetch(subcommand)
-          end
-          nil
-        end
-
-        def subcommands_target_doc
-          "\n"
-        end
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/patches/module/speaker.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/speaker'
-require 'eac_ruby_utils/patch'
-
-class Module
-  def enable_speaker
-    ::EacRubyUtils.patch(self, ::EacCli::Speaker)
-  end
-end

data/vendor/eac_cli/lib/eac_cli/speaker/_class_methods.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/speaker/node'
-
-module EacCli
-  module Speaker
-    class << self
-      def current_node
-        nodes_stack.last
-      end
-
-      def on_node(&block)
-        push
-        yield(*(block.arity.zero? ? [] : [current_node]))
-      ensure
-        pop
-      end
-
-      def push
-        nodes_stack << ::EacCli::Speaker::Node.new
-        current_node
-      end
-
-      def pop
-        return nodes_stack.pop if nodes_stack.count > 1
-
-        raise "Cannot remove first node (nodes_stack.count: #{nodes_stack.count})"
-      end
-
-      private
-
-      def nodes_stack
-        @nodes_stack ||= [::EacCli::Speaker::Node.new]
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/speaker/node.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/object/if_present'
-require 'eac_cli/speaker/_constants'
-
-module EacCli
-  module Speaker
-    class Node
-      attr_accessor :stdin, :stdout, :stderr, :stderr_line_prefix
-
-      def initialize(parent = nil)
-        self.stdin = parent.if_present(::EacCli::Speaker::STDIN, &:stdin)
-        self.stdout = parent.if_present(::EacCli::Speaker::STDOUT, &:stdout)
-        self.stderr = parent.if_present(::EacCli::Speaker::STDERR, &:stderr)
-        self.stderr_line_prefix = parent.if_present('', &:stderr_line_prefix)
-      end
-
-      def configure
-        yield(self)
-        self
-      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(::EacCli::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/docopt_runner_spec.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/docopt_runner'
-
-RSpec.describe ::EacCli::DocoptRunner do
-  context 'runner without DOC constant' do
-    class RunnerWithoutDocConstant < ::EacCli::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 < ::EacCli::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 < ::EacCli::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 }
-
-    describe '#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
-
-      describe '#subcommand' do
-        it 'is of subcommand class' do
-          expect(instance.subcommand).to be_a(RunnerWithSubcommands::MySubCommand)
-        end
-      end
-
-      describe '#context' do
-        it 'accesses instance methods by subcommand' do
-          expect(instance.subcommand.context(:parent_arg)).to eq('value0')
-        end
-      end
-
-      describe '#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]) }
-
-      describe '#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