ehbrs-tools 0.17.0 → 0.22.0

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

@@ -6,8 +6,18 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   module RunnerWith
     module Subcommands
+      require_sub __FILE__
+
+      class << self
+        def runner?(object)
+          ::EacCli::Runner.runner?(object)
+        end
+      end
+
       common_concern do
         include ::EacCli::Runner
+        runner_definition.singleton_class
+                         .include(::EacCli::RunnerWith::Subcommands::DefinitionConcern)
       end
 
       EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
@@ -19,7 +29,7 @@ module EacCli
       def available_subcommands_auto
         self.class.constants
             .map { |name| [name.to_s.underscore.gsub('_', '-'), self.class.const_get(name)] }
-            .select { |c| ::EacCli::Runner.runner?(c[1]) }
+            .select { |c| ::EacCli::RunnerWith::Subcommands.runner?(c[1]) }
             .to_h.with_indifferent_access
       end
 
@@ -32,7 +42,7 @@ module EacCli
       end
 
       def help_extra_text
-        (['Subcommands:'] + available_subcommands.keys.map { |s| "  #{s}" })
+        (['Subcommands:'] + available_subcommands.keys.sort.map { |s| "  #{s}" })
           .map { |v| "#{v}\n" }.join
       end
 
@@ -48,8 +58,12 @@ module EacCli
       end
 
       def run_with_subcommand
-        if subcommand_name
-          subcommand_runner.run_run
+        if run_subcommand?
+          if subcommand_runner.respond_to?(:run_run)
+            subcommand_runner.run_run
+          else
+            subcommand_runner.run
+          end
         else
           run_without_subcommand
         end
@@ -63,6 +77,10 @@ module EacCli
         "Method #{__method__} should be overrided in #{self.class.name}"
       end
 
+      def run_subcommand?
+        subcommand_name.present?
+      end
+
       def subcommands?
         self.class.runner_definition.subcommands?
       end

data/vendor/eac_cli/lib/eac_cli/runner_with/subcommands/definition_concern.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module Subcommands
+      module DefinitionConcern
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner_with_set.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module EacCli
+  class RunnerWithSet
+    class << self
+      def default
+        @default ||= new
+      end
+    end
+
+    def add_namespace(namespace)
+      namespace = sanitize_namespace(namespace)
+      raise "\"#{namespace}\" already was included" if namespace_set.include?(namespace)
+
+      namespace_set << namespace
+      self
+    end
+
+    def item_to_module(item)
+      item.is_a?(::Module) ? item : key_to_module(item)
+    end
+
+    def namespaces
+      namespace_set.dup
+    end
+
+    private
+
+    def namespace_set
+      @namespace_set ||= ::Array.new
+    end
+
+    def key_to_module(key)
+      namespace_set.lazy
+                   .map { |namespace| key_to_module_in_namespace(namespace, key) }
+                   .find(&:present?) ||
+        raise("Not module found with key \"#{key}\" (Namespaces: #{namespace_set})")
+    end
+
+    def key_to_module_in_namespace(namespace, key)
+      namespace.const_get(key.to_s.camelize)
+    rescue ::NameError
+      nil
+    end
+
+    def sanitize_namespace(source)
+      source.is_a?(::Module) ? source : source.to_s.constantize
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/speaker/receiver'
+
+module EacCli
+  class Speaker
+    require_sub __FILE__, include_modules: true
+    include ::EacRubyUtils::Speaker::Receiver
+
+    common_constructor :options, default: [{}] do
+      self.options = self.class.lists.option.hash_keys_validate!(options)
+    end
+
+    def puts(string = '')
+      string.to_s.each_line do |line|
+        err_out.puts(err_line_prefix.to_s + line)
+      end
+    end
+
+    def out(string = '')
+      out_out.write(string.to_s)
+    end
+
+    def fatal_error(string)
+      puts "ERROR: #{string}".white.on_red
+      Kernel.exit 1
+    end
+
+    def title(string)
+      string = string.to_s
+      puts(('-' * (8 + string.length)).green)
+      puts("--- #{string} ---".green)
+      puts(('-' * (8 + string.length)).green)
+      puts
+    end
+
+    def info(string)
+      puts string.to_s.white
+    end
+
+    def infom(string)
+      puts string.to_s.light_yellow
+    end
+
+    def warn(string)
+      puts string.to_s.yellow
+    end
+
+    # Options:
+    #   +bool+ ([Boolean], default: +false+): requires a answer "yes" or "no".
+    #   +list+ ([Hash] or [Array], default: +nil+): requires a answer from a list.
+    #   +noecho+ ([Boolean], default: +false+): does not output answer.
+    def input(question, options = {})
+      bool, list, noecho = options.to_options_consumer.consume_all(:bool, :list, :noecho)
+      if list
+        request_from_list(question, list, noecho)
+      elsif bool
+        request_from_bool(question, noecho)
+      else
+        request_string(question, noecho)
+      end
+    end
+
+    def infov(*args)
+      r = []
+      args.each_with_index do |v, i|
+        if i.even?
+          r << "#{v}: ".cyan
+        else
+          r.last << v.to_s
+        end
+      end
+      puts r.join(', ')
+    end
+
+    def success(string)
+      puts string.to_s.green
+    end
+
+    private
+
+    def list_value(list, input)
+      values = list_values(list)
+      return input, true unless values
+      return input, false unless values.include?(input)
+    end
+
+    def list_values(list)
+      if list.is_a?(::Hash)
+        list.keys.map(&:to_s)
+      elsif list.is_a?(::Array)
+        list.map(&:to_s)
+      end
+    end
+
+    def request_from_bool(question, noecho)
+      request_from_list(question, { yes: true, y: true, no: false, n: false }, noecho)
+    end
+
+    def request_from_list(question, list, noecho)
+      list = ::EacCli::Speaker::List.build(list)
+      loop do
+        input = request_string("#{question} [#{list.valid_labels.join('/')}]", noecho)
+        return list.build_value(input) if list.valid_value?(input)
+
+        warn "Invalid input: \"#{input}\" (Valid: #{list.valid_labels.join(', ')})"
+      end
+    end
+
+    def request_string(question, noecho)
+      err_out.write "#{question}: ".to_s.yellow
+      noecho ? request_string_noecho : request_string_echo
+    end
+
+    def request_string_noecho
+      r = in_in.noecho(&:gets).chomp.strip
+      err_out.write("\n")
+      r
+    end
+
+    def request_string_echo
+      in_in.gets.chomp.strip
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/by_reference'
+
+module EacCli
+  # https://github.com/fazibear/colorize
+  class Speaker
+    STDERR = ::EacRubyUtils::ByReference.new { $stderr }
+    STDIN = ::EacRubyUtils::ByReference.new { $stdin }
+    STDOUT = ::EacRubyUtils::ByReference.new { $stdout }
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'ostruct'
+
+module EacCli
+  class Speaker
+    class List
+      class << self
+        def build(list)
+          return List.new(hash_to_values(list)) if list.is_a?(::Hash)
+          return List.new(array_to_values(list)) if list.is_a?(::Array)
+
+          raise "Invalid list: #{list} (#{list.class})"
+        end
+
+        private
+
+        def hash_to_values(list)
+          list.map { |key, value| ::OpenStruct.new(key: key, label: key, value: value) }
+        end
+
+        def array_to_values(list)
+          list.map { |value| ::OpenStruct.new(key: value, label: value, value: value) }
+        end
+      end
+
+      attr_reader :values
+
+      def initialize(values)
+        @values = values.map do |v|
+          ::OpenStruct.new(key: to_key(v.key), label: to_label(v.label), value: v.value)
+        end
+      end
+
+      def valid_labels
+        values.map(&:label)
+      end
+
+      def valid_value?(value)
+        values.any? { |v| v.key == to_key(value) }
+      end
+
+      def to_key(value)
+        to_label(value).downcase
+      end
+
+      def to_label(value)
+        value.to_s.strip
+      end
+
+      def build_value(value)
+        key = to_key(value)
+        values.each do |v| # rubocop:disable Style/HashEachMethods
+          return v.value if v.key == key
+        end
+        raise "Value not found: \"#{value}\" (#{values})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Speaker
+    module Options
+      common_concern do
+        enable_listable
+        lists.add_symbol :option, :out_out, :err_out, :in_in, :parent, :err_line_prefix
+      end
+
+      def err_out
+        option(OPTION_ERR_OUT, ::EacCli::Speaker::STDERR)
+      end
+
+      def out_out
+        option(OPTION_OUT_OUT, ::EacCli::Speaker::STDOUT)
+      end
+
+      def in_in
+        option(OPTION_IN_IN, ::EacCli::Speaker::STDIN)
+      end
+
+      def err_line_prefix
+        option(OPTION_ERR_LINE_PREFIX, '')
+      end
+
+      def parent
+        options[OPTION_PARENT]
+      end
+
+      def option(key, default)
+        options[key] || parent.if_present(default) { |v| v.send(__METHOD__) }
+      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.12.4'
+  VERSION = '0.21.1'
 end

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

@@ -7,6 +7,10 @@ RSpec.describe ::EacCli::Definition::Alternative do
 
   it { expect { instance.arg_opt '-a', '--opt2', 'A argument option' }.not_to raise_error }
   it { expect { instance.bool_opt '-b', '--opt1', 'A boolean option' }.not_to raise_error }
+  it { expect { instance.bool_opt '-b', '--no-description' }.not_to raise_error }
+  it { expect { instance.bool_opt '--opt1', 'A option without short' }.not_to raise_error }
+  it { expect { instance.bool_opt '-b', 'A option without long' }.not_to raise_error }
+  it { expect { instance.bool_opt 'A option without selectors' }.to raise_error(::StandardError) }
   it { expect { instance.options_argument(true) }.not_to raise_error }
   it { expect { instance.pos_arg :pos1 }.not_to raise_error }
   it { expect { instance.pos_arg :pos2, optional: true, repeat: true }.not_to raise_error }

data/vendor/{eac_ruby_utils/spec/lib/eac_ruby_utils/console/configs_spec.rb → eac_cli/spec/lib/eac_cli/old_configs_spec.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/console/configs'
+require 'eac_cli/old_configs'
 
-RSpec.describe ::EacRubyUtils::Console::Configs do
+RSpec.describe ::EacCli::OldConfigs do
   describe '#entry_key_to_envvar_name' do
     {
       'a.entry.value' => 'A_ENTRY_VALUE',

data/vendor/eac_cli/spec/lib/eac_cli/parser/alternative_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'eac_cli/docopt/runner_extension'
+require 'eac_cli/parser/alternative'
 
 RSpec.describe ::EacCli::Parser::Alternative do
   let(:instance) { described_class.new(alternative, argv) }

data/vendor/eac_cli/spec/lib/eac_cli/runner_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/console/docopt_runner'
 require 'eac_cli/runner'
 
 RSpec.describe ::EacCli::Runner do
@@ -11,7 +10,9 @@ RSpec.describe ::EacCli::Runner do
 
       runner_definition do
         arg_opt '-o', '--opt1', 'A arg option.'
-        bool_opt '-o', '--opt2', 'A boolean option'
+        bool_opt '-p', '--opt2', 'A boolean option'
+        arg_opt '-q', '--opt4', 'A repeatable argument option.', repeat: true
+        bool_opt '-r', '--opt5', 'A repeatable boolean option', repeat: true
         pos_arg :pos1
         pos_arg :pos2, repeat: true, optional: true
         alt do
@@ -29,7 +30,7 @@ RSpec.describe ::EacCli::Runner do
   context 'when all args are supplied' do
     let(:argv) { %w[--opt1 aaa --opt2 bbb ccc ddd] }
     let(:parsed_expected) do
-      { opt1: 'aaa', opt2: true, opt3: false, pos1: 'bbb',
+      { opt1: 'aaa', opt2: true, opt3: false, opt4: [], opt5: 0, pos1: 'bbb',
         pos2: %w[ccc ddd] }
     end
 
@@ -40,9 +41,33 @@ RSpec.describe ::EacCli::Runner do
     it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
   end
 
+  context 'with long option and argument in same position' do
+    let(:argv) { %w[--opt1=aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+  end
+
+  context 'with valid grouped short options' do
+    let(:argv) { %w[-po aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to eq(true) }
+  end
+
+  context 'with invalid grouped short options' do
+    let(:argv) { %w[-op aaa pos1] }
+
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
   context 'when only required args are supplied' do
     let(:argv) { %w[bbb] }
-    let(:parsed_expected) { { opt1: nil, opt2: false, opt3: false, pos1: 'bbb', pos2: [] } }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: [], opt5: 0, pos1: 'bbb',
+        pos2: [] }
+    end
 
     it { expect(parsed_actual).to eq(parsed_expected) }
     it { expect(instance.parsed.opt1).to be_nil }
@@ -61,12 +86,25 @@ RSpec.describe ::EacCli::Runner do
 
   context 'when alternative args are supplied' do
     let(:argv) { %w[--opt3] }
-    let(:parsed_expected) { { opt1: nil, opt2: false, opt3: true, pos1: nil, pos2: [] } }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: true, opt4: [], opt5: 0, pos1: nil,
+        pos2: [] }
+    end
 
     it { expect(parsed_actual).to eq(parsed_expected) }
     it { expect(instance.parsed.opt3?).to eq(true) }
   end
 
+  context 'when repeated options are supplied' do
+    let(:argv) { %w[--opt5 -rrr --opt4=A -q B --opt4 C AAA] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: %w[A B C], opt5: 4, pos1: 'AAA',
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+  end
+
   context 'when extra args are not supplied' do
     let(:runner_class) do
       the_module = described_class